PageRenderTime 78ms CodeModel.GetById 17ms RepoModel.GetById 1ms app.codeStats 0ms

/samples/web/js/socket.io-0.9.10.js

https://github.com/ADAIN/mod-socket-io
JavaScript | 3887 lines | 2935 code | 334 blank | 618 comment | 228 complexity | e3a0e79ed9f916f6c67bdfcda83edc5c MD5 | raw file
Possible License(s): Apache-2.0
  1. /*! Socket.IO.js build:0.9.10, development. Copyright(c) 2011 LearnBoost <dev@learnboost.com> MIT Licensed */
  2. var io = ('undefined' === typeof module ? {} : module.exports);
  3. (function() {
  4. /**
  5. * socket.io
  6. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  7. * MIT Licensed
  8. */
  9. (function (exports, global) {
  10. /**
  11. * IO namespace.
  12. *
  13. * @namespace
  14. */
  15. var io = exports;
  16. /**
  17. * Socket.IO version
  18. *
  19. * @api public
  20. */
  21. io.version = '0.9.10';
  22. /**
  23. * Protocol implemented.
  24. *
  25. * @api public
  26. */
  27. io.protocol = 1;
  28. /**
  29. * Available transports, these will be populated with the available transports
  30. *
  31. * @api public
  32. */
  33. io.transports = [];
  34. /**
  35. * Keep track of jsonp callbacks.
  36. *
  37. * @api private
  38. */
  39. io.j = [];
  40. /**
  41. * Keep track of our io.Sockets
  42. *
  43. * @api private
  44. */
  45. io.sockets = {};
  46. /**
  47. * Manages connections to hosts.
  48. *
  49. * @param {String} uri
  50. * @Param {Boolean} force creation of new socket (defaults to false)
  51. * @api public
  52. */
  53. io.connect = function (host, details) {
  54. var uri = io.util.parseUri(host)
  55. , uuri
  56. , socket;
  57. if (global && global.location) {
  58. uri.protocol = uri.protocol || global.location.protocol.slice(0, -1);
  59. uri.host = uri.host || (global.document
  60. ? global.document.domain : global.location.hostname);
  61. uri.port = uri.port || global.location.port;
  62. }
  63. uuri = io.util.uniqueUri(uri);
  64. var options = {
  65. host: uri.host
  66. , secure: 'https' == uri.protocol
  67. , port: uri.port || ('https' == uri.protocol ? 443 : 80)
  68. , query: uri.query || ''
  69. };
  70. io.util.merge(options, details);
  71. if (options['force new connection'] || !io.sockets[uuri]) {
  72. socket = new io.Socket(options);
  73. }
  74. if (!options['force new connection'] && socket) {
  75. io.sockets[uuri] = socket;
  76. }
  77. socket = socket || io.sockets[uuri];
  78. // if path is different from '' or /
  79. return socket.of(uri.path.length > 1 ? uri.path : '');
  80. };
  81. })('object' === typeof module ? module.exports : (this.io = {}), this);
  82. /**
  83. * socket.io
  84. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  85. * MIT Licensed
  86. */
  87. (function (exports, global) {
  88. /**
  89. * Utilities namespace.
  90. *
  91. * @namespace
  92. */
  93. var util = exports.util = {};
  94. /**
  95. * Parses an URI
  96. *
  97. * @author Steven Levithan <stevenlevithan.com> (MIT license)
  98. * @api public
  99. */
  100. var re = /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
  101. var parts = ['source', 'protocol', 'authority', 'userInfo', 'user', 'password',
  102. 'host', 'port', 'relative', 'path', 'directory', 'file', 'query',
  103. 'anchor'];
  104. util.parseUri = function (str) {
  105. var m = re.exec(str || '')
  106. , uri = {}
  107. , i = 14;
  108. while (i--) {
  109. uri[parts[i]] = m[i] || '';
  110. }
  111. return uri;
  112. };
  113. /**
  114. * Produces a unique url that identifies a Socket.IO connection.
  115. *
  116. * @param {Object} uri
  117. * @api public
  118. */
  119. util.uniqueUri = function (uri) {
  120. var protocol = uri.protocol
  121. , host = uri.host
  122. , port = uri.port;
  123. if ('document' in global) {
  124. host = host || document.domain;
  125. port = port || (protocol == 'https'
  126. && document.location.protocol !== 'https:' ? 443 : document.location.port);
  127. } else {
  128. host = host || 'localhost';
  129. if (!port && protocol == 'https') {
  130. port = 443;
  131. }
  132. }
  133. return (protocol || 'http') + '://' + host + ':' + (port || 80);
  134. };
  135. /**
  136. * Mergest 2 query strings in to once unique query string
  137. *
  138. * @param {String} base
  139. * @param {String} addition
  140. * @api public
  141. */
  142. util.query = function (base, addition) {
  143. var query = util.chunkQuery(base || '')
  144. , components = [];
  145. util.merge(query, util.chunkQuery(addition || ''));
  146. for (var part in query) {
  147. if (query.hasOwnProperty(part)) {
  148. components.push(part + '=' + query[part]);
  149. }
  150. }
  151. return components.length ? '?' + components.join('&') : '';
  152. };
  153. /**
  154. * Transforms a querystring in to an object
  155. *
  156. * @param {String} qs
  157. * @api public
  158. */
  159. util.chunkQuery = function (qs) {
  160. var query = {}
  161. , params = qs.split('&')
  162. , i = 0
  163. , l = params.length
  164. , kv;
  165. for (; i < l; ++i) {
  166. kv = params[i].split('=');
  167. if (kv[0]) {
  168. query[kv[0]] = kv[1];
  169. }
  170. }
  171. return query;
  172. };
  173. /**
  174. * Executes the given function when the page is loaded.
  175. *
  176. * io.util.load(function () { console.log('page loaded'); });
  177. *
  178. * @param {Function} fn
  179. * @api public
  180. */
  181. var pageLoaded = false;
  182. util.load = function (fn) {
  183. if ('document' in global && document.readyState === 'complete' || pageLoaded) {
  184. return fn();
  185. }
  186. util.on(global, 'load', fn, false);
  187. };
  188. /**
  189. * Adds an event.
  190. *
  191. * @api private
  192. */
  193. util.on = function (element, event, fn, capture) {
  194. if (element.attachEvent) {
  195. element.attachEvent('on' + event, fn);
  196. } else if (element.addEventListener) {
  197. element.addEventListener(event, fn, capture);
  198. }
  199. };
  200. /**
  201. * Generates the correct `XMLHttpRequest` for regular and cross domain requests.
  202. *
  203. * @param {Boolean} [xdomain] Create a request that can be used cross domain.
  204. * @returns {XMLHttpRequest|false} If we can create a XMLHttpRequest.
  205. * @api private
  206. */
  207. util.request = function (xdomain) {
  208. if (xdomain && 'undefined' != typeof XDomainRequest) {
  209. return new XDomainRequest();
  210. }
  211. if ('undefined' != typeof XMLHttpRequest && (!xdomain || util.ua.hasCORS)) {
  212. return new XMLHttpRequest();
  213. }
  214. if (!xdomain) {
  215. try {
  216. return new window[(['Active'].concat('Object').join('X'))]('Microsoft.XMLHTTP');
  217. } catch(e) { }
  218. }
  219. return null;
  220. };
  221. /**
  222. * XHR based transport constructor.
  223. *
  224. * @constructor
  225. * @api public
  226. */
  227. /**
  228. * Change the internal pageLoaded value.
  229. */
  230. if ('undefined' != typeof window) {
  231. util.load(function () {
  232. pageLoaded = true;
  233. });
  234. }
  235. /**
  236. * Defers a function to ensure a spinner is not displayed by the browser
  237. *
  238. * @param {Function} fn
  239. * @api public
  240. */
  241. util.defer = function (fn) {
  242. if (!util.ua.webkit || 'undefined' != typeof importScripts) {
  243. return fn();
  244. }
  245. util.load(function () {
  246. setTimeout(fn, 100);
  247. });
  248. };
  249. /**
  250. * Merges two objects.
  251. *
  252. * @api public
  253. */
  254. util.merge = function merge (target, additional, deep, lastseen) {
  255. var seen = lastseen || []
  256. , depth = typeof deep == 'undefined' ? 2 : deep
  257. , prop;
  258. for (prop in additional) {
  259. if (additional.hasOwnProperty(prop) && util.indexOf(seen, prop) < 0) {
  260. if (typeof target[prop] !== 'object' || !depth) {
  261. target[prop] = additional[prop];
  262. seen.push(additional[prop]);
  263. } else {
  264. util.merge(target[prop], additional[prop], depth - 1, seen);
  265. }
  266. }
  267. }
  268. return target;
  269. };
  270. /**
  271. * Merges prototypes from objects
  272. *
  273. * @api public
  274. */
  275. util.mixin = function (ctor, ctor2) {
  276. util.merge(ctor.prototype, ctor2.prototype);
  277. };
  278. /**
  279. * Shortcut for prototypical and static inheritance.
  280. *
  281. * @api private
  282. */
  283. util.inherit = function (ctor, ctor2) {
  284. function f() {};
  285. f.prototype = ctor2.prototype;
  286. ctor.prototype = new f;
  287. };
  288. /**
  289. * Checks if the given object is an Array.
  290. *
  291. * io.util.isArray([]); // true
  292. * io.util.isArray({}); // false
  293. *
  294. * @param Object obj
  295. * @api public
  296. */
  297. util.isArray = Array.isArray || function (obj) {
  298. return Object.prototype.toString.call(obj) === '[object Array]';
  299. };
  300. /**
  301. * Intersects values of two arrays into a third
  302. *
  303. * @api public
  304. */
  305. util.intersect = function (arr, arr2) {
  306. var ret = []
  307. , longest = arr.length > arr2.length ? arr : arr2
  308. , shortest = arr.length > arr2.length ? arr2 : arr;
  309. for (var i = 0, l = shortest.length; i < l; i++) {
  310. if (~util.indexOf(longest, shortest[i]))
  311. ret.push(shortest[i]);
  312. }
  313. return ret;
  314. }
  315. /**
  316. * Array indexOf compatibility.
  317. *
  318. * @see bit.ly/a5Dxa2
  319. * @api public
  320. */
  321. util.indexOf = function (arr, o, i) {
  322. for (var j = arr.length, i = i < 0 ? i + j < 0 ? 0 : i + j : i || 0;
  323. i < j && arr[i] !== o; i++) {}
  324. return j <= i ? -1 : i;
  325. };
  326. /**
  327. * Converts enumerables to array.
  328. *
  329. * @api public
  330. */
  331. util.toArray = function (enu) {
  332. var arr = [];
  333. for (var i = 0, l = enu.length; i < l; i++)
  334. arr.push(enu[i]);
  335. return arr;
  336. };
  337. /**
  338. * UA / engines detection namespace.
  339. *
  340. * @namespace
  341. */
  342. util.ua = {};
  343. /**
  344. * Whether the UA supports CORS for XHR.
  345. *
  346. * @api public
  347. */
  348. util.ua.hasCORS = 'undefined' != typeof XMLHttpRequest && (function () {
  349. try {
  350. var a = new XMLHttpRequest();
  351. } catch (e) {
  352. return false;
  353. }
  354. return a.withCredentials != undefined;
  355. })();
  356. /**
  357. * Detect webkit.
  358. *
  359. * @api public
  360. */
  361. util.ua.webkit = 'undefined' != typeof navigator
  362. && /webkit/i.test(navigator.userAgent);
  363. /**
  364. * Detect iPad/iPhone/iPod.
  365. *
  366. * @api public
  367. */
  368. util.ua.iDevice = 'undefined' != typeof navigator
  369. && /iPad|iPhone|iPod/i.test(navigator.userAgent);
  370. })('undefined' != typeof io ? io : module.exports, this);
  371. /**
  372. * socket.io
  373. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  374. * MIT Licensed
  375. */
  376. (function (exports, io) {
  377. /**
  378. * Expose constructor.
  379. */
  380. exports.EventEmitter = EventEmitter;
  381. /**
  382. * Event emitter constructor.
  383. *
  384. * @api public.
  385. */
  386. function EventEmitter () {};
  387. /**
  388. * Adds a listener
  389. *
  390. * @api public
  391. */
  392. EventEmitter.prototype.on = function (name, fn) {
  393. if (!this.$events) {
  394. this.$events = {};
  395. }
  396. if (!this.$events[name]) {
  397. this.$events[name] = fn;
  398. } else if (io.util.isArray(this.$events[name])) {
  399. this.$events[name].push(fn);
  400. } else {
  401. this.$events[name] = [this.$events[name], fn];
  402. }
  403. return this;
  404. };
  405. EventEmitter.prototype.addListener = EventEmitter.prototype.on;
  406. /**
  407. * Adds a volatile listener.
  408. *
  409. * @api public
  410. */
  411. EventEmitter.prototype.once = function (name, fn) {
  412. var self = this;
  413. function on () {
  414. self.removeListener(name, on);
  415. fn.apply(this, arguments);
  416. };
  417. on.listener = fn;
  418. this.on(name, on);
  419. return this;
  420. };
  421. /**
  422. * Removes a listener.
  423. *
  424. * @api public
  425. */
  426. EventEmitter.prototype.removeListener = function (name, fn) {
  427. if (this.$events && this.$events[name]) {
  428. var list = this.$events[name];
  429. if (io.util.isArray(list)) {
  430. var pos = -1;
  431. for (var i = 0, l = list.length; i < l; i++) {
  432. if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {
  433. pos = i;
  434. break;
  435. }
  436. }
  437. if (pos < 0) {
  438. return this;
  439. }
  440. list.splice(pos, 1);
  441. if (!list.length) {
  442. delete this.$events[name];
  443. }
  444. } else if (list === fn || (list.listener && list.listener === fn)) {
  445. delete this.$events[name];
  446. }
  447. }
  448. return this;
  449. };
  450. /**
  451. * Removes all listeners for an event.
  452. *
  453. * @api public
  454. */
  455. EventEmitter.prototype.removeAllListeners = function (name) {
  456. if (name === undefined) {
  457. this.$events = {};
  458. return this;
  459. }
  460. if (this.$events && this.$events[name]) {
  461. this.$events[name] = null;
  462. }
  463. return this;
  464. };
  465. /**
  466. * Gets all listeners for a certain event.
  467. *
  468. * @api publci
  469. */
  470. EventEmitter.prototype.listeners = function (name) {
  471. if (!this.$events) {
  472. this.$events = {};
  473. }
  474. if (!this.$events[name]) {
  475. this.$events[name] = [];
  476. }
  477. if (!io.util.isArray(this.$events[name])) {
  478. this.$events[name] = [this.$events[name]];
  479. }
  480. return this.$events[name];
  481. };
  482. /**
  483. * Emits an event.
  484. *
  485. * @api public
  486. */
  487. EventEmitter.prototype.emit = function (name) {
  488. if (!this.$events) {
  489. return false;
  490. }
  491. var handler = this.$events[name];
  492. if (!handler) {
  493. return false;
  494. }
  495. var args = Array.prototype.slice.call(arguments, 1);
  496. if ('function' == typeof handler) {
  497. handler.apply(this, args);
  498. } else if (io.util.isArray(handler)) {
  499. var listeners = handler.slice();
  500. for (var i = 0, l = listeners.length; i < l; i++) {
  501. listeners[i].apply(this, args);
  502. }
  503. } else {
  504. return false;
  505. }
  506. return true;
  507. };
  508. })(
  509. 'undefined' != typeof io ? io : module.exports
  510. , 'undefined' != typeof io ? io : module.parent.exports
  511. );
  512. /**
  513. * socket.io
  514. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  515. * MIT Licensed
  516. */
  517. /**
  518. * Based on JSON2 (http://www.JSON.org/js.html).
  519. */
  520. (function (exports, nativeJSON) {
  521. "use strict";
  522. // use native JSON if it's available
  523. if (nativeJSON && nativeJSON.parse){
  524. return exports.JSON = {
  525. parse: nativeJSON.parse
  526. , stringify: nativeJSON.stringify
  527. }
  528. }
  529. var JSON = exports.JSON = {};
  530. function f(n) {
  531. // Format integers to have at least two digits.
  532. return n < 10 ? '0' + n : n;
  533. }
  534. function date(d, key) {
  535. return isFinite(d.valueOf()) ?
  536. d.getUTCFullYear() + '-' +
  537. f(d.getUTCMonth() + 1) + '-' +
  538. f(d.getUTCDate()) + 'T' +
  539. f(d.getUTCHours()) + ':' +
  540. f(d.getUTCMinutes()) + ':' +
  541. f(d.getUTCSeconds()) + 'Z' : null;
  542. };
  543. var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
  544. escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
  545. gap,
  546. indent,
  547. meta = { // table of character substitutions
  548. '\b': '\\b',
  549. '\t': '\\t',
  550. '\n': '\\n',
  551. '\f': '\\f',
  552. '\r': '\\r',
  553. '"' : '\\"',
  554. '\\': '\\\\'
  555. },
  556. rep;
  557. function quote(string) {
  558. // If the string contains no control characters, no quote characters, and no
  559. // backslash characters, then we can safely slap some quotes around it.
  560. // Otherwise we must also replace the offending characters with safe escape
  561. // sequences.
  562. escapable.lastIndex = 0;
  563. return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
  564. var c = meta[a];
  565. return typeof c === 'string' ? c :
  566. '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
  567. }) + '"' : '"' + string + '"';
  568. }
  569. function str(key, holder) {
  570. // Produce a string from holder[key].
  571. var i, // The loop counter.
  572. k, // The member key.
  573. v, // The member value.
  574. length,
  575. mind = gap,
  576. partial,
  577. value = holder[key];
  578. // If the value has a toJSON method, call it to obtain a replacement value.
  579. if (value instanceof Date) {
  580. value = date(key);
  581. }
  582. // If we were called with a replacer function, then call the replacer to
  583. // obtain a replacement value.
  584. if (typeof rep === 'function') {
  585. value = rep.call(holder, key, value);
  586. }
  587. // What happens next depends on the value's type.
  588. switch (typeof value) {
  589. case 'string':
  590. return quote(value);
  591. case 'number':
  592. // JSON numbers must be finite. Encode non-finite numbers as null.
  593. return isFinite(value) ? String(value) : 'null';
  594. case 'boolean':
  595. case 'null':
  596. // If the value is a boolean or null, convert it to a string. Note:
  597. // typeof null does not produce 'null'. The case is included here in
  598. // the remote chance that this gets fixed someday.
  599. return String(value);
  600. // If the type is 'object', we might be dealing with an object or an array or
  601. // null.
  602. case 'object':
  603. // Due to a specification blunder in ECMAScript, typeof null is 'object',
  604. // so watch out for that case.
  605. if (!value) {
  606. return 'null';
  607. }
  608. // Make an array to hold the partial results of stringifying this object value.
  609. gap += indent;
  610. partial = [];
  611. // Is the value an array?
  612. if (Object.prototype.toString.apply(value) === '[object Array]') {
  613. // The value is an array. Stringify every element. Use null as a placeholder
  614. // for non-JSON values.
  615. length = value.length;
  616. for (i = 0; i < length; i += 1) {
  617. partial[i] = str(i, value) || 'null';
  618. }
  619. // Join all of the elements together, separated with commas, and wrap them in
  620. // brackets.
  621. v = partial.length === 0 ? '[]' : gap ?
  622. '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
  623. '[' + partial.join(',') + ']';
  624. gap = mind;
  625. return v;
  626. }
  627. // If the replacer is an array, use it to select the members to be stringified.
  628. if (rep && typeof rep === 'object') {
  629. length = rep.length;
  630. for (i = 0; i < length; i += 1) {
  631. if (typeof rep[i] === 'string') {
  632. k = rep[i];
  633. v = str(k, value);
  634. if (v) {
  635. partial.push(quote(k) + (gap ? ': ' : ':') + v);
  636. }
  637. }
  638. }
  639. } else {
  640. // Otherwise, iterate through all of the keys in the object.
  641. for (k in value) {
  642. if (Object.prototype.hasOwnProperty.call(value, k)) {
  643. v = str(k, value);
  644. if (v) {
  645. partial.push(quote(k) + (gap ? ': ' : ':') + v);
  646. }
  647. }
  648. }
  649. }
  650. // Join all of the member texts together, separated with commas,
  651. // and wrap them in braces.
  652. v = partial.length === 0 ? '{}' : gap ?
  653. '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
  654. '{' + partial.join(',') + '}';
  655. gap = mind;
  656. return v;
  657. }
  658. }
  659. // If the JSON object does not yet have a stringify method, give it one.
  660. JSON.stringify = function (value, replacer, space) {
  661. // The stringify method takes a value and an optional replacer, and an optional
  662. // space parameter, and returns a JSON text. The replacer can be a function
  663. // that can replace values, or an array of strings that will select the keys.
  664. // A default replacer method can be provided. Use of the space parameter can
  665. // produce text that is more easily readable.
  666. var i;
  667. gap = '';
  668. indent = '';
  669. // If the space parameter is a number, make an indent string containing that
  670. // many spaces.
  671. if (typeof space === 'number') {
  672. for (i = 0; i < space; i += 1) {
  673. indent += ' ';
  674. }
  675. // If the space parameter is a string, it will be used as the indent string.
  676. } else if (typeof space === 'string') {
  677. indent = space;
  678. }
  679. // If there is a replacer, it must be a function or an array.
  680. // Otherwise, throw an error.
  681. rep = replacer;
  682. if (replacer && typeof replacer !== 'function' &&
  683. (typeof replacer !== 'object' ||
  684. typeof replacer.length !== 'number')) {
  685. throw new Error('JSON.stringify');
  686. }
  687. // Make a fake root object containing our value under the key of ''.
  688. // Return the result of stringifying the value.
  689. return str('', {'': value});
  690. };
  691. // If the JSON object does not yet have a parse method, give it one.
  692. JSON.parse = function (text, reviver) {
  693. // The parse method takes a text and an optional reviver function, and returns
  694. // a JavaScript value if the text is a valid JSON text.
  695. var j;
  696. function walk(holder, key) {
  697. // The walk method is used to recursively walk the resulting structure so
  698. // that modifications can be made.
  699. var k, v, value = holder[key];
  700. if (value && typeof value === 'object') {
  701. for (k in value) {
  702. if (Object.prototype.hasOwnProperty.call(value, k)) {
  703. v = walk(value, k);
  704. if (v !== undefined) {
  705. value[k] = v;
  706. } else {
  707. delete value[k];
  708. }
  709. }
  710. }
  711. }
  712. return reviver.call(holder, key, value);
  713. }
  714. // Parsing happens in four stages. In the first stage, we replace certain
  715. // Unicode characters with escape sequences. JavaScript handles many characters
  716. // incorrectly, either silently deleting them, or treating them as line endings.
  717. text = String(text);
  718. cx.lastIndex = 0;
  719. if (cx.test(text)) {
  720. text = text.replace(cx, function (a) {
  721. return '\\u' +
  722. ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
  723. });
  724. }
  725. // In the second stage, we run the text against regular expressions that look
  726. // for non-JSON patterns. We are especially concerned with '()' and 'new'
  727. // because they can cause invocation, and '=' because it can cause mutation.
  728. // But just to be safe, we want to reject all unexpected forms.
  729. // We split the second stage into 4 regexp operations in order to work around
  730. // crippling inefficiencies in IE's and Safari's regexp engines. First we
  731. // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
  732. // replace all simple value tokens with ']' characters. Third, we delete all
  733. // open brackets that follow a colon or comma or that begin the text. Finally,
  734. // we look to see that the remaining characters are only whitespace or ']' or
  735. // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
  736. if (/^[\],:{}\s]*$/
  737. .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
  738. .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
  739. .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
  740. // In the third stage we use the eval function to compile the text into a
  741. // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
  742. // in JavaScript: it can begin a block or an object literal. We wrap the text
  743. // in parens to eliminate the ambiguity.
  744. j = eval('(' + text + ')');
  745. // In the optional fourth stage, we recursively walk the new structure, passing
  746. // each name/value pair to a reviver function for possible transformation.
  747. return typeof reviver === 'function' ?
  748. walk({'': j}, '') : j;
  749. }
  750. // If the text is not JSON parseable, then a SyntaxError is thrown.
  751. throw new SyntaxError('JSON.parse');
  752. };
  753. })(
  754. 'undefined' != typeof io ? io : module.exports
  755. , typeof JSON !== 'undefined' ? JSON : undefined
  756. );
  757. /**
  758. * socket.io
  759. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  760. * MIT Licensed
  761. */
  762. (function (exports, io) {
  763. /**
  764. * Parser namespace.
  765. *
  766. * @namespace
  767. */
  768. var parser = exports.parser = {};
  769. /**
  770. * Packet types.
  771. */
  772. var packets = parser.packets = [
  773. 'disconnect'
  774. , 'connect'
  775. , 'heartbeat'
  776. , 'message'
  777. , 'json'
  778. , 'event'
  779. , 'ack'
  780. , 'error'
  781. , 'noop'
  782. ];
  783. /**
  784. * Errors reasons.
  785. */
  786. var reasons = parser.reasons = [
  787. 'transport not supported'
  788. , 'client not handshaken'
  789. , 'unauthorized'
  790. ];
  791. /**
  792. * Errors advice.
  793. */
  794. var advice = parser.advice = [
  795. 'reconnect'
  796. ];
  797. /**
  798. * Shortcuts.
  799. */
  800. var JSON = io.JSON
  801. , indexOf = io.util.indexOf;
  802. /**
  803. * Encodes a packet.
  804. *
  805. * @api private
  806. */
  807. parser.encodePacket = function (packet) {
  808. var type = indexOf(packets, packet.type)
  809. , id = packet.id || ''
  810. , endpoint = packet.endpoint || ''
  811. , ack = packet.ack
  812. , data = null;
  813. switch (packet.type) {
  814. case 'error':
  815. var reason = packet.reason ? indexOf(reasons, packet.reason) : ''
  816. , adv = packet.advice ? indexOf(advice, packet.advice) : '';
  817. if (reason !== '' || adv !== '')
  818. data = reason + (adv !== '' ? ('+' + adv) : '');
  819. break;
  820. case 'message':
  821. if (packet.data !== '')
  822. data = packet.data;
  823. break;
  824. case 'event':
  825. var ev = { name: packet.name };
  826. if (packet.args && packet.args.length) {
  827. ev.args = packet.args;
  828. }
  829. data = JSON.stringify(ev);
  830. break;
  831. case 'json':
  832. data = JSON.stringify(packet.data);
  833. break;
  834. case 'connect':
  835. if (packet.qs)
  836. data = packet.qs;
  837. break;
  838. case 'ack':
  839. data = packet.ackId
  840. + (packet.args && packet.args.length
  841. ? '+' + JSON.stringify(packet.args) : '');
  842. break;
  843. }
  844. // construct packet with required fragments
  845. var encoded = [
  846. type
  847. , id + (ack == 'data' ? '+' : '')
  848. , endpoint
  849. ];
  850. // data fragment is optional
  851. if (data !== null && data !== undefined)
  852. encoded.push(data);
  853. return encoded.join(':');
  854. };
  855. /**
  856. * Encodes multiple messages (payload).
  857. *
  858. * @param {Array} messages
  859. * @api private
  860. */
  861. parser.encodePayload = function (packets) {
  862. var decoded = '';
  863. if (packets.length == 1)
  864. return packets[0];
  865. for (var i = 0, l = packets.length; i < l; i++) {
  866. var packet = packets[i];
  867. decoded += '\ufffd' + packet.length + '\ufffd' + packets[i];
  868. }
  869. return decoded;
  870. };
  871. /**
  872. * Decodes a packet
  873. *
  874. * @api private
  875. */
  876. var regexp = /([^:]+):([0-9]+)?(\+)?:([^:]+)?:?([\s\S]*)?/;
  877. parser.decodePacket = function (data) {
  878. var pieces = data.match(regexp);
  879. if (!pieces) return {};
  880. var id = pieces[2] || ''
  881. , data = pieces[5] || ''
  882. , packet = {
  883. type: packets[pieces[1]]
  884. , endpoint: pieces[4] || ''
  885. };
  886. // whether we need to acknowledge the packet
  887. if (id) {
  888. packet.id = id;
  889. if (pieces[3])
  890. packet.ack = 'data';
  891. else
  892. packet.ack = true;
  893. }
  894. // handle different packet types
  895. switch (packet.type) {
  896. case 'error':
  897. var pieces = data.split('+');
  898. packet.reason = reasons[pieces[0]] || '';
  899. packet.advice = advice[pieces[1]] || '';
  900. break;
  901. case 'message':
  902. packet.data = data || '';
  903. break;
  904. case 'event':
  905. try {
  906. var opts = JSON.parse(data);
  907. packet.name = opts.name;
  908. packet.args = opts.args;
  909. } catch (e) { }
  910. packet.args = packet.args || [];
  911. break;
  912. case 'json':
  913. try {
  914. packet.data = JSON.parse(data);
  915. } catch (e) { }
  916. break;
  917. case 'connect':
  918. packet.qs = data || '';
  919. break;
  920. case 'ack':
  921. var pieces = data.match(/^([0-9]+)(\+)?(.*)/);
  922. if (pieces) {
  923. packet.ackId = pieces[1];
  924. packet.args = [];
  925. if (pieces[3]) {
  926. try {
  927. packet.args = pieces[3] ? JSON.parse(pieces[3]) : [];
  928. } catch (e) { }
  929. }
  930. }
  931. break;
  932. case 'disconnect':
  933. case 'heartbeat':
  934. break;
  935. };
  936. return packet;
  937. };
  938. /**
  939. * Decodes data payload. Detects multiple messages
  940. *
  941. * @return {Array} messages
  942. * @api public
  943. */
  944. parser.decodePayload = function (data) {
  945. // IE doesn't like data[i] for unicode chars, charAt works fine
  946. if (data.charAt(0) == '\ufffd') {
  947. var ret = [];
  948. for (var i = 1, length = ''; i < data.length; i++) {
  949. if (data.charAt(i) == '\ufffd') {
  950. ret.push(parser.decodePacket(data.substr(i + 1).substr(0, length)));
  951. i += Number(length) + 1;
  952. length = '';
  953. } else {
  954. length += data.charAt(i);
  955. }
  956. }
  957. return ret;
  958. } else {
  959. return [parser.decodePacket(data)];
  960. }
  961. };
  962. })(
  963. 'undefined' != typeof io ? io : module.exports
  964. , 'undefined' != typeof io ? io : module.parent.exports
  965. );
  966. /**
  967. * socket.io
  968. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  969. * MIT Licensed
  970. */
  971. (function (exports, io) {
  972. /**
  973. * Expose constructor.
  974. */
  975. exports.Transport = Transport;
  976. /**
  977. * This is the transport template for all supported transport methods.
  978. *
  979. * @constructor
  980. * @api public
  981. */
  982. function Transport (socket, sessid) {
  983. this.socket = socket;
  984. this.sessid = sessid;
  985. };
  986. /**
  987. * Apply EventEmitter mixin.
  988. */
  989. io.util.mixin(Transport, io.EventEmitter);
  990. /**
  991. * Indicates whether heartbeats is enabled for this transport
  992. *
  993. * @api private
  994. */
  995. Transport.prototype.heartbeats = function () {
  996. return true;
  997. }
  998. /**
  999. * Handles the response from the server. When a new response is received
  1000. * it will automatically update the timeout, decode the message and
  1001. * forwards the response to the onMessage function for further processing.
  1002. *
  1003. * @param {String} data Response from the server.
  1004. * @api private
  1005. */
  1006. Transport.prototype.onData = function (data) {
  1007. this.clearCloseTimeout();
  1008. // If the connection in currently open (or in a reopening state) reset the close
  1009. // timeout since we have just received data. This check is necessary so
  1010. // that we don't reset the timeout on an explicitly disconnected connection.
  1011. if (this.socket.connected || this.socket.connecting || this.socket.reconnecting) {
  1012. this.setCloseTimeout();
  1013. }
  1014. if (data !== '') {
  1015. // todo: we should only do decodePayload for xhr transports
  1016. var msgs = io.parser.decodePayload(data);
  1017. if (msgs && msgs.length) {
  1018. for (var i = 0, l = msgs.length; i < l; i++) {
  1019. this.onPacket(msgs[i]);
  1020. }
  1021. }
  1022. }
  1023. return this;
  1024. };
  1025. /**
  1026. * Handles packets.
  1027. *
  1028. * @api private
  1029. */
  1030. Transport.prototype.onPacket = function (packet) {
  1031. this.socket.setHeartbeatTimeout();
  1032. if (packet.type == 'heartbeat') {
  1033. return this.onHeartbeat();
  1034. }
  1035. if (packet.type == 'connect' && packet.endpoint == '') {
  1036. this.onConnect();
  1037. }
  1038. if (packet.type == 'error' && packet.advice == 'reconnect') {
  1039. this.isOpen = false;
  1040. }
  1041. this.socket.onPacket(packet);
  1042. return this;
  1043. };
  1044. /**
  1045. * Sets close timeout
  1046. *
  1047. * @api private
  1048. */
  1049. Transport.prototype.setCloseTimeout = function () {
  1050. if (!this.closeTimeout) {
  1051. var self = this;
  1052. this.closeTimeout = setTimeout(function () {
  1053. self.onDisconnect();
  1054. }, this.socket.closeTimeout);
  1055. }
  1056. };
  1057. /**
  1058. * Called when transport disconnects.
  1059. *
  1060. * @api private
  1061. */
  1062. Transport.prototype.onDisconnect = function () {
  1063. if (this.isOpen) this.close();
  1064. this.clearTimeouts();
  1065. this.socket.onDisconnect();
  1066. return this;
  1067. };
  1068. /**
  1069. * Called when transport connects
  1070. *
  1071. * @api private
  1072. */
  1073. Transport.prototype.onConnect = function () {
  1074. this.socket.onConnect();
  1075. return this;
  1076. }
  1077. /**
  1078. * Clears close timeout
  1079. *
  1080. * @api private
  1081. */
  1082. Transport.prototype.clearCloseTimeout = function () {
  1083. if (this.closeTimeout) {
  1084. clearTimeout(this.closeTimeout);
  1085. this.closeTimeout = null;
  1086. }
  1087. };
  1088. /**
  1089. * Clear timeouts
  1090. *
  1091. * @api private
  1092. */
  1093. Transport.prototype.clearTimeouts = function () {
  1094. this.clearCloseTimeout();
  1095. if (this.reopenTimeout) {
  1096. clearTimeout(this.reopenTimeout);
  1097. }
  1098. };
  1099. /**
  1100. * Sends a packet
  1101. *
  1102. * @param {Object} packet object.
  1103. * @api private
  1104. */
  1105. Transport.prototype.packet = function (packet) {
  1106. this.send(io.parser.encodePacket(packet));
  1107. };
  1108. /**
  1109. * Send the received heartbeat message back to server. So the server
  1110. * knows we are still connected.
  1111. *
  1112. * @param {String} heartbeat Heartbeat response from the server.
  1113. * @api private
  1114. */
  1115. Transport.prototype.onHeartbeat = function (heartbeat) {
  1116. this.packet({ type: 'heartbeat' });
  1117. };
  1118. /**
  1119. * Called when the transport opens.
  1120. *
  1121. * @api private
  1122. */
  1123. Transport.prototype.onOpen = function () {
  1124. this.isOpen = true;
  1125. this.clearCloseTimeout();
  1126. this.socket.onOpen();
  1127. };
  1128. /**
  1129. * Notifies the base when the connection with the Socket.IO server
  1130. * has been disconnected.
  1131. *
  1132. * @api private
  1133. */
  1134. Transport.prototype.onClose = function () {
  1135. var self = this;
  1136. /* FIXME: reopen delay causing a infinit loop
  1137. this.reopenTimeout = setTimeout(function () {
  1138. self.open();
  1139. }, this.socket.options['reopen delay']);*/
  1140. this.isOpen = false;
  1141. this.socket.onClose();
  1142. this.onDisconnect();
  1143. };
  1144. /**
  1145. * Generates a connection url based on the Socket.IO URL Protocol.
  1146. * See <https://github.com/learnboost/socket.io-node/> for more details.
  1147. *
  1148. * @returns {String} Connection url
  1149. * @api private
  1150. */
  1151. Transport.prototype.prepareUrl = function () {
  1152. var options = this.socket.options;
  1153. return this.scheme() + '://'
  1154. + options.host + ':' + options.port + '/'
  1155. + options.resource + '/' + io.protocol
  1156. + '/' + this.name + '/' + this.sessid;
  1157. };
  1158. /**
  1159. * Checks if the transport is ready to start a connection.
  1160. *
  1161. * @param {Socket} socket The socket instance that needs a transport
  1162. * @param {Function} fn The callback
  1163. * @api private
  1164. */
  1165. Transport.prototype.ready = function (socket, fn) {
  1166. fn.call(this);
  1167. };
  1168. })(
  1169. 'undefined' != typeof io ? io : module.exports
  1170. , 'undefined' != typeof io ? io : module.parent.exports
  1171. );
  1172. /**
  1173. * socket.io
  1174. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  1175. * MIT Licensed
  1176. */
  1177. (function (exports, io, global) {
  1178. /**
  1179. * Expose constructor.
  1180. */
  1181. exports.Socket = Socket;
  1182. /**
  1183. * Create a new `Socket.IO client` which can establish a persistent
  1184. * connection with a Socket.IO enabled server.
  1185. *
  1186. * @api public
  1187. */
  1188. function Socket (options) {
  1189. this.options = {
  1190. port: 80
  1191. , secure: false
  1192. , document: 'document' in global ? document : false
  1193. , resource: 'socket.io'
  1194. , transports: io.transports
  1195. , 'connect timeout': 10000
  1196. , 'try multiple transports': true
  1197. , 'reconnect': true
  1198. , 'reconnection delay': 500
  1199. , 'reconnection limit': Infinity
  1200. , 'reopen delay': 3000
  1201. , 'max reconnection attempts': 10
  1202. , 'sync disconnect on unload': false
  1203. , 'auto connect': true
  1204. , 'flash policy port': 10843
  1205. , 'manualFlush': false
  1206. };
  1207. io.util.merge(this.options, options);
  1208. this.connected = false;
  1209. this.open = false;
  1210. this.connecting = false;
  1211. this.reconnecting = false;
  1212. this.namespaces = {};
  1213. this.buffer = [];
  1214. this.doBuffer = false;
  1215. if (this.options['sync disconnect on unload'] &&
  1216. (!this.isXDomain() || io.util.ua.hasCORS)) {
  1217. var self = this;
  1218. io.util.on(global, 'beforeunload', function () {
  1219. self.disconnectSync();
  1220. }, false);
  1221. }
  1222. if (this.options['auto connect']) {
  1223. this.connect();
  1224. }
  1225. };
  1226. /**
  1227. * Apply EventEmitter mixin.
  1228. */
  1229. io.util.mixin(Socket, io.EventEmitter);
  1230. /**
  1231. * Returns a namespace listener/emitter for this socket
  1232. *
  1233. * @api public
  1234. */
  1235. Socket.prototype.of = function (name) {
  1236. if (!this.namespaces[name]) {
  1237. this.namespaces[name] = new io.SocketNamespace(this, name);
  1238. if (name !== '') {
  1239. this.namespaces[name].packet({ type: 'connect' });
  1240. }
  1241. }
  1242. return this.namespaces[name];
  1243. };
  1244. /**
  1245. * Emits the given event to the Socket and all namespaces
  1246. *
  1247. * @api private
  1248. */
  1249. Socket.prototype.publish = function () {
  1250. this.emit.apply(this, arguments);
  1251. var nsp;
  1252. for (var i in this.namespaces) {
  1253. if (this.namespaces.hasOwnProperty(i)) {
  1254. nsp = this.of(i);
  1255. nsp.$emit.apply(nsp, arguments);
  1256. }
  1257. }
  1258. };
  1259. /**
  1260. * Performs the handshake
  1261. *
  1262. * @api private
  1263. */
  1264. function empty () { };
  1265. Socket.prototype.handshake = function (fn) {
  1266. // alert("Socket handshake()");
  1267. var self = this
  1268. , options = this.options;
  1269. function complete (data) {
  1270. // alert("Socket handshake complete(): " + data);
  1271. if (data instanceof Error) {
  1272. self.connecting = false;
  1273. self.onError(data.message);
  1274. } else {
  1275. fn.apply(null, data.split(':'));
  1276. }
  1277. };
  1278. var url = [
  1279. 'http' + (options.secure ? 's' : '') + ':/'
  1280. , options.host + ':' + options.port
  1281. , options.resource
  1282. , io.protocol
  1283. , io.util.query(this.options.query, 't=' + +new Date)
  1284. ].join('/');
  1285. // alert("Socket handshake(): " + url);
  1286. if (this.isXDomain() && !io.util.ua.hasCORS) {
  1287. // alert("Socket handshake isXDomain");
  1288. var insertAt = document.getElementsByTagName('script')[0]
  1289. , script = document.createElement('script');
  1290. script.src = url + '&jsonp=' + io.j.length;
  1291. insertAt.parentNode.insertBefore(script, insertAt);
  1292. // alert("Socket io.j.push");
  1293. io.j.push(function (data) {
  1294. // alert("Socket handshake push() with: " + data);
  1295. complete(data);
  1296. script.parentNode.removeChild(script);
  1297. });
  1298. } else {
  1299. // alert("Socket handshake is not XDomain")
  1300. var xhr = io.util.request();
  1301. xhr.open('GET', url, true);
  1302. if (this.isXDomain()) {
  1303. xhr.withCredentials = true;
  1304. }
  1305. xhr.onreadystatechange = function () {
  1306. if (xhr.readyState == 4) {
  1307. xhr.onreadystatechange = empty;
  1308. if (xhr.status == 200) {
  1309. // alert("Socket handshake() status 200");
  1310. complete(xhr.responseText);
  1311. } else if (xhr.status == 403) {
  1312. // alert("Socket handshake() status 403");
  1313. self.onError(xhr.responseText);
  1314. } else {
  1315. // alert("Socket handshake() status else");
  1316. self.connecting = false;
  1317. !self.reconnecting && self.onError(xhr.responseText);
  1318. }
  1319. }
  1320. };
  1321. xhr.send(null);
  1322. }
  1323. };
  1324. /**
  1325. * Find an available transport based on the options supplied in the constructor.
  1326. *
  1327. * @api private
  1328. */
  1329. Socket.prototype.getTransport = function (override) {
  1330. var transports = override || this.transports, match;
  1331. for (var i = 0, transport; transport = transports[i]; i++) {
  1332. if (io.Transport[transport]
  1333. && io.Transport[transport].check(this)
  1334. && (!this.isXDomain() || io.Transport[transport].xdomainCheck(this))) {
  1335. return new io.Transport[transport](this, this.sessionid);
  1336. }
  1337. }
  1338. return null;
  1339. };
  1340. /**
  1341. * Connects to the server.
  1342. *
  1343. * @param {Function} [fn] Callback.
  1344. * @returns {io.Socket}
  1345. * @api public
  1346. */
  1347. Socket.prototype.connect = function (fn) {
  1348. if (this.connecting) {
  1349. return this;
  1350. }
  1351. var self = this;
  1352. self.connecting = true;
  1353. this.handshake(function (sid, heartbeat, close, transports) {
  1354. self.sessionid = sid;
  1355. self.closeTimeout = close * 1000;
  1356. self.heartbeatTimeout = heartbeat * 1000;
  1357. if(!self.transports)
  1358. self.transports = self.origTransports = (transports ? io.util.intersect(
  1359. transports.split(',')
  1360. , self.options.transports
  1361. ) : self.options.transports);
  1362. self.setHeartbeatTimeout();
  1363. function connect (transports){
  1364. if (self.transport) self.transport.clearTimeouts();
  1365. self.transport = self.getTransport(transports);
  1366. if (!self.transport) return self.publish('connect_failed');
  1367. // once the transport is ready
  1368. self.transport.ready(self, function () {
  1369. self.connecting = true;
  1370. self.publish('connecting', self.transport.name);
  1371. self.transport.open();
  1372. if (self.options['connect timeout']) {
  1373. self.connectTimeoutTimer = setTimeout(function () {
  1374. if (!self.connected) {
  1375. self.connecting = false;
  1376. if (self.options['try multiple transports']) {
  1377. var remaining = self.transports;
  1378. while (remaining.length > 0 && remaining.splice(0,1)[0] !=
  1379. self.transport.name) {}
  1380. if (remaining.length){
  1381. connect(remaining);
  1382. } else {
  1383. self.publish('connect_failed');
  1384. }
  1385. }
  1386. }
  1387. }, self.options['connect timeout']);
  1388. }
  1389. });
  1390. }
  1391. connect(self.transports);
  1392. self.once('connect', function (){
  1393. clearTimeout(self.connectTimeoutTimer);
  1394. fn && typeof fn == 'function' && fn();
  1395. });
  1396. });
  1397. return this;
  1398. };
  1399. /**
  1400. * Clears and sets a new heartbeat timeout using the value given by the
  1401. * server during the handshake.
  1402. *
  1403. * @api private
  1404. */
  1405. Socket.prototype.setHeartbeatTimeout = function () {
  1406. clearTimeout(this.heartbeatTimeoutTimer);
  1407. if(this.transport && !this.transport.heartbeats()) return;
  1408. var self = this;
  1409. this.heartbeatTimeoutTimer = setTimeout(function () {
  1410. self.transport.onClose();
  1411. }, this.heartbeatTimeout);
  1412. };
  1413. /**
  1414. * Sends a message.
  1415. *
  1416. * @param {Object} data packet.
  1417. * @returns {io.Socket}
  1418. * @api public
  1419. */
  1420. Socket.prototype.packet = function (data) {
  1421. if (this.connected && !this.doBuffer) {
  1422. this.transport.packet(data);
  1423. } else {
  1424. this.buffer.push(data);
  1425. }
  1426. return this;
  1427. };
  1428. /**
  1429. * Sets buffer state
  1430. *
  1431. * @api private
  1432. */
  1433. Socket.prototype.setBuffer = function (v) {
  1434. this.doBuffer = v;
  1435. if (!v && this.connected && this.buffer.length) {
  1436. if (!this.options['manualFlush']) {
  1437. this.flushBuffer();
  1438. }
  1439. }
  1440. };
  1441. /**
  1442. * Flushes the buffer data over the wire.
  1443. * To be invoked manually when 'manualFlush' is set to true.
  1444. *
  1445. * @api public
  1446. */
  1447. Socket.prototype.flushBuffer = function() {
  1448. this.transport.payload(this.buffer);
  1449. this.buffer = [];
  1450. };
  1451. /**
  1452. * Disconnect the established connect.
  1453. *
  1454. * @returns {io.Socket}
  1455. * @api public
  1456. */
  1457. Socket.prototype.disconnect = function () {
  1458. if (this.connected || this.connecting) {
  1459. if (this.open) {
  1460. this.of('').packet({ type: 'disconnect' });
  1461. }
  1462. // handle disconnection immediately
  1463. this.onDisconnect('booted');
  1464. }
  1465. return this;
  1466. };
  1467. /**
  1468. * Disconnects the socket with a sync XHR.
  1469. *
  1470. * @api private
  1471. */
  1472. Socket.prototype.disconnectSync = function () {
  1473. // ensure disconnection
  1474. var xhr = io.util.request();
  1475. var uri = [
  1476. 'http' + (this.options.secure ? 's' : '') + ':/'
  1477. , this.options.host + ':' + this.options.port
  1478. , this.options.resource
  1479. , io.protocol
  1480. , ''
  1481. , this.sessionid
  1482. ].join('/') + '/?disconnect=1';
  1483. xhr.open('GET', uri, false);
  1484. xhr.send(null);
  1485. // handle disconnection immediately
  1486. this.onDisconnect('booted');
  1487. };
  1488. /**
  1489. * Check if we need to use cross domain enabled transports. Cross domain would
  1490. * be a different port or different domain name.
  1491. *
  1492. * @returns {Boolean}
  1493. * @api private
  1494. */
  1495. Socket.prototype.isXDomain = function () {
  1496. var port = global.location.port ||
  1497. ('https:' == global.location.protocol ? 443 : 80);
  1498. return this.options.host !== global.location.hostname
  1499. || this.options.port != port;
  1500. };
  1501. /**
  1502. * Called upon handshake.
  1503. *
  1504. * @api private
  1505. */
  1506. Socket.prototype.onConnect = function () {
  1507. if (!this.connected) {
  1508. this.connected = true;
  1509. this.connecting = false;
  1510. if (!this.doBuffer) {
  1511. // make sure to flush the buffer
  1512. this.setBuffer(false);
  1513. }
  1514. this.emit('connect');
  1515. }
  1516. };
  1517. /**
  1518. * Called when the transport opens
  1519. *
  1520. * @api private
  1521. */
  1522. Socket.prototype.onOpen = function () {
  1523. this.open = true;
  1524. };
  1525. /**
  1526. * Called when the transport closes.
  1527. *
  1528. * @api private
  1529. */
  1530. Socket.prototype.onClose = function () {
  1531. this.open = false;
  1532. clearTimeout(this.heartbeatTimeoutTimer);
  1533. };
  1534. /**
  1535. * Called when the transport first opens a connection
  1536. *
  1537. * @param text
  1538. */
  1539. Socket.prototype.onPacket = function (packet) {
  1540. this.of(packet.endpoint).onPacket(packet);
  1541. };
  1542. /**
  1543. * Handles an error.
  1544. *
  1545. * @api private
  1546. */
  1547. Socket.prototype.onError = function (err) {
  1548. if (err && err.advice) {
  1549. if (err.advice === 'reconnect' && (this.connected || this.connecting)) {
  1550. this.disconnect();
  1551. if (this.options.reconnect) {
  1552. this.reconnect();
  1553. }
  1554. }
  1555. }
  1556. this.publish('error', err && err.reason ? err.reason : err);
  1557. };
  1558. /**
  1559. * Called when the transport disconnects.
  1560. *
  1561. * @api private
  1562. */
  1563. Socket.prototype.onDisconnect = function (reason) {
  1564. var wasConnected = this.connected
  1565. , wasConnecting = this.connecting;
  1566. this.connected = false;
  1567. this.connecting = false;
  1568. this.open = false;
  1569. if (wasConnected || wasConnecting) {
  1570. this.transport.close();
  1571. this.transport.clearTimeouts();
  1572. if (wasConnected) {
  1573. this.publish('disconnect', reason);
  1574. if ('booted' != reason && this.options.reconnect && !this.reconnecting) {
  1575. this.reconnect();
  1576. }
  1577. }
  1578. }
  1579. };
  1580. /**
  1581. * Called upon reconnection.
  1582. *
  1583. * @api private
  1584. */
  1585. Socket.prototype.reconnect = function () {
  1586. this.reconnecting = true;
  1587. this.reconnectionAttempts = 0;
  1588. this.reconnectionDelay = this.options['reconnection delay'];
  1589. var self = this
  1590. , maxAttempts = this.options['max reconnection attempts']
  1591. , tryMultiple = this.options['try multiple transports']
  1592. , limit = this.options['reconnection limit'];
  1593. function reset () {
  1594. if (self.connected) {
  1595. for (var i in self.namespaces) {
  1596. if (self.namespaces.hasOwnProperty(i) && '' !== i) {
  1597. self.namespaces[i].packet({ type: 'connect' });
  1598. }
  1599. }
  1600. self.publish('reconnect', self.transport.name, self.reconnectionAttempts);
  1601. }
  1602. clearTimeout(self.reconnectionTimer);
  1603. self.removeListener('connect_failed', maybeReconnect);
  1604. self.removeListener('connect', maybeReconnect);
  1605. self.reconnecting = false;
  1606. delete self.reconnectionAttempts;
  1607. delete self.reconnectionDelay;
  1608. delete self.reconnectionTimer;
  1609. delete self.redoTransports;
  1610. self.options['try multiple transports'] = tryMultiple;
  1611. };
  1612. function maybeReconnect () {
  1613. if (!self.reconnecting) {
  1614. return;
  1615. }
  1616. if (self.connected) {
  1617. return reset();
  1618. };
  1619. if (self.connecting && self.reconnecting) {
  1620. return self.reconnectionTimer = setTimeout(maybeReconnect, 1000);
  1621. }
  1622. if (self.reconnectionAttempts++ >= maxAttempts) {
  1623. if (!self.redoTransports) {
  1624. self.on('connect_failed', maybeReconnect);
  1625. self.options['try multiple transports'] = true;
  1626. self.transports = self.origTransports;
  1627. self.transport = self.getTransport();
  1628. self.redoTransports = true;
  1629. self.connect();
  1630. } else {
  1631. self.publish('reconnect_failed');
  1632. reset();
  1633. }
  1634. } else {
  1635. if (self.reconnectionDelay < limit) {
  1636. self.reconnectionDelay *= 2; // exponential back off
  1637. }
  1638. self.connect();
  1639. self.publish('reconnecting', self.reconnectionDelay, self.reconnectionAttempts);
  1640. self.reconnectionTimer = setTimeout(maybeReconnect, self.reconnectionDelay);
  1641. }
  1642. };
  1643. this.options['try multiple transports'] = false;
  1644. this.reconnectionTimer = setTimeout(maybeReconnect, this.reconnectionDelay);
  1645. this.on('connect', maybeReconnect);
  1646. };
  1647. })(
  1648. 'undefined' != typeof io ? io : module.exports
  1649. , 'undefined' != typeof io ? io : module.parent.exports
  1650. , this
  1651. );
  1652. /**
  1653. * socket.io
  1654. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  1655. * MIT Licensed
  1656. */
  1657. (function (exports, io) {
  1658. /**
  1659. * Expose constructor.
  1660. */
  1661. exports.SocketNamespace = SocketNamespace;
  1662. /**
  1663. * Socket namespace constructor.
  1664. *
  1665. * @constructor
  1666. * @api public
  1667. */
  1668. function SocketNamespace (socket, name) {
  1669. this.socket = socket;
  1670. this.name = name || '';
  1671. this.flags = {};
  1672. this.json = new Flag(this, 'json');
  1673. this.ackPackets = 0;
  1674. this.acks = {};
  1675. };
  1676. /**
  1677. * Apply EventEmitter mixin.
  1678. */
  1679. io.util.mixin(SocketNamespace, io.EventEmitter);
  1680. /**
  1681. * Copies emit since we override it
  1682. *
  1683. * @api private
  1684. */
  1685. SocketNamespace.prototype.$emit = io.EventEmitter.prototype.emit;
  1686. /**
  1687. * Creates a new namespace, by proxying the request to the socket. This
  1688. * allows us to use the synax as we do on the server.
  1689. *
  1690. * @api public
  1691. */
  1692. SocketNamespace.prototype.of = function () {
  1693. return this.socket.of.apply(this.socket, arguments);
  1694. };
  1695. /**
  1696. * Sends a packet.
  1697. *
  1698. * @api private
  1699. */
  1700. SocketNamespace.prototype.packet = function (packet) {
  1701. packet.endpoint = this.name;
  1702. this.socket.packet(packet);
  1703. this.flags = {};
  1704. return this;
  1705. };
  1706. /**
  1707. * Sends a message
  1708. *
  1709. * @api public
  1710. */
  1711. SocketNamespace.prototype.send = function (data, fn) {
  1712. var packet = {
  1713. type: this.flags.json ? 'json' : 'message'
  1714. , data: data
  1715. };
  1716. if ('function' == typeof fn) {
  1717. packet.id = ++this.ackPackets;
  1718. packet.ack = true;
  1719. this.acks[packet.id] = fn;
  1720. }
  1721. return this.packet(packet);
  1722. };
  1723. /**
  1724. * Emits an event
  1725. *
  1726. * @api public
  1727. */
  1728. SocketNamespace.prototype.emit = function (name) {
  1729. var args = Array.prototype.slice.call(arguments, 1)
  1730. , lastArg = args[args.length - 1]
  1731. , packet = {
  1732. type: 'event'
  1733. , name: name
  1734. };
  1735. if ('function' == typeof lastArg) {
  1736. packet.id = ++this.ackPackets;
  1737. packet.ack = 'data';
  1738. this.acks[packet.id] = lastArg;
  1739. args = args.slice(0, args.length - 1);
  1740. }
  1741. packet.args = args;
  1742. return this.packet(packet);
  1743. };
  1744. /**
  1745. * Disconnects the namespace
  1746. *
  1747. * @api private
  1748. */
  1749. SocketNamespace.prototype.disconnect = function () {
  1750. if (this.name === '') {
  1751. this.socket.disconnect();
  1752. } else {
  1753. this.packet({ type: 'disconnect' });
  1754. this.$emit('disconnect');
  1755. }
  1756. return this;
  1757. };
  1758. /**
  1759. * Handles a packet
  1760. *
  1761. * @api private
  1762. */
  1763. SocketNamespace.prototype.onPacket = function (packet) {
  1764. var self = this;
  1765. function ack () {
  1766. self.packet({
  1767. type: 'ack'
  1768. , args: io.util.toArray(arguments)
  1769. , ackId: packet.id
  1770. });
  1771. };
  1772. switch (packet.type) {
  1773. case 'connect':
  1774. this.$emit('connect');
  1775. break;
  1776. case 'disconnect':
  1777. if (this.name === '') {
  1778. this.socket.onDisconnect(packet.reason || 'booted');
  1779. } else {
  1780. this.$emit('disconnect', packet.reason);
  1781. }
  1782. break;
  1783. case 'message':
  1784. case 'json':
  1785. var params = ['message', packet.data];
  1786. if (packet.ack == 'data') {
  1787. params.push(ack);
  1788. } else if (packet.ack) {
  1789. this.packet({ type: 'ack', ackId: packet.id });
  1790. }
  1791. this.$emit.apply(this, params);
  1792. break;
  1793. case 'event':
  1794. var params = [packet.name].concat(packet.args);
  1795. if (packet.ack == 'data')
  1796. params.push(ack);
  1797. this.$emit.apply(this, params);
  1798. break;
  1799. case 'ack':
  1800. if (this.acks[packet.ackId]) {
  1801. this.acks[packet.ackId].apply(this, packet.args);
  1802. delete this.acks[packet.ackId];
  1803. }
  1804. break;
  1805. case 'error':
  1806. if (packet.advice){
  1807. this.socket.onError(packet);
  1808. } else {
  1809. if (packet.reason == 'unauthorized') {
  1810. this.$emit('connect_failed', packet.reason);
  1811. } else {
  1812. this.$emit('error', packet.reason);
  1813. }
  1814. }
  1815. break;
  1816. }
  1817. };
  1818. /**
  1819. * Flag interface.
  1820. *
  1821. * @api private
  1822. */
  1823. function Flag (nsp, name) {
  1824. this.namespace = nsp;
  1825. this.name = name;
  1826. };
  1827. /**
  1828. * Send a message
  1829. *
  1830. * @api public
  1831. */
  1832. Flag.prototype.send = function () {
  1833. this.namespace.flags[this.name] = true;
  1834. this.namespace.send.apply(this.namespace, arguments);
  1835. };
  1836. /**
  1837. * Emit an event
  1838. *
  1839. * @api public
  1840. */
  1841. Flag.prototype.emit = function () {
  1842. this.namespace.flags[this.name] = true;
  1843. this.namespace.emit.apply(this.namespace, arguments);
  1844. };
  1845. })(
  1846. 'undefined' != typeof io ? io : module.exports
  1847. , 'undefined' != typeof io ? io : module.parent.exports
  1848. );
  1849. /**
  1850. * socket.io
  1851. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  1852. * MIT Licensed
  1853. */
  1854. (function (exports, io, global) {
  1855. /**
  1856. * Expose constructor.
  1857. */
  1858. exports.websocket = WS;
  1859. /**
  1860. * The WebSocket transport uses the HTML5 WebSocket API to establish an
  1861. * persistent connection with the Socket.IO server. This transport will also
  1862. * be inherited by the FlashSocket fallback as it provides a API compatible
  1863. * polyfill for the WebSockets.
  1864. *
  1865. * @constructor
  1866. * @extends {io.Transport}
  1867. * @api public
  1868. */
  1869. function WS (socket) {
  1870. io.Transport.apply(this, arguments);
  1871. };
  1872. /**
  1873. * Inherits from Transport.
  1874. */
  1875. io.util.inherit(WS, io.Transport);
  1876. /**
  1877. * Transport name
  1878. *
  1879. * @api public
  1880. */
  1881. WS.prototype.name = 'websocket';
  1882. /**
  1883. * Initializes a new `WebSocket` connection with the Socket.IO server. We attach
  1884. * all the appropriate listeners to handle the responses from the server.
  1885. *
  1886. * @returns {Transport}
  1887. * @api public
  1888. */
  1889. WS.prototype.open = function () {
  1890. var query = io.util.query(this.socket.options.query)
  1891. , self = this
  1892. , Socket
  1893. if (!Socket) {
  1894. Socket = global.MozWebSocket || global.WebSocket;
  1895. }
  1896. this.websocket = new Socket(this.prepareUrl() + query);
  1897. this.websocket.onopen = function () {
  1898. self.onOpen();
  1899. self.socket.setBuffer(false);
  1900. };
  1901. this.websocket.onmessage = function (ev) {
  1902. self.onData(ev.data);
  1903. };
  1904. this.websocket.onclose = function () {
  1905. self.onClose();
  1906. self.socket.setBuffer(true);
  1907. };
  1908. this.websocket.onerror = function (e) {
  1909. self.onError(e);
  1910. };
  1911. return this;
  1912. };
  1913. /**
  1914. * Send a message to the Socket.IO server. The message will automatically be
  1915. * encoded in the correct message format.
  1916. *
  1917. * @returns {Transport}
  1918. * @api public
  1919. */
  1920. // Do to a bug in the current IDevices browser, we need to wrap the send in a
  1921. // setTimeout, when they resume from sleeping the browser will crash if
  1922. // we don't allow the browser time to detect the socket has been closed
  1923. if (io.util.ua.iDevice) {
  1924. WS.prototype.send = function (data) {
  1925. var self = this;
  1926. setTimeout(function() {
  1927. self.websocket.send(data);
  1928. },0);
  1929. return this;
  1930. };
  1931. } else {
  1932. WS.prototype.send = function (data) {
  1933. this.websocket.send(data);
  1934. return this;
  1935. };
  1936. }
  1937. /**
  1938. * Payload
  1939. *
  1940. * @api private
  1941. */
  1942. WS.prototype.payload = function (arr) {
  1943. for (var i = 0, l = arr.length; i < l; i++) {
  1944. this.packet(arr[i]);
  1945. }
  1946. return this;
  1947. };
  1948. /**
  1949. * Disconnect the established `WebSocket` connection.
  1950. *
  1951. * @returns {Transport}
  1952. * @api public
  1953. */
  1954. WS.prototype.close = function () {
  1955. this.websocket.close();
  1956. return this;
  1957. };
  1958. /**
  1959. * Handle the errors that `WebSocket` might be giving when we
  1960. * are attempting to connect or send messages.
  1961. *
  1962. * @param {Error} e The error.
  1963. * @api private
  1964. */
  1965. WS.prototype.onError = function (e) {
  1966. this.socket.onError(e);
  1967. };
  1968. /**
  1969. * Returns the appropriate scheme for the URI generation.
  1970. *
  1971. * @api private
  1972. */
  1973. WS.prototype.scheme = function () {
  1974. return this.socket.options.secure ? 'wss' : 'ws';
  1975. };
  1976. /**
  1977. * Checks if the browser has support for native `WebSockets` and that
  1978. * it's not the polyfill created for the FlashSocket transport.
  1979. *
  1980. * @return {Boolean}
  1981. * @api public
  1982. */
  1983. WS.check = function () {
  1984. return ('WebSocket' in global && !('__addTask' in WebSocket))
  1985. || 'MozWebSocket' in global;
  1986. };
  1987. /**
  1988. * Check if the `WebSocket` transport support cross domain communications.
  1989. *
  1990. * @returns {Boolean}
  1991. * @api public
  1992. */
  1993. WS.xdomainCheck = function () {
  1994. return true;
  1995. };
  1996. /**
  1997. * Add the transport to your public io.transports array.
  1998. *
  1999. * @api private
  2000. */
  2001. io.transports.push('websocket');
  2002. })(
  2003. 'undefined' != typeof io ? io.Transport : module.exports
  2004. , 'undefined' != typeof io ? io : module.parent.exports
  2005. , this
  2006. );
  2007. /**
  2008. * socket.io
  2009. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  2010. * MIT Licensed
  2011. */
  2012. (function (exports, io) {
  2013. /**
  2014. * Expose constructor.
  2015. */
  2016. exports.flashsocket = Flashsocket;
  2017. /**
  2018. * The FlashSocket transport. This is a API wrapper for the HTML5 WebSocket
  2019. * specification. It uses a .swf file to communicate with the server. If you want
  2020. * to serve the .swf file from a other server than where the Socket.IO script is
  2021. * coming from you need to use the insecure version of the .swf. More information
  2022. * about this can be found on the github page.
  2023. *
  2024. * @constructor
  2025. * @extends {io.Transport.websocket}
  2026. * @api public
  2027. */
  2028. function Flashsocket () {
  2029. io.Transport.websocket.apply(this, arguments);
  2030. };
  2031. /**
  2032. * Inherits from Transport.
  2033. */
  2034. io.util.inherit(Flashsocket, io.Transport.websocket);
  2035. /**
  2036. * Transport name
  2037. *
  2038. * @api public
  2039. */
  2040. Flashsocket.prototype.name = 'flashsocket';
  2041. /**
  2042. * Disconnect the established `FlashSocket` connection. This is done by adding a
  2043. * new task to the FlashSocket. The rest will be handled off by the `WebSocket`
  2044. * transport.
  2045. *
  2046. * @returns {Transport}
  2047. * @api public
  2048. */
  2049. Flashsocket.prototype.open = function () {
  2050. var self = this
  2051. , args = arguments;
  2052. WebSocket.__addTask(function () {
  2053. io.Transport.websocket.prototype.open.apply(self, args);
  2054. });
  2055. return this;
  2056. };
  2057. /**
  2058. * Sends a message to the Socket.IO server. This is done by adding a new
  2059. * task to the FlashSocket. The rest will be handled off by the `WebSocket`
  2060. * transport.
  2061. *
  2062. * @returns {Transport}
  2063. * @api public
  2064. */
  2065. Flashsocket.prototype.send = function () {
  2066. var self = this, args = arguments;
  2067. WebSocket.__addTask(function () {
  2068. io.Transport.websocket.prototype.send.apply(self, args);
  2069. });
  2070. return this;
  2071. };
  2072. /**
  2073. * Disconnects the established `FlashSocket` connection.
  2074. *
  2075. * @returns {Transport}
  2076. * @api public
  2077. */
  2078. Flashsocket.prototype.close = function () {
  2079. WebSocket.__tasks.length = 0;
  2080. io.Transport.websocket.prototype.close.call(this);
  2081. return this;
  2082. };
  2083. /**
  2084. * The WebSocket fall back needs to append the flash container to the body
  2085. * element, so we need to make sure we have access to it. Or defer the call
  2086. * until we are sure there is a body element.
  2087. *
  2088. * @param {Socket} socket The socket instance that needs a transport
  2089. * @param {Function} fn The callback
  2090. * @api private
  2091. */
  2092. Flashsocket.prototype.ready = function (socket, fn) {
  2093. function init () {
  2094. // alert("FlashSocket init()")
  2095. var options = socket.options
  2096. , port = options['flash policy port']
  2097. , path = [
  2098. 'http' + (options.secure ? 's' : '') + ':/'
  2099. , options.host + ':' + options.port
  2100. , options.resource
  2101. , 'static/flashsocket'
  2102. , 'WebSocketMain' + (socket.isXDomain() ? 'Insecure' : '') + '.swf'
  2103. ];
  2104. // Only start downloading the swf file when the checked that this browser
  2105. // actually supports it
  2106. if (!Flashsocket.loaded) {
  2107. // alert("FlashSocket not loaded");
  2108. if (typeof WEB_SOCKET_SWF_LOCATION === 'undefined') {
  2109. // Set the correct file based on the XDomain settings
  2110. WEB_SOCKET_SWF_LOCATION = path.join('/');
  2111. }
  2112. if (port !== 843) {
  2113. // alert("load policy file");
  2114. WebSocket.loadFlashPolicyFile('xmlsocket://' + options.host + ':' + port);
  2115. }
  2116. WebSocket.__initialize();
  2117. Flashsocket.loaded = true;
  2118. }
  2119. // alert("FlashSocket fn.call(self)");
  2120. fn.call(self);
  2121. }
  2122. var self = this;
  2123. if (document.body) return init();
  2124. io.util.load(init);
  2125. };
  2126. /**
  2127. * Check if the FlashSocket transport is supported as it requires that the Adobe
  2128. * Flash Player plug-in version `10.0.0` or greater is installed. And also check if
  2129. * the polyfill is correctly loaded.
  2130. *
  2131. * @returns {Boolean}
  2132. * @api public
  2133. */
  2134. Flashsocket.check = function () {
  2135. if (
  2136. typeof WebSocket == 'undefined'
  2137. || !('__initialize' in WebSocket) || !swfobject
  2138. ) return false;
  2139. return swfobject.getFlashPlayerVersion().major >= 10;
  2140. };
  2141. /**
  2142. * Check if the FlashSocket transport can be used as cross domain / cross origin
  2143. * transport. Because we can't see which type (secure or insecure) of .swf is used
  2144. * we will just return true.
  2145. *
  2146. * @returns {Boolean}
  2147. * @api public
  2148. */
  2149. Flashsocket.xdomainCheck = function () {
  2150. return true;
  2151. };
  2152. /**
  2153. * Disable AUTO_INITIALIZATION
  2154. */
  2155. if (typeof window != 'undefined') {
  2156. WEB_SOCKET_DISABLE_AUTO_INITIALIZATION = true;
  2157. }
  2158. /**
  2159. * Add the transport to your public io.transports array.
  2160. *
  2161. * @api private
  2162. */
  2163. io.transports.push('flashsocket');
  2164. })(
  2165. 'undefined' != typeof io ? io.Transport : module.exports
  2166. , 'undefined' != typeof io ? io : module.parent.exports
  2167. );
  2168. /* SWFObject v2.2 <http://code.google.com/p/swfobject/>
  2169. is released under the MIT License <http://www.opensource.org/licenses/mit-license.php>
  2170. */
  2171. if ('undefined' != typeof window) {
  2172. var swfobject=function(){var D="undefined",r="object",S="Shockwave Flash",W="ShockwaveFlash.ShockwaveFlash",q="application/x-shockwave-flash",R="SWFObjectExprInst",x="onreadystatechange",O=window,j=document,t=navigator,T=false,U=[h],o=[],N=[],I=[],l,Q,E,B,J=false,a=false,n,G,m=true,M=function(){var aa=typeof j.getElementById!=D&&typeof j.getElementsByTagName!=D&&typeof j.createElement!=D,ah=t.userAgent.toLowerCase(),Y=t.platform.toLowerCase(),ae=Y?/win/.test(Y):/win/.test(ah),ac=Y?/mac/.test(Y):/mac/.test(ah),af=/webkit/.test(ah)?parseFloat(ah.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):false,X=!+"\v1",ag=[0,0,0],ab=null;if(typeof t.plugins!=D&&typeof t.plugins[S]==r){ab=t.plugins[S].description;if(ab&&!(typeof t.mimeTypes!=D&&t.mimeTypes[q]&&!t.mimeTypes[q].enabledPlugin)){T=true;X=false;ab=ab.replace(/^.*\s+(\S+\s+\S+$)/,"$1");ag[0]=parseInt(ab.replace(/^(.*)\..*$/,"$1"),10);ag[1]=parseInt(ab.replace(/^.*\.(.*)\s.*$/,"$1"),10);ag[2]=/[a-zA-Z]/.test(ab)?parseInt(ab.replace(/^.*[a-zA-Z]+(.*)$/,"$1"),10):0}}else{if(typeof O[(['Active'].concat('Object').join('X'))]!=D){try{var ad=new window[(['Active'].concat('Object').join('X'))](W);if(ad){ab=ad.GetVariable("$version");if(ab){X=true;ab=ab.split(" ")[1].split(",");ag=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)]}}}catch(Z){}}}return{w3:aa,pv:ag,wk:af,ie:X,win:ae,mac:ac}}(),k=function(){if(!M.w3){return}if((typeof j.readyState!=D&&j.readyState=="complete")||(typeof j.readyState==D&&(j.getElementsByTagName("body")[0]||j.body))){f()}if(!J){if(typeof j.addEventListener!=D){j.addEventListener("DOMContentLoaded",f,false)}if(M.ie&&M.win){j.attachEvent(x,function(){if(j.readyState=="complete"){j.detachEvent(x,arguments.callee);f()}});if(O==top){(function(){if(J){return}try{j.documentElement.doScroll("left")}catch(X){setTimeout(arguments.callee,0);return}f()})()}}if(M.wk){(function(){if(J){return}if(!/loaded|complete/.test(j.readyState)){setTimeout(arguments.callee,0);return}f()})()}s(f)}}();function f(){if(J){return}try{var Z=j.getElementsByTagName("body")[0].appendChild(C("span"));Z.parentNode.removeChild(Z)}catch(aa){return}J=true;var X=U.length;for(var Y=0;Y<X;Y++){U[Y]()}}function K(X){if(J){X()}else{U[U.length]=X}}function s(Y){if(typeof O.addEventListener!=D){O.addEventListener("load",Y,false)}else{if(typeof j.addEventListener!=D){j.addEventListener("load",Y,false)}else{if(typeof O.attachEvent!=D){i(O,"onload",Y)}else{if(typeof O.onload=="function"){var X=O.onload;O.onload=function(){X();Y()}}else{O.onload=Y}}}}}function h(){if(T){V()}else{H()}}function V(){var X=j.getElementsByTagName("body")[0];var aa=C(r);aa.setAttribute("type",q);var Z=X.appendChild(aa);if(Z){var Y=0;(function(){if(typeof Z.GetVariable!=D){var ab=Z.GetVariable("$version");if(ab){ab=ab.split(" ")[1].split(",");M.pv=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)]}}else{if(Y<10){Y++;setTimeout(arguments.callee,10);return}}X.removeChild(aa);Z=null;H()})()}else{H()}}function H(){var ag=o.length;if(ag>0){for(var af=0;af<ag;af++){var Y=o[af].id;var ab=o[af].callbackFn;var aa={success:false,id:Y};if(M.pv[0]>0){var ae=c(Y);if(ae){if(F(o[af].swfVersion)&&!(M.wk&&M.wk<312)){w(Y,true);if(ab){aa.success=true;aa.ref=z(Y);ab(aa)}}else{if(o[af].expressInstall&&A()){var ai={};ai.data=o[af].expressInstall;ai.width=ae.getAttribute("width")||"0";ai.height=ae.getAttribute("height")||"0";if(ae.getAttribute("class")){ai.styleclass=ae.getAttribute("class")}if(ae.getAttribute("align")){ai.align=ae.getAttribute("align")}var ah={};var X=ae.getElementsByTagName("param");var ac=X.length;for(var ad=0;ad<ac;ad++){if(X[ad].getAttribute("name").toLowerCase()!="movie"){ah[X[ad].getAttribute("name")]=X[ad].getAttribute("value")}}P(ai,ah,Y,ab)}else{p(ae);if(ab){ab(aa)}}}}}else{w(Y,true);if(ab){var Z=z(Y);if(Z&&typeof Z.SetVariable!=D){aa.success=true;aa.ref=Z}ab(aa)}}}}}function z(aa){var X=null;var Y=c(aa);if(Y&&Y.nodeName=="OBJECT"){if(typeof Y.SetVariable!=D){X=Y}else{var Z=Y.getElementsByTagName(r)[0];if(Z){X=Z}}}return X}function A(){return !a&&F("6.0.65")&&(M.win||M.mac)&&!(M.wk&&M.wk<312)}function P(aa,ab,X,Z){a=true;E=Z||null;B={success:false,id:X};var ae=c(X);if(ae){if(ae.nodeName=="OBJECT"){l=g(ae);Q=null}else{l=ae;Q=X}aa.id=R;if(typeof aa.width==D||(!/%$/.test(aa.width)&&parseInt(aa.width,10)<310)){aa.width="310"}if(typeof aa.height==D||(!/%$/.test(aa.height)&&parseInt(aa.height,10)<137)){aa.height="137"}j.title=j.title.slice(0,47)+" - Flash Player Installation";var ad=M.ie&&M.win?(['Active'].concat('').join('X')):"PlugIn",ac="MMredirectURL="+O.location.toString().replace(/&/g,"%26")+"&MMplayerType="+ad+"&MMdoctitle="+j.title;if(typeof ab.flashvars!=D){ab.flashvars+="&"+ac}else{ab.flashvars=ac}if(M.ie&&M.win&&ae.readyState!=4){var Y=C("div");X+="SWFObjectNew";Y.setAttribute("id",X);ae.parentNode.insertBefore(Y,ae);ae.style.display="none";(function(){if(ae.readyState==4){ae.parentNode.removeChild(ae)}else{setTimeout(arguments.callee,10)}})()}u(aa,ab,X)}}function p(Y){if(M.ie&&M.win&&Y.readyState!=4){var X=C("div");Y.parentNode.insertBefore(X,Y);X.parentNode.replaceChild(g(Y),X);Y.style.display="none";(function(){if(Y.readyState==4){Y.parentNode.removeChild(Y)}else{setTimeout(arguments.callee,10)}})()}else{Y.parentNode.replaceChild(g(Y),Y)}}function g(ab){var aa=C("div");if(M.win&&M.ie){aa.innerHTML=ab.innerHTML}else{var Y=ab.getElementsByTagName(r)[0];if(Y){var ad=Y.childNodes;if(ad){var X=ad.length;for(var Z=0;Z<X;Z++){if(!(ad[Z].nodeType==1&&ad[Z].nodeName=="PARAM")&&!(ad[Z].nodeType==8)){aa.appendChild(ad[Z].cloneNode(true))}}}}}return aa}function u(ai,ag,Y){var X,aa=c(Y);if(M.wk&&M.wk<312){return X}if(aa){if(typeof ai.id==D){ai.id=Y}if(M.ie&&M.win){var ah="";for(var ae in ai){if(ai[ae]!=Object.prototype[ae]){if(ae.toLowerCase()=="data"){ag.movie=ai[ae]}else{if(ae.toLowerCase()=="styleclass"){ah+=' class="'+ai[ae]+'"'}else{if(ae.toLowerCase()!="classid"){ah+=" "+ae+'="'+ai[ae]+'"'}}}}}var af="";for(var ad in ag){if(ag[ad]!=Object.prototype[ad]){af+='<param name="'+ad+'" value="'+ag[ad]+'" />'}}aa.outerHTML='<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"'+ah+">"+af+"</object>";N[N.length]=ai.id;X=c(ai.id)}else{var Z=C(r);Z.setAttribute("type",q);for(var ac in ai){if(ai[ac]!=Object.prototype[ac]){if(ac.toLowerCase()=="styleclass"){Z.setAttribute("class",ai[ac])}else{if(ac.toLowerCase()!="classid"){Z.setAttribute(ac,ai[ac])}}}}for(var ab in ag){if(ag[ab]!=Object.prototype[ab]&&ab.toLowerCase()!="movie"){e(Z,ab,ag[ab])}}aa.parentNode.replaceChild(Z,aa);X=Z}}return X}function e(Z,X,Y){var aa=C("param");aa.setAttribute("name",X);aa.setAttribute("value",Y);Z.appendChild(aa)}function y(Y){var X=c(Y);if(X&&X.nodeName=="OBJECT"){if(M.ie&&M.win){X.style.display="none";(function(){if(X.readyState==4){b(Y)}else{setTimeout(arguments.callee,10)}})()}else{X.parentNode.removeChild(X)}}}function b(Z){var Y=c(Z);if(Y){for(var X in Y){if(typeof Y[X]=="function"){Y[X]=null}}Y.parentNode.removeChild(Y)}}function c(Z){var X=null;try{X=j.getElementById(Z)}catch(Y){}return X}function C(X){return j.createElement(X)}function i(Z,X,Y){Z.attachEvent(X,Y);I[I.length]=[Z,X,Y]}function F(Z){var Y=M.pv,X=Z.split(".");X[0]=parseInt(X[0],10);X[1]=parseInt(X[1],10)||0;X[2]=parseInt(X[2],10)||0;return(Y[0]>X[0]||(Y[0]==X[0]&&Y[1]>X[1])||(Y[0]==X[0]&&Y[1]==X[1]&&Y[2]>=X[2]))?true:false}function v(ac,Y,ad,ab){if(M.ie&&M.mac){return}var aa=j.getElementsByTagName("head")[0];if(!aa){return}var X=(ad&&typeof ad=="string")?ad:"screen";if(ab){n=null;G=null}if(!n||G!=X){var Z=C("style");Z.setAttribute("type","text/css");Z.setAttribute("media",X);n=aa.appendChild(Z);if(M.ie&&M.win&&typeof j.styleSheets!=D&&j.styleSheets.length>0){n=j.styleSheets[j.styleSheets.length-1]}G=X}if(M.ie&&M.win){if(n&&typeof n.addRule==r){n.addRule(ac,Y)}}else{if(n&&typeof j.createTextNode!=D){n.appendChild(j.createTextNode(ac+" {"+Y+"}"))}}}function w(Z,X){if(!m){return}var Y=X?"visible":"hidden";if(J&&c(Z)){c(Z).style.visibility=Y}else{v("#"+Z,"visibility:"+Y)}}function L(Y){var Z=/[\\\"<>\.;]/;var X=Z.exec(Y)!=null;return X&&typeof encodeURIComponent!=D?encodeURIComponent(Y):Y}var d=function(){if(M.ie&&M.win){window.attachEvent("onunload",function(){var ac=I.length;for(var ab=0;ab<ac;ab++){I[ab][0].detachEvent(I[ab][1],I[ab][2])}var Z=N.length;for(var aa=0;aa<Z;aa++){y(N[aa])}for(var Y in M){M[Y]=null}M=null;for(var X in swfobject){swfobject[X]=null}swfobject=null})}}();return{registerObject:function(ab,X,aa,Z){if(M.w3&&ab&&X){var Y={};Y.id=ab;Y.swfVersion=X;Y.expressInstall=aa;Y.callbackFn=Z;o[o.length]=Y;w(ab,false)}else{if(Z){Z({success:false,id:ab})}}},getObjectById:function(X){if(M.w3){return z(X)}},embedSWF:function(ab,ah,ae,ag,Y,aa,Z,ad,af,ac){var X={success:false,id:ah};if(M.w3&&!(M.wk&&M.wk<312)&&ab&&ah&&ae&&ag&&Y){w(ah,false);K(function(){ae+="";ag+="";var aj={};if(af&&typeof af===r){for(var al in af){aj[al]=af[al]}}aj.data=ab;aj.width=ae;aj.height=ag;var am={};if(ad&&typeof ad===r){for(var ak in ad){am[ak]=ad[ak]}}if(Z&&typeof Z===r){for(var ai in Z){if(typeof am.flashvars!=D){am.flashvars+="&"+ai+"="+Z[ai]}else{am.flashvars=ai+"="+Z[ai]}}}if(F(Y)){var an=u(aj,am,ah);if(aj.id==ah){w(ah,true)}X.success=true;X.ref=an}else{if(aa&&A()){aj.data=aa;P(aj,am,ah,ac);return}else{w(ah,true)}}if(ac){ac(X)}})}else{if(ac){ac(X)}}},switchOffAutoHideShow:function(){m=false},ua:M,getFlashPlayerVersion:function(){return{major:M.pv[0],minor:M.pv[1],release:M.pv[2]}},hasFlashPlayerVersion:F,createSWF:function(Z,Y,X){if(M.w3){return u(Z,Y,X)}else{return undefined}},showExpressInstall:function(Z,aa,X,Y){if(M.w3&&A()){P(Z,aa,X,Y)}},removeSWF:function(X){if(M.w3){y(X)}},createCSS:function(aa,Z,Y,X){if(M.w3){v(aa,Z,Y,X)}},addDomLoadEvent:K,addLoadEvent:s,getQueryParamValue:function(aa){var Z=j.location.search||j.location.hash;if(Z){if(/\?/.test(Z)){Z=Z.split("?")[1]}if(aa==null){return L(Z)}var Y=Z.split("&");for(var X=0;X<Y.length;X++){if(Y[X].substring(0,Y[X].indexOf("="))==aa){return L(Y[X].substring((Y[X].indexOf("=")+1)))}}}return""},expressInstallCallback:function(){if(a){var X=c(R);if(X&&l){X.parentNode.replaceChild(l,X);if(Q){w(Q,true);if(M.ie&&M.win){l.style.display="block"}}if(E){E(B)}}a=false}}}}();
  2173. }
  2174. // Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
  2175. // License: New BSD License
  2176. // Reference: http://dev.w3.org/html5/websockets/
  2177. // Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol
  2178. (function() {
  2179. if ('undefined' == typeof window || window.WebSocket) return;
  2180. var console = window.console;
  2181. if (!console || !console.log || !console.error) {
  2182. console = {log: function(){ }, error: function(){ }};
  2183. }
  2184. if (!swfobject.hasFlashPlayerVersion("10.0.0")) {
  2185. console.error("Flash Player >= 10.0.0 is required.");
  2186. return;
  2187. }
  2188. if (location.protocol == "file:") {
  2189. console.error(
  2190. "WARNING: web-socket-js doesn't work in file:///... URL " +
  2191. "unless you set Flash Security Settings properly. " +
  2192. "Open the page via Web server i.e. http://...");
  2193. }
  2194. /**
  2195. * This class represents a faux web socket.
  2196. * @param {string} url
  2197. * @param {array or string} protocols
  2198. * @param {string} proxyHost
  2199. * @param {int} proxyPort
  2200. * @param {string} headers
  2201. */
  2202. WebSocket = function(url, protocols, proxyHost, proxyPort, headers) {
  2203. var self = this;
  2204. self.__id = WebSocket.__nextId++;
  2205. WebSocket.__instances[self.__id] = self;
  2206. self.readyState = WebSocket.CONNECTING;
  2207. self.bufferedAmount = 0;
  2208. self.__events = {};
  2209. if (!protocols) {
  2210. protocols = [];
  2211. } else if (typeof protocols == "string") {
  2212. protocols = [protocols];
  2213. }
  2214. // Uses setTimeout() to make sure __createFlash() runs after the caller sets ws.onopen etc.
  2215. // Otherwise, when onopen fires immediately, onopen is called before it is set.
  2216. setTimeout(function() {
  2217. WebSocket.__addTask(function() {
  2218. WebSocket.__flash.create(
  2219. self.__id, url, protocols, proxyHost || null, proxyPort || 0, headers || null);
  2220. });
  2221. }, 0);
  2222. };
  2223. /**
  2224. * Send data to the web socket.
  2225. * @param {string} data The data to send to the socket.
  2226. * @return {boolean} True for success, false for failure.
  2227. */
  2228. WebSocket.prototype.send = function(data) {
  2229. if (this.readyState == WebSocket.CONNECTING) {
  2230. throw "INVALID_STATE_ERR: Web Socket connection has not been established";
  2231. }
  2232. // We use encodeURIComponent() here, because FABridge doesn't work if
  2233. // the argument includes some characters. We don't use escape() here
  2234. // because of this:
  2235. // https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Functions#escape_and_unescape_Functions
  2236. // But it looks decodeURIComponent(encodeURIComponent(s)) doesn't
  2237. // preserve all Unicode characters either e.g. "\uffff" in Firefox.
  2238. // Note by wtritch: Hopefully this will not be necessary using ExternalInterface. Will require
  2239. // additional testing.
  2240. var result = WebSocket.__flash.send(this.__id, encodeURIComponent(data));
  2241. if (result < 0) { // success
  2242. return true;
  2243. } else {
  2244. this.bufferedAmount += result;
  2245. return false;
  2246. }
  2247. };
  2248. /**
  2249. * Close this web socket gracefully.
  2250. */
  2251. WebSocket.prototype.close = function() {
  2252. if (this.readyState == WebSocket.CLOSED || this.readyState == WebSocket.CLOSING) {
  2253. return;
  2254. }
  2255. this.readyState = WebSocket.CLOSING;
  2256. WebSocket.__flash.close(this.__id);
  2257. };
  2258. /**
  2259. * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
  2260. *
  2261. * @param {string} type
  2262. * @param {function} listener
  2263. * @param {boolean} useCapture
  2264. * @return void
  2265. */
  2266. WebSocket.prototype.addEventListener = function(type, listener, useCapture) {
  2267. if (!(type in this.__events)) {
  2268. this.__events[type] = [];
  2269. }
  2270. this.__events[type].push(listener);
  2271. };
  2272. /**
  2273. * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
  2274. *
  2275. * @param {string} type
  2276. * @param {function} listener
  2277. * @param {boolean} useCapture
  2278. * @return void
  2279. */
  2280. WebSocket.prototype.removeEventListener = function(type, listener, useCapture) {
  2281. if (!(type in this.__events)) return;
  2282. var events = this.__events[type];
  2283. for (var i = events.length - 1; i >= 0; --i) {
  2284. if (events[i] === listener) {
  2285. events.splice(i, 1);
  2286. break;
  2287. }
  2288. }
  2289. };
  2290. /**
  2291. * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
  2292. *
  2293. * @param {Event} event
  2294. * @return void
  2295. */
  2296. WebSocket.prototype.dispatchEvent = function(event) {
  2297. var events = this.__events[event.type] || [];
  2298. for (var i = 0; i < events.length; ++i) {
  2299. events[i](event);
  2300. }
  2301. var handler = this["on" + event.type];
  2302. if (handler) handler(event);
  2303. };
  2304. /**
  2305. * Handles an event from Flash.
  2306. * @param {Object} flashEvent
  2307. */
  2308. WebSocket.prototype.__handleEvent = function(flashEvent) {
  2309. if ("readyState" in flashEvent) {
  2310. this.readyState = flashEvent.readyState;
  2311. }
  2312. if ("protocol" in flashEvent) {
  2313. this.protocol = flashEvent.protocol;
  2314. }
  2315. var jsEvent;
  2316. if (flashEvent.type == "open" || flashEvent.type == "error") {
  2317. jsEvent = this.__createSimpleEvent(flashEvent.type);
  2318. } else if (flashEvent.type == "close") {
  2319. // TODO implement jsEvent.wasClean
  2320. jsEvent = this.__createSimpleEvent("close");
  2321. } else if (flashEvent.type == "message") {
  2322. var data = decodeURIComponent(flashEvent.message);
  2323. jsEvent = this.__createMessageEvent("message", data);
  2324. } else {
  2325. throw "unknown event type: " + flashEvent.type;
  2326. }
  2327. this.dispatchEvent(jsEvent);
  2328. };
  2329. WebSocket.prototype.__createSimpleEvent = function(type) {
  2330. if (document.createEvent && window.Event) {
  2331. var event = document.createEvent("Event");
  2332. event.initEvent(type, false, false);
  2333. return event;
  2334. } else {
  2335. return {type: type, bubbles: false, cancelable: false};
  2336. }
  2337. };
  2338. WebSocket.prototype.__createMessageEvent = function(type, data) {
  2339. if (document.createEvent && window.MessageEvent && !window.opera) {
  2340. var event = document.createEvent("MessageEvent");
  2341. event.initMessageEvent("message", false, false, data, null, null, window, null);
  2342. return event;
  2343. } else {
  2344. // IE and Opera, the latter one truncates the data parameter after any 0x00 bytes.
  2345. return {type: type, data: data, bubbles: false, cancelable: false};
  2346. }
  2347. };
  2348. /**
  2349. * Define the WebSocket readyState enumeration.
  2350. */
  2351. WebSocket.CONNECTING = 0;
  2352. WebSocket.OPEN = 1;
  2353. WebSocket.CLOSING = 2;
  2354. WebSocket.CLOSED = 3;
  2355. WebSocket.__flash = null;
  2356. WebSocket.__instances = {};
  2357. WebSocket.__tasks = [];
  2358. WebSocket.__nextId = 0;
  2359. /**
  2360. * Load a new flash security policy file.
  2361. * @param {string} url
  2362. */
  2363. WebSocket.loadFlashPolicyFile = function(url){
  2364. // alert("load flash policy file: " + url)
  2365. WebSocket.__addTask(function() {
  2366. WebSocket.__flash.loadManualPolicyFile(url);
  2367. });
  2368. };
  2369. /**
  2370. * Loads WebSocketMain.swf and creates WebSocketMain object in Flash.
  2371. */
  2372. WebSocket.__initialize = function() {
  2373. if (WebSocket.__flash) return;
  2374. if (WebSocket.__swfLocation) {
  2375. // For backword compatibility.
  2376. window.WEB_SOCKET_SWF_LOCATION = WebSocket.__swfLocation;
  2377. }
  2378. if (!window.WEB_SOCKET_SWF_LOCATION) {
  2379. console.error("[WebSocket] set WEB_SOCKET_SWF_LOCATION to location of WebSocketMain.swf");
  2380. return;
  2381. }
  2382. var container = document.createElement("div");
  2383. container.id = "webSocketContainer";
  2384. // Hides Flash box. We cannot use display: none or visibility: hidden because it prevents
  2385. // Flash from loading at least in IE. So we move it out of the screen at (-100, -100).
  2386. // But this even doesn't work with Flash Lite (e.g. in Droid Incredible). So with Flash
  2387. // Lite, we put it at (0, 0). This shows 1x1 box visible at left-top corner but this is
  2388. // the best we can do as far as we know now.
  2389. container.style.position = "absolute";
  2390. if (WebSocket.__isFlashLite()) {
  2391. container.style.left = "0px";
  2392. container.style.top = "0px";
  2393. } else {
  2394. container.style.left = "-100px";
  2395. container.style.top = "-100px";
  2396. }
  2397. var holder = document.createElement("div");
  2398. holder.id = "webSocketFlash";
  2399. container.appendChild(holder);
  2400. document.body.appendChild(container);
  2401. // See this article for hasPriority:
  2402. // http://help.adobe.com/en_US/as3/mobile/WS4bebcd66a74275c36cfb8137124318eebc6-7ffd.html
  2403. swfobject.embedSWF(
  2404. WEB_SOCKET_SWF_LOCATION,
  2405. "webSocketFlash",
  2406. "1" /* width */,
  2407. "1" /* height */,
  2408. "10.0.0" /* SWF version */,
  2409. null,
  2410. null,
  2411. {hasPriority: true, swliveconnect : true, allowScriptAccess: "always"},
  2412. null,
  2413. function(e) {
  2414. if (!e.success) {
  2415. console.error("[WebSocket] swfobject.embedSWF failed");
  2416. }
  2417. });
  2418. };
  2419. /**
  2420. * Called by Flash to notify JS that it's fully loaded and ready
  2421. * for communication.
  2422. */
  2423. WebSocket.__onFlashInitialized = function() {
  2424. // alert("flash initialized");
  2425. // We need to set a timeout here to avoid round-trip calls
  2426. // to flash during the initialization process.
  2427. setTimeout(function() {
  2428. WebSocket.__flash = document.getElementById("webSocketFlash");
  2429. // alert("websocket_flash " + WebSocket.__flash);
  2430. console.dir(WebSocket.__flash);
  2431. WebSocket.__flash.setCallerUrl(location.href);
  2432. WebSocket.__flash.setDebug(!!window.WEB_SOCKET_DEBUG);
  2433. for (var i = 0; i < WebSocket.__tasks.length; ++i) {
  2434. WebSocket.__tasks[i]();
  2435. }
  2436. WebSocket.__tasks = [];
  2437. }, 0);
  2438. };
  2439. /**
  2440. * Called by Flash to notify WebSockets events are fired.
  2441. */
  2442. WebSocket.__onFlashEvent = function() {
  2443. setTimeout(function() {
  2444. try {
  2445. // Gets events using receiveEvents() instead of getting it from event object
  2446. // of Flash event. This is to make sure to keep message order.
  2447. // It seems sometimes Flash events don't arrive in the same order as they are sent.
  2448. var events = WebSocket.__flash.receiveEvents();
  2449. for (var i = 0; i < events.length; ++i) {
  2450. WebSocket.__instances[events[i].webSocketId].__handleEvent(events[i]);
  2451. }
  2452. } catch (e) {
  2453. console.error(e);
  2454. }
  2455. }, 0);
  2456. return true;
  2457. };
  2458. // Called by Flash.
  2459. WebSocket.__log = function(message) {
  2460. console.log(decodeURIComponent(message));
  2461. };
  2462. // Called by Flash.
  2463. WebSocket.__error = function(message) {
  2464. console.error(decodeURIComponent(message));
  2465. };
  2466. WebSocket.__addTask = function(task) {
  2467. if (WebSocket.__flash) {
  2468. task();
  2469. } else {
  2470. WebSocket.__tasks.push(task);
  2471. }
  2472. };
  2473. /**
  2474. * Test if the browser is running flash lite.
  2475. * @return {boolean} True if flash lite is running, false otherwise.
  2476. */
  2477. WebSocket.__isFlashLite = function() {
  2478. if (!window.navigator || !window.navigator.mimeTypes) {
  2479. return false;
  2480. }
  2481. var mimeType = window.navigator.mimeTypes["application/x-shockwave-flash"];
  2482. if (!mimeType || !mimeType.enabledPlugin || !mimeType.enabledPlugin.filename) {
  2483. return false;
  2484. }
  2485. return mimeType.enabledPlugin.filename.match(/flashlite/i) ? true : false;
  2486. };
  2487. if (!window.WEB_SOCKET_DISABLE_AUTO_INITIALIZATION) {
  2488. if (window.addEventListener) {
  2489. window.addEventListener("load", function(){
  2490. WebSocket.__initialize();
  2491. }, false);
  2492. } else {
  2493. window.attachEvent("onload", function(){
  2494. WebSocket.__initialize();
  2495. });
  2496. }
  2497. }
  2498. })();
  2499. /**
  2500. * socket.io
  2501. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  2502. * MIT Licensed
  2503. */
  2504. (function (exports, io, global) {
  2505. /**
  2506. * Expose constructor.
  2507. *
  2508. * @api public
  2509. */
  2510. exports.XHR = XHR;
  2511. /**
  2512. * XHR constructor
  2513. *
  2514. * @costructor
  2515. * @api public
  2516. */
  2517. function XHR (socket) {
  2518. if (!socket) return;
  2519. io.Transport.apply(this, arguments);
  2520. this.sendBuffer = [];
  2521. };
  2522. /**
  2523. * Inherits from Transport.
  2524. */
  2525. io.util.inherit(XHR, io.Transport);
  2526. /**
  2527. * Establish a connection
  2528. *
  2529. * @returns {Transport}
  2530. * @api public
  2531. */
  2532. XHR.prototype.open = function () {
  2533. this.socket.setBuffer(false);
  2534. this.onOpen();
  2535. this.get();
  2536. // we need to make sure the request succeeds since we have no indication
  2537. // whether the request opened or not until it succeeded.
  2538. this.setCloseTimeout();
  2539. return this;
  2540. };
  2541. /**
  2542. * Check if we need to send data to the Socket.IO server, if we have data in our
  2543. * buffer we encode it and forward it to the `post` method.
  2544. *
  2545. * @api private
  2546. */
  2547. XHR.prototype.payload = function (payload) {
  2548. var msgs = [];
  2549. for (var i = 0, l = payload.length; i < l; i++) {
  2550. msgs.push(io.parser.encodePacket(payload[i]));
  2551. }
  2552. this.send(io.parser.encodePayload(msgs));
  2553. };
  2554. /**
  2555. * Send data to the Socket.IO server.
  2556. *
  2557. * @param data The message
  2558. * @returns {Transport}
  2559. * @api public
  2560. */
  2561. XHR.prototype.send = function (data) {
  2562. this.post(data);
  2563. return this;
  2564. };
  2565. /**
  2566. * Posts a encoded message to the Socket.IO server.
  2567. *
  2568. * @param {String} data A encoded message.
  2569. * @api private
  2570. */
  2571. function empty () { };
  2572. XHR.prototype.post = function (data) {
  2573. var self = this;
  2574. this.socket.setBuffer(true);
  2575. function stateChange () {
  2576. if (this.readyState == 4) {
  2577. this.onreadystatechange = empty;
  2578. self.posting = false;
  2579. if (this.status == 200){
  2580. self.socket.setBuffer(false);
  2581. } else {
  2582. self.onClose();
  2583. }
  2584. }
  2585. }
  2586. function onload () {
  2587. this.onload = empty;
  2588. self.socket.setBuffer(false);
  2589. };
  2590. this.sendXHR = this.request('POST');
  2591. if (global.XDomainRequest && this.sendXHR instanceof XDomainRequest) {
  2592. this.sendXHR.onload = this.sendXHR.onerror = onload;
  2593. } else {
  2594. this.sendXHR.onreadystatechange = stateChange;
  2595. }
  2596. this.sendXHR.send(data);
  2597. };
  2598. /**
  2599. * Disconnects the established `XHR` connection.
  2600. *
  2601. * @returns {Transport}
  2602. * @api public
  2603. */
  2604. XHR.prototype.close = function () {
  2605. this.onClose();
  2606. return this;
  2607. };
  2608. /**
  2609. * Generates a configured XHR request
  2610. *
  2611. * @param {String} url The url that needs to be requested.
  2612. * @param {String} method The method the request should use.
  2613. * @returns {XMLHttpRequest}
  2614. * @api private
  2615. */
  2616. XHR.prototype.request = function (method) {
  2617. var req = io.util.request(this.socket.isXDomain())
  2618. , query = io.util.query(this.socket.options.query, 't=' + +new Date);
  2619. req.open(method || 'GET', this.prepareUrl() + query, true);
  2620. if (method == 'POST') {
  2621. try {
  2622. if (req.setRequestHeader) {
  2623. req.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');
  2624. } else {
  2625. // XDomainRequest
  2626. req.contentType = 'text/plain';
  2627. }
  2628. } catch (e) {}
  2629. }
  2630. return req;
  2631. };
  2632. /**
  2633. * Returns the scheme to use for the transport URLs.
  2634. *
  2635. * @api private
  2636. */
  2637. XHR.prototype.scheme = function () {
  2638. return this.socket.options.secure ? 'https' : 'http';
  2639. };
  2640. /**
  2641. * Check if the XHR transports are supported
  2642. *
  2643. * @param {Boolean} xdomain Check if we support cross domain requests.
  2644. * @returns {Boolean}
  2645. * @api public
  2646. */
  2647. XHR.check = function (socket, xdomain) {
  2648. try {
  2649. var request = io.util.request(xdomain),
  2650. usesXDomReq = (global.XDomainRequest && request instanceof XDomainRequest),
  2651. socketProtocol = (socket && socket.options && socket.options.secure ? 'https:' : 'http:'),
  2652. isXProtocol = (socketProtocol != global.location.protocol);
  2653. if (request && !(usesXDomReq && isXProtocol)) {
  2654. return true;
  2655. }
  2656. } catch(e) {}
  2657. return false;
  2658. };
  2659. /**
  2660. * Check if the XHR transport supports cross domain requests.
  2661. *
  2662. * @returns {Boolean}
  2663. * @api public
  2664. */
  2665. XHR.xdomainCheck = function (socket) {
  2666. return XHR.check(socket, true);
  2667. };
  2668. })(
  2669. 'undefined' != typeof io ? io.Transport : module.exports
  2670. , 'undefined' != typeof io ? io : module.parent.exports
  2671. , this
  2672. );
  2673. /**
  2674. * socket.io
  2675. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  2676. * MIT Licensed
  2677. */
  2678. (function (exports, io, global) {
  2679. /**
  2680. * Expose constructor.
  2681. */
  2682. exports['xhr-polling'] = XHRPolling;
  2683. /**
  2684. * The XHR-polling transport uses long polling XHR requests to create a
  2685. * "persistent" connection with the server.
  2686. *
  2687. * @constructor
  2688. * @api public
  2689. */
  2690. function XHRPolling () {
  2691. io.Transport.XHR.apply(this, arguments);
  2692. };
  2693. /**
  2694. * Inherits from XHR transport.
  2695. */
  2696. io.util.inherit(XHRPolling, io.Transport.XHR);
  2697. /**
  2698. * Merge the properties from XHR transport
  2699. */
  2700. io.util.merge(XHRPolling, io.Transport.XHR);
  2701. /**
  2702. * Transport name
  2703. *
  2704. * @api public
  2705. */
  2706. XHRPolling.prototype.name = 'xhr-polling';
  2707. /**
  2708. * Indicates whether heartbeats is enabled for this transport
  2709. *
  2710. * @api private
  2711. */
  2712. XHRPolling.prototype.heartbeats = function () {
  2713. return false;
  2714. };
  2715. /**
  2716. * Establish a connection, for iPhone and Android this will be done once the page
  2717. * is loaded.
  2718. *
  2719. * @returns {Transport} Chaining.
  2720. * @api public
  2721. */
  2722. XHRPolling.prototype.open = function () {
  2723. var self = this;
  2724. io.Transport.XHR.prototype.open.call(self);
  2725. return false;
  2726. };
  2727. /**
  2728. * Starts a XHR request to wait for incoming messages.
  2729. *
  2730. * @api private
  2731. */
  2732. function empty () {};
  2733. XHRPolling.prototype.get = function () {
  2734. if (!this.isOpen) return;
  2735. var self = this;
  2736. function stateChange () {
  2737. if (this.readyState == 4) {
  2738. this.onreadystatechange = empty;
  2739. if (this.status == 200) {
  2740. self.onData(this.responseText);
  2741. self.get();
  2742. } else {
  2743. self.onClose();
  2744. }
  2745. }
  2746. };
  2747. function onload () {
  2748. this.onload = empty;
  2749. this.onerror = empty;
  2750. self.onData(this.responseText);
  2751. self.get();
  2752. };
  2753. function onerror () {
  2754. self.onClose();
  2755. };
  2756. this.xhr = this.request();
  2757. if (global.XDomainRequest && this.xhr instanceof XDomainRequest) {
  2758. this.xhr.onload = onload;
  2759. this.xhr.onerror = onerror;
  2760. } else {
  2761. this.xhr.onreadystatechange = stateChange;
  2762. }
  2763. this.xhr.send(null);
  2764. };
  2765. /**
  2766. * Handle the unclean close behavior.
  2767. *
  2768. * @api private
  2769. */
  2770. XHRPolling.prototype.onClose = function () {
  2771. io.Transport.XHR.prototype.onClose.call(this);
  2772. if (this.xhr) {
  2773. this.xhr.onreadystatechange = this.xhr.onload = this.xhr.onerror = empty;
  2774. try {
  2775. this.xhr.abort();
  2776. } catch(e){}
  2777. this.xhr = null;
  2778. }
  2779. };
  2780. /**
  2781. * Webkit based browsers show a infinit spinner when you start a XHR request
  2782. * before the browsers onload event is called so we need to defer opening of
  2783. * the transport until the onload event is called. Wrapping the cb in our
  2784. * defer method solve this.
  2785. *
  2786. * @param {Socket} socket The socket instance that needs a transport
  2787. * @param {Function} fn The callback
  2788. * @api private
  2789. */
  2790. XHRPolling.prototype.ready = function (socket, fn) {
  2791. var self = this;
  2792. io.util.defer(function () {
  2793. fn.call(self);
  2794. });
  2795. };
  2796. /**
  2797. * Add the transport to your public io.transports array.
  2798. *
  2799. * @api private
  2800. */
  2801. io.transports.push('xhr-polling');
  2802. })(
  2803. 'undefined' != typeof io ? io.Transport : module.exports
  2804. , 'undefined' != typeof io ? io : module.parent.exports
  2805. , this
  2806. );
  2807. /**
  2808. * socket.io
  2809. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  2810. * MIT Licensed
  2811. */
  2812. (function (exports, io, global) {
  2813. /**
  2814. * There is a way to hide the loading indicator in Firefox. If you create and
  2815. * remove a iframe it will stop showing the current loading indicator.
  2816. * Unfortunately we can't feature detect that and UA sniffing is evil.
  2817. *
  2818. * @api private
  2819. */
  2820. var indicator = global.document && "MozAppearance" in
  2821. global.document.documentElement.style;
  2822. /**
  2823. * Expose constructor.
  2824. */
  2825. exports['jsonp-polling'] = JSONPPolling;
  2826. /**
  2827. * The JSONP transport creates an persistent connection by dynamically
  2828. * inserting a script tag in the page. This script tag will receive the
  2829. * information of the Socket.IO server. When new information is received
  2830. * it creates a new script tag for the new data stream.
  2831. *
  2832. * @constructor
  2833. * @extends {io.Transport.xhr-polling}
  2834. * @api public
  2835. */
  2836. function JSONPPolling (socket) {
  2837. io.Transport['xhr-polling'].apply(this, arguments);
  2838. this.index = io.j.length;
  2839. var self = this;
  2840. io.j.push(function (msg) {
  2841. self._(msg);
  2842. });
  2843. };
  2844. /**
  2845. * Inherits from XHR polling transport.
  2846. */
  2847. io.util.inherit(JSONPPolling, io.Transport['xhr-polling']);
  2848. /**
  2849. * Transport name
  2850. *
  2851. * @api public
  2852. */
  2853. JSONPPolling.prototype.name = 'jsonp-polling';
  2854. /**
  2855. * Posts a encoded message to the Socket.IO server using an iframe.
  2856. * The iframe is used because script tags can create POST based requests.
  2857. * The iframe is positioned outside of the view so the user does not
  2858. * notice it's existence.
  2859. *
  2860. * @param {String} data A encoded message.
  2861. * @api private
  2862. */
  2863. JSONPPolling.prototype.post = function (data) {
  2864. var self = this
  2865. , query = io.util.query(
  2866. this.socket.options.query
  2867. , 't='+ (+new Date) + '&i=' + this.index
  2868. );
  2869. if (!this.form) {
  2870. var form = document.createElement('form')
  2871. , area = document.createElement('textarea')
  2872. , id = this.iframeId = 'socketio_iframe_' + this.index
  2873. , iframe;
  2874. form.className = 'socketio';
  2875. form.style.position = 'absolute';
  2876. form.style.top = '0px';
  2877. form.style.left = '0px';
  2878. form.style.display = 'none';
  2879. form.target = id;
  2880. form.method = 'POST';
  2881. form.setAttribute('accept-charset', 'utf-8');
  2882. area.name = 'd';
  2883. form.appendChild(area);
  2884. document.body.appendChild(form);
  2885. this.form = form;
  2886. this.area = area;
  2887. }
  2888. this.form.action = this.prepareUrl() + query;
  2889. function complete () {
  2890. initIframe();
  2891. self.socket.setBuffer(false);
  2892. };
  2893. function initIframe () {
  2894. if (self.iframe) {
  2895. self.form.removeChild(self.iframe);
  2896. }
  2897. try {
  2898. // ie6 dynamic iframes with target="" support (thanks Chris Lambacher)
  2899. iframe = document.createElement('<iframe name="'+ self.iframeId +'">');
  2900. } catch (e) {
  2901. iframe = document.createElement('iframe');
  2902. iframe.name = self.iframeId;
  2903. }
  2904. iframe.id = self.iframeId;
  2905. self.form.appendChild(iframe);
  2906. self.iframe = iframe;
  2907. };
  2908. initIframe();
  2909. // we temporarily stringify until we figure out how to prevent
  2910. // browsers from turning `\n` into `\r\n` in form inputs
  2911. this.area.value = io.JSON.stringify(data);
  2912. try {
  2913. this.form.submit();
  2914. } catch(e) {}
  2915. if (this.iframe.attachEvent) {
  2916. iframe.onreadystatechange = function () {
  2917. if (self.iframe.readyState == 'complete') {
  2918. complete();
  2919. }
  2920. };
  2921. } else {
  2922. this.iframe.onload = complete;
  2923. }
  2924. this.socket.setBuffer(true);
  2925. };
  2926. /**
  2927. * Creates a new JSONP poll that can be used to listen
  2928. * for messages from the Socket.IO server.
  2929. *
  2930. * @api private
  2931. */
  2932. JSONPPolling.prototype.get = function () {
  2933. var self = this
  2934. , script = document.createElement('script')
  2935. , query = io.util.query(
  2936. this.socket.options.query
  2937. , 't='+ (+new Date) + '&i=' + this.index
  2938. );
  2939. if (this.script) {
  2940. this.script.parentNode.removeChild(this.script);
  2941. this.script = null;
  2942. }
  2943. script.async = true;
  2944. script.src = this.prepareUrl() + query;
  2945. script.onerror = function () {
  2946. self.onClose();
  2947. };
  2948. var insertAt = document.getElementsByTagName('script')[0]
  2949. insertAt.parentNode.insertBefore(script, insertAt);
  2950. this.script = script;
  2951. if (indicator) {
  2952. setTimeout(function () {
  2953. var iframe = document.createElement('iframe');
  2954. document.body.appendChild(iframe);
  2955. document.body.removeChild(iframe);
  2956. }, 100);
  2957. }
  2958. };
  2959. /**
  2960. * Callback function for the incoming message stream from the Socket.IO server.
  2961. *
  2962. * @param {String} data The message
  2963. * @api private
  2964. */
  2965. JSONPPolling.prototype._ = function (msg) {
  2966. this.onData(msg);
  2967. if (this.isOpen) {
  2968. this.get();
  2969. }
  2970. return this;
  2971. };
  2972. /**
  2973. * The indicator hack only works after onload
  2974. *
  2975. * @param {Socket} socket The socket instance that needs a transport
  2976. * @param {Function} fn The callback
  2977. * @api private
  2978. */
  2979. JSONPPolling.prototype.ready = function (socket, fn) {
  2980. var self = this;
  2981. if (!indicator) return fn.call(this);
  2982. io.util.load(function () {
  2983. fn.call(self);
  2984. });
  2985. };
  2986. /**
  2987. * Checks if browser supports this transport.
  2988. *
  2989. * @return {Boolean}
  2990. * @api public
  2991. */
  2992. JSONPPolling.check = function () {
  2993. return 'document' in global;
  2994. };
  2995. /**
  2996. * Check if cross domain requests are supported
  2997. *
  2998. * @returns {Boolean}
  2999. * @api public
  3000. */
  3001. JSONPPolling.xdomainCheck = function () {
  3002. return true;
  3003. };
  3004. /**
  3005. * Add the transport to your public io.transports array.
  3006. *
  3007. * @api private
  3008. */
  3009. io.transports.push('jsonp-polling');
  3010. })(
  3011. 'undefined' != typeof io ? io.Transport : module.exports
  3012. , 'undefined' != typeof io ? io : module.parent.exports
  3013. , this
  3014. );
  3015. /**
  3016. * socket.io
  3017. * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  3018. * MIT Licensed
  3019. */
  3020. (function (exports, io) {
  3021. /**
  3022. * Expose constructor.
  3023. */
  3024. exports.htmlfile = HTMLFile;
  3025. /**
  3026. * The HTMLFile transport creates a `forever iframe` based transport
  3027. * for Internet Explorer. Regular forever iframe implementations will
  3028. * continuously trigger the browsers buzy indicators. If the forever iframe
  3029. * is created inside a `htmlfile` these indicators will not be trigged.
  3030. *
  3031. * @constructor
  3032. * @extends {io.Transport.XHR}
  3033. * @api public
  3034. */
  3035. function HTMLFile (socket) {
  3036. io.Transport.XHR.apply(this, arguments);
  3037. };
  3038. /**
  3039. * Inherits from XHR transport.
  3040. */
  3041. io.util.inherit(HTMLFile, io.Transport.XHR);
  3042. /**
  3043. * Transport name
  3044. *
  3045. * @api public
  3046. */
  3047. HTMLFile.prototype.name = 'htmlfile';
  3048. /**
  3049. * Creates a new Ac...eX `htmlfile` with a forever loading iframe
  3050. * that can be used to listen to messages. Inside the generated
  3051. * `htmlfile` a reference will be made to the HTMLFile transport.
  3052. *
  3053. * @api private
  3054. */
  3055. HTMLFile.prototype.get = function () {
  3056. this.doc = new window[(['Active'].concat('Object').join('X'))]('htmlfile');
  3057. this.doc.open();
  3058. this.doc.write('<html></html>');
  3059. this.doc.close();
  3060. this.doc.parentWindow.s = this;
  3061. var iframeC = this.doc.createElement('div');
  3062. iframeC.className = 'socketio';
  3063. this.doc.body.appendChild(iframeC);
  3064. this.iframe = this.doc.createElement('iframe');
  3065. iframeC.appendChild(this.iframe);
  3066. var self = this
  3067. , query = io.util.query(this.socket.options.query, 't='+ +new Date);
  3068. this.iframe.src = this.prepareUrl() + query;
  3069. io.util.on(window, 'unload', function () {
  3070. self.destroy();
  3071. });
  3072. };
  3073. /**
  3074. * The Socket.IO server will write script tags inside the forever
  3075. * iframe, this function will be used as callback for the incoming
  3076. * information.
  3077. *
  3078. * @param {String} data The message
  3079. * @param {document} doc Reference to the context
  3080. * @api private
  3081. */
  3082. HTMLFile.prototype._ = function (data, doc) {
  3083. this.onData(data);
  3084. try {
  3085. var script = doc.getElementsByTagName('script')[0];
  3086. script.parentNode.removeChild(script);
  3087. } catch (e) { }
  3088. };
  3089. /**
  3090. * Destroy the established connection, iframe and `htmlfile`.
  3091. * And calls the `CollectGarbage` function of Internet Explorer
  3092. * to release the memory.
  3093. *
  3094. * @api private
  3095. */
  3096. HTMLFile.prototype.destroy = function () {
  3097. if (this.iframe){
  3098. try {
  3099. this.iframe.src = 'about:blank';
  3100. } catch(e){}
  3101. this.doc = null;
  3102. this.iframe.parentNode.removeChild(this.iframe);
  3103. this.iframe = null;
  3104. CollectGarbage();
  3105. }
  3106. };
  3107. /**
  3108. * Disconnects the established connection.
  3109. *
  3110. * @returns {Transport} Chaining.
  3111. * @api public
  3112. */
  3113. HTMLFile.prototype.close = function () {
  3114. this.destroy();
  3115. return io.Transport.XHR.prototype.close.call(this);
  3116. };
  3117. /**
  3118. * Checks if the browser supports this transport. The browser
  3119. * must have an `Ac...eXObject` implementation.
  3120. *
  3121. * @return {Boolean}
  3122. * @api public
  3123. */
  3124. HTMLFile.check = function (socket) {
  3125. if (typeof window != "undefined" && (['Active'].concat('Object').join('X')) in window){
  3126. try {
  3127. var a = new window[(['Active'].concat('Object').join('X'))]('htmlfile');
  3128. return a && io.Transport.XHR.check(socket);
  3129. } catch(e){}
  3130. }
  3131. return false;
  3132. };
  3133. /**
  3134. * Check if cross domain requests are supported.
  3135. *
  3136. * @returns {Boolean}
  3137. * @api public
  3138. */
  3139. HTMLFile.xdomainCheck = function () {
  3140. // we can probably do handling for sub-domains, we should
  3141. // test that it's cross domain but a subdomain here
  3142. return false;
  3143. };
  3144. /**
  3145. * Add the transport to your public io.transports array.
  3146. *
  3147. * @api private
  3148. */
  3149. io.transports.push('htmlfile');
  3150. })(
  3151. 'undefined' != typeof io ? io.Transport : module.exports
  3152. , 'undefined' != typeof io ? io : module.parent.exports
  3153. );
  3154. })();