mirror of
https://github.com/socketio/socket.io.git
synced 2026-04-30 03:00:39 -04:00
8482 lines
211 KiB
JavaScript
8482 lines
211 KiB
JavaScript
!function(e){"object"==typeof exports?module.exports=e():"function"==typeof define&&define.amd?define(e):"undefined"!=typeof window?window.io=e():"undefined"!=typeof global?global.io=e():"undefined"!=typeof self&&(self.io=e())}(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);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.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(require,module,exports){
|
||
|
||
module.exports = require('./lib/');
|
||
|
||
},{"./lib/":2}],2:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var url = require('./url');
|
||
var parser = require('socket.io-parser');
|
||
var Manager = require('./manager');
|
||
var debug = require('debug')('socket.io-client');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = exports = lookup;
|
||
|
||
/**
|
||
* Managers cache.
|
||
*/
|
||
|
||
var cache = exports.managers = {};
|
||
|
||
/**
|
||
* Looks up an existing `Manager` for multiplexing.
|
||
* If the user summons:
|
||
*
|
||
* `io('http://localhost/a');`
|
||
* `io('http://localhost/b');`
|
||
*
|
||
* We reuse the existing instance based on same scheme/port/host,
|
||
* and we initialize sockets for each namespace.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function lookup(uri, opts){
|
||
opts = opts || {};
|
||
|
||
var parsed = url(uri);
|
||
var href = parsed.href;
|
||
var id = parsed.id;
|
||
var io;
|
||
|
||
if (opts.forceNew || false === opts.multiplex) {
|
||
debug('ignoring socket cache for %s', href);
|
||
io = Manager(href, opts);
|
||
} else {
|
||
if (!cache[id]) {
|
||
debug('new io instance for %s', href);
|
||
cache[id] = Manager(href, opts);
|
||
}
|
||
io = cache[id];
|
||
}
|
||
|
||
return io.socket(parsed.path);
|
||
}
|
||
|
||
/**
|
||
* Protocol version.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.protocol = parser.protocol;
|
||
|
||
/**
|
||
* `connect`.
|
||
*
|
||
* @param {String} uri
|
||
* @api public
|
||
*/
|
||
|
||
exports.connect = lookup;
|
||
|
||
/**
|
||
* Expose constructors for standalone build.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.Manager = require('./manager');
|
||
exports.Socket = require('./socket');
|
||
|
||
},{"./manager":3,"./socket":5,"./url":6,"debug":10,"socket.io-parser":39}],3:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var url = require('./url');
|
||
var eio = require('engine.io-client');
|
||
var Socket = require('./socket');
|
||
var Emitter = require('emitter');
|
||
var parser = require('socket.io-parser');
|
||
var on = require('./on');
|
||
var bind = require('bind');
|
||
var object = require('object-component');
|
||
var debug = require('debug')('socket.io-client:manager');
|
||
|
||
/**
|
||
* Module exports
|
||
*/
|
||
|
||
module.exports = Manager;
|
||
|
||
/**
|
||
* `Manager` constructor.
|
||
*
|
||
* @param {Socket|String} engine instance or engine uri/opts
|
||
* @param {Object} options
|
||
* @api public
|
||
*/
|
||
|
||
function Manager(socket, opts){
|
||
if (!(this instanceof Manager)) return new Manager(socket, opts);
|
||
opts = opts || {};
|
||
opts.path = opts.path || '/socket.io';
|
||
this.nsps = {};
|
||
this.subs = [];
|
||
this.reconnection(opts.reconnection);
|
||
this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
|
||
this.reconnectionDelay(opts.reconnectionDelay || 1000);
|
||
this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
|
||
this.timeout(null == opts.timeout ? 10000 : opts.timeout);
|
||
this.readyState = 'closed';
|
||
if (!socket || !socket.write) socket = eio(socket, opts);
|
||
this.engine = socket;
|
||
this.connected = 0;
|
||
this.attempts = 0;
|
||
this.encoding = false;
|
||
this.packetBuffer = [];
|
||
this.encoder = new parser.Encoder();
|
||
this.decoder = new parser.Decoder();
|
||
this.open();
|
||
}
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Manager.prototype);
|
||
|
||
/**
|
||
* Sets the `reconnection` config.
|
||
*
|
||
* @param {Boolean} true/false if it should automatically reconnect
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.reconnection = function(v){
|
||
if (!arguments.length) return this._reconnection;
|
||
this._reconnection = !!v;
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the reconnection attempts config.
|
||
*
|
||
* @param {Number} max reconnection attempts before giving up
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.reconnectionAttempts = function(v){
|
||
if (!arguments.length) return this._reconnectionAttempts;
|
||
this._reconnectionAttempts = v;
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the delay between reconnections.
|
||
*
|
||
* @param {Number} delay
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.reconnectionDelay = function(v){
|
||
if (!arguments.length) return this._reconnectionDelay;
|
||
this._reconnectionDelay = v;
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the maximum delay between reconnections.
|
||
*
|
||
* @param {Number} delay
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.reconnectionDelayMax = function(v){
|
||
if (!arguments.length) return this._reconnectionDelayMax;
|
||
this._reconnectionDelayMax = v;
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the connection timeout. `false` to disable
|
||
*
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.timeout = function(v){
|
||
if (!arguments.length) return this._timeout;
|
||
this._timeout = v;
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sets the current transport `socket`.
|
||
*
|
||
* @param {Function} optional, callback
|
||
* @return {Manager} self
|
||
* @api public
|
||
*/
|
||
|
||
Manager.prototype.open =
|
||
Manager.prototype.connect = function(fn){
|
||
if (~this.readyState.indexOf('open')) return this;
|
||
|
||
var socket = this.engine;
|
||
var self = this;
|
||
var timerSub;
|
||
|
||
this.readyState = 'opening';
|
||
|
||
// emit `open`
|
||
var openSub = on(socket, 'open', bind(this, 'onopen'));
|
||
|
||
// emit `connect_error`
|
||
var errorSub = on(socket, 'error', function(data){
|
||
self.cleanup();
|
||
self.emit('connect_error', data);
|
||
if (fn) {
|
||
var err = new Error('Connection error');
|
||
err.data = data;
|
||
fn(err);
|
||
}
|
||
});
|
||
|
||
// emit `connect_timeout`
|
||
if (false !== this._timeout) {
|
||
var timeout = this._timeout;
|
||
debug('connect attempt will timeout after %d', timeout);
|
||
|
||
// set timer
|
||
var timer = setTimeout(function(){
|
||
debug('connect attempt timed out after %d', timeout);
|
||
openSub.destroy();
|
||
socket.close();
|
||
socket.emit('error', 'timeout');
|
||
self.emit('connect_timeout', timeout);
|
||
}, timeout);
|
||
|
||
// create handle
|
||
timerSub = {
|
||
destroy: function(){
|
||
clearTimeout(timer);
|
||
}
|
||
};
|
||
|
||
this.subs.push(timerSub);
|
||
}
|
||
|
||
this.subs.push(openSub);
|
||
this.subs.push(errorSub);
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Called upon transport open.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onopen = function(){
|
||
// clear old subs
|
||
this.cleanup();
|
||
|
||
// mark as open
|
||
this.readyState = 'open';
|
||
this.emit('open');
|
||
|
||
// add new subs
|
||
var socket = this.engine;
|
||
this.subs.push(on(socket, 'data', bind(this, 'ondata')));
|
||
this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));
|
||
this.subs.push(on(socket, 'error', bind(this, 'onerror')));
|
||
this.subs.push(on(socket, 'close', bind(this, 'onclose')));
|
||
};
|
||
|
||
/**
|
||
* Called with data.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.ondata = function(data){
|
||
this.decoder.add(data);
|
||
};
|
||
|
||
/**
|
||
* Called when parser fully decodes a packet.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.ondecoded = function(packet) {
|
||
this.emit('packet', packet);
|
||
}
|
||
|
||
/**
|
||
* Called upon socket error.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onerror = function(err){
|
||
this.emit('error', err);
|
||
};
|
||
|
||
/**
|
||
* Creates a new socket for the given `nsp`.
|
||
*
|
||
* @return {Socket}
|
||
* @api public
|
||
*/
|
||
|
||
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('connect', function(){
|
||
self.connected++;
|
||
});
|
||
}
|
||
return socket;
|
||
};
|
||
|
||
/**
|
||
* Called upon a socket close.
|
||
*
|
||
* @param {Socket} socket
|
||
*/
|
||
|
||
Manager.prototype.destroy = function(socket){
|
||
this.connected--;
|
||
if (!this.connected) {
|
||
this.close();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Writes a packet.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.packet = function(packet){
|
||
debug('writing packet %j', packet);
|
||
var self = this;
|
||
|
||
if (!self.encoding) { // encode, then write to engine with result
|
||
self.encoding = true;
|
||
this.encoder.encode(packet, function(encodedPackets) {
|
||
for (var i = 0; i < encodedPackets.length; i++) {
|
||
self.engine.write(encodedPackets[i]);
|
||
}
|
||
self.encoding = false;
|
||
self.processPacketQueue();
|
||
});
|
||
} else { // add packet to the queue
|
||
self.packetBuffer.push(packet);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* If packet buffer is non-empty, begins encoding the
|
||
* next packet in line.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.processPacketQueue = function() {
|
||
if (this.packetBuffer.length > 0 && !this.encoding) {
|
||
var pack = this.packetBuffer.shift();
|
||
this.packet(pack);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Clean up transport subscriptions and packet buffer.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.cleanup = function(){
|
||
var sub;
|
||
while (sub = this.subs.shift()) sub.destroy();
|
||
|
||
this.packetBuffer = [];
|
||
this.encoding = false;
|
||
|
||
this.decoder.destroy();
|
||
};
|
||
|
||
/**
|
||
* Close the current socket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.close =
|
||
Manager.prototype.disconnect = function(){
|
||
this.skipReconnect = true;
|
||
this.cleanup();
|
||
this.engine.close();
|
||
};
|
||
|
||
/**
|
||
* Called upon engine close.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onclose = function(){
|
||
this.cleanup();
|
||
if (!this.skipReconnect) {
|
||
var self = this;
|
||
this.reconnect();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Attempt a reconnection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.reconnect = function(){
|
||
var self = this;
|
||
this.attempts++;
|
||
|
||
if (this.attempts > this._reconnectionAttempts) {
|
||
this.emit('reconnect_failed');
|
||
this.reconnecting = false;
|
||
} else {
|
||
var delay = this.attempts * this.reconnectionDelay();
|
||
delay = Math.min(delay, this.reconnectionDelayMax());
|
||
debug('will wait %dms before reconnect attempt', delay);
|
||
|
||
this.reconnecting = true;
|
||
var timer = setTimeout(function(){
|
||
debug('attemptign reconnect');
|
||
self.open(function(err){
|
||
if (err) {
|
||
debug('reconnect attempt error');
|
||
self.reconnect();
|
||
return self.emit('reconnect_error', err.data);
|
||
} else {
|
||
debug('reconnect success');
|
||
self.onreconnect();
|
||
}
|
||
});
|
||
}, delay);
|
||
|
||
this.subs.push({
|
||
destroy: function(){
|
||
clearTimeout(timer);
|
||
}
|
||
});
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon successful reconnect.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Manager.prototype.onreconnect = function(){
|
||
var attempt = this.attempts;
|
||
this.attempts = 0;
|
||
this.reconnecting = false;
|
||
this.emit('reconnect', attempt);
|
||
};
|
||
|
||
},{"./on":4,"./socket":5,"./url":6,"bind":8,"debug":10,"emitter":11,"engine.io-client":12,"object-component":36,"socket.io-parser":39}],4:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = on;
|
||
|
||
/**
|
||
* Helper for subscriptions.
|
||
*
|
||
* @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`
|
||
* @param {String} event name
|
||
* @param {Function} callback
|
||
* @api public
|
||
*/
|
||
|
||
function on(obj, ev, fn) {
|
||
obj.on(ev, fn);
|
||
return {
|
||
destroy: function(){
|
||
obj.removeListener(ev, fn);
|
||
}
|
||
};
|
||
}
|
||
|
||
},{}],5:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var parser = require('socket.io-parser');
|
||
var Emitter = require('emitter');
|
||
var toArray = require('to-array');
|
||
var on = require('./on');
|
||
var bind = require('bind');
|
||
var debug = require('debug')('socket.io-client:socket');
|
||
var hasBin = require('has-binary-data');
|
||
var indexOf = require('indexof');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = exports = Socket;
|
||
|
||
/**
|
||
* Internal events (blacklisted).
|
||
* These events can't be emitted by the user.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
var events = {
|
||
connect: 1,
|
||
disconnect: 1,
|
||
error: 1
|
||
};
|
||
|
||
/**
|
||
* Shortcut to `Emitter#emit`.
|
||
*/
|
||
|
||
var emit = Emitter.prototype.emit;
|
||
|
||
/**
|
||
* `Socket` constructor.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function Socket(io, nsp){
|
||
this.io = io;
|
||
this.nsp = nsp;
|
||
this.json = this; // compat
|
||
this.ids = 0;
|
||
this.acks = {};
|
||
this.open();
|
||
this.buffer = [];
|
||
this.connected = false;
|
||
this.disconnected = true;
|
||
}
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Socket.prototype);
|
||
|
||
/**
|
||
* Called upon engine `open`.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.open =
|
||
Socket.prototype.connect = function(){
|
||
var io = this.io;
|
||
io.open(); // ensure open
|
||
if ('open' == this.io.readyState) this.onopen();
|
||
this.subs = [
|
||
on(io, 'open', bind(this, 'onopen')),
|
||
on(io, 'error', bind(this, 'onerror'))
|
||
];
|
||
};
|
||
|
||
/**
|
||
* Sends a `message` event.
|
||
*
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.send = function(){
|
||
var args = toArray(arguments);
|
||
args.unshift('message');
|
||
this.emit.apply(this, args);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Override `emit`.
|
||
* If the event is in `events`, it's emitted normally.
|
||
*
|
||
* @param {String} event name
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.emit = function(ev){
|
||
if (events.hasOwnProperty(ev)) {
|
||
emit.apply(this, arguments);
|
||
return this;
|
||
}
|
||
|
||
var args = toArray(arguments);
|
||
var parserType = parser.EVENT; // default
|
||
if (hasBin(args)) { parserType = parser.BINARY_EVENT; } // binary
|
||
var packet = { type: parserType, data: args };
|
||
|
||
// event ack callback
|
||
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++;
|
||
}
|
||
|
||
this.packet(packet);
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sends a packet.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.packet = function(packet){
|
||
packet.nsp = this.nsp;
|
||
this.io.packet(packet);
|
||
};
|
||
|
||
/**
|
||
* Called upon `error`.
|
||
*
|
||
* @param {Object} data
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onerror = function(data){
|
||
this.emit('error', data);
|
||
};
|
||
|
||
/**
|
||
* "Opens" the socket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onopen = function(){
|
||
debug('transport is open - connecting');
|
||
|
||
// write connect packet if necessary
|
||
if ('/' != this.nsp) {
|
||
this.packet({ type: parser.CONNECT });
|
||
}
|
||
|
||
// subscribe
|
||
var io = this.io;
|
||
this.subs.push(
|
||
on(io, 'packet', bind(this, 'onpacket')),
|
||
on(io, 'close', bind(this, 'onclose'))
|
||
);
|
||
};
|
||
|
||
/**
|
||
* Called upon engine `close`.
|
||
*
|
||
* @param {String} reason
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onclose = function(reason){
|
||
debug('close (%s)', reason);
|
||
this.connected = false;
|
||
this.disconnected = true;
|
||
this.emit('disconnect', reason);
|
||
};
|
||
|
||
/**
|
||
* Called with socket packet.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
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.DISCONNECT:
|
||
this.ondisconnect();
|
||
break;
|
||
|
||
case parser.ERROR:
|
||
this.emit('error', packet.data);
|
||
break;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon a server event.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
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.buffer.push(args);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Produces an ack callback to emit with an event.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.ack = function(id){
|
||
var self = this;
|
||
var sent = false;
|
||
return function(){
|
||
// prevent double callbacks
|
||
if (sent) return;
|
||
var args = toArray(arguments);
|
||
debug('sending ack %j', args);
|
||
self.packet({
|
||
type: parser.ACK,
|
||
id: id,
|
||
data: args
|
||
});
|
||
};
|
||
};
|
||
|
||
/**
|
||
* Called upon a server acknowlegement.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onack = function(packet){
|
||
debug('calling ack %s with %j', packet.id, packet.data);
|
||
var fn = this.acks[packet.id];
|
||
fn.apply(this, packet.data);
|
||
delete this.acks[packet.id];
|
||
};
|
||
|
||
/**
|
||
* Called upon server connect.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onconnect = function(){
|
||
this.connected = true;
|
||
this.disconnected = false;
|
||
this.emit('connect');
|
||
this.emitBuffered();
|
||
};
|
||
|
||
/**
|
||
* Emit buffered events.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.emitBuffered = function(){
|
||
for (var i = 0; i < this.buffer.length; i++) {
|
||
emit.apply(this, this.buffer[i]);
|
||
}
|
||
this.buffer = [];
|
||
};
|
||
|
||
/**
|
||
* Called upon server disconnect.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.ondisconnect = function(){
|
||
debug('server disconnect (%s)', this.nsp);
|
||
this.destroy();
|
||
this.onclose('io server disconnect');
|
||
};
|
||
|
||
/**
|
||
* Cleans up.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.destroy = function(){
|
||
debug('destroying socket (%s)', this.nsp);
|
||
|
||
// manual close means no reconnect
|
||
for (var i = 0; i < this.subs.length; i++) {
|
||
this.subs[i].destroy();
|
||
}
|
||
|
||
// notify manager
|
||
this.io.destroy(this);
|
||
};
|
||
|
||
/**
|
||
* Disconnects the socket manually.
|
||
*
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.close =
|
||
Socket.prototype.disconnect = function(){
|
||
if (!this.connected) return this;
|
||
|
||
debug('performing disconnect (%s)', this.nsp);
|
||
this.packet({ type: parser.PACKET_DISCONNECT });
|
||
|
||
// destroy subscriptions
|
||
this.destroy();
|
||
|
||
// fire events
|
||
this.onclose('io client disconnect');
|
||
return this;
|
||
};
|
||
|
||
},{"./on":4,"bind":8,"debug":10,"emitter":11,"has-binary-data":31,"indexof":35,"socket.io-parser":39,"to-array":42}],6:[function(require,module,exports){
|
||
var global=typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var parseuri = require('parseuri');
|
||
var debug = require('debug')('socket.io-client:url');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = url;
|
||
|
||
/**
|
||
* URL parser.
|
||
*
|
||
* @param {String} url
|
||
* @param {Object} An object meant to mimic window.location.
|
||
* Defaults to window.location.
|
||
* @api public
|
||
*/
|
||
|
||
function url(uri, loc){
|
||
var obj = uri;
|
||
|
||
// default to window.location
|
||
var loc = loc || global.location;
|
||
if (null == uri) uri = loc.protocol + '//' + loc.hostname;
|
||
|
||
// relative path support
|
||
if ('string' == typeof uri) {
|
||
if ('/' == uri.charAt(0)) {
|
||
if ('undefined' != typeof loc) {
|
||
uri = loc.hostname + uri;
|
||
}
|
||
}
|
||
|
||
if (!/^(https?|wss?):\/\//.test(uri)) {
|
||
debug('protocol-less url %s', uri);
|
||
if ('undefined' != typeof loc) {
|
||
uri = loc.protocol + '//' + uri;
|
||
} else {
|
||
uri = 'https://' + uri;
|
||
}
|
||
}
|
||
|
||
// parse
|
||
debug('parse %s', uri);
|
||
obj = parseuri(uri);
|
||
}
|
||
|
||
// make sure we treat `localhost:80` and `localhost` equally
|
||
if ((/(http|ws)/.test(obj.protocol) && 80 == obj.port) ||
|
||
(/(http|ws)s/.test(obj.protocol) && 443 == obj.port)) {
|
||
delete obj.port;
|
||
}
|
||
|
||
obj.path = obj.path || '/';
|
||
|
||
// define unique id
|
||
obj.id = obj.protocol + obj.host + (obj.port ? (':' + obj.port) : '');
|
||
|
||
// define href
|
||
obj.href = obj.protocol + '://' + obj.host + (obj.port ? (':' + obj.port) : '');
|
||
|
||
return obj;
|
||
}
|
||
|
||
},{"debug":10,"parseuri":37}],7:[function(require,module,exports){
|
||
/*
|
||
* base64-arraybuffer
|
||
* https://github.com/niklasvh/base64-arraybuffer
|
||
*
|
||
* Copyright (c) 2012 Niklas von Hertzen
|
||
* Licensed under the MIT license.
|
||
*/
|
||
(function(chars){
|
||
"use strict";
|
||
|
||
exports.encode = function(arraybuffer) {
|
||
var bytes = new Uint8Array(arraybuffer),
|
||
i, len = bytes.buffer.byteLength, base64 = "";
|
||
|
||
for (i = 0; i < len; i+=3) {
|
||
base64 += chars[bytes.buffer[i] >> 2];
|
||
base64 += chars[((bytes.buffer[i] & 3) << 4) | (bytes.buffer[i + 1] >> 4)];
|
||
base64 += chars[((bytes.buffer[i + 1] & 15) << 2) | (bytes.buffer[i + 2] >> 6)];
|
||
base64 += chars[bytes.buffer[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 * 0.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+/");
|
||
},{}],8:[function(require,module,exports){
|
||
|
||
/**
|
||
* Slice reference.
|
||
*/
|
||
|
||
var slice = [].slice;
|
||
|
||
/**
|
||
* Bind `obj` to `fn`.
|
||
*
|
||
* @param {Object} obj
|
||
* @param {Function|String} fn or string
|
||
* @return {Function}
|
||
* @api public
|
||
*/
|
||
|
||
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)));
|
||
}
|
||
};
|
||
|
||
},{}],9:[function(require,module,exports){
|
||
require=(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);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.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(require,module,exports){
|
||
exports.readIEEE754 = function(buffer, offset, isBE, mLen, nBytes) {
|
||
var e, m,
|
||
eLen = nBytes * 8 - mLen - 1,
|
||
eMax = (1 << eLen) - 1,
|
||
eBias = eMax >> 1,
|
||
nBits = -7,
|
||
i = isBE ? 0 : (nBytes - 1),
|
||
d = isBE ? 1 : -1,
|
||
s = buffer[offset + i];
|
||
|
||
i += d;
|
||
|
||
e = s & ((1 << (-nBits)) - 1);
|
||
s >>= (-nBits);
|
||
nBits += eLen;
|
||
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
|
||
|
||
m = e & ((1 << (-nBits)) - 1);
|
||
e >>= (-nBits);
|
||
nBits += mLen;
|
||
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
|
||
|
||
if (e === 0) {
|
||
e = 1 - eBias;
|
||
} else if (e === eMax) {
|
||
return m ? NaN : ((s ? -1 : 1) * Infinity);
|
||
} else {
|
||
m = m + Math.pow(2, mLen);
|
||
e = e - eBias;
|
||
}
|
||
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
|
||
};
|
||
|
||
exports.writeIEEE754 = function(buffer, value, offset, isBE, mLen, nBytes) {
|
||
var e, m, c,
|
||
eLen = nBytes * 8 - mLen - 1,
|
||
eMax = (1 << eLen) - 1,
|
||
eBias = eMax >> 1,
|
||
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
|
||
i = isBE ? (nBytes - 1) : 0,
|
||
d = isBE ? -1 : 1,
|
||
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
|
||
|
||
value = Math.abs(value);
|
||
|
||
if (isNaN(value) || value === Infinity) {
|
||
m = isNaN(value) ? 1 : 0;
|
||
e = eMax;
|
||
} else {
|
||
e = Math.floor(Math.log(value) / Math.LN2);
|
||
if (value * (c = Math.pow(2, -e)) < 1) {
|
||
e--;
|
||
c *= 2;
|
||
}
|
||
if (e + eBias >= 1) {
|
||
value += rt / c;
|
||
} else {
|
||
value += rt * Math.pow(2, 1 - eBias);
|
||
}
|
||
if (value * c >= 2) {
|
||
e++;
|
||
c /= 2;
|
||
}
|
||
|
||
if (e + eBias >= eMax) {
|
||
m = 0;
|
||
e = eMax;
|
||
} else if (e + eBias >= 1) {
|
||
m = (value * c - 1) * Math.pow(2, mLen);
|
||
e = e + eBias;
|
||
} else {
|
||
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
|
||
e = 0;
|
||
}
|
||
}
|
||
|
||
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
|
||
|
||
e = (e << mLen) | m;
|
||
eLen += mLen;
|
||
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
|
||
|
||
buffer[offset + i - d] |= s * 128;
|
||
};
|
||
|
||
},{}],"q9TxCC":[function(require,module,exports){
|
||
var assert;
|
||
exports.Buffer = Buffer;
|
||
exports.SlowBuffer = Buffer;
|
||
Buffer.poolSize = 8192;
|
||
exports.INSPECT_MAX_BYTES = 50;
|
||
|
||
function stringtrim(str) {
|
||
if (str.trim) return str.trim();
|
||
return str.replace(/^\s+|\s+$/g, '');
|
||
}
|
||
|
||
function Buffer(subject, encoding, offset) {
|
||
if(!assert) assert= require('assert');
|
||
if (!(this instanceof Buffer)) {
|
||
return new Buffer(subject, encoding, offset);
|
||
}
|
||
this.parent = this;
|
||
this.offset = 0;
|
||
|
||
// Work-around: node's base64 implementation
|
||
// allows for non-padded strings while base64-js
|
||
// does not..
|
||
if (encoding == "base64" && typeof subject == "string") {
|
||
subject = stringtrim(subject);
|
||
while (subject.length % 4 != 0) {
|
||
subject = subject + "=";
|
||
}
|
||
}
|
||
|
||
var type;
|
||
|
||
// Are we slicing?
|
||
if (typeof offset === 'number') {
|
||
this.length = coerce(encoding);
|
||
// slicing works, with limitations (no parent tracking/update)
|
||
// check https://github.com/toots/buffer-browserify/issues/19
|
||
for (var i = 0; i < this.length; i++) {
|
||
this[i] = subject.get(i+offset);
|
||
}
|
||
} else {
|
||
// Find the length
|
||
switch (type = typeof subject) {
|
||
case 'number':
|
||
this.length = coerce(subject);
|
||
break;
|
||
|
||
case 'string':
|
||
this.length = Buffer.byteLength(subject, encoding);
|
||
break;
|
||
|
||
case 'object': // Assume object is an array
|
||
this.length = coerce(subject.length);
|
||
break;
|
||
|
||
default:
|
||
throw new Error('First argument needs to be a number, ' +
|
||
'array or string.');
|
||
}
|
||
|
||
// Treat array-ish objects as a byte array.
|
||
if (isArrayIsh(subject)) {
|
||
for (var i = 0; i < this.length; i++) {
|
||
if (subject instanceof Buffer) {
|
||
this[i] = subject.readUInt8(i);
|
||
}
|
||
else {
|
||
this[i] = subject[i];
|
||
}
|
||
}
|
||
} else if (type == 'string') {
|
||
// We are a string
|
||
this.length = this.write(subject, 0, encoding);
|
||
} else if (type === 'number') {
|
||
for (var i = 0; i < this.length; i++) {
|
||
this[i] = 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
Buffer.prototype.get = function get(i) {
|
||
if (i < 0 || i >= this.length) throw new Error('oob');
|
||
return this[i];
|
||
};
|
||
|
||
Buffer.prototype.set = function set(i, v) {
|
||
if (i < 0 || i >= this.length) throw new Error('oob');
|
||
return this[i] = v;
|
||
};
|
||
|
||
Buffer.byteLength = function (str, encoding) {
|
||
switch (encoding || "utf8") {
|
||
case 'hex':
|
||
return str.length / 2;
|
||
|
||
case 'utf8':
|
||
case 'utf-8':
|
||
return utf8ToBytes(str).length;
|
||
|
||
case 'ascii':
|
||
case 'binary':
|
||
return str.length;
|
||
|
||
case 'base64':
|
||
return base64ToBytes(str).length;
|
||
|
||
default:
|
||
throw new Error('Unknown encoding');
|
||
}
|
||
};
|
||
|
||
Buffer.prototype.utf8Write = function (string, offset, length) {
|
||
var bytes, pos;
|
||
return Buffer._charsWritten = blitBuffer(utf8ToBytes(string), this, offset, length);
|
||
};
|
||
|
||
Buffer.prototype.asciiWrite = function (string, offset, length) {
|
||
var bytes, pos;
|
||
return Buffer._charsWritten = blitBuffer(asciiToBytes(string), this, offset, length);
|
||
};
|
||
|
||
Buffer.prototype.binaryWrite = Buffer.prototype.asciiWrite;
|
||
|
||
Buffer.prototype.base64Write = function (string, offset, length) {
|
||
var bytes, pos;
|
||
return Buffer._charsWritten = blitBuffer(base64ToBytes(string), this, offset, length);
|
||
};
|
||
|
||
Buffer.prototype.base64Slice = function (start, end) {
|
||
var bytes = Array.prototype.slice.apply(this, arguments)
|
||
return require("base64-js").fromByteArray(bytes);
|
||
};
|
||
|
||
Buffer.prototype.utf8Slice = function () {
|
||
var bytes = Array.prototype.slice.apply(this, arguments);
|
||
var res = "";
|
||
var tmp = "";
|
||
var i = 0;
|
||
while (i < bytes.length) {
|
||
if (bytes[i] <= 0x7F) {
|
||
res += decodeUtf8Char(tmp) + String.fromCharCode(bytes[i]);
|
||
tmp = "";
|
||
} else
|
||
tmp += "%" + bytes[i].toString(16);
|
||
|
||
i++;
|
||
}
|
||
|
||
return res + decodeUtf8Char(tmp);
|
||
}
|
||
|
||
Buffer.prototype.asciiSlice = function () {
|
||
var bytes = Array.prototype.slice.apply(this, arguments);
|
||
var ret = "";
|
||
for (var i = 0; i < bytes.length; i++)
|
||
ret += String.fromCharCode(bytes[i]);
|
||
return ret;
|
||
}
|
||
|
||
Buffer.prototype.binarySlice = Buffer.prototype.asciiSlice;
|
||
|
||
Buffer.prototype.inspect = function() {
|
||
var out = [],
|
||
len = this.length;
|
||
for (var i = 0; i < len; i++) {
|
||
out[i] = toHex(this[i]);
|
||
if (i == exports.INSPECT_MAX_BYTES) {
|
||
out[i + 1] = '...';
|
||
break;
|
||
}
|
||
}
|
||
return '<Buffer ' + out.join(' ') + '>';
|
||
};
|
||
|
||
|
||
Buffer.prototype.hexSlice = function(start, end) {
|
||
var len = this.length;
|
||
|
||
if (!start || start < 0) start = 0;
|
||
if (!end || end < 0 || end > len) end = len;
|
||
|
||
var out = '';
|
||
for (var i = start; i < end; i++) {
|
||
out += toHex(this[i]);
|
||
}
|
||
return out;
|
||
};
|
||
|
||
|
||
Buffer.prototype.toString = function(encoding, start, end) {
|
||
encoding = String(encoding || 'utf8').toLowerCase();
|
||
start = +start || 0;
|
||
if (typeof end == 'undefined') end = this.length;
|
||
|
||
// Fastpath empty strings
|
||
if (+end == start) {
|
||
return '';
|
||
}
|
||
|
||
switch (encoding) {
|
||
case 'hex':
|
||
return this.hexSlice(start, end);
|
||
|
||
case 'utf8':
|
||
case 'utf-8':
|
||
return this.utf8Slice(start, end);
|
||
|
||
case 'ascii':
|
||
return this.asciiSlice(start, end);
|
||
|
||
case 'binary':
|
||
return this.binarySlice(start, end);
|
||
|
||
case 'base64':
|
||
return this.base64Slice(start, end);
|
||
|
||
case 'ucs2':
|
||
case 'ucs-2':
|
||
return this.ucs2Slice(start, end);
|
||
|
||
default:
|
||
throw new Error('Unknown encoding');
|
||
}
|
||
};
|
||
|
||
|
||
Buffer.prototype.hexWrite = function(string, offset, length) {
|
||
offset = +offset || 0;
|
||
var remaining = this.length - offset;
|
||
if (!length) {
|
||
length = remaining;
|
||
} else {
|
||
length = +length;
|
||
if (length > remaining) {
|
||
length = remaining;
|
||
}
|
||
}
|
||
|
||
// must be an even number of digits
|
||
var strLen = string.length;
|
||
if (strLen % 2) {
|
||
throw new Error('Invalid hex string');
|
||
}
|
||
if (length > strLen / 2) {
|
||
length = strLen / 2;
|
||
}
|
||
for (var i = 0; i < length; i++) {
|
||
var byte = parseInt(string.substr(i * 2, 2), 16);
|
||
if (isNaN(byte)) throw new Error('Invalid hex string');
|
||
this[offset + i] = byte;
|
||
}
|
||
Buffer._charsWritten = i * 2;
|
||
return i;
|
||
};
|
||
|
||
|
||
Buffer.prototype.write = function(string, offset, length, encoding) {
|
||
// Support both (string, offset, length, encoding)
|
||
// and the legacy (string, encoding, offset, length)
|
||
if (isFinite(offset)) {
|
||
if (!isFinite(length)) {
|
||
encoding = length;
|
||
length = undefined;
|
||
}
|
||
} else { // legacy
|
||
var swap = encoding;
|
||
encoding = offset;
|
||
offset = length;
|
||
length = swap;
|
||
}
|
||
|
||
offset = +offset || 0;
|
||
var remaining = this.length - offset;
|
||
if (!length) {
|
||
length = remaining;
|
||
} else {
|
||
length = +length;
|
||
if (length > remaining) {
|
||
length = remaining;
|
||
}
|
||
}
|
||
encoding = String(encoding || 'utf8').toLowerCase();
|
||
|
||
switch (encoding) {
|
||
case 'hex':
|
||
return this.hexWrite(string, offset, length);
|
||
|
||
case 'utf8':
|
||
case 'utf-8':
|
||
return this.utf8Write(string, offset, length);
|
||
|
||
case 'ascii':
|
||
return this.asciiWrite(string, offset, length);
|
||
|
||
case 'binary':
|
||
return this.binaryWrite(string, offset, length);
|
||
|
||
case 'base64':
|
||
return this.base64Write(string, offset, length);
|
||
|
||
case 'ucs2':
|
||
case 'ucs-2':
|
||
return this.ucs2Write(string, offset, length);
|
||
|
||
default:
|
||
throw new Error('Unknown encoding');
|
||
}
|
||
};
|
||
|
||
// slice(start, end)
|
||
function clamp(index, len, defaultValue) {
|
||
if (typeof index !== 'number') return defaultValue;
|
||
index = ~~index; // Coerce to integer.
|
||
if (index >= len) return len;
|
||
if (index >= 0) return index;
|
||
index += len;
|
||
if (index >= 0) return index;
|
||
return 0;
|
||
}
|
||
|
||
Buffer.prototype.slice = function(start, end) {
|
||
var len = this.length;
|
||
start = clamp(start, len, 0);
|
||
end = clamp(end, len, len);
|
||
return new Buffer(this, end - start, +start);
|
||
};
|
||
|
||
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
||
Buffer.prototype.copy = function(target, target_start, start, end) {
|
||
var source = this;
|
||
start || (start = 0);
|
||
if (end === undefined || isNaN(end)) {
|
||
end = this.length;
|
||
}
|
||
target_start || (target_start = 0);
|
||
|
||
if (end < start) throw new Error('sourceEnd < sourceStart');
|
||
|
||
// Copy 0 bytes; we're done
|
||
if (end === start) return 0;
|
||
if (target.length == 0 || source.length == 0) return 0;
|
||
|
||
if (target_start < 0 || target_start >= target.length) {
|
||
throw new Error('targetStart out of bounds');
|
||
}
|
||
|
||
if (start < 0 || start >= source.length) {
|
||
throw new Error('sourceStart out of bounds');
|
||
}
|
||
|
||
if (end < 0 || end > source.length) {
|
||
throw new Error('sourceEnd out of bounds');
|
||
}
|
||
|
||
// Are we oob?
|
||
if (end > this.length) {
|
||
end = this.length;
|
||
}
|
||
|
||
if (target.length - target_start < end - start) {
|
||
end = target.length - target_start + start;
|
||
}
|
||
|
||
var temp = [];
|
||
for (var i=start; i<end; i++) {
|
||
assert.ok(typeof this[i] !== 'undefined', "copying undefined buffer bytes!");
|
||
temp.push(this[i]);
|
||
}
|
||
|
||
for (var i=target_start; i<target_start+temp.length; i++) {
|
||
target[i] = temp[i-target_start];
|
||
}
|
||
};
|
||
|
||
// fill(value, start=0, end=buffer.length)
|
||
Buffer.prototype.fill = function fill(value, start, end) {
|
||
value || (value = 0);
|
||
start || (start = 0);
|
||
end || (end = this.length);
|
||
|
||
if (typeof value === 'string') {
|
||
value = value.charCodeAt(0);
|
||
}
|
||
if (!(typeof value === 'number') || isNaN(value)) {
|
||
throw new Error('value is not a number');
|
||
}
|
||
|
||
if (end < start) throw new Error('end < start');
|
||
|
||
// Fill 0 bytes; we're done
|
||
if (end === start) return 0;
|
||
if (this.length == 0) return 0;
|
||
|
||
if (start < 0 || start >= this.length) {
|
||
throw new Error('start out of bounds');
|
||
}
|
||
|
||
if (end < 0 || end > this.length) {
|
||
throw new Error('end out of bounds');
|
||
}
|
||
|
||
for (var i = start; i < end; i++) {
|
||
this[i] = value;
|
||
}
|
||
}
|
||
|
||
// Static methods
|
||
Buffer.isBuffer = function isBuffer(b) {
|
||
return b instanceof Buffer || b instanceof Buffer;
|
||
};
|
||
|
||
Buffer.concat = function (list, totalLength) {
|
||
if (!isArray(list)) {
|
||
throw new Error("Usage: Buffer.concat(list, [totalLength])\n \
|
||
list should be an Array.");
|
||
}
|
||
|
||
if (list.length === 0) {
|
||
return new Buffer(0);
|
||
} else if (list.length === 1) {
|
||
return list[0];
|
||
}
|
||
|
||
if (typeof totalLength !== 'number') {
|
||
totalLength = 0;
|
||
for (var i = 0; i < list.length; i++) {
|
||
var buf = list[i];
|
||
totalLength += buf.length;
|
||
}
|
||
}
|
||
|
||
var buffer = new Buffer(totalLength);
|
||
var pos = 0;
|
||
for (var i = 0; i < list.length; i++) {
|
||
var buf = list[i];
|
||
buf.copy(buffer, pos);
|
||
pos += buf.length;
|
||
}
|
||
return buffer;
|
||
};
|
||
|
||
Buffer.isEncoding = function(encoding) {
|
||
switch ((encoding + '').toLowerCase()) {
|
||
case 'hex':
|
||
case 'utf8':
|
||
case 'utf-8':
|
||
case 'ascii':
|
||
case 'binary':
|
||
case 'base64':
|
||
case 'ucs2':
|
||
case 'ucs-2':
|
||
case 'utf16le':
|
||
case 'utf-16le':
|
||
case 'raw':
|
||
return true;
|
||
|
||
default:
|
||
return false;
|
||
}
|
||
};
|
||
|
||
// helpers
|
||
|
||
function coerce(length) {
|
||
// Coerce length to a number (possibly NaN), round up
|
||
// in case it's fractional (e.g. 123.456) then do a
|
||
// double negate to coerce a NaN to 0. Easy, right?
|
||
length = ~~Math.ceil(+length);
|
||
return length < 0 ? 0 : length;
|
||
}
|
||
|
||
function isArray(subject) {
|
||
return (Array.isArray ||
|
||
function(subject){
|
||
return {}.toString.apply(subject) == '[object Array]'
|
||
})
|
||
(subject)
|
||
}
|
||
|
||
function isArrayIsh(subject) {
|
||
return isArray(subject) || Buffer.isBuffer(subject) ||
|
||
subject && typeof subject === 'object' &&
|
||
typeof subject.length === 'number';
|
||
}
|
||
|
||
function toHex(n) {
|
||
if (n < 16) return '0' + n.toString(16);
|
||
return n.toString(16);
|
||
}
|
||
|
||
function utf8ToBytes(str) {
|
||
var byteArray = [];
|
||
for (var i = 0; i < str.length; i++)
|
||
if (str.charCodeAt(i) <= 0x7F)
|
||
byteArray.push(str.charCodeAt(i));
|
||
else {
|
||
var h = encodeURIComponent(str.charAt(i)).substr(1).split('%');
|
||
for (var j = 0; j < h.length; j++)
|
||
byteArray.push(parseInt(h[j], 16));
|
||
}
|
||
|
||
return byteArray;
|
||
}
|
||
|
||
function asciiToBytes(str) {
|
||
var byteArray = []
|
||
for (var i = 0; i < str.length; i++ )
|
||
// Node's code seems to be doing this and not & 0x7F..
|
||
byteArray.push( str.charCodeAt(i) & 0xFF );
|
||
|
||
return byteArray;
|
||
}
|
||
|
||
function base64ToBytes(str) {
|
||
return require("base64-js").toByteArray(str);
|
||
}
|
||
|
||
function blitBuffer(src, dst, offset, length) {
|
||
var pos, i = 0;
|
||
while (i < length) {
|
||
if ((i+offset >= dst.length) || (i >= src.length))
|
||
break;
|
||
|
||
dst[i + offset] = src[i];
|
||
i++;
|
||
}
|
||
return i;
|
||
}
|
||
|
||
function decodeUtf8Char(str) {
|
||
try {
|
||
return decodeURIComponent(str);
|
||
} catch (err) {
|
||
return String.fromCharCode(0xFFFD); // UTF 8 invalid char
|
||
}
|
||
}
|
||
|
||
// read/write bit-twiddling
|
||
|
||
Buffer.prototype.readUInt8 = function(offset, noAssert) {
|
||
var buffer = this;
|
||
|
||
if (!noAssert) {
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset < buffer.length,
|
||
'Trying to read beyond buffer length');
|
||
}
|
||
|
||
if (offset >= buffer.length) return;
|
||
|
||
return buffer[offset];
|
||
};
|
||
|
||
function readUInt16(buffer, offset, isBigEndian, noAssert) {
|
||
var val = 0;
|
||
|
||
|
||
if (!noAssert) {
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 1 < buffer.length,
|
||
'Trying to read beyond buffer length');
|
||
}
|
||
|
||
if (offset >= buffer.length) return 0;
|
||
|
||
if (isBigEndian) {
|
||
val = buffer[offset] << 8;
|
||
if (offset + 1 < buffer.length) {
|
||
val |= buffer[offset + 1];
|
||
}
|
||
} else {
|
||
val = buffer[offset];
|
||
if (offset + 1 < buffer.length) {
|
||
val |= buffer[offset + 1] << 8;
|
||
}
|
||
}
|
||
|
||
return val;
|
||
}
|
||
|
||
Buffer.prototype.readUInt16LE = function(offset, noAssert) {
|
||
return readUInt16(this, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.readUInt16BE = function(offset, noAssert) {
|
||
return readUInt16(this, offset, true, noAssert);
|
||
};
|
||
|
||
function readUInt32(buffer, offset, isBigEndian, noAssert) {
|
||
var val = 0;
|
||
|
||
if (!noAssert) {
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 3 < buffer.length,
|
||
'Trying to read beyond buffer length');
|
||
}
|
||
|
||
if (offset >= buffer.length) return 0;
|
||
|
||
if (isBigEndian) {
|
||
if (offset + 1 < buffer.length)
|
||
val = buffer[offset + 1] << 16;
|
||
if (offset + 2 < buffer.length)
|
||
val |= buffer[offset + 2] << 8;
|
||
if (offset + 3 < buffer.length)
|
||
val |= buffer[offset + 3];
|
||
val = val + (buffer[offset] << 24 >>> 0);
|
||
} else {
|
||
if (offset + 2 < buffer.length)
|
||
val = buffer[offset + 2] << 16;
|
||
if (offset + 1 < buffer.length)
|
||
val |= buffer[offset + 1] << 8;
|
||
val |= buffer[offset];
|
||
if (offset + 3 < buffer.length)
|
||
val = val + (buffer[offset + 3] << 24 >>> 0);
|
||
}
|
||
|
||
return val;
|
||
}
|
||
|
||
Buffer.prototype.readUInt32LE = function(offset, noAssert) {
|
||
return readUInt32(this, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.readUInt32BE = function(offset, noAssert) {
|
||
return readUInt32(this, offset, true, noAssert);
|
||
};
|
||
|
||
|
||
/*
|
||
* Signed integer types, yay team! A reminder on how two's complement actually
|
||
* works. The first bit is the signed bit, i.e. tells us whether or not the
|
||
* number should be positive or negative. If the two's complement value is
|
||
* positive, then we're done, as it's equivalent to the unsigned representation.
|
||
*
|
||
* Now if the number is positive, you're pretty much done, you can just leverage
|
||
* the unsigned translations and return those. Unfortunately, negative numbers
|
||
* aren't quite that straightforward.
|
||
*
|
||
* At first glance, one might be inclined to use the traditional formula to
|
||
* translate binary numbers between the positive and negative values in two's
|
||
* complement. (Though it doesn't quite work for the most negative value)
|
||
* Mainly:
|
||
* - invert all the bits
|
||
* - add one to the result
|
||
*
|
||
* Of course, this doesn't quite work in Javascript. Take for example the value
|
||
* of -128. This could be represented in 16 bits (big-endian) as 0xff80. But of
|
||
* course, Javascript will do the following:
|
||
*
|
||
* > ~0xff80
|
||
* -65409
|
||
*
|
||
* Whoh there, Javascript, that's not quite right. But wait, according to
|
||
* Javascript that's perfectly correct. When Javascript ends up seeing the
|
||
* constant 0xff80, it has no notion that it is actually a signed number. It
|
||
* assumes that we've input the unsigned value 0xff80. Thus, when it does the
|
||
* binary negation, it casts it into a signed value, (positive 0xff80). Then
|
||
* when you perform binary negation on that, it turns it into a negative number.
|
||
*
|
||
* Instead, we're going to have to use the following general formula, that works
|
||
* in a rather Javascript friendly way. I'm glad we don't support this kind of
|
||
* weird numbering scheme in the kernel.
|
||
*
|
||
* (BIT-MAX - (unsigned)val + 1) * -1
|
||
*
|
||
* The astute observer, may think that this doesn't make sense for 8-bit numbers
|
||
* (really it isn't necessary for them). However, when you get 16-bit numbers,
|
||
* you do. Let's go back to our prior example and see how this will look:
|
||
*
|
||
* (0xffff - 0xff80 + 1) * -1
|
||
* (0x007f + 1) * -1
|
||
* (0x0080) * -1
|
||
*/
|
||
Buffer.prototype.readInt8 = function(offset, noAssert) {
|
||
var buffer = this;
|
||
var neg;
|
||
|
||
if (!noAssert) {
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset < buffer.length,
|
||
'Trying to read beyond buffer length');
|
||
}
|
||
|
||
if (offset >= buffer.length) return;
|
||
|
||
neg = buffer[offset] & 0x80;
|
||
if (!neg) {
|
||
return (buffer[offset]);
|
||
}
|
||
|
||
return ((0xff - buffer[offset] + 1) * -1);
|
||
};
|
||
|
||
function readInt16(buffer, offset, isBigEndian, noAssert) {
|
||
var neg, val;
|
||
|
||
if (!noAssert) {
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 1 < buffer.length,
|
||
'Trying to read beyond buffer length');
|
||
}
|
||
|
||
val = readUInt16(buffer, offset, isBigEndian, noAssert);
|
||
neg = val & 0x8000;
|
||
if (!neg) {
|
||
return val;
|
||
}
|
||
|
||
return (0xffff - val + 1) * -1;
|
||
}
|
||
|
||
Buffer.prototype.readInt16LE = function(offset, noAssert) {
|
||
return readInt16(this, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.readInt16BE = function(offset, noAssert) {
|
||
return readInt16(this, offset, true, noAssert);
|
||
};
|
||
|
||
function readInt32(buffer, offset, isBigEndian, noAssert) {
|
||
var neg, val;
|
||
|
||
if (!noAssert) {
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 3 < buffer.length,
|
||
'Trying to read beyond buffer length');
|
||
}
|
||
|
||
val = readUInt32(buffer, offset, isBigEndian, noAssert);
|
||
neg = val & 0x80000000;
|
||
if (!neg) {
|
||
return (val);
|
||
}
|
||
|
||
return (0xffffffff - val + 1) * -1;
|
||
}
|
||
|
||
Buffer.prototype.readInt32LE = function(offset, noAssert) {
|
||
return readInt32(this, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.readInt32BE = function(offset, noAssert) {
|
||
return readInt32(this, offset, true, noAssert);
|
||
};
|
||
|
||
function readFloat(buffer, offset, isBigEndian, noAssert) {
|
||
if (!noAssert) {
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset + 3 < buffer.length,
|
||
'Trying to read beyond buffer length');
|
||
}
|
||
|
||
return require('./buffer_ieee754').readIEEE754(buffer, offset, isBigEndian,
|
||
23, 4);
|
||
}
|
||
|
||
Buffer.prototype.readFloatLE = function(offset, noAssert) {
|
||
return readFloat(this, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.readFloatBE = function(offset, noAssert) {
|
||
return readFloat(this, offset, true, noAssert);
|
||
};
|
||
|
||
function readDouble(buffer, offset, isBigEndian, noAssert) {
|
||
if (!noAssert) {
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset + 7 < buffer.length,
|
||
'Trying to read beyond buffer length');
|
||
}
|
||
|
||
return require('./buffer_ieee754').readIEEE754(buffer, offset, isBigEndian,
|
||
52, 8);
|
||
}
|
||
|
||
Buffer.prototype.readDoubleLE = function(offset, noAssert) {
|
||
return readDouble(this, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.readDoubleBE = function(offset, noAssert) {
|
||
return readDouble(this, offset, true, noAssert);
|
||
};
|
||
|
||
|
||
/*
|
||
* We have to make sure that the value is a valid integer. This means that it is
|
||
* non-negative. It has no fractional component and that it does not exceed the
|
||
* maximum allowed value.
|
||
*
|
||
* value The number to check for validity
|
||
*
|
||
* max The maximum value
|
||
*/
|
||
function verifuint(value, max) {
|
||
assert.ok(typeof (value) == 'number',
|
||
'cannot write a non-number as a number');
|
||
|
||
assert.ok(value >= 0,
|
||
'specified a negative value for writing an unsigned value');
|
||
|
||
assert.ok(value <= max, 'value is larger than maximum value for type');
|
||
|
||
assert.ok(Math.floor(value) === value, 'value has a fractional component');
|
||
}
|
||
|
||
Buffer.prototype.writeUInt8 = function(value, offset, noAssert) {
|
||
var buffer = this;
|
||
|
||
if (!noAssert) {
|
||
assert.ok(value !== undefined && value !== null,
|
||
'missing value');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset < buffer.length,
|
||
'trying to write beyond buffer length');
|
||
|
||
verifuint(value, 0xff);
|
||
}
|
||
|
||
if (offset < buffer.length) {
|
||
buffer[offset] = value;
|
||
}
|
||
};
|
||
|
||
function writeUInt16(buffer, value, offset, isBigEndian, noAssert) {
|
||
if (!noAssert) {
|
||
assert.ok(value !== undefined && value !== null,
|
||
'missing value');
|
||
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 1 < buffer.length,
|
||
'trying to write beyond buffer length');
|
||
|
||
verifuint(value, 0xffff);
|
||
}
|
||
|
||
for (var i = 0; i < Math.min(buffer.length - offset, 2); i++) {
|
||
buffer[offset + i] =
|
||
(value & (0xff << (8 * (isBigEndian ? 1 - i : i)))) >>>
|
||
(isBigEndian ? 1 - i : i) * 8;
|
||
}
|
||
|
||
}
|
||
|
||
Buffer.prototype.writeUInt16LE = function(value, offset, noAssert) {
|
||
writeUInt16(this, value, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
|
||
writeUInt16(this, value, offset, true, noAssert);
|
||
};
|
||
|
||
function writeUInt32(buffer, value, offset, isBigEndian, noAssert) {
|
||
if (!noAssert) {
|
||
assert.ok(value !== undefined && value !== null,
|
||
'missing value');
|
||
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 3 < buffer.length,
|
||
'trying to write beyond buffer length');
|
||
|
||
verifuint(value, 0xffffffff);
|
||
}
|
||
|
||
for (var i = 0; i < Math.min(buffer.length - offset, 4); i++) {
|
||
buffer[offset + i] =
|
||
(value >>> (isBigEndian ? 3 - i : i) * 8) & 0xff;
|
||
}
|
||
}
|
||
|
||
Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
|
||
writeUInt32(this, value, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
|
||
writeUInt32(this, value, offset, true, noAssert);
|
||
};
|
||
|
||
|
||
/*
|
||
* We now move onto our friends in the signed number category. Unlike unsigned
|
||
* numbers, we're going to have to worry a bit more about how we put values into
|
||
* arrays. Since we are only worrying about signed 32-bit values, we're in
|
||
* slightly better shape. Unfortunately, we really can't do our favorite binary
|
||
* & in this system. It really seems to do the wrong thing. For example:
|
||
*
|
||
* > -32 & 0xff
|
||
* 224
|
||
*
|
||
* What's happening above is really: 0xe0 & 0xff = 0xe0. However, the results of
|
||
* this aren't treated as a signed number. Ultimately a bad thing.
|
||
*
|
||
* What we're going to want to do is basically create the unsigned equivalent of
|
||
* our representation and pass that off to the wuint* functions. To do that
|
||
* we're going to do the following:
|
||
*
|
||
* - if the value is positive
|
||
* we can pass it directly off to the equivalent wuint
|
||
* - if the value is negative
|
||
* we do the following computation:
|
||
* mb + val + 1, where
|
||
* mb is the maximum unsigned value in that byte size
|
||
* val is the Javascript negative integer
|
||
*
|
||
*
|
||
* As a concrete value, take -128. In signed 16 bits this would be 0xff80. If
|
||
* you do out the computations:
|
||
*
|
||
* 0xffff - 128 + 1
|
||
* 0xffff - 127
|
||
* 0xff80
|
||
*
|
||
* You can then encode this value as the signed version. This is really rather
|
||
* hacky, but it should work and get the job done which is our goal here.
|
||
*/
|
||
|
||
/*
|
||
* A series of checks to make sure we actually have a signed 32-bit number
|
||
*/
|
||
function verifsint(value, max, min) {
|
||
assert.ok(typeof (value) == 'number',
|
||
'cannot write a non-number as a number');
|
||
|
||
assert.ok(value <= max, 'value larger than maximum allowed value');
|
||
|
||
assert.ok(value >= min, 'value smaller than minimum allowed value');
|
||
|
||
assert.ok(Math.floor(value) === value, 'value has a fractional component');
|
||
}
|
||
|
||
function verifIEEE754(value, max, min) {
|
||
assert.ok(typeof (value) == 'number',
|
||
'cannot write a non-number as a number');
|
||
|
||
assert.ok(value <= max, 'value larger than maximum allowed value');
|
||
|
||
assert.ok(value >= min, 'value smaller than minimum allowed value');
|
||
}
|
||
|
||
Buffer.prototype.writeInt8 = function(value, offset, noAssert) {
|
||
var buffer = this;
|
||
|
||
if (!noAssert) {
|
||
assert.ok(value !== undefined && value !== null,
|
||
'missing value');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset < buffer.length,
|
||
'Trying to write beyond buffer length');
|
||
|
||
verifsint(value, 0x7f, -0x80);
|
||
}
|
||
|
||
if (value >= 0) {
|
||
buffer.writeUInt8(value, offset, noAssert);
|
||
} else {
|
||
buffer.writeUInt8(0xff + value + 1, offset, noAssert);
|
||
}
|
||
};
|
||
|
||
function writeInt16(buffer, value, offset, isBigEndian, noAssert) {
|
||
if (!noAssert) {
|
||
assert.ok(value !== undefined && value !== null,
|
||
'missing value');
|
||
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 1 < buffer.length,
|
||
'Trying to write beyond buffer length');
|
||
|
||
verifsint(value, 0x7fff, -0x8000);
|
||
}
|
||
|
||
if (value >= 0) {
|
||
writeUInt16(buffer, value, offset, isBigEndian, noAssert);
|
||
} else {
|
||
writeUInt16(buffer, 0xffff + value + 1, offset, isBigEndian, noAssert);
|
||
}
|
||
}
|
||
|
||
Buffer.prototype.writeInt16LE = function(value, offset, noAssert) {
|
||
writeInt16(this, value, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.writeInt16BE = function(value, offset, noAssert) {
|
||
writeInt16(this, value, offset, true, noAssert);
|
||
};
|
||
|
||
function writeInt32(buffer, value, offset, isBigEndian, noAssert) {
|
||
if (!noAssert) {
|
||
assert.ok(value !== undefined && value !== null,
|
||
'missing value');
|
||
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 3 < buffer.length,
|
||
'Trying to write beyond buffer length');
|
||
|
||
verifsint(value, 0x7fffffff, -0x80000000);
|
||
}
|
||
|
||
if (value >= 0) {
|
||
writeUInt32(buffer, value, offset, isBigEndian, noAssert);
|
||
} else {
|
||
writeUInt32(buffer, 0xffffffff + value + 1, offset, isBigEndian, noAssert);
|
||
}
|
||
}
|
||
|
||
Buffer.prototype.writeInt32LE = function(value, offset, noAssert) {
|
||
writeInt32(this, value, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.writeInt32BE = function(value, offset, noAssert) {
|
||
writeInt32(this, value, offset, true, noAssert);
|
||
};
|
||
|
||
function writeFloat(buffer, value, offset, isBigEndian, noAssert) {
|
||
if (!noAssert) {
|
||
assert.ok(value !== undefined && value !== null,
|
||
'missing value');
|
||
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 3 < buffer.length,
|
||
'Trying to write beyond buffer length');
|
||
|
||
verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38);
|
||
}
|
||
|
||
require('./buffer_ieee754').writeIEEE754(buffer, value, offset, isBigEndian,
|
||
23, 4);
|
||
}
|
||
|
||
Buffer.prototype.writeFloatLE = function(value, offset, noAssert) {
|
||
writeFloat(this, value, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.writeFloatBE = function(value, offset, noAssert) {
|
||
writeFloat(this, value, offset, true, noAssert);
|
||
};
|
||
|
||
function writeDouble(buffer, value, offset, isBigEndian, noAssert) {
|
||
if (!noAssert) {
|
||
assert.ok(value !== undefined && value !== null,
|
||
'missing value');
|
||
|
||
assert.ok(typeof (isBigEndian) === 'boolean',
|
||
'missing or invalid endian');
|
||
|
||
assert.ok(offset !== undefined && offset !== null,
|
||
'missing offset');
|
||
|
||
assert.ok(offset + 7 < buffer.length,
|
||
'Trying to write beyond buffer length');
|
||
|
||
verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308);
|
||
}
|
||
|
||
require('./buffer_ieee754').writeIEEE754(buffer, value, offset, isBigEndian,
|
||
52, 8);
|
||
}
|
||
|
||
Buffer.prototype.writeDoubleLE = function(value, offset, noAssert) {
|
||
writeDouble(this, value, offset, false, noAssert);
|
||
};
|
||
|
||
Buffer.prototype.writeDoubleBE = function(value, offset, noAssert) {
|
||
writeDouble(this, value, offset, true, noAssert);
|
||
};
|
||
|
||
},{"./buffer_ieee754":1,"assert":6,"base64-js":4}],"buffer-browserify":[function(require,module,exports){
|
||
module.exports=require('q9TxCC');
|
||
},{}],4:[function(require,module,exports){
|
||
(function (exports) {
|
||
'use strict';
|
||
|
||
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
||
|
||
function b64ToByteArray(b64) {
|
||
var i, j, l, tmp, placeHolders, arr;
|
||
|
||
if (b64.length % 4 > 0) {
|
||
throw 'Invalid string. Length must be a multiple of 4';
|
||
}
|
||
|
||
// the number of equal signs (place holders)
|
||
// if there are two placeholders, than the two characters before it
|
||
// represent one byte
|
||
// if there is only one, then the three characters before it represent 2 bytes
|
||
// this is just a cheap hack to not do indexOf twice
|
||
placeHolders = b64.indexOf('=');
|
||
placeHolders = placeHolders > 0 ? b64.length - placeHolders : 0;
|
||
|
||
// base64 is 4/3 + up to two characters of the original data
|
||
arr = [];//new Uint8Array(b64.length * 3 / 4 - placeHolders);
|
||
|
||
// if there are placeholders, only get up to the last complete 4 chars
|
||
l = placeHolders > 0 ? b64.length - 4 : b64.length;
|
||
|
||
for (i = 0, j = 0; i < l; i += 4, j += 3) {
|
||
tmp = (lookup.indexOf(b64[i]) << 18) | (lookup.indexOf(b64[i + 1]) << 12) | (lookup.indexOf(b64[i + 2]) << 6) | lookup.indexOf(b64[i + 3]);
|
||
arr.push((tmp & 0xFF0000) >> 16);
|
||
arr.push((tmp & 0xFF00) >> 8);
|
||
arr.push(tmp & 0xFF);
|
||
}
|
||
|
||
if (placeHolders === 2) {
|
||
tmp = (lookup.indexOf(b64[i]) << 2) | (lookup.indexOf(b64[i + 1]) >> 4);
|
||
arr.push(tmp & 0xFF);
|
||
} else if (placeHolders === 1) {
|
||
tmp = (lookup.indexOf(b64[i]) << 10) | (lookup.indexOf(b64[i + 1]) << 4) | (lookup.indexOf(b64[i + 2]) >> 2);
|
||
arr.push((tmp >> 8) & 0xFF);
|
||
arr.push(tmp & 0xFF);
|
||
}
|
||
|
||
return arr;
|
||
}
|
||
|
||
function uint8ToBase64(uint8) {
|
||
var i,
|
||
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
|
||
output = "",
|
||
temp, length;
|
||
|
||
function tripletToBase64 (num) {
|
||
return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];
|
||
};
|
||
|
||
// go through the array every three bytes, we'll deal with trailing stuff later
|
||
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
|
||
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
|
||
output += tripletToBase64(temp);
|
||
}
|
||
|
||
// pad the end with zeros, but make sure to not forget the extra bytes
|
||
switch (extraBytes) {
|
||
case 1:
|
||
temp = uint8[uint8.length - 1];
|
||
output += lookup[temp >> 2];
|
||
output += lookup[(temp << 4) & 0x3F];
|
||
output += '==';
|
||
break;
|
||
case 2:
|
||
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]);
|
||
output += lookup[temp >> 10];
|
||
output += lookup[(temp >> 4) & 0x3F];
|
||
output += lookup[(temp << 2) & 0x3F];
|
||
output += '=';
|
||
break;
|
||
}
|
||
|
||
return output;
|
||
}
|
||
|
||
module.exports.toByteArray = b64ToByteArray;
|
||
module.exports.fromByteArray = uint8ToBase64;
|
||
}());
|
||
|
||
},{}],5:[function(require,module,exports){
|
||
|
||
|
||
//
|
||
// The shims in this file are not fully implemented shims for the ES5
|
||
// features, but do work for the particular usecases there is in
|
||
// the other modules.
|
||
//
|
||
|
||
var toString = Object.prototype.toString;
|
||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||
|
||
// Array.isArray is supported in IE9
|
||
function isArray(xs) {
|
||
return toString.call(xs) === '[object Array]';
|
||
}
|
||
exports.isArray = typeof Array.isArray === 'function' ? Array.isArray : isArray;
|
||
|
||
// Array.prototype.indexOf is supported in IE9
|
||
exports.indexOf = function indexOf(xs, x) {
|
||
if (xs.indexOf) return xs.indexOf(x);
|
||
for (var i = 0; i < xs.length; i++) {
|
||
if (x === xs[i]) return i;
|
||
}
|
||
return -1;
|
||
};
|
||
|
||
// Array.prototype.filter is supported in IE9
|
||
exports.filter = function filter(xs, fn) {
|
||
if (xs.filter) return xs.filter(fn);
|
||
var res = [];
|
||
for (var i = 0; i < xs.length; i++) {
|
||
if (fn(xs[i], i, xs)) res.push(xs[i]);
|
||
}
|
||
return res;
|
||
};
|
||
|
||
// Array.prototype.forEach is supported in IE9
|
||
exports.forEach = function forEach(xs, fn, self) {
|
||
if (xs.forEach) return xs.forEach(fn, self);
|
||
for (var i = 0; i < xs.length; i++) {
|
||
fn.call(self, xs[i], i, xs);
|
||
}
|
||
};
|
||
|
||
// Array.prototype.map is supported in IE9
|
||
exports.map = function map(xs, fn) {
|
||
if (xs.map) return xs.map(fn);
|
||
var out = new Array(xs.length);
|
||
for (var i = 0; i < xs.length; i++) {
|
||
out[i] = fn(xs[i], i, xs);
|
||
}
|
||
return out;
|
||
};
|
||
|
||
// Array.prototype.reduce is supported in IE9
|
||
exports.reduce = function reduce(array, callback, opt_initialValue) {
|
||
if (array.reduce) return array.reduce(callback, opt_initialValue);
|
||
var value, isValueSet = false;
|
||
|
||
if (2 < arguments.length) {
|
||
value = opt_initialValue;
|
||
isValueSet = true;
|
||
}
|
||
for (var i = 0, l = array.length; l > i; ++i) {
|
||
if (array.hasOwnProperty(i)) {
|
||
if (isValueSet) {
|
||
value = callback(value, array[i], i, array);
|
||
}
|
||
else {
|
||
value = array[i];
|
||
isValueSet = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return value;
|
||
};
|
||
|
||
// String.prototype.substr - negative index don't work in IE8
|
||
if ('ab'.substr(-1) !== 'b') {
|
||
exports.substr = function (str, start, length) {
|
||
// did we get a negative start, calculate how much it is from the beginning of the string
|
||
if (start < 0) start = str.length + start;
|
||
|
||
// call the original function
|
||
return str.substr(start, length);
|
||
};
|
||
} else {
|
||
exports.substr = function (str, start, length) {
|
||
return str.substr(start, length);
|
||
};
|
||
}
|
||
|
||
// String.prototype.trim is supported in IE9
|
||
exports.trim = function (str) {
|
||
if (str.trim) return str.trim();
|
||
return str.replace(/^\s+|\s+$/g, '');
|
||
};
|
||
|
||
// Function.prototype.bind is supported in IE9
|
||
exports.bind = function () {
|
||
var args = Array.prototype.slice.call(arguments);
|
||
var fn = args.shift();
|
||
if (fn.bind) return fn.bind.apply(fn, args);
|
||
var self = args.shift();
|
||
return function () {
|
||
fn.apply(self, args.concat([Array.prototype.slice.call(arguments)]));
|
||
};
|
||
};
|
||
|
||
// Object.create is supported in IE9
|
||
function create(prototype, properties) {
|
||
var object;
|
||
if (prototype === null) {
|
||
object = { '__proto__' : null };
|
||
}
|
||
else {
|
||
if (typeof prototype !== 'object') {
|
||
throw new TypeError(
|
||
'typeof prototype[' + (typeof prototype) + '] != \'object\''
|
||
);
|
||
}
|
||
var Type = function () {};
|
||
Type.prototype = prototype;
|
||
object = new Type();
|
||
object.__proto__ = prototype;
|
||
}
|
||
if (typeof properties !== 'undefined' && Object.defineProperties) {
|
||
Object.defineProperties(object, properties);
|
||
}
|
||
return object;
|
||
}
|
||
exports.create = typeof Object.create === 'function' ? Object.create : create;
|
||
|
||
// Object.keys and Object.getOwnPropertyNames is supported in IE9 however
|
||
// they do show a description and number property on Error objects
|
||
function notObject(object) {
|
||
return ((typeof object != "object" && typeof object != "function") || object === null);
|
||
}
|
||
|
||
function keysShim(object) {
|
||
if (notObject(object)) {
|
||
throw new TypeError("Object.keys called on a non-object");
|
||
}
|
||
|
||
var result = [];
|
||
for (var name in object) {
|
||
if (hasOwnProperty.call(object, name)) {
|
||
result.push(name);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// getOwnPropertyNames is almost the same as Object.keys one key feature
|
||
// is that it returns hidden properties, since that can't be implemented,
|
||
// this feature gets reduced so it just shows the length property on arrays
|
||
function propertyShim(object) {
|
||
if (notObject(object)) {
|
||
throw new TypeError("Object.getOwnPropertyNames called on a non-object");
|
||
}
|
||
|
||
var result = keysShim(object);
|
||
if (exports.isArray(object) && exports.indexOf(object, 'length') === -1) {
|
||
result.push('length');
|
||
}
|
||
return result;
|
||
}
|
||
|
||
var keys = typeof Object.keys === 'function' ? Object.keys : keysShim;
|
||
var getOwnPropertyNames = typeof Object.getOwnPropertyNames === 'function' ?
|
||
Object.getOwnPropertyNames : propertyShim;
|
||
|
||
if (new Error().hasOwnProperty('description')) {
|
||
var ERROR_PROPERTY_FILTER = function (obj, array) {
|
||
if (toString.call(obj) === '[object Error]') {
|
||
array = exports.filter(array, function (name) {
|
||
return name !== 'description' && name !== 'number' && name !== 'message';
|
||
});
|
||
}
|
||
return array;
|
||
};
|
||
|
||
exports.keys = function (object) {
|
||
return ERROR_PROPERTY_FILTER(object, keys(object));
|
||
};
|
||
exports.getOwnPropertyNames = function (object) {
|
||
return ERROR_PROPERTY_FILTER(object, getOwnPropertyNames(object));
|
||
};
|
||
} else {
|
||
exports.keys = keys;
|
||
exports.getOwnPropertyNames = getOwnPropertyNames;
|
||
}
|
||
|
||
// Object.getOwnPropertyDescriptor - supported in IE8 but only on dom elements
|
||
function valueObject(value, key) {
|
||
return { value: value[key] };
|
||
}
|
||
|
||
if (typeof Object.getOwnPropertyDescriptor === 'function') {
|
||
try {
|
||
Object.getOwnPropertyDescriptor({'a': 1}, 'a');
|
||
exports.getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
} catch (e) {
|
||
// IE8 dom element issue - use a try catch and default to valueObject
|
||
exports.getOwnPropertyDescriptor = function (value, key) {
|
||
try {
|
||
return Object.getOwnPropertyDescriptor(value, key);
|
||
} catch (e) {
|
||
return valueObject(value, key);
|
||
}
|
||
};
|
||
}
|
||
} else {
|
||
exports.getOwnPropertyDescriptor = valueObject;
|
||
}
|
||
|
||
},{}],6:[function(require,module,exports){
|
||
// Copyright Joyent, Inc. and other Node contributors.
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||
// copy of this software and associated documentation files (the
|
||
// "Software"), to deal in the Software without restriction, including
|
||
// without limitation the rights to use, copy, modify, merge, publish,
|
||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||
// persons to whom the Software is furnished to do so, subject to the
|
||
// following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included
|
||
// in all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
|
||
// UTILITY
|
||
var util = require('util');
|
||
var shims = require('_shims');
|
||
var pSlice = Array.prototype.slice;
|
||
|
||
// 1. The assert module provides functions that throw
|
||
// AssertionError's when particular conditions are not met. The
|
||
// assert module must conform to the following interface.
|
||
|
||
var assert = module.exports = ok;
|
||
|
||
// 2. The AssertionError is defined in assert.
|
||
// new assert.AssertionError({ message: message,
|
||
// actual: actual,
|
||
// expected: expected })
|
||
|
||
assert.AssertionError = function AssertionError(options) {
|
||
this.name = 'AssertionError';
|
||
this.actual = options.actual;
|
||
this.expected = options.expected;
|
||
this.operator = options.operator;
|
||
this.message = options.message || getMessage(this);
|
||
};
|
||
|
||
// assert.AssertionError instanceof Error
|
||
util.inherits(assert.AssertionError, Error);
|
||
|
||
function replacer(key, value) {
|
||
if (util.isUndefined(value)) {
|
||
return '' + value;
|
||
}
|
||
if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
|
||
return value.toString();
|
||
}
|
||
if (util.isFunction(value) || util.isRegExp(value)) {
|
||
return value.toString();
|
||
}
|
||
return value;
|
||
}
|
||
|
||
function truncate(s, n) {
|
||
if (util.isString(s)) {
|
||
return s.length < n ? s : s.slice(0, n);
|
||
} else {
|
||
return s;
|
||
}
|
||
}
|
||
|
||
function getMessage(self) {
|
||
return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
|
||
self.operator + ' ' +
|
||
truncate(JSON.stringify(self.expected, replacer), 128);
|
||
}
|
||
|
||
// At present only the three keys mentioned above are used and
|
||
// understood by the spec. Implementations or sub modules can pass
|
||
// other keys to the AssertionError's constructor - they will be
|
||
// ignored.
|
||
|
||
// 3. All of the following functions must throw an AssertionError
|
||
// when a corresponding condition is not met, with a message that
|
||
// may be undefined if not provided. All assertion methods provide
|
||
// both the actual and expected values to the assertion error for
|
||
// display purposes.
|
||
|
||
function fail(actual, expected, message, operator, stackStartFunction) {
|
||
throw new assert.AssertionError({
|
||
message: message,
|
||
actual: actual,
|
||
expected: expected,
|
||
operator: operator,
|
||
stackStartFunction: stackStartFunction
|
||
});
|
||
}
|
||
|
||
// EXTENSION! allows for well behaved errors defined elsewhere.
|
||
assert.fail = fail;
|
||
|
||
// 4. Pure assertion tests whether a value is truthy, as determined
|
||
// by !!guard.
|
||
// assert.ok(guard, message_opt);
|
||
// This statement is equivalent to assert.equal(true, !!guard,
|
||
// message_opt);. To test strictly for the value true, use
|
||
// assert.strictEqual(true, guard, message_opt);.
|
||
|
||
function ok(value, message) {
|
||
if (!value) fail(value, true, message, '==', assert.ok);
|
||
}
|
||
assert.ok = ok;
|
||
|
||
// 5. The equality assertion tests shallow, coercive equality with
|
||
// ==.
|
||
// assert.equal(actual, expected, message_opt);
|
||
|
||
assert.equal = function equal(actual, expected, message) {
|
||
if (actual != expected) fail(actual, expected, message, '==', assert.equal);
|
||
};
|
||
|
||
// 6. The non-equality assertion tests for whether two objects are not equal
|
||
// with != assert.notEqual(actual, expected, message_opt);
|
||
|
||
assert.notEqual = function notEqual(actual, expected, message) {
|
||
if (actual == expected) {
|
||
fail(actual, expected, message, '!=', assert.notEqual);
|
||
}
|
||
};
|
||
|
||
// 7. The equivalence assertion tests a deep equality relation.
|
||
// assert.deepEqual(actual, expected, message_opt);
|
||
|
||
assert.deepEqual = function deepEqual(actual, expected, message) {
|
||
if (!_deepEqual(actual, expected)) {
|
||
fail(actual, expected, message, 'deepEqual', assert.deepEqual);
|
||
}
|
||
};
|
||
|
||
function _deepEqual(actual, expected) {
|
||
// 7.1. All identical values are equivalent, as determined by ===.
|
||
if (actual === expected) {
|
||
return true;
|
||
|
||
} else if (util.isBuffer(actual) && util.isBuffer(expected)) {
|
||
if (actual.length != expected.length) return false;
|
||
|
||
for (var i = 0; i < actual.length; i++) {
|
||
if (actual[i] !== expected[i]) return false;
|
||
}
|
||
|
||
return true;
|
||
|
||
// 7.2. If the expected value is a Date object, the actual value is
|
||
// equivalent if it is also a Date object that refers to the same time.
|
||
} else if (util.isDate(actual) && util.isDate(expected)) {
|
||
return actual.getTime() === expected.getTime();
|
||
|
||
// 7.3 If the expected value is a RegExp object, the actual value is
|
||
// equivalent if it is also a RegExp object with the same source and
|
||
// properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
|
||
} else if (util.isRegExp(actual) && util.isRegExp(expected)) {
|
||
return actual.source === expected.source &&
|
||
actual.global === expected.global &&
|
||
actual.multiline === expected.multiline &&
|
||
actual.lastIndex === expected.lastIndex &&
|
||
actual.ignoreCase === expected.ignoreCase;
|
||
|
||
// 7.4. Other pairs that do not both pass typeof value == 'object',
|
||
// equivalence is determined by ==.
|
||
} else if (!util.isObject(actual) && !util.isObject(expected)) {
|
||
return actual == expected;
|
||
|
||
// 7.5 For all other Object pairs, including Array objects, equivalence is
|
||
// determined by having the same number of owned properties (as verified
|
||
// with Object.prototype.hasOwnProperty.call), the same set of keys
|
||
// (although not necessarily the same order), equivalent values for every
|
||
// corresponding key, and an identical 'prototype' property. Note: this
|
||
// accounts for both named and indexed properties on Arrays.
|
||
} else {
|
||
return objEquiv(actual, expected);
|
||
}
|
||
}
|
||
|
||
function isArguments(object) {
|
||
return Object.prototype.toString.call(object) == '[object Arguments]';
|
||
}
|
||
|
||
function objEquiv(a, b) {
|
||
if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
|
||
return false;
|
||
// an identical 'prototype' property.
|
||
if (a.prototype !== b.prototype) return false;
|
||
//~~~I've managed to break Object.keys through screwy arguments passing.
|
||
// Converting to array solves the problem.
|
||
if (isArguments(a)) {
|
||
if (!isArguments(b)) {
|
||
return false;
|
||
}
|
||
a = pSlice.call(a);
|
||
b = pSlice.call(b);
|
||
return _deepEqual(a, b);
|
||
}
|
||
try {
|
||
var ka = shims.keys(a),
|
||
kb = shims.keys(b),
|
||
key, i;
|
||
} catch (e) {//happens when one is a string literal and the other isn't
|
||
return false;
|
||
}
|
||
// having the same number of owned properties (keys incorporates
|
||
// hasOwnProperty)
|
||
if (ka.length != kb.length)
|
||
return false;
|
||
//the same set of keys (although not necessarily the same order),
|
||
ka.sort();
|
||
kb.sort();
|
||
//~~~cheap key test
|
||
for (i = ka.length - 1; i >= 0; i--) {
|
||
if (ka[i] != kb[i])
|
||
return false;
|
||
}
|
||
//equivalent values for every corresponding key, and
|
||
//~~~possibly expensive deep test
|
||
for (i = ka.length - 1; i >= 0; i--) {
|
||
key = ka[i];
|
||
if (!_deepEqual(a[key], b[key])) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// 8. The non-equivalence assertion tests for any deep inequality.
|
||
// assert.notDeepEqual(actual, expected, message_opt);
|
||
|
||
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
|
||
if (_deepEqual(actual, expected)) {
|
||
fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
|
||
}
|
||
};
|
||
|
||
// 9. The strict equality assertion tests strict equality, as determined by ===.
|
||
// assert.strictEqual(actual, expected, message_opt);
|
||
|
||
assert.strictEqual = function strictEqual(actual, expected, message) {
|
||
if (actual !== expected) {
|
||
fail(actual, expected, message, '===', assert.strictEqual);
|
||
}
|
||
};
|
||
|
||
// 10. The strict non-equality assertion tests for strict inequality, as
|
||
// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
|
||
|
||
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
|
||
if (actual === expected) {
|
||
fail(actual, expected, message, '!==', assert.notStrictEqual);
|
||
}
|
||
};
|
||
|
||
function expectedException(actual, expected) {
|
||
if (!actual || !expected) {
|
||
return false;
|
||
}
|
||
|
||
if (Object.prototype.toString.call(expected) == '[object RegExp]') {
|
||
return expected.test(actual);
|
||
} else if (actual instanceof expected) {
|
||
return true;
|
||
} else if (expected.call({}, actual) === true) {
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
function _throws(shouldThrow, block, expected, message) {
|
||
var actual;
|
||
|
||
if (util.isString(expected)) {
|
||
message = expected;
|
||
expected = null;
|
||
}
|
||
|
||
try {
|
||
block();
|
||
} catch (e) {
|
||
actual = e;
|
||
}
|
||
|
||
message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
|
||
(message ? ' ' + message : '.');
|
||
|
||
if (shouldThrow && !actual) {
|
||
fail(actual, expected, 'Missing expected exception' + message);
|
||
}
|
||
|
||
if (!shouldThrow && expectedException(actual, expected)) {
|
||
fail(actual, expected, 'Got unwanted exception' + message);
|
||
}
|
||
|
||
if ((shouldThrow && actual && expected &&
|
||
!expectedException(actual, expected)) || (!shouldThrow && actual)) {
|
||
throw actual;
|
||
}
|
||
}
|
||
|
||
// 11. Expected to throw an error:
|
||
// assert.throws(block, Error_opt, message_opt);
|
||
|
||
assert.throws = function(block, /*optional*/error, /*optional*/message) {
|
||
_throws.apply(this, [true].concat(pSlice.call(arguments)));
|
||
};
|
||
|
||
// EXTENSION! This is annoying to write outside this module.
|
||
assert.doesNotThrow = function(block, /*optional*/message) {
|
||
_throws.apply(this, [false].concat(pSlice.call(arguments)));
|
||
};
|
||
|
||
assert.ifError = function(err) { if (err) {throw err;}};
|
||
},{"_shims":5,"util":7}],7:[function(require,module,exports){
|
||
// Copyright Joyent, Inc. and other Node contributors.
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||
// copy of this software and associated documentation files (the
|
||
// "Software"), to deal in the Software without restriction, including
|
||
// without limitation the rights to use, copy, modify, merge, publish,
|
||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||
// persons to whom the Software is furnished to do so, subject to the
|
||
// following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included
|
||
// in all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
|
||
var shims = require('_shims');
|
||
|
||
var formatRegExp = /%[sdj%]/g;
|
||
exports.format = function(f) {
|
||
if (!isString(f)) {
|
||
var objects = [];
|
||
for (var i = 0; i < arguments.length; i++) {
|
||
objects.push(inspect(arguments[i]));
|
||
}
|
||
return objects.join(' ');
|
||
}
|
||
|
||
var i = 1;
|
||
var args = arguments;
|
||
var len = args.length;
|
||
var str = String(f).replace(formatRegExp, function(x) {
|
||
if (x === '%') return '%';
|
||
if (i >= len) return x;
|
||
switch (x) {
|
||
case '%s': return String(args[i++]);
|
||
case '%d': return Number(args[i++]);
|
||
case '%j':
|
||
try {
|
||
return JSON.stringify(args[i++]);
|
||
} catch (_) {
|
||
return '[Circular]';
|
||
}
|
||
default:
|
||
return x;
|
||
}
|
||
});
|
||
for (var x = args[i]; i < len; x = args[++i]) {
|
||
if (isNull(x) || !isObject(x)) {
|
||
str += ' ' + x;
|
||
} else {
|
||
str += ' ' + inspect(x);
|
||
}
|
||
}
|
||
return str;
|
||
};
|
||
|
||
/**
|
||
* Echos the value of a value. Trys to print the value out
|
||
* in the best way possible given the different types.
|
||
*
|
||
* @param {Object} obj The object to print out.
|
||
* @param {Object} opts Optional options object that alters the output.
|
||
*/
|
||
/* legacy: obj, showHidden, depth, colors*/
|
||
function inspect(obj, opts) {
|
||
// default options
|
||
var ctx = {
|
||
seen: [],
|
||
stylize: stylizeNoColor
|
||
};
|
||
// legacy...
|
||
if (arguments.length >= 3) ctx.depth = arguments[2];
|
||
if (arguments.length >= 4) ctx.colors = arguments[3];
|
||
if (isBoolean(opts)) {
|
||
// legacy...
|
||
ctx.showHidden = opts;
|
||
} else if (opts) {
|
||
// got an "options" object
|
||
exports._extend(ctx, opts);
|
||
}
|
||
// set default options
|
||
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
||
if (isUndefined(ctx.depth)) ctx.depth = 2;
|
||
if (isUndefined(ctx.colors)) ctx.colors = false;
|
||
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
||
if (ctx.colors) ctx.stylize = stylizeWithColor;
|
||
return formatValue(ctx, obj, ctx.depth);
|
||
}
|
||
exports.inspect = inspect;
|
||
|
||
|
||
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
||
inspect.colors = {
|
||
'bold' : [1, 22],
|
||
'italic' : [3, 23],
|
||
'underline' : [4, 24],
|
||
'inverse' : [7, 27],
|
||
'white' : [37, 39],
|
||
'grey' : [90, 39],
|
||
'black' : [30, 39],
|
||
'blue' : [34, 39],
|
||
'cyan' : [36, 39],
|
||
'green' : [32, 39],
|
||
'magenta' : [35, 39],
|
||
'red' : [31, 39],
|
||
'yellow' : [33, 39]
|
||
};
|
||
|
||
// Don't use 'blue' not visible on cmd.exe
|
||
inspect.styles = {
|
||
'special': 'cyan',
|
||
'number': 'yellow',
|
||
'boolean': 'yellow',
|
||
'undefined': 'grey',
|
||
'null': 'bold',
|
||
'string': 'green',
|
||
'date': 'magenta',
|
||
// "name": intentionally not styling
|
||
'regexp': 'red'
|
||
};
|
||
|
||
|
||
function stylizeWithColor(str, styleType) {
|
||
var style = inspect.styles[styleType];
|
||
|
||
if (style) {
|
||
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
|
||
'\u001b[' + inspect.colors[style][1] + 'm';
|
||
} else {
|
||
return str;
|
||
}
|
||
}
|
||
|
||
|
||
function stylizeNoColor(str, styleType) {
|
||
return str;
|
||
}
|
||
|
||
|
||
function arrayToHash(array) {
|
||
var hash = {};
|
||
|
||
shims.forEach(array, function(val, idx) {
|
||
hash[val] = true;
|
||
});
|
||
|
||
return hash;
|
||
}
|
||
|
||
|
||
function formatValue(ctx, value, recurseTimes) {
|
||
// Provide a hook for user-specified inspect functions.
|
||
// Check that value is an object with an inspect function on it
|
||
if (ctx.customInspect &&
|
||
value &&
|
||
isFunction(value.inspect) &&
|
||
// Filter out the util module, it's inspect function is special
|
||
value.inspect !== exports.inspect &&
|
||
// Also filter out any prototype objects using the circular check.
|
||
!(value.constructor && value.constructor.prototype === value)) {
|
||
var ret = value.inspect(recurseTimes);
|
||
if (!isString(ret)) {
|
||
ret = formatValue(ctx, ret, recurseTimes);
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Primitive types cannot have properties
|
||
var primitive = formatPrimitive(ctx, value);
|
||
if (primitive) {
|
||
return primitive;
|
||
}
|
||
|
||
// Look up the keys of the object.
|
||
var keys = shims.keys(value);
|
||
var visibleKeys = arrayToHash(keys);
|
||
|
||
if (ctx.showHidden) {
|
||
keys = shims.getOwnPropertyNames(value);
|
||
}
|
||
|
||
// Some type of object without properties can be shortcutted.
|
||
if (keys.length === 0) {
|
||
if (isFunction(value)) {
|
||
var name = value.name ? ': ' + value.name : '';
|
||
return ctx.stylize('[Function' + name + ']', 'special');
|
||
}
|
||
if (isRegExp(value)) {
|
||
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
||
}
|
||
if (isDate(value)) {
|
||
return ctx.stylize(Date.prototype.toString.call(value), 'date');
|
||
}
|
||
if (isError(value)) {
|
||
return formatError(value);
|
||
}
|
||
}
|
||
|
||
var base = '', array = false, braces = ['{', '}'];
|
||
|
||
// Make Array say that they are Array
|
||
if (isArray(value)) {
|
||
array = true;
|
||
braces = ['[', ']'];
|
||
}
|
||
|
||
// Make functions say that they are functions
|
||
if (isFunction(value)) {
|
||
var n = value.name ? ': ' + value.name : '';
|
||
base = ' [Function' + n + ']';
|
||
}
|
||
|
||
// Make RegExps say that they are RegExps
|
||
if (isRegExp(value)) {
|
||
base = ' ' + RegExp.prototype.toString.call(value);
|
||
}
|
||
|
||
// Make dates with properties first say the date
|
||
if (isDate(value)) {
|
||
base = ' ' + Date.prototype.toUTCString.call(value);
|
||
}
|
||
|
||
// Make error with message first say the error
|
||
if (isError(value)) {
|
||
base = ' ' + formatError(value);
|
||
}
|
||
|
||
if (keys.length === 0 && (!array || value.length == 0)) {
|
||
return braces[0] + base + braces[1];
|
||
}
|
||
|
||
if (recurseTimes < 0) {
|
||
if (isRegExp(value)) {
|
||
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
||
} else {
|
||
return ctx.stylize('[Object]', 'special');
|
||
}
|
||
}
|
||
|
||
ctx.seen.push(value);
|
||
|
||
var output;
|
||
if (array) {
|
||
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
||
} else {
|
||
output = keys.map(function(key) {
|
||
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
||
});
|
||
}
|
||
|
||
ctx.seen.pop();
|
||
|
||
return reduceToSingleString(output, base, braces);
|
||
}
|
||
|
||
|
||
function formatPrimitive(ctx, value) {
|
||
if (isUndefined(value))
|
||
return ctx.stylize('undefined', 'undefined');
|
||
if (isString(value)) {
|
||
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
|
||
.replace(/'/g, "\\'")
|
||
.replace(/\\"/g, '"') + '\'';
|
||
return ctx.stylize(simple, 'string');
|
||
}
|
||
if (isNumber(value))
|
||
return ctx.stylize('' + value, 'number');
|
||
if (isBoolean(value))
|
||
return ctx.stylize('' + value, 'boolean');
|
||
// For some reason typeof null is "object", so special case here.
|
||
if (isNull(value))
|
||
return ctx.stylize('null', 'null');
|
||
}
|
||
|
||
|
||
function formatError(value) {
|
||
return '[' + Error.prototype.toString.call(value) + ']';
|
||
}
|
||
|
||
|
||
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
||
var output = [];
|
||
for (var i = 0, l = value.length; i < l; ++i) {
|
||
if (hasOwnProperty(value, String(i))) {
|
||
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
||
String(i), true));
|
||
} else {
|
||
output.push('');
|
||
}
|
||
}
|
||
|
||
shims.forEach(keys, function(key) {
|
||
if (!key.match(/^\d+$/)) {
|
||
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
||
key, true));
|
||
}
|
||
});
|
||
return output;
|
||
}
|
||
|
||
|
||
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
|
||
var name, str, desc;
|
||
desc = shims.getOwnPropertyDescriptor(value, key) || { value: value[key] };
|
||
if (desc.get) {
|
||
if (desc.set) {
|
||
str = ctx.stylize('[Getter/Setter]', 'special');
|
||
} else {
|
||
str = ctx.stylize('[Getter]', 'special');
|
||
}
|
||
} else {
|
||
if (desc.set) {
|
||
str = ctx.stylize('[Setter]', 'special');
|
||
}
|
||
}
|
||
|
||
if (!hasOwnProperty(visibleKeys, key)) {
|
||
name = '[' + key + ']';
|
||
}
|
||
if (!str) {
|
||
if (shims.indexOf(ctx.seen, desc.value) < 0) {
|
||
if (isNull(recurseTimes)) {
|
||
str = formatValue(ctx, desc.value, null);
|
||
} else {
|
||
str = formatValue(ctx, desc.value, recurseTimes - 1);
|
||
}
|
||
if (str.indexOf('\n') > -1) {
|
||
if (array) {
|
||
str = str.split('\n').map(function(line) {
|
||
return ' ' + line;
|
||
}).join('\n').substr(2);
|
||
} else {
|
||
str = '\n' + str.split('\n').map(function(line) {
|
||
return ' ' + line;
|
||
}).join('\n');
|
||
}
|
||
}
|
||
} else {
|
||
str = ctx.stylize('[Circular]', 'special');
|
||
}
|
||
}
|
||
if (isUndefined(name)) {
|
||
if (array && key.match(/^\d+$/)) {
|
||
return str;
|
||
}
|
||
name = JSON.stringify('' + key);
|
||
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
||
name = name.substr(1, name.length - 2);
|
||
name = ctx.stylize(name, 'name');
|
||
} else {
|
||
name = name.replace(/'/g, "\\'")
|
||
.replace(/\\"/g, '"')
|
||
.replace(/(^"|"$)/g, "'");
|
||
name = ctx.stylize(name, 'string');
|
||
}
|
||
}
|
||
|
||
return name + ': ' + str;
|
||
}
|
||
|
||
|
||
function reduceToSingleString(output, base, braces) {
|
||
var numLinesEst = 0;
|
||
var length = shims.reduce(output, function(prev, cur) {
|
||
numLinesEst++;
|
||
if (cur.indexOf('\n') >= 0) numLinesEst++;
|
||
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
|
||
}, 0);
|
||
|
||
if (length > 60) {
|
||
return braces[0] +
|
||
(base === '' ? '' : base + '\n ') +
|
||
' ' +
|
||
output.join(',\n ') +
|
||
' ' +
|
||
braces[1];
|
||
}
|
||
|
||
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
||
}
|
||
|
||
|
||
// NOTE: These type checking functions intentionally don't use `instanceof`
|
||
// because it is fragile and can be easily faked with `Object.create()`.
|
||
function isArray(ar) {
|
||
return shims.isArray(ar);
|
||
}
|
||
exports.isArray = isArray;
|
||
|
||
function isBoolean(arg) {
|
||
return typeof arg === 'boolean';
|
||
}
|
||
exports.isBoolean = isBoolean;
|
||
|
||
function isNull(arg) {
|
||
return arg === null;
|
||
}
|
||
exports.isNull = isNull;
|
||
|
||
function isNullOrUndefined(arg) {
|
||
return arg == null;
|
||
}
|
||
exports.isNullOrUndefined = isNullOrUndefined;
|
||
|
||
function isNumber(arg) {
|
||
return typeof arg === 'number';
|
||
}
|
||
exports.isNumber = isNumber;
|
||
|
||
function isString(arg) {
|
||
return typeof arg === 'string';
|
||
}
|
||
exports.isString = isString;
|
||
|
||
function isSymbol(arg) {
|
||
return typeof arg === 'symbol';
|
||
}
|
||
exports.isSymbol = isSymbol;
|
||
|
||
function isUndefined(arg) {
|
||
return arg === void 0;
|
||
}
|
||
exports.isUndefined = isUndefined;
|
||
|
||
function isRegExp(re) {
|
||
return isObject(re) && objectToString(re) === '[object RegExp]';
|
||
}
|
||
exports.isRegExp = isRegExp;
|
||
|
||
function isObject(arg) {
|
||
return typeof arg === 'object' && arg;
|
||
}
|
||
exports.isObject = isObject;
|
||
|
||
function isDate(d) {
|
||
return isObject(d) && objectToString(d) === '[object Date]';
|
||
}
|
||
exports.isDate = isDate;
|
||
|
||
function isError(e) {
|
||
return isObject(e) && objectToString(e) === '[object Error]';
|
||
}
|
||
exports.isError = isError;
|
||
|
||
function isFunction(arg) {
|
||
return typeof arg === 'function';
|
||
}
|
||
exports.isFunction = isFunction;
|
||
|
||
function isPrimitive(arg) {
|
||
return arg === null ||
|
||
typeof arg === 'boolean' ||
|
||
typeof arg === 'number' ||
|
||
typeof arg === 'string' ||
|
||
typeof arg === 'symbol' || // ES6 symbol
|
||
typeof arg === 'undefined';
|
||
}
|
||
exports.isPrimitive = isPrimitive;
|
||
|
||
function isBuffer(arg) {
|
||
return arg instanceof Buffer;
|
||
}
|
||
exports.isBuffer = isBuffer;
|
||
|
||
function objectToString(o) {
|
||
return Object.prototype.toString.call(o);
|
||
}
|
||
|
||
|
||
function pad(n) {
|
||
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
||
}
|
||
|
||
|
||
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
||
'Oct', 'Nov', 'Dec'];
|
||
|
||
// 26 Feb 16:19:34
|
||
function timestamp() {
|
||
var d = new Date();
|
||
var time = [pad(d.getHours()),
|
||
pad(d.getMinutes()),
|
||
pad(d.getSeconds())].join(':');
|
||
return [d.getDate(), months[d.getMonth()], time].join(' ');
|
||
}
|
||
|
||
|
||
// log is just a thin wrapper to console.log that prepends a timestamp
|
||
exports.log = function() {
|
||
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
|
||
};
|
||
|
||
|
||
/**
|
||
* Inherit the prototype methods from one constructor into another.
|
||
*
|
||
* The Function.prototype.inherits from lang.js rewritten as a standalone
|
||
* function (not on Function.prototype). NOTE: If this file is to be loaded
|
||
* during bootstrapping this function needs to be rewritten using some native
|
||
* functions as prototype setup using normal JavaScript does not work as
|
||
* expected during bootstrapping (see mirror.js in r114903).
|
||
*
|
||
* @param {function} ctor Constructor function which needs to inherit the
|
||
* prototype.
|
||
* @param {function} superCtor Constructor function to inherit prototype from.
|
||
*/
|
||
exports.inherits = function(ctor, superCtor) {
|
||
ctor.super_ = superCtor;
|
||
ctor.prototype = shims.create(superCtor.prototype, {
|
||
constructor: {
|
||
value: ctor,
|
||
enumerable: false,
|
||
writable: true,
|
||
configurable: true
|
||
}
|
||
});
|
||
};
|
||
|
||
exports._extend = function(origin, add) {
|
||
// Don't do anything if add isn't an object
|
||
if (!add || !isObject(add)) return origin;
|
||
|
||
var keys = shims.keys(add);
|
||
var i = keys.length;
|
||
while (i--) {
|
||
origin[keys[i]] = add[keys[i]];
|
||
}
|
||
return origin;
|
||
};
|
||
|
||
function hasOwnProperty(obj, prop) {
|
||
return Object.prototype.hasOwnProperty.call(obj, prop);
|
||
}
|
||
|
||
},{"_shims":5}]},{},[])
|
||
;;module.exports=require("buffer-browserify")
|
||
|
||
},{}],10:[function(require,module,exports){
|
||
|
||
/**
|
||
* Expose `debug()` as the module.
|
||
*/
|
||
|
||
module.exports = debug;
|
||
|
||
/**
|
||
* Create a debugger with the given `name`.
|
||
*
|
||
* @param {String} name
|
||
* @return {Type}
|
||
* @api public
|
||
*/
|
||
|
||
function debug(name) {
|
||
if (!debug.enabled(name)) return function(){};
|
||
|
||
return function(fmt){
|
||
fmt = coerce(fmt);
|
||
|
||
var curr = new Date;
|
||
var ms = curr - (debug[name] || curr);
|
||
debug[name] = curr;
|
||
|
||
fmt = name
|
||
+ ' '
|
||
+ fmt
|
||
+ ' +' + debug.humanize(ms);
|
||
|
||
// This hackery is required for IE8
|
||
// where `console.log` doesn't have 'apply'
|
||
window.console
|
||
&& console.log
|
||
&& Function.prototype.apply.call(console.log, console, arguments);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* The currently active debug mode names.
|
||
*/
|
||
|
||
debug.names = [];
|
||
debug.skips = [];
|
||
|
||
/**
|
||
* Enables a debug mode by name. This can include modes
|
||
* separated by a colon and wildcards.
|
||
*
|
||
* @param {String} name
|
||
* @api public
|
||
*/
|
||
|
||
debug.enable = function(name) {
|
||
try {
|
||
localStorage.debug = name;
|
||
} catch(e){}
|
||
|
||
var split = (name || '').split(/[\s,]+/)
|
||
, len = split.length;
|
||
|
||
for (var i = 0; i < len; i++) {
|
||
name = split[i].replace('*', '.*?');
|
||
if (name[0] === '-') {
|
||
debug.skips.push(new RegExp('^' + name.substr(1) + '$'));
|
||
}
|
||
else {
|
||
debug.names.push(new RegExp('^' + name + '$'));
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Disable debug output.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
debug.disable = function(){
|
||
debug.enable('');
|
||
};
|
||
|
||
/**
|
||
* Humanize the given `ms`.
|
||
*
|
||
* @param {Number} m
|
||
* @return {String}
|
||
* @api private
|
||
*/
|
||
|
||
debug.humanize = function(ms) {
|
||
var sec = 1000
|
||
, min = 60 * 1000
|
||
, hour = 60 * min;
|
||
|
||
if (ms >= hour) return (ms / hour).toFixed(1) + 'h';
|
||
if (ms >= min) return (ms / min).toFixed(1) + 'm';
|
||
if (ms >= sec) return (ms / sec | 0) + 's';
|
||
return ms + 'ms';
|
||
};
|
||
|
||
/**
|
||
* Returns true if the given mode name is enabled, false otherwise.
|
||
*
|
||
* @param {String} name
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/
|
||
|
||
debug.enabled = function(name) {
|
||
for (var i = 0, len = debug.skips.length; i < len; i++) {
|
||
if (debug.skips[i].test(name)) {
|
||
return false;
|
||
}
|
||
}
|
||
for (var i = 0, len = debug.names.length; i < len; i++) {
|
||
if (debug.names[i].test(name)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
|
||
/**
|
||
* Coerce `val`.
|
||
*/
|
||
|
||
function coerce(val) {
|
||
if (val instanceof Error) return val.stack || val.message;
|
||
return val;
|
||
}
|
||
|
||
// persist
|
||
|
||
try {
|
||
if (window.localStorage) debug.enable(localStorage.debug);
|
||
} catch(e){}
|
||
|
||
},{}],11:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var index = require('indexof');
|
||
|
||
/**
|
||
* Expose `Emitter`.
|
||
*/
|
||
|
||
module.exports = Emitter;
|
||
|
||
/**
|
||
* Initialize a new `Emitter`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function Emitter(obj) {
|
||
if (obj) return mixin(obj);
|
||
};
|
||
|
||
/**
|
||
* Mixin the emitter properties.
|
||
*
|
||
* @param {Object} obj
|
||
* @return {Object}
|
||
* @api private
|
||
*/
|
||
|
||
function mixin(obj) {
|
||
for (var key in Emitter.prototype) {
|
||
obj[key] = Emitter.prototype[key];
|
||
}
|
||
return obj;
|
||
}
|
||
|
||
/**
|
||
* Listen on the given `event` with `fn`.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.on = function(event, fn){
|
||
this._callbacks = this._callbacks || {};
|
||
(this._callbacks[event] = this._callbacks[event] || [])
|
||
.push(fn);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Adds an `event` listener that will be invoked a single
|
||
* time then automatically removed.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.once = function(event, fn){
|
||
var self = this;
|
||
this._callbacks = this._callbacks || {};
|
||
|
||
function on() {
|
||
self.off(event, on);
|
||
fn.apply(this, arguments);
|
||
}
|
||
|
||
fn._off = on;
|
||
this.on(event, on);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Remove the given callback for `event` or all
|
||
* registered callbacks.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.off =
|
||
Emitter.prototype.removeListener =
|
||
Emitter.prototype.removeAllListeners = function(event, fn){
|
||
this._callbacks = this._callbacks || {};
|
||
|
||
// all
|
||
if (0 == arguments.length) {
|
||
this._callbacks = {};
|
||
return this;
|
||
}
|
||
|
||
// specific event
|
||
var callbacks = this._callbacks[event];
|
||
if (!callbacks) return this;
|
||
|
||
// remove all handlers
|
||
if (1 == arguments.length) {
|
||
delete this._callbacks[event];
|
||
return this;
|
||
}
|
||
|
||
// remove specific handler
|
||
var i = index(callbacks, fn._off || fn);
|
||
if (~i) callbacks.splice(i, 1);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Emit `event` with the given args.
|
||
*
|
||
* @param {String} event
|
||
* @param {Mixed} ...
|
||
* @return {Emitter}
|
||
*/
|
||
|
||
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;
|
||
};
|
||
|
||
/**
|
||
* Return array of callbacks for `event`.
|
||
*
|
||
* @param {String} event
|
||
* @return {Array}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.listeners = function(event){
|
||
this._callbacks = this._callbacks || {};
|
||
return this._callbacks[event] || [];
|
||
};
|
||
|
||
/**
|
||
* Check if this emitter has `event` handlers.
|
||
*
|
||
* @param {String} event
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.hasListeners = function(event){
|
||
return !! this.listeners(event).length;
|
||
};
|
||
|
||
},{"indexof":35}],12:[function(require,module,exports){
|
||
|
||
module.exports = require('./lib/');
|
||
|
||
},{"./lib/":14}],13:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var Emitter = require('emitter');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = Emitter;
|
||
|
||
/**
|
||
* Compatibility with `WebSocket#addEventListener`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.addEventListener = Emitter.prototype.on;
|
||
|
||
/**
|
||
* Compatibility with `WebSocket#removeEventListener`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.removeEventListener = Emitter.prototype.off;
|
||
|
||
/**
|
||
* Node-compatible `EventEmitter#removeListener`
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Emitter.prototype.removeListener = Emitter.prototype.off;
|
||
|
||
},{"emitter":11}],14:[function(require,module,exports){
|
||
|
||
module.exports = require('./socket');
|
||
|
||
/**
|
||
* Exports parser
|
||
*
|
||
* @api public
|
||
*
|
||
*/
|
||
module.exports.parser = require('engine.io-parser');
|
||
|
||
},{"./socket":15,"engine.io-parser":25}],15:[function(require,module,exports){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var util = require('./util');
|
||
var transports = require('./transports');
|
||
var Emitter = require('./emitter');
|
||
var debug = require('debug')('engine.io-client:socket');
|
||
var index = require('indexof');
|
||
var parser = require('engine.io-parser');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = Socket;
|
||
|
||
/**
|
||
* Global reference.
|
||
*/
|
||
|
||
var global = require('global');
|
||
|
||
/**
|
||
* Noop function.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
function noop(){}
|
||
|
||
/**
|
||
* Socket constructor.
|
||
*
|
||
* @param {String|Object} uri or options
|
||
* @param {Object} options
|
||
* @api public
|
||
*/
|
||
|
||
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 = util.parseUri(uri);
|
||
opts.host = uri.host;
|
||
opts.secure = uri.protocol == 'https' || uri.protocol == 'wss';
|
||
opts.port = uri.port;
|
||
if (uri.query) opts.query = uri.query;
|
||
}
|
||
|
||
this.secure = null != opts.secure ? opts.secure :
|
||
(global.location && 'https:' == location.protocol);
|
||
|
||
if (opts.host) {
|
||
var pieces = opts.host.split(':');
|
||
opts.hostname = pieces.shift();
|
||
if (pieces.length) opts.port = pieces.pop();
|
||
}
|
||
|
||
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 = util.qsParse(this.query);
|
||
this.upgrade = false !== opts.upgrade;
|
||
this.path = (opts.path || '/engine.io').replace(/\/$/, '') + '/';
|
||
this.forceJSONP = !!opts.forceJSONP;
|
||
this.forceBase64 = !!opts.forceBase64;
|
||
this.timestampParam = opts.timestampParam || 't';
|
||
this.timestampRequests = opts.timestampRequests;
|
||
this.flashPath = opts.flashPath || '';
|
||
this.transports = opts.transports || ['polling', 'websocket', 'flashsocket'];
|
||
this.readyState = '';
|
||
this.writeBuffer = [];
|
||
this.callbackBuffer = [];
|
||
this.policyPort = opts.policyPort || 843;
|
||
this.rememberUpgrade = opts.rememberUpgrade || false;
|
||
this.open();
|
||
this.binaryType = null;
|
||
this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;
|
||
}
|
||
|
||
Socket.priorWebsocketSuccess = false;
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Socket.prototype);
|
||
|
||
/**
|
||
* Protocol version.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Socket.protocol = parser.protocol; // this is an int
|
||
|
||
/**
|
||
* Expose deps for legacy compatibility
|
||
* and standalone browser access.
|
||
*/
|
||
|
||
Socket.Socket = Socket;
|
||
Socket.Transport = require('./transport');
|
||
Socket.Emitter = require('./emitter');
|
||
Socket.transports = require('./transports');
|
||
Socket.util = require('./util');
|
||
Socket.parser = require('engine.io-parser');
|
||
|
||
/**
|
||
* Creates transport of the given type.
|
||
*
|
||
* @param {String} transport name
|
||
* @return {Transport}
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.createTransport = function (name) {
|
||
debug('creating transport "%s"', name);
|
||
var query = clone(this.query);
|
||
|
||
// append engine.io protocol identifier
|
||
query.EIO = parser.protocol;
|
||
|
||
// transport name
|
||
query.transport = name;
|
||
|
||
// session id if we already have one
|
||
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,
|
||
forceBase64: this.forceBase64,
|
||
timestampRequests: this.timestampRequests,
|
||
timestampParam: this.timestampParam,
|
||
flashPath: this.flashPath,
|
||
policyPort: this.policyPort,
|
||
socket: this
|
||
});
|
||
|
||
return transport;
|
||
};
|
||
|
||
function clone (obj) {
|
||
var o = {};
|
||
for (var i in obj) {
|
||
if (obj.hasOwnProperty(i)) {
|
||
o[i] = obj[i];
|
||
}
|
||
}
|
||
return o;
|
||
}
|
||
|
||
/**
|
||
* Initializes transport to use and starts probe.
|
||
*
|
||
* @api private
|
||
*/
|
||
Socket.prototype.open = function () {
|
||
var transport;
|
||
if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') != -1) {
|
||
transport = 'websocket';
|
||
} else {
|
||
transport = this.transports[0];
|
||
}
|
||
this.readyState = 'opening';
|
||
var transport = this.createTransport(transport);
|
||
transport.open();
|
||
this.setTransport(transport);
|
||
};
|
||
|
||
/**
|
||
* Sets the current transport. Disables the existing one (if any).
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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();
|
||
}
|
||
|
||
// set up transport
|
||
this.transport = transport;
|
||
|
||
// set up transport listeners
|
||
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');
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Probes a transport.
|
||
*
|
||
* @param {String} transport name
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.probe = function (name) {
|
||
debug('probing transport "%s"', name);
|
||
var transport = this.createTransport(name, { probe: 1 })
|
||
, failed = false
|
||
, self = this;
|
||
|
||
Socket.priorWebsocketSuccess = false;
|
||
|
||
transport.once('open', function () {
|
||
if (this.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);
|
||
Socket.priorWebsocketSuccess = 'websocket' == transport.name;
|
||
|
||
debug('pausing current transport "%s"', self.transport.name);
|
||
self.transport.pause(function () {
|
||
if (failed) return;
|
||
if ('closed' == self.readyState || 'closing' == self.readyState) {
|
||
return;
|
||
}
|
||
debug('changing transport and sending upgrade packet');
|
||
transport.removeListener('error', onerror);
|
||
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);
|
||
}
|
||
});
|
||
});
|
||
|
||
transport.once('error', onerror);
|
||
function onerror(err) {
|
||
if (failed) return;
|
||
|
||
// Any callback called by transport should be ignored since now
|
||
failed = true;
|
||
|
||
var error = new Error('probe error: ' + err);
|
||
error.transport = transport.name;
|
||
|
||
transport.close();
|
||
transport = null;
|
||
|
||
debug('probe transport "%s" failed because of error: %s', name, err);
|
||
|
||
self.emit('upgradeError', error);
|
||
}
|
||
|
||
transport.open();
|
||
|
||
this.once('close', function () {
|
||
if (transport) {
|
||
debug('socket closed prematurely - aborting probe');
|
||
failed = true;
|
||
transport.close();
|
||
transport = null;
|
||
}
|
||
});
|
||
|
||
this.once('upgrading', function (to) {
|
||
if (transport && to.name != transport.name) {
|
||
debug('"%s" works - aborting "%s"', to.name, transport.name);
|
||
transport.close();
|
||
transport = null;
|
||
}
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Called when connection is deemed open.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.onOpen = function () {
|
||
debug('socket open');
|
||
this.readyState = 'open';
|
||
Socket.priorWebsocketSuccess = 'websocket' == this.transport.name;
|
||
this.emit('open');
|
||
this.onopen && this.onopen.call(this);
|
||
this.flush();
|
||
|
||
// we check for `readyState` in case an `open`
|
||
// listener already closed the socket
|
||
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]);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Handles a packet.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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);
|
||
|
||
// Socket is live - any packet counts
|
||
this.emit('heartbeat');
|
||
|
||
switch (packet.type) {
|
||
case 'open':
|
||
this.onHandshake(util.parseJSON(packet.data));
|
||
break;
|
||
|
||
case 'pong':
|
||
this.setPing();
|
||
break;
|
||
|
||
case 'error':
|
||
var err = new Error('server error');
|
||
err.code = packet.data;
|
||
this.emit('error', err);
|
||
break;
|
||
|
||
case 'message':
|
||
this.emit('data', packet.data);
|
||
this.emit('message', packet.data);
|
||
var event = { data: packet.data };
|
||
event.toString = function () {
|
||
return packet.data;
|
||
};
|
||
|
||
this.onmessage && this.onmessage.call(this, event);
|
||
break;
|
||
}
|
||
} else {
|
||
debug('packet received with socket readyState "%s"', this.readyState);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon handshake completion.
|
||
*
|
||
* @param {Object} handshake obj
|
||
* @api private
|
||
*/
|
||
|
||
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();
|
||
this.setPing();
|
||
|
||
// Prolong liveness of socket on heartbeat
|
||
this.removeListener('heartbeat', this.onHeartbeat);
|
||
this.on('heartbeat', this.onHeartbeat);
|
||
};
|
||
|
||
/**
|
||
* Resets ping timeout.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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));
|
||
};
|
||
|
||
/**
|
||
* Pings server every `this.pingInterval` and expects response
|
||
* within `this.pingTimeout` or closes connection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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);
|
||
};
|
||
|
||
/**
|
||
* Sends a ping packet.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.ping = function () {
|
||
this.sendPacket('ping');
|
||
};
|
||
|
||
/**
|
||
* Called on `drain` event
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onDrain = function() {
|
||
for (var i = 0; i < this.prevBufferLen; i++) {
|
||
if (this.callbackBuffer[i]) {
|
||
this.callbackBuffer[i]();
|
||
}
|
||
}
|
||
|
||
this.writeBuffer.splice(0, this.prevBufferLen);
|
||
this.callbackBuffer.splice(0, this.prevBufferLen);
|
||
|
||
// setting prevBufferLen = 0 is very important
|
||
// for example, when upgrading, upgrade packet is sent over,
|
||
// and a nonzero prevBufferLen could cause problems on `drain`
|
||
this.prevBufferLen = 0;
|
||
|
||
if (this.writeBuffer.length == 0) {
|
||
this.emit('drain');
|
||
} else {
|
||
this.flush();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Flush write buffers.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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);
|
||
// keep track of current length of writeBuffer
|
||
// splice writeBuffer and callbackBuffer on `drain`
|
||
this.prevBufferLen = this.writeBuffer.length;
|
||
this.emit('flush');
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Sends a message.
|
||
*
|
||
* @param {String} message.
|
||
* @param {Function} callback function.
|
||
* @return {Socket} for chaining.
|
||
* @api public
|
||
*/
|
||
|
||
Socket.prototype.write =
|
||
Socket.prototype.send = function (msg, fn) {
|
||
this.sendPacket('message', msg, fn);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sends a packet.
|
||
*
|
||
* @param {String} packet type.
|
||
* @param {String} data.
|
||
* @param {Function} callback function.
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.sendPacket = function (type, data, fn) {
|
||
var packet = { type: type, data: data };
|
||
this.emit('packetCreate', packet);
|
||
this.writeBuffer.push(packet);
|
||
this.callbackBuffer.push(fn);
|
||
this.flush();
|
||
};
|
||
|
||
/**
|
||
* Closes the connection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.close = function () {
|
||
if ('opening' == this.readyState || 'open' == this.readyState) {
|
||
this.onClose('forced close');
|
||
debug('socket closing - telling transport to close');
|
||
this.transport.close();
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Called upon transport error
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onError = function (err) {
|
||
debug('socket error %j', err);
|
||
Socket.priorWebsocketSuccess = false;
|
||
this.emit('error', err);
|
||
this.onerror && this.onerror.call(this, err);
|
||
this.onClose('transport error', err);
|
||
};
|
||
|
||
/**
|
||
* Called upon transport close.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Socket.prototype.onClose = function (reason, desc) {
|
||
if ('opening' == this.readyState || 'open' == this.readyState) {
|
||
debug('socket close with reason: "%s"', reason);
|
||
var self = this;
|
||
|
||
// clear timers
|
||
clearTimeout(this.pingIntervalTimer);
|
||
clearTimeout(this.pingTimeoutTimer);
|
||
|
||
// clean buffers in next tick, so developers can still
|
||
// grab the buffers on `close` event
|
||
setTimeout(function() {
|
||
self.writeBuffer = [];
|
||
self.callbackBuffer = [];
|
||
self.prevBufferLen = 0;
|
||
}, 0);
|
||
|
||
// ignore further transport communication
|
||
this.transport.removeAllListeners();
|
||
|
||
// set ready state
|
||
this.readyState = 'closed';
|
||
|
||
// clear session id
|
||
this.id = null;
|
||
|
||
// emit close event
|
||
this.emit('close', reason, desc);
|
||
this.onclose && this.onclose.call(this);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Filters upgrades, returning only those matching client transports.
|
||
*
|
||
* @param {Array} server upgrades
|
||
* @api private
|
||
*
|
||
*/
|
||
|
||
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;
|
||
};
|
||
|
||
},{"./emitter":13,"./transport":16,"./transports":18,"./util":23,"debug":10,"engine.io-parser":25,"global":29,"indexof":35}],16:[function(require,module,exports){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var util = require('./util');
|
||
var parser = require('engine.io-parser');
|
||
var Emitter = require('./emitter');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = Transport;
|
||
|
||
/**
|
||
* Transport abstract constructor.
|
||
*
|
||
* @param {Object} options.
|
||
* @api private
|
||
*/
|
||
|
||
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;
|
||
}
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Transport.prototype);
|
||
|
||
/**
|
||
* Emits an error.
|
||
*
|
||
* @param {String} str
|
||
* @return {Transport} for chaining
|
||
* @api public
|
||
*/
|
||
|
||
Transport.prototype.onError = function (msg, desc) {
|
||
var err = new Error(msg);
|
||
err.type = 'TransportError';
|
||
err.description = desc;
|
||
this.emit('error', err);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Opens the transport.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Transport.prototype.open = function () {
|
||
if ('closed' == this.readyState || '' == this.readyState) {
|
||
this.readyState = 'opening';
|
||
this.doOpen();
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Closes the transport.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.close = function () {
|
||
if ('opening' == this.readyState || 'open' == this.readyState) {
|
||
this.doClose();
|
||
this.onClose();
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* Sends multiple packets.
|
||
*
|
||
* @param {Array} packets
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.send = function(packets){
|
||
if ('open' == this.readyState) {
|
||
this.write(packets);
|
||
} else {
|
||
throw new Error('Transport not open');
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon open
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.onOpen = function () {
|
||
this.readyState = 'open';
|
||
this.writable = true;
|
||
this.emit('open');
|
||
};
|
||
|
||
/**
|
||
* Called with data.
|
||
*
|
||
* @param {String} data
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.onData = function (data) {
|
||
this.onPacket(parser.decodePacket(data, this.socket.binaryType));
|
||
};
|
||
|
||
/**
|
||
* Called with a decoded packet.
|
||
*/
|
||
|
||
Transport.prototype.onPacket = function (packet) {
|
||
this.emit('packet', packet);
|
||
};
|
||
|
||
/**
|
||
* Called upon close.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Transport.prototype.onClose = function () {
|
||
this.readyState = 'closed';
|
||
this.emit('close');
|
||
};
|
||
|
||
},{"./emitter":13,"./util":23,"engine.io-parser":25}],17:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var WS = require('./websocket');
|
||
var util = require('../util');
|
||
var debug = require('debug')('engine.io-client:flashsocket');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = FlashWS;
|
||
|
||
/**
|
||
* Global reference.
|
||
*/
|
||
|
||
var global = require('global');
|
||
|
||
/**
|
||
* Obfuscated key for Blue Coat.
|
||
*/
|
||
|
||
var xobject = global[['Active'].concat('Object').join('X')];
|
||
|
||
/**
|
||
* FlashWS constructor.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function FlashWS(options){
|
||
WS.call(this, options);
|
||
this.flashPath = options.flashPath;
|
||
this.policyPort = options.policyPort;
|
||
}
|
||
|
||
/**
|
||
* Inherits from WebSocket.
|
||
*/
|
||
|
||
util.inherits(FlashWS, WS);
|
||
|
||
/**
|
||
* Transport name.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
FlashWS.prototype.name = 'flashsocket';
|
||
|
||
/*
|
||
* FlashSockets only support binary as base64 encoded strings
|
||
*/
|
||
|
||
FlashWS.prototype.supportsBinary = false;
|
||
|
||
/**
|
||
* Opens the transport.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
FlashWS.prototype.doOpen = function(){
|
||
if (!this.check()) {
|
||
// let the probe timeout
|
||
return;
|
||
}
|
||
|
||
// instrument websocketjs logging
|
||
function log(type){
|
||
return function(){
|
||
var str = Array.prototype.join.call(arguments, ' ');
|
||
debug('[websocketjs %s] %s', type, str);
|
||
};
|
||
}
|
||
|
||
global.WEB_SOCKET_LOGGER = { log: log('debug'), error: log('error') };
|
||
global.WEB_SOCKET_SUPPRESS_CROSS_DOMAIN_SWF_ERROR = true;
|
||
global.WEB_SOCKET_DISABLE_AUTO_INITIALIZATION = true;
|
||
|
||
if (!global.WEB_SOCKET_SWF_LOCATION) {
|
||
global.WEB_SOCKET_SWF_LOCATION = this.flashPath + 'WebSocketMainInsecure.swf';
|
||
}
|
||
|
||
// dependencies
|
||
var deps = [this.flashPath + 'web_socket.js'];
|
||
|
||
if (!global.swfobject) {
|
||
deps.unshift(this.flashPath + 'swfobject.js');
|
||
}
|
||
|
||
var self = this;
|
||
|
||
load(deps, function(){
|
||
self.ready(function(){
|
||
WebSocket.__addTask(function () {
|
||
self.ws = new WebSocket(self.uri());
|
||
self.addEventListeners();
|
||
});
|
||
});
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Override to prevent closing uninitialized flashsocket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
FlashWS.prototype.doClose = function(){
|
||
if (!this.ws) return;
|
||
var self = this;
|
||
WebSocket.__addTask(function(){
|
||
WS.prototype.doClose.call(self);
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Writes to the Flash socket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
FlashWS.prototype.write = function(){
|
||
var self = this, args = arguments;
|
||
WebSocket.__addTask(function(){
|
||
WS.prototype.write.apply(self, args);
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Called upon dependencies are loaded.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
FlashWS.prototype.ready = function(fn){
|
||
if (typeof WebSocket == 'undefined' ||
|
||
!('__initialize' in WebSocket) || !global.swfobject) {
|
||
return;
|
||
}
|
||
|
||
if (global.swfobject.getFlashPlayerVersion().major < 10) {
|
||
return;
|
||
}
|
||
|
||
function init () {
|
||
// only start downloading the swf file when
|
||
// we checked that this browser actually supports it
|
||
if (!FlashWS.loaded) {
|
||
if (843 != self.policyPort) {
|
||
var policy = 'xmlsocket://' + self.hostname + ':' + self.policyPort;
|
||
WebSocket.loadFlashPolicyFile(policy);
|
||
}
|
||
|
||
WebSocket.__initialize();
|
||
FlashWS.loaded = true;
|
||
}
|
||
|
||
fn.call(self);
|
||
}
|
||
|
||
var self = this;
|
||
if (document.body) {
|
||
return init();
|
||
}
|
||
|
||
util.load(init);
|
||
};
|
||
|
||
/**
|
||
* Feature detection for flashsocket.
|
||
*
|
||
* @return {Boolean} whether this transport is available.
|
||
* @api public
|
||
*/
|
||
|
||
FlashWS.prototype.check = function(){
|
||
if ('undefined' == typeof window) {
|
||
return false;
|
||
}
|
||
|
||
if (typeof WebSocket != 'undefined' && !('__initialize' in WebSocket)) {
|
||
return false;
|
||
}
|
||
|
||
if (xobject) {
|
||
var control = null;
|
||
try {
|
||
control = new xobject('ShockwaveFlash.ShockwaveFlash');
|
||
} catch (e) { }
|
||
if (control) {
|
||
return true;
|
||
}
|
||
} else {
|
||
for (var i = 0, l = navigator.plugins.length; i < l; i++) {
|
||
for (var j = 0, m = navigator.plugins[i].length; j < m; j++) {
|
||
if (navigator.plugins[i][j].description == 'Shockwave Flash') {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
};
|
||
|
||
/**
|
||
* Lazy loading of scripts.
|
||
* Based on $script by Dustin Diaz - MIT
|
||
*/
|
||
|
||
var scripts = {};
|
||
|
||
/**
|
||
* Injects a script. Keeps tracked of injected ones.
|
||
*
|
||
* @param {String} path
|
||
* @param {Function} callback
|
||
* @api private
|
||
*/
|
||
|
||
function create(path, fn){
|
||
if (scripts[path]) return fn();
|
||
|
||
var el = document.createElement('script');
|
||
var loaded = false;
|
||
|
||
debug('loading "%s"', path);
|
||
el.onload = el.onreadystatechange = function(){
|
||
if (loaded || scripts[path]) return;
|
||
var rs = el.readyState;
|
||
if (!rs || 'loaded' == rs || 'complete' == rs) {
|
||
debug('loaded "%s"', path);
|
||
el.onload = el.onreadystatechange = null;
|
||
loaded = true;
|
||
scripts[path] = true;
|
||
fn();
|
||
}
|
||
};
|
||
|
||
el.async = 1;
|
||
el.src = path;
|
||
|
||
var head = document.getElementsByTagName('head')[0];
|
||
head.insertBefore(el, head.firstChild);
|
||
}
|
||
|
||
/**
|
||
* Loads scripts and fires a callback.
|
||
*
|
||
* @param {Array} paths
|
||
* @param {Function} callback
|
||
*/
|
||
|
||
function load(arr, fn){
|
||
function process(i){
|
||
if (!arr[i]) return fn();
|
||
create(arr[i], function () {
|
||
process(++i);
|
||
});
|
||
}
|
||
|
||
process(0);
|
||
}
|
||
|
||
},{"../util":23,"./websocket":22,"debug":10,"global":29}],18:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module dependencies
|
||
*/
|
||
|
||
var XMLHttpRequest = require('xmlhttprequest')
|
||
, XHR = require('./polling-xhr')
|
||
, JSONP = require('./polling-jsonp')
|
||
, websocket = require('./websocket')
|
||
, flashsocket = require('./flashsocket')
|
||
|
||
/**
|
||
* Export transports.
|
||
*/
|
||
|
||
exports.polling = polling;
|
||
exports.websocket = websocket;
|
||
exports.flashsocket = flashsocket;
|
||
|
||
/**
|
||
* Global reference.
|
||
*/
|
||
|
||
var global = require('global');
|
||
|
||
/**
|
||
* Polling transport polymorphic constructor.
|
||
* Decides on xhr vs jsonp based on feature detection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
function polling (opts) {
|
||
var xhr
|
||
, xd = false;
|
||
|
||
if (global.location) {
|
||
var isSSL = 'https:' == location.protocol;
|
||
var port = location.port;
|
||
|
||
// some user agents have empty `location.port`
|
||
if (!port) {
|
||
port = isSSL ? 443 : 80;
|
||
}
|
||
|
||
xd = opts.hostname != location.hostname || port != opts.port;
|
||
}
|
||
|
||
opts.xdomain = xd;
|
||
xhr = new XMLHttpRequest(opts);
|
||
|
||
if (xhr && !opts.forceJSONP) {
|
||
return new XHR(opts);
|
||
} else {
|
||
return new JSONP(opts);
|
||
}
|
||
};
|
||
|
||
},{"./flashsocket":17,"./polling-jsonp":19,"./polling-xhr":20,"./websocket":22,"global":29,"xmlhttprequest":24}],19:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module requirements.
|
||
*/
|
||
|
||
var Polling = require('./polling');
|
||
var util = require('../util');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = JSONPPolling;
|
||
|
||
/**
|
||
* Global reference.
|
||
*/
|
||
|
||
var global = require('global');
|
||
|
||
/**
|
||
* Cached regular expressions.
|
||
*/
|
||
|
||
var rNewline = /\n/g;
|
||
|
||
/**
|
||
* Global JSONP callbacks.
|
||
*/
|
||
|
||
var callbacks;
|
||
|
||
/**
|
||
* Callbacks count.
|
||
*/
|
||
|
||
var index = 0;
|
||
|
||
/**
|
||
* Noop.
|
||
*/
|
||
|
||
function empty () { }
|
||
|
||
/**
|
||
* JSONP Polling constructor.
|
||
*
|
||
* @param {Object} opts.
|
||
* @api public
|
||
*/
|
||
|
||
function JSONPPolling (opts) {
|
||
Polling.call(this, opts);
|
||
|
||
// define global callbacks array if not present
|
||
// we do this here (lazily) to avoid unneeded global pollution
|
||
if (!callbacks) {
|
||
// we need to consider multiple engines in the same page
|
||
if (!global.___eio) global.___eio = [];
|
||
callbacks = global.___eio;
|
||
}
|
||
|
||
// callback identifier
|
||
this.index = callbacks.length;
|
||
|
||
// add callback to jsonp global
|
||
var self = this;
|
||
callbacks.push(function (msg) {
|
||
self.onData(msg);
|
||
});
|
||
|
||
// append to query string
|
||
this.query.j = this.index;
|
||
}
|
||
|
||
/**
|
||
* Inherits from Polling.
|
||
*/
|
||
|
||
util.inherits(JSONPPolling, Polling);
|
||
|
||
/*
|
||
* JSONP only supports binary as base64 encoded strings
|
||
*/
|
||
|
||
JSONPPolling.prototype.supportsBinary = false;
|
||
|
||
/**
|
||
* Closes the socket
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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;
|
||
}
|
||
|
||
Polling.prototype.doClose.call(this);
|
||
};
|
||
|
||
/**
|
||
* Starts a poll cycle.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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];
|
||
insertAt.parentNode.insertBefore(script, insertAt);
|
||
this.script = script;
|
||
|
||
|
||
if (util.ua.gecko) {
|
||
setTimeout(function () {
|
||
var iframe = document.createElement('iframe');
|
||
document.body.appendChild(iframe);
|
||
document.body.removeChild(iframe);
|
||
}, 100);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Writes with a hidden iframe.
|
||
*
|
||
* @param {String} data to send
|
||
* @param {Function} called upon flush.
|
||
* @api private
|
||
*/
|
||
|
||
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 {
|
||
// ie6 dynamic iframes with target="" support (thanks Chris Lambacher)
|
||
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();
|
||
|
||
// escape \n to prevent it from being converted into \r\n by some UAs
|
||
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;
|
||
}
|
||
};
|
||
|
||
},{"../util":23,"./polling":21,"global":29}],20:[function(require,module,exports){
|
||
/**
|
||
* Module requirements.
|
||
*/
|
||
|
||
var XMLHttpRequest = require('xmlhttprequest');
|
||
var Polling = require('./polling');
|
||
var util = require('../util');
|
||
var Emitter = require('../emitter');
|
||
var debug = require('debug')('engine.io-client:polling-xhr');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = XHR;
|
||
module.exports.Request = Request;
|
||
|
||
/**
|
||
* Global reference.
|
||
*/
|
||
|
||
var global = require('global');
|
||
|
||
/**
|
||
* Obfuscated key for Blue Coat.
|
||
*/
|
||
|
||
var hasAttachEvent = global.document && global.document.attachEvent;
|
||
|
||
/**
|
||
* Empty function
|
||
*/
|
||
|
||
function empty(){}
|
||
|
||
/**
|
||
* XHR Polling constructor.
|
||
*
|
||
* @param {Object} opts
|
||
* @api public
|
||
*/
|
||
|
||
function XHR(opts){
|
||
Polling.call(this, opts);
|
||
|
||
if (global.location) {
|
||
var isSSL = 'https:' == location.protocol;
|
||
var port = location.port;
|
||
|
||
// some user agents have empty `location.port`
|
||
if (!port) {
|
||
port = isSSL ? 443 : 80;
|
||
}
|
||
|
||
this.xd = opts.hostname != global.location.hostname ||
|
||
port != opts.port;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Inherits from Polling.
|
||
*/
|
||
|
||
util.inherits(XHR, Polling);
|
||
|
||
/**
|
||
* XHR supports binary
|
||
*/
|
||
|
||
XHR.prototype.supportsBinary = true;
|
||
|
||
/**
|
||
* Creates a request.
|
||
*
|
||
* @param {String} method
|
||
* @api private
|
||
*/
|
||
|
||
XHR.prototype.request = function(opts){
|
||
opts = opts || {};
|
||
opts.uri = this.uri();
|
||
opts.xd = this.xd;
|
||
opts.agent = this.agent || false;
|
||
opts.supportsBinary = this.supportsBinary;
|
||
return new Request(opts);
|
||
};
|
||
|
||
/**
|
||
* Sends data.
|
||
*
|
||
* @param {String} data to send.
|
||
* @param {Function} called upon flush.
|
||
* @api private
|
||
*/
|
||
|
||
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;
|
||
};
|
||
|
||
/**
|
||
* Starts a poll cycle.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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;
|
||
};
|
||
|
||
/**
|
||
* Request constructor
|
||
*
|
||
* @param {Object} options
|
||
* @api public
|
||
*/
|
||
|
||
function Request(opts){
|
||
this.method = opts.method || 'GET';
|
||
this.uri = opts.uri;
|
||
this.xd = !!opts.xd;
|
||
this.async = false !== opts.async;
|
||
this.data = undefined != opts.data ? opts.data : null;
|
||
this.agent = opts.agent;
|
||
this.create(opts.isBinary, opts.supportsBinary);
|
||
}
|
||
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/
|
||
|
||
Emitter(Request.prototype);
|
||
|
||
/**
|
||
* Creates the XHR object and sends the request.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.create = function(isBinary, supportsBinary){
|
||
var xhr = this.xhr = new XMLHttpRequest({ agent: this.agent, xdomain: this.xd });
|
||
var self = this;
|
||
|
||
try {
|
||
debug('xhr open %s: %s', this.method, this.uri);
|
||
xhr.open(this.method, this.uri, this.async);
|
||
if (supportsBinary) {
|
||
// This has to be done after open because Firefox is stupid
|
||
// http://stackoverflow.com/questions/13216903/get-binary-data-with-xmlhttprequest-in-a-firefox-extension
|
||
xhr.responseType = 'arraybuffer';
|
||
}
|
||
|
||
if ('POST' == this.method) {
|
||
try {
|
||
if (isBinary) {
|
||
xhr.setRequestHeader('Content-type', 'application/octet-stream');
|
||
} else {
|
||
xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');
|
||
}
|
||
} catch (e) {}
|
||
}
|
||
|
||
// ie6 check
|
||
if ('withCredentials' in xhr) {
|
||
xhr.withCredentials = true;
|
||
}
|
||
|
||
xhr.onreadystatechange = function(){
|
||
var data;
|
||
|
||
try {
|
||
if (4 != xhr.readyState) return;
|
||
if (200 == xhr.status || 1223 == xhr.status) {
|
||
var contentType = xhr.getResponseHeader('Content-Type');
|
||
if (contentType === 'application/octet-stream') {
|
||
data = xhr.response;
|
||
} else {
|
||
if (!supportsBinary) {
|
||
data = xhr.responseText;
|
||
} else {
|
||
data = 'ok';
|
||
}
|
||
}
|
||
} else {
|
||
// make sure the `error` event handler that's user-set
|
||
// does not throw in the same tick and gets caught here
|
||
setTimeout(function(){
|
||
self.onError(xhr.status);
|
||
}, 0);
|
||
}
|
||
} catch (e) {
|
||
self.onError(e);
|
||
}
|
||
|
||
if (null != data) {
|
||
self.onData(data);
|
||
}
|
||
};
|
||
|
||
debug('xhr data %s', this.data);
|
||
xhr.send(this.data);
|
||
} catch (e) {
|
||
// Need to defer since .create() is called directly fhrom the constructor
|
||
// and thus the 'error' event can only be only bound *after* this exception
|
||
// occurs. Therefore, also, we cannot throw here at all.
|
||
setTimeout(function() {
|
||
self.onError(e);
|
||
}, 0);
|
||
return;
|
||
}
|
||
|
||
if (hasAttachEvent) {
|
||
this.index = Request.requestsCount++;
|
||
Request.requests[this.index] = this;
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Called upon successful response.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.onSuccess = function(){
|
||
this.emit('success');
|
||
this.cleanup();
|
||
};
|
||
|
||
/**
|
||
* Called if we have data.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.onData = function(data){
|
||
this.emit('data', data);
|
||
this.onSuccess();
|
||
};
|
||
|
||
/**
|
||
* Called upon error.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.onError = function(err){
|
||
this.emit('error', err);
|
||
this.cleanup();
|
||
};
|
||
|
||
/**
|
||
* Cleans up house.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Request.prototype.cleanup = function(){
|
||
if ('undefined' == typeof this.xhr ) {
|
||
return;
|
||
}
|
||
// xmlhttprequest
|
||
this.xhr.onreadystatechange = empty;
|
||
|
||
try {
|
||
this.xhr.abort();
|
||
} catch(e) {}
|
||
|
||
if (hasAttachEvent) {
|
||
delete Request.requests[this.index];
|
||
}
|
||
|
||
this.xhr = null;
|
||
};
|
||
|
||
/**
|
||
* Aborts the request.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Request.prototype.abort = function(){
|
||
this.cleanup();
|
||
};
|
||
|
||
/**
|
||
* Cleanup is needed for old versions of IE
|
||
* that leak memory unless we abort request before unload.
|
||
*/
|
||
|
||
if (hasAttachEvent) {
|
||
Request.requestsCount = 0;
|
||
Request.requests = {};
|
||
|
||
function unloadHandler() {
|
||
for (var i in Request.requests) {
|
||
if (Request.requests.hasOwnProperty(i)) {
|
||
Request.requests[i].abort();
|
||
}
|
||
}
|
||
}
|
||
|
||
global.attachEvent('onunload', unloadHandler);
|
||
}
|
||
|
||
},{"../emitter":13,"../util":23,"./polling":21,"debug":10,"global":29,"xmlhttprequest":24}],21:[function(require,module,exports){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var Transport = require('../transport');
|
||
var util = require('../util');
|
||
var parser = require('engine.io-parser');
|
||
var debug = require('debug')('engine.io-client:polling');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = Polling;
|
||
|
||
/**
|
||
* Global reference.
|
||
*/
|
||
|
||
var global = require('global');
|
||
|
||
/**
|
||
* Is XHR2 supported?
|
||
*/
|
||
|
||
var hasXHR2 = (function() {
|
||
var XMLHttpRequest = require('xmlhttprequest');
|
||
var xhr = new XMLHttpRequest({ agent: this.agent, xdomain: false });
|
||
return null != xhr.responseType;
|
||
})();
|
||
|
||
/**
|
||
* Polling interface.
|
||
*
|
||
* @param {Object} opts
|
||
* @api private
|
||
*/
|
||
|
||
function Polling(opts){
|
||
var forceBase64 = (opts && opts.forceBase64);
|
||
if (!hasXHR2 || forceBase64) {
|
||
this.supportsBinary = false;
|
||
}
|
||
Transport.call(this, opts);
|
||
}
|
||
|
||
/**
|
||
* Inherits from Transport.
|
||
*/
|
||
|
||
util.inherits(Polling, Transport);
|
||
|
||
/**
|
||
* Transport name.
|
||
*/
|
||
|
||
Polling.prototype.name = 'polling';
|
||
|
||
/**
|
||
* Opens the socket (triggers polling). We write a PING message to determine
|
||
* when the transport is open.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Polling.prototype.doOpen = function(){
|
||
this.poll();
|
||
};
|
||
|
||
/**
|
||
* Pauses polling.
|
||
*
|
||
* @param {Function} callback upon buffers are flushed and transport is paused
|
||
* @api private
|
||
*/
|
||
|
||
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();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Starts polling cycle.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Polling.prototype.poll = function(){
|
||
debug('polling');
|
||
this.polling = true;
|
||
this.doPoll();
|
||
this.emit('poll');
|
||
};
|
||
|
||
/**
|
||
* Overloads onData to detect payloads.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Polling.prototype.onData = function(data){
|
||
var self = this;
|
||
debug('polling got data %s', data);
|
||
var callback = function(packet, index, total) {
|
||
// if its the first message we consider the transport open
|
||
if ('opening' == self.readyState) {
|
||
self.onOpen();
|
||
}
|
||
|
||
// if its a close packet, we close the ongoing requests
|
||
if ('close' == packet.type) {
|
||
self.onClose();
|
||
return false;
|
||
}
|
||
|
||
// otherwise bypass onData and handle the message
|
||
self.onPacket(packet);
|
||
};
|
||
|
||
// decode payload
|
||
parser.decodePayload(data, this.socket.binaryType, callback);
|
||
|
||
// if an event did not trigger closing
|
||
if ('closed' != this.readyState) {
|
||
// if we got data we're not polling
|
||
this.polling = false;
|
||
this.emit('pollComplete');
|
||
|
||
if ('open' == this.readyState) {
|
||
this.poll();
|
||
} else {
|
||
debug('ignoring poll - transport state "%s"', this.readyState);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* For polling, send a close packet.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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 {
|
||
// in case we're trying to close while
|
||
// handshaking is in progress (GH-164)
|
||
debug('transport not open - deferring close');
|
||
this.once('open', close);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Writes a packets payload.
|
||
*
|
||
* @param {Array} data packets
|
||
* @param {Function} drain callback
|
||
* @api private
|
||
*/
|
||
|
||
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);
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Generates uri for connection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
Polling.prototype.uri = function(){
|
||
var query = this.query || {};
|
||
var schema = this.secure ? 'https' : 'http';
|
||
var port = '';
|
||
|
||
// cache busting is forced for IE / android / iOS6 ಠ_ಠ
|
||
if ('ActiveXObject' in global
|
||
|| util.ua.chromeframe
|
||
|| util.ua.android
|
||
|| util.ua.ios6
|
||
|| this.timestampRequests) {
|
||
if (false !== this.timestampRequests) {
|
||
query[this.timestampParam] = +new Date;
|
||
}
|
||
}
|
||
|
||
if (!this.supportsBinary && !query.sid) {
|
||
query.b64 = 1;
|
||
}
|
||
|
||
query = util.qs(query);
|
||
|
||
// avoid port if default for schema
|
||
if (this.port && (('https' == schema && this.port != 443) ||
|
||
('http' == schema && this.port != 80))) {
|
||
port = ':' + this.port;
|
||
}
|
||
|
||
// prepend ? to query
|
||
if (query.length) {
|
||
query = '?' + query;
|
||
}
|
||
|
||
return schema + '://' + this.hostname + port + this.path + query;
|
||
};
|
||
|
||
},{"../transport":16,"../util":23,"debug":10,"engine.io-parser":25,"global":29,"xmlhttprequest":24}],22:[function(require,module,exports){
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var Transport = require('../transport');
|
||
var parser = require('engine.io-parser');
|
||
var util = require('../util');
|
||
var debug = require('debug')('engine.io-client:websocket');
|
||
|
||
/**
|
||
* `ws` exposes a WebSocket-compatible interface in
|
||
* Node, or the `WebSocket` or `MozWebSocket` globals
|
||
* in the browser.
|
||
*/
|
||
|
||
var WebSocket = require('ws');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = WS;
|
||
|
||
/**
|
||
* Global reference.
|
||
*/
|
||
|
||
var global = require('global');
|
||
|
||
/**
|
||
* WebSocket transport constructor.
|
||
*
|
||
* @api {Object} connection options
|
||
* @api public
|
||
*/
|
||
|
||
function WS(opts){
|
||
var forceBase64 = (opts && opts.forceBase64);
|
||
if (forceBase64) {
|
||
this.supportsBinary = false;
|
||
}
|
||
Transport.call(this, opts);
|
||
}
|
||
|
||
/**
|
||
* Inherits from Transport.
|
||
*/
|
||
|
||
util.inherits(WS, Transport);
|
||
|
||
/**
|
||
* Transport name.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
WS.prototype.name = 'websocket';
|
||
|
||
/*
|
||
* WebSockets support binary
|
||
*/
|
||
|
||
WS.prototype.supportsBinary = true;
|
||
|
||
/**
|
||
* Opens socket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.doOpen = function(){
|
||
if (!this.check()) {
|
||
// let probe timeout
|
||
return;
|
||
}
|
||
|
||
var self = this;
|
||
var uri = this.uri();
|
||
var protocols = void(0);
|
||
var opts = { agent: this.agent };
|
||
|
||
this.ws = new WebSocket(uri, protocols, opts);
|
||
|
||
if (this.ws.binaryType !== undefined) {
|
||
this.supportsBinary = false;
|
||
}
|
||
|
||
this.ws.binaryType = 'arraybuffer';
|
||
this.addEventListeners();
|
||
};
|
||
|
||
/**
|
||
* Adds event listeners to the socket
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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);
|
||
};
|
||
};
|
||
|
||
/**
|
||
* Override `onData` to use a timer on iOS.
|
||
* See: https://gist.github.com/mloughran/2052006
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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);
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Writes data to socket.
|
||
*
|
||
* @param {Array} array of packets.
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.write = function(packets){
|
||
var self = this;
|
||
this.writable = false;
|
||
// encodePacket efficient as it uses WS framing
|
||
// no need for encodePayload
|
||
for (var i = 0, l = packets.length; i < l; i++) {
|
||
parser.encodePacket(packets[i], this.supportsBinary, function(data) {
|
||
self.ws.send(data);
|
||
});
|
||
}
|
||
|
||
function ondrain() {
|
||
self.writable = true;
|
||
self.emit('drain');
|
||
}
|
||
// fake drain
|
||
// defer to next tick to allow Socket to clear writeBuffer
|
||
setTimeout(ondrain, 0);
|
||
};
|
||
|
||
/**
|
||
* Called upon close
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.onClose = function(){
|
||
Transport.prototype.onClose.call(this);
|
||
};
|
||
|
||
/**
|
||
* Closes socket.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.doClose = function(){
|
||
if (typeof this.ws !== 'undefined') {
|
||
this.ws.close();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Generates uri for connection.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
WS.prototype.uri = function(){
|
||
var query = this.query || {};
|
||
var schema = this.secure ? 'wss' : 'ws';
|
||
var port = '';
|
||
|
||
// avoid port if default for schema
|
||
if (this.port && (('wss' == schema && this.port != 443)
|
||
|| ('ws' == schema && this.port != 80))) {
|
||
port = ':' + this.port;
|
||
}
|
||
|
||
// append timestamp to URI
|
||
if (this.timestampRequests) {
|
||
query[this.timestampParam] = +new Date;
|
||
}
|
||
|
||
// communicate binary support capabilities
|
||
if (!this.supportsBinary) {
|
||
query.b64 = 1;
|
||
}
|
||
|
||
query = util.qs(query);
|
||
|
||
// prepend ? to query
|
||
if (query.length) {
|
||
query = '?' + query;
|
||
}
|
||
|
||
return schema + '://' + this.hostname + port + this.path + query;
|
||
};
|
||
|
||
/**
|
||
* Feature detection for WebSocket.
|
||
*
|
||
* @return {Boolean} whether this transport is available.
|
||
* @api public
|
||
*/
|
||
|
||
WS.prototype.check = function(){
|
||
return !!WebSocket && !('__initialize' in WebSocket && this.name === WS.prototype.name);
|
||
};
|
||
|
||
},{"../transport":16,"../util":23,"debug":10,"engine.io-parser":25,"global":29,"ws":30}],23:[function(require,module,exports){
|
||
|
||
var global = require('global');
|
||
|
||
/**
|
||
* Status of page load.
|
||
*/
|
||
|
||
var pageLoaded = false;
|
||
|
||
/**
|
||
* Inheritance.
|
||
*
|
||
* @param {Function} ctor a
|
||
* @param {Function} ctor b
|
||
* @api private
|
||
*/
|
||
|
||
exports.inherits = function inherits (a, b) {
|
||
function c () { }
|
||
c.prototype = b.prototype;
|
||
a.prototype = new c;
|
||
};
|
||
|
||
/**
|
||
* Object.keys
|
||
*/
|
||
|
||
exports.keys = Object.keys || function (obj) {
|
||
var ret = [];
|
||
var has = Object.prototype.hasOwnProperty;
|
||
|
||
for (var i in obj) {
|
||
if (has.call(obj, i)) {
|
||
ret.push(i);
|
||
}
|
||
}
|
||
|
||
return ret;
|
||
};
|
||
|
||
/**
|
||
* Adds an event.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
exports.on = function (element, event, fn, capture) {
|
||
if (element.attachEvent) {
|
||
element.attachEvent('on' + event, fn);
|
||
} else if (element.addEventListener) {
|
||
element.addEventListener(event, fn, capture);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Load utility.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
exports.load = function (fn) {
|
||
if (global.document && document.readyState === 'complete' || pageLoaded) {
|
||
return fn();
|
||
}
|
||
|
||
exports.on(global, 'load', fn, false);
|
||
};
|
||
|
||
/**
|
||
* Change the internal pageLoaded value.
|
||
*/
|
||
|
||
if ('undefined' != typeof window) {
|
||
exports.load(function () {
|
||
pageLoaded = true;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* JSON parse.
|
||
*
|
||
* @see Based on jQuery#parseJSON (MIT) and JSON2
|
||
* @api private
|
||
*/
|
||
|
||
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+$/;
|
||
|
||
exports.parseJSON = function (data) {
|
||
if ('string' != typeof data || !data) {
|
||
return null;
|
||
}
|
||
|
||
data = data.replace(rtrimLeft, '').replace(rtrimRight, '');
|
||
|
||
// Attempt to parse using the native JSON parser first
|
||
if (global.JSON && JSON.parse) {
|
||
return JSON.parse(data);
|
||
}
|
||
|
||
if (rvalidchars.test(data.replace(rvalidescape, '@')
|
||
.replace(rvalidtokens, ']')
|
||
.replace(rvalidbraces, ''))) {
|
||
return (new Function('return ' + data))();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* UA / engines detection namespace.
|
||
*
|
||
* @namespace
|
||
*/
|
||
|
||
exports.ua = {};
|
||
|
||
/**
|
||
* Detect webkit.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
exports.ua.webkit = 'undefined' != typeof navigator &&
|
||
/webkit/i.test(navigator.userAgent);
|
||
|
||
/**
|
||
* Detect gecko.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
exports.ua.gecko = 'undefined' != typeof navigator &&
|
||
/gecko/i.test(navigator.userAgent);
|
||
|
||
/**
|
||
* Detect android;
|
||
*/
|
||
|
||
exports.ua.android = 'undefined' != typeof navigator &&
|
||
/android/i.test(navigator.userAgent);
|
||
|
||
/**
|
||
* Detect iOS.
|
||
*/
|
||
|
||
exports.ua.ios = 'undefined' != typeof navigator &&
|
||
/^(iPad|iPhone|iPod)$/.test(navigator.platform);
|
||
exports.ua.ios6 = exports.ua.ios && /OS 6_/.test(navigator.userAgent);
|
||
|
||
/**
|
||
* Detect Chrome Frame.
|
||
*/
|
||
|
||
exports.ua.chromeframe = Boolean(global.externalHost);
|
||
|
||
/**
|
||
* Parses an URI
|
||
*
|
||
* @author Steven Levithan <stevenlevithan.com> (MIT license)
|
||
* @api private
|
||
*/
|
||
|
||
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'
|
||
];
|
||
|
||
exports.parseUri = function (str) {
|
||
var m = re.exec(str || '')
|
||
, uri = {}
|
||
, i = 14;
|
||
|
||
while (i--) {
|
||
uri[parts[i]] = m[i] || '';
|
||
}
|
||
|
||
return uri;
|
||
};
|
||
|
||
/**
|
||
* Compiles a querystring
|
||
*
|
||
* @param {Object}
|
||
* @api private
|
||
*/
|
||
|
||
exports.qs = 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;
|
||
};
|
||
|
||
/**
|
||
* Parses a simple querystring.
|
||
*
|
||
* @param {String} qs
|
||
* @api private
|
||
*/
|
||
|
||
exports.qsParse = 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;
|
||
};
|
||
|
||
},{"global":29}],24:[function(require,module,exports){
|
||
// browser shim for xmlhttprequest module
|
||
var hasCORS = require('has-cors');
|
||
|
||
module.exports = function(opts) {
|
||
var xdomain = opts.xdomain;
|
||
|
||
// XMLHttpRequest can be disabled on IE
|
||
try {
|
||
if ('undefined' != typeof XMLHttpRequest && (!xdomain || hasCORS)) {
|
||
return new XMLHttpRequest();
|
||
}
|
||
} catch (e) { }
|
||
|
||
if (!xdomain) {
|
||
try {
|
||
return new ActiveXObject('Microsoft.XMLHTTP');
|
||
} catch(e) { }
|
||
}
|
||
}
|
||
|
||
},{"has-cors":33}],25:[function(require,module,exports){
|
||
var global=typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var keys = require('./keys');
|
||
var sliceBuffer = require('arraybuffer.slice');
|
||
var base64encoder = require('base64-arraybuffer');
|
||
var after = require('after');
|
||
|
||
/**
|
||
* A utility for doing slicing, even when ArrayBuffer.prototype.slice doesn't
|
||
* exist
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
/**
|
||
* Current protocol version.
|
||
*/
|
||
|
||
exports.protocol = 2;
|
||
|
||
/**
|
||
* Packet types.
|
||
*/
|
||
|
||
var packets = exports.packets = {
|
||
open: 0 // non-ws
|
||
, close: 1 // non-ws
|
||
, ping: 2
|
||
, pong: 3
|
||
, message: 4
|
||
, upgrade: 5
|
||
, noop: 6
|
||
};
|
||
|
||
var packetslist = keys(packets);
|
||
|
||
/**
|
||
* Premade error packet.
|
||
*/
|
||
|
||
var err = { type: 'error', data: 'parser error' };
|
||
|
||
/**
|
||
* Create a blob builder even when vendor prefixes exist
|
||
*/
|
||
|
||
var BlobBuilder = global.BlobBuilder
|
||
|| global.WebKitBlobBuilder
|
||
|| global.MSBlobBuilder
|
||
|| global.MozBlobBuilder;
|
||
|
||
/**
|
||
* Check if Blob constructor is supported
|
||
*/
|
||
|
||
var blobSupported = (function() {
|
||
try {
|
||
var b = new Blob(['hi']);
|
||
return b.size == 2;
|
||
} catch(e) {
|
||
return false;
|
||
}
|
||
})();
|
||
|
||
/**
|
||
* Check if BlobBuilder is supported
|
||
*/
|
||
|
||
var blobBuilderSupported = !!BlobBuilder
|
||
&& !!BlobBuilder.prototype.append
|
||
&& !!BlobBuilder.prototype.getBlob;
|
||
|
||
/**
|
||
* Encodes a packet.
|
||
*
|
||
* <packet type id> [ <data> ]
|
||
*
|
||
* Example:
|
||
*
|
||
* 5hello world
|
||
* 3
|
||
* 4
|
||
*
|
||
* Binary is encoded in an identical principle
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
exports.encodePacket = function (packet, supportsBinary, callback) {
|
||
if (typeof supportsBinary == 'function') {
|
||
callback = supportsBinary;
|
||
supportsBinary = false;
|
||
}
|
||
|
||
var data = (packet.data === undefined)
|
||
? undefined
|
||
: packet.data.buffer || packet.data;
|
||
|
||
if (global.ArrayBuffer && data instanceof ArrayBuffer) {
|
||
return encodeArrayBuffer(packet, supportsBinary, callback);
|
||
} else if (blobSupported && data instanceof Blob) {
|
||
return encodeBlob(packet, supportsBinary, callback);
|
||
}
|
||
|
||
// Sending data as a utf-8 string
|
||
var encoded = packets[packet.type];
|
||
|
||
// data fragment is optional
|
||
if (undefined !== packet.data) {
|
||
encoded += String(packet.data);
|
||
}
|
||
|
||
return callback('' + encoded);
|
||
|
||
};
|
||
|
||
/**
|
||
* Encode packet helpers for binary types
|
||
*/
|
||
|
||
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, callback);
|
||
};
|
||
return fr.readAsArrayBuffer(packet.data);
|
||
};
|
||
|
||
function encodeBlob(packet, supportsBinary, callback) {
|
||
if (!supportsBinary) {
|
||
return exports.encodeBase64Packet(packet, callback);
|
||
}
|
||
|
||
var length = new Uint8Array(1);
|
||
length[0] = packets[packet.type];
|
||
var blob;
|
||
if (blobSupported) {
|
||
blob = new Blob([length.buffer, packet.data]);
|
||
} else {
|
||
var bb = new BlobBuilder();
|
||
bb.append(length);
|
||
bb.append(packet.data);
|
||
blob = bb.getBlob();
|
||
}
|
||
|
||
return callback(blob);
|
||
};
|
||
|
||
/**
|
||
* Encodes a packet with binary data in a base64 string
|
||
*
|
||
* @param {Object} packet, has `type` and `data`
|
||
* @return {String} base64 encoded message
|
||
*/
|
||
|
||
exports.encodeBase64Packet = function(packet, callback) {
|
||
var message = 'b' + exports.packets[packet.type];
|
||
if (blobSupported && packet.data instanceof 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) {
|
||
// iPhone Safari doesn't let you apply with typed arrays
|
||
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);
|
||
};
|
||
|
||
/**
|
||
* Decodes a packet. Changes format to Blob if requested.
|
||
*
|
||
* @return {Object} with `type` and `data` (if any)
|
||
* @api private
|
||
*/
|
||
|
||
exports.decodePacket = function (data, binaryType) {
|
||
// String data
|
||
if (typeof data == 'string' || data === undefined) {
|
||
if (data.charAt(0) == 'b') {
|
||
return exports.decodeBase64Packet(data.substr(1), binaryType);
|
||
}
|
||
|
||
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 (blobSupported && binaryType === 'blob') {
|
||
rest = new Blob([rest]);
|
||
} else if (blobBuilderSupported && binaryType === 'blob') {
|
||
var bb = new BlobBuilder();
|
||
bb.append(rest);
|
||
rest = bb.getBlob();
|
||
}
|
||
return { type: packetslist[type], data: rest };
|
||
};
|
||
|
||
/**
|
||
* Decodes a packet encoded in a base64 string
|
||
*
|
||
* @param {String} base64 encoded message
|
||
* @return {Object} with `type` and `data` (if any)
|
||
*/
|
||
|
||
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' && blobSupported) {
|
||
data = new Blob([data]);
|
||
} else if (binaryType === 'blob' && blobBuilderSupported) {
|
||
var bb = new BlobBuilder();
|
||
bb.append(data);
|
||
data = bb.getBlob();
|
||
}
|
||
|
||
return { type: type, data: data };
|
||
};
|
||
|
||
/**
|
||
* Encodes multiple messages (payload).
|
||
*
|
||
* <length>:data
|
||
*
|
||
* Example:
|
||
*
|
||
* 11:hello world2:hi
|
||
*
|
||
* If any contents are binary, they will be encoded as base64 strings. Base64
|
||
* encoded strings are marked with a b before the length specifier
|
||
*
|
||
* @param {Array} packets
|
||
* @api private
|
||
*/
|
||
|
||
exports.encodePayload = function (packets, supportsBinary, callback) {
|
||
if (typeof supportsBinary == 'function') {
|
||
callback = supportsBinary;
|
||
supportsBinary = null;
|
||
}
|
||
|
||
if (supportsBinary) {
|
||
if (blobSupported || blobBuilderSupported) {
|
||
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, supportsBinary, function(message) {
|
||
doneCallback(null, setLengthHeader(message));
|
||
});
|
||
};
|
||
|
||
map(packets, encodeOne, function(err, results) {
|
||
return callback(results.join(''));
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Async array map using after
|
||
*/
|
||
|
||
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);
|
||
};
|
||
};
|
||
|
||
/*
|
||
* Decodes data when a payload is maybe expected. Possible binary contents are
|
||
* decoded from their base64 representation
|
||
*
|
||
* @param {String} data, callback method
|
||
* @api public
|
||
*/
|
||
|
||
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 == '') {
|
||
// parser error - ignoring payload
|
||
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)))) {
|
||
// parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
}
|
||
|
||
msg = data.substr(i + 1, n);
|
||
|
||
if (length != msg.length) {
|
||
// parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
}
|
||
|
||
if (msg.length) {
|
||
packet = exports.decodePacket(msg, binaryType);
|
||
|
||
if (err.type == packet.type && err.data == packet.data) {
|
||
// parser error in individual packet - ignoring payload
|
||
return callback(err, 0, 1);
|
||
}
|
||
|
||
var ret = callback(packet, i + n, l);
|
||
if (false === ret) return;
|
||
}
|
||
|
||
// advance cursor
|
||
i += n;
|
||
length = '';
|
||
}
|
||
}
|
||
|
||
if (length != '') {
|
||
// parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
}
|
||
|
||
};
|
||
|
||
/**
|
||
* Encodes multiple messages (payload) as binary.
|
||
*
|
||
* <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number
|
||
* 255><data>
|
||
*
|
||
* Example:
|
||
* 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers
|
||
*
|
||
* @param {Array} packets
|
||
* @return {ArrayBuffer} encoded payload
|
||
* @api private
|
||
*/
|
||
|
||
exports.encodePayloadAsArrayBuffer = function(packets, callback) {
|
||
if (!packets.length) {
|
||
return callback(new ArrayBuffer(0));
|
||
}
|
||
|
||
function encodeOne(packet, doneCallback) {
|
||
exports.encodePacket(packet, 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 + (new String(len)).length + len + 2; // string/binary identifier + separator = 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) { // not true binary
|
||
resultArray[bufferIndex++] = 0;
|
||
} else { // true binary
|
||
resultArray[bufferIndex++] = 1;
|
||
}
|
||
|
||
var lenStr = new String(ab.byteLength);
|
||
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);
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Encode as Blob
|
||
*/
|
||
|
||
exports.encodePayloadAsBlob = function(packets, callback) {
|
||
function encodeOne(packet, doneCallback) {
|
||
exports.encodePacket(packet, 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 = new String(len);
|
||
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 (blobSupported) {
|
||
var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);
|
||
doneCallback(null, blob);
|
||
} else {
|
||
var bb = new BlobBuilder();
|
||
bb.append(binaryIdentifier);
|
||
bb.append(lengthAry.buffer);
|
||
bb.append(encoded);
|
||
var blob = bb.getBlob();
|
||
doneCallback(null, blob);
|
||
}
|
||
});
|
||
};
|
||
|
||
map(packets, encodeOne, function(err, results) {
|
||
if (blobSupported) {
|
||
return callback(new Blob(results));
|
||
}
|
||
|
||
var bb = new BlobBuilder();
|
||
results.forEach(function(encoding) {
|
||
bb.append(encoding);
|
||
});
|
||
return callback(bb.getBlob());
|
||
});
|
||
};
|
||
|
||
/*
|
||
* Decodes data when a payload is maybe expected. Strings are decoded by
|
||
* interpreting each byte as a key code for entries marked to start with 0. See
|
||
* description of encodePayloadAsBinary
|
||
*
|
||
* @param {ArrayBuffer} data, callback method
|
||
* @api public
|
||
*/
|
||
|
||
exports.decodePayloadAsBinary = function (data, binaryType, callback) {
|
||
if (typeof binaryType === 'function') {
|
||
callback = binaryType;
|
||
binaryType = null;
|
||
}
|
||
|
||
var bufferTail = data;
|
||
var buffers = [];
|
||
|
||
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;
|
||
msgLength += tailArray[i];
|
||
}
|
||
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) {
|
||
// iPhone Safari doesn't let you apply to typed arrays
|
||
var typed = new Uint8Array(msg);
|
||
var basic = new Array(typed.length);
|
||
for (var i = 0; i < typed.length; i++) {
|
||
basic[i] = typed[i];
|
||
}
|
||
msg = String.fromCharCode.apply(null, basic);
|
||
}
|
||
}
|
||
buffers.push(msg);
|
||
bufferTail = sliceBuffer(bufferTail, msgLength);
|
||
}
|
||
|
||
var total = buffers.length;
|
||
buffers.forEach(function(buffer, i) {
|
||
callback(exports.decodePacket(buffer, binaryType), i, total);
|
||
});
|
||
};
|
||
|
||
},{"./keys":26,"after":27,"arraybuffer.slice":28,"base64-arraybuffer":7}],26:[function(require,module,exports){
|
||
|
||
/**
|
||
* Gets the keys for an object.
|
||
*
|
||
* @return {Array} keys
|
||
* @api private
|
||
*/
|
||
|
||
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;
|
||
};
|
||
|
||
},{}],27:[function(require,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
|
||
|
||
// after first error, rest are passed to err_cb
|
||
if (err) {
|
||
bail = true
|
||
callback(err)
|
||
// future error callbacks will go to error handler
|
||
callback = err_cb
|
||
} else if (proxy.count === 0 && !bail) {
|
||
callback(null, result)
|
||
}
|
||
}
|
||
}
|
||
|
||
function noop() {}
|
||
|
||
},{}],28:[function(require,module,exports){
|
||
/**
|
||
* An abstraction for slicing an arraybuffer even when
|
||
* ArrayBuffer.prototype.slice is not supported
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
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;
|
||
};
|
||
|
||
},{}],29:[function(require,module,exports){
|
||
|
||
/**
|
||
* Returns `this`. Execute this without a "context" (i.e. without it being
|
||
* attached to an object of the left-hand side), and `this` points to the
|
||
* "global" scope of the current JS execution.
|
||
*/
|
||
|
||
module.exports = (function () { return this; })();
|
||
|
||
},{}],30:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var global = (function() { return this; })();
|
||
|
||
/**
|
||
* WebSocket constructor.
|
||
*/
|
||
|
||
var WebSocket = global.WebSocket || global.MozWebSocket;
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = WebSocket ? ws : null;
|
||
|
||
/**
|
||
* WebSocket constructor.
|
||
*
|
||
* The third `opts` options object gets ignored in web browsers, since it's
|
||
* non-standard, and throws a TypeError if passed to the constructor.
|
||
* See: https://github.com/einaros/ws/issues/227
|
||
*
|
||
* @param {String} uri
|
||
* @param {Array} protocols (optional)
|
||
* @param {Object) opts (optional)
|
||
* @api public
|
||
*/
|
||
|
||
function ws(uri, protocols, opts) {
|
||
var instance;
|
||
if (protocols) {
|
||
instance = new WebSocket(uri, protocols);
|
||
} else {
|
||
instance = new WebSocket(uri);
|
||
}
|
||
return instance;
|
||
}
|
||
|
||
if (WebSocket) ws.prototype = WebSocket.prototype;
|
||
|
||
},{}],31:[function(require,module,exports){
|
||
var global=typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},Buffer=require("__browserify_Buffer").Buffer;/*
|
||
* Module requirements.
|
||
*/
|
||
|
||
var isArray = require('isarray');
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = hasBinary;
|
||
|
||
/**
|
||
* Checks for binary data.
|
||
*
|
||
* Right now only Buffer and ArrayBuffer are supported..
|
||
*
|
||
* @param {Object} anything
|
||
* @api public
|
||
*/
|
||
|
||
function hasBinary(data) {
|
||
|
||
function recursiveCheckForBinary(obj) {
|
||
if (!obj) return false;
|
||
|
||
if ( (global.Buffer && 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 (recursiveCheckForBinary(obj[i])) {
|
||
return true;
|
||
}
|
||
}
|
||
} else if (obj && 'object' == typeof obj) {
|
||
for (var key in obj) {
|
||
if (recursiveCheckForBinary(obj[key])) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
return recursiveCheckForBinary(data);
|
||
}
|
||
|
||
},{"__browserify_Buffer":9,"isarray":32}],32:[function(require,module,exports){
|
||
module.exports = Array.isArray || function (arr) {
|
||
return Object.prototype.toString.call(arr) == '[object Array]';
|
||
};
|
||
|
||
},{}],33:[function(require,module,exports){
|
||
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var global = require('global');
|
||
|
||
/**
|
||
* Module exports.
|
||
*
|
||
* Logic borrowed from Modernizr:
|
||
*
|
||
* - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js
|
||
*/
|
||
|
||
try {
|
||
module.exports = 'XMLHttpRequest' in global &&
|
||
'withCredentials' in new global.XMLHttpRequest();
|
||
} catch (err) {
|
||
// if XMLHttp support is disabled in IE then it will throw
|
||
// when trying to create
|
||
module.exports = false;
|
||
}
|
||
|
||
},{"global":34}],34:[function(require,module,exports){
|
||
module.exports=require(29)
|
||
},{}],35:[function(require,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;
|
||
};
|
||
},{}],36:[function(require,module,exports){
|
||
|
||
/**
|
||
* HOP ref.
|
||
*/
|
||
|
||
var has = Object.prototype.hasOwnProperty;
|
||
|
||
/**
|
||
* Return own keys in `obj`.
|
||
*
|
||
* @param {Object} obj
|
||
* @return {Array}
|
||
* @api public
|
||
*/
|
||
|
||
exports.keys = Object.keys || function(obj){
|
||
var keys = [];
|
||
for (var key in obj) {
|
||
if (has.call(obj, key)) {
|
||
keys.push(key);
|
||
}
|
||
}
|
||
return keys;
|
||
};
|
||
|
||
/**
|
||
* Return own values in `obj`.
|
||
*
|
||
* @param {Object} obj
|
||
* @return {Array}
|
||
* @api public
|
||
*/
|
||
|
||
exports.values = function(obj){
|
||
var vals = [];
|
||
for (var key in obj) {
|
||
if (has.call(obj, key)) {
|
||
vals.push(obj[key]);
|
||
}
|
||
}
|
||
return vals;
|
||
};
|
||
|
||
/**
|
||
* Merge `b` into `a`.
|
||
*
|
||
* @param {Object} a
|
||
* @param {Object} b
|
||
* @return {Object} a
|
||
* @api public
|
||
*/
|
||
|
||
exports.merge = function(a, b){
|
||
for (var key in b) {
|
||
if (has.call(b, key)) {
|
||
a[key] = b[key];
|
||
}
|
||
}
|
||
return a;
|
||
};
|
||
|
||
/**
|
||
* Return length of `obj`.
|
||
*
|
||
* @param {Object} obj
|
||
* @return {Number}
|
||
* @api public
|
||
*/
|
||
|
||
exports.length = function(obj){
|
||
return exports.keys(obj).length;
|
||
};
|
||
|
||
/**
|
||
* Check if `obj` is empty.
|
||
*
|
||
* @param {Object} obj
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/
|
||
|
||
exports.isEmpty = function(obj){
|
||
return 0 == exports.length(obj);
|
||
};
|
||
},{}],37:[function(require,module,exports){
|
||
/**
|
||
* Parses an URI
|
||
*
|
||
* @author Steven Levithan <stevenlevithan.com> (MIT license)
|
||
* @api private
|
||
*/
|
||
|
||
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 m = re.exec(str || '')
|
||
, uri = {}
|
||
, i = 14;
|
||
|
||
while (i--) {
|
||
uri[parts[i]] = m[i] || '';
|
||
}
|
||
|
||
return uri;
|
||
};
|
||
|
||
},{}],38:[function(require,module,exports){
|
||
var global=typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},Buffer=require("__browserify_Buffer").Buffer;/**
|
||
* Modle requirements
|
||
*/
|
||
|
||
var isArray = require('isarray');
|
||
|
||
/**
|
||
* Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.
|
||
* Anything with blobs or files should be fed through removeBlobs before coming
|
||
* here.
|
||
*
|
||
* @param {Object} packet - socket.io event packet
|
||
* @return {Object} with deconstructed packet and list of buffers
|
||
* @api public
|
||
*/
|
||
|
||
exports.deconstructPacket = function(packet) {
|
||
var buffers = [];
|
||
var packetData = packet.data;
|
||
|
||
function deconstructBinPackRecursive(data) {
|
||
if (!data) return data;
|
||
|
||
if ((global.Buffer && Buffer.isBuffer(data)) ||
|
||
(global.ArrayBuffer && data instanceof ArrayBuffer)) { // replace binary
|
||
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] = deconstructBinPackRecursive(data[i]);
|
||
}
|
||
return newData;
|
||
} else if ('object' == typeof data) {
|
||
var newData = {};
|
||
for (var key in data) {
|
||
newData[key] = deconstructBinPackRecursive(data[key]);
|
||
}
|
||
return newData;
|
||
}
|
||
return data;
|
||
}
|
||
|
||
var pack = packet;
|
||
pack.data = deconstructBinPackRecursive(packetData);
|
||
pack.attachments = buffers.length; // number of binary 'attachments'
|
||
return {packet: pack, buffers: buffers};
|
||
}
|
||
|
||
/**
|
||
* Reconstructs a binary packet from its placeholder packet and buffers
|
||
*
|
||
* @param {Object} packet - event packet with placeholders
|
||
* @param {Array} buffers - binary buffers to put in placeholder positions
|
||
* @return {Object} reconstructed packet
|
||
* @api public
|
||
*/
|
||
|
||
exports.reconstructPacket = function(packet, buffers) {
|
||
var curPlaceHolder = 0;
|
||
|
||
function reconstructBinPackRecursive(data) {
|
||
if (data._placeholder) {
|
||
var buf = buffers[data.num]; // appropriate buffer (should be natural order anyway)
|
||
return buf;
|
||
} else if (isArray(data)) {
|
||
for (var i = 0; i < data.length; i++) {
|
||
data[i] = reconstructBinPackRecursive(data[i]);
|
||
}
|
||
return data;
|
||
} else if ('object' == typeof data) {
|
||
for (var key in data) {
|
||
data[key] = reconstructBinPackRecursive(data[key]);
|
||
}
|
||
return data;
|
||
}
|
||
return data;
|
||
}
|
||
|
||
packet.data = reconstructBinPackRecursive(packet.data);
|
||
packet.attachments = undefined; // no longer useful
|
||
return packet;
|
||
}
|
||
|
||
/**
|
||
* Asynchronously removes Blobs or Files from data via
|
||
* FileReader's readAsArrayBuffer method. Used before encoding
|
||
* data as msgpack. Calls callback with the blobless data.
|
||
*
|
||
* @param {Object} data
|
||
* @param {Function} callback
|
||
* @api private
|
||
*/
|
||
|
||
exports.removeBlobs = function(data, callback) {
|
||
|
||
function removeBlobsRecursive(obj, curKey, containingObject) {
|
||
if (!obj) return obj;
|
||
|
||
// convert any blob
|
||
if ((global.Blob && obj instanceof Blob) ||
|
||
(global.File && obj instanceof File)) {
|
||
pendingBlobs++;
|
||
|
||
// async filereader
|
||
var fileReader = new FileReader();
|
||
fileReader.onload = function() { // this.result == arraybuffer
|
||
if (containingObject) {
|
||
containingObject[curKey] = this.result;
|
||
}
|
||
else {
|
||
bloblessData = this.result;
|
||
}
|
||
|
||
// if nothing pending its callback time
|
||
if(! --pendingBlobs) {
|
||
callback(bloblessData);
|
||
}
|
||
};
|
||
|
||
fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer
|
||
}
|
||
|
||
if (isArray(obj)) { // handle array
|
||
for (var i = 0; i < obj.length; i++) {
|
||
removeBlobsRecursive(obj[i], i, obj);
|
||
}
|
||
} else if (obj && 'object' == typeof obj) { // and object
|
||
for (var key in obj) {
|
||
removeBlobsRecursive(obj[key], key, obj);
|
||
}
|
||
}
|
||
}
|
||
|
||
var pendingBlobs = 0;
|
||
var bloblessData = data;
|
||
removeBlobsRecursive(bloblessData);
|
||
if (!pendingBlobs) {
|
||
callback(bloblessData);
|
||
}
|
||
}
|
||
},{"__browserify_Buffer":9,"isarray":40}],39:[function(require,module,exports){
|
||
var global=typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},Buffer=require("__browserify_Buffer").Buffer;
|
||
/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
var debug = require('debug')('socket.io-parser');
|
||
var json = require('json3');
|
||
var isArray = require('isarray');
|
||
var Emitter = require('emitter');
|
||
var binary = require('./binary');
|
||
|
||
|
||
/**
|
||
* Protocol version.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.protocol = 1;
|
||
|
||
/**
|
||
* Packet types.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.types = [
|
||
'CONNECT',
|
||
'DISCONNECT',
|
||
'EVENT',
|
||
'BINARY_EVENT',
|
||
'ACK',
|
||
'ERROR'
|
||
];
|
||
|
||
/**
|
||
* Packet type `connect`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.CONNECT = 0;
|
||
|
||
/**
|
||
* Packet type `disconnect`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.DISCONNECT = 1;
|
||
|
||
/**
|
||
* Packet type `event`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.EVENT = 2;
|
||
|
||
/**
|
||
* Packet type `ack`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.ACK = 3;
|
||
|
||
/**
|
||
* Packet type `error`.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.ERROR = 4;
|
||
|
||
/**
|
||
* Packet type 'binary event'
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
exports.BINARY_EVENT = 5;
|
||
|
||
exports.Encoder = Encoder
|
||
|
||
/**
|
||
* A socket.io Encoder instance
|
||
*
|
||
* @api public
|
||
*/
|
||
function Encoder() {};
|
||
|
||
/**
|
||
* Encode a packet as a single string if non-binary, or as a
|
||
* buffer sequence, depending on packet type.
|
||
*
|
||
* @param {Object} obj - packet object
|
||
* @param {Function} callback - function to handle encodings (likely engine.write)
|
||
* @return Calls callback with Array of encodings
|
||
* @api public
|
||
*/
|
||
|
||
Encoder.prototype.encode = function(obj, callback){
|
||
debug('encoding packet %j', obj);
|
||
|
||
if (obj.type == exports.BINARY_EVENT) {
|
||
encodeAsBinary(obj, callback);
|
||
}
|
||
else {
|
||
var encoding = encodeAsString(obj);
|
||
callback([encoding]);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Encode packet as string.
|
||
*
|
||
* @param {Object} packet
|
||
* @return {String} encoded
|
||
* @api private
|
||
*/
|
||
|
||
function encodeAsString(obj) {
|
||
var str = '';
|
||
var nsp = false;
|
||
|
||
// first is type
|
||
str += obj.type;
|
||
|
||
// attachments if we have them
|
||
if (exports.BINARY_EVENT == obj.type) {
|
||
str += obj.attachments;
|
||
str += '-';
|
||
}
|
||
|
||
// if we have a namespace other than `/`
|
||
// we append it followed by a comma `,`
|
||
if (obj.nsp && '/' != obj.nsp) {
|
||
nsp = true;
|
||
str += obj.nsp;
|
||
}
|
||
|
||
// immediately followed by the id
|
||
if (null != obj.id) {
|
||
if (nsp) {
|
||
str += ',';
|
||
nsp = false;
|
||
}
|
||
str += obj.id;
|
||
}
|
||
|
||
// json data
|
||
if (null != obj.data) {
|
||
if (nsp) str += ',';
|
||
str += json.stringify(obj.data);
|
||
}
|
||
|
||
debug('encoded %j as %s', obj, str);
|
||
return str;
|
||
}
|
||
|
||
/**
|
||
* Encode packet as 'buffer sequence' by removing blobs, and
|
||
* deconstructing packet into object with placeholders and
|
||
* a list of buffers.
|
||
*
|
||
* @param {Object} packet
|
||
* @return {Buffer} encoded
|
||
* @api private
|
||
*/
|
||
|
||
function encodeAsBinary(obj, callback) {
|
||
|
||
function writeEncoding(bloblessData) {
|
||
var deconstruction = binary.deconstructPacket(bloblessData);
|
||
var pack = encodeAsString(deconstruction.packet);
|
||
var buffers = deconstruction.buffers;
|
||
|
||
buffers.unshift(pack); // add packet info to beginning of data list
|
||
callback(buffers); // write all the buffers
|
||
}
|
||
|
||
binary.removeBlobs(obj, writeEncoding);
|
||
}
|
||
|
||
exports.Decoder = Decoder
|
||
|
||
/**
|
||
* A socket.io Decoder instance
|
||
*
|
||
* @return {Object} decoder
|
||
* @api public
|
||
*/
|
||
|
||
function Decoder() {
|
||
this.reconstructor = null;
|
||
}
|
||
|
||
/**
|
||
* Mix in `Emitter` with Decoder.
|
||
*/
|
||
|
||
Emitter(Decoder.prototype);
|
||
|
||
/**
|
||
* Decodes an ecoded packet string into packet JSON.
|
||
*
|
||
* @param {String} obj - encoded packet
|
||
* @return {Object} packet
|
||
* @api public
|
||
*/
|
||
|
||
Decoder.prototype.add = function(obj) {
|
||
var packet;
|
||
if ('string' == typeof obj) {
|
||
packet = decodeString(obj);
|
||
if (packet.type == exports.BINARY_EVENT) { // binary packet's json
|
||
this.reconstructor = new BinaryReconstructor(packet);
|
||
} else { // non-binary full packet
|
||
this.emit('decoded', packet);
|
||
}
|
||
}
|
||
else if ((global.Buffer && Buffer.isBuffer(obj)) ||
|
||
(global.ArrayBuffer && obj instanceof ArrayBuffer) ||
|
||
obj.base64) { // raw binary data
|
||
if (!this.reconstructor) {
|
||
throw new Error('got binary data when not reconstructing a packet');
|
||
} else {
|
||
packet = this.reconstructor.takeBinaryData(obj);
|
||
if (packet) { // received final buffer
|
||
this.reconstructor = null;
|
||
this.emit('decoded', packet);
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
throw new Error('Unknown type: ' + obj);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Decode a packet String (JSON data)
|
||
*
|
||
* @param {String} str
|
||
* @return {Object} packet
|
||
* @api private
|
||
*/
|
||
|
||
function decodeString(str) {
|
||
var p = {};
|
||
var i = 0;
|
||
|
||
// look up type
|
||
p.type = Number(str.charAt(0));
|
||
if (null == exports.types[p.type]) return error();
|
||
|
||
// look up attachments if type binary
|
||
if (exports.BINARY_EVENT == p.type) {
|
||
p.attachments = '';
|
||
while (str.charAt(++i) != '-') {
|
||
p.attachments += str.charAt(i);
|
||
}
|
||
p.attachments = Number(p.attachments);
|
||
}
|
||
|
||
// look up namespace (if any)
|
||
if ('/' == str.charAt(i + 1)) {
|
||
p.nsp = '';
|
||
while (++i) {
|
||
var c = str.charAt(i);
|
||
if (',' == c) break;
|
||
p.nsp += c;
|
||
if (i + 1 == str.length) break;
|
||
}
|
||
} else {
|
||
p.nsp = '/';
|
||
}
|
||
|
||
// look up id
|
||
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 + 1 == str.length) break;
|
||
}
|
||
p.id = Number(p.id);
|
||
}
|
||
|
||
// look up json data
|
||
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;
|
||
};
|
||
|
||
/**
|
||
* Deallocates a parser's resources
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
Decoder.prototype.destroy = function() {
|
||
if (this.reconstructor) {
|
||
this.reconstructor.finishedReconstruction();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* A manager of a binary event's 'buffer sequence'. Should
|
||
* be constructed whenever a packet of type BINARY_EVENT is
|
||
* decoded.
|
||
*
|
||
* @param {Object} packet
|
||
* @return {BinaryReconstructor} initialized reconstructor
|
||
* @api private
|
||
*/
|
||
|
||
function BinaryReconstructor(packet) {
|
||
this.reconPack = packet;
|
||
this.buffers = [];
|
||
}
|
||
|
||
/**
|
||
* Method to be called when binary data received from connection
|
||
* after a BINARY_EVENT packet.
|
||
*
|
||
* @param {Buffer | ArrayBuffer} binData - the raw binary data received
|
||
* @return {null | Object} returns null if more binary data is expected or
|
||
* a reconstructed packet object if all buffers have been received.
|
||
* @api private
|
||
*/
|
||
|
||
BinaryReconstructor.prototype.takeBinaryData = function(binData) {
|
||
this.buffers.push(binData);
|
||
if (this.buffers.length == this.reconPack.attachments) { // done with buffer list
|
||
var packet = binary.reconstructPacket(this.reconPack, this.buffers);
|
||
this.finishedReconstruction();
|
||
return packet;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* Cleans up binary packet reconstruction variables.
|
||
*
|
||
* @api private
|
||
*/
|
||
|
||
BinaryReconstructor.prototype.finishedReconstruction = function() {
|
||
this.reconPack = null;
|
||
this.buffers = [];
|
||
}
|
||
|
||
function error(data){
|
||
return {
|
||
type: exports.ERROR,
|
||
data: 'parser error'
|
||
};
|
||
}
|
||
|
||
},{"./binary":38,"__browserify_Buffer":9,"debug":10,"emitter":11,"isarray":40,"json3":41}],40:[function(require,module,exports){
|
||
module.exports=require(32)
|
||
},{}],41:[function(require,module,exports){
|
||
/*! JSON v3.2.6 | http://bestiejs.github.io/json3 | Copyright 2012-2013, Kit Cambridge | http://kit.mit-license.org */
|
||
;(function (window) {
|
||
// Convenience aliases.
|
||
var getClass = {}.toString, isProperty, forEach, undef;
|
||
|
||
// Detect the `define` function exposed by asynchronous module loaders. The
|
||
// strict `define` check is necessary for compatibility with `r.js`.
|
||
var isLoader = typeof define === "function" && define.amd;
|
||
|
||
// Detect native implementations.
|
||
var nativeJSON = typeof JSON == "object" && JSON;
|
||
|
||
// Set up the JSON 3 namespace, preferring the CommonJS `exports` object if
|
||
// available.
|
||
var JSON3 = typeof exports == "object" && exports && !exports.nodeType && exports;
|
||
|
||
if (JSON3 && nativeJSON) {
|
||
// Explicitly delegate to the native `stringify` and `parse`
|
||
// implementations in CommonJS environments.
|
||
JSON3.stringify = nativeJSON.stringify;
|
||
JSON3.parse = nativeJSON.parse;
|
||
} else {
|
||
// Export for web browsers, JavaScript engines, and asynchronous module
|
||
// loaders, using the global `JSON` object if available.
|
||
JSON3 = window.JSON = nativeJSON || {};
|
||
}
|
||
|
||
// Test the `Date#getUTC*` methods. Based on work by @Yaffle.
|
||
var isExtended = new Date(-3509827334573292);
|
||
try {
|
||
// The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical
|
||
// results for certain dates in Opera >= 10.53.
|
||
isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&
|
||
// Safari < 2.0.2 stores the internal millisecond time value correctly,
|
||
// but clips the values returned by the date methods to the range of
|
||
// signed 32-bit integers ([-2 ** 31, 2 ** 31 - 1]).
|
||
isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;
|
||
} catch (exception) {}
|
||
|
||
// Internal: Determines whether the native `JSON.stringify` and `parse`
|
||
// implementations are spec-compliant. Based on work by Ken Snyder.
|
||
function has(name) {
|
||
if (has[name] !== undef) {
|
||
// Return cached feature test result.
|
||
return has[name];
|
||
}
|
||
|
||
var isSupported;
|
||
if (name == "bug-string-char-index") {
|
||
// IE <= 7 doesn't support accessing string characters using square
|
||
// bracket notation. IE 8 only supports this for primitives.
|
||
isSupported = "a"[0] != "a";
|
||
} else if (name == "json") {
|
||
// Indicates whether both `JSON.stringify` and `JSON.parse` are
|
||
// supported.
|
||
isSupported = has("json-stringify") && has("json-parse");
|
||
} else {
|
||
var value, serialized = '{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}';
|
||
// Test `JSON.stringify`.
|
||
if (name == "json-stringify") {
|
||
var stringify = JSON3.stringify, stringifySupported = typeof stringify == "function" && isExtended;
|
||
if (stringifySupported) {
|
||
// A test function object with a custom `toJSON` method.
|
||
(value = function () {
|
||
return 1;
|
||
}).toJSON = value;
|
||
try {
|
||
stringifySupported =
|
||
// Firefox 3.1b1 and b2 serialize string, number, and boolean
|
||
// primitives as object literals.
|
||
stringify(0) === "0" &&
|
||
// FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object
|
||
// literals.
|
||
stringify(new Number()) === "0" &&
|
||
stringify(new String()) == '""' &&
|
||
// FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or
|
||
// does not define a canonical JSON representation (this applies to
|
||
// objects with `toJSON` properties as well, *unless* they are nested
|
||
// within an object or array).
|
||
stringify(getClass) === undef &&
|
||
// IE 8 serializes `undefined` as `"undefined"`. Safari <= 5.1.7 and
|
||
// FF 3.1b3 pass this test.
|
||
stringify(undef) === undef &&
|
||
// Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,
|
||
// respectively, if the value is omitted entirely.
|
||
stringify() === undef &&
|
||
// FF 3.1b1, 2 throw an error if the given value is not a number,
|
||
// string, array, object, Boolean, or `null` literal. This applies to
|
||
// objects with custom `toJSON` methods as well, unless they are nested
|
||
// inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`
|
||
// methods entirely.
|
||
stringify(value) === "1" &&
|
||
stringify([value]) == "[1]" &&
|
||
// Prototype <= 1.6.1 serializes `[undefined]` as `"[]"` instead of
|
||
// `"[null]"`.
|
||
stringify([undef]) == "[null]" &&
|
||
// YUI 3.0.0b1 fails to serialize `null` literals.
|
||
stringify(null) == "null" &&
|
||
// FF 3.1b1, 2 halts serialization if an array contains a function:
|
||
// `[1, true, getClass, 1]` serializes as "[1,true,],". FF 3.1b3
|
||
// elides non-JSON values from objects and arrays, unless they
|
||
// define custom `toJSON` methods.
|
||
stringify([undef, getClass, null]) == "[null,null,null]" &&
|
||
// Simple serialization test. FF 3.1b1 uses Unicode escape sequences
|
||
// where character escape codes are expected (e.g., `\b` => `\u0008`).
|
||
stringify({ "a": [value, true, false, null, "\x00\b\n\f\r\t"] }) == serialized &&
|
||
// FF 3.1b1 and b2 ignore the `filter` and `width` arguments.
|
||
stringify(null, value) === "1" &&
|
||
stringify([1, 2], null, 1) == "[\n 1,\n 2\n]" &&
|
||
// JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly
|
||
// serialize extended years.
|
||
stringify(new Date(-8.64e15)) == '"-271821-04-20T00:00:00.000Z"' &&
|
||
// The milliseconds are optional in ES 5, but required in 5.1.
|
||
stringify(new Date(8.64e15)) == '"+275760-09-13T00:00:00.000Z"' &&
|
||
// Firefox <= 11.0 incorrectly serializes years prior to 0 as negative
|
||
// four-digit years instead of six-digit years. Credits: @Yaffle.
|
||
stringify(new Date(-621987552e5)) == '"-000001-01-01T00:00:00.000Z"' &&
|
||
// Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond
|
||
// values less than 1000. Credits: @Yaffle.
|
||
stringify(new Date(-1)) == '"1969-12-31T23:59:59.999Z"';
|
||
} catch (exception) {
|
||
stringifySupported = false;
|
||
}
|
||
}
|
||
isSupported = stringifySupported;
|
||
}
|
||
// Test `JSON.parse`.
|
||
if (name == "json-parse") {
|
||
var parse = JSON3.parse;
|
||
if (typeof parse == "function") {
|
||
try {
|
||
// FF 3.1b1, b2 will throw an exception if a bare literal is provided.
|
||
// Conforming implementations should also coerce the initial argument to
|
||
// a string prior to parsing.
|
||
if (parse("0") === 0 && !parse(false)) {
|
||
// Simple parsing test.
|
||
value = parse(serialized);
|
||
var parseSupported = value["a"].length == 5 && value["a"][0] === 1;
|
||
if (parseSupported) {
|
||
try {
|
||
// Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.
|
||
parseSupported = !parse('"\t"');
|
||
} catch (exception) {}
|
||
if (parseSupported) {
|
||
try {
|
||
// FF 4.0 and 4.0.1 allow leading `+` signs and leading
|
||
// decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow
|
||
// certain octal literals.
|
||
parseSupported = parse("01") !== 1;
|
||
} catch (exception) {}
|
||
}
|
||
if (parseSupported) {
|
||
try {
|
||
// FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal
|
||
// points. These environments, along with FF 3.1b1 and 2,
|
||
// also allow trailing commas in JSON objects and arrays.
|
||
parseSupported = parse("1.") !== 1;
|
||
} catch (exception) {}
|
||
}
|
||
}
|
||
}
|
||
} catch (exception) {
|
||
parseSupported = false;
|
||
}
|
||
}
|
||
isSupported = parseSupported;
|
||
}
|
||
}
|
||
return has[name] = !!isSupported;
|
||
}
|
||
|
||
if (!has("json")) {
|
||
// Common `[[Class]]` name aliases.
|
||
var functionClass = "[object Function]";
|
||
var dateClass = "[object Date]";
|
||
var numberClass = "[object Number]";
|
||
var stringClass = "[object String]";
|
||
var arrayClass = "[object Array]";
|
||
var booleanClass = "[object Boolean]";
|
||
|
||
// Detect incomplete support for accessing string characters by index.
|
||
var charIndexBuggy = has("bug-string-char-index");
|
||
|
||
// Define additional utility methods if the `Date` methods are buggy.
|
||
if (!isExtended) {
|
||
var floor = Math.floor;
|
||
// A mapping between the months of the year and the number of days between
|
||
// January 1st and the first of the respective month.
|
||
var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
|
||
// Internal: Calculates the number of days between the Unix epoch and the
|
||
// first day of the given month.
|
||
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);
|
||
};
|
||
}
|
||
|
||
// Internal: Determines if a property is a direct property of the given
|
||
// object. Delegates to the native `Object#hasOwnProperty` method.
|
||
if (!(isProperty = {}.hasOwnProperty)) {
|
||
isProperty = function (property) {
|
||
var members = {}, constructor;
|
||
if ((members.__proto__ = null, members.__proto__ = {
|
||
// The *proto* property cannot be set multiple times in recent
|
||
// versions of Firefox and SeaMonkey.
|
||
"toString": 1
|
||
}, members).toString != getClass) {
|
||
// Safari <= 2.0.3 doesn't implement `Object#hasOwnProperty`, but
|
||
// supports the mutable *proto* property.
|
||
isProperty = function (property) {
|
||
// Capture and break the object's prototype chain (see section 8.6.2
|
||
// of the ES 5.1 spec). The parenthesized expression prevents an
|
||
// unsafe transformation by the Closure Compiler.
|
||
var original = this.__proto__, result = property in (this.__proto__ = null, this);
|
||
// Restore the original prototype chain.
|
||
this.__proto__ = original;
|
||
return result;
|
||
};
|
||
} else {
|
||
// Capture a reference to the top-level `Object` constructor.
|
||
constructor = members.constructor;
|
||
// Use the `constructor` property to simulate `Object#hasOwnProperty` in
|
||
// other environments.
|
||
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);
|
||
};
|
||
}
|
||
|
||
// Internal: A set of primitive types used by `isHostType`.
|
||
var PrimitiveTypes = {
|
||
'boolean': 1,
|
||
'number': 1,
|
||
'string': 1,
|
||
'undefined': 1
|
||
};
|
||
|
||
// Internal: Determines if the given object `property` value is a
|
||
// non-primitive.
|
||
var isHostType = function (object, property) {
|
||
var type = typeof object[property];
|
||
return type == 'object' ? !!object[property] : !PrimitiveTypes[type];
|
||
};
|
||
|
||
// Internal: Normalizes the `for...in` iteration algorithm across
|
||
// environments. Each enumerated key is yielded to a `callback` function.
|
||
forEach = function (object, callback) {
|
||
var size = 0, Properties, members, property;
|
||
|
||
// Tests for bugs in the current environment's `for...in` algorithm. The
|
||
// `valueOf` property inherits the non-enumerable flag from
|
||
// `Object.prototype` in older versions of IE, Netscape, and Mozilla.
|
||
(Properties = function () {
|
||
this.valueOf = 0;
|
||
}).prototype.valueOf = 0;
|
||
|
||
// Iterate over a new instance of the `Properties` class.
|
||
members = new Properties();
|
||
for (property in members) {
|
||
// Ignore all properties inherited from `Object.prototype`.
|
||
if (isProperty.call(members, property)) {
|
||
size++;
|
||
}
|
||
}
|
||
Properties = members = null;
|
||
|
||
// Normalize the iteration algorithm.
|
||
if (!size) {
|
||
// A list of non-enumerable properties inherited from `Object.prototype`.
|
||
members = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];
|
||
// IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable
|
||
// properties.
|
||
forEach = function (object, callback) {
|
||
var isFunction = getClass.call(object) == functionClass, property, length;
|
||
var hasProperty = !isFunction && typeof object.constructor != 'function' && isHostType(object, 'hasOwnProperty') ? object.hasOwnProperty : isProperty;
|
||
for (property in object) {
|
||
// Gecko <= 1.0 enumerates the `prototype` property of functions under
|
||
// certain conditions; IE does not.
|
||
if (!(isFunction && property == "prototype") && hasProperty.call(object, property)) {
|
||
callback(property);
|
||
}
|
||
}
|
||
// Manually invoke the callback for each non-enumerable property.
|
||
for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));
|
||
};
|
||
} else if (size == 2) {
|
||
// Safari <= 2.0.4 enumerates shadowed properties twice.
|
||
forEach = function (object, callback) {
|
||
// Create a set of iterated properties.
|
||
var members = {}, isFunction = getClass.call(object) == functionClass, property;
|
||
for (property in object) {
|
||
// Store each property name to prevent double enumeration. The
|
||
// `prototype` property of functions is not enumerated due to cross-
|
||
// environment inconsistencies.
|
||
if (!(isFunction && property == "prototype") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {
|
||
callback(property);
|
||
}
|
||
}
|
||
};
|
||
} else {
|
||
// No bugs detected; use the standard `for...in` algorithm.
|
||
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);
|
||
}
|
||
}
|
||
// Manually invoke the callback for the `constructor` property due to
|
||
// cross-environment inconsistencies.
|
||
if (isConstructor || isProperty.call(object, (property = "constructor"))) {
|
||
callback(property);
|
||
}
|
||
};
|
||
}
|
||
return forEach(object, callback);
|
||
};
|
||
|
||
// Public: Serializes a JavaScript `value` as a JSON string. The optional
|
||
// `filter` argument may specify either a function that alters how object and
|
||
// array members are serialized, or an array of strings and numbers that
|
||
// indicates which properties should be serialized. The optional `width`
|
||
// argument may be either a string or number that specifies the indentation
|
||
// level of the output.
|
||
if (!has("json-stringify")) {
|
||
// Internal: A map of control characters and their escaped equivalents.
|
||
var Escapes = {
|
||
92: "\\\\",
|
||
34: '\\"',
|
||
8: "\\b",
|
||
12: "\\f",
|
||
10: "\\n",
|
||
13: "\\r",
|
||
9: "\\t"
|
||
};
|
||
|
||
// Internal: Converts `value` into a zero-padded string such that its
|
||
// length is at least equal to `width`. The `width` must be <= 6.
|
||
var leadingZeroes = "000000";
|
||
var toPaddedString = function (width, value) {
|
||
// The `|| 0` expression is necessary to work around a bug in
|
||
// Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== "0"`.
|
||
return (leadingZeroes + (value || 0)).slice(-width);
|
||
};
|
||
|
||
// Internal: Double-quotes a string `value`, replacing all ASCII control
|
||
// characters (characters with code unit values between 0 and 31) with
|
||
// their escaped equivalents. This is an implementation of the
|
||
// `Quote(value)` operation defined in ES 5.1 section 15.12.3.
|
||
var unicodePrefix = "\\u00";
|
||
var quote = function (value) {
|
||
var result = '"', index = 0, length = value.length, isLarge = length > 10 && charIndexBuggy, symbols;
|
||
if (isLarge) {
|
||
symbols = value.split("");
|
||
}
|
||
for (; index < length; index++) {
|
||
var charCode = value.charCodeAt(index);
|
||
// If the character is a control character, append its Unicode or
|
||
// shorthand escape sequence; otherwise, append the character as-is.
|
||
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 += isLarge ? symbols[index] : charIndexBuggy ? value.charAt(index) : value[index];
|
||
}
|
||
}
|
||
return result + '"';
|
||
};
|
||
|
||
// Internal: Recursively serializes an object. Implements the
|
||
// `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.
|
||
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 {
|
||
// Necessary for host object support.
|
||
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) {
|
||
// Dates are serialized according to the `Date#toJSON` method
|
||
// specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15
|
||
// for the ISO 8601 date time string format.
|
||
if (getDay) {
|
||
// Manually compute the year, month, date, hours, minutes,
|
||
// seconds, and milliseconds if the `getUTC*` methods are
|
||
// buggy. Adapted from @Yaffle's `date-shim` project.
|
||
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);
|
||
// The `time` value specifies the time within the day (see ES
|
||
// 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used
|
||
// to compute `A modulo B`, as the `%` operator does not
|
||
// correspond to the `modulo` operation for negative numbers.
|
||
time = (value % 864e5 + 864e5) % 864e5;
|
||
// The hours, minutes, seconds, and milliseconds are obtained by
|
||
// decomposing the time within the day. See section 15.9.1.10.
|
||
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();
|
||
}
|
||
// Serialize extended years correctly.
|
||
value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-" : "+") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +
|
||
"-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) +
|
||
// Months, dates, hours, minutes, and seconds should have two
|
||
// digits; milliseconds should have three.
|
||
"T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) +
|
||
// Milliseconds are optional in ES 5.0, but required in 5.1.
|
||
"." + toPaddedString(3, milliseconds) + "Z";
|
||
} else {
|
||
value = null;
|
||
}
|
||
} else if (typeof value.toJSON == "function" && ((className != numberClass && className != stringClass && className != arrayClass) || isProperty.call(value, "toJSON"))) {
|
||
// Prototype <= 1.6.1 adds non-standard `toJSON` methods to the
|
||
// `Number`, `String`, `Date`, and `Array` prototypes. JSON 3
|
||
// ignores all `toJSON` methods on these objects unless they are
|
||
// defined directly on an instance.
|
||
value = value.toJSON(property);
|
||
}
|
||
}
|
||
if (callback) {
|
||
// If a replacement function was provided, call it to obtain the value
|
||
// for serialization.
|
||
value = callback.call(object, property, value);
|
||
}
|
||
if (value === null) {
|
||
return "null";
|
||
}
|
||
className = getClass.call(value);
|
||
if (className == booleanClass) {
|
||
// Booleans are represented literally.
|
||
return "" + value;
|
||
} else if (className == numberClass) {
|
||
// JSON numbers must be finite. `Infinity` and `NaN` are serialized as
|
||
// `"null"`.
|
||
return value > -1 / 0 && value < 1 / 0 ? "" + value : "null";
|
||
} else if (className == stringClass) {
|
||
// Strings are double-quoted and escaped.
|
||
return quote("" + value);
|
||
}
|
||
// Recursively serialize objects and arrays.
|
||
if (typeof value == "object") {
|
||
// Check for cyclic structures. This is a linear search; performance
|
||
// is inversely proportional to the number of unique nested objects.
|
||
for (length = stack.length; length--;) {
|
||
if (stack[length] === value) {
|
||
// Cyclic structures cannot be serialized by `JSON.stringify`.
|
||
throw TypeError();
|
||
}
|
||
}
|
||
// Add the object to the stack of traversed objects.
|
||
stack.push(value);
|
||
results = [];
|
||
// Save the current indentation level and indent one additional level.
|
||
prefix = indentation;
|
||
indentation += whitespace;
|
||
if (className == arrayClass) {
|
||
// Recursively serialize array elements.
|
||
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 {
|
||
// Recursively serialize object members. Members are selected from
|
||
// either a user-specified list of property names, or the object
|
||
// itself.
|
||
forEach(properties || value, function (property) {
|
||
var element = serialize(property, value, callback, properties, whitespace, indentation, stack);
|
||
if (element !== undef) {
|
||
// According to ES 5.1 section 15.12.3: "If `gap` {whitespace}
|
||
// is not the empty string, let `member` {quote(property) + ":"}
|
||
// be the concatenation of `member` and the `space` character."
|
||
// The "`space` character" refers to the literal space
|
||
// character, not the `space` {width} argument provided to
|
||
// `JSON.stringify`.
|
||
results.push(quote(property) + ":" + (whitespace ? " " : "") + element);
|
||
}
|
||
});
|
||
result = results.length ? (whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}" : ("{" + results.join(",") + "}")) : "{}";
|
||
}
|
||
// Remove the object from the traversed object stack.
|
||
stack.pop();
|
||
return result;
|
||
}
|
||
};
|
||
|
||
// Public: `JSON.stringify`. See ES 5.1 section 15.12.3.
|
||
JSON3.stringify = function (source, filter, width) {
|
||
var whitespace, callback, properties, className;
|
||
if (typeof filter == "function" || typeof filter == "object" && filter) {
|
||
if ((className = getClass.call(filter)) == functionClass) {
|
||
callback = filter;
|
||
} else if (className == arrayClass) {
|
||
// Convert the property names array into a makeshift set.
|
||
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) {
|
||
// Convert the `width` to an integer and create a string containing
|
||
// `width` number of space characters.
|
||
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);
|
||
}
|
||
}
|
||
// Opera <= 7.54u2 discards the values associated with empty string keys
|
||
// (`""`) only if they are used directly within an object member list
|
||
// (e.g., `!("" in { "": 1})`).
|
||
return serialize("", (value = {}, value[""] = source, value), callback, properties, whitespace, "", []);
|
||
};
|
||
}
|
||
|
||
// Public: Parses a JSON source string.
|
||
if (!has("json-parse")) {
|
||
var fromCharCode = String.fromCharCode;
|
||
|
||
// Internal: A map of escaped control characters and their unescaped
|
||
// equivalents.
|
||
var Unescapes = {
|
||
92: "\\",
|
||
34: '"',
|
||
47: "/",
|
||
98: "\b",
|
||
116: "\t",
|
||
110: "\n",
|
||
102: "\f",
|
||
114: "\r"
|
||
};
|
||
|
||
// Internal: Stores the parser state.
|
||
var Index, Source;
|
||
|
||
// Internal: Resets the parser state and throws a `SyntaxError`.
|
||
var abort = function() {
|
||
Index = Source = null;
|
||
throw SyntaxError();
|
||
};
|
||
|
||
// Internal: Returns the next token, or `"$"` if the parser has reached
|
||
// the end of the source string. A token may be a string, number, `null`
|
||
// literal, or Boolean literal.
|
||
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:
|
||
// Skip whitespace tokens, including tabs, carriage returns, line
|
||
// feeds, and space characters.
|
||
Index++;
|
||
break;
|
||
case 123: case 125: case 91: case 93: case 58: case 44:
|
||
// Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at
|
||
// the current position.
|
||
value = charIndexBuggy ? source.charAt(Index) : source[Index];
|
||
Index++;
|
||
return value;
|
||
case 34:
|
||
// `"` delimits a JSON string; advance to the next character and
|
||
// begin parsing the string. String tokens are prefixed with the
|
||
// sentinel `@` character to distinguish them from punctuators and
|
||
// end-of-string tokens.
|
||
for (value = "@", Index++; Index < length;) {
|
||
charCode = source.charCodeAt(Index);
|
||
if (charCode < 32) {
|
||
// Unescaped ASCII control characters (those with a code unit
|
||
// less than the space character) are not permitted.
|
||
abort();
|
||
} else if (charCode == 92) {
|
||
// A reverse solidus (`\`) marks the beginning of an escaped
|
||
// control character (including `"`, `\`, and `/`) or Unicode
|
||
// escape sequence.
|
||
charCode = source.charCodeAt(++Index);
|
||
switch (charCode) {
|
||
case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:
|
||
// Revive escaped control characters.
|
||
value += Unescapes[charCode];
|
||
Index++;
|
||
break;
|
||
case 117:
|
||
// `\u` marks the beginning of a Unicode escape sequence.
|
||
// Advance to the first character and validate the
|
||
// four-digit code point.
|
||
begin = ++Index;
|
||
for (position = Index + 4; Index < position; Index++) {
|
||
charCode = source.charCodeAt(Index);
|
||
// A valid sequence comprises four hexdigits (case-
|
||
// insensitive) that form a single hexadecimal value.
|
||
if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {
|
||
// Invalid Unicode escape sequence.
|
||
abort();
|
||
}
|
||
}
|
||
// Revive the escaped character.
|
||
value += fromCharCode("0x" + source.slice(begin, Index));
|
||
break;
|
||
default:
|
||
// Invalid escape sequence.
|
||
abort();
|
||
}
|
||
} else {
|
||
if (charCode == 34) {
|
||
// An unescaped double-quote character marks the end of the
|
||
// string.
|
||
break;
|
||
}
|
||
charCode = source.charCodeAt(Index);
|
||
begin = Index;
|
||
// Optimize for the common case where a string is valid.
|
||
while (charCode >= 32 && charCode != 92 && charCode != 34) {
|
||
charCode = source.charCodeAt(++Index);
|
||
}
|
||
// Append the string as-is.
|
||
value += source.slice(begin, Index);
|
||
}
|
||
}
|
||
if (source.charCodeAt(Index) == 34) {
|
||
// Advance to the next character and return the revived string.
|
||
Index++;
|
||
return value;
|
||
}
|
||
// Unterminated string.
|
||
abort();
|
||
default:
|
||
// Parse numbers and literals.
|
||
begin = Index;
|
||
// Advance past the negative sign, if one is specified.
|
||
if (charCode == 45) {
|
||
isSigned = true;
|
||
charCode = source.charCodeAt(++Index);
|
||
}
|
||
// Parse an integer or floating-point value.
|
||
if (charCode >= 48 && charCode <= 57) {
|
||
// Leading zeroes are interpreted as octal literals.
|
||
if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {
|
||
// Illegal octal literal.
|
||
abort();
|
||
}
|
||
isSigned = false;
|
||
// Parse the integer component.
|
||
for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);
|
||
// Floats cannot contain a leading decimal point; however, this
|
||
// case is already accounted for by the parser.
|
||
if (source.charCodeAt(Index) == 46) {
|
||
position = ++Index;
|
||
// Parse the decimal component.
|
||
for (; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);
|
||
if (position == Index) {
|
||
// Illegal trailing decimal.
|
||
abort();
|
||
}
|
||
Index = position;
|
||
}
|
||
// Parse exponents. The `e` denoting the exponent is
|
||
// case-insensitive.
|
||
charCode = source.charCodeAt(Index);
|
||
if (charCode == 101 || charCode == 69) {
|
||
charCode = source.charCodeAt(++Index);
|
||
// Skip past the sign following the exponent, if one is
|
||
// specified.
|
||
if (charCode == 43 || charCode == 45) {
|
||
Index++;
|
||
}
|
||
// Parse the exponential component.
|
||
for (position = Index; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);
|
||
if (position == Index) {
|
||
// Illegal empty exponent.
|
||
abort();
|
||
}
|
||
Index = position;
|
||
}
|
||
// Coerce the parsed value to a JavaScript number.
|
||
return +source.slice(begin, Index);
|
||
}
|
||
// A negative sign may only precede numbers.
|
||
if (isSigned) {
|
||
abort();
|
||
}
|
||
// `true`, `false`, and `null` literals.
|
||
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;
|
||
}
|
||
// Unrecognized token.
|
||
abort();
|
||
}
|
||
}
|
||
// Return the sentinel `$` character if the parser has reached the end
|
||
// of the source string.
|
||
return "$";
|
||
};
|
||
|
||
// Internal: Parses a JSON `value` token.
|
||
var get = function (value) {
|
||
var results, hasMembers;
|
||
if (value == "$") {
|
||
// Unexpected end of input.
|
||
abort();
|
||
}
|
||
if (typeof value == "string") {
|
||
if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") {
|
||
// Remove the sentinel `@` character.
|
||
return value.slice(1);
|
||
}
|
||
// Parse object and array literals.
|
||
if (value == "[") {
|
||
// Parses a JSON array, returning a new JavaScript array.
|
||
results = [];
|
||
for (;; hasMembers || (hasMembers = true)) {
|
||
value = lex();
|
||
// A closing square bracket marks the end of the array literal.
|
||
if (value == "]") {
|
||
break;
|
||
}
|
||
// If the array literal contains elements, the current token
|
||
// should be a comma separating the previous element from the
|
||
// next.
|
||
if (hasMembers) {
|
||
if (value == ",") {
|
||
value = lex();
|
||
if (value == "]") {
|
||
// Unexpected trailing `,` in array literal.
|
||
abort();
|
||
}
|
||
} else {
|
||
// A `,` must separate each array element.
|
||
abort();
|
||
}
|
||
}
|
||
// Elisions and leading commas are not permitted.
|
||
if (value == ",") {
|
||
abort();
|
||
}
|
||
results.push(get(value));
|
||
}
|
||
return results;
|
||
} else if (value == "{") {
|
||
// Parses a JSON object, returning a new JavaScript object.
|
||
results = {};
|
||
for (;; hasMembers || (hasMembers = true)) {
|
||
value = lex();
|
||
// A closing curly brace marks the end of the object literal.
|
||
if (value == "}") {
|
||
break;
|
||
}
|
||
// If the object literal contains members, the current token
|
||
// should be a comma separator.
|
||
if (hasMembers) {
|
||
if (value == ",") {
|
||
value = lex();
|
||
if (value == "}") {
|
||
// Unexpected trailing `,` in object literal.
|
||
abort();
|
||
}
|
||
} else {
|
||
// A `,` must separate each object member.
|
||
abort();
|
||
}
|
||
}
|
||
// Leading commas are not permitted, object property names must be
|
||
// double-quoted strings, and a `:` must separate each property
|
||
// name and value.
|
||
if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") {
|
||
abort();
|
||
}
|
||
results[value.slice(1)] = get(lex());
|
||
}
|
||
return results;
|
||
}
|
||
// Unexpected token encountered.
|
||
abort();
|
||
}
|
||
return value;
|
||
};
|
||
|
||
// Internal: Updates a traversed object member.
|
||
var update = function(source, property, callback) {
|
||
var element = walk(source, property, callback);
|
||
if (element === undef) {
|
||
delete source[property];
|
||
} else {
|
||
source[property] = element;
|
||
}
|
||
};
|
||
|
||
// Internal: Recursively traverses a parsed JSON object, invoking the
|
||
// `callback` function for each value. This is an implementation of the
|
||
// `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.
|
||
var walk = function (source, property, callback) {
|
||
var value = source[property], length;
|
||
if (typeof value == "object" && value) {
|
||
// `forEach` can't be used to traverse an array in Opera <= 8.54
|
||
// because its `Object#hasOwnProperty` implementation returns `false`
|
||
// for array indices (e.g., `![1, 2, 3].hasOwnProperty("0")`).
|
||
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);
|
||
};
|
||
|
||
// Public: `JSON.parse`. See ES 5.1 section 15.12.2.
|
||
JSON3.parse = function (source, callback) {
|
||
var result, value;
|
||
Index = 0;
|
||
Source = "" + source;
|
||
result = get(lex());
|
||
// If a JSON string contains multiple tokens, it is invalid.
|
||
if (lex() != "$") {
|
||
abort();
|
||
}
|
||
// Reset the parser state.
|
||
Index = Source = null;
|
||
return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[""] = result, value), "", callback) : result;
|
||
};
|
||
}
|
||
}
|
||
|
||
// Export for asynchronous module loaders.
|
||
if (isLoader) {
|
||
define(function () {
|
||
return JSON3;
|
||
});
|
||
}
|
||
}(this));
|
||
|
||
},{}],42:[function(require,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
|
||
}
|
||
|
||
},{}]},{},[1])
|
||
(1)
|
||
});
|
||
;
|