08-27-周三_17-09-29

node_modules/sockjs/.npmignore

@@ -0,0 +1,6 @@
+.gitignore
+lib/.placeholder
+VERSION-GEN
+src
+node_modules
+*~

node_modules/sockjs/COPYING

@@ -0,0 +1,6 @@
+Parts of the code are derived from various open source projects.
+
+For code derived from Socket.IO by Guillermo Rauch see
+https://github.com/LearnBoost/socket.io/tree/0.6.17#readme.
+
+All other code is released on MIT license, see LICENSE-MIT-SockJS.

node_modules/sockjs/Changelog

@@ -0,0 +1,171 @@
+0.3.7
+=====
+
+ * Expose "protocol" on raw websocket connection instance, correctly
+
+0.3.6
+=====
+
+ * When the server closes a connection, make sure the send buffer still
+   gets flushed.
+ * Expose "protocol" on raw websocket connection instance
+ * #105, #109, #113 - expose 'host', 'user-agent', and 'accept-language'
+   headers
+ * Serve SockJS over https CDN by default
+ * Upgrade Faye to 0.4.4 from 0.4.0
+
+0.3.5
+=====
+
+ * #103 - connection.protocol might have been empty on some rare
+   occasions.
+ * #99 - faye-websocket was leaking sockets in "closed" state
+   when dealing with rfc websockets
+
+
+0.3.4
+=====
+
+ * #73 - apparently 'package' is a reserved keyword (use 'pkg' instead)
+ * #93 - Coffescript can leak a variable when the same name is used
+   in catch statement. Let's always use 'x' as the variable in catch.
+ * #76 - decorateConnection could throw an error if remote connection
+   was closed before setup was complete
+ * #90 - Fix "TypeError: 'addListener'" exception (via @pl).
+ * remove 'optionalDependencies' section from package.json,
+   'rbytes' was always optional.
+ * #91 - Fix rare null exception.
+
+
+0.3.3
+=====
+
+ * sockjs/sockjs-protocol#56, #88 Fix for iOS 6 caching POSTs
+
+
+0.3.1
+=====
+
+ * #58 - websocket transport emitted an array instead of a string
+   during onmessage event.
+ * Running under node.js 0.7 caused infinite recursion (Stephan Kochen)
+ * #59 - restrict characters allowed in callback parameter
+ * Updated readme - rbytes package is optional
+ * Updated readme WRT deployments on heroku
+ * Add minimalistic license block to every source file.
+
+
+0.3.0
+=====
+
+ * Sending JSESSIONID cookie is now *disabled* by default.
+ * sockjs/sockjs-protocol#46 - introduce new service
+   required for protocol tests "/cookie_needed_echo"
+ * Initial work towards better integration with
+   "connect" (Stephan Kochen). See discusion:
+       https://github.com/senchalabs/connect/pull/506
+ * More documentation about the Cookie and Origin headers.
+ * #51 - expose "readyState" on connection instance
+ * #53 - expose "protocol" on connection instance
+ * #52 - Some protocols may not emit 'close' event with IE.
+ * sockjs/sockjs-client#49 - Support 'null' origin - aka: allow SockJS
+   client to be served from file:// paths.
+
+
+0.2.1
+=====
+
+ * Bumped "faye-websocket" dependency to 0.4. Updated
+   code to take advantage of introduced changes.
+ * Pinned "node-static" and bumped "node-uuid" dependencies.
+ * Removed "Origin" header list of headers exposed to the user.
+   This header is not really meaningful in sockjs context.
+ * Header "Access-Control-Allow-Methods" was misspelled.
+
+
+0.2.0
+=====
+
+ * #36, #3 - Replace a custom WebSocket server implementation
+   with  faye-websocket-node.
+ * Multiple changes to support SockJS-protocol 0.2.
+    * The session is now closed on network errors immediately
+      (instead of waiting 5 seconds)
+    * Raw websocket interface available - to make it easier
+      to write command line SockJS clients.
+    * Support '/info' url.
+ * The test server got moved from SockJS-client to SockJS-node.
+ * Dropped deprecated Server API (use createServer method instead).
+ * Option `websocket` is now used instead of `disabled_transports`.
+
+
+0.1.2
+=====
+
+ * #27 - Allow all unicode characters to be send over SockJS.
+ * #14 - Make it possible to customize JSESSIONID cookie logic.
+
+
+0.1.1
+=====
+
+ * #32 Expose various request headers on connection.
+ * #30 Expose request path on connection.
+
+
+0.1.0
+=====
+
+ * The API changed, there is now an idiomatic API, modelled on node.js
+   Stream API. The old API is deprecated and there is a dummy wrapper
+   that emulates it. Please do upgrade to the new idiomatic API.
+ * #22 Initial support for hybi13 (stephank)
+ * New options accepted by the `Server` constructor: `log`,
+   `heartbeat_delay` and `disconnect_delay`.
+ * SockJS is now not able to send rich data structures - all data
+   passed to `write` is converted to a string.
+ * #23 `Connection.remoteAddress` property introduced (Stéphan Kochen)
+ * Loads of small changes in order to adhere to protocol spec.
+
+
+0.0.5
+=====
+
+ * #20: `npm submodule sockjs` didn't work due to outdated github
+   path.
+
+
+0.0.4
+=====
+
+ * Support for htmlfile transport, used by IE in a deployment
+   dependent on cookies.
+ * Added /chunking_test API, used to detect support for HTTP chunking
+   on client side.
+ * Unified code logic for all the chunking transports - the same code
+   is reused for polling versions.
+ * All the chunking transports are closed by the server after 128K was
+   send, in order to force client to GC and reconnect.
+ * Don't distribute source coffeescript with npm.
+ * Minor fixes in websocket code.
+ * Dropped jQuery dependency.
+ * Unicode encoding could been garbled during XHR upload.
+ * Other minor fixes.
+
+
+0.0.3
+======
+
+ * EventSource transport didn't emit 'close' event.
+
+
+0.0.2
+=====
+
+ * By default set JSESSIONID cookie, useful for load balancing.
+
+
+0.0.1
+=====
+
+ * Initial release.

node_modules/sockjs/LICENSE-MIT-SockJS

@@ -0,0 +1,19 @@
+Copyright (C) 2011 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.

node_modules/sockjs/Makefile

@@ -0,0 +1,55 @@
+.PHONY: all serve clean
+
+COFFEE:=./node_modules/.bin/coffee
+
+#### General
+
+all: build
+
+build: src/*coffee
+	@$(COFFEE) -v > /dev/null
+	$(COFFEE) -o lib/ -c src/*.coffee
+
+clean:
+	rm -f lib/*.js
+
+
+#### Testing
+
+test_server:
+	node examples/test_server/server.js
+
+serve:
+	@if [ -e .pidfile.pid ]; then		\
+		kill `cat .pidfile.pid`;	\
+		rm .pidfile.pid;		\
+	fi
+
+	@while [ 1 ]; do				\
+		make build;				\
+		echo " [*] Running http server";	\
+		make test_server &			\
+		SRVPID=$$!;				\
+		echo $$SRVPID > .pidfile.pid;		\
+		echo " [*] Server pid: $$SRVPID";	\
+		inotifywait -r -q -e modify .;		\
+		kill `cat .pidfile.pid`;		\
+		rm -f .pidfile.pid;			\
+		sleep 0.1;				\
+	done
+
+#### Release process
+#   1) commit everything
+#   2) amend version in package.json
+#   3) run 'make tag' and run suggested 'git push' variants
+#   4) run 'npm publish'
+
+RVER:=$(shell grep "version" package.json|tr '\t"' ' \t'|cut -f 4)
+VER:=$(shell ./VERSION-GEN)
+
+.PHONY: tag
+tag: all
+	git commit $(TAG_OPTS) package.json Changelog -m "Release $(RVER)"
+	git tag v$(RVER) -m "Release $(RVER)"
+	@echo ' [*] Now run'
+	@echo 'git push; git push --tag'

node_modules/sockjs/README.md

@@ -0,0 +1,458 @@
+SockJS family:
+
+  * [SockJS-client](https://github.com/sockjs/sockjs-client) JavaScript client library
+  * [SockJS-node](https://github.com/sockjs/sockjs-node) Node.js server
+  * [SockJS-erlang](https://github.com/sockjs/sockjs-erlang) Erlang server
+  * [SockJS-tornado](https://github.com/MrJoes/sockjs-tornado) Python/Tornado server
+  * [vert.x](https://github.com/purplefox/vert.x) Java/vert.x server
+
+Work in progress:
+
+  * [SockJS-ruby](https://github.com/nyarly/sockjs-ruby)
+  * [SockJS-netty](https://github.com/cgbystrom/sockjs-netty)
+  * [SockJS-gevent](https://github.com/sdiehl/sockjs-gevent) ([and a fork](https://github.com/njoyce/sockjs-gevent))
+  * [pyramid-SockJS](https://github.com/fafhrd91/pyramid_sockjs)
+  * [wildcloud-websockets](https://github.com/wildcloud/wildcloud-websockets)
+  * [SockJS-cyclone](https://github.com/flaviogrossi/sockjs-cyclone)
+  * [SockJS-twisted](https://github.com/Fugiman/sockjs-twisted/)
+  * [wai-SockJS](https://github.com/Palmik/wai-sockjs)
+  * [SockJS-perl](https://github.com/vti/sockjs-perl)
+  * [SockJS-go](https://github.com/igm/sockjs-go/)
+
+What is SockJS?
+===============
+
+SockJS is a JavaScript library (for browsers) that provides a WebSocket-like
+object. SockJS gives you a coherent, cross-browser, Javascript API
+which creates a low latency, full duplex, cross-domain communication
+channel between the browser and the web server, with WebSockets or without.
+This necessitates the use of a server, which this is one version of, for Node.js.
+
+
+SockJS-node server
+==================
+
+SockJS-node is a Node.js server side counterpart of
+[SockJS-client browser library](https://github.com/sockjs/sockjs-client)
+written in CoffeeScript.
+
+To install `sockjs-node` run:
+
+    npm install sockjs
+
+For additional security (true random numbers) you might want to
+install `rbytes` package - SockJS will use it if available:
+
+    npm install rbytes
+
+
+An simplified echo SockJS server could look more or less like:
+
+```javascript
+var http = require('http');
+var sockjs = require('sockjs');
+
+var echo = sockjs.createServer();
+echo.on('connection', function(conn) {
+    conn.on('data', function(message) {
+        conn.write(message);
+    });
+    conn.on('close', function() {});
+});
+
+var server = http.createServer();
+echo.installHandlers(server, {prefix:'/echo'});
+server.listen(9999, '0.0.0.0');
+```
+
+(Take look at
+[examples](https://github.com/sockjs/sockjs-node/tree/master/examples/echo)
+directory for a complete version.)
+
+Subscribe to
+[SockJS mailing list](https://groups.google.com/forum/#!forum/sockjs) for
+discussions and support.
+
+
+Live QUnit tests and smoke tests
+--------------------------------
+
+[SockJS-client](https://github.com/sockjs/sockjs-client) comes with
+some QUnit tests and a few smoke tests that are using SockJS-node. At
+the moment they are deployed in few places, just click to see if
+SockJS is working in your browser:
+
+ * http://sockjs.popcnt.org/ and https://sockjs.popcnt.org/ (hosted in Europe)
+ * http://sockjs.cloudfoundry.com/ (CloudFoundry, websockets disabled, loadbalanced)
+ * https://sockjs.cloudfoundry.com/ (CloudFoundry SSL, websockets disabled, loadbalanced)
+
+
+SockJS-node API
+---------------
+
+The API design is based on the common Node API's like
+[Streams API](http://nodejs.org/docs/v0.5.8/api/streams.html) or
+[Http.Server API](http://nodejs.org/docs/v0.5.8/api/http.html#http.Server).
+
+### Server class
+
+SockJS module is generating a `Server` class, similar to
+[Node.js http.createServer](http://nodejs.org/docs/v0.5.8/api/http.html#http.createServer)
+module.
+
+```javascript
+var sockjs_server = sockjs.createServer(options);
+```
+
+Where `options` is a hash which can contain:
+
+<dl>
+<dt>sockjs_url (string, required)</dt>
+<dd>Transports which don't support cross-domain communication natively
+   ('eventsource' to name one) use an iframe trick. A simple page is
+   served from the SockJS server (using its foreign domain) and is
+   placed in an invisible iframe. Code run from this iframe doesn't
+   need to worry about cross-domain issues, as it's being run from
+   domain local to the SockJS server. This iframe also does need to
+   load SockJS javascript client library, and this option lets you specify
+   its url (if you're unsure, point it to
+   <a href="http://cdn.sockjs.org/sockjs-0.3.min.js">
+   the latest minified SockJS client release</a>, this is the default).
+   You must explicitly specify this url on the server side for security
+   reasons - we don't want the possibility of running any foreign
+   javascript within the SockJS domain (aka cross site scripting attack).
+   Also, sockjs javascript library is probably already cached by the
+   browser - it makes sense to reuse the sockjs url you're using in
+   normally.</dd>
+
+<dt>prefix (string)</dt>
+<dd>A url prefix for the server. All http requests which paths begins
+   with selected prefix will be handled by SockJS. All other requests
+   will be passed through, to previously registered handlers.</dd>
+
+<dt>response_limit (integer)</dt>
+<dd>Most streaming transports save responses on the client side and
+   don't free memory used by delivered messages. Such transports need
+   to be garbage-collected once in a while. `response_limit` sets
+   a minimum number of bytes that can be send over a single http streaming
+   request before it will be closed. After that client needs to open
+   new request. Setting this value to one effectively disables
+   streaming and will make streaming transports to behave like polling
+   transports. The default value is 128K.</dd>
+
+<dt>websocket (boolean)</dt>
+<dd>Some load balancers don't support websockets. This option can be used
+   to disable websockets support by the server. By default websockets are
+   enabled.</dd>
+
+<dt>jsessionid (boolean or function)</dt>
+<dd>Some hosting providers enable sticky sessions only to requests that
+  have JSESSIONID cookie set. This setting controls if the server should
+  set this cookie to a dummy value. By default setting JSESSIONID cookie
+  is disabled. More sophisticated behaviour can be achieved by supplying
+  a function.</dd>
+
+<dt>log (function(severity, message))</dt>
+<dd>It's quite useful, especially for debugging, to see some messages
+  printed by a SockJS-node library. This is done using this `log`
+  function, which is by default set to `console.log`. If this
+  behaviour annoys you for some reason, override `log` setting with a
+  custom handler.  The following `severities` are used: `debug`
+  (miscellaneous logs), `info` (requests logs), `error` (serious
+  errors, consider filing an issue).</dd>
+
+<dt>heartbeat_delay (milliseconds)</dt>
+<dd>In order to keep proxies and load balancers from closing long
+  running http requests we need to pretend that the connection is
+  active and send a heartbeat packet once in a while. This setting
+  controls how often this is done. By default a heartbeat packet is
+  sent every 25 seconds.  </dd>
+
+<dt>disconnect_delay (milliseconds)</dt>
+<dd>The server sends a `close` event when a client receiving
+  connection have not been seen for a while. This delay is configured
+  by this setting. By default the `close` event will be emitted when a
+  receiving connection wasn't seen for 5 seconds.  </dd>
+</dl>
+
+
+### Server instance
+
+Once you have create `Server` instance you can hook it to the
+[http.Server instance](http://nodejs.org/docs/v0.5.8/api/http.html#http.createServer).
+
+```javascript
+var http_server = http.createServer();
+sockjs_server.installHandlers(http_server, options);
+http_server.listen(...);
+```
+
+Where `options` can overshadow options given when creating `Server`
+instance.
+
+`Server` instance is an
+[EventEmitter](http://nodejs.org/docs/v0.4.10/api/events.html#events.EventEmitter),
+and emits following event:
+
+<dl>
+<dt>Event: connection (connection)</dt>
+<dd>A new connection has been successfully opened.</dd>
+</dl>
+
+All http requests that don't go under the path selected by `prefix`
+will remain unanswered and will be passed to previously registered
+handlers. You must install your custom http handlers before calling
+`installHandlers`.
+
+### Connection instance
+
+A `Connection` instance supports
+[Node Stream API](http://nodejs.org/docs/v0.5.8/api/streams.html) and
+has following methods and properties:
+
+<dl>
+<dt>Property: readable (boolean)</dt>
+<dd>Is the stream readable?</dd>
+
+<dt>Property: writable (boolean)</dt>
+<dd>Is the stream writable?</dd>
+
+<dt>Property: remoteAddress (string)</dt>
+<dd>Last known IP address of the client.</dd>
+
+<dt>Property: remotePort (number)</dt>
+<dd>Last known port number of the client.</dd>
+
+<dt>Property: address (object)</dt>
+<dd>Hash with 'address' and 'port' fields.</dd>
+
+<dt>Property: headers (object)</dt>
+<dd>Hash containing various headers copied from last receiving request
+    on that connection. Exposed headers include: `origin`, `referer`
+    and `x-forwarded-for` (and friends). We explicitly do not grant
+    access to `cookie` header, as using it may easily lead to security
+    issues (for details read the section "Authorisation").</dd>
+
+<dt>Property: url (string)</dt>
+<dd><a href="http://nodejs.org/docs/v0.4.10/api/http.html#request.url">Url</a>
+    property copied from last request.</dd>
+
+<dt>Property: pathname (string)</dt>
+<dd>`pathname` from parsed url, for convenience.</dd>
+
+<dt>Property: prefix (string)</dt>
+<dd>Prefix of the url on which the request was handled.</dd>
+
+<dt>Property: protocol (string)</dt>
+<dd>Protocol used by the connection. Keep in mind that some protocols
+   are indistinguishable - for example "xhr-polling" and "xdr-polling".</dd>
+
+<dt>Property: readyState (integer)</dt>
+<dd>Current state of the connection:
+   0-connecting, 1-open, 2-closing, 3-closed.</dd>
+
+<dt>write(message)</dt>
+<dd>Sends a message over opened connection. A message must be a
+  non-empty string. It's illegal to send a message after the connection was
+  closed (either after 'close' or 'end' method or 'close' event).</dd>
+
+<dt>close([code], [reason])</dt>
+<dd>Asks the remote client to disconnect. 'code' and 'reason'
+   parameters are optional and can be used to share the reason of
+   disconnection.</dd>
+
+<dt>end()</dt>
+<dd>Asks the remote client to disconnect with default 'code' and
+   'reason' values.</dd>
+
+</dl>
+
+A `Connection` instance emits the following events:
+
+<dl>
+<dt>Event: data (message)</dt>
+<dd>A message arrived on the connection. Message is a unicode
+  string.</dd>
+
+<dt>Event: close ()</dt>
+<dd>Connection was closed. This event is triggered exactly once for
+   every connection.</dd>
+</dl>
+
+For example:
+
+```javascript
+sockjs_server.on('connection', function(conn) {
+    console.log('connection' + conn);
+    conn.on('close', function() {
+        console.log('close ' + conn);
+    });
+    conn.on('data', function(message) {
+        console.log('message ' + conn,
+                    message);
+    });
+});
+```
+
+### Footnote
+
+A fully working echo server does need a bit more boilerplate (to
+handle requests unanswered by SockJS), see the
+[`echo` example](https://github.com/sockjs/sockjs-node/tree/master/examples/echo)
+for a complete code.
+
+### Examples
+
+If you want to see samples of running code, take a look at:
+
+ * [./examples/echo](https://github.com/sockjs/sockjs-node/tree/master/examples/echo)
+   directory, which contains a full example of a echo server.
+ * [./examples/test_server](https://github.com/sockjs/sockjs-node/tree/master/examples/test_server) a standard SockJS test server.
+
+
+Connecting to SockJS-node without the client
+--------------------------------------------
+
+Although the main point of SockJS it to enable browser-to-server
+connectivity, it is possible to connect to SockJS from an external
+application. Any SockJS server complying with 0.3 protocol does
+support a raw WebSocket url. The raw WebSocket url for the test server
+looks like:
+
+ * ws://localhost:8081/echo/websocket
+
+You can connect any WebSocket RFC 6455 compliant WebSocket client to
+this url. This can be a command line client, external application,
+third party code or even a browser (though I don't know why you would
+want to do so).
+
+
+Deployment and load balancing
+-----------------------------
+
+There are two issues that needs to be considered when planning a
+non-trivial SockJS-node deployment: WebSocket-compatible load balancer
+and sticky sessions (aka session affinity).
+
+### WebSocket compatible load balancer
+
+Often WebSockets don't play nicely with proxies and load balancers.
+Deploying a SockJS server behind Nginx or Apache could be painful.
+
+Fortunately recent versions of an excellent load balancer
+[HAProxy](http://haproxy.1wt.eu/) are able to proxy WebSocket
+connections. We propose to put HAProxy as a front line load balancer
+and use it to split SockJS traffic from normal HTTP data. Take a look
+at the sample
+[SockJS HAProxy configuration](https://github.com/sockjs/sockjs-node/blob/master/examples/haproxy.cfg).
+
+The config also shows how to use HAproxy balancing to split traffic
+between multiple Node.js servers. You can also do balancing using dns
+names.
+
+### Sticky sessions
+
+If you plan deploying more than one SockJS server, you must make sure
+that all HTTP requests for a single session will hit the same server.
+SockJS has two mechanisms that can be useful to achieve that:
+
+ * Urls are prefixed with server and session id numbers, like:
+   `/resource/<server_number>/<session_id>/transport`.  This is
+   useful for load balancers that support prefix-based affinity
+   (HAProxy does).
+ * `JSESSIONID` cookie is being set by SockJS-node. Many load
+   balancers turn on sticky sessions if that cookie is set. This
+   technique is derived from Java applications, where sticky sessions
+   are often necessary. HAProxy does support this method, as well as
+   some hosting providers, for example CloudFoundry.  In order to
+   enable this method on the client side, please supply a
+   `cookie:true` option to SockJS constructor.
+
+
+Development and testing
+-----------------------
+
+If you want to work on SockJS-node source code, you need to clone the
+git repo and follow these steps. First you need to install
+dependencies:
+
+    cd sockjs-node
+    npm install
+    npm install --dev
+    ln -s .. node_modules/sockjs
+
+You're ready to compile CoffeeScript:
+
+    make build
+
+If compilation succeeds you may want to test if your changes pass all
+the tests. Currently, there are two separate test suites. For both of
+them you need to start a SockJS-node test server (by default listening
+on port 8081):
+
+    make test_server
+
+### SockJS-protocol Python tests
+
+To run it run something like:
+
+    cd sockjs-protocol
+    make test_deps
+    ./venv/bin/python sockjs-protocol-0.3.py
+
+For details see
+[SockJS-protocol README](https://github.com/sockjs/sockjs-protocol#readme).
+
+### SockJS-client QUnit tests
+
+You need to start a second web server (by default listening on 8080)
+that is serving various static html and javascript files:
+
+    cd sockjs-client
+    make test
+
+At that point you should have two web servers running: sockjs-node on
+8081 and sockjs-client on 8080. When you open the browser on
+[http://localhost:8080/](http://localhost:8080/) you should be able
+run the QUnit tests against your sockjs-node server.
+
+For details see
+[SockJS-client README](https://github.com/sockjs/sockjs-client#readme).
+
+Additionally, if you're doing more serious development consider using
+`make serve`, which will automatically the server when you modify the
+source code.
+
+
+Various issues and design considerations
+----------------------------------------
+
+### Authorisation
+
+SockJS-node does not expose cookies to the application. This is done
+deliberately as using cookie-based authorisation with SockJS simply
+doesn't make sense and will lead to security issues.
+
+Cookies are a contract between a browser and an http server, and are
+identified by a domain name. If a browser has a cookie set for
+particular domain, it will pass it as a part of all http requests to
+the host. But to get various transports working, SockJS uses a middleman
+- an iframe hosted from target SockJS domain. That means the server
+will receive requests from the iframe, and not from the real
+domain. The domain of an iframe is the same as the SockJS domain. The
+problem is that any website can embed the iframe and communicate with
+it - and request establishing SockJS connection. Using cookies for
+authorisation in this scenario will result in granting full access to
+SockJS communication with your website from any website. This is a
+classic CSRF attack.
+
+Basically - cookies are not suited for SockJS model. If you want to
+authorise a session - provide a unique token on a page, send it as a
+first thing over SockJS connection and validate it on the server
+side. In essence, this is how cookies work.
+
+
+### Deploying SockJS on Heroku
+
+Long polling is known to cause problems on Heroku, but
+[workaround for SockJS is available](https://github.com/sockjs/sockjs-node/issues/57#issuecomment-5242187).

node_modules/sockjs/examples/echo/README.md

@@ -0,0 +1,15 @@
+SockJS-node Echo example
+========================
+
+To run this example, first install dependencies:
+
+    npm install
+
+And run a server:
+
+    node server.js
+
+
+That will spawn an http server at http://127.0.0.1:9999/ which will
+serve both html (served from the current directory) and also SockJS
+server (under the [/echo](http://127.0.0.1:9999/echo) path).

node_modules/sockjs/examples/echo/index.html

@@ -0,0 +1,71 @@
+<!doctype html>
+<html><head>
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
+    <script src="http://cdn.sockjs.org/sockjs-0.3.min.js"></script>
+    <style>
+      .box {
+          width: 300px;
+          float: left;
+          margin: 0 20px 0 20px;
+      }
+      .box div, .box input {
+          border: 1px solid;
+          -moz-border-radius: 4px;
+          border-radius: 4px;
+          width: 100%;
+          padding: 0px;
+          margin: 5px;
+      }
+      .box div {
+          border-color: grey;
+          height: 300px;
+          overflow: auto;
+      }
+      .box input {
+          height: 30px;
+      }
+      h1 {
+          margin-left: 30px;
+      }
+      body {
+          background-color: #F0F0F0;
+          font-family: "Arial";
+      }
+    </style>
+</head><body lang="en">
+    <h1>SockJS Echo example</h1>
+
+    <div id="first" class="box">
+      <div></div>
+      <form><input autocomplete="off" value="Type here..."></input></form>
+    </div>
+
+    <script>
+        var sockjs_url = '/echo';
+        var sockjs = new SockJS(sockjs_url);
+        $('#first input').focus();
+
+        var div  = $('#first div');
+        var inp  = $('#first input');
+        var form = $('#first form');
+
+        var print = function(m, p) {
+            p = (p === undefined) ? '' : JSON.stringify(p);
+            div.append($("<code>").text(m + ' ' + p));
+            div.append($("<br>"));
+            div.scrollTop(div.scrollTop()+10000);
+        };
+
+        sockjs.onopen    = function()  {print('[*] open', sockjs.protocol);};
+        sockjs.onmessage = function(e) {print('[.] message', e.data);};
+        sockjs.onclose   = function()  {print('[*] close');};
+
+        form.submit(function() {
+            print('[ ] sending', inp.val());
+            sockjs.send(inp.val());
+            inp.val('');
+            return false;
+        });
+
+    </script>
+</body></html>

node_modules/sockjs/examples/echo/package.json

@@ -0,0 +1,8 @@
+{
+        "name": "sockjs-echo",
+        "version": "0.0.0-unreleasable",
+        "dependencies": {
+                "node-static": "0.5.9",
+                "sockjs": "*"
+        }
+}

node_modules/sockjs/examples/echo/server.js

@@ -0,0 +1,30 @@
+var http = require('http');
+var sockjs = require('sockjs');
+var node_static = require('node-static');
+
+// 1. Echo sockjs server
+var sockjs_opts = {sockjs_url: "http://cdn.sockjs.org/sockjs-0.3.min.js"};
+
+var sockjs_echo = sockjs.createServer(sockjs_opts);
+sockjs_echo.on('connection', function(conn) {
+    conn.on('data', function(message) {
+        conn.write(message);
+    });
+});
+
+// 2. Static files server
+var static_directory = new node_static.Server(__dirname);
+
+// 3. Usual http stuff
+var server = http.createServer();
+server.addListener('request', function(req, res) {
+    static_directory.serve(req, res);
+});
+server.addListener('upgrade', function(req,res){
+    res.end();
+});
+
+sockjs_echo.installHandlers(server, {prefix:'/echo'});
+
+console.log(' [*] Listening on 0.0.0.0:9999' );
+server.listen(9999, '0.0.0.0');

node_modules/sockjs/examples/express-3.x/index.html

@@ -0,0 +1,71 @@
+<!doctype html>
+<html><head>
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
+    <script src="http://cdn.sockjs.org/sockjs-0.3.min.js"></script>
+    <style>
+      .box {
+          width: 300px;
+          float: left;
+          margin: 0 20px 0 20px;
+      }
+      .box div, .box input {
+          border: 1px solid;
+          -moz-border-radius: 4px;
+          border-radius: 4px;
+          width: 100%;
+          padding: 0px;
+          margin: 5px;
+      }
+      .box div {
+          border-color: grey;
+          height: 300px;
+          overflow: auto;
+      }
+      .box input {
+          height: 30px;
+      }
+      h1 {
+          margin-left: 30px;
+      }
+      body {
+          background-color: #F0F0F0;
+          font-family: "Arial";
+      }
+    </style>
+</head><body lang="en">
+    <h1>SockJS Express example</h1>
+
+    <div id="first" class="box">
+      <div></div>
+      <form><input autocomplete="off" value="Type here..."></input></form>
+    </div>
+
+    <script>
+        var sockjs_url = '/echo';
+        var sockjs = new SockJS(sockjs_url);
+        $('#first input').focus();
+
+        var div  = $('#first div');
+        var inp  = $('#first input');
+        var form = $('#first form');
+
+        var print = function(m, p) {
+            p = (p === undefined) ? '' : JSON.stringify(p);
+            div.append($("<code>").text(m + ' ' + p));
+            div.append($("<br>"));
+            div.scrollTop(div.scrollTop()+10000);
+        };
+
+        sockjs.onopen    = function()  {print('[*] open', sockjs.protocol);};
+        sockjs.onmessage = function(e) {print('[.] message', e.data);};
+        sockjs.onclose   = function()  {print('[*] close');};
+
+        form.submit(function() {
+            print('[ ] sending', inp.val());
+            sockjs.send(inp.val());
+            inp.val('');
+            return false;
+        });
+
+    </script>
+</body></html>

node_modules/sockjs/examples/express-3.x/package.json

@@ -0,0 +1,8 @@
+{
+        "name": "sockjs-express",
+        "version": "0.0.0-unreleasable",
+        "dependencies": {
+                "express": "~3*",
+                "sockjs": "*"
+        }
+}

node_modules/sockjs/examples/express-3.x/server.js

@@ -0,0 +1,26 @@
+var express = require('express');
+var sockjs  = require('sockjs');
+var http    = require('http');
+
+// 1. Echo sockjs server
+var sockjs_opts = {sockjs_url: "http://cdn.sockjs.org/sockjs-0.3.min.js"};
+
+var sockjs_echo = sockjs.createServer(sockjs_opts);
+sockjs_echo.on('connection', function(conn) {
+    conn.on('data', function(message) {
+        conn.write(message);
+    });
+});
+
+// 2. Express server
+var app = express(); /* express.createServer will not work here */
+var server = http.createServer(app);
+
+sockjs_echo.installHandlers(server, {prefix:'/echo'});
+
+console.log(' [*] Listening on 0.0.0.0:9999' );
+server.listen(9999, '0.0.0.0');
+
+app.get('/', function (req, res) {
+    res.sendfile(__dirname + '/index.html');
+});

node_modules/sockjs/examples/express/index.html

@@ -0,0 +1,71 @@
+<!doctype html>
+<html><head>
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
+    <script src="http://cdn.sockjs.org/sockjs-0.3.min.js"></script>
+    <style>
+      .box {
+          width: 300px;
+          float: left;
+          margin: 0 20px 0 20px;
+      }
+      .box div, .box input {
+          border: 1px solid;
+          -moz-border-radius: 4px;
+          border-radius: 4px;
+          width: 100%;
+          padding: 0px;
+          margin: 5px;
+      }
+      .box div {
+          border-color: grey;
+          height: 300px;
+          overflow: auto;
+      }
+      .box input {
+          height: 30px;
+      }
+      h1 {
+          margin-left: 30px;
+      }
+      body {
+          background-color: #F0F0F0;
+          font-family: "Arial";
+      }
+    </style>
+</head><body lang="en">
+    <h1>SockJS Express example</h1>
+
+    <div id="first" class="box">
+      <div></div>
+      <form><input autocomplete="off" value="Type here..."></input></form>
+    </div>
+
+    <script>
+        var sockjs_url = '/echo';
+        var sockjs = new SockJS(sockjs_url);
+        $('#first input').focus();
+
+        var div  = $('#first div');
+        var inp  = $('#first input');
+        var form = $('#first form');
+
+        var print = function(m, p) {
+            p = (p === undefined) ? '' : JSON.stringify(p);
+            div.append($("<code>").text(m + ' ' + p));
+            div.append($("<br>"));
+            div.scrollTop(div.scrollTop()+10000);
+        };
+
+        sockjs.onopen    = function()  {print('[*] open', sockjs.protocol);};
+        sockjs.onmessage = function(e) {print('[.] message', e.data);};
+        sockjs.onclose   = function()  {print('[*] close');};
+
+        form.submit(function() {
+            print('[ ] sending', inp.val());
+            sockjs.send(inp.val());
+            inp.val('');
+            return false;
+        });
+
+    </script>
+</body></html>

node_modules/sockjs/examples/express/package.json

@@ -0,0 +1,8 @@
+{
+        "name": "sockjs-express",
+        "version": "0.0.0-unreleasable",
+        "dependencies": {
+                "express": "<3",
+                "sockjs": "*"
+        }
+}

node_modules/sockjs/examples/express/server.js

@@ -0,0 +1,23 @@
+var express = require('express');
+var sockjs  = require('sockjs');
+
+// 1. Echo sockjs server
+var sockjs_opts = {sockjs_url: "http://cdn.sockjs.org/sockjs-0.3.min.js"};
+
+var sockjs_echo = sockjs.createServer(sockjs_opts);
+sockjs_echo.on('connection', function(conn) {
+    conn.on('data', function(message) {
+        conn.write(message);
+    });
+});
+
+// 2. Express server
+var app = express.createServer();
+sockjs_echo.installHandlers(app, {prefix:'/echo'});
+
+console.log(' [*] Listening on 0.0.0.0:9999' );
+app.listen(9999, '0.0.0.0');
+
+app.get('/', function (req, res) {
+    res.sendfile(__dirname + '/index.html');
+});

node_modules/sockjs/examples/haproxy.cfg

@@ -0,0 +1,42 @@
+# Requires recent Haproxy to work with websockets (for example 1.4.16).
+defaults
+    mode http
+    # Set timeouts to your needs
+    timeout client  5s
+    timeout connect 5s
+    timeout server  5s
+
+frontend all 0.0.0.0:8888
+    mode http
+    timeout client 120s
+
+    option forwardfor
+    # Fake connection:close, required in this setup.
+    option http-server-close
+    option http-pretend-keepalive
+
+    acl is_sockjs path_beg /echo /broadcast /close
+    acl is_stats  path_beg /stats
+
+    use_backend sockjs if is_sockjs
+    use_backend stats if is_stats
+    default_backend static
+
+
+backend sockjs
+    # Load-balance according to hash created from first two
+    # directories in url path. For example requests going to /1/
+    # should be handled by single server (assuming resource prefix is
+    # one-level deep, like "/echo").
+    balance uri depth 2
+    timeout server  120s
+    server srv_sockjs1 127.0.0.1:9999
+    # server srv_sockjs2 127.0.0.1:9998
+
+backend static
+    balance roundrobin
+    server srv_static 127.0.0.1:8000
+
+backend stats
+    stats uri /stats
+    stats enable

node_modules/sockjs/examples/multiplex/README.md

@@ -0,0 +1,26 @@
+WebSocket-multiplex SockJS example
+==================================
+
+This example is a copy of example from
+[websocket-multiplex](https://github.com/sockjs/websocket-multiplex/)
+project:
+
+ * https://github.com/sockjs/websocket-multiplex/
+
+
+To run this example, first install dependencies:
+
+    npm install
+
+And run a server:
+
+    node server.js
+
+
+That will spawn an http server at http://127.0.0.1:9999/ which will
+serve both html (served from the current directory) and also SockJS
+service (under the [/multiplex](http://127.0.0.1:9999/multiplex)
+path).
+
+With that set up, WebSocket-multiplex is able to push three virtual
+connections over a single SockJS connection. See the code for details.

node_modules/sockjs/examples/multiplex/index.html

@@ -0,0 +1,96 @@
+<!doctype html>
+<html><head>
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
+    <script src="http://cdn.sockjs.org/sockjs-0.3.min.js"></script>
+    <script src="http://cdn.sockjs.org/websocket-multiplex-0.1.js"></script>
+    <style>
+      .box {
+          width: 300px;
+          float: left;
+          margin: 0 20px 0 20px;
+      }
+      .box div, .box input {
+          border: 1px solid;
+          -moz-border-radius: 4px;
+          border-radius: 4px;
+          width: 100%;
+          padding: 0px;
+          margin: 5px;
+      }
+      .box div {
+          border-color: grey;
+          height: 300px;
+          overflow: auto;
+      }
+      .box input {
+          height: 30px;
+      }
+      h1 {
+          margin-left: 75px;
+      }
+      body {
+          background-color: #F0F0F0;
+          font-family: "Arial";
+      }
+    </style>
+</head><body lang="en">
+    <h1>SockJS Multiplex example</h1>
+
+    <div id="first" class="box">
+      <div></div>
+      <form><input autocomplete="off" value="Type here..."></input></form>
+    </div>
+
+    <div id="second" class="box">
+      <div></div>
+      <form><input autocomplete="off"></input></form>
+    </div>
+
+    <div id="third" class="box">
+      <div></div>
+      <form><input autocomplete="off"></input></form>
+    </div>
+
+    <script>
+        // Pipe - convenience wrapper to present data received from an
+        // object supporting WebSocket API in an html element. And the other
+        // direction: data typed into an input box shall be sent back.
+        var pipe = function(ws, el_name) {
+            var div  = $(el_name + ' div');
+            var inp  = $(el_name + ' input');
+            var form = $(el_name + ' form');
+
+            var print = function(m, p) {
+                p = (p === undefined) ? '' : JSON.stringify(p);
+                div.append($("<code>").text(m + ' ' + p));
+                div.append($("<br>"));
+                div.scrollTop(div.scrollTop() + 10000);
+            };
+
+            ws.onopen    = function()  {print('[*] open', ws.protocol);};
+            ws.onmessage = function(e) {print('[.] message', e.data);};
+            ws.onclose   = function()  {print('[*] close');};
+
+            form.submit(function() {
+                print('[ ] sending', inp.val());
+                ws.send(inp.val());
+                inp.val('');
+                return false;
+            });
+        };
+
+        var sockjs_url = '/multiplex';
+        var sockjs = new SockJS(sockjs_url);
+
+        var multiplexer = new WebSocketMultiplex(sockjs);
+        var ann  = multiplexer.channel('ann');
+        var bob  = multiplexer.channel('bob');
+        var carl = multiplexer.channel('carl');
+
+        pipe(ann,  '#first');
+        pipe(bob,  '#second');
+        pipe(carl, '#third');
+
+        $('#first input').focus();
+    </script>
+</body></html>

node_modules/sockjs/examples/multiplex/package.json

@@ -0,0 +1,9 @@
+{
+        "name": "sockjs-multiplex",
+        "version": "0.0.0-unreleasable",
+        "dependencies": {
+                "express": "2.5.8",
+                "sockjs": "*",
+                "websocket-multiplex" : "0.1.x"
+        }
+}

node_modules/sockjs/examples/multiplex/server.js

@@ -0,0 +1,52 @@
+var express             = require('express');
+var sockjs              = require('sockjs');
+
+var websocket_multiplex = require('websocket-multiplex');
+
+
+// 1. Setup SockJS server
+var sockjs_opts = {sockjs_url: "http://cdn.sockjs.org/sockjs-0.3.min.js"};
+var service = sockjs.createServer(sockjs_opts);
+
+
+// 2. Setup multiplexing
+var multiplexer = new websocket_multiplex.MultiplexServer(service);
+
+var ann = multiplexer.registerChannel('ann');
+ann.on('connection', function(conn) {
+    conn.write('Ann says hi!');
+    conn.on('data', function(data) {
+        conn.write('Ann nods: ' + data);
+    });
+});
+
+var bob = multiplexer.registerChannel('bob');
+bob.on('connection', function(conn) {
+    conn.write('Bob doesn\'t agree.');
+    conn.on('data', function(data) {
+        conn.write('Bob says no to: ' + data);
+    });
+});
+
+var carl = multiplexer.registerChannel('carl');
+carl.on('connection', function(conn) {
+    conn.write('Carl says goodbye!');
+    // Explicitly cancel connection
+    conn.end();
+});
+
+
+// 3. Express server
+var app = express.createServer();
+service.installHandlers(app, {prefix:'/multiplex'});
+
+console.log(' [*] Listening on 0.0.0.0:9999' );
+app.listen(9999, '0.0.0.0');
+
+app.get('/', function (req, res) {
+    res.sendfile(__dirname + '/index.html');
+});
+
+app.get('/multiplex.js', function (req, res) {
+    res.sendfile(__dirname + '/multiplex.js');
+});

node_modules/sockjs/examples/test_server/README.md

@@ -0,0 +1,30 @@
+SockJS test server
+==================
+
+In order to test sockjs server implementation the server needs to
+provide a standarized sockjs endpoint that will can used by various
+sockjs-related tests. For example by QUnit or
+[Sockjs-protocol](https://github.com/sockjs/sockjs-protocol) tests.
+
+This small code does exactly that - runs a simple server that supports
+the following SockJS services:
+
+ * `/echo`
+ * `/disabled_websocket_echo`
+ * `/cookie_needed_echo`
+ * `/close`
+ * `/ticker`
+ * `/amplify`
+ * `/broadcast`
+
+If you just want to quickly run it:
+
+    npm install
+    node server.js
+
+
+If you want to run do development it's recommended to run `make
+test_server` from the top `sockjs-node` directory:
+
+    cd ../..
+    make test_server

node_modules/sockjs/examples/test_server/config.js

@@ -0,0 +1,9 @@
+exports.config = {
+    server_opts: {
+        sockjs_url: 'http://localhost:8080/lib/sockjs.js',
+        websocket: true
+    },
+
+    port: 8081,
+    host: '0.0.0.0'
+};

node_modules/sockjs/examples/test_server/package.json

@@ -0,0 +1,7 @@
+{
+    "name": "sockjs-test-server",
+    "version": "0.0.0-unreleasable",
+    "dependencies": {
+        "sockjs": "*"
+    }
+}

node_modules/sockjs/examples/test_server/server.js

@@ -0,0 +1,19 @@
+var http = require('http');
+var config = require('./config').config;
+var sockjs_app = require('./sockjs_app');
+
+
+var server = http.createServer();
+server.addListener('request', function(req, res) {
+    res.setHeader('content-type', 'text/plain');
+    res.writeHead(404);
+    res.end('404 - Nothing here (via sockjs-node test_server)');
+});
+server.addListener('upgrade', function(req, res){
+    res.end();
+});
+
+sockjs_app.install(config.server_opts, server);
+
+console.log(" [*] Listening on", config.host + ':' + config.port);
+server.listen(config.port, config.host);

node_modules/sockjs/examples/test_server/sockjs_app.js

@@ -0,0 +1,85 @@
+var sockjs = require('sockjs');
+
+exports.install = function(opts, server) {
+    var sjs_echo = sockjs.createServer(opts);
+    sjs_echo.on('connection', function(conn) {
+        console.log('    [+] echo open    ' + conn);
+        conn.on('close', function() {
+            console.log('    [-] echo close   ' + conn);
+        });
+        conn.on('data', function(m) {
+            var d  = JSON.stringify(m);
+            console.log('    [ ] echo message ' + conn,
+                        d.slice(0,64)+
+                        ((d.length > 64) ? '...' : ''));
+            conn.write(m);
+        });
+    });
+
+    var sjs_close = sockjs.createServer(opts);
+    sjs_close.on('connection', function(conn) {
+        console.log('    [+] clos open    ' + conn);
+        conn.close(3000, "Go away!");
+        conn.on('close', function() {
+            console.log('    [-] clos close   ' + conn);
+        });
+    });
+
+    var sjs_ticker = sockjs.createServer(opts);
+    sjs_ticker.on('connection', function(conn) {
+        console.log('    [+] ticker open   ' + conn);
+        var tref;
+        var schedule = function() {
+            conn.write('tick!');
+            tref = setTimeout(schedule, 1000);
+        };
+        tref = setTimeout(schedule, 1000);
+        conn.on('close', function() {
+            clearTimeout(tref);
+            console.log('    [-] ticker close   ' + conn);
+        });
+    });
+
+    var broadcast = {};
+    var sjs_broadcast = sockjs.createServer(opts);
+    sjs_broadcast.on('connection', function(conn) {
+        console.log('    [+] broadcast open ' + conn);
+        broadcast[conn.id] = conn;
+        conn.on('close', function() {
+            delete broadcast[conn.id];
+            console.log('    [-] broadcast close' + conn);
+        });
+        conn.on('data', function(m) {
+            console.log('    [-] broadcast message', m);
+            for(var id in broadcast) {
+                broadcast[id].write(m);
+            }
+        });
+    });
+
+    var sjs_amplify = sockjs.createServer(opts);
+    sjs_amplify.on('connection', function(conn) {
+        console.log('    [+] amp open    ' + conn);
+        conn.on('close', function() {
+            console.log('    [-] amp close   ' + conn);
+        });
+        conn.on('data', function(m) {
+            var n = Math.floor(Number(m));
+            n = (n > 0 && n < 19) ? n : 1;
+            console.log('    [ ] amp message: 2^' + n);
+            conn.write(Array(Math.pow(2, n)+1).join('x'));
+        });
+    });
+
+
+    sjs_echo.installHandlers(server, {prefix:'/echo',
+                                      response_limit: 4096}),
+    sjs_echo.installHandlers(server, {prefix:'/disabled_websocket_echo',
+                                      websocket: false});
+    sjs_echo.installHandlers(server, {prefix:'/cookie_needed_echo',
+                                      jsessionid: true});
+    sjs_close.installHandlers(server, {prefix:'/close'});
+    sjs_ticker.installHandlers(server, {prefix:'/ticker'});
+    sjs_amplify.installHandlers(server, {prefix:'/amplify'});
+    sjs_broadcast.installHandlers(server, {prefix:'/broadcast'});
+};

node_modules/sockjs/index.js

@@ -0,0 +1 @@
+module.exports = require('./lib/sockjs');

node_modules/sockjs/lib/chunking-test.js

@@ -0,0 +1,73 @@
+(function() {
+  var utils;
+
+  utils = require('./utils');
+
+  exports.app = {
+    chunking_test: function(req, res, _, next_filter) {
+      var write,
+        _this = this;
+      res.setHeader('Content-Type', 'application/javascript; charset=UTF-8');
+      res.writeHead(200);
+      write = function(payload) {
+        try {
+          return res.write(payload + '\n');
+        } catch (x) {
+
+        }
+      };
+      utils.timeout_chain([
+        [
+          0, function() {
+            return write('h');
+          }
+        ], [
+          1, function() {
+            return write(Array(2049).join(' ') + 'h');
+          }
+        ], [
+          5, function() {
+            return write('h');
+          }
+        ], [
+          25, function() {
+            return write('h');
+          }
+        ], [
+          125, function() {
+            return write('h');
+          }
+        ], [
+          625, function() {
+            return write('h');
+          }
+        ], [
+          3125, function() {
+            write('h');
+            return res.end();
+          }
+        ]
+      ]);
+      return true;
+    },
+    info: function(req, res, _) {
+      var info;
+      info = {
+        websocket: this.options.websocket,
+        origins: ['*:*'],
+        cookie_needed: !!this.options.jsessionid,
+        entropy: utils.random32()
+      };
+      res.setHeader('Content-Type', 'application/json; charset=UTF-8');
+      res.writeHead(200);
+      return res.end(JSON.stringify(info));
+    },
+    info_options: function(req, res) {
+      res.statusCode = 204;
+      res.setHeader('Access-Control-Allow-Methods', 'OPTIONS, GET');
+      res.setHeader('Access-Control-Max-Age', res.cache_for);
+      return '';
+    }
+  };
+
+}).call(this);

node_modules/sockjs/lib/iframe.js

@@ -0,0 +1,29 @@
+(function() {
+  var iframe_template, utils;
+
+  utils = require('./utils');
+
+  iframe_template = "<!DOCTYPE html>\n<html>\n<head>\n  <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\" />\n  <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n  <script>\n    document.domain = document.domain;\n    _sockjs_onload = function(){SockJS.bootstrap_iframe();};\n  </script>\n  <script src=\"{{ sockjs_url }}\"></script>\n</head>\n<body>\n  <h2>Don't panic!</h2>\n  <p>This is a SockJS hidden iframe. It's used for cross domain magic.</p>\n</body>\n</html>";
+
+  exports.app = {
+    iframe: function(req, res) {
+      var content, context, k, quoted_md5;
+      context = {
+        '{{ sockjs_url }}': this.options.sockjs_url
+      };
+      content = iframe_template;
+      for (k in context) {
+        content = content.replace(k, context[k]);
+      }
+      quoted_md5 = '"' + utils.md5_hex(content) + '"';
+      if ('if-none-match' in req.headers && req.headers['if-none-match'] === quoted_md5) {
+        res.statusCode = 304;
+        return '';
+      }
+      res.setHeader('Content-Type', 'text/html; charset=UTF-8');
+      res.setHeader('ETag', quoted_md5);
+      return content;
+    }
+  };
+
+}).call(this);

node_modules/sockjs/lib/sockjs.js

@@ -0,0 +1,216 @@
+(function() {
+  var App, Listener, Server, chunking_test, events, fs, generate_dispatcher, iframe, sockjsVersion, trans_eventsource, trans_htmlfile, trans_jsonp, trans_websocket, trans_xhr, utils, webjs,
+    __hasProp = Object.prototype.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; },
+    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  events = require('events');
+
+  fs = require('fs');
+
+  webjs = require('./webjs');
+
+  utils = require('./utils');
+
+  trans_websocket = require('./trans-websocket');
+
+  trans_jsonp = require('./trans-jsonp');
+
+  trans_xhr = require('./trans-xhr');
+
+  iframe = require('./iframe');
+
+  trans_eventsource = require('./trans-eventsource');
+
+  trans_htmlfile = require('./trans-htmlfile');
+
+  chunking_test = require('./chunking-test');
+
+  sockjsVersion = function() {
+    var pkg;
+    try {
+      pkg = fs.readFileSync(__dirname + '/../package.json', 'utf-8');
+    } catch (x) {
+
+    }
+    if (pkg) {
+      return JSON.parse(pkg).version;
+    } else {
+      return null;
+    }
+  };
+
+  App = (function(_super) {
+
+    __extends(App, _super);
+
+    function App() {
+      App.__super__.constructor.apply(this, arguments);
+    }
+
+    App.prototype.welcome_screen = function(req, res) {
+      res.setHeader('content-type', 'text/plain; charset=UTF-8');
+      res.writeHead(200);
+      res.end("Welcome to SockJS!\n");
+      return true;
+    };
+
+    App.prototype.handle_404 = function(req, res) {
+      res.setHeader('content-type', 'text/plain; charset=UTF-8');
+      res.writeHead(404);
+      res.end('404 Error: Page not found\n');
+      return true;
+    };
+
+    App.prototype.disabled_transport = function(req, res, data) {
+      return this.handle_404(req, res, data);
+    };
+
+    App.prototype.h_sid = function(req, res, data) {
+      var jsid;
+      req.cookies = utils.parseCookie(req.headers.cookie);
+      if (typeof this.options.jsessionid === 'function') {
+        this.options.jsessionid(req, res);
+      } else if (this.options.jsessionid && res.setHeader) {
+        jsid = req.cookies['JSESSIONID'] || 'dummy';
+        res.setHeader('Set-Cookie', 'JSESSIONID=' + jsid + '; path=/');
+      }
+      return data;
+    };
+
+    App.prototype.log = function(severity, line) {
+      return this.options.log(severity, line);
+    };
+
+    return App;
+
+  })(webjs.GenericApp);
+
+  utils.objectExtend(App.prototype, iframe.app);
+
+  utils.objectExtend(App.prototype, chunking_test.app);
+
+  utils.objectExtend(App.prototype, trans_websocket.app);
+
+  utils.objectExtend(App.prototype, trans_jsonp.app);
+
+  utils.objectExtend(App.prototype, trans_xhr.app);
+
+  utils.objectExtend(App.prototype, trans_eventsource.app);
+
+  utils.objectExtend(App.prototype, trans_htmlfile.app);
+
+  generate_dispatcher = function(options) {
+    var dispatcher, opts_filters, p, t,
+      _this = this;
+    p = function(s) {
+      return new RegExp('^' + options.prefix + s + '[/]?$');
+    };
+    t = function(s) {
+      return [p('/([^/.]+)/([^/.]+)' + s), 'server', 'session'];
+    };
+    opts_filters = function(options_filter) {
+      if (options_filter == null) options_filter = 'xhr_options';
+      return ['h_sid', 'xhr_cors', 'cache_for', options_filter, 'expose'];
+    };
+    dispatcher = [['GET', p(''), ['welcome_screen']], ['GET', p('/iframe[0-9-.a-z_]*.html'), ['iframe', 'cache_for', 'expose']], ['OPTIONS', p('/info'), opts_filters('info_options')], ['GET', p('/info'), ['xhr_cors', 'h_no_cache', 'info', 'expose']], ['OPTIONS', p('/chunking_test'), opts_filters()], ['POST', p('/chunking_test'), ['xhr_cors', 'expect_xhr', 'chunking_test']], ['GET', p('/websocket'), ['raw_websocket']], ['GET', t('/jsonp'), ['h_sid', 'h_no_cache', 'jsonp']], ['POST', t('/jsonp_send'), ['h_sid', 'h_no_cache', 'expect_form', 'jsonp_send']], ['POST', t('/xhr'), ['h_sid', 'h_no_cache', 'xhr_cors', 'xhr_poll']], ['OPTIONS', t('/xhr'), opts_filters()], ['POST', t('/xhr_send'), ['h_sid', 'h_no_cache', 'xhr_cors', 'expect_xhr', 'xhr_send']], ['OPTIONS', t('/xhr_send'), opts_filters()], ['POST', t('/xhr_streaming'), ['h_sid', 'h_no_cache', 'xhr_cors', 'xhr_streaming']], ['OPTIONS', t('/xhr_streaming'), opts_filters()], ['GET', t('/eventsource'), ['h_sid', 'h_no_cache', 'eventsource']], ['GET', t('/htmlfile'), ['h_sid', 'h_no_cache', 'htmlfile']]];
+    if (options.websocket) {
+      dispatcher.push(['GET', t('/websocket'), ['sockjs_websocket']]);
+    } else {
+      dispatcher.push(['GET', t('/websocket'), ['cache_for', 'disabled_transport']]);
+    }
+    return dispatcher;
+  };
+
+  Listener = (function() {
+
+    function Listener(options, emit) {
+      this.options = options;
+      this.handler = __bind(this.handler, this);
+      this.app = new App();
+      this.app.options = options;
+      this.app.emit = emit;
+      this.app.log('debug', 'SockJS v' + sockjsVersion() + ' ' + 'bound to ' + JSON.stringify(options.prefix));
+      this.dispatcher = generate_dispatcher(this.options);
+      this.webjs_handler = webjs.generateHandler(this.app, this.dispatcher);
+      this.path_regexp = new RegExp('^' + this.options.prefix + '([/].+|[/]?)$');
+    }
+
+    Listener.prototype.handler = function(req, res, extra) {
+      if (!req.url.match(this.path_regexp)) return false;
+      this.webjs_handler(req, res, extra);
+      return true;
+    };
+
+    Listener.prototype.getHandler = function() {
+      var _this = this;
+      return function(a, b, c) {
+        return _this.handler(a, b, c);
+      };
+    };
+
+    return Listener;
+
+  })();
+
+  Server = (function(_super) {
+
+    __extends(Server, _super);
+
+    function Server(user_options) {
+      this.options = {
+        prefix: '',
+        response_limit: 128 * 1024,
+        websocket: true,
+        jsessionid: false,
+        heartbeat_delay: 25000,
+        disconnect_delay: 5000,
+        log: function(severity, line) {
+          return console.log(line);
+        },
+        sockjs_url: 'https://d1fxtkz8shb9d2.cloudfront.net/sockjs-0.3.min.js'
+      };
+      if (user_options) utils.objectExtend(this.options, user_options);
+    }
+
+    Server.prototype.listener = function(handler_options) {
+      var options,
+        _this = this;
+      options = utils.objectExtend({}, this.options);
+      if (handler_options) utils.objectExtend(options, handler_options);
+      return new Listener(options, function() {
+        return _this.emit.apply(_this, arguments);
+      });
+    };
+
+    Server.prototype.installHandlers = function(http_server, handler_options) {
+      var handler;
+      handler = this.listener(handler_options).getHandler();
+      utils.overshadowListeners(http_server, 'request', handler);
+      utils.overshadowListeners(http_server, 'upgrade', handler);
+      return true;
+    };
+
+    Server.prototype.middleware = function(handler_options) {
+      var handler;
+      handler = this.listener(handler_options).getHandler();
+      handler.upgrade = handler;
+      return handler;
+    };
+
+    return Server;
+
+  })(events.EventEmitter);
+
+  exports.createServer = function(options) {
+    return new Server(options);
+  };
+
+  exports.listen = function(http_server, options) {
+    var srv;
+    srv = exports.createServer(options);
+    if (http_server) srv.installHandlers(http_server);
+    return srv;
+  };
+
+}).call(this);

node_modules/sockjs/lib/trans-eventsource.js

@@ -0,0 +1,40 @@
+(function() {
+  var EventSourceReceiver, transport, utils,
+    __hasProp = Object.prototype.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; };
+
+  utils = require('./utils');
+
+  transport = require('./transport');
+
+  EventSourceReceiver = (function(_super) {
+
+    __extends(EventSourceReceiver, _super);
+
+    function EventSourceReceiver() {
+      EventSourceReceiver.__super__.constructor.apply(this, arguments);
+    }
+
+    EventSourceReceiver.prototype.protocol = "eventsource";
+
+    EventSourceReceiver.prototype.doSendFrame = function(payload) {
+      var data;
+      data = ['data: ', utils.escape_selected(payload, '\r\n\x00'), '\r\n\r\n'];
+      return EventSourceReceiver.__super__.doSendFrame.call(this, data.join(''));
+    };
+
+    return EventSourceReceiver;
+
+  })(transport.ResponseReceiver);
+
+  exports.app = {
+    eventsource: function(req, res) {
+      res.setHeader('Content-Type', 'text/event-stream; charset=UTF-8');
+      res.writeHead(200);
+      res.write('\r\n');
+      transport.register(req, this, new EventSourceReceiver(req, res, this.options));
+      return true;
+    }
+  };
+
+}).call(this);

node_modules/sockjs/lib/trans-htmlfile.js

@@ -0,0 +1,58 @@
+(function() {
+  var HtmlFileReceiver, iframe_template, transport, utils,
+    __hasProp = Object.prototype.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; };
+
+  utils = require('./utils');
+
+  transport = require('./transport');
+
+  iframe_template = "<!doctype html>\n<html><head>\n  <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\" />\n  <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\" />\n</head><body><h2>Don't panic!</h2>\n  <script>\n    document.domain = document.domain;\n    var c = parent.{{ callback }};\n    c.start();\n    function p(d) {c.message(d);};\n    window.onload = function() {c.stop();};\n  </script>";
+
+  iframe_template += Array(1024 - iframe_template.length + 14).join(' ');
+
+  iframe_template += '\r\n\r\n';
+
+  HtmlFileReceiver = (function(_super) {
+
+    __extends(HtmlFileReceiver, _super);
+
+    function HtmlFileReceiver() {
+      HtmlFileReceiver.__super__.constructor.apply(this, arguments);
+    }
+
+    HtmlFileReceiver.prototype.protocol = "htmlfile";
+
+    HtmlFileReceiver.prototype.doSendFrame = function(payload) {
+      return HtmlFileReceiver.__super__.doSendFrame.call(this, '<script>\np(' + JSON.stringify(payload) + ');\n</script>\r\n');
+    };
+
+    return HtmlFileReceiver;
+
+  })(transport.ResponseReceiver);
+
+  exports.app = {
+    htmlfile: function(req, res) {
+      var callback;
+      if (!('c' in req.query || 'callback' in req.query)) {
+        throw {
+          status: 500,
+          message: '"callback" parameter required'
+        };
+      }
+      callback = 'c' in req.query ? req.query['c'] : req.query['callback'];
+      if (/[^a-zA-Z0-9-_.]/.test(callback)) {
+        throw {
+          status: 500,
+          message: 'invalid "callback" parameter'
+        };
+      }
+      res.setHeader('Content-Type', 'text/html; charset=UTF-8');
+      res.writeHead(200);
+      res.write(iframe_template.replace(/{{ callback }}/g, callback));
+      transport.register(req, this, new HtmlFileReceiver(req, res, this.options));
+      return true;
+    }
+  };
+
+}).call(this);

node_modules/sockjs/lib/trans-jsonp.js

@@ -0,0 +1,104 @@
+(function() {
+  var JsonpReceiver, transport,
+    __hasProp = Object.prototype.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; };
+
+  transport = require('./transport');
+
+  JsonpReceiver = (function(_super) {
+
+    __extends(JsonpReceiver, _super);
+
+    JsonpReceiver.prototype.protocol = "jsonp-polling";
+
+    JsonpReceiver.prototype.max_response_size = 1;
+
+    function JsonpReceiver(req, res, options, callback) {
+      this.callback = callback;
+      JsonpReceiver.__super__.constructor.call(this, req, res, options);
+    }
+
+    JsonpReceiver.prototype.doSendFrame = function(payload) {
+      return JsonpReceiver.__super__.doSendFrame.call(this, this.callback + "(" + JSON.stringify(payload) + ");\r\n");
+    };
+
+    return JsonpReceiver;
+
+  })(transport.ResponseReceiver);
+
+  exports.app = {
+    jsonp: function(req, res, _, next_filter) {
+      var callback;
+      if (!('c' in req.query || 'callback' in req.query)) {
+        throw {
+          status: 500,
+          message: '"callback" parameter required'
+        };
+      }
+      callback = 'c' in req.query ? req.query['c'] : req.query['callback'];
+      if (/[^a-zA-Z0-9-_.]/.test(callback)) {
+        throw {
+          status: 500,
+          message: 'invalid "callback" parameter'
+        };
+      }
+      res.setHeader('Content-Type', 'application/javascript; charset=UTF-8');
+      res.writeHead(200);
+      transport.register(req, this, new JsonpReceiver(req, res, this.options, callback));
+      return true;
+    },
+    jsonp_send: function(req, res, query) {
+      var d, jsonp, message, _i, _len;
+      if (!query) {
+        throw {
+          status: 500,
+          message: 'Payload expected.'
+        };
+      }
+      if (typeof query === 'string') {
+        try {
+          d = JSON.parse(query);
+        } catch (x) {
+          throw {
+            status: 500,
+            message: 'Broken JSON encoding.'
+          };
+        }
+      } else {
+        d = query.d;
+      }
+      if (typeof d === 'string' && d) {
+        try {
+          d = JSON.parse(d);
+        } catch (x) {
+          throw {
+            status: 500,
+            message: 'Broken JSON encoding.'
+          };
+        }
+      }
+      if (!d || d.__proto__.constructor !== Array) {
+        throw {
+          status: 500,
+          message: 'Payload expected.'
+        };
+      }
+      jsonp = transport.Session.bySessionId(req.session);
+      if (jsonp === null) {
+        throw {
+          status: 404
+        };
+      }
+      for (_i = 0, _len = d.length; _i < _len; _i++) {
+        message = d[_i];
+        jsonp.didMessage(message);
+      }
+      res.setHeader('Content-Length', '2');
+      res.setHeader('Content-Type', 'text/plain; charset=UTF-8');
+      res.writeHead(200);
+      res.end('ok');
+      return true;
+    }
+  };
+
+}).call(this);

node_modules/sockjs/lib/trans-websocket.js

@@ -0,0 +1,205 @@
+(function() {
+  var FayeWebsocket, RawWebsocketSessionReceiver, Transport, WebSocketReceiver, transport, utils,
+    __hasProp = Object.prototype.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; };
+
+  FayeWebsocket = require('faye-websocket');
+
+  utils = require('./utils');
+
+  transport = require('./transport');
+
+  exports.app = {
+    _websocket_check: function(req, connection, head) {
+      var conn;
+      if ((req.headers.upgrade || '').toLowerCase() !== 'websocket') {
+        throw {
+          status: 400,
+          message: 'Can "Upgrade" only to "WebSocket".'
+        };
+      }
+      conn = (req.headers.connection || '').toLowerCase();
+      if ((conn.split(/, */)).indexOf('upgrade') === -1) {
+        throw {
+          status: 400,
+          message: '"Connection" must be "Upgrade".'
+        };
+      }
+    },
+    sockjs_websocket: function(req, connection, head) {
+      var ws,
+        _this = this;
+      this._websocket_check(req, connection, head);
+      ws = new FayeWebsocket(req, connection, head);
+      ws.onopen = function() {
+        return transport.registerNoSession(req, _this, new WebSocketReceiver(ws, connection));
+      };
+      return true;
+    },
+    raw_websocket: function(req, connection, head) {
+      var ver, ws,
+        _this = this;
+      this._websocket_check(req, connection, head);
+      ver = req.headers['sec-websocket-version'] || '';
+      if (['8', '13'].indexOf(ver) === -1) {
+        throw {
+          status: 400,
+          message: 'Only supported WebSocket protocol is RFC 6455.'
+        };
+      }
+      ws = new FayeWebsocket(req, connection, head);
+      ws.onopen = function() {
+        return new RawWebsocketSessionReceiver(req, connection, _this, ws);
+      };
+      return true;
+    }
+  };
+
+  WebSocketReceiver = (function(_super) {
+
+    __extends(WebSocketReceiver, _super);
+
+    WebSocketReceiver.prototype.protocol = "websocket";
+
+    function WebSocketReceiver(ws, connection) {
+      var _this = this;
+      this.ws = ws;
+      this.connection = connection;
+      try {
+        this.connection.setKeepAlive(true, 5000);
+        this.connection.setNoDelay(true);
+      } catch (x) {
+
+      }
+      this.ws.addEventListener('message', function(m) {
+        return _this.didMessage(m.data);
+      });
+      WebSocketReceiver.__super__.constructor.call(this, this.connection);
+    }
+
+    WebSocketReceiver.prototype.setUp = function() {
+      WebSocketReceiver.__super__.setUp.apply(this, arguments);
+      return this.ws.addEventListener('close', this.thingy_end_cb);
+    };
+
+    WebSocketReceiver.prototype.tearDown = function() {
+      this.ws.removeEventListener('close', this.thingy_end_cb);
+      return WebSocketReceiver.__super__.tearDown.apply(this, arguments);
+    };
+
+    WebSocketReceiver.prototype.didMessage = function(payload) {
+      var message, msg, _i, _len, _results;
+      if (this.ws && this.session && payload.length > 0) {
+        try {
+          message = JSON.parse(payload);
+        } catch (x) {
+          return this.didClose(1002, 'Broken framing.');
+        }
+        if (payload[0] === '[') {
+          _results = [];
+          for (_i = 0, _len = message.length; _i < _len; _i++) {
+            msg = message[_i];
+            _results.push(this.session.didMessage(msg));
+          }
+          return _results;
+        } else {
+          return this.session.didMessage(message);
+        }
+      }
+    };
+
+    WebSocketReceiver.prototype.doSendFrame = function(payload) {
+      if (this.ws) {
+        try {
+          this.ws.send(payload);
+          return true;
+        } catch (x) {
+
+        }
+      }
+      return false;
+    };
+
+    WebSocketReceiver.prototype.didClose = function() {
+      WebSocketReceiver.__super__.didClose.apply(this, arguments);
+      try {
+        this.ws.close(1000, "Normal closure", false);
+      } catch (x) {
+
+      }
+      this.ws = null;
+      return this.connection = null;
+    };
+
+    return WebSocketReceiver;
+
+  })(transport.GenericReceiver);
+
+  Transport = transport.Transport;
+
+  RawWebsocketSessionReceiver = (function(_super) {
+
+    __extends(RawWebsocketSessionReceiver, _super);
+
+    function RawWebsocketSessionReceiver(req, conn, server, ws) {
+      var _this = this;
+      this.ws = ws;
+      this.prefix = server.options.prefix;
+      this.readyState = Transport.OPEN;
+      this.recv = {
+        connection: conn,
+        protocol: "websocket-raw"
+      };
+      this.connection = new transport.SockJSConnection(this);
+      this.decorateConnection(req);
+      server.emit('connection', this.connection);
+      this._end_cb = function() {
+        return _this.didClose();
+      };
+      this.ws.addEventListener('close', this._end_cb);
+      this._message_cb = function(m) {
+        return _this.didMessage(m);
+      };
+      this.ws.addEventListener('message', this._message_cb);
+    }
+
+    RawWebsocketSessionReceiver.prototype.didMessage = function(m) {
+      if (this.readyState === Transport.OPEN) this.connection.emit('data', m.data);
+    };
+
+    RawWebsocketSessionReceiver.prototype.send = function(payload) {
+      if (this.readyState !== Transport.OPEN) return false;
+      this.ws.send(payload);
+      return true;
+    };
+
+    RawWebsocketSessionReceiver.prototype.close = function(status, reason) {
+      if (status == null) status = 1000;
+      if (reason == null) reason = "Normal closure";
+      if (this.readyState !== Transport.OPEN) return false;
+      this.readyState = Transport.CLOSING;
+      this.ws.close(status, reason, false);
+      return true;
+    };
+
+    RawWebsocketSessionReceiver.prototype.didClose = function() {
+      if (!this.ws) return;
+      this.ws.removeEventListener('message', this._message_cb);
+      this.ws.removeEventListener('close', this._end_cb);
+      try {
+        this.ws.close(1000, "Normal closure", false);
+      } catch (x) {
+
+      }
+      this.ws = null;
+      this.readyState = Transport.CLOSED;
+      this.connection.emit('end');
+      this.connection.emit('close');
+      return this.connection = null;
+    };
+
+    return RawWebsocketSessionReceiver;
+
+  })(transport.Session);
+
+}).call(this);

node_modules/sockjs/lib/trans-xhr.js

@@ -0,0 +1,116 @@
+(function() {
+  var XhrPollingReceiver, XhrStreamingReceiver, transport, utils,
+    __hasProp = Object.prototype.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; };
+
+  transport = require('./transport');
+
+  utils = require('./utils');
+
+  XhrStreamingReceiver = (function(_super) {
+
+    __extends(XhrStreamingReceiver, _super);
+
+    function XhrStreamingReceiver() {
+      XhrStreamingReceiver.__super__.constructor.apply(this, arguments);
+    }
+
+    XhrStreamingReceiver.prototype.protocol = "xhr-streaming";
+
+    XhrStreamingReceiver.prototype.doSendFrame = function(payload) {
+      return XhrStreamingReceiver.__super__.doSendFrame.call(this, payload + '\n');
+    };
+
+    return XhrStreamingReceiver;
+
+  })(transport.ResponseReceiver);
+
+  XhrPollingReceiver = (function(_super) {
+
+    __extends(XhrPollingReceiver, _super);
+
+    function XhrPollingReceiver() {
+      XhrPollingReceiver.__super__.constructor.apply(this, arguments);
+    }
+
+    XhrPollingReceiver.prototype.protocol = "xhr-polling";
+
+    XhrPollingReceiver.prototype.max_response_size = 1;
+
+    return XhrPollingReceiver;
+
+  })(XhrStreamingReceiver);
+
+  exports.app = {
+    xhr_options: function(req, res) {
+      res.statusCode = 204;
+      res.setHeader('Access-Control-Allow-Methods', 'OPTIONS, POST');
+      res.setHeader('Access-Control-Max-Age', res.cache_for);
+      return '';
+    },
+    xhr_send: function(req, res, data) {
+      var d, jsonp, message, _i, _len;
+      if (!data) {
+        throw {
+          status: 500,
+          message: 'Payload expected.'
+        };
+      }
+      try {
+        d = JSON.parse(data);
+      } catch (x) {
+        throw {
+          status: 500,
+          message: 'Broken JSON encoding.'
+        };
+      }
+      if (!d || d.__proto__.constructor !== Array) {
+        throw {
+          status: 500,
+          message: 'Payload expected.'
+        };
+      }
+      jsonp = transport.Session.bySessionId(req.session);
+      if (!jsonp) {
+        throw {
+          status: 404
+        };
+      }
+      for (_i = 0, _len = d.length; _i < _len; _i++) {
+        message = d[_i];
+        jsonp.didMessage(message);
+      }
+      res.setHeader('Content-Type', 'text/plain; charset=UTF-8');
+      res.writeHead(204);
+      res.end();
+      return true;
+    },
+    xhr_cors: function(req, res, content) {
+      var headers, origin;
+      if (!req.headers['origin'] || req.headers['origin'] === 'null') {
+        origin = '*';
+      } else {
+        origin = req.headers['origin'];
+      }
+      res.setHeader('Access-Control-Allow-Origin', origin);
+      headers = req.headers['access-control-request-headers'];
+      if (headers) res.setHeader('Access-Control-Allow-Headers', headers);
+      res.setHeader('Access-Control-Allow-Credentials', 'true');
+      return content;
+    },
+    xhr_poll: function(req, res, _, next_filter) {
+      res.setHeader('Content-Type', 'application/javascript; charset=UTF-8');
+      res.writeHead(200);
+      transport.register(req, this, new XhrPollingReceiver(req, res, this.options));
+      return true;
+    },
+    xhr_streaming: function(req, res, _, next_filter) {
+      res.setHeader('Content-Type', 'application/javascript; charset=UTF-8');
+      res.writeHead(200);
+      res.write(Array(2049).join('h') + '\n');
+      transport.register(req, this, new XhrStreamingReceiver(req, res, this.options));
+      return true;
+    }
+  };
+
+}).call(this);

node_modules/sockjs/lib/transport.js

@@ -0,0 +1,386 @@
+(function() {
+  var GenericReceiver, MAP, ResponseReceiver, Session, SockJSConnection, Transport, closeFrame, register, stream, utils, uuid,
+    __hasProp = Object.prototype.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; };
+
+  stream = require('stream');
+
+  uuid = require('node-uuid');
+
+  utils = require('./utils');
+
+  Transport = (function() {
+
+    function Transport() {}
+
+    return Transport;
+
+  })();
+
+  Transport.CONNECTING = 0;
+
+  Transport.OPEN = 1;
+
+  Transport.CLOSING = 2;
+
+  Transport.CLOSED = 3;
+
+  closeFrame = function(status, reason) {
+    return 'c' + JSON.stringify([status, reason]);
+  };
+
+  SockJSConnection = (function(_super) {
+
+    __extends(SockJSConnection, _super);
+
+    function SockJSConnection(_session) {
+      this._session = _session;
+      this.id = uuid();
+      this.headers = {};
+      this.prefix = this._session.prefix;
+    }
+
+    SockJSConnection.prototype.toString = function() {
+      return '<SockJSConnection ' + this.id + '>';
+    };
+
+    SockJSConnection.prototype.write = function(string) {
+      return this._session.send('' + string);
+    };
+
+    SockJSConnection.prototype.end = function(string) {
+      if (string) this.write(string);
+      this.close();
+      return null;
+    };
+
+    SockJSConnection.prototype.close = function(code, reason) {
+      return this._session.close(code, reason);
+    };
+
+    SockJSConnection.prototype.destroy = function() {
+      this.removeAllListeners();
+      return this.end();
+    };
+
+    SockJSConnection.prototype.destroySoon = function() {
+      return this.destroy();
+    };
+
+    return SockJSConnection;
+
+  })(stream.Stream);
+
+  SockJSConnection.prototype.__defineGetter__('readable', function() {
+    return this._session.readyState === Transport.OPEN;
+  });
+
+  SockJSConnection.prototype.__defineGetter__('writable', function() {
+    return this._session.readyState === Transport.OPEN;
+  });
+
+  SockJSConnection.prototype.__defineGetter__('readyState', function() {
+    return this._session.readyState;
+  });
+
+  MAP = {};
+
+  Session = (function() {
+
+    function Session(session_id, server) {
+      var _this = this;
+      this.session_id = session_id;
+      this.heartbeat_delay = server.options.heartbeat_delay;
+      this.disconnect_delay = server.options.disconnect_delay;
+      this.prefix = server.options.prefix;
+      this.send_buffer = [];
+      this.is_closing = false;
+      this.readyState = Transport.CONNECTING;
+      if (this.session_id) MAP[this.session_id] = this;
+      this.timeout_cb = function() {
+        return _this.didTimeout();
+      };
+      this.to_tref = setTimeout(this.timeout_cb, this.disconnect_delay);
+      this.connection = new SockJSConnection(this);
+      this.emit_open = function() {
+        _this.emit_open = null;
+        return server.emit('connection', _this.connection);
+      };
+    }
+
+    Session.prototype.register = function(req, recv) {
+      if (this.recv) {
+        recv.doSendFrame(closeFrame(2010, "Another connection still open"));
+        recv.didClose();
+        return;
+      }
+      if (this.to_tref) {
+        clearTimeout(this.to_tref);
+        this.to_tref = null;
+      }
+      if (this.readyState === Transport.CLOSING) {
+        this.flushToRecv(recv);
+        recv.doSendFrame(this.close_frame);
+        recv.didClose();
+        this.to_tref = setTimeout(this.timeout_cb, this.disconnect_delay);
+        return;
+      }
+      this.recv = recv;
+      this.recv.session = this;
+      this.decorateConnection(req);
+      if (this.readyState === Transport.CONNECTING) {
+        this.recv.doSendFrame('o');
+        this.readyState = Transport.OPEN;
+        process.nextTick(this.emit_open);
+      }
+      if (!this.recv) return;
+      this.tryFlush();
+    };
+
+    Session.prototype.decorateConnection = function(req) {
+      var address, headers, key, remoteAddress, remotePort, socket, _i, _len, _ref;
+      if (!(socket = this.recv.connection)) socket = this.recv.response.connection;
+      try {
+        remoteAddress = socket.remoteAddress;
+        remotePort = socket.remotePort;
+        address = socket.address();
+      } catch (x) {
+
+      }
+      if (remoteAddress) {
+        this.connection.remoteAddress = remoteAddress;
+        this.connection.remotePort = remotePort;
+        this.connection.address = address;
+      }
+      this.connection.url = req.url;
+      this.connection.pathname = req.pathname;
+      this.connection.protocol = this.recv.protocol;
+      headers = {};
+      _ref = ['referer', 'x-client-ip', 'x-forwarded-for', 'x-cluster-client-ip', 'via', 'x-real-ip', 'host', 'user-agent', 'accept-language'];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        key = _ref[_i];
+        if (req.headers[key]) headers[key] = req.headers[key];
+      }
+      if (headers) return this.connection.headers = headers;
+    };
+
+    Session.prototype.unregister = function() {
+      this.recv.session = null;
+      this.recv = null;
+      if (this.to_tref) clearTimeout(this.to_tref);
+      return this.to_tref = setTimeout(this.timeout_cb, this.disconnect_delay);
+    };
+
+    Session.prototype.flushToRecv = function(recv) {
+      var sb, _ref;
+      if (this.send_buffer.length > 0) {
+        _ref = [this.send_buffer, []], sb = _ref[0], this.send_buffer = _ref[1];
+        recv.doSendBulk(sb);
+        return true;
+      }
+      return false;
+    };
+
+    Session.prototype.tryFlush = function() {
+      var x,
+        _this = this;
+      if (!this.flushToRecv(this.recv)) {
+        if (this.to_tref) clearTimeout(this.to_tref);
+        x = function() {
+          if (_this.recv) {
+            _this.to_tref = setTimeout(x, _this.heartbeat_delay);
+            return _this.recv.doSendFrame("h");
+          }
+        };
+        this.to_tref = setTimeout(x, this.heartbeat_delay);
+      }
+    };
+
+    Session.prototype.didTimeout = function() {
+      if (this.to_tref) {
+        clearTimeout(this.to_tref);
+        this.to_tref = null;
+      }
+      if (this.readyState !== Transport.CONNECTING && this.readyState !== Transport.OPEN && this.readyState !== Transport.CLOSING) {
+        throw Error('INVALID_STATE_ERR');
+      }
+      if (this.recv) throw Error('RECV_STILL_THERE');
+      this.readyState = Transport.CLOSED;
+      this.connection.emit('end');
+      this.connection.emit('close');
+      this.connection = null;
+      if (this.session_id) {
+        delete MAP[this.session_id];
+        return this.session_id = null;
+      }
+    };
+
+    Session.prototype.didMessage = function(payload) {
+      if (this.readyState === Transport.OPEN) {
+        this.connection.emit('data', payload);
+      }
+    };
+
+    Session.prototype.send = function(payload) {
+      if (this.readyState !== Transport.OPEN) return false;
+      this.send_buffer.push('' + payload);
+      if (this.recv) this.tryFlush();
+      return true;
+    };
+
+    Session.prototype.close = function(status, reason) {
+      if (status == null) status = 1000;
+      if (reason == null) reason = "Normal closure";
+      if (this.readyState !== Transport.OPEN) return false;
+      this.readyState = Transport.CLOSING;
+      this.close_frame = closeFrame(status, reason);
+      if (this.recv) {
+        this.recv.doSendFrame(this.close_frame);
+        if (this.recv) this.recv.didClose();
+        if (this.recv) this.unregister();
+      }
+      return true;
+    };
+
+    return Session;
+
+  })();
+
+  Session.bySessionId = function(session_id) {
+    return MAP[session_id] || null;
+  };
+
+  register = function(req, server, session_id, receiver) {
+    var session;
+    session = Session.bySessionId(session_id);
+    if (!session) session = new Session(session_id, server);
+    session.register(req, receiver);
+    return session;
+  };
+
+  exports.register = function(req, server, receiver) {
+    return register(req, server, req.session, receiver);
+  };
+
+  exports.registerNoSession = function(req, server, receiver) {
+    return register(req, server, void 0, receiver);
+  };
+
+  GenericReceiver = (function() {
+
+    function GenericReceiver(thingy) {
+      this.thingy = thingy;
+      this.setUp(this.thingy);
+    }
+
+    GenericReceiver.prototype.setUp = function() {
+      var _this = this;
+      this.thingy_end_cb = function() {
+        return _this.didAbort(1006, "Connection closed");
+      };
+      this.thingy.addListener('close', this.thingy_end_cb);
+      return this.thingy.addListener('end', this.thingy_end_cb);
+    };
+
+    GenericReceiver.prototype.tearDown = function() {
+      this.thingy.removeListener('close', this.thingy_end_cb);
+      this.thingy.removeListener('end', this.thingy_end_cb);
+      return this.thingy_end_cb = null;
+    };
+
+    GenericReceiver.prototype.didAbort = function(status, reason) {
+      var session;
+      session = this.session;
+      this.didClose(status, reason);
+      if (session) return session.didTimeout();
+    };
+
+    GenericReceiver.prototype.didClose = function(status, reason) {
+      if (this.thingy) {
+        this.tearDown(this.thingy);
+        this.thingy = null;
+      }
+      if (this.session) return this.session.unregister(status, reason);
+    };
+
+    GenericReceiver.prototype.doSendBulk = function(messages) {
+      var m, q_msgs;
+      q_msgs = (function() {
+        var _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = messages.length; _i < _len; _i++) {
+          m = messages[_i];
+          _results.push(utils.quote(m));
+        }
+        return _results;
+      })();
+      return this.doSendFrame('a' + '[' + q_msgs.join(',') + ']');
+    };
+
+    return GenericReceiver;
+
+  })();
+
+  ResponseReceiver = (function(_super) {
+
+    __extends(ResponseReceiver, _super);
+
+    ResponseReceiver.prototype.max_response_size = void 0;
+
+    function ResponseReceiver(request, response, options) {
+      this.request = request;
+      this.response = response;
+      this.options = options;
+      this.curr_response_size = 0;
+      try {
+        this.request.connection.setKeepAlive(true, 5000);
+      } catch (x) {
+
+      }
+      ResponseReceiver.__super__.constructor.call(this, this.request.connection);
+      if (this.max_response_size === void 0) {
+        this.max_response_size = this.options.response_limit;
+      }
+    }
+
+    ResponseReceiver.prototype.doSendFrame = function(payload) {
+      var r;
+      this.curr_response_size += payload.length;
+      r = false;
+      try {
+        this.response.write(payload);
+        r = true;
+      } catch (x) {
+
+      }
+      if (this.max_response_size && this.curr_response_size >= this.max_response_size) {
+        this.didClose();
+      }
+      return r;
+    };
+
+    ResponseReceiver.prototype.didClose = function() {
+      ResponseReceiver.__super__.didClose.apply(this, arguments);
+      try {
+        this.response.end();
+      } catch (x) {
+
+      }
+      return this.response = null;
+    };
+
+    return ResponseReceiver;
+
+  })(GenericReceiver);
+
+  exports.GenericReceiver = GenericReceiver;
+
+  exports.Transport = Transport;
+
+  exports.Session = Session;
+
+  exports.ResponseReceiver = ResponseReceiver;
+
+  exports.SockJSConnection = SockJSConnection;
+
+}).call(this);

node_modules/sockjs/lib/utils.js

@@ -0,0 +1,154 @@
+(function() {
+  var array_intersection, crypto, escapable, lookup, rbytes, unroll_lookup;
+
+  crypto = require('crypto');
+
+  try {
+    rbytes = require('rbytes');
+  } catch (x) {
+
+  }
+
+  exports.array_intersection = array_intersection = function(arr_a, arr_b) {
+    var a, r, _i, _len;
+    r = [];
+    for (_i = 0, _len = arr_a.length; _i < _len; _i++) {
+      a = arr_a[_i];
+      if (arr_b.indexOf(a) !== -1) r.push(a);
+    }
+    return r;
+  };
+
+  exports.escape_selected = function(str, chars) {
+    var c, i, map, parts, r, v, _i, _len, _ref;
+    map = {};
+    chars = '%' + chars;
+    for (_i = 0, _len = chars.length; _i < _len; _i++) {
+      c = chars[_i];
+      map[c] = escape(c);
+    }
+    r = new RegExp('([' + chars + '])');
+    parts = str.split(r);
+    for (i = 0, _ref = parts.length; 0 <= _ref ? i < _ref : i > _ref; 0 <= _ref ? i++ : i--) {
+      v = parts[i];
+      if (v.length === 1 && v in map) parts[i] = map[v];
+    }
+    return parts.join('');
+  };
+
+  exports.buffer_concat = function(buf_a, buf_b) {
+    var dst;
+    dst = new Buffer(buf_a.length + buf_b.length);
+    buf_a.copy(dst);
+    buf_b.copy(dst, buf_a.length);
+    return dst;
+  };
+
+  exports.md5_hex = function(data) {
+    return crypto.createHash('md5').update(data).digest('hex');
+  };
+
+  exports.sha1_base64 = function(data) {
+    return crypto.createHash('sha1').update(data).digest('base64');
+  };
+
+  exports.timeout_chain = function(arr) {
+    var fun, timeout, user_fun, _ref,
+      _this = this;
+    arr = arr.slice(0);
+    if (!arr.length) return;
+    _ref = arr.shift(), timeout = _ref[0], user_fun = _ref[1];
+    fun = function() {
+      user_fun();
+      return exports.timeout_chain(arr);
+    };
+    return setTimeout(fun, timeout);
+  };
+
+  exports.objectExtend = function(dst, src) {
+    var k;
+    for (k in src) {
+      if (src.hasOwnProperty(k)) dst[k] = src[k];
+    }
+    return dst;
+  };
+
+  exports.overshadowListeners = function(ee, event, handler) {
+    var new_handler, old_listeners;
+    old_listeners = ee.listeners(event).slice(0);
+    ee.removeAllListeners(event);
+    new_handler = function() {
+      var listener, _i, _len;
+      if (handler.apply(this, arguments) !== true) {
+        for (_i = 0, _len = old_listeners.length; _i < _len; _i++) {
+          listener = old_listeners[_i];
+          listener.apply(this, arguments);
+        }
+        return false;
+      }
+      return true;
+    };
+    return ee.addListener(event, new_handler);
+  };
+
+  escapable = /[\x00-\x1f\ud800-\udfff\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufff0-\uffff]/g;
+
+  unroll_lookup = function(escapable) {
+    var c, i, unrolled;
+    unrolled = {};
+    c = (function() {
+      var _results;
+      _results = [];
+      for (i = 0; i < 65536; i++) {
+        _results.push(String.fromCharCode(i));
+      }
+      return _results;
+    })();
+    escapable.lastIndex = 0;
+    c.join('').replace(escapable, function(a) {
+      return unrolled[a] = '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+    });
+    return unrolled;
+  };
+
+  lookup = unroll_lookup(escapable);
+
+  exports.quote = function(string) {
+    var quoted;
+    quoted = JSON.stringify(string);
+    escapable.lastIndex = 0;
+    if (!escapable.test(quoted)) return quoted;
+    return quoted.replace(escapable, function(a) {
+      return lookup[a];
+    });
+  };
+
+  exports.parseCookie = function(cookie_header) {
+    var cookie, cookies, parts, _i, _len, _ref;
+    cookies = {};
+    if (cookie_header) {
+      _ref = cookie_header.split(';');
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        cookie = _ref[_i];
+        parts = cookie.split('=');
+        cookies[parts[0].trim()] = (parts[1] || '').trim();
+      }
+    }
+    return cookies;
+  };
+
+  exports.random32 = function() {
+    var foo, v;
+    if (rbytes) {
+      foo = rbytes.randomBytes(4);
+      v = [foo[0], foo[1], foo[2], foo[3]];
+    } else {
+      foo = function() {
+        return Math.floor(Math.random() * 256);
+      };
+      v = [foo(), foo(), foo(), foo()];
+    }
+    return v[0] + (v[1] * 256) + (v[2] * 256 * 256) + (v[3] * 256 * 256 * 256);
+  };
+
+}).call(this);

node_modules/sockjs/lib/webjs.js

@@ -0,0 +1,283 @@
+(function() {
+  var GenericApp, execute_request, fake_response, fs, http, querystring, url, utils;
+
+  url = require('url');
+
+  querystring = require('querystring');
+
+  fs = require('fs');
+
+  http = require('http');
+
+  utils = require('./utils');
+
+  execute_request = function(app, funs, req, res, data) {
+    var fun, _results;
+    try {
+      _results = [];
+      while (funs.length > 0) {
+        fun = funs.shift();
+        req.last_fun = fun;
+        _results.push(data = app[fun](req, res, data, req.next_filter));
+      }
+      return _results;
+    } catch (x) {
+      if (typeof x === 'object' && 'status' in x) {
+        if (x.status === 0) {
+          return;
+        } else if ('handle_' + x.status in app) {
+          app['handle_' + x.status](req, res, x);
+        } else {
+          app['handle_error'](req, res, x);
+        }
+      } else {
+        app['handle_error'](req, res, x);
+      }
+      return app['log_request'](req, res, true);
+    }
+  };
+
+  fake_response = function(req, res) {
+    var headers;
+    headers = {
+      'Connection': 'close'
+    };
+    res.writeHead = function(status, user_headers) {
+      var k, r;
+      if (user_headers == null) user_headers = {};
+      r = [];
+      r.push('HTTP/' + req.httpVersion + ' ' + status + ' ' + http.STATUS_CODES[status]);
+      utils.objectExtend(headers, user_headers);
+      for (k in headers) {
+        r.push(k + ': ' + headers[k]);
+      }
+      r = r.concat(['', '']);
+      try {
+        res.write(r.join('\r\n'));
+      } catch (x) {
+
+      }
+      try {
+        return res.end();
+      } catch (x) {
+
+      }
+    };
+    return res.setHeader = function(k, v) {
+      return headers[k] = v;
+    };
+  };
+
+  exports.generateHandler = function(app, dispatcher) {
+    return function(req, res, head) {
+      var allowed_methods, found, funs, i, m, method, path, row, _i, _len, _ref;
+      if (typeof res.writeHead === "undefined") fake_response(req, res);
+      utils.objectExtend(req, url.parse(req.url, true));
+      req.start_date = new Date();
+      found = false;
+      allowed_methods = [];
+      for (_i = 0, _len = dispatcher.length; _i < _len; _i++) {
+        row = dispatcher[_i];
+        method = row[0], path = row[1], funs = row[2];
+        if (path.constructor !== Array) path = [path];
+        m = req.pathname.match(path[0]);
+        if (!m) continue;
+        if (!req.method.match(new RegExp(method))) {
+          allowed_methods.push(method);
+          continue;
+        }
+        for (i = 1, _ref = path.length; 1 <= _ref ? i < _ref : i > _ref; 1 <= _ref ? i++ : i--) {
+          req[path[i]] = m[i];
+        }
+        funs = funs.slice(0);
+        funs.push('log_request');
+        req.next_filter = function(data) {
+          return execute_request(app, funs, req, res, data);
+        };
+        req.next_filter(head);
+        found = true;
+        break;
+      }
+      if (!found) {
+        if (allowed_methods.length !== 0) {
+          app['handle_405'](req, res, allowed_methods);
+        } else {
+          app['handle_404'](req, res);
+        }
+        app['log_request'](req, res, true);
+      }
+    };
+  };
+
+  exports.GenericApp = GenericApp = (function() {
+
+    function GenericApp() {}
+
+    GenericApp.prototype.handle_404 = function(req, res, x) {
+      if (res.finished) return x;
+      res.writeHead(404, {});
+      res.end();
+      return true;
+    };
+
+    GenericApp.prototype.handle_405 = function(req, res, methods) {
+      res.writeHead(405, {
+        'Allow': methods.join(', ')
+      });
+      res.end();
+      return true;
+    };
+
+    GenericApp.prototype.handle_error = function(req, res, x) {
+      if (res.finished) return x;
+      if (typeof x === 'object' && 'status' in x) {
+        res.writeHead(x.status, {});
+        res.end(x.message || "");
+      } else {
+        try {
+          res.writeHead(500, {});
+          res.end("500 - Internal Server Error");
+        } catch (x) {
+
+        }
+        this.log('error', 'Exception on "' + req.method + ' ' + req.href + '" in filter "' + req.last_fun + '":\n' + (x.stack || x));
+      }
+      return true;
+    };
+
+    GenericApp.prototype.log_request = function(req, res, data) {
+      var td;
+      td = (new Date()) - req.start_date;
+      this.log('info', req.method + ' ' + req.url + ' ' + td + 'ms ' + (res.finished ? res._header.split('\r')[0].split(' ')[1] : '(unfinished)'));
+      return data;
+    };
+
+    GenericApp.prototype.log = function(severity, line) {
+      return console.log(line);
+    };
+
+    GenericApp.prototype.expose_html = function(req, res, content) {
+      if (res.finished) return content;
+      if (!res.getHeader('Content-Type')) {
+        res.setHeader('Content-Type', 'text/html; charset=UTF-8');
+      }
+      return this.expose(req, res, content);
+    };
+
+    GenericApp.prototype.expose_json = function(req, res, content) {
+      if (res.finished) return content;
+      if (!res.getHeader('Content-Type')) {
+        res.setHeader('Content-Type', 'application/json');
+      }
+      return this.expose(req, res, JSON.stringify(content));
+    };
+
+    GenericApp.prototype.expose = function(req, res, content) {
+      if (res.finished) return content;
+      if (content && !res.getHeader('Content-Type')) {
+        res.setHeader('Content-Type', 'text/plain');
+      }
+      if (content) res.setHeader('Content-Length', content.length);
+      res.writeHead(res.statusCode);
+      res.end(content, 'utf8');
+      return true;
+    };
+
+    GenericApp.prototype.serve_file = function(req, res, filename, next_filter) {
+      var a;
+      a = function(error, content) {
+        if (error) {
+          res.writeHead(500);
+          res.end("can't read file");
+        } else {
+          res.setHeader('Content-length', content.length);
+          res.writeHead(res.statusCode, res.headers);
+          res.end(content, 'utf8');
+        }
+        return next_filter(true);
+      };
+      fs.readFile(filename, a);
+      throw {
+        status: 0
+      };
+    };
+
+    GenericApp.prototype.cache_for = function(req, res, content) {
+      var exp;
+      res.cache_for = res.cache_for || 365 * 24 * 60 * 60;
+      res.setHeader('Cache-Control', 'public, max-age=' + res.cache_for);
+      exp = new Date();
+      exp.setTime(exp.getTime() + res.cache_for * 1000);
+      res.setHeader('Expires', exp.toGMTString());
+      return content;
+    };
+
+    GenericApp.prototype.h_no_cache = function(req, res, content) {
+      res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0');
+      return content;
+    };
+
+    GenericApp.prototype.expect_form = function(req, res, _data, next_filter) {
+      var data,
+        _this = this;
+      data = new Buffer(0);
+      req.on('data', function(d) {
+        return data = utils.buffer_concat(data, new Buffer(d, 'binary'));
+      });
+      req.on('end', function() {
+        var q;
+        data = data.toString('utf-8');
+        switch ((req.headers['content-type'] || '').split(';')[0]) {
+          case 'application/x-www-form-urlencoded':
+            q = querystring.parse(data);
+            break;
+          case 'text/plain':
+          case '':
+            q = data;
+            break;
+          default:
+            _this.log('error', "Unsupported content-type " + req.headers['content-type']);
+            q = void 0;
+        }
+        return next_filter(q);
+      });
+      throw {
+        status: 0
+      };
+    };
+
+    GenericApp.prototype.expect_xhr = function(req, res, _data, next_filter) {
+      var data,
+        _this = this;
+      data = new Buffer(0);
+      req.on('data', function(d) {
+        return data = utils.buffer_concat(data, new Buffer(d, 'binary'));
+      });
+      req.on('end', function() {
+        var q;
+        data = data.toString('utf-8');
+        switch ((req.headers['content-type'] || '').split(';')[0]) {
+          case 'text/plain':
+          case 'T':
+          case 'application/json':
+          case 'application/xml':
+          case '':
+          case 'text/xml':
+            q = data;
+            break;
+          default:
+            _this.log('error', 'Unsupported content-type ' + req.headers['content-type']);
+            q = void 0;
+        }
+        return next_filter(q);
+      });
+      throw {
+        status: 0
+      };
+    };
+
+    return GenericApp;
+
+  })();
+
+}).call(this);

node_modules/sockjs/package.json

@@ -0,0 +1,100 @@
+{
+  "_args": [
+    [
+      {
+        "name": "sockjs",
+        "raw": "sockjs@0.3.7",
+        "rawSpec": "0.3.7",
+        "scope": null,
+        "spec": "0.3.7",
+        "type": "version"
+      },
+      "/root/gitbook/node_modules/shoe"
+    ]
+  ],
+  "_from": "sockjs@0.3.7",
+  "_id": "sockjs@0.3.7",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/sockjs",
+  "_npmUser": {
+    "email": "glasser@meteor.com",
+    "name": "glasser"
+  },
+  "_npmVersion": "1.2.2",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "sockjs",
+    "raw": "sockjs@0.3.7",
+    "rawSpec": "0.3.7",
+    "scope": null,
+    "spec": "0.3.7",
+    "type": "version"
+  },
+  "_requiredBy": [
+    "/shoe"
+  ],
+  "_resolved": "https://registry.npmjs.org/sockjs/-/sockjs-0.3.7.tgz",
+  "_shasum": "2950e0586d8a9d3044958a831ade68db197749cb",
+  "_shrinkwrap": null,
+  "_spec": "sockjs@0.3.7",
+  "_where": "/root/gitbook/node_modules/shoe",
+  "author": {
+    "name": "Marek Majkowski"
+  },
+  "bugs": {
+    "url": "https://github.com/sockjs/sockjs-node/issues"
+  },
+  "dependencies": {
+    "faye-websocket": "0.4.4",
+    "node-uuid": "1.3.3"
+  },
+  "description": "SockJS-node is a server counterpart of SockJS-client a JavaScript library that provides a WebSocket-like object in the browser. SockJS gives you a coherent, cross-browser, Javascript API which creates a low latency, full duplex, cross-domain communication",
+  "devDependencies": {
+    "coffee-script": "1.2.x"
+  },
+  "directories": {},
+  "dist": {
+    "integrity": "sha512-Hhb9Z0yY5QWc4rSXcGgByUhijT/adjyL6SpoLeZgXbpa8rd2s9Dbr1voP/8eeLDYET4AHTffPxz4kgJQH8WwrA==",
+    "shasum": "2950e0586d8a9d3044958a831ade68db197749cb",
+    "signatures": [
+      {
+        "keyid": "SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA",
+        "sig": "MEYCIQCf7ZzWA3Et9yena56Z9QvUGnLsYqTUbEA+jW+Qhql+qAIhAM3eMVNOkp5uk4YcPB58uUQy0BxNPC9x2tVYNkWDMVHl"
+      }
+    ],
+    "tarball": "https://registry.npmjs.org/sockjs/-/sockjs-0.3.7.tgz"
+  },
+  "homepage": "https://github.com/sockjs/sockjs-node",
+  "keywords": [
+    "websockets",
+    "websocket"
+  ],
+  "main": "index",
+  "maintainers": [
+    {
+      "email": "majek04@gmail.com",
+      "name": "majek"
+    },
+    {
+      "email": "matthew@rabbitmq.com",
+      "name": "msackman"
+    },
+    {
+      "email": "mikeb@squaremobius.net",
+      "name": "squaremo"
+    },
+    {
+      "email": "glasser@meteor.com",
+      "name": "glasser"
+    }
+  ],
+  "name": "sockjs",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sockjs/sockjs-node.git"
+  },
+  "version": "0.3.7"
+}