All Downloads are FREE. Search and download functionalities are using the official Maven repository.

META-INF.resources.websocket.sockjs.js Maven / Gradle / Ivy

The newest version!
/* SockJS client, version 0.3.4, http://sockjs.org, MIT License

 Copyright (c) 2011-2012 VMware, Inc.

 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.
 */

// JSON2 by Douglas Crockford (minified).
var JSON;JSON||(JSON={}),function(){function str(a,b){var c,d,e,f,g=gap,h,i=b[a];i&&typeof i=="object"&&typeof i.toJSON=="function"&&(i=i.toJSON(a)),typeof rep=="function"&&(i=rep.call(b,a,i));switch(typeof i){case"string":return quote(i);case"number":return isFinite(i)?String(i):"null";case"boolean":case"null":return String(i);case"object":if(!i)return"null";gap+=indent,h=[];if(Object.prototype.toString.apply(i)==="[object Array]"){f=i.length;for(c=0;c 1) {
                this._listeners[eventType] = arr.slice(0, idx).concat( arr.slice(idx+1) );
            } else {
                delete this._listeners[eventType];
            }
            return;
        }
        return;
    };

    REventTarget.prototype.dispatchEvent = function (event) {
        var t = event.type;
        var args = Array.prototype.slice.call(arguments, 0);
        if (this['on'+t]) {
            this['on'+t].apply(this, args);
        }
        if (this._listeners && t in this._listeners) {
            for(var i=0; i < this._listeners[t].length; i++) {
                this._listeners[t][i].apply(this, args);
            }
        }
    };
//         [*] End of lib/reventtarget.js


//         [*] Including lib/simpleevent.js
    /*
     * ***** BEGIN LICENSE BLOCK *****
     * Copyright (c) 2011-2012 VMware, Inc.
     *
     * For the license see COPYING.
     * ***** END LICENSE BLOCK *****
     */

    var SimpleEvent = function(type, obj) {
        this.type = type;
        if (typeof obj !== 'undefined') {
            for(var k in obj) {
                if (!obj.hasOwnProperty(k)) continue;
                this[k] = obj[k];
            }
        }
    };

    SimpleEvent.prototype.toString = function() {
        var r = [];
        for(var k in this) {
            if (!this.hasOwnProperty(k)) continue;
            var v = this[k];
            if (typeof v === 'function') v = '[function]';
            r.push(k + '=' + v);
        }
        return 'SimpleEvent(' + r.join(', ') + ')';
    };
//         [*] End of lib/simpleevent.js


//         [*] Including lib/eventemitter.js
    /*
     * ***** BEGIN LICENSE BLOCK *****
     * Copyright (c) 2011-2012 VMware, Inc.
     *
     * For the license see COPYING.
     * ***** END LICENSE BLOCK *****
     */

    var EventEmitter = function(events) {
        var that = this;
        that._events = events || [];
        that._listeners = {};
    };
    EventEmitter.prototype.emit = function(type) {
        var that = this;
        that._verifyType(type);
        if (that._nuked) return;

        var args = Array.prototype.slice.call(arguments, 1);
        if (that['on'+type]) {
            that['on'+type].apply(that, args);
        }
        if (type in that._listeners) {
            for(var i = 0; i < that._listeners[type].length; i++) {
                that._listeners[type][i].apply(that, args);
            }
        }
    };

    EventEmitter.prototype.on = function(type, callback) {
        var that = this;
        that._verifyType(type);
        if (that._nuked) return;

        if (!(type in that._listeners)) {
            that._listeners[type] = [];
        }
        that._listeners[type].push(callback);
    };

    EventEmitter.prototype._verifyType = function(type) {
        var that = this;
        if (utils.arrIndexOf(that._events, type) === -1) {
            utils.log('Event ' + JSON.stringify(type) +
                ' not listed ' + JSON.stringify(that._events) +
                ' in ' + that);
        }
    };

    EventEmitter.prototype.nuke = function() {
        var that = this;
        that._nuked = true;
        for(var i=0; i= 3000 && code <= 4999);
    };

// See: http://www.erg.abdn.ac.uk/~gerrit/dccp/notes/ccid2/rto_estimator/
// and RFC 2988.
    utils.countRTO = function (rtt) {
        var rto;
        if (rtt > 100) {
            rto = 3 * rtt; // rto > 300msec
        } else {
            rto = rtt + 200; // 200msec < rto <= 300msec
        }
        return rto;
    }

    utils.log = function() {
        if (_window.console && console.log && console.log.apply) {
            console.log.apply(console, arguments);
        }
    };

    utils.bind = function(fun, that) {
        if (fun.bind) {
            return fun.bind(that);
        } else {
            return function() {
                return fun.apply(that, arguments);
            };
        }
    };

    utils.flatUrl = function(url) {
        return url.indexOf('?') === -1 && url.indexOf('#') === -1;
    };

    utils.amendUrl = function(url) {
        var dl = _document.location;
        if (!url) {
            throw new Error('Wrong url for SockJS');
        }
        if (!utils.flatUrl(url)) {
            throw new Error('Only basic urls are supported in SockJS');
        }

        //  '//abc' --> 'http://abc'
        if (url.indexOf('//') === 0) {
            url = dl.protocol + url;
        }
        // '/abc' --> 'http://localhost:80/abc'
        if (url.indexOf('/') === 0) {
            url = dl.protocol + '//' + dl.host + url;
        }
        // strip trailing slashes
        url = url.replace(/[/]+$/,'');
        return url;
    };

// IE doesn't support [].indexOf.
    utils.arrIndexOf = function(arr, obj){
        for(var i=0; i < arr.length; i++){
            if(arr[i] === obj){
                return i;
            }
        }
        return -1;
    };

    utils.arrSkip = function(arr, obj) {
        var idx = utils.arrIndexOf(arr, obj);
        if (idx === -1) {
            return arr.slice();
        } else {
            var dst = arr.slice(0, idx);
            return dst.concat(arr.slice(idx+1));
        }
    };

// Via: https://gist.github.com/1133122/2121c601c5549155483f50be3da5305e83b8c5df
    utils.isArray = Array.isArray || function(value) {
            return {}.toString.call(value).indexOf('Array') >= 0
        };

    utils.delay = function(t, fun) {
        if(typeof t === 'function') {
            fun = t;
            t = 0;
        }
        return setTimeout(fun, t);
    };


// Chars worth escaping, as defined by Douglas Crockford:
//   https://github.com/douglascrockford/JSON-js/blob/47a9882cddeb1e8529e07af9736218075372b8ac/json2.js#L196
    var json_escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
        json_lookup = {
            "\u0000":"\\u0000","\u0001":"\\u0001","\u0002":"\\u0002","\u0003":"\\u0003",
            "\u0004":"\\u0004","\u0005":"\\u0005","\u0006":"\\u0006","\u0007":"\\u0007",
            "\b":"\\b","\t":"\\t","\n":"\\n","\u000b":"\\u000b","\f":"\\f","\r":"\\r",
            "\u000e":"\\u000e","\u000f":"\\u000f","\u0010":"\\u0010","\u0011":"\\u0011",
            "\u0012":"\\u0012","\u0013":"\\u0013","\u0014":"\\u0014","\u0015":"\\u0015",
            "\u0016":"\\u0016","\u0017":"\\u0017","\u0018":"\\u0018","\u0019":"\\u0019",
            "\u001a":"\\u001a","\u001b":"\\u001b","\u001c":"\\u001c","\u001d":"\\u001d",
            "\u001e":"\\u001e","\u001f":"\\u001f","\"":"\\\"","\\":"\\\\",
            "\u007f":"\\u007f","\u0080":"\\u0080","\u0081":"\\u0081","\u0082":"\\u0082",
            "\u0083":"\\u0083","\u0084":"\\u0084","\u0085":"\\u0085","\u0086":"\\u0086",
            "\u0087":"\\u0087","\u0088":"\\u0088","\u0089":"\\u0089","\u008a":"\\u008a",
            "\u008b":"\\u008b","\u008c":"\\u008c","\u008d":"\\u008d","\u008e":"\\u008e",
            "\u008f":"\\u008f","\u0090":"\\u0090","\u0091":"\\u0091","\u0092":"\\u0092",
            "\u0093":"\\u0093","\u0094":"\\u0094","\u0095":"\\u0095","\u0096":"\\u0096",
            "\u0097":"\\u0097","\u0098":"\\u0098","\u0099":"\\u0099","\u009a":"\\u009a",
            "\u009b":"\\u009b","\u009c":"\\u009c","\u009d":"\\u009d","\u009e":"\\u009e",
            "\u009f":"\\u009f","\u00ad":"\\u00ad","\u0600":"\\u0600","\u0601":"\\u0601",
            "\u0602":"\\u0602","\u0603":"\\u0603","\u0604":"\\u0604","\u070f":"\\u070f",
            "\u17b4":"\\u17b4","\u17b5":"\\u17b5","\u200c":"\\u200c","\u200d":"\\u200d",
            "\u200e":"\\u200e","\u200f":"\\u200f","\u2028":"\\u2028","\u2029":"\\u2029",
            "\u202a":"\\u202a","\u202b":"\\u202b","\u202c":"\\u202c","\u202d":"\\u202d",
            "\u202e":"\\u202e","\u202f":"\\u202f","\u2060":"\\u2060","\u2061":"\\u2061",
            "\u2062":"\\u2062","\u2063":"\\u2063","\u2064":"\\u2064","\u2065":"\\u2065",
            "\u2066":"\\u2066","\u2067":"\\u2067","\u2068":"\\u2068","\u2069":"\\u2069",
            "\u206a":"\\u206a","\u206b":"\\u206b","\u206c":"\\u206c","\u206d":"\\u206d",
            "\u206e":"\\u206e","\u206f":"\\u206f","\ufeff":"\\ufeff","\ufff0":"\\ufff0",
            "\ufff1":"\\ufff1","\ufff2":"\\ufff2","\ufff3":"\\ufff3","\ufff4":"\\ufff4",
            "\ufff5":"\\ufff5","\ufff6":"\\ufff6","\ufff7":"\\ufff7","\ufff8":"\\ufff8",
            "\ufff9":"\\ufff9","\ufffa":"\\ufffa","\ufffb":"\\ufffb","\ufffc":"\\ufffc",
            "\ufffd":"\\ufffd","\ufffe":"\\ufffe","\uffff":"\\uffff"};

// Some extra characters that Chrome gets wrong, and substitutes with
// something else on the wire.
    var extra_escapable = /[\x00-\x1f\ud800-\udfff\ufffe\uffff\u0300-\u0333\u033d-\u0346\u034a-\u034c\u0350-\u0352\u0357-\u0358\u035c-\u0362\u0374\u037e\u0387\u0591-\u05af\u05c4\u0610-\u0617\u0653-\u0654\u0657-\u065b\u065d-\u065e\u06df-\u06e2\u06eb-\u06ec\u0730\u0732-\u0733\u0735-\u0736\u073a\u073d\u073f-\u0741\u0743\u0745\u0747\u07eb-\u07f1\u0951\u0958-\u095f\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b5c-\u0b5d\u0e38-\u0e39\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f72-\u0f76\u0f78\u0f80-\u0f83\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1939-\u193a\u1a17\u1b6b\u1cda-\u1cdb\u1dc0-\u1dcf\u1dfc\u1dfe\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1fbb\u1fbe\u1fc9\u1fcb\u1fd3\u1fdb\u1fe3\u1feb\u1fee-\u1fef\u1ff9\u1ffb\u1ffd\u2000-\u2001\u20d0-\u20d1\u20d4-\u20d7\u20e7-\u20e9\u2126\u212a-\u212b\u2329-\u232a\u2adc\u302b-\u302c\uaab2-\uaab3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa2d\ufa30-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\ufff0-\uffff]/g,
        extra_lookup;

// JSON Quote string. Use native implementation when possible.
    var JSONQuote = (JSON && JSON.stringify) || function(string) {
            json_escapable.lastIndex = 0;
            if (json_escapable.test(string)) {
                string = string.replace(json_escapable, function(a) {
                    return json_lookup[a];
                });
            }
            return '"' + string + '"';
        };

// This may be quite slow, so let's delay until user actually uses bad
// characters.
    var unroll_lookup = function(escapable) {
        var i;
        var unrolled = {}
        var c = []
        for(i=0; i<65536; i++) {
            c.push( String.fromCharCode(i) );
        }
        escapable.lastIndex = 0;
        c.join('').replace(escapable, function (a) {
            unrolled[ a ] = '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
            return '';
        });
        escapable.lastIndex = 0;
        return unrolled;
    };

// Quote string, also taking care of unicode characters that browsers
// often break. Especially, take care of unicode surrogates:
//    http://en.wikipedia.org/wiki/Mapping_of_Unicode_characters#Surrogates
    utils.quote = function(string) {
        var quoted = JSONQuote(string);

        // In most cases this should be very fast and good enough.
        extra_escapable.lastIndex = 0;
        if(!extra_escapable.test(quoted)) {
            return quoted;
        }

        if(!extra_lookup) extra_lookup = unroll_lookup(extra_escapable);

        return quoted.replace(extra_escapable, function(a) {
            return extra_lookup[a];
        });
    }

    var _all_protocols = ['websocket',
        'xdr-streaming',
        'xhr-streaming',
        'iframe-eventsource',
        'iframe-htmlfile',
        'xdr-polling',
        'xhr-polling',
        'iframe-xhr-polling',
        'jsonp-polling'];

    utils.probeProtocols = function() {
        var probed = {};
        for(var i=0; i<_all_protocols.length; i++) {
            var protocol = _all_protocols[i];
            // User can have a typo in protocol name.
            probed[protocol] = SockJS[protocol] &&
                SockJS[protocol].enabled();
        }
        return probed;
    };

    utils.detectProtocols = function(probed, protocols_whitelist, info) {
        var pe = {},
            protocols = [];
        if (!protocols_whitelist) protocols_whitelist = _all_protocols;
        for(var i=0; i 0) {
                    maybe_push(protos);
                }
            }
        }

        // 1. Websocket
        if (info.websocket !== false) {
            maybe_push(['websocket']);
        }

        // 2. Streaming
        if (pe['xhr-streaming'] && !info.null_origin) {
            protocols.push('xhr-streaming');
        } else {
            if (pe['xdr-streaming'] && !info.cookie_needed && !info.null_origin) {
                protocols.push('xdr-streaming');
            } else {
                maybe_push(['iframe-eventsource',
                    'iframe-htmlfile']);
            }
        }

        // 3. Polling
        if (pe['xhr-polling'] && !info.null_origin) {
            protocols.push('xhr-polling');
        } else {
            if (pe['xdr-polling'] && !info.cookie_needed && !info.null_origin) {
                protocols.push('xdr-polling');
            } else {
                maybe_push(['iframe-xhr-polling',
                    'jsonp-polling']);
            }
        }
        return protocols;
    }
//         [*] End of lib/utils.js


//         [*] Including lib/dom.js
    /*
     * ***** BEGIN LICENSE BLOCK *****
     * Copyright (c) 2011-2012 VMware, Inc.
     *
     * For the license see COPYING.
     * ***** END LICENSE BLOCK *****
     */

// May be used by htmlfile jsonp and transports.
    var MPrefix = '_sockjs_global';
    utils.createHook = function() {
        var window_id = 'a' + utils.random_string(8);
        if (!(MPrefix in _window)) {
            var map = {};
            _window[MPrefix] = function(window_id) {
                if (!(window_id in map)) {
                    map[window_id] = {
                        id: window_id,
                        del: function() {delete map[window_id];}
                    };
                }
                return map[window_id];
            }
        }
        return _window[MPrefix](window_id);
    };



    utils.attachMessage = function(listener) {
        utils.attachEvent('message', listener);
    };
    utils.attachEvent = function(event, listener) {
        if (typeof _window.addEventListener !== 'undefined') {
            _window.addEventListener(event, listener, false);
        } else {
            // IE quirks.
            // According to: http://stevesouders.com/misc/test-postmessage.php
            // the message gets delivered only to 'document', not 'window'.
            _document.attachEvent("on" + event, listener);
            // I get 'window' for ie8.
            _window.attachEvent("on" + event, listener);
        }
    };

    utils.detachMessage = function(listener) {
        utils.detachEvent('message', listener);
    };
    utils.detachEvent = function(event, listener) {
        if (typeof _window.addEventListener !== 'undefined') {
            _window.removeEventListener(event, listener, false);
        } else {
            _document.detachEvent("on" + event, listener);
            _window.detachEvent("on" + event, listener);
        }
    };


    var on_unload = {};
// Things registered after beforeunload are to be called immediately.
    var after_unload = false;

    var trigger_unload_callbacks = function() {
        for(var ref in on_unload) {
            on_unload[ref]();
            delete on_unload[ref];
        };
    };

    var unload_triggered = function() {
        if(after_unload) return;
        after_unload = true;
        trigger_unload_callbacks();
    };

// 'unload' alone is not reliable in opera within an iframe, but we
// can't use `beforeunload` as IE fires it on javascript: links.
    utils.attachEvent('unload', unload_triggered);

    utils.unload_add = function(listener) {
        var ref = utils.random_string(8);
        on_unload[ref] = listener;
        if (after_unload) {
            utils.delay(trigger_unload_callbacks);
        }
        return ref;
    };
    utils.unload_del = function(ref) {
        if (ref in on_unload)
            delete on_unload[ref];
    };


    utils.createIframe = function (iframe_url, error_callback) {
        var iframe = _document.createElement('iframe');
        var tref, unload_ref;
        var unattach = function() {
            clearTimeout(tref);
            // Explorer had problems with that.
            try {iframe.onload = null;} catch (x) {}
            iframe.onerror = null;
        };
        var cleanup = function() {
            if (iframe) {
                unattach();
                // This timeout makes chrome fire onbeforeunload event
                // within iframe. Without the timeout it goes straight to
                // onunload.
                setTimeout(function() {
                    if(iframe) {
                        iframe.parentNode.removeChild(iframe);
                    }
                    iframe = null;
                }, 0);
                utils.unload_del(unload_ref);
            }
        };
        var onerror = function(r) {
            if (iframe) {
                cleanup();
                error_callback(r);
            }
        };
        var post = function(msg, origin) {
            try {
                // When the iframe is not loaded, IE raises an exception
                // on 'contentWindow'.
                if (iframe && iframe.contentWindow) {
                    iframe.contentWindow.postMessage(msg, origin);
                }
            } catch (x) {};
        };

        iframe.src = iframe_url;
        iframe.style.display = 'none';
        iframe.style.position = 'absolute';
        iframe.onerror = function(){onerror('onerror');};
        iframe.onload = function() {
            // `onload` is triggered before scripts on the iframe are
            // executed. Give it few seconds to actually load stuff.
            clearTimeout(tref);
            tref = setTimeout(function(){onerror('onload timeout');}, 2000);
        };
        _document.body.appendChild(iframe);
        tref = setTimeout(function(){onerror('timeout');}, 15000);
        unload_ref = utils.unload_add(cleanup);
        return {
            post: post,
            cleanup: cleanup,
            loaded: unattach
        };
    };

    utils.createHtmlfile = function (iframe_url, error_callback) {
        var doc = new ActiveXObject('htmlfile');
        var tref, unload_ref;
        var iframe;
        var unattach = function() {
            clearTimeout(tref);
        };
        var cleanup = function() {
            if (doc) {
                unattach();
                utils.unload_del(unload_ref);
                iframe.parentNode.removeChild(iframe);
                iframe = doc = null;
                CollectGarbage();
            }
        };
        var onerror = function(r)  {
            if (doc) {
                cleanup();
                error_callback(r);
            }
        };
        var post = function(msg, origin) {
            try {
                // When the iframe is not loaded, IE raises an exception
                // on 'contentWindow'.
                if (iframe && iframe.contentWindow) {
                    iframe.contentWindow.postMessage(msg, origin);
                }
            } catch (x) {};
        };

        doc.open();
        doc.write('' +
            'document.domain="' + document.domain + '";' +
            '');
        doc.close();
        doc.parentWindow[WPrefix] = _window[WPrefix];
        var c = doc.createElement('div');
        doc.body.appendChild(c);
        iframe = doc.createElement('iframe');
        c.appendChild(iframe);
        iframe.src = iframe_url;
        tref = setTimeout(function(){onerror('timeout');}, 15000);
        unload_ref = utils.unload_add(cleanup);
        return {
            post: post,
            cleanup: cleanup,
            loaded: unattach
        };
    };
//         [*] End of lib/dom.js


//         [*] Including lib/dom2.js
    /*
     * ***** BEGIN LICENSE BLOCK *****
     * Copyright (c) 2011-2012 VMware, Inc.
     *
     * For the license see COPYING.
     * ***** END LICENSE BLOCK *****
     */

    var AbstractXHRObject = function(){};
    AbstractXHRObject.prototype = new EventEmitter(['chunk', 'finish']);

    AbstractXHRObject.prototype._start = function(method, url, payload, opts) {
        var that = this;

        try {
            that.xhr = new XMLHttpRequest();
        } catch(x) {};

        if (!that.xhr) {
            try {
                that.xhr = new _window.ActiveXObject('Microsoft.XMLHTTP');
            } catch(x) {};
        }
        if (_window.ActiveXObject || _window.XDomainRequest) {
            // IE8 caches even POSTs
            url += ((url.indexOf('?') === -1) ? '?' : '&') + 't='+(+new Date);
        }

        // Explorer tends to keep connection open, even after the
        // tab gets closed: http://bugs.jquery.com/ticket/5280
        that.unload_ref = utils.unload_add(function(){that._cleanup(true);});
        try {
            that.xhr.open(method, url, true);
        } catch(e) {
            // IE raises an exception on wrong port.
            that.emit('finish', 0, '');
            that._cleanup();
            return;
        };

        if (!opts || !opts.no_credentials) {
            // Mozilla docs says https://developer.mozilla.org/en/XMLHttpRequest :
            // "This never affects same-site requests."
            that.xhr.withCredentials = 'true';
        }
        if (opts && opts.headers) {
            for(var key in opts.headers) {
                that.xhr.setRequestHeader(key, opts.headers[key]);
            }
        }

        that.xhr.onreadystatechange = function() {
            if (that.xhr) {
                var x = that.xhr;
                switch (x.readyState) {
                    case 3:
                        // IE doesn't like peeking into responseText or status
                        // on Microsoft.XMLHTTP and readystate=3
                        try {
                            var status = x.status;
                            var text = x.responseText;
                        } catch (x) {};
                        // IE returns 1223 for 204: http://bugs.jquery.com/ticket/1450
                        if (status === 1223) status = 204;

                        // IE does return readystate == 3 for 404 answers.
                        if (text && text.length > 0) {
                            that.emit('chunk', status, text);
                        }
                        break;
                    case 4:
                        var status = x.status;
                        // IE returns 1223 for 204: http://bugs.jquery.com/ticket/1450
                        if (status === 1223) status = 204;

                        that.emit('finish', status, x.responseText);
                        that._cleanup(false);
                        break;
                }
            }
        };
        that.xhr.send(payload);
    };

    AbstractXHRObject.prototype._cleanup = function(abort) {
        var that = this;
        if (!that.xhr) return;
        utils.unload_del(that.unload_ref);

        // IE needs this field to be a function
        that.xhr.onreadystatechange = function(){};

        if (abort) {
            try {
                that.xhr.abort();
            } catch(x) {};
        }
        that.unload_ref = that.xhr = null;
    };

    AbstractXHRObject.prototype.close = function() {
        var that = this;
        that.nuke();
        that._cleanup(true);
    };

    var XHRCorsObject = utils.XHRCorsObject = function() {
        var that = this, args = arguments;
        utils.delay(function(){that._start.apply(that, args);});
    };
    XHRCorsObject.prototype = new AbstractXHRObject();

    var XHRLocalObject = utils.XHRLocalObject = function(method, url, payload) {
        var that = this;
        utils.delay(function(){
            that._start(method, url, payload, {
                no_credentials: true
            });
        });
    };
    XHRLocalObject.prototype = new AbstractXHRObject();



// References:
//   http://ajaxian.com/archives/100-line-ajax-wrapper
//   http://msdn.microsoft.com/en-us/library/cc288060(v=VS.85).aspx
    var XDRObject = utils.XDRObject = function(method, url, payload) {
        var that = this;
        utils.delay(function(){that._start(method, url, payload);});
    };
    XDRObject.prototype = new EventEmitter(['chunk', 'finish']);
    XDRObject.prototype._start = function(method, url, payload) {
        var that = this;
        var xdr = new XDomainRequest();
        // IE caches even POSTs
        url += ((url.indexOf('?') === -1) ? '?' : '&') + 't='+(+new Date);

        var onerror = xdr.ontimeout = xdr.onerror = function() {
            that.emit('finish', 0, '');
            that._cleanup(false);
        };
        xdr.onprogress = function() {
            that.emit('chunk', 200, xdr.responseText);
        };
        xdr.onload = function() {
            that.emit('finish', 200, xdr.responseText);
            that._cleanup(false);
        };
        that.xdr = xdr;
        that.unload_ref = utils.unload_add(function(){that._cleanup(true);});
        try {
            // Fails with AccessDenied if port number is bogus
            that.xdr.open(method, url);
            that.xdr.send(payload);
        } catch(x) {
            onerror();
        }
    };

    XDRObject.prototype._cleanup = function(abort) {
        var that = this;
        if (!that.xdr) return;
        utils.unload_del(that.unload_ref);

        that.xdr.ontimeout = that.xdr.onerror = that.xdr.onprogress =
            that.xdr.onload = null;
        if (abort) {
            try {
                that.xdr.abort();
            } catch(x) {};
        }
        that.unload_ref = that.xdr = null;
    };

    XDRObject.prototype.close = function() {
        var that = this;
        that.nuke();
        that._cleanup(true);
    };

// 1. Is natively via XHR
// 2. Is natively via XDR
// 3. Nope, but postMessage is there so it should work via the Iframe.
// 4. Nope, sorry.
    utils.isXHRCorsCapable = function() {
        if (_window.XMLHttpRequest && 'withCredentials' in new XMLHttpRequest()) {
            return 1;
        }
        // XDomainRequest doesn't work if page is served from file://
        if (_window.XDomainRequest && _document.domain) {
            return 2;
        }
        if (IframeTransport.enabled()) {
            return 3;
        }
        return 4;
    };
//         [*] End of lib/dom2.js


//         [*] Including lib/sockjs.js
    /*
     * ***** BEGIN LICENSE BLOCK *****
     * Copyright (c) 2011-2012 VMware, Inc.
     *
     * For the license see COPYING.
     * ***** END LICENSE BLOCK *****
     */

    var SockJS = function(url, dep_protocols_whitelist, options) {
        var splits = url.split("?");
        var query = null;
        if(splits.length == 2){
            url = splits[0];
            query = splits[1];
        }
        if (this === _window) {
            // makes `new` optional
            return new SockJS(url, dep_protocols_whitelist, options);
        }

        var that = this, protocols_whitelist;
        that._options = {devel: false, debug: false, protocols_whitelist: [],
            info: undefined, rtt: undefined};
        if (options) {
            utils.objectExtend(that._options, options);
        }
        that._base_url = utils.amendUrl(url);
        that._server = that._options.server || utils.random_number_string(1000);
        if (that._options.protocols_whitelist &&
            that._options.protocols_whitelist.length) {
            protocols_whitelist = that._options.protocols_whitelist;
        } else {
            // Deprecated API
            if (typeof dep_protocols_whitelist === 'string' &&
                dep_protocols_whitelist.length > 0) {
                protocols_whitelist = [dep_protocols_whitelist];
            } else if (utils.isArray(dep_protocols_whitelist)) {
                protocols_whitelist = dep_protocols_whitelist
            } else {
                protocols_whitelist = null;
            }
            if (protocols_whitelist) {
                that._debug('Deprecated API: Use "protocols_whitelist" option ' +
                    'instead of supplying protocol list as a second ' +
                    'parameter to SockJS constructor.');
            }
        }
        that._protocols = [];
        that.protocol = null;
        that.readyState = SockJS.CONNECTING;
        that._ir = createInfoReceiver(that._base_url);
        that._query = query;
        that._ir.onfinish = function(info, rtt) {
            that._ir = null;
            if (info) {
                if (that._options.info) {
                    // Override if user supplies the option
                    info = utils.objectExtend(info, that._options.info);
                }
                if (that._options.rtt) {
                    rtt = that._options.rtt;
                }
                that._applyInfo(info, rtt, protocols_whitelist);
                that._didClose();
            } else {
                that._didClose(1002, 'Can\'t connect to server', true);
            }
        };
    };
// Inheritance
    SockJS.prototype = new REventTarget();

    SockJS.version = "0.3.4";

    SockJS.CONNECTING = 0;
    SockJS.OPEN = 1;
    SockJS.CLOSING = 2;
    SockJS.CLOSED = 3;

    SockJS.prototype._debug = function() {
        if (this._options.debug)
            utils.log.apply(utils, arguments);
    };

    SockJS.prototype._dispatchOpen = function() {
        var that = this;
        if (that.readyState === SockJS.CONNECTING) {
            if (that._transport_tref) {
                clearTimeout(that._transport_tref);
                that._transport_tref = null;
            }
            that.readyState = SockJS.OPEN;
            that.dispatchEvent(new SimpleEvent("open"));
        } else {
            // The server might have been restarted, and lost track of our
            // connection.
            that._didClose(1006, "Server lost session");
        }
    };

    SockJS.prototype._dispatchMessage = function(data) {
        var that = this;
        if (that.readyState !== SockJS.OPEN)
            return;
        that.dispatchEvent(new SimpleEvent("message", {data: data}));
    };

    SockJS.prototype._dispatchHeartbeat = function(data) {
        var that = this;
        if (that.readyState !== SockJS.OPEN)
            return;
        that.dispatchEvent(new SimpleEvent('heartbeat', {}));
    };

    SockJS.prototype._didClose = function(code, reason, force) {
        var that = this;
        if (that.readyState !== SockJS.CONNECTING &&
            that.readyState !== SockJS.OPEN &&
            that.readyState !== SockJS.CLOSING)
            throw new Error('INVALID_STATE_ERR');
        if (that._ir) {
            that._ir.nuke();
            that._ir = null;
        }

        if (that._transport) {
            that._transport.doCleanup();
            that._transport = null;
        }

        var close_event = new SimpleEvent("close", {
            code: code,
            reason: reason,
            wasClean: utils.userSetCode(code)});

        if (!utils.userSetCode(code) &&
            that.readyState === SockJS.CONNECTING && !force) {
            if (that._try_next_protocol(close_event)) {
                return;
            }
            close_event = new SimpleEvent("close", {code: 2000,
                reason: "All transports failed",
                wasClean: false,
                last_event: close_event});
        }
        that.readyState = SockJS.CLOSED;

        utils.delay(function() {
            that.dispatchEvent(close_event);
        });
    };

    SockJS.prototype._didMessage = function(data) {
        var that = this;
        var type = data.slice(0, 1);
        switch(type) {
            case 'o':
                that._dispatchOpen();
                break;
            case 'a':
                var payload = JSON.parse(data.slice(1) || '[]');
                for(var i=0; i < payload.length; i++){
                    that._dispatchMessage(payload[i]);
                }
                break;
            case 'm':
                var payload = JSON.parse(data.slice(1) || 'null');
                that._dispatchMessage(payload);
                break;
            case 'c':
                var payload = JSON.parse(data.slice(1) || '[]');
                that._didClose(payload[0], payload[1]);
                break;
            case 'h':
                that._dispatchHeartbeat();
                break;
        }
    };

    SockJS.prototype._try_next_protocol = function(close_event) {
        var that = this;
        if (that.protocol) {
            that._debug('Closed transport:', that.protocol, ''+close_event);
            that.protocol = null;
        }
        if (that._transport_tref) {
            clearTimeout(that._transport_tref);
            that._transport_tref = null;
        }

        while(1) {
            var protocol = that.protocol = that._protocols.shift();
            if (!protocol) {
                return false;
            }
            // Some protocols require access to `body`, what if were in
            // the `head`?
            if (SockJS[protocol] &&
                SockJS[protocol].need_body === true &&
                (!_document.body ||
                (typeof _document.readyState !== 'undefined'
                && _document.readyState !== 'complete'))) {
                that._protocols.unshift(protocol);
                that.protocol = 'waiting-for-load';
                utils.attachEvent('load', function(){
                    that._try_next_protocol();
                });
                return true;
            }

            if (!SockJS[protocol] ||
                !SockJS[protocol].enabled(that._options)) {
                that._debug('Skipping transport:', protocol);
            } else {
                var roundTrips = SockJS[protocol].roundTrips || 1;
                var to = ((that._options.rto || 0) * roundTrips) || 5000;
                that._transport_tref = utils.delay(to, function() {
                    if (that.readyState === SockJS.CONNECTING) {
                        // I can't understand how it is possible to run
                        // this timer, when the state is CLOSED, but
                        // apparently in IE everythin is possible.
                        that._didClose(2007, "Transport timeouted");
                    }
                });

                var connid = utils.random_string(8);
                var trans_url = that._base_url + '/' + that._server + '/' + connid;
                that._debug('Opening transport:', protocol, ' url:'+trans_url,
                    ' RTO:'+that._options.rto);
                that._transport = new SockJS[protocol](that, trans_url,
                    that._base_url, that._query);
                return true;
            }
        }
    };

    SockJS.prototype.close = function(code, reason) {
        var that = this;
        if (code && !utils.userSetCode(code))
            throw new Error("INVALID_ACCESS_ERR");
        if(that.readyState !== SockJS.CONNECTING &&
            that.readyState !== SockJS.OPEN) {
            return false;
        }
        that.readyState = SockJS.CLOSING;
        that._didClose(code || 1000, reason || "Normal closure");
        return true;
    };

    SockJS.prototype.send = function(data) {
        var that = this;
        if (that.readyState === SockJS.CONNECTING)
            throw new Error('INVALID_STATE_ERR');
        if (that.readyState === SockJS.OPEN) {
            that._transport.doSend(utils.quote('' + data));
        }
        return true;
    };

    SockJS.prototype._applyInfo = function(info, rtt, protocols_whitelist) {
        var that = this;
        that._options.info = info;
        that._options.rtt = rtt;
        that._options.rto = utils.countRTO(rtt);
        that._options.info.null_origin = !_document.domain;
        var probed = utils.probeProtocols();
        that._protocols = utils.detectProtocols(probed, protocols_whitelist, info);
    };
//         [*] End of lib/sockjs.js


//         [*] Including lib/trans-websocket.js
    /*
     * ***** BEGIN LICENSE BLOCK *****
     * Copyright (c) 2011-2012 VMware, Inc.
     *
     * For the license see COPYING.
     * ***** END LICENSE BLOCK *****
     */
    var WebSocketTransport = SockJS.websocket = function(ri, trans_url, base_url, query) {
        var that = this;
        var url = trans_url + '/websocket';
        if (url.slice(0, 5) === 'https') {
            url = 'wss' + url.slice(5);
        } else {
            url = 'ws' + url.slice(4);
        }
        that.ri = ri;
        that.url = url;
        var Constructor = _window.WebSocket || _window.MozWebSocket;

        that.ws = new Constructor(that.url + (query == null?"":"?" + query));
        that.ws.onmessage = function(e) {
            that.ri._didMessage(e.data);
        };
        // Firefox has an interesting bug. If a websocket connection is
        // created after onunload, it stays alive even when user
        // navigates away from the page. In such situation let's lie -
        // let's not open the ws connection at all. See:
        // https://github.com/sockjs/sockjs-client/issues/28
        // https://bugzilla.mozilla.org/show_bug.cgi?id=696085
        that.unload_ref = utils.unload_add(function(){that.ws.close()});
        that.ws.onclose = function() {
            that.ri._didMessage(utils.closeFrame(1006, "WebSocket connection broken"));
        };
    };

    WebSocketTransport.prototype.doSend = function(data) {
        this.ws.send('[' + data + ']');
    };

    WebSocketTransport.prototype.doCleanup = function() {
        var that = this;
        var ws = that.ws;
        if (ws) {
            ws.onmessage = ws.onclose = null;
            ws.close();
            utils.unload_del(that.unload_ref);
            that.unload_ref = that.ri = that.ws = null;
        }
    };

    WebSocketTransport.enabled = function() {
        return !!(_window.WebSocket || _window.MozWebSocket);
    };

// In theory, ws should require 1 round trip. But in chrome, this is
// not very stable over SSL. Most likely a ws connection requires a
// separate SSL connection, in which case 2 round trips are an
// absolute minumum.
    WebSocketTransport.roundTrips = 2;
//         [*] End of lib/trans-websocket.js


//         [*] Including lib/trans-sender.js
    /*
     * ***** BEGIN LICENSE BLOCK *****
     * Copyright (c) 2011-2012 VMware, Inc.
     *
     * For the license see COPYING.
     * ***** END LICENSE BLOCK *****
     */

    var BufferedSender = function() {};
    BufferedSender.prototype.send_constructor = function(sender) {
        var that = this;
        that.send_buffer = [];
        that.sender = sender;
    };
    BufferedSender.prototype.doSend = function(message) {
        var that = this;
        that.send_buffer.push(message);
        if (!that.send_stop) {
            that.send_schedule();
        }
    };

// For polling transports in a situation when in the message callback,
// new message is being send. If the sending connection was started
// before receiving one, it is possible to saturate the network and
// timeout due to the lack of receiving socket. To avoid that we delay
// sending messages by some small time, in order to let receiving
// connection be started beforehand. This is only a halfmeasure and
// does not fix the big problem, but it does make the tests go more
// stable on slow networks.
    BufferedSender.prototype.send_schedule_wait = function() {
        var that = this;
        var tref;
        that.send_stop = function() {
            that.send_stop = null;
            clearTimeout(tref);
        };
        tref = utils.delay(25, function() {
            that.send_stop = null;
            that.send_schedule();
        });
    };

    BufferedSender.prototype.send_schedule = function() {
        var that = this;
        if (that.send_buffer.length > 0) {
            var payload = '[' + that.send_buffer.join(',') + ']';
            that.send_stop = that.sender(that.trans_url, payload, function(success, abort_reason) {
                that.send_stop = null;
                if (success === false) {
                    that.ri._didClose(1006, 'Sending error ' + abort_reason);
                } else {
                    that.send_schedule_wait();
                }
            });
            that.send_buffer = [];
        }
    };

    BufferedSender.prototype.send_destructor = function() {
        var that = this;
        if (that._send_stop) {
            that._send_stop();
        }
        that._send_stop = null;
    };

    var jsonPGenericSender = function(url, payload, callback) {
        var that = this;

        if (!('_send_form' in that)) {
            var form = that._send_form = _document.createElement('form');
            var area = that._send_area = _document.createElement('textarea');
            area.name = 'd';
            form.style.display = 'none';
            form.style.position = 'absolute';
            form.method = 'POST';
            form.enctype = 'application/x-www-form-urlencoded';
            form.acceptCharset = "UTF-8";
            form.appendChild(area);
            _document.body.appendChild(form);
        }
        var form = that._send_form;
        var area = that._send_area;
        var id = 'a' + utils.random_string(8);
        form.target = id;
        form.action = url + '/jsonp_send?i=' + id;

        var iframe;
        try {
            // ie6 dynamic iframes with target="" support (thanks Chris Lambacher)
            iframe = _document.createElement('