7071 lines
242 KiB
JavaScript
7071 lines
242 KiB
JavaScript
// modules are defined as an array
|
||
// [ module function, map of requires ]
|
||
//
|
||
// map of requires is short require name -> numeric require
|
||
//
|
||
// anything defined in a previous bundle is accessed via the
|
||
// orig method which is the require for previous bundles
|
||
|
||
(function (modules, entry, mainEntry, parcelRequireName, globalName) {
|
||
/* eslint-disable no-undef */
|
||
var globalObject =
|
||
typeof globalThis !== 'undefined'
|
||
? globalThis
|
||
: typeof self !== 'undefined'
|
||
? self
|
||
: typeof window !== 'undefined'
|
||
? window
|
||
: typeof global !== 'undefined'
|
||
? global
|
||
: {};
|
||
/* eslint-enable no-undef */
|
||
|
||
// Save the require from previous bundle to this closure if any
|
||
var previousRequire =
|
||
typeof globalObject[parcelRequireName] === 'function' &&
|
||
globalObject[parcelRequireName];
|
||
|
||
var cache = previousRequire.cache || {};
|
||
// Do not use `require` to prevent Webpack from trying to bundle this call
|
||
var nodeRequire =
|
||
typeof module !== 'undefined' &&
|
||
typeof module.require === 'function' &&
|
||
module.require.bind(module);
|
||
|
||
function newRequire(name, jumped) {
|
||
if (!cache[name]) {
|
||
if (!modules[name]) {
|
||
// if we cannot find the module within our internal map or
|
||
// cache jump to the current global require ie. the last bundle
|
||
// that was added to the page.
|
||
var currentRequire =
|
||
typeof globalObject[parcelRequireName] === 'function' &&
|
||
globalObject[parcelRequireName];
|
||
if (!jumped && currentRequire) {
|
||
return currentRequire(name, true);
|
||
}
|
||
|
||
// If there are other bundles on this page the require from the
|
||
// previous one is saved to 'previousRequire'. Repeat this as
|
||
// many times as there are bundles until the module is found or
|
||
// we exhaust the require chain.
|
||
if (previousRequire) {
|
||
return previousRequire(name, true);
|
||
}
|
||
|
||
// Try the node require function if it exists.
|
||
if (nodeRequire && typeof name === 'string') {
|
||
return nodeRequire(name);
|
||
}
|
||
|
||
var err = new Error("Cannot find module '" + name + "'");
|
||
err.code = 'MODULE_NOT_FOUND';
|
||
throw err;
|
||
}
|
||
|
||
localRequire.resolve = resolve;
|
||
localRequire.cache = {};
|
||
|
||
var module = (cache[name] = new newRequire.Module(name));
|
||
|
||
modules[name][0].call(
|
||
module.exports,
|
||
localRequire,
|
||
module,
|
||
module.exports,
|
||
this
|
||
);
|
||
}
|
||
|
||
return cache[name].exports;
|
||
|
||
function localRequire(x) {
|
||
var res = localRequire.resolve(x);
|
||
return res === false ? {} : newRequire(res);
|
||
}
|
||
|
||
function resolve(x) {
|
||
var id = modules[name][1][x];
|
||
return id != null ? id : x;
|
||
}
|
||
}
|
||
|
||
function Module(moduleName) {
|
||
this.id = moduleName;
|
||
this.bundle = newRequire;
|
||
this.exports = {};
|
||
}
|
||
|
||
newRequire.isParcelRequire = true;
|
||
newRequire.Module = Module;
|
||
newRequire.modules = modules;
|
||
newRequire.cache = cache;
|
||
newRequire.parent = previousRequire;
|
||
newRequire.register = function (id, exports) {
|
||
modules[id] = [
|
||
function (require, module) {
|
||
module.exports = exports;
|
||
},
|
||
{},
|
||
];
|
||
};
|
||
|
||
Object.defineProperty(newRequire, 'root', {
|
||
get: function () {
|
||
return globalObject[parcelRequireName];
|
||
},
|
||
});
|
||
|
||
globalObject[parcelRequireName] = newRequire;
|
||
|
||
for (var i = 0; i < entry.length; i++) {
|
||
newRequire(entry[i]);
|
||
}
|
||
|
||
if (mainEntry) {
|
||
// Expose entry point to Node, AMD or browser globals
|
||
// Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
|
||
var mainExports = newRequire(mainEntry);
|
||
|
||
// CommonJS
|
||
if (typeof exports === 'object' && typeof module !== 'undefined') {
|
||
module.exports = mainExports;
|
||
|
||
// RequireJS
|
||
} else if (typeof define === 'function' && define.amd) {
|
||
define(function () {
|
||
return mainExports;
|
||
});
|
||
|
||
// <script>
|
||
} else if (globalName) {
|
||
this[globalName] = mainExports;
|
||
}
|
||
}
|
||
})({"gmPuC":[function(require,module,exports) {
|
||
var global = arguments[3];
|
||
var HMR_HOST = null;
|
||
var HMR_PORT = null;
|
||
var HMR_SECURE = false;
|
||
var HMR_ENV_HASH = "d6ea1d42532a7575";
|
||
module.bundle.HMR_BUNDLE_ID = "5c1b77e3b71e74eb";
|
||
"use strict";
|
||
/* global HMR_HOST, HMR_PORT, HMR_ENV_HASH, HMR_SECURE, chrome, browser, __parcel__import__, __parcel__importScripts__, ServiceWorkerGlobalScope */ /*::
|
||
import type {
|
||
HMRAsset,
|
||
HMRMessage,
|
||
} from '@parcel/reporter-dev-server/src/HMRServer.js';
|
||
interface ParcelRequire {
|
||
(string): mixed;
|
||
cache: {|[string]: ParcelModule|};
|
||
hotData: {|[string]: mixed|};
|
||
Module: any;
|
||
parent: ?ParcelRequire;
|
||
isParcelRequire: true;
|
||
modules: {|[string]: [Function, {|[string]: string|}]|};
|
||
HMR_BUNDLE_ID: string;
|
||
root: ParcelRequire;
|
||
}
|
||
interface ParcelModule {
|
||
hot: {|
|
||
data: mixed,
|
||
accept(cb: (Function) => void): void,
|
||
dispose(cb: (mixed) => void): void,
|
||
// accept(deps: Array<string> | string, cb: (Function) => void): void,
|
||
// decline(): void,
|
||
_acceptCallbacks: Array<(Function) => void>,
|
||
_disposeCallbacks: Array<(mixed) => void>,
|
||
|};
|
||
}
|
||
interface ExtensionContext {
|
||
runtime: {|
|
||
reload(): void,
|
||
getURL(url: string): string;
|
||
getManifest(): {manifest_version: number, ...};
|
||
|};
|
||
}
|
||
declare var module: {bundle: ParcelRequire, ...};
|
||
declare var HMR_HOST: string;
|
||
declare var HMR_PORT: string;
|
||
declare var HMR_ENV_HASH: string;
|
||
declare var HMR_SECURE: boolean;
|
||
declare var chrome: ExtensionContext;
|
||
declare var browser: ExtensionContext;
|
||
declare var __parcel__import__: (string) => Promise<void>;
|
||
declare var __parcel__importScripts__: (string) => Promise<void>;
|
||
declare var globalThis: typeof self;
|
||
declare var ServiceWorkerGlobalScope: Object;
|
||
*/ var OVERLAY_ID = "__parcel__error__overlay__";
|
||
var OldModule = module.bundle.Module;
|
||
function Module(moduleName) {
|
||
OldModule.call(this, moduleName);
|
||
this.hot = {
|
||
data: module.bundle.hotData[moduleName],
|
||
_acceptCallbacks: [],
|
||
_disposeCallbacks: [],
|
||
accept: function(fn) {
|
||
this._acceptCallbacks.push(fn || function() {});
|
||
},
|
||
dispose: function(fn) {
|
||
this._disposeCallbacks.push(fn);
|
||
}
|
||
};
|
||
module.bundle.hotData[moduleName] = undefined;
|
||
}
|
||
module.bundle.Module = Module;
|
||
module.bundle.hotData = {};
|
||
var checkedAssets /*: {|[string]: boolean|} */ , assetsToDispose /*: Array<[ParcelRequire, string]> */ , assetsToAccept /*: Array<[ParcelRequire, string]> */ ;
|
||
function getHostname() {
|
||
return HMR_HOST || (location.protocol.indexOf("http") === 0 ? location.hostname : "localhost");
|
||
}
|
||
function getPort() {
|
||
return HMR_PORT || location.port;
|
||
}
|
||
// eslint-disable-next-line no-redeclare
|
||
var parent = module.bundle.parent;
|
||
if ((!parent || !parent.isParcelRequire) && typeof WebSocket !== "undefined") {
|
||
var hostname = getHostname();
|
||
var port = getPort();
|
||
var protocol = HMR_SECURE || location.protocol == "https:" && !/localhost|127.0.0.1|0.0.0.0/.test(hostname) ? "wss" : "ws";
|
||
var ws;
|
||
try {
|
||
ws = new WebSocket(protocol + "://" + hostname + (port ? ":" + port : "") + "/");
|
||
} catch (err) {
|
||
if (err.message) console.error(err.message);
|
||
ws = {};
|
||
}
|
||
// Web extension context
|
||
var extCtx = typeof browser === "undefined" ? typeof chrome === "undefined" ? null : chrome : browser;
|
||
// Safari doesn't support sourceURL in error stacks.
|
||
// eval may also be disabled via CSP, so do a quick check.
|
||
var supportsSourceURL = false;
|
||
try {
|
||
(0, eval)('throw new Error("test"); //# sourceURL=test.js');
|
||
} catch (err) {
|
||
supportsSourceURL = err.stack.includes("test.js");
|
||
}
|
||
// $FlowFixMe
|
||
ws.onmessage = async function(event /*: {data: string, ...} */ ) {
|
||
checkedAssets = {} /*: {|[string]: boolean|} */ ;
|
||
assetsToAccept = [];
|
||
assetsToDispose = [];
|
||
var data /*: HMRMessage */ = JSON.parse(event.data);
|
||
if (data.type === "update") {
|
||
// Remove error overlay if there is one
|
||
if (typeof document !== "undefined") removeErrorOverlay();
|
||
let assets = data.assets.filter((asset)=>asset.envHash === HMR_ENV_HASH);
|
||
// Handle HMR Update
|
||
let handled = assets.every((asset)=>{
|
||
return asset.type === "css" || asset.type === "js" && hmrAcceptCheck(module.bundle.root, asset.id, asset.depsByBundle);
|
||
});
|
||
if (handled) {
|
||
console.clear();
|
||
// Dispatch custom event so other runtimes (e.g React Refresh) are aware.
|
||
if (typeof window !== "undefined" && typeof CustomEvent !== "undefined") window.dispatchEvent(new CustomEvent("parcelhmraccept"));
|
||
await hmrApplyUpdates(assets);
|
||
// Dispose all old assets.
|
||
let processedAssets = {} /*: {|[string]: boolean|} */ ;
|
||
for(let i = 0; i < assetsToDispose.length; i++){
|
||
let id = assetsToDispose[i][1];
|
||
if (!processedAssets[id]) {
|
||
hmrDispose(assetsToDispose[i][0], id);
|
||
processedAssets[id] = true;
|
||
}
|
||
}
|
||
// Run accept callbacks. This will also re-execute other disposed assets in topological order.
|
||
processedAssets = {};
|
||
for(let i = 0; i < assetsToAccept.length; i++){
|
||
let id = assetsToAccept[i][1];
|
||
if (!processedAssets[id]) {
|
||
hmrAccept(assetsToAccept[i][0], id);
|
||
processedAssets[id] = true;
|
||
}
|
||
}
|
||
} else fullReload();
|
||
}
|
||
if (data.type === "error") {
|
||
// Log parcel errors to console
|
||
for (let ansiDiagnostic of data.diagnostics.ansi){
|
||
let stack = ansiDiagnostic.codeframe ? ansiDiagnostic.codeframe : ansiDiagnostic.stack;
|
||
console.error("\uD83D\uDEA8 [parcel]: " + ansiDiagnostic.message + "\n" + stack + "\n\n" + ansiDiagnostic.hints.join("\n"));
|
||
}
|
||
if (typeof document !== "undefined") {
|
||
// Render the fancy html overlay
|
||
removeErrorOverlay();
|
||
var overlay = createErrorOverlay(data.diagnostics.html);
|
||
// $FlowFixMe
|
||
document.body.appendChild(overlay);
|
||
}
|
||
}
|
||
};
|
||
ws.onerror = function(e) {
|
||
if (e.message) console.error(e.message);
|
||
};
|
||
ws.onclose = function() {
|
||
console.warn("[parcel] \uD83D\uDEA8 Connection to the HMR server was lost");
|
||
};
|
||
}
|
||
function removeErrorOverlay() {
|
||
var overlay = document.getElementById(OVERLAY_ID);
|
||
if (overlay) {
|
||
overlay.remove();
|
||
console.log("[parcel] \u2728 Error resolved");
|
||
}
|
||
}
|
||
function createErrorOverlay(diagnostics) {
|
||
var overlay = document.createElement("div");
|
||
overlay.id = OVERLAY_ID;
|
||
let errorHTML = '<div style="background: black; opacity: 0.85; font-size: 16px; color: white; position: fixed; height: 100%; width: 100%; top: 0px; left: 0px; padding: 30px; font-family: Menlo, Consolas, monospace; z-index: 9999;">';
|
||
for (let diagnostic of diagnostics){
|
||
let stack = diagnostic.frames.length ? diagnostic.frames.reduce((p, frame)=>{
|
||
return `${p}
|
||
<a href="/__parcel_launch_editor?file=${encodeURIComponent(frame.location)}" style="text-decoration: underline; color: #888" onclick="fetch(this.href); return false">${frame.location}</a>
|
||
${frame.code}`;
|
||
}, "") : diagnostic.stack;
|
||
errorHTML += `
|
||
<div>
|
||
<div style="font-size: 18px; font-weight: bold; margin-top: 20px;">
|
||
\u{1F6A8} ${diagnostic.message}
|
||
</div>
|
||
<pre>${stack}</pre>
|
||
<div>
|
||
${diagnostic.hints.map((hint)=>"<div>\uD83D\uDCA1 " + hint + "</div>").join("")}
|
||
</div>
|
||
${diagnostic.documentation ? `<div>\u{1F4DD} <a style="color: violet" href="${diagnostic.documentation}" target="_blank">Learn more</a></div>` : ""}
|
||
</div>
|
||
`;
|
||
}
|
||
errorHTML += "</div>";
|
||
overlay.innerHTML = errorHTML;
|
||
return overlay;
|
||
}
|
||
function fullReload() {
|
||
if ("reload" in location) location.reload();
|
||
else if (extCtx && extCtx.runtime && extCtx.runtime.reload) extCtx.runtime.reload();
|
||
}
|
||
function getParents(bundle, id) /*: Array<[ParcelRequire, string]> */ {
|
||
var modules = bundle.modules;
|
||
if (!modules) return [];
|
||
var parents = [];
|
||
var k, d, dep;
|
||
for(k in modules)for(d in modules[k][1]){
|
||
dep = modules[k][1][d];
|
||
if (dep === id || Array.isArray(dep) && dep[dep.length - 1] === id) parents.push([
|
||
bundle,
|
||
k
|
||
]);
|
||
}
|
||
if (bundle.parent) parents = parents.concat(getParents(bundle.parent, id));
|
||
return parents;
|
||
}
|
||
function updateLink(link) {
|
||
var href = link.getAttribute("href");
|
||
if (!href) return;
|
||
var newLink = link.cloneNode();
|
||
newLink.onload = function() {
|
||
if (link.parentNode !== null) // $FlowFixMe
|
||
link.parentNode.removeChild(link);
|
||
};
|
||
newLink.setAttribute("href", // $FlowFixMe
|
||
href.split("?")[0] + "?" + Date.now());
|
||
// $FlowFixMe
|
||
link.parentNode.insertBefore(newLink, link.nextSibling);
|
||
}
|
||
var cssTimeout = null;
|
||
function reloadCSS() {
|
||
if (cssTimeout) return;
|
||
cssTimeout = setTimeout(function() {
|
||
var links = document.querySelectorAll('link[rel="stylesheet"]');
|
||
for(var i = 0; i < links.length; i++){
|
||
// $FlowFixMe[incompatible-type]
|
||
var href /*: string */ = links[i].getAttribute("href");
|
||
var hostname = getHostname();
|
||
var servedFromHMRServer = hostname === "localhost" ? new RegExp("^(https?:\\/\\/(0.0.0.0|127.0.0.1)|localhost):" + getPort()).test(href) : href.indexOf(hostname + ":" + getPort());
|
||
var absolute = /^https?:\/\//i.test(href) && href.indexOf(location.origin) !== 0 && !servedFromHMRServer;
|
||
if (!absolute) updateLink(links[i]);
|
||
}
|
||
cssTimeout = null;
|
||
}, 50);
|
||
}
|
||
function hmrDownload(asset) {
|
||
if (asset.type === "js") {
|
||
if (typeof document !== "undefined") {
|
||
let script = document.createElement("script");
|
||
script.src = asset.url + "?t=" + Date.now();
|
||
if (asset.outputFormat === "esmodule") script.type = "module";
|
||
return new Promise((resolve, reject)=>{
|
||
var _document$head;
|
||
script.onload = ()=>resolve(script);
|
||
script.onerror = reject;
|
||
(_document$head = document.head) === null || _document$head === void 0 || _document$head.appendChild(script);
|
||
});
|
||
} else if (typeof importScripts === "function") {
|
||
// Worker scripts
|
||
if (asset.outputFormat === "esmodule") return import(asset.url + "?t=" + Date.now());
|
||
else return new Promise((resolve, reject)=>{
|
||
try {
|
||
importScripts(asset.url + "?t=" + Date.now());
|
||
resolve();
|
||
} catch (err) {
|
||
reject(err);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
}
|
||
async function hmrApplyUpdates(assets) {
|
||
global.parcelHotUpdate = Object.create(null);
|
||
let scriptsToRemove;
|
||
try {
|
||
// If sourceURL comments aren't supported in eval, we need to load
|
||
// the update from the dev server over HTTP so that stack traces
|
||
// are correct in errors/logs. This is much slower than eval, so
|
||
// we only do it if needed (currently just Safari).
|
||
// https://bugs.webkit.org/show_bug.cgi?id=137297
|
||
// This path is also taken if a CSP disallows eval.
|
||
if (!supportsSourceURL) {
|
||
let promises = assets.map((asset)=>{
|
||
var _hmrDownload;
|
||
return (_hmrDownload = hmrDownload(asset)) === null || _hmrDownload === void 0 ? void 0 : _hmrDownload.catch((err)=>{
|
||
// Web extension fix
|
||
if (extCtx && extCtx.runtime && extCtx.runtime.getManifest().manifest_version == 3 && typeof ServiceWorkerGlobalScope != "undefined" && global instanceof ServiceWorkerGlobalScope) {
|
||
extCtx.runtime.reload();
|
||
return;
|
||
}
|
||
throw err;
|
||
});
|
||
});
|
||
scriptsToRemove = await Promise.all(promises);
|
||
}
|
||
assets.forEach(function(asset) {
|
||
hmrApply(module.bundle.root, asset);
|
||
});
|
||
} finally{
|
||
delete global.parcelHotUpdate;
|
||
if (scriptsToRemove) scriptsToRemove.forEach((script)=>{
|
||
if (script) {
|
||
var _document$head2;
|
||
(_document$head2 = document.head) === null || _document$head2 === void 0 || _document$head2.removeChild(script);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
function hmrApply(bundle /*: ParcelRequire */ , asset /*: HMRAsset */ ) {
|
||
var modules = bundle.modules;
|
||
if (!modules) return;
|
||
if (asset.type === "css") reloadCSS();
|
||
else if (asset.type === "js") {
|
||
let deps = asset.depsByBundle[bundle.HMR_BUNDLE_ID];
|
||
if (deps) {
|
||
if (modules[asset.id]) {
|
||
// Remove dependencies that are removed and will become orphaned.
|
||
// This is necessary so that if the asset is added back again, the cache is gone, and we prevent a full page reload.
|
||
let oldDeps = modules[asset.id][1];
|
||
for(let dep in oldDeps)if (!deps[dep] || deps[dep] !== oldDeps[dep]) {
|
||
let id = oldDeps[dep];
|
||
let parents = getParents(module.bundle.root, id);
|
||
if (parents.length === 1) hmrDelete(module.bundle.root, id);
|
||
}
|
||
}
|
||
if (supportsSourceURL) // Global eval. We would use `new Function` here but browser
|
||
// support for source maps is better with eval.
|
||
(0, eval)(asset.output);
|
||
// $FlowFixMe
|
||
let fn = global.parcelHotUpdate[asset.id];
|
||
modules[asset.id] = [
|
||
fn,
|
||
deps
|
||
];
|
||
} else if (bundle.parent) hmrApply(bundle.parent, asset);
|
||
}
|
||
}
|
||
function hmrDelete(bundle, id) {
|
||
let modules = bundle.modules;
|
||
if (!modules) return;
|
||
if (modules[id]) {
|
||
// Collect dependencies that will become orphaned when this module is deleted.
|
||
let deps = modules[id][1];
|
||
let orphans = [];
|
||
for(let dep in deps){
|
||
let parents = getParents(module.bundle.root, deps[dep]);
|
||
if (parents.length === 1) orphans.push(deps[dep]);
|
||
}
|
||
// Delete the module. This must be done before deleting dependencies in case of circular dependencies.
|
||
delete modules[id];
|
||
delete bundle.cache[id];
|
||
// Now delete the orphans.
|
||
orphans.forEach((id)=>{
|
||
hmrDelete(module.bundle.root, id);
|
||
});
|
||
} else if (bundle.parent) hmrDelete(bundle.parent, id);
|
||
}
|
||
function hmrAcceptCheck(bundle /*: ParcelRequire */ , id /*: string */ , depsByBundle /*: ?{ [string]: { [string]: string } }*/ ) {
|
||
if (hmrAcceptCheckOne(bundle, id, depsByBundle)) return true;
|
||
// Traverse parents breadth first. All possible ancestries must accept the HMR update, or we'll reload.
|
||
let parents = getParents(module.bundle.root, id);
|
||
let accepted = false;
|
||
while(parents.length > 0){
|
||
let v = parents.shift();
|
||
let a = hmrAcceptCheckOne(v[0], v[1], null);
|
||
if (a) // If this parent accepts, stop traversing upward, but still consider siblings.
|
||
accepted = true;
|
||
else {
|
||
// Otherwise, queue the parents in the next level upward.
|
||
let p = getParents(module.bundle.root, v[1]);
|
||
if (p.length === 0) {
|
||
// If there are no parents, then we've reached an entry without accepting. Reload.
|
||
accepted = false;
|
||
break;
|
||
}
|
||
parents.push(...p);
|
||
}
|
||
}
|
||
return accepted;
|
||
}
|
||
function hmrAcceptCheckOne(bundle /*: ParcelRequire */ , id /*: string */ , depsByBundle /*: ?{ [string]: { [string]: string } }*/ ) {
|
||
var modules = bundle.modules;
|
||
if (!modules) return;
|
||
if (depsByBundle && !depsByBundle[bundle.HMR_BUNDLE_ID]) {
|
||
// If we reached the root bundle without finding where the asset should go,
|
||
// there's nothing to do. Mark as "accepted" so we don't reload the page.
|
||
if (!bundle.parent) return true;
|
||
return hmrAcceptCheck(bundle.parent, id, depsByBundle);
|
||
}
|
||
if (checkedAssets[id]) return true;
|
||
checkedAssets[id] = true;
|
||
var cached = bundle.cache[id];
|
||
assetsToDispose.push([
|
||
bundle,
|
||
id
|
||
]);
|
||
if (!cached || cached.hot && cached.hot._acceptCallbacks.length) {
|
||
assetsToAccept.push([
|
||
bundle,
|
||
id
|
||
]);
|
||
return true;
|
||
}
|
||
}
|
||
function hmrDispose(bundle /*: ParcelRequire */ , id /*: string */ ) {
|
||
var cached = bundle.cache[id];
|
||
bundle.hotData[id] = {};
|
||
if (cached && cached.hot) cached.hot.data = bundle.hotData[id];
|
||
if (cached && cached.hot && cached.hot._disposeCallbacks.length) cached.hot._disposeCallbacks.forEach(function(cb) {
|
||
cb(bundle.hotData[id]);
|
||
});
|
||
delete bundle.cache[id];
|
||
}
|
||
function hmrAccept(bundle /*: ParcelRequire */ , id /*: string */ ) {
|
||
// Execute the module.
|
||
bundle(id);
|
||
// Run the accept callbacks in the new version of the module.
|
||
var cached = bundle.cache[id];
|
||
if (cached && cached.hot && cached.hot._acceptCallbacks.length) cached.hot._acceptCallbacks.forEach(function(cb) {
|
||
var assetsToAlsoAccept = cb(function() {
|
||
return getParents(module.bundle.root, id);
|
||
});
|
||
if (assetsToAlsoAccept && assetsToAccept.length) {
|
||
assetsToAlsoAccept.forEach(function(a) {
|
||
hmrDispose(a[0], a[1]);
|
||
});
|
||
// $FlowFixMe[method-unbinding]
|
||
assetsToAccept.push.apply(assetsToAccept, assetsToAlsoAccept);
|
||
}
|
||
});
|
||
}
|
||
|
||
},{}],"h7u1C":[function(require,module,exports) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
var _linxSdkModule = require("./linx-sdk-module");
|
||
var _linxSdkModuleDefault = parcelHelpers.interopDefault(_linxSdkModule);
|
||
// @ts-ignore
|
||
async function start() {
|
||
const linxSdk = new (0, _linxSdkModuleDefault.default)("24630a02-331d-4b67-993d-9590cd37093f", "https://dev.linx.safemobile.com");
|
||
await linxSdk.init("AIRWizard-sergiu", "Safemobile123");
|
||
linxSdk.establishWsConnection();
|
||
}
|
||
start();
|
||
|
||
},{"./linx-sdk-module":"5NPnF","@parcel/transformer-js/src/esmodule-helpers.js":"gkKU3"}],"5NPnF":[function(require,module,exports) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
var _models = require("./models");
|
||
var _utils = require("./utils");
|
||
var _utilsDefault = parcelHelpers.interopDefault(_utils);
|
||
var _socketIoClient = require("socket.io-client");
|
||
var _socketIoClientDefault = parcelHelpers.interopDefault(_socketIoClient);
|
||
class LinxSdkModule {
|
||
constructor(apiKey, host){
|
||
this.utils = new (0, _utilsDefault.default)(host);
|
||
}
|
||
async init(user, password) {
|
||
try {
|
||
const login = await this.utils.request((0, _models.Method).POST, (0, _models.Route).LOGIN, {
|
||
login: user,
|
||
password: password
|
||
});
|
||
if (!login.success) {
|
||
(0, _utilsDefault.default).log("Failed to initialize SDK", (0, _models.LogLevel).ERROR);
|
||
return false;
|
||
} else {
|
||
this.user = login.data;
|
||
(0, _utilsDefault.default).log("The SDK initialized successfully");
|
||
this.getGroups();
|
||
return true;
|
||
}
|
||
} catch (err) {
|
||
(0, _utilsDefault.default).log(JSON.stringify(err.message), (0, _models.LogLevel).ERROR);
|
||
return false;
|
||
}
|
||
}
|
||
establishWsConnection() {
|
||
const hubAddress = this.user.account.configuration.hub_address;
|
||
this.socket = (0, _socketIoClientDefault.default)(hubAddress, {
|
||
rejectUnauthorized: false,
|
||
secure: true
|
||
});
|
||
this.socket.on("connect", ()=>{
|
||
this.sendArs(true);
|
||
(0, _utilsDefault.default).log("The connection with the WS server was successfully established");
|
||
});
|
||
[
|
||
"connect_timeout",
|
||
"connect_error",
|
||
"disconnect"
|
||
].forEach((handler)=>{
|
||
this.socket.on(handler, (message)=>{
|
||
(0, _utilsDefault.default).log(message, (0, _models.LogLevel).ERROR);
|
||
});
|
||
});
|
||
}
|
||
sendArs(ars) {
|
||
this.socket.emit("ars", JSON.stringify({
|
||
ars,
|
||
userAgent: "Dispatcher",
|
||
asset_id: this.user.asset.id,
|
||
account_id: this.user.account.id,
|
||
asset_sip_id: this.user.asset.sip_id,
|
||
fake: false
|
||
}));
|
||
}
|
||
sendGroupMonitoring() {
|
||
const monitoringObject = {
|
||
asset_alias: this.user.asset.name,
|
||
asset_id: this.user.asset.id,
|
||
asset_sip_id: this.user.asset.sip_id,
|
||
group_id: 1,
|
||
group_sip_id: 100190001,
|
||
request_ptt_groups_status: false,
|
||
scan_group_ids: []
|
||
};
|
||
this.socket.emit("group-monitoring", JSON.stringify(monitoringObject));
|
||
}
|
||
async getGroups() {
|
||
const getGroupsRoute = (0, _models.Route).GROUPS.replace("$1", this.user.account.id.toString());
|
||
const groups = await this.utils.request((0, _models.Method).GET, getGroupsRoute);
|
||
console.log("groups", groups);
|
||
}
|
||
}
|
||
exports.default = LinxSdkModule;
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"gkKU3","./utils":"5dFnk","./models":"lidte","socket.io-client":"c56j9"}],"gkKU3":[function(require,module,exports) {
|
||
exports.interopDefault = function(a) {
|
||
return a && a.__esModule ? a : {
|
||
default: a
|
||
};
|
||
};
|
||
exports.defineInteropFlag = function(a) {
|
||
Object.defineProperty(a, "__esModule", {
|
||
value: true
|
||
});
|
||
};
|
||
exports.exportAll = function(source, dest) {
|
||
Object.keys(source).forEach(function(key) {
|
||
if (key === "default" || key === "__esModule" || dest.hasOwnProperty(key)) return;
|
||
Object.defineProperty(dest, key, {
|
||
enumerable: true,
|
||
get: function() {
|
||
return source[key];
|
||
}
|
||
});
|
||
});
|
||
return dest;
|
||
};
|
||
exports.export = function(dest, destName, get) {
|
||
Object.defineProperty(dest, destName, {
|
||
enumerable: true,
|
||
get: get
|
||
});
|
||
};
|
||
|
||
},{}],"5dFnk":[function(require,module,exports) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
var _models = require("./models");
|
||
class Utils {
|
||
constructor(host){
|
||
this.host = host;
|
||
}
|
||
async request(method, path, data) {
|
||
const req = await fetch(`${this.host}${path}`, {
|
||
method: (0, _models.Method)[method],
|
||
mode: "cors",
|
||
credentials: "same-origin",
|
||
headers: {
|
||
"Content-Type": "application/json"
|
||
},
|
||
redirect: "follow",
|
||
referrerPolicy: "no-referrer",
|
||
body: data ? JSON.stringify(data) : null
|
||
});
|
||
return req.json();
|
||
}
|
||
static log(message, level = (0, _models.LogLevel).INFO) {
|
||
switch(level){
|
||
case 0:
|
||
console.log(`%c\u{24D8} SDK INFO: ${message}`, "background: #183fdb; color: #ffffff");
|
||
break;
|
||
case 1:
|
||
console.log(`%c\u{2757}SDK WARNING: ${message}`, "background: #c46a10; color: #ffffff");
|
||
break;
|
||
case 2:
|
||
console.log(`%c\u{26D4}SDK ERROR: ${message}`, "background: #c41010; color: #ffffff");
|
||
break;
|
||
default:
|
||
console.log("default");
|
||
}
|
||
}
|
||
}
|
||
exports.default = Utils;
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"gkKU3","./models":"lidte"}],"lidte":[function(require,module,exports) {
|
||
var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
|
||
parcelHelpers.defineInteropFlag(exports);
|
||
parcelHelpers.export(exports, "Route", ()=>Route);
|
||
parcelHelpers.export(exports, "Method", ()=>Method);
|
||
parcelHelpers.export(exports, "LogLevel", ()=>LogLevel);
|
||
var Route;
|
||
(function(Route) {
|
||
Route["LOGIN"] = "/api/login";
|
||
Route["GROUPS"] = "/api/sdk/account/$1/groups";
|
||
})(Route || (Route = {}));
|
||
var Method;
|
||
(function(Method) {
|
||
Method[Method["GET"] = 0] = "GET";
|
||
Method[Method["POST"] = 1] = "POST";
|
||
})(Method || (Method = {}));
|
||
var LogLevel;
|
||
(function(LogLevel) {
|
||
LogLevel[LogLevel["INFO"] = 0] = "INFO";
|
||
LogLevel[LogLevel["WARNING"] = 1] = "WARNING";
|
||
LogLevel[LogLevel["ERROR"] = 2] = "ERROR";
|
||
})(LogLevel || (LogLevel = {}));
|
||
|
||
},{"@parcel/transformer-js/src/esmodule-helpers.js":"gkKU3"}],"c56j9":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var url = require("5ef338c215ec7db2");
|
||
var parser = require("5b02f87b9b6b8913");
|
||
var Manager = require("370cb6511e85e739");
|
||
var debug = require("fa9e2b7ef62c353a")("socket.io-client");
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = exports = lookup;
|
||
/**
|
||
* Managers cache.
|
||
*/ var cache = exports.managers = {};
|
||
/**
|
||
* Looks up an existing `Manager` for multiplexing.
|
||
* If the user summons:
|
||
*
|
||
* `io('http://localhost/a');`
|
||
* `io('http://localhost/b');`
|
||
*
|
||
* We reuse the existing instance based on same scheme/port/host,
|
||
* and we initialize sockets for each namespace.
|
||
*
|
||
* @api public
|
||
*/ function lookup(uri, opts) {
|
||
if (typeof uri === "object") {
|
||
opts = uri;
|
||
uri = undefined;
|
||
}
|
||
opts = opts || {};
|
||
var parsed = url(uri);
|
||
var source = parsed.source;
|
||
var id = parsed.id;
|
||
var path = parsed.path;
|
||
var sameNamespace = cache[id] && path in cache[id].nsps;
|
||
var newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
|
||
var io;
|
||
if (newConnection) {
|
||
debug("ignoring socket cache for %s", source);
|
||
io = Manager(source, opts);
|
||
} else {
|
||
if (!cache[id]) {
|
||
debug("new io instance for %s", source);
|
||
cache[id] = Manager(source, opts);
|
||
}
|
||
io = cache[id];
|
||
}
|
||
if (parsed.query && !opts.query) opts.query = parsed.query;
|
||
return io.socket(parsed.path, opts);
|
||
}
|
||
/**
|
||
* Protocol version.
|
||
*
|
||
* @api public
|
||
*/ exports.protocol = parser.protocol;
|
||
/**
|
||
* `connect`.
|
||
*
|
||
* @param {String} uri
|
||
* @api public
|
||
*/ exports.connect = lookup;
|
||
/**
|
||
* Expose constructors for standalone build.
|
||
*
|
||
* @api public
|
||
*/ exports.Manager = require("370cb6511e85e739");
|
||
exports.Socket = require("f338ca1a73d48b1c");
|
||
|
||
},{"5ef338c215ec7db2":"eK0ik","5b02f87b9b6b8913":"iEP88","370cb6511e85e739":"k06Qi","fa9e2b7ef62c353a":"l0oUb","f338ca1a73d48b1c":"aZLF9"}],"eK0ik":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var parseuri = require("5adf3dd721bcd05e");
|
||
var debug = require("bd995f207386731a")("socket.io-client:url");
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = url;
|
||
/**
|
||
* URL parser.
|
||
*
|
||
* @param {String} url
|
||
* @param {Object} An object meant to mimic window.location.
|
||
* Defaults to window.location.
|
||
* @api public
|
||
*/ function url(uri, loc) {
|
||
var obj = uri;
|
||
// default to window.location
|
||
loc = loc || typeof location !== "undefined" && location;
|
||
if (null == uri) uri = loc.protocol + "//" + loc.host;
|
||
// relative path support
|
||
if ("string" === typeof uri) {
|
||
if ("/" === uri.charAt(0)) {
|
||
if ("/" === uri.charAt(1)) uri = loc.protocol + uri;
|
||
else uri = loc.host + uri;
|
||
}
|
||
if (!/^(https?|wss?):\/\//.test(uri)) {
|
||
debug("protocol-less url %s", uri);
|
||
if ("undefined" !== typeof loc) uri = loc.protocol + "//" + uri;
|
||
else uri = "https://" + uri;
|
||
}
|
||
// parse
|
||
debug("parse %s", uri);
|
||
obj = parseuri(uri);
|
||
}
|
||
// make sure we treat `localhost:80` and `localhost` equally
|
||
if (!obj.port) {
|
||
if (/^(http|ws)$/.test(obj.protocol)) obj.port = "80";
|
||
else if (/^(http|ws)s$/.test(obj.protocol)) obj.port = "443";
|
||
}
|
||
obj.path = obj.path || "/";
|
||
var ipv6 = obj.host.indexOf(":") !== -1;
|
||
var host = ipv6 ? "[" + obj.host + "]" : obj.host;
|
||
// define unique id
|
||
obj.id = obj.protocol + "://" + host + ":" + obj.port;
|
||
// define href
|
||
obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port);
|
||
return obj;
|
||
}
|
||
|
||
},{"5adf3dd721bcd05e":"7w9JU","bd995f207386731a":"l0oUb"}],"7w9JU":[function(require,module,exports) {
|
||
/**
|
||
* Parses an URI
|
||
*
|
||
* @author Steven Levithan <stevenlevithan.com> (MIT license)
|
||
* @api private
|
||
*/ var re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
|
||
var parts = [
|
||
"source",
|
||
"protocol",
|
||
"authority",
|
||
"userInfo",
|
||
"user",
|
||
"password",
|
||
"host",
|
||
"port",
|
||
"relative",
|
||
"path",
|
||
"directory",
|
||
"file",
|
||
"query",
|
||
"anchor"
|
||
];
|
||
module.exports = function parseuri(str) {
|
||
var src = str, b = str.indexOf("["), e = str.indexOf("]");
|
||
if (b != -1 && e != -1) str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ";") + str.substring(e, str.length);
|
||
var m = re.exec(str || ""), uri = {}, i = 14;
|
||
while(i--)uri[parts[i]] = m[i] || "";
|
||
if (b != -1 && e != -1) {
|
||
uri.source = src;
|
||
uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ":");
|
||
uri.authority = uri.authority.replace("[", "").replace("]", "").replace(/;/g, ":");
|
||
uri.ipv6uri = true;
|
||
}
|
||
uri.pathNames = pathNames(uri, uri["path"]);
|
||
uri.queryKey = queryKey(uri, uri["query"]);
|
||
return uri;
|
||
};
|
||
function pathNames(obj, path) {
|
||
var regx = /\/{2,9}/g, names = path.replace(regx, "/").split("/");
|
||
if (path.substr(0, 1) == "/" || path.length === 0) names.splice(0, 1);
|
||
if (path.substr(path.length - 1, 1) == "/") names.splice(names.length - 1, 1);
|
||
return names;
|
||
}
|
||
function queryKey(uri, query) {
|
||
var data = {};
|
||
query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function($0, $1, $2) {
|
||
if ($1) data[$1] = $2;
|
||
});
|
||
return data;
|
||
}
|
||
|
||
},{}],"l0oUb":[function(require,module,exports) {
|
||
/**
|
||
* This is the web browser implementation of `debug()`.
|
||
*
|
||
* Expose `debug()` as the module.
|
||
*/ var process = require("12edbb1af7d8bd3b");
|
||
exports = module.exports = require("164b7987e493c35c");
|
||
exports.log = log;
|
||
exports.formatArgs = formatArgs;
|
||
exports.save = save;
|
||
exports.load = load;
|
||
exports.useColors = useColors;
|
||
exports.storage = "undefined" != typeof chrome && "undefined" != typeof chrome.storage ? chrome.storage.local : localstorage();
|
||
/**
|
||
* Colors.
|
||
*/ exports.colors = [
|
||
"#0000CC",
|
||
"#0000FF",
|
||
"#0033CC",
|
||
"#0033FF",
|
||
"#0066CC",
|
||
"#0066FF",
|
||
"#0099CC",
|
||
"#0099FF",
|
||
"#00CC00",
|
||
"#00CC33",
|
||
"#00CC66",
|
||
"#00CC99",
|
||
"#00CCCC",
|
||
"#00CCFF",
|
||
"#3300CC",
|
||
"#3300FF",
|
||
"#3333CC",
|
||
"#3333FF",
|
||
"#3366CC",
|
||
"#3366FF",
|
||
"#3399CC",
|
||
"#3399FF",
|
||
"#33CC00",
|
||
"#33CC33",
|
||
"#33CC66",
|
||
"#33CC99",
|
||
"#33CCCC",
|
||
"#33CCFF",
|
||
"#6600CC",
|
||
"#6600FF",
|
||
"#6633CC",
|
||
"#6633FF",
|
||
"#66CC00",
|
||
"#66CC33",
|
||
"#9900CC",
|
||
"#9900FF",
|
||
"#9933CC",
|
||
"#9933FF",
|
||
"#99CC00",
|
||
"#99CC33",
|
||
"#CC0000",
|
||
"#CC0033",
|
||
"#CC0066",
|
||
"#CC0099",
|
||
"#CC00CC",
|
||
"#CC00FF",
|
||
"#CC3300",
|
||
"#CC3333",
|
||
"#CC3366",
|
||
"#CC3399",
|
||
"#CC33CC",
|
||
"#CC33FF",
|
||
"#CC6600",
|
||
"#CC6633",
|
||
"#CC9900",
|
||
"#CC9933",
|
||
"#CCCC00",
|
||
"#CCCC33",
|
||
"#FF0000",
|
||
"#FF0033",
|
||
"#FF0066",
|
||
"#FF0099",
|
||
"#FF00CC",
|
||
"#FF00FF",
|
||
"#FF3300",
|
||
"#FF3333",
|
||
"#FF3366",
|
||
"#FF3399",
|
||
"#FF33CC",
|
||
"#FF33FF",
|
||
"#FF6600",
|
||
"#FF6633",
|
||
"#FF9900",
|
||
"#FF9933",
|
||
"#FFCC00",
|
||
"#FFCC33"
|
||
];
|
||
/**
|
||
* Currently only WebKit-based Web Inspectors, Firefox >= v31,
|
||
* and the Firebug extension (any Firefox version) are known
|
||
* to support "%c" CSS customizations.
|
||
*
|
||
* TODO: add a `localStorage` variable to explicitly enable/disable colors
|
||
*/ function useColors() {
|
||
// NB: In an Electron preload script, document will be defined but not fully
|
||
// initialized. Since we know we're in Chrome, we'll just detect this case
|
||
// explicitly
|
||
if (typeof window !== "undefined" && window.process && window.process.type === "renderer") return true;
|
||
// Internet Explorer and Edge do not support colors.
|
||
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) return false;
|
||
// is webkit? http://stackoverflow.com/a/16459606/376773
|
||
// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
|
||
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // is firebug? http://stackoverflow.com/a/398120/376773
|
||
typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // is firefox >= v31?
|
||
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
|
||
typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // double check webkit in userAgent just in case we are in a worker
|
||
typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
|
||
}
|
||
/**
|
||
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
|
||
*/ exports.formatters.j = function(v) {
|
||
try {
|
||
return JSON.stringify(v);
|
||
} catch (err) {
|
||
return "[UnexpectedJSONParseError]: " + err.message;
|
||
}
|
||
};
|
||
/**
|
||
* Colorize log arguments if enabled.
|
||
*
|
||
* @api public
|
||
*/ function formatArgs(args) {
|
||
var useColors = this.useColors;
|
||
args[0] = (useColors ? "%c" : "") + this.namespace + (useColors ? " %c" : " ") + args[0] + (useColors ? "%c " : " ") + "+" + exports.humanize(this.diff);
|
||
if (!useColors) return;
|
||
var c = "color: " + this.color;
|
||
args.splice(1, 0, c, "color: inherit");
|
||
// the final "%c" is somewhat tricky, because there could be other
|
||
// arguments passed either before or after the %c, so we need to
|
||
// figure out the correct index to insert the CSS into
|
||
var index = 0;
|
||
var lastC = 0;
|
||
args[0].replace(/%[a-zA-Z%]/g, function(match) {
|
||
if ("%%" === match) return;
|
||
index++;
|
||
if ("%c" === match) // we only are interested in the *last* %c
|
||
// (the user may have provided their own)
|
||
lastC = index;
|
||
});
|
||
args.splice(lastC, 0, c);
|
||
}
|
||
/**
|
||
* Invokes `console.log()` when available.
|
||
* No-op when `console.log` is not a "function".
|
||
*
|
||
* @api public
|
||
*/ function log() {
|
||
// this hackery is required for IE8/9, where
|
||
// the `console.log` function doesn't have 'apply'
|
||
return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
|
||
}
|
||
/**
|
||
* Save `namespaces`.
|
||
*
|
||
* @param {String} namespaces
|
||
* @api private
|
||
*/ function save(namespaces) {
|
||
try {
|
||
if (null == namespaces) exports.storage.removeItem("debug");
|
||
else exports.storage.debug = namespaces;
|
||
} catch (e) {}
|
||
}
|
||
/**
|
||
* Load `namespaces`.
|
||
*
|
||
* @return {String} returns the previously persisted debug modes
|
||
* @api private
|
||
*/ function load() {
|
||
var r;
|
||
try {
|
||
r = exports.storage.debug;
|
||
} catch (e) {}
|
||
// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
|
||
if (!r && typeof process !== "undefined" && "env" in process) r = undefined;
|
||
return r;
|
||
}
|
||
/**
|
||
* Enable namespaces listed in `localStorage.debug` initially.
|
||
*/ exports.enable(load());
|
||
/**
|
||
* Localstorage attempts to return the localstorage.
|
||
*
|
||
* This is necessary because safari throws
|
||
* when a user disables cookies/localstorage
|
||
* and you attempt to access it.
|
||
*
|
||
* @return {LocalStorage}
|
||
* @api private
|
||
*/ function localstorage() {
|
||
try {
|
||
return window.localStorage;
|
||
} catch (e) {}
|
||
}
|
||
|
||
},{"12edbb1af7d8bd3b":"d5jf4","164b7987e493c35c":"W9ObK"}],"d5jf4":[function(require,module,exports) {
|
||
// shim for using process in browser
|
||
var process = module.exports = {};
|
||
// cached from whatever global is present so that test runners that stub it
|
||
// don't break things. But we need to wrap it in a try catch in case it is
|
||
// wrapped in strict mode code which doesn't define any globals. It's inside a
|
||
// function because try/catches deoptimize in certain engines.
|
||
var cachedSetTimeout;
|
||
var cachedClearTimeout;
|
||
function defaultSetTimout() {
|
||
throw new Error("setTimeout has not been defined");
|
||
}
|
||
function defaultClearTimeout() {
|
||
throw new Error("clearTimeout has not been defined");
|
||
}
|
||
(function() {
|
||
try {
|
||
if (typeof setTimeout === "function") cachedSetTimeout = setTimeout;
|
||
else cachedSetTimeout = defaultSetTimout;
|
||
} catch (e) {
|
||
cachedSetTimeout = defaultSetTimout;
|
||
}
|
||
try {
|
||
if (typeof clearTimeout === "function") cachedClearTimeout = clearTimeout;
|
||
else cachedClearTimeout = defaultClearTimeout;
|
||
} catch (e) {
|
||
cachedClearTimeout = defaultClearTimeout;
|
||
}
|
||
})();
|
||
function runTimeout(fun) {
|
||
if (cachedSetTimeout === setTimeout) //normal enviroments in sane situations
|
||
return setTimeout(fun, 0);
|
||
// if setTimeout wasn't available but was latter defined
|
||
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
||
cachedSetTimeout = setTimeout;
|
||
return setTimeout(fun, 0);
|
||
}
|
||
try {
|
||
// when when somebody has screwed with setTimeout but no I.E. maddness
|
||
return cachedSetTimeout(fun, 0);
|
||
} catch (e) {
|
||
try {
|
||
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
||
return cachedSetTimeout.call(null, fun, 0);
|
||
} catch (e) {
|
||
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
||
return cachedSetTimeout.call(this, fun, 0);
|
||
}
|
||
}
|
||
}
|
||
function runClearTimeout(marker) {
|
||
if (cachedClearTimeout === clearTimeout) //normal enviroments in sane situations
|
||
return clearTimeout(marker);
|
||
// if clearTimeout wasn't available but was latter defined
|
||
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
||
cachedClearTimeout = clearTimeout;
|
||
return clearTimeout(marker);
|
||
}
|
||
try {
|
||
// when when somebody has screwed with setTimeout but no I.E. maddness
|
||
return cachedClearTimeout(marker);
|
||
} catch (e) {
|
||
try {
|
||
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
||
return cachedClearTimeout.call(null, marker);
|
||
} catch (e) {
|
||
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
||
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
||
return cachedClearTimeout.call(this, marker);
|
||
}
|
||
}
|
||
}
|
||
var queue = [];
|
||
var draining = false;
|
||
var currentQueue;
|
||
var queueIndex = -1;
|
||
function cleanUpNextTick() {
|
||
if (!draining || !currentQueue) return;
|
||
draining = false;
|
||
if (currentQueue.length) queue = currentQueue.concat(queue);
|
||
else queueIndex = -1;
|
||
if (queue.length) drainQueue();
|
||
}
|
||
function drainQueue() {
|
||
if (draining) return;
|
||
var timeout = runTimeout(cleanUpNextTick);
|
||
draining = true;
|
||
var len = queue.length;
|
||
while(len){
|
||
currentQueue = queue;
|
||
queue = [];
|
||
while(++queueIndex < len)if (currentQueue) currentQueue[queueIndex].run();
|
||
queueIndex = -1;
|
||
len = queue.length;
|
||
}
|
||
currentQueue = null;
|
||
draining = false;
|
||
runClearTimeout(timeout);
|
||
}
|
||
process.nextTick = function(fun) {
|
||
var args = new Array(arguments.length - 1);
|
||
if (arguments.length > 1) for(var i = 1; i < arguments.length; i++)args[i - 1] = arguments[i];
|
||
queue.push(new Item(fun, args));
|
||
if (queue.length === 1 && !draining) runTimeout(drainQueue);
|
||
};
|
||
// v8 likes predictible objects
|
||
function Item(fun, array) {
|
||
this.fun = fun;
|
||
this.array = array;
|
||
}
|
||
Item.prototype.run = function() {
|
||
this.fun.apply(null, this.array);
|
||
};
|
||
process.title = "browser";
|
||
process.browser = true;
|
||
process.env = {};
|
||
process.argv = [];
|
||
process.version = ""; // empty string to avoid regexp issues
|
||
process.versions = {};
|
||
function noop() {}
|
||
process.on = noop;
|
||
process.addListener = noop;
|
||
process.once = noop;
|
||
process.off = noop;
|
||
process.removeListener = noop;
|
||
process.removeAllListeners = noop;
|
||
process.emit = noop;
|
||
process.prependListener = noop;
|
||
process.prependOnceListener = noop;
|
||
process.listeners = function(name) {
|
||
return [];
|
||
};
|
||
process.binding = function(name) {
|
||
throw new Error("process.binding is not supported");
|
||
};
|
||
process.cwd = function() {
|
||
return "/";
|
||
};
|
||
process.chdir = function(dir) {
|
||
throw new Error("process.chdir is not supported");
|
||
};
|
||
process.umask = function() {
|
||
return 0;
|
||
};
|
||
|
||
},{}],"W9ObK":[function(require,module,exports) {
|
||
/**
|
||
* This is the common logic for both the Node.js and web browser
|
||
* implementations of `debug()`.
|
||
*
|
||
* Expose `debug()` as the module.
|
||
*/ exports = module.exports = createDebug.debug = createDebug["default"] = createDebug;
|
||
exports.coerce = coerce;
|
||
exports.disable = disable;
|
||
exports.enable = enable;
|
||
exports.enabled = enabled;
|
||
exports.humanize = require("9e84ac15c703264e");
|
||
/**
|
||
* Active `debug` instances.
|
||
*/ exports.instances = [];
|
||
/**
|
||
* The currently active debug mode names, and names to skip.
|
||
*/ exports.names = [];
|
||
exports.skips = [];
|
||
/**
|
||
* Map of special "%n" handling functions, for the debug "format" argument.
|
||
*
|
||
* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
|
||
*/ exports.formatters = {};
|
||
/**
|
||
* Select a color.
|
||
* @param {String} namespace
|
||
* @return {Number}
|
||
* @api private
|
||
*/ function selectColor(namespace) {
|
||
var hash = 0, i;
|
||
for(i in namespace){
|
||
hash = (hash << 5) - hash + namespace.charCodeAt(i);
|
||
hash |= 0; // Convert to 32bit integer
|
||
}
|
||
return exports.colors[Math.abs(hash) % exports.colors.length];
|
||
}
|
||
/**
|
||
* Create a debugger with the given `namespace`.
|
||
*
|
||
* @param {String} namespace
|
||
* @return {Function}
|
||
* @api public
|
||
*/ function createDebug(namespace) {
|
||
var prevTime;
|
||
function debug() {
|
||
// disabled?
|
||
if (!debug.enabled) return;
|
||
var self = debug;
|
||
// set `diff` timestamp
|
||
var curr = +new Date();
|
||
var ms = curr - (prevTime || curr);
|
||
self.diff = ms;
|
||
self.prev = prevTime;
|
||
self.curr = curr;
|
||
prevTime = curr;
|
||
// turn the `arguments` into a proper Array
|
||
var args = new Array(arguments.length);
|
||
for(var i = 0; i < args.length; i++)args[i] = arguments[i];
|
||
args[0] = exports.coerce(args[0]);
|
||
if ("string" !== typeof args[0]) // anything else let's inspect with %O
|
||
args.unshift("%O");
|
||
// apply any `formatters` transformations
|
||
var index = 0;
|
||
args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
|
||
// if we encounter an escaped % then don't increase the array index
|
||
if (match === "%%") return match;
|
||
index++;
|
||
var formatter = exports.formatters[format];
|
||
if ("function" === typeof formatter) {
|
||
var val = args[index];
|
||
match = formatter.call(self, val);
|
||
// now we need to remove `args[index]` since it's inlined in the `format`
|
||
args.splice(index, 1);
|
||
index--;
|
||
}
|
||
return match;
|
||
});
|
||
// apply env-specific formatting (colors, etc.)
|
||
exports.formatArgs.call(self, args);
|
||
var logFn = debug.log || exports.log || console.log.bind(console);
|
||
logFn.apply(self, args);
|
||
}
|
||
debug.namespace = namespace;
|
||
debug.enabled = exports.enabled(namespace);
|
||
debug.useColors = exports.useColors();
|
||
debug.color = selectColor(namespace);
|
||
debug.destroy = destroy;
|
||
// env-specific initialization logic for debug instances
|
||
if ("function" === typeof exports.init) exports.init(debug);
|
||
exports.instances.push(debug);
|
||
return debug;
|
||
}
|
||
function destroy() {
|
||
var index = exports.instances.indexOf(this);
|
||
if (index !== -1) {
|
||
exports.instances.splice(index, 1);
|
||
return true;
|
||
} else return false;
|
||
}
|
||
/**
|
||
* Enables a debug mode by namespaces. This can include modes
|
||
* separated by a colon and wildcards.
|
||
*
|
||
* @param {String} namespaces
|
||
* @api public
|
||
*/ function enable(namespaces) {
|
||
exports.save(namespaces);
|
||
exports.names = [];
|
||
exports.skips = [];
|
||
var i;
|
||
var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
|
||
var len = split.length;
|
||
for(i = 0; i < len; i++){
|
||
if (!split[i]) continue; // ignore empty strings
|
||
namespaces = split[i].replace(/\*/g, ".*?");
|
||
if (namespaces[0] === "-") exports.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
|
||
else exports.names.push(new RegExp("^" + namespaces + "$"));
|
||
}
|
||
for(i = 0; i < exports.instances.length; i++){
|
||
var instance = exports.instances[i];
|
||
instance.enabled = exports.enabled(instance.namespace);
|
||
}
|
||
}
|
||
/**
|
||
* Disable debug output.
|
||
*
|
||
* @api public
|
||
*/ function disable() {
|
||
exports.enable("");
|
||
}
|
||
/**
|
||
* Returns true if the given mode name is enabled, false otherwise.
|
||
*
|
||
* @param {String} name
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/ function enabled(name) {
|
||
if (name[name.length - 1] === "*") return true;
|
||
var i, len;
|
||
for(i = 0, len = exports.skips.length; i < len; i++){
|
||
if (exports.skips[i].test(name)) return false;
|
||
}
|
||
for(i = 0, len = exports.names.length; i < len; i++){
|
||
if (exports.names[i].test(name)) return true;
|
||
}
|
||
return false;
|
||
}
|
||
/**
|
||
* Coerce `val`.
|
||
*
|
||
* @param {Mixed} val
|
||
* @return {Mixed}
|
||
* @api private
|
||
*/ function coerce(val) {
|
||
if (val instanceof Error) return val.stack || val.message;
|
||
return val;
|
||
}
|
||
|
||
},{"9e84ac15c703264e":"jauEe"}],"jauEe":[function(require,module,exports) {
|
||
/**
|
||
* Helpers.
|
||
*/ var s = 1000;
|
||
var m = s * 60;
|
||
var h = m * 60;
|
||
var d = h * 24;
|
||
var y = d * 365.25;
|
||
/**
|
||
* Parse or format the given `val`.
|
||
*
|
||
* Options:
|
||
*
|
||
* - `long` verbose formatting [false]
|
||
*
|
||
* @param {String|Number} val
|
||
* @param {Object} [options]
|
||
* @throws {Error} throw an error if val is not a non-empty string or a number
|
||
* @return {String|Number}
|
||
* @api public
|
||
*/ module.exports = function(val, options) {
|
||
options = options || {};
|
||
var type = typeof val;
|
||
if (type === "string" && val.length > 0) return parse(val);
|
||
else if (type === "number" && isNaN(val) === false) return options.long ? fmtLong(val) : fmtShort(val);
|
||
throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
|
||
};
|
||
/**
|
||
* Parse the given `str` and return milliseconds.
|
||
*
|
||
* @param {String} str
|
||
* @return {Number}
|
||
* @api private
|
||
*/ function parse(str) {
|
||
str = String(str);
|
||
if (str.length > 100) return;
|
||
var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
|
||
if (!match) return;
|
||
var n = parseFloat(match[1]);
|
||
var type = (match[2] || "ms").toLowerCase();
|
||
switch(type){
|
||
case "years":
|
||
case "year":
|
||
case "yrs":
|
||
case "yr":
|
||
case "y":
|
||
return n * y;
|
||
case "days":
|
||
case "day":
|
||
case "d":
|
||
return n * d;
|
||
case "hours":
|
||
case "hour":
|
||
case "hrs":
|
||
case "hr":
|
||
case "h":
|
||
return n * h;
|
||
case "minutes":
|
||
case "minute":
|
||
case "mins":
|
||
case "min":
|
||
case "m":
|
||
return n * m;
|
||
case "seconds":
|
||
case "second":
|
||
case "secs":
|
||
case "sec":
|
||
case "s":
|
||
return n * s;
|
||
case "milliseconds":
|
||
case "millisecond":
|
||
case "msecs":
|
||
case "msec":
|
||
case "ms":
|
||
return n;
|
||
default:
|
||
return undefined;
|
||
}
|
||
}
|
||
/**
|
||
* Short format for `ms`.
|
||
*
|
||
* @param {Number} ms
|
||
* @return {String}
|
||
* @api private
|
||
*/ function fmtShort(ms) {
|
||
if (ms >= d) return Math.round(ms / d) + "d";
|
||
if (ms >= h) return Math.round(ms / h) + "h";
|
||
if (ms >= m) return Math.round(ms / m) + "m";
|
||
if (ms >= s) return Math.round(ms / s) + "s";
|
||
return ms + "ms";
|
||
}
|
||
/**
|
||
* Long format for `ms`.
|
||
*
|
||
* @param {Number} ms
|
||
* @return {String}
|
||
* @api private
|
||
*/ function fmtLong(ms) {
|
||
return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms";
|
||
}
|
||
/**
|
||
* Pluralization helper.
|
||
*/ function plural(ms, n, name) {
|
||
if (ms < n) return;
|
||
if (ms < n * 1.5) return Math.floor(ms / n) + " " + name;
|
||
return Math.ceil(ms / n) + " " + name + "s";
|
||
}
|
||
|
||
},{}],"iEP88":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var debug = require("366c24e924e4a950")("socket.io-parser");
|
||
var Emitter = require("ad67595a336212b1");
|
||
var binary = require("953f291a69c886c8");
|
||
var isArray = require("a82d98bd8ba0bc00");
|
||
var isBuf = require("feb21716d587608b");
|
||
/**
|
||
* Protocol version.
|
||
*
|
||
* @api public
|
||
*/ exports.protocol = 4;
|
||
/**
|
||
* Packet types.
|
||
*
|
||
* @api public
|
||
*/ exports.types = [
|
||
"CONNECT",
|
||
"DISCONNECT",
|
||
"EVENT",
|
||
"ACK",
|
||
"ERROR",
|
||
"BINARY_EVENT",
|
||
"BINARY_ACK"
|
||
];
|
||
/**
|
||
* Packet type `connect`.
|
||
*
|
||
* @api public
|
||
*/ exports.CONNECT = 0;
|
||
/**
|
||
* Packet type `disconnect`.
|
||
*
|
||
* @api public
|
||
*/ exports.DISCONNECT = 1;
|
||
/**
|
||
* Packet type `event`.
|
||
*
|
||
* @api public
|
||
*/ exports.EVENT = 2;
|
||
/**
|
||
* Packet type `ack`.
|
||
*
|
||
* @api public
|
||
*/ exports.ACK = 3;
|
||
/**
|
||
* Packet type `error`.
|
||
*
|
||
* @api public
|
||
*/ exports.ERROR = 4;
|
||
/**
|
||
* Packet type 'binary event'
|
||
*
|
||
* @api public
|
||
*/ exports.BINARY_EVENT = 5;
|
||
/**
|
||
* Packet type `binary ack`. For acks with binary arguments.
|
||
*
|
||
* @api public
|
||
*/ exports.BINARY_ACK = 6;
|
||
/**
|
||
* Encoder constructor.
|
||
*
|
||
* @api public
|
||
*/ exports.Encoder = Encoder;
|
||
/**
|
||
* Decoder constructor.
|
||
*
|
||
* @api public
|
||
*/ exports.Decoder = Decoder;
|
||
/**
|
||
* A socket.io Encoder instance
|
||
*
|
||
* @api public
|
||
*/ function Encoder() {}
|
||
var ERROR_PACKET = exports.ERROR + '"encode error"';
|
||
/**
|
||
* Encode a packet as a single string if non-binary, or as a
|
||
* buffer sequence, depending on packet type.
|
||
*
|
||
* @param {Object} obj - packet object
|
||
* @param {Function} callback - function to handle encodings (likely engine.write)
|
||
* @return Calls callback with Array of encodings
|
||
* @api public
|
||
*/ Encoder.prototype.encode = function(obj, callback) {
|
||
debug("encoding packet %j", obj);
|
||
if (exports.BINARY_EVENT === obj.type || exports.BINARY_ACK === obj.type) encodeAsBinary(obj, callback);
|
||
else {
|
||
var encoding = encodeAsString(obj);
|
||
callback([
|
||
encoding
|
||
]);
|
||
}
|
||
};
|
||
/**
|
||
* Encode packet as string.
|
||
*
|
||
* @param {Object} packet
|
||
* @return {String} encoded
|
||
* @api private
|
||
*/ function encodeAsString(obj) {
|
||
// first is type
|
||
var str = "" + obj.type;
|
||
// attachments if we have them
|
||
if (exports.BINARY_EVENT === obj.type || exports.BINARY_ACK === obj.type) str += obj.attachments + "-";
|
||
// if we have a namespace other than `/`
|
||
// we append it followed by a comma `,`
|
||
if (obj.nsp && "/" !== obj.nsp) str += obj.nsp + ",";
|
||
// immediately followed by the id
|
||
if (null != obj.id) str += obj.id;
|
||
// json data
|
||
if (null != obj.data) {
|
||
var payload = tryStringify(obj.data);
|
||
if (payload !== false) str += payload;
|
||
else return ERROR_PACKET;
|
||
}
|
||
debug("encoded %j as %s", obj, str);
|
||
return str;
|
||
}
|
||
function tryStringify(str) {
|
||
try {
|
||
return JSON.stringify(str);
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
}
|
||
/**
|
||
* Encode packet as 'buffer sequence' by removing blobs, and
|
||
* deconstructing packet into object with placeholders and
|
||
* a list of buffers.
|
||
*
|
||
* @param {Object} packet
|
||
* @return {Buffer} encoded
|
||
* @api private
|
||
*/ function encodeAsBinary(obj, callback) {
|
||
function writeEncoding(bloblessData) {
|
||
var deconstruction = binary.deconstructPacket(bloblessData);
|
||
var pack = encodeAsString(deconstruction.packet);
|
||
var buffers = deconstruction.buffers;
|
||
buffers.unshift(pack); // add packet info to beginning of data list
|
||
callback(buffers); // write all the buffers
|
||
}
|
||
binary.removeBlobs(obj, writeEncoding);
|
||
}
|
||
/**
|
||
* A socket.io Decoder instance
|
||
*
|
||
* @return {Object} decoder
|
||
* @api public
|
||
*/ function Decoder() {
|
||
this.reconstructor = null;
|
||
}
|
||
/**
|
||
* Mix in `Emitter` with Decoder.
|
||
*/ Emitter(Decoder.prototype);
|
||
/**
|
||
* Decodes an encoded packet string into packet JSON.
|
||
*
|
||
* @param {String} obj - encoded packet
|
||
* @return {Object} packet
|
||
* @api public
|
||
*/ Decoder.prototype.add = function(obj) {
|
||
var packet;
|
||
if (typeof obj === "string") {
|
||
if (this.reconstructor) throw new Error("got plaintext data when reconstructing a packet");
|
||
packet = decodeString(obj);
|
||
if (exports.BINARY_EVENT === packet.type || exports.BINARY_ACK === packet.type) {
|
||
this.reconstructor = new BinaryReconstructor(packet);
|
||
// no attachments, labeled binary but no binary data to follow
|
||
if (this.reconstructor.reconPack.attachments === 0) this.emit("decoded", packet);
|
||
} else this.emit("decoded", packet);
|
||
} else if (isBuf(obj) || obj.base64) {
|
||
if (!this.reconstructor) throw new Error("got binary data when not reconstructing a packet");
|
||
else {
|
||
packet = this.reconstructor.takeBinaryData(obj);
|
||
if (packet) {
|
||
this.reconstructor = null;
|
||
this.emit("decoded", packet);
|
||
}
|
||
}
|
||
} else throw new Error("Unknown type: " + obj);
|
||
};
|
||
/**
|
||
* Decode a packet String (JSON data)
|
||
*
|
||
* @param {String} str
|
||
* @return {Object} packet
|
||
* @api private
|
||
*/ function decodeString(str) {
|
||
var i = 0;
|
||
// look up type
|
||
var p = {
|
||
type: Number(str.charAt(0))
|
||
};
|
||
if (null == exports.types[p.type]) return error("unknown packet type " + p.type);
|
||
// look up attachments if type binary
|
||
if (exports.BINARY_EVENT === p.type || exports.BINARY_ACK === p.type) {
|
||
var start = i + 1;
|
||
while(str.charAt(++i) !== "-" && i != str.length);
|
||
var buf = str.substring(start, i);
|
||
if (buf != Number(buf) || str.charAt(i) !== "-") throw new Error("Illegal attachments");
|
||
p.attachments = Number(buf);
|
||
}
|
||
// look up namespace (if any)
|
||
if ("/" === str.charAt(i + 1)) {
|
||
var start = i + 1;
|
||
while(++i){
|
||
var c = str.charAt(i);
|
||
if ("," === c) break;
|
||
if (i === str.length) break;
|
||
}
|
||
p.nsp = str.substring(start, i);
|
||
} else p.nsp = "/";
|
||
// look up id
|
||
var next = str.charAt(i + 1);
|
||
if ("" !== next && Number(next) == next) {
|
||
var start = i + 1;
|
||
while(++i){
|
||
var c = str.charAt(i);
|
||
if (null == c || Number(c) != c) {
|
||
--i;
|
||
break;
|
||
}
|
||
if (i === str.length) break;
|
||
}
|
||
p.id = Number(str.substring(start, i + 1));
|
||
}
|
||
// look up json data
|
||
if (str.charAt(++i)) {
|
||
var payload = tryParse(str.substr(i));
|
||
var isPayloadValid = payload !== false && (p.type === exports.ERROR || isArray(payload));
|
||
if (isPayloadValid) p.data = payload;
|
||
else return error("invalid payload");
|
||
}
|
||
debug("decoded %s as %j", str, p);
|
||
return p;
|
||
}
|
||
function tryParse(str) {
|
||
try {
|
||
return JSON.parse(str);
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
}
|
||
/**
|
||
* Deallocates a parser's resources
|
||
*
|
||
* @api public
|
||
*/ Decoder.prototype.destroy = function() {
|
||
if (this.reconstructor) this.reconstructor.finishedReconstruction();
|
||
};
|
||
/**
|
||
* A manager of a binary event's 'buffer sequence'. Should
|
||
* be constructed whenever a packet of type BINARY_EVENT is
|
||
* decoded.
|
||
*
|
||
* @param {Object} packet
|
||
* @return {BinaryReconstructor} initialized reconstructor
|
||
* @api private
|
||
*/ function BinaryReconstructor(packet) {
|
||
this.reconPack = packet;
|
||
this.buffers = [];
|
||
}
|
||
/**
|
||
* Method to be called when binary data received from connection
|
||
* after a BINARY_EVENT packet.
|
||
*
|
||
* @param {Buffer | ArrayBuffer} binData - the raw binary data received
|
||
* @return {null | Object} returns null if more binary data is expected or
|
||
* a reconstructed packet object if all buffers have been received.
|
||
* @api private
|
||
*/ BinaryReconstructor.prototype.takeBinaryData = function(binData) {
|
||
this.buffers.push(binData);
|
||
if (this.buffers.length === this.reconPack.attachments) {
|
||
var packet = binary.reconstructPacket(this.reconPack, this.buffers);
|
||
this.finishedReconstruction();
|
||
return packet;
|
||
}
|
||
return null;
|
||
};
|
||
/**
|
||
* Cleans up binary packet reconstruction variables.
|
||
*
|
||
* @api private
|
||
*/ BinaryReconstructor.prototype.finishedReconstruction = function() {
|
||
this.reconPack = null;
|
||
this.buffers = [];
|
||
};
|
||
function error(msg) {
|
||
return {
|
||
type: exports.ERROR,
|
||
data: "parser error: " + msg
|
||
};
|
||
}
|
||
|
||
},{"366c24e924e4a950":"l0oUb","ad67595a336212b1":"5nHrO","953f291a69c886c8":"eUwTZ","a82d98bd8ba0bc00":"hk7XJ","feb21716d587608b":"4tjYH"}],"5nHrO":[function(require,module,exports) {
|
||
/**
|
||
* Expose `Emitter`.
|
||
*/ module.exports = Emitter;
|
||
/**
|
||
* Initialize a new `Emitter`.
|
||
*
|
||
* @api public
|
||
*/ function Emitter(obj) {
|
||
if (obj) return mixin(obj);
|
||
}
|
||
/**
|
||
* Mixin the emitter properties.
|
||
*
|
||
* @param {Object} obj
|
||
* @return {Object}
|
||
* @api private
|
||
*/ function mixin(obj) {
|
||
for(var key in Emitter.prototype)obj[key] = Emitter.prototype[key];
|
||
return obj;
|
||
}
|
||
/**
|
||
* Listen on the given `event` with `fn`.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/ Emitter.prototype.on = Emitter.prototype.addEventListener = function(event, fn) {
|
||
this._callbacks = this._callbacks || {};
|
||
(this._callbacks["$" + event] = this._callbacks["$" + event] || []).push(fn);
|
||
return this;
|
||
};
|
||
/**
|
||
* Adds an `event` listener that will be invoked a single
|
||
* time then automatically removed.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/ Emitter.prototype.once = function(event, fn) {
|
||
function on() {
|
||
this.off(event, on);
|
||
fn.apply(this, arguments);
|
||
}
|
||
on.fn = fn;
|
||
this.on(event, on);
|
||
return this;
|
||
};
|
||
/**
|
||
* Remove the given callback for `event` or all
|
||
* registered callbacks.
|
||
*
|
||
* @param {String} event
|
||
* @param {Function} fn
|
||
* @return {Emitter}
|
||
* @api public
|
||
*/ Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function(event, fn) {
|
||
this._callbacks = this._callbacks || {};
|
||
// all
|
||
if (0 == arguments.length) {
|
||
this._callbacks = {};
|
||
return this;
|
||
}
|
||
// specific event
|
||
var callbacks = this._callbacks["$" + event];
|
||
if (!callbacks) return this;
|
||
// remove all handlers
|
||
if (1 == arguments.length) {
|
||
delete this._callbacks["$" + event];
|
||
return this;
|
||
}
|
||
// remove specific handler
|
||
var cb;
|
||
for(var i = 0; i < callbacks.length; i++){
|
||
cb = callbacks[i];
|
||
if (cb === fn || cb.fn === fn) {
|
||
callbacks.splice(i, 1);
|
||
break;
|
||
}
|
||
}
|
||
// Remove event specific arrays for event types that no
|
||
// one is subscribed for to avoid memory leak.
|
||
if (callbacks.length === 0) delete this._callbacks["$" + event];
|
||
return this;
|
||
};
|
||
/**
|
||
* Emit `event` with the given args.
|
||
*
|
||
* @param {String} event
|
||
* @param {Mixed} ...
|
||
* @return {Emitter}
|
||
*/ Emitter.prototype.emit = function(event) {
|
||
this._callbacks = this._callbacks || {};
|
||
var args = new Array(arguments.length - 1), callbacks = this._callbacks["$" + event];
|
||
for(var i = 1; i < arguments.length; i++)args[i - 1] = arguments[i];
|
||
if (callbacks) {
|
||
callbacks = callbacks.slice(0);
|
||
for(var i = 0, len = callbacks.length; i < len; ++i)callbacks[i].apply(this, args);
|
||
}
|
||
return this;
|
||
};
|
||
/**
|
||
* Return array of callbacks for `event`.
|
||
*
|
||
* @param {String} event
|
||
* @return {Array}
|
||
* @api public
|
||
*/ Emitter.prototype.listeners = function(event) {
|
||
this._callbacks = this._callbacks || {};
|
||
return this._callbacks["$" + event] || [];
|
||
};
|
||
/**
|
||
* Check if this emitter has `event` handlers.
|
||
*
|
||
* @param {String} event
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/ Emitter.prototype.hasListeners = function(event) {
|
||
return !!this.listeners(event).length;
|
||
};
|
||
|
||
},{}],"eUwTZ":[function(require,module,exports) {
|
||
/*global Blob,File*/ /**
|
||
* Module requirements
|
||
*/ var isArray = require("7a1ca0164409c8f0");
|
||
var isBuf = require("90b57d5b5423a10e");
|
||
var toString = Object.prototype.toString;
|
||
var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && toString.call(Blob) === "[object BlobConstructor]";
|
||
var withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString.call(File) === "[object FileConstructor]";
|
||
/**
|
||
* Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.
|
||
* Anything with blobs or files should be fed through removeBlobs before coming
|
||
* here.
|
||
*
|
||
* @param {Object} packet - socket.io event packet
|
||
* @return {Object} with deconstructed packet and list of buffers
|
||
* @api public
|
||
*/ exports.deconstructPacket = function(packet) {
|
||
var buffers = [];
|
||
var packetData = packet.data;
|
||
var pack = packet;
|
||
pack.data = _deconstructPacket(packetData, buffers);
|
||
pack.attachments = buffers.length; // number of binary 'attachments'
|
||
return {
|
||
packet: pack,
|
||
buffers: buffers
|
||
};
|
||
};
|
||
function _deconstructPacket(data, buffers) {
|
||
if (!data) return data;
|
||
if (isBuf(data)) {
|
||
var placeholder = {
|
||
_placeholder: true,
|
||
num: buffers.length
|
||
};
|
||
buffers.push(data);
|
||
return placeholder;
|
||
} else if (isArray(data)) {
|
||
var newData = new Array(data.length);
|
||
for(var i = 0; i < data.length; i++)newData[i] = _deconstructPacket(data[i], buffers);
|
||
return newData;
|
||
} else if (typeof data === "object" && !(data instanceof Date)) {
|
||
var newData = {};
|
||
for(var key in data)newData[key] = _deconstructPacket(data[key], buffers);
|
||
return newData;
|
||
}
|
||
return data;
|
||
}
|
||
/**
|
||
* Reconstructs a binary packet from its placeholder packet and buffers
|
||
*
|
||
* @param {Object} packet - event packet with placeholders
|
||
* @param {Array} buffers - binary buffers to put in placeholder positions
|
||
* @return {Object} reconstructed packet
|
||
* @api public
|
||
*/ exports.reconstructPacket = function(packet, buffers) {
|
||
packet.data = _reconstructPacket(packet.data, buffers);
|
||
packet.attachments = undefined; // no longer useful
|
||
return packet;
|
||
};
|
||
function _reconstructPacket(data, buffers) {
|
||
if (!data) return data;
|
||
if (data && data._placeholder === true) {
|
||
var isIndexValid = typeof data.num === "number" && data.num >= 0 && data.num < buffers.length;
|
||
if (isIndexValid) return buffers[data.num]; // appropriate buffer (should be natural order anyway)
|
||
else throw new Error("illegal attachments");
|
||
} else if (isArray(data)) for(var i = 0; i < data.length; i++)data[i] = _reconstructPacket(data[i], buffers);
|
||
else if (typeof data === "object") for(var key in data)data[key] = _reconstructPacket(data[key], buffers);
|
||
return data;
|
||
}
|
||
/**
|
||
* Asynchronously removes Blobs or Files from data via
|
||
* FileReader's readAsArrayBuffer method. Used before encoding
|
||
* data as msgpack. Calls callback with the blobless data.
|
||
*
|
||
* @param {Object} data
|
||
* @param {Function} callback
|
||
* @api private
|
||
*/ exports.removeBlobs = function(data, callback) {
|
||
function _removeBlobs(obj, curKey, containingObject) {
|
||
if (!obj) return obj;
|
||
// convert any blob
|
||
if (withNativeBlob && obj instanceof Blob || withNativeFile && obj instanceof File) {
|
||
pendingBlobs++;
|
||
// async filereader
|
||
var fileReader = new FileReader();
|
||
fileReader.onload = function() {
|
||
if (containingObject) containingObject[curKey] = this.result;
|
||
else bloblessData = this.result;
|
||
// if nothing pending its callback time
|
||
if (!--pendingBlobs) callback(bloblessData);
|
||
};
|
||
fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer
|
||
} else if (isArray(obj)) for(var i = 0; i < obj.length; i++)_removeBlobs(obj[i], i, obj);
|
||
else if (typeof obj === "object" && !isBuf(obj)) for(var key in obj)_removeBlobs(obj[key], key, obj);
|
||
}
|
||
var pendingBlobs = 0;
|
||
var bloblessData = data;
|
||
_removeBlobs(bloblessData);
|
||
if (!pendingBlobs) callback(bloblessData);
|
||
};
|
||
|
||
},{"7a1ca0164409c8f0":"hk7XJ","90b57d5b5423a10e":"4tjYH"}],"hk7XJ":[function(require,module,exports) {
|
||
var toString = {}.toString;
|
||
module.exports = Array.isArray || function(arr) {
|
||
return toString.call(arr) == "[object Array]";
|
||
};
|
||
|
||
},{}],"4tjYH":[function(require,module,exports) {
|
||
var Buffer = require("500f9fc6063dba12").Buffer;
|
||
module.exports = isBuf;
|
||
var withNativeBuffer = typeof Buffer === "function" && typeof Buffer.isBuffer === "function";
|
||
var withNativeArrayBuffer = typeof ArrayBuffer === "function";
|
||
var isView = function(obj) {
|
||
return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer;
|
||
};
|
||
/**
|
||
* Returns true if obj is a buffer or an arraybuffer.
|
||
*
|
||
* @api private
|
||
*/ function isBuf(obj) {
|
||
return withNativeBuffer && Buffer.isBuffer(obj) || withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj));
|
||
}
|
||
|
||
},{"500f9fc6063dba12":"fCgem"}],"fCgem":[function(require,module,exports) {
|
||
/*!
|
||
* The buffer module from node.js, for the browser.
|
||
*
|
||
* @author Feross Aboukhadijeh <https://feross.org>
|
||
* @license MIT
|
||
*/ /* eslint-disable no-proto */ "use strict";
|
||
const base64 = require("9c62938f1dccc73c");
|
||
const ieee754 = require("aceacb6a4531a9d2");
|
||
const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" // eslint-disable-line dot-notation
|
||
? Symbol["for"]("nodejs.util.inspect.custom") // eslint-disable-line dot-notation
|
||
: null;
|
||
exports.Buffer = Buffer;
|
||
exports.SlowBuffer = SlowBuffer;
|
||
exports.INSPECT_MAX_BYTES = 50;
|
||
const K_MAX_LENGTH = 0x7fffffff;
|
||
exports.kMaxLength = K_MAX_LENGTH;
|
||
/**
|
||
* If `Buffer.TYPED_ARRAY_SUPPORT`:
|
||
* === true Use Uint8Array implementation (fastest)
|
||
* === false Print warning and recommend using `buffer` v4.x which has an Object
|
||
* implementation (most compatible, even IE6)
|
||
*
|
||
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
|
||
* Opera 11.6+, iOS 4.2+.
|
||
*
|
||
* We report that the browser does not support typed arrays if the are not subclassable
|
||
* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
|
||
* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
|
||
* for __proto__ and has a buggy typed array implementation.
|
||
*/ Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
|
||
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
|
||
function typedArraySupport() {
|
||
// Can typed array instances can be augmented?
|
||
try {
|
||
const arr = new Uint8Array(1);
|
||
const proto = {
|
||
foo: function() {
|
||
return 42;
|
||
}
|
||
};
|
||
Object.setPrototypeOf(proto, Uint8Array.prototype);
|
||
Object.setPrototypeOf(arr, proto);
|
||
return arr.foo() === 42;
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
}
|
||
Object.defineProperty(Buffer.prototype, "parent", {
|
||
enumerable: true,
|
||
get: function() {
|
||
if (!Buffer.isBuffer(this)) return undefined;
|
||
return this.buffer;
|
||
}
|
||
});
|
||
Object.defineProperty(Buffer.prototype, "offset", {
|
||
enumerable: true,
|
||
get: function() {
|
||
if (!Buffer.isBuffer(this)) return undefined;
|
||
return this.byteOffset;
|
||
}
|
||
});
|
||
function createBuffer(length) {
|
||
if (length > K_MAX_LENGTH) throw new RangeError('The value "' + length + '" is invalid for option "size"');
|
||
// Return an augmented `Uint8Array` instance
|
||
const buf = new Uint8Array(length);
|
||
Object.setPrototypeOf(buf, Buffer.prototype);
|
||
return buf;
|
||
}
|
||
/**
|
||
* The Buffer constructor returns instances of `Uint8Array` that have their
|
||
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
|
||
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
|
||
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
|
||
* returns a single octet.
|
||
*
|
||
* The `Uint8Array` prototype remains unmodified.
|
||
*/ function Buffer(arg, encodingOrOffset, length) {
|
||
// Common case.
|
||
if (typeof arg === "number") {
|
||
if (typeof encodingOrOffset === "string") throw new TypeError('The "string" argument must be of type string. Received type number');
|
||
return allocUnsafe(arg);
|
||
}
|
||
return from(arg, encodingOrOffset, length);
|
||
}
|
||
Buffer.poolSize = 8192 // not used by this implementation
|
||
;
|
||
function from(value, encodingOrOffset, length) {
|
||
if (typeof value === "string") return fromString(value, encodingOrOffset);
|
||
if (ArrayBuffer.isView(value)) return fromArrayView(value);
|
||
if (value == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
|
||
if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) return fromArrayBuffer(value, encodingOrOffset, length);
|
||
if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) return fromArrayBuffer(value, encodingOrOffset, length);
|
||
if (typeof value === "number") throw new TypeError('The "value" argument must not be of type number. Received type number');
|
||
const valueOf = value.valueOf && value.valueOf();
|
||
if (valueOf != null && valueOf !== value) return Buffer.from(valueOf, encodingOrOffset, length);
|
||
const b = fromObject(value);
|
||
if (b) return b;
|
||
if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") return Buffer.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
|
||
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
|
||
}
|
||
/**
|
||
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
|
||
* if value is a number.
|
||
* Buffer.from(str[, encoding])
|
||
* Buffer.from(array)
|
||
* Buffer.from(buffer)
|
||
* Buffer.from(arrayBuffer[, byteOffset[, length]])
|
||
**/ Buffer.from = function(value, encodingOrOffset, length) {
|
||
return from(value, encodingOrOffset, length);
|
||
};
|
||
// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
|
||
// https://github.com/feross/buffer/pull/148
|
||
Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype);
|
||
Object.setPrototypeOf(Buffer, Uint8Array);
|
||
function assertSize(size) {
|
||
if (typeof size !== "number") throw new TypeError('"size" argument must be of type number');
|
||
else if (size < 0) throw new RangeError('The value "' + size + '" is invalid for option "size"');
|
||
}
|
||
function alloc(size, fill, encoding) {
|
||
assertSize(size);
|
||
if (size <= 0) return createBuffer(size);
|
||
if (fill !== undefined) // Only pay attention to encoding if it's a string. This
|
||
// prevents accidentally sending in a number that would
|
||
// be interpreted as a start offset.
|
||
return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
|
||
return createBuffer(size);
|
||
}
|
||
/**
|
||
* Creates a new filled Buffer instance.
|
||
* alloc(size[, fill[, encoding]])
|
||
**/ Buffer.alloc = function(size, fill, encoding) {
|
||
return alloc(size, fill, encoding);
|
||
};
|
||
function allocUnsafe(size) {
|
||
assertSize(size);
|
||
return createBuffer(size < 0 ? 0 : checked(size) | 0);
|
||
}
|
||
/**
|
||
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
|
||
* */ Buffer.allocUnsafe = function(size) {
|
||
return allocUnsafe(size);
|
||
};
|
||
/**
|
||
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
|
||
*/ Buffer.allocUnsafeSlow = function(size) {
|
||
return allocUnsafe(size);
|
||
};
|
||
function fromString(string, encoding) {
|
||
if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
|
||
if (!Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
|
||
const length = byteLength(string, encoding) | 0;
|
||
let buf = createBuffer(length);
|
||
const actual = buf.write(string, encoding);
|
||
if (actual !== length) // Writing a hex string, for example, that contains invalid characters will
|
||
// cause everything after the first invalid character to be ignored. (e.g.
|
||
// 'abxxcd' will be treated as 'ab')
|
||
buf = buf.slice(0, actual);
|
||
return buf;
|
||
}
|
||
function fromArrayLike(array) {
|
||
const length = array.length < 0 ? 0 : checked(array.length) | 0;
|
||
const buf = createBuffer(length);
|
||
for(let i = 0; i < length; i += 1)buf[i] = array[i] & 255;
|
||
return buf;
|
||
}
|
||
function fromArrayView(arrayView) {
|
||
if (isInstance(arrayView, Uint8Array)) {
|
||
const copy = new Uint8Array(arrayView);
|
||
return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
|
||
}
|
||
return fromArrayLike(arrayView);
|
||
}
|
||
function fromArrayBuffer(array, byteOffset, length) {
|
||
if (byteOffset < 0 || array.byteLength < byteOffset) throw new RangeError('"offset" is outside of buffer bounds');
|
||
if (array.byteLength < byteOffset + (length || 0)) throw new RangeError('"length" is outside of buffer bounds');
|
||
let buf;
|
||
if (byteOffset === undefined && length === undefined) buf = new Uint8Array(array);
|
||
else if (length === undefined) buf = new Uint8Array(array, byteOffset);
|
||
else buf = new Uint8Array(array, byteOffset, length);
|
||
// Return an augmented `Uint8Array` instance
|
||
Object.setPrototypeOf(buf, Buffer.prototype);
|
||
return buf;
|
||
}
|
||
function fromObject(obj) {
|
||
if (Buffer.isBuffer(obj)) {
|
||
const len = checked(obj.length) | 0;
|
||
const buf = createBuffer(len);
|
||
if (buf.length === 0) return buf;
|
||
obj.copy(buf, 0, 0, len);
|
||
return buf;
|
||
}
|
||
if (obj.length !== undefined) {
|
||
if (typeof obj.length !== "number" || numberIsNaN(obj.length)) return createBuffer(0);
|
||
return fromArrayLike(obj);
|
||
}
|
||
if (obj.type === "Buffer" && Array.isArray(obj.data)) return fromArrayLike(obj.data);
|
||
}
|
||
function checked(length) {
|
||
// Note: cannot use `length < K_MAX_LENGTH` here because that fails when
|
||
// length is NaN (which is otherwise coerced to zero.)
|
||
if (length >= K_MAX_LENGTH) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
|
||
return length | 0;
|
||
}
|
||
function SlowBuffer(length) {
|
||
if (+length != length) length = 0;
|
||
return Buffer.alloc(+length);
|
||
}
|
||
Buffer.isBuffer = function isBuffer(b) {
|
||
return b != null && b._isBuffer === true && b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
|
||
;
|
||
};
|
||
Buffer.compare = function compare(a, b) {
|
||
if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
|
||
if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
|
||
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
|
||
if (a === b) return 0;
|
||
let x = a.length;
|
||
let y = b.length;
|
||
for(let i = 0, len = Math.min(x, y); i < len; ++i)if (a[i] !== b[i]) {
|
||
x = a[i];
|
||
y = b[i];
|
||
break;
|
||
}
|
||
if (x < y) return -1;
|
||
if (y < x) return 1;
|
||
return 0;
|
||
};
|
||
Buffer.isEncoding = function isEncoding(encoding) {
|
||
switch(String(encoding).toLowerCase()){
|
||
case "hex":
|
||
case "utf8":
|
||
case "utf-8":
|
||
case "ascii":
|
||
case "latin1":
|
||
case "binary":
|
||
case "base64":
|
||
case "ucs2":
|
||
case "ucs-2":
|
||
case "utf16le":
|
||
case "utf-16le":
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
};
|
||
Buffer.concat = function concat(list, length) {
|
||
if (!Array.isArray(list)) throw new TypeError('"list" argument must be an Array of Buffers');
|
||
if (list.length === 0) return Buffer.alloc(0);
|
||
let i;
|
||
if (length === undefined) {
|
||
length = 0;
|
||
for(i = 0; i < list.length; ++i)length += list[i].length;
|
||
}
|
||
const buffer = Buffer.allocUnsafe(length);
|
||
let pos = 0;
|
||
for(i = 0; i < list.length; ++i){
|
||
let buf = list[i];
|
||
if (isInstance(buf, Uint8Array)) {
|
||
if (pos + buf.length > buffer.length) {
|
||
if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
|
||
buf.copy(buffer, pos);
|
||
} else Uint8Array.prototype.set.call(buffer, buf, pos);
|
||
} else if (!Buffer.isBuffer(buf)) throw new TypeError('"list" argument must be an Array of Buffers');
|
||
else buf.copy(buffer, pos);
|
||
pos += buf.length;
|
||
}
|
||
return buffer;
|
||
};
|
||
function byteLength(string, encoding) {
|
||
if (Buffer.isBuffer(string)) return string.length;
|
||
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) return string.byteLength;
|
||
if (typeof string !== "string") throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string);
|
||
const len = string.length;
|
||
const mustMatch = arguments.length > 2 && arguments[2] === true;
|
||
if (!mustMatch && len === 0) return 0;
|
||
// Use a for loop to avoid recursion
|
||
let loweredCase = false;
|
||
for(;;)switch(encoding){
|
||
case "ascii":
|
||
case "latin1":
|
||
case "binary":
|
||
return len;
|
||
case "utf8":
|
||
case "utf-8":
|
||
return utf8ToBytes(string).length;
|
||
case "ucs2":
|
||
case "ucs-2":
|
||
case "utf16le":
|
||
case "utf-16le":
|
||
return len * 2;
|
||
case "hex":
|
||
return len >>> 1;
|
||
case "base64":
|
||
return base64ToBytes(string).length;
|
||
default:
|
||
if (loweredCase) return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
|
||
;
|
||
encoding = ("" + encoding).toLowerCase();
|
||
loweredCase = true;
|
||
}
|
||
}
|
||
Buffer.byteLength = byteLength;
|
||
function slowToString(encoding, start, end) {
|
||
let loweredCase = false;
|
||
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
|
||
// property of a typed array.
|
||
// This behaves neither like String nor Uint8Array in that we set start/end
|
||
// to their upper/lower bounds if the value passed is out of range.
|
||
// undefined is handled specially as per ECMA-262 6th Edition,
|
||
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
|
||
if (start === undefined || start < 0) start = 0;
|
||
// Return early if start > this.length. Done here to prevent potential uint32
|
||
// coercion fail below.
|
||
if (start > this.length) return "";
|
||
if (end === undefined || end > this.length) end = this.length;
|
||
if (end <= 0) return "";
|
||
// Force coercion to uint32. This will also coerce falsey/NaN values to 0.
|
||
end >>>= 0;
|
||
start >>>= 0;
|
||
if (end <= start) return "";
|
||
if (!encoding) encoding = "utf8";
|
||
while(true)switch(encoding){
|
||
case "hex":
|
||
return hexSlice(this, start, end);
|
||
case "utf8":
|
||
case "utf-8":
|
||
return utf8Slice(this, start, end);
|
||
case "ascii":
|
||
return asciiSlice(this, start, end);
|
||
case "latin1":
|
||
case "binary":
|
||
return latin1Slice(this, start, end);
|
||
case "base64":
|
||
return base64Slice(this, start, end);
|
||
case "ucs2":
|
||
case "ucs-2":
|
||
case "utf16le":
|
||
case "utf-16le":
|
||
return utf16leSlice(this, start, end);
|
||
default:
|
||
if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
|
||
encoding = (encoding + "").toLowerCase();
|
||
loweredCase = true;
|
||
}
|
||
}
|
||
// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
|
||
// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
|
||
// reliably in a browserify context because there could be multiple different
|
||
// copies of the 'buffer' package in use. This method works even for Buffer
|
||
// instances that were created from another copy of the `buffer` package.
|
||
// See: https://github.com/feross/buffer/issues/154
|
||
Buffer.prototype._isBuffer = true;
|
||
function swap(b, n, m) {
|
||
const i = b[n];
|
||
b[n] = b[m];
|
||
b[m] = i;
|
||
}
|
||
Buffer.prototype.swap16 = function swap16() {
|
||
const len = this.length;
|
||
if (len % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
|
||
for(let i = 0; i < len; i += 2)swap(this, i, i + 1);
|
||
return this;
|
||
};
|
||
Buffer.prototype.swap32 = function swap32() {
|
||
const len = this.length;
|
||
if (len % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
|
||
for(let i = 0; i < len; i += 4){
|
||
swap(this, i, i + 3);
|
||
swap(this, i + 1, i + 2);
|
||
}
|
||
return this;
|
||
};
|
||
Buffer.prototype.swap64 = function swap64() {
|
||
const len = this.length;
|
||
if (len % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
|
||
for(let i = 0; i < len; i += 8){
|
||
swap(this, i, i + 7);
|
||
swap(this, i + 1, i + 6);
|
||
swap(this, i + 2, i + 5);
|
||
swap(this, i + 3, i + 4);
|
||
}
|
||
return this;
|
||
};
|
||
Buffer.prototype.toString = function toString() {
|
||
const length = this.length;
|
||
if (length === 0) return "";
|
||
if (arguments.length === 0) return utf8Slice(this, 0, length);
|
||
return slowToString.apply(this, arguments);
|
||
};
|
||
Buffer.prototype.toLocaleString = Buffer.prototype.toString;
|
||
Buffer.prototype.equals = function equals(b) {
|
||
if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
|
||
if (this === b) return true;
|
||
return Buffer.compare(this, b) === 0;
|
||
};
|
||
Buffer.prototype.inspect = function inspect() {
|
||
let str = "";
|
||
const max = exports.INSPECT_MAX_BYTES;
|
||
str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
|
||
if (this.length > max) str += " ... ";
|
||
return "<Buffer " + str + ">";
|
||
};
|
||
if (customInspectSymbol) Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
|
||
Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
|
||
if (isInstance(target, Uint8Array)) target = Buffer.from(target, target.offset, target.byteLength);
|
||
if (!Buffer.isBuffer(target)) throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
|
||
if (start === undefined) start = 0;
|
||
if (end === undefined) end = target ? target.length : 0;
|
||
if (thisStart === undefined) thisStart = 0;
|
||
if (thisEnd === undefined) thisEnd = this.length;
|
||
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) throw new RangeError("out of range index");
|
||
if (thisStart >= thisEnd && start >= end) return 0;
|
||
if (thisStart >= thisEnd) return -1;
|
||
if (start >= end) return 1;
|
||
start >>>= 0;
|
||
end >>>= 0;
|
||
thisStart >>>= 0;
|
||
thisEnd >>>= 0;
|
||
if (this === target) return 0;
|
||
let x = thisEnd - thisStart;
|
||
let y = end - start;
|
||
const len = Math.min(x, y);
|
||
const thisCopy = this.slice(thisStart, thisEnd);
|
||
const targetCopy = target.slice(start, end);
|
||
for(let i = 0; i < len; ++i)if (thisCopy[i] !== targetCopy[i]) {
|
||
x = thisCopy[i];
|
||
y = targetCopy[i];
|
||
break;
|
||
}
|
||
if (x < y) return -1;
|
||
if (y < x) return 1;
|
||
return 0;
|
||
};
|
||
// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
|
||
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
|
||
//
|
||
// Arguments:
|
||
// - buffer - a Buffer to search
|
||
// - val - a string, Buffer, or number
|
||
// - byteOffset - an index into `buffer`; will be clamped to an int32
|
||
// - encoding - an optional encoding, relevant is val is a string
|
||
// - dir - true for indexOf, false for lastIndexOf
|
||
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
|
||
// Empty buffer means no match
|
||
if (buffer.length === 0) return -1;
|
||
// Normalize byteOffset
|
||
if (typeof byteOffset === "string") {
|
||
encoding = byteOffset;
|
||
byteOffset = 0;
|
||
} else if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff;
|
||
else if (byteOffset < -2147483648) byteOffset = -2147483648;
|
||
byteOffset = +byteOffset // Coerce to Number.
|
||
;
|
||
if (numberIsNaN(byteOffset)) // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
|
||
byteOffset = dir ? 0 : buffer.length - 1;
|
||
// Normalize byteOffset: negative offsets start from the end of the buffer
|
||
if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
|
||
if (byteOffset >= buffer.length) {
|
||
if (dir) return -1;
|
||
else byteOffset = buffer.length - 1;
|
||
} else if (byteOffset < 0) {
|
||
if (dir) byteOffset = 0;
|
||
else return -1;
|
||
}
|
||
// Normalize val
|
||
if (typeof val === "string") val = Buffer.from(val, encoding);
|
||
// Finally, search either indexOf (if dir is true) or lastIndexOf
|
||
if (Buffer.isBuffer(val)) {
|
||
// Special case: looking for empty string/buffer always fails
|
||
if (val.length === 0) return -1;
|
||
return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
|
||
} else if (typeof val === "number") {
|
||
val = val & 0xFF // Search for a byte value [0-255]
|
||
;
|
||
if (typeof Uint8Array.prototype.indexOf === "function") {
|
||
if (dir) return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
|
||
else return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
|
||
}
|
||
return arrayIndexOf(buffer, [
|
||
val
|
||
], byteOffset, encoding, dir);
|
||
}
|
||
throw new TypeError("val must be string, number or Buffer");
|
||
}
|
||
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
|
||
let indexSize = 1;
|
||
let arrLength = arr.length;
|
||
let valLength = val.length;
|
||
if (encoding !== undefined) {
|
||
encoding = String(encoding).toLowerCase();
|
||
if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
|
||
if (arr.length < 2 || val.length < 2) return -1;
|
||
indexSize = 2;
|
||
arrLength /= 2;
|
||
valLength /= 2;
|
||
byteOffset /= 2;
|
||
}
|
||
}
|
||
function read(buf, i) {
|
||
if (indexSize === 1) return buf[i];
|
||
else return buf.readUInt16BE(i * indexSize);
|
||
}
|
||
let i;
|
||
if (dir) {
|
||
let foundIndex = -1;
|
||
for(i = byteOffset; i < arrLength; i++)if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
|
||
if (foundIndex === -1) foundIndex = i;
|
||
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
|
||
} else {
|
||
if (foundIndex !== -1) i -= i - foundIndex;
|
||
foundIndex = -1;
|
||
}
|
||
} else {
|
||
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
|
||
for(i = byteOffset; i >= 0; i--){
|
||
let found = true;
|
||
for(let j = 0; j < valLength; j++)if (read(arr, i + j) !== read(val, j)) {
|
||
found = false;
|
||
break;
|
||
}
|
||
if (found) return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
|
||
return this.indexOf(val, byteOffset, encoding) !== -1;
|
||
};
|
||
Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
|
||
return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
|
||
};
|
||
Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
|
||
return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
|
||
};
|
||
function hexWrite(buf, string, offset, length) {
|
||
offset = Number(offset) || 0;
|
||
const remaining = buf.length - offset;
|
||
if (!length) length = remaining;
|
||
else {
|
||
length = Number(length);
|
||
if (length > remaining) length = remaining;
|
||
}
|
||
const strLen = string.length;
|
||
if (length > strLen / 2) length = strLen / 2;
|
||
let i;
|
||
for(i = 0; i < length; ++i){
|
||
const parsed = parseInt(string.substr(i * 2, 2), 16);
|
||
if (numberIsNaN(parsed)) return i;
|
||
buf[offset + i] = parsed;
|
||
}
|
||
return i;
|
||
}
|
||
function utf8Write(buf, string, offset, length) {
|
||
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
|
||
}
|
||
function asciiWrite(buf, string, offset, length) {
|
||
return blitBuffer(asciiToBytes(string), buf, offset, length);
|
||
}
|
||
function base64Write(buf, string, offset, length) {
|
||
return blitBuffer(base64ToBytes(string), buf, offset, length);
|
||
}
|
||
function ucs2Write(buf, string, offset, length) {
|
||
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
|
||
}
|
||
Buffer.prototype.write = function write(string, offset, length, encoding) {
|
||
// Buffer#write(string)
|
||
if (offset === undefined) {
|
||
encoding = "utf8";
|
||
length = this.length;
|
||
offset = 0;
|
||
// Buffer#write(string, encoding)
|
||
} else if (length === undefined && typeof offset === "string") {
|
||
encoding = offset;
|
||
length = this.length;
|
||
offset = 0;
|
||
// Buffer#write(string, offset[, length][, encoding])
|
||
} else if (isFinite(offset)) {
|
||
offset = offset >>> 0;
|
||
if (isFinite(length)) {
|
||
length = length >>> 0;
|
||
if (encoding === undefined) encoding = "utf8";
|
||
} else {
|
||
encoding = length;
|
||
length = undefined;
|
||
}
|
||
} else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
|
||
const remaining = this.length - offset;
|
||
if (length === undefined || length > remaining) length = remaining;
|
||
if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) throw new RangeError("Attempt to write outside buffer bounds");
|
||
if (!encoding) encoding = "utf8";
|
||
let loweredCase = false;
|
||
for(;;)switch(encoding){
|
||
case "hex":
|
||
return hexWrite(this, string, offset, length);
|
||
case "utf8":
|
||
case "utf-8":
|
||
return utf8Write(this, string, offset, length);
|
||
case "ascii":
|
||
case "latin1":
|
||
case "binary":
|
||
return asciiWrite(this, string, offset, length);
|
||
case "base64":
|
||
// Warning: maxLength not taken into account in base64Write
|
||
return base64Write(this, string, offset, length);
|
||
case "ucs2":
|
||
case "ucs-2":
|
||
case "utf16le":
|
||
case "utf-16le":
|
||
return ucs2Write(this, string, offset, length);
|
||
default:
|
||
if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
|
||
encoding = ("" + encoding).toLowerCase();
|
||
loweredCase = true;
|
||
}
|
||
};
|
||
Buffer.prototype.toJSON = function toJSON() {
|
||
return {
|
||
type: "Buffer",
|
||
data: Array.prototype.slice.call(this._arr || this, 0)
|
||
};
|
||
};
|
||
function base64Slice(buf, start, end) {
|
||
if (start === 0 && end === buf.length) return base64.fromByteArray(buf);
|
||
else return base64.fromByteArray(buf.slice(start, end));
|
||
}
|
||
function utf8Slice(buf, start, end) {
|
||
end = Math.min(buf.length, end);
|
||
const res = [];
|
||
let i = start;
|
||
while(i < end){
|
||
const firstByte = buf[i];
|
||
let codePoint = null;
|
||
let bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;
|
||
if (i + bytesPerSequence <= end) {
|
||
let secondByte, thirdByte, fourthByte, tempCodePoint;
|
||
switch(bytesPerSequence){
|
||
case 1:
|
||
if (firstByte < 0x80) codePoint = firstByte;
|
||
break;
|
||
case 2:
|
||
secondByte = buf[i + 1];
|
||
if ((secondByte & 0xC0) === 0x80) {
|
||
tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;
|
||
if (tempCodePoint > 0x7F) codePoint = tempCodePoint;
|
||
}
|
||
break;
|
||
case 3:
|
||
secondByte = buf[i + 1];
|
||
thirdByte = buf[i + 2];
|
||
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
|
||
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;
|
||
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) codePoint = tempCodePoint;
|
||
}
|
||
break;
|
||
case 4:
|
||
secondByte = buf[i + 1];
|
||
thirdByte = buf[i + 2];
|
||
fourthByte = buf[i + 3];
|
||
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
|
||
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | fourthByte & 0x3F;
|
||
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) codePoint = tempCodePoint;
|
||
}
|
||
}
|
||
}
|
||
if (codePoint === null) {
|
||
// we did not generate a valid codePoint so insert a
|
||
// replacement char (U+FFFD) and advance only 1 byte
|
||
codePoint = 0xFFFD;
|
||
bytesPerSequence = 1;
|
||
} else if (codePoint > 0xFFFF) {
|
||
// encode to utf16 (surrogate pair dance)
|
||
codePoint -= 0x10000;
|
||
res.push(codePoint >>> 10 & 0x3FF | 0xD800);
|
||
codePoint = 0xDC00 | codePoint & 0x3FF;
|
||
}
|
||
res.push(codePoint);
|
||
i += bytesPerSequence;
|
||
}
|
||
return decodeCodePointsArray(res);
|
||
}
|
||
// Based on http://stackoverflow.com/a/22747272/680742, the browser with
|
||
// the lowest limit is Chrome, with 0x10000 args.
|
||
// We go 1 magnitude less, for safety
|
||
const MAX_ARGUMENTS_LENGTH = 0x1000;
|
||
function decodeCodePointsArray(codePoints) {
|
||
const len = codePoints.length;
|
||
if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
|
||
;
|
||
// Decode in chunks to avoid "call stack size exceeded".
|
||
let res = "";
|
||
let i = 0;
|
||
while(i < len)res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
|
||
return res;
|
||
}
|
||
function asciiSlice(buf, start, end) {
|
||
let ret = "";
|
||
end = Math.min(buf.length, end);
|
||
for(let i = start; i < end; ++i)ret += String.fromCharCode(buf[i] & 0x7F);
|
||
return ret;
|
||
}
|
||
function latin1Slice(buf, start, end) {
|
||
let ret = "";
|
||
end = Math.min(buf.length, end);
|
||
for(let i = start; i < end; ++i)ret += String.fromCharCode(buf[i]);
|
||
return ret;
|
||
}
|
||
function hexSlice(buf, start, end) {
|
||
const len = buf.length;
|
||
if (!start || start < 0) start = 0;
|
||
if (!end || end < 0 || end > len) end = len;
|
||
let out = "";
|
||
for(let i = start; i < end; ++i)out += hexSliceLookupTable[buf[i]];
|
||
return out;
|
||
}
|
||
function utf16leSlice(buf, start, end) {
|
||
const bytes = buf.slice(start, end);
|
||
let res = "";
|
||
// If bytes.length is odd, the last 8 bits must be ignored (same as node.js)
|
||
for(let i = 0; i < bytes.length - 1; i += 2)res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
|
||
return res;
|
||
}
|
||
Buffer.prototype.slice = function slice(start, end) {
|
||
const len = this.length;
|
||
start = ~~start;
|
||
end = end === undefined ? len : ~~end;
|
||
if (start < 0) {
|
||
start += len;
|
||
if (start < 0) start = 0;
|
||
} else if (start > len) start = len;
|
||
if (end < 0) {
|
||
end += len;
|
||
if (end < 0) end = 0;
|
||
} else if (end > len) end = len;
|
||
if (end < start) end = start;
|
||
const newBuf = this.subarray(start, end);
|
||
// Return an augmented `Uint8Array` instance
|
||
Object.setPrototypeOf(newBuf, Buffer.prototype);
|
||
return newBuf;
|
||
};
|
||
/*
|
||
* Need to make sure that buffer isn't trying to write out of bounds.
|
||
*/ function checkOffset(offset, ext, length) {
|
||
if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
|
||
if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
|
||
}
|
||
Buffer.prototype.readUintLE = Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
||
let val = this[offset];
|
||
let mul = 1;
|
||
let i = 0;
|
||
while(++i < byteLength && (mul *= 0x100))val += this[offset + i] * mul;
|
||
return val;
|
||
};
|
||
Buffer.prototype.readUintBE = Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
||
let val = this[offset + --byteLength];
|
||
let mul = 1;
|
||
while(byteLength > 0 && (mul *= 0x100))val += this[offset + --byteLength] * mul;
|
||
return val;
|
||
};
|
||
Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 1, this.length);
|
||
return this[offset];
|
||
};
|
||
Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 2, this.length);
|
||
return this[offset] | this[offset + 1] << 8;
|
||
};
|
||
Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 2, this.length);
|
||
return this[offset] << 8 | this[offset + 1];
|
||
};
|
||
Buffer.prototype.readUint32LE = Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 4, this.length);
|
||
return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;
|
||
};
|
||
Buffer.prototype.readUint32BE = Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 4, this.length);
|
||
return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
|
||
};
|
||
Buffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
|
||
offset = offset >>> 0;
|
||
validateNumber(offset, "offset");
|
||
const first = this[offset];
|
||
const last = this[offset + 7];
|
||
if (first === undefined || last === undefined) boundsError(offset, this.length - 8);
|
||
const lo = first + this[++offset] * 256 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
|
||
const hi = this[++offset] + this[++offset] * 256 + this[++offset] * 2 ** 16 + last * 2 ** 24;
|
||
return BigInt(lo) + (BigInt(hi) << BigInt(32));
|
||
});
|
||
Buffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
|
||
offset = offset >>> 0;
|
||
validateNumber(offset, "offset");
|
||
const first = this[offset];
|
||
const last = this[offset + 7];
|
||
if (first === undefined || last === undefined) boundsError(offset, this.length - 8);
|
||
const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 256 + this[++offset];
|
||
const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 256 + last;
|
||
return (BigInt(hi) << BigInt(32)) + BigInt(lo);
|
||
});
|
||
Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
||
let val = this[offset];
|
||
let mul = 1;
|
||
let i = 0;
|
||
while(++i < byteLength && (mul *= 0x100))val += this[offset + i] * mul;
|
||
mul *= 0x80;
|
||
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
|
||
return val;
|
||
};
|
||
Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
||
let i = byteLength;
|
||
let mul = 1;
|
||
let val = this[offset + --i];
|
||
while(i > 0 && (mul *= 0x100))val += this[offset + --i] * mul;
|
||
mul *= 0x80;
|
||
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
|
||
return val;
|
||
};
|
||
Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 1, this.length);
|
||
if (!(this[offset] & 0x80)) return this[offset];
|
||
return (0xff - this[offset] + 1) * -1;
|
||
};
|
||
Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 2, this.length);
|
||
const val = this[offset] | this[offset + 1] << 8;
|
||
return val & 0x8000 ? val | 0xFFFF0000 : val;
|
||
};
|
||
Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 2, this.length);
|
||
const val = this[offset + 1] | this[offset] << 8;
|
||
return val & 0x8000 ? val | 0xFFFF0000 : val;
|
||
};
|
||
Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 4, this.length);
|
||
return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
|
||
};
|
||
Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 4, this.length);
|
||
return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
|
||
};
|
||
Buffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
|
||
offset = offset >>> 0;
|
||
validateNumber(offset, "offset");
|
||
const first = this[offset];
|
||
const last = this[offset + 7];
|
||
if (first === undefined || last === undefined) boundsError(offset, this.length - 8);
|
||
const val = this[offset + 4] + this[offset + 5] * 256 + this[offset + 6] * 2 ** 16 + (last << 24 // Overflow
|
||
);
|
||
return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 256 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
|
||
});
|
||
Buffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
|
||
offset = offset >>> 0;
|
||
validateNumber(offset, "offset");
|
||
const first = this[offset];
|
||
const last = this[offset + 7];
|
||
if (first === undefined || last === undefined) boundsError(offset, this.length - 8);
|
||
const val = (first << 24) + // Overflow
|
||
this[++offset] * 2 ** 16 + this[++offset] * 256 + this[++offset];
|
||
return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 256 + last);
|
||
});
|
||
Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 4, this.length);
|
||
return ieee754.read(this, offset, true, 23, 4);
|
||
};
|
||
Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 4, this.length);
|
||
return ieee754.read(this, offset, false, 23, 4);
|
||
};
|
||
Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 8, this.length);
|
||
return ieee754.read(this, offset, true, 52, 8);
|
||
};
|
||
Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkOffset(offset, 8, this.length);
|
||
return ieee754.read(this, offset, false, 52, 8);
|
||
};
|
||
function checkInt(buf, value, offset, ext, max, min) {
|
||
if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
|
||
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
|
||
if (offset + ext > buf.length) throw new RangeError("Index out of range");
|
||
}
|
||
Buffer.prototype.writeUintLE = Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
if (!noAssert) {
|
||
const maxBytes = Math.pow(2, 8 * byteLength) - 1;
|
||
checkInt(this, value, offset, byteLength, maxBytes, 0);
|
||
}
|
||
let mul = 1;
|
||
let i = 0;
|
||
this[offset] = value & 0xFF;
|
||
while(++i < byteLength && (mul *= 0x100))this[offset + i] = value / mul & 0xFF;
|
||
return offset + byteLength;
|
||
};
|
||
Buffer.prototype.writeUintBE = Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
if (!noAssert) {
|
||
const maxBytes = Math.pow(2, 8 * byteLength) - 1;
|
||
checkInt(this, value, offset, byteLength, maxBytes, 0);
|
||
}
|
||
let i = byteLength - 1;
|
||
let mul = 1;
|
||
this[offset + i] = value & 0xFF;
|
||
while(--i >= 0 && (mul *= 0x100))this[offset + i] = value / mul & 0xFF;
|
||
return offset + byteLength;
|
||
};
|
||
Buffer.prototype.writeUint8 = Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
|
||
this[offset] = value & 0xff;
|
||
return offset + 1;
|
||
};
|
||
Buffer.prototype.writeUint16LE = Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
|
||
this[offset] = value & 0xff;
|
||
this[offset + 1] = value >>> 8;
|
||
return offset + 2;
|
||
};
|
||
Buffer.prototype.writeUint16BE = Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
|
||
this[offset] = value >>> 8;
|
||
this[offset + 1] = value & 0xff;
|
||
return offset + 2;
|
||
};
|
||
Buffer.prototype.writeUint32LE = Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
|
||
this[offset + 3] = value >>> 24;
|
||
this[offset + 2] = value >>> 16;
|
||
this[offset + 1] = value >>> 8;
|
||
this[offset] = value & 0xff;
|
||
return offset + 4;
|
||
};
|
||
Buffer.prototype.writeUint32BE = Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
|
||
this[offset] = value >>> 24;
|
||
this[offset + 1] = value >>> 16;
|
||
this[offset + 2] = value >>> 8;
|
||
this[offset + 3] = value & 0xff;
|
||
return offset + 4;
|
||
};
|
||
function wrtBigUInt64LE(buf, value, offset, min, max) {
|
||
checkIntBI(value, min, max, buf, offset, 7);
|
||
let lo = Number(value & BigInt(0xffffffff));
|
||
buf[offset++] = lo;
|
||
lo = lo >> 8;
|
||
buf[offset++] = lo;
|
||
lo = lo >> 8;
|
||
buf[offset++] = lo;
|
||
lo = lo >> 8;
|
||
buf[offset++] = lo;
|
||
let hi = Number(value >> BigInt(32) & BigInt(0xffffffff));
|
||
buf[offset++] = hi;
|
||
hi = hi >> 8;
|
||
buf[offset++] = hi;
|
||
hi = hi >> 8;
|
||
buf[offset++] = hi;
|
||
hi = hi >> 8;
|
||
buf[offset++] = hi;
|
||
return offset;
|
||
}
|
||
function wrtBigUInt64BE(buf, value, offset, min, max) {
|
||
checkIntBI(value, min, max, buf, offset, 7);
|
||
let lo = Number(value & BigInt(0xffffffff));
|
||
buf[offset + 7] = lo;
|
||
lo = lo >> 8;
|
||
buf[offset + 6] = lo;
|
||
lo = lo >> 8;
|
||
buf[offset + 5] = lo;
|
||
lo = lo >> 8;
|
||
buf[offset + 4] = lo;
|
||
let hi = Number(value >> BigInt(32) & BigInt(0xffffffff));
|
||
buf[offset + 3] = hi;
|
||
hi = hi >> 8;
|
||
buf[offset + 2] = hi;
|
||
hi = hi >> 8;
|
||
buf[offset + 1] = hi;
|
||
hi = hi >> 8;
|
||
buf[offset] = hi;
|
||
return offset + 8;
|
||
}
|
||
Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
|
||
return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
|
||
});
|
||
Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
|
||
return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
|
||
});
|
||
Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) {
|
||
const limit = Math.pow(2, 8 * byteLength - 1);
|
||
checkInt(this, value, offset, byteLength, limit - 1, -limit);
|
||
}
|
||
let i = 0;
|
||
let mul = 1;
|
||
let sub = 0;
|
||
this[offset] = value & 0xFF;
|
||
while(++i < byteLength && (mul *= 0x100)){
|
||
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) sub = 1;
|
||
this[offset + i] = (value / mul >> 0) - sub & 0xFF;
|
||
}
|
||
return offset + byteLength;
|
||
};
|
||
Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) {
|
||
const limit = Math.pow(2, 8 * byteLength - 1);
|
||
checkInt(this, value, offset, byteLength, limit - 1, -limit);
|
||
}
|
||
let i = byteLength - 1;
|
||
let mul = 1;
|
||
let sub = 0;
|
||
this[offset + i] = value & 0xFF;
|
||
while(--i >= 0 && (mul *= 0x100)){
|
||
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) sub = 1;
|
||
this[offset + i] = (value / mul >> 0) - sub & 0xFF;
|
||
}
|
||
return offset + byteLength;
|
||
};
|
||
Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -128);
|
||
if (value < 0) value = 0xff + value + 1;
|
||
this[offset] = value & 0xff;
|
||
return offset + 1;
|
||
};
|
||
Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -32768);
|
||
this[offset] = value & 0xff;
|
||
this[offset + 1] = value >>> 8;
|
||
return offset + 2;
|
||
};
|
||
Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -32768);
|
||
this[offset] = value >>> 8;
|
||
this[offset + 1] = value & 0xff;
|
||
return offset + 2;
|
||
};
|
||
Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -2147483648);
|
||
this[offset] = value & 0xff;
|
||
this[offset + 1] = value >>> 8;
|
||
this[offset + 2] = value >>> 16;
|
||
this[offset + 3] = value >>> 24;
|
||
return offset + 4;
|
||
};
|
||
Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -2147483648);
|
||
if (value < 0) value = 0xffffffff + value + 1;
|
||
this[offset] = value >>> 24;
|
||
this[offset + 1] = value >>> 16;
|
||
this[offset + 2] = value >>> 8;
|
||
this[offset + 3] = value & 0xff;
|
||
return offset + 4;
|
||
};
|
||
Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
|
||
return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
|
||
});
|
||
Buffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
|
||
return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
|
||
});
|
||
function checkIEEE754(buf, value, offset, ext, max, min) {
|
||
if (offset + ext > buf.length) throw new RangeError("Index out of range");
|
||
if (offset < 0) throw new RangeError("Index out of range");
|
||
}
|
||
function writeFloat(buf, value, offset, littleEndian, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -340282346638528860000000000000000000000);
|
||
ieee754.write(buf, value, offset, littleEndian, 23, 4);
|
||
return offset + 4;
|
||
}
|
||
Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
|
||
return writeFloat(this, value, offset, true, noAssert);
|
||
};
|
||
Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
|
||
return writeFloat(this, value, offset, false, noAssert);
|
||
};
|
||
function writeDouble(buf, value, offset, littleEndian, noAssert) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
if (!noAssert) checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000);
|
||
ieee754.write(buf, value, offset, littleEndian, 52, 8);
|
||
return offset + 8;
|
||
}
|
||
Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
|
||
return writeDouble(this, value, offset, true, noAssert);
|
||
};
|
||
Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
|
||
return writeDouble(this, value, offset, false, noAssert);
|
||
};
|
||
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
||
Buffer.prototype.copy = function copy(target, targetStart, start, end) {
|
||
if (!Buffer.isBuffer(target)) throw new TypeError("argument should be a Buffer");
|
||
if (!start) start = 0;
|
||
if (!end && end !== 0) end = this.length;
|
||
if (targetStart >= target.length) targetStart = target.length;
|
||
if (!targetStart) targetStart = 0;
|
||
if (end > 0 && end < start) end = start;
|
||
// Copy 0 bytes; we're done
|
||
if (end === start) return 0;
|
||
if (target.length === 0 || this.length === 0) return 0;
|
||
// Fatal error conditions
|
||
if (targetStart < 0) throw new RangeError("targetStart out of bounds");
|
||
if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
|
||
if (end < 0) throw new RangeError("sourceEnd out of bounds");
|
||
// Are we oob?
|
||
if (end > this.length) end = this.length;
|
||
if (target.length - targetStart < end - start) end = target.length - targetStart + start;
|
||
const len = end - start;
|
||
if (this === target && typeof Uint8Array.prototype.copyWithin === "function") // Use built-in when available, missing from IE11
|
||
this.copyWithin(targetStart, start, end);
|
||
else Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
|
||
return len;
|
||
};
|
||
// Usage:
|
||
// buffer.fill(number[, offset[, end]])
|
||
// buffer.fill(buffer[, offset[, end]])
|
||
// buffer.fill(string[, offset[, end]][, encoding])
|
||
Buffer.prototype.fill = function fill(val, start, end, encoding) {
|
||
// Handle string cases:
|
||
if (typeof val === "string") {
|
||
if (typeof start === "string") {
|
||
encoding = start;
|
||
start = 0;
|
||
end = this.length;
|
||
} else if (typeof end === "string") {
|
||
encoding = end;
|
||
end = this.length;
|
||
}
|
||
if (encoding !== undefined && typeof encoding !== "string") throw new TypeError("encoding must be a string");
|
||
if (typeof encoding === "string" && !Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
|
||
if (val.length === 1) {
|
||
const code = val.charCodeAt(0);
|
||
if (encoding === "utf8" && code < 128 || encoding === "latin1") // Fast path: If `val` fits into a single byte, use that numeric value.
|
||
val = code;
|
||
}
|
||
} else if (typeof val === "number") val = val & 255;
|
||
else if (typeof val === "boolean") val = Number(val);
|
||
// Invalid ranges are not set to a default, so can range check early.
|
||
if (start < 0 || this.length < start || this.length < end) throw new RangeError("Out of range index");
|
||
if (end <= start) return this;
|
||
start = start >>> 0;
|
||
end = end === undefined ? this.length : end >>> 0;
|
||
if (!val) val = 0;
|
||
let i;
|
||
if (typeof val === "number") for(i = start; i < end; ++i)this[i] = val;
|
||
else {
|
||
const bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding);
|
||
const len = bytes.length;
|
||
if (len === 0) throw new TypeError('The value "' + val + '" is invalid for argument "value"');
|
||
for(i = 0; i < end - start; ++i)this[i + start] = bytes[i % len];
|
||
}
|
||
return this;
|
||
};
|
||
// CUSTOM ERRORS
|
||
// =============
|
||
// Simplified versions from Node, changed for Buffer-only usage
|
||
const errors = {};
|
||
function E(sym, getMessage, Base) {
|
||
errors[sym] = class NodeError extends Base {
|
||
constructor(){
|
||
super();
|
||
Object.defineProperty(this, "message", {
|
||
value: getMessage.apply(this, arguments),
|
||
writable: true,
|
||
configurable: true
|
||
});
|
||
// Add the error code to the name to include it in the stack trace.
|
||
this.name = `${this.name} [${sym}]`;
|
||
// Access the stack to generate the error message including the error code
|
||
// from the name.
|
||
this.stack // eslint-disable-line no-unused-expressions
|
||
;
|
||
// Reset the name to the actual name.
|
||
delete this.name;
|
||
}
|
||
get code() {
|
||
return sym;
|
||
}
|
||
set code(value) {
|
||
Object.defineProperty(this, "code", {
|
||
configurable: true,
|
||
enumerable: true,
|
||
value,
|
||
writable: true
|
||
});
|
||
}
|
||
toString() {
|
||
return `${this.name} [${sym}]: ${this.message}`;
|
||
}
|
||
};
|
||
}
|
||
E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
|
||
if (name) return `${name} is outside of buffer bounds`;
|
||
return "Attempt to access memory outside buffer bounds";
|
||
}, RangeError);
|
||
E("ERR_INVALID_ARG_TYPE", function(name, actual) {
|
||
return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
|
||
}, TypeError);
|
||
E("ERR_OUT_OF_RANGE", function(str, range, input) {
|
||
let msg = `The value of "${str}" is out of range.`;
|
||
let received = input;
|
||
if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) received = addNumericalSeparator(String(input));
|
||
else if (typeof input === "bigint") {
|
||
received = String(input);
|
||
if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) received = addNumericalSeparator(received);
|
||
received += "n";
|
||
}
|
||
msg += ` It must be ${range}. Received ${received}`;
|
||
return msg;
|
||
}, RangeError);
|
||
function addNumericalSeparator(val) {
|
||
let res = "";
|
||
let i = val.length;
|
||
const start = val[0] === "-" ? 1 : 0;
|
||
for(; i >= start + 4; i -= 3)res = `_${val.slice(i - 3, i)}${res}`;
|
||
return `${val.slice(0, i)}${res}`;
|
||
}
|
||
// CHECK FUNCTIONS
|
||
// ===============
|
||
function checkBounds(buf, offset, byteLength) {
|
||
validateNumber(offset, "offset");
|
||
if (buf[offset] === undefined || buf[offset + byteLength] === undefined) boundsError(offset, buf.length - (byteLength + 1));
|
||
}
|
||
function checkIntBI(value, min, max, buf, offset, byteLength) {
|
||
if (value > max || value < min) {
|
||
const n = typeof min === "bigint" ? "n" : "";
|
||
let range;
|
||
if (byteLength > 3) {
|
||
if (min === 0 || min === BigInt(0)) range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
|
||
else range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` + `${(byteLength + 1) * 8 - 1}${n}`;
|
||
} else range = `>= ${min}${n} and <= ${max}${n}`;
|
||
throw new errors.ERR_OUT_OF_RANGE("value", range, value);
|
||
}
|
||
checkBounds(buf, offset, byteLength);
|
||
}
|
||
function validateNumber(value, name) {
|
||
if (typeof value !== "number") throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
|
||
}
|
||
function boundsError(value, length, type) {
|
||
if (Math.floor(value) !== value) {
|
||
validateNumber(value, type);
|
||
throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
|
||
}
|
||
if (length < 0) throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
|
||
throw new errors.ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
|
||
}
|
||
// HELPER FUNCTIONS
|
||
// ================
|
||
const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
|
||
function base64clean(str) {
|
||
// Node takes equal signs as end of the Base64 encoding
|
||
str = str.split("=")[0];
|
||
// Node strips out invalid characters like \n and \t from the string, base64-js does not
|
||
str = str.trim().replace(INVALID_BASE64_RE, "");
|
||
// Node converts strings with length < 2 to ''
|
||
if (str.length < 2) return "";
|
||
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
|
||
while(str.length % 4 !== 0)str = str + "=";
|
||
return str;
|
||
}
|
||
function utf8ToBytes(string, units) {
|
||
units = units || Infinity;
|
||
let codePoint;
|
||
const length = string.length;
|
||
let leadSurrogate = null;
|
||
const bytes = [];
|
||
for(let i = 0; i < length; ++i){
|
||
codePoint = string.charCodeAt(i);
|
||
// is surrogate component
|
||
if (codePoint > 0xD7FF && codePoint < 0xE000) {
|
||
// last char was a lead
|
||
if (!leadSurrogate) {
|
||
// no lead yet
|
||
if (codePoint > 0xDBFF) {
|
||
// unexpected trail
|
||
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
||
continue;
|
||
} else if (i + 1 === length) {
|
||
// unpaired lead
|
||
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
||
continue;
|
||
}
|
||
// valid lead
|
||
leadSurrogate = codePoint;
|
||
continue;
|
||
}
|
||
// 2 leads in a row
|
||
if (codePoint < 0xDC00) {
|
||
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
||
leadSurrogate = codePoint;
|
||
continue;
|
||
}
|
||
// valid surrogate pair
|
||
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
|
||
} else if (leadSurrogate) // valid bmp char, but last char was a lead
|
||
{
|
||
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
||
}
|
||
leadSurrogate = null;
|
||
// encode utf8
|
||
if (codePoint < 0x80) {
|
||
if ((units -= 1) < 0) break;
|
||
bytes.push(codePoint);
|
||
} else if (codePoint < 0x800) {
|
||
if ((units -= 2) < 0) break;
|
||
bytes.push(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);
|
||
} else if (codePoint < 0x10000) {
|
||
if ((units -= 3) < 0) break;
|
||
bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);
|
||
} else if (codePoint < 0x110000) {
|
||
if ((units -= 4) < 0) break;
|
||
bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);
|
||
} else throw new Error("Invalid code point");
|
||
}
|
||
return bytes;
|
||
}
|
||
function asciiToBytes(str) {
|
||
const byteArray = [];
|
||
for(let i = 0; i < str.length; ++i)// Node's code seems to be doing this and not & 0x7F..
|
||
byteArray.push(str.charCodeAt(i) & 0xFF);
|
||
return byteArray;
|
||
}
|
||
function utf16leToBytes(str, units) {
|
||
let c, hi, lo;
|
||
const byteArray = [];
|
||
for(let i = 0; i < str.length; ++i){
|
||
if ((units -= 2) < 0) break;
|
||
c = str.charCodeAt(i);
|
||
hi = c >> 8;
|
||
lo = c % 256;
|
||
byteArray.push(lo);
|
||
byteArray.push(hi);
|
||
}
|
||
return byteArray;
|
||
}
|
||
function base64ToBytes(str) {
|
||
return base64.toByteArray(base64clean(str));
|
||
}
|
||
function blitBuffer(src, dst, offset, length) {
|
||
let i;
|
||
for(i = 0; i < length; ++i){
|
||
if (i + offset >= dst.length || i >= src.length) break;
|
||
dst[i + offset] = src[i];
|
||
}
|
||
return i;
|
||
}
|
||
// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
|
||
// the `instanceof` check but they should be treated as of that type.
|
||
// See: https://github.com/feross/buffer/issues/166
|
||
function isInstance(obj, type) {
|
||
return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
|
||
}
|
||
function numberIsNaN(obj) {
|
||
// For IE11 support
|
||
return obj !== obj // eslint-disable-line no-self-compare
|
||
;
|
||
}
|
||
// Create lookup table for `toString('hex')`
|
||
// See: https://github.com/feross/buffer/issues/219
|
||
const hexSliceLookupTable = function() {
|
||
const alphabet = "0123456789abcdef";
|
||
const table = new Array(256);
|
||
for(let i = 0; i < 16; ++i){
|
||
const i16 = i * 16;
|
||
for(let j = 0; j < 16; ++j)table[i16 + j] = alphabet[i] + alphabet[j];
|
||
}
|
||
return table;
|
||
}();
|
||
// Return not function with Error if BigInt not supported
|
||
function defineBigIntMethod(fn) {
|
||
return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
|
||
}
|
||
function BufferBigIntNotDefined() {
|
||
throw new Error("BigInt not supported");
|
||
}
|
||
|
||
},{"9c62938f1dccc73c":"eIiSV","aceacb6a4531a9d2":"cO95r"}],"eIiSV":[function(require,module,exports) {
|
||
"use strict";
|
||
exports.byteLength = byteLength;
|
||
exports.toByteArray = toByteArray;
|
||
exports.fromByteArray = fromByteArray;
|
||
var lookup = [];
|
||
var revLookup = [];
|
||
var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
|
||
var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||
for(var i = 0, len = code.length; i < len; ++i){
|
||
lookup[i] = code[i];
|
||
revLookup[code.charCodeAt(i)] = i;
|
||
}
|
||
// Support decoding URL-safe base64 strings, as Node.js does.
|
||
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
|
||
revLookup["-".charCodeAt(0)] = 62;
|
||
revLookup["_".charCodeAt(0)] = 63;
|
||
function getLens(b64) {
|
||
var len = b64.length;
|
||
if (len % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
|
||
// Trim off extra bytes after placeholder bytes are found
|
||
// See: https://github.com/beatgammit/base64-js/issues/42
|
||
var validLen = b64.indexOf("=");
|
||
if (validLen === -1) validLen = len;
|
||
var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
|
||
return [
|
||
validLen,
|
||
placeHoldersLen
|
||
];
|
||
}
|
||
// base64 is 4/3 + up to two characters of the original data
|
||
function byteLength(b64) {
|
||
var lens = getLens(b64);
|
||
var validLen = lens[0];
|
||
var placeHoldersLen = lens[1];
|
||
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
|
||
}
|
||
function _byteLength(b64, validLen, placeHoldersLen) {
|
||
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
|
||
}
|
||
function toByteArray(b64) {
|
||
var tmp;
|
||
var lens = getLens(b64);
|
||
var validLen = lens[0];
|
||
var placeHoldersLen = lens[1];
|
||
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
|
||
var curByte = 0;
|
||
// if there are placeholders, only get up to the last complete 4 chars
|
||
var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
|
||
var i;
|
||
for(i = 0; i < len; i += 4){
|
||
tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
|
||
arr[curByte++] = tmp >> 16 & 0xFF;
|
||
arr[curByte++] = tmp >> 8 & 0xFF;
|
||
arr[curByte++] = tmp & 0xFF;
|
||
}
|
||
if (placeHoldersLen === 2) {
|
||
tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
|
||
arr[curByte++] = tmp & 0xFF;
|
||
}
|
||
if (placeHoldersLen === 1) {
|
||
tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
|
||
arr[curByte++] = tmp >> 8 & 0xFF;
|
||
arr[curByte++] = tmp & 0xFF;
|
||
}
|
||
return arr;
|
||
}
|
||
function tripletToBase64(num) {
|
||
return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];
|
||
}
|
||
function encodeChunk(uint8, start, end) {
|
||
var tmp;
|
||
var output = [];
|
||
for(var i = start; i < end; i += 3){
|
||
tmp = (uint8[i] << 16 & 0xFF0000) + (uint8[i + 1] << 8 & 0xFF00) + (uint8[i + 2] & 0xFF);
|
||
output.push(tripletToBase64(tmp));
|
||
}
|
||
return output.join("");
|
||
}
|
||
function fromByteArray(uint8) {
|
||
var tmp;
|
||
var len = uint8.length;
|
||
var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
|
||
;
|
||
var parts = [];
|
||
var maxChunkLength = 16383 // must be multiple of 3
|
||
;
|
||
// go through the array every three bytes, we'll deal with trailing stuff later
|
||
for(var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength)parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
|
||
// pad the end with zeros, but make sure to not forget the extra bytes
|
||
if (extraBytes === 1) {
|
||
tmp = uint8[len - 1];
|
||
parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + "==");
|
||
} else if (extraBytes === 2) {
|
||
tmp = (uint8[len - 2] << 8) + uint8[len - 1];
|
||
parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 0x3F] + lookup[tmp << 2 & 0x3F] + "=");
|
||
}
|
||
return parts.join("");
|
||
}
|
||
|
||
},{}],"cO95r":[function(require,module,exports) {
|
||
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */ exports.read = function(buffer, offset, isLE, mLen, nBytes) {
|
||
var e, m;
|
||
var eLen = nBytes * 8 - mLen - 1;
|
||
var eMax = (1 << eLen) - 1;
|
||
var eBias = eMax >> 1;
|
||
var nBits = -7;
|
||
var i = isLE ? nBytes - 1 : 0;
|
||
var d = isLE ? -1 : 1;
|
||
var s = buffer[offset + i];
|
||
i += d;
|
||
e = s & (1 << -nBits) - 1;
|
||
s >>= -nBits;
|
||
nBits += eLen;
|
||
for(; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
|
||
m = e & (1 << -nBits) - 1;
|
||
e >>= -nBits;
|
||
nBits += mLen;
|
||
for(; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
|
||
if (e === 0) e = 1 - eBias;
|
||
else if (e === eMax) return m ? NaN : (s ? -1 : 1) * Infinity;
|
||
else {
|
||
m = m + Math.pow(2, mLen);
|
||
e = e - eBias;
|
||
}
|
||
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
|
||
};
|
||
exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
|
||
var e, m, c;
|
||
var eLen = nBytes * 8 - mLen - 1;
|
||
var eMax = (1 << eLen) - 1;
|
||
var eBias = eMax >> 1;
|
||
var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
|
||
var i = isLE ? 0 : nBytes - 1;
|
||
var d = isLE ? 1 : -1;
|
||
var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
|
||
value = Math.abs(value);
|
||
if (isNaN(value) || value === Infinity) {
|
||
m = isNaN(value) ? 1 : 0;
|
||
e = eMax;
|
||
} else {
|
||
e = Math.floor(Math.log(value) / Math.LN2);
|
||
if (value * (c = Math.pow(2, -e)) < 1) {
|
||
e--;
|
||
c *= 2;
|
||
}
|
||
if (e + eBias >= 1) value += rt / c;
|
||
else value += rt * Math.pow(2, 1 - eBias);
|
||
if (value * c >= 2) {
|
||
e++;
|
||
c /= 2;
|
||
}
|
||
if (e + eBias >= eMax) {
|
||
m = 0;
|
||
e = eMax;
|
||
} else if (e + eBias >= 1) {
|
||
m = (value * c - 1) * Math.pow(2, mLen);
|
||
e = e + eBias;
|
||
} else {
|
||
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
|
||
e = 0;
|
||
}
|
||
}
|
||
for(; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
|
||
e = e << mLen | m;
|
||
eLen += mLen;
|
||
for(; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
|
||
buffer[offset + i - d] |= s * 128;
|
||
};
|
||
|
||
},{}],"k06Qi":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var eio = require("f57be303c493efd2");
|
||
var Socket = require("e760c9b2a747031c");
|
||
var Emitter = require("99ae4b9e5778008");
|
||
var parser = require("6966ecce58a0bdaf");
|
||
var on = require("80141cdb0669abd5");
|
||
var bind = require("4b01f94098858aec");
|
||
var debug = require("5a5644a1e8ec0623")("socket.io-client:manager");
|
||
var indexOf = require("4aecf95553dd3ef1");
|
||
var Backoff = require("c2a95f6083d1f904");
|
||
/**
|
||
* IE6+ hasOwnProperty
|
||
*/ var has = Object.prototype.hasOwnProperty;
|
||
/**
|
||
* Module exports
|
||
*/ module.exports = Manager;
|
||
/**
|
||
* `Manager` constructor.
|
||
*
|
||
* @param {String} engine instance or engine uri/opts
|
||
* @param {Object} options
|
||
* @api public
|
||
*/ function Manager(uri, opts) {
|
||
if (!(this instanceof Manager)) return new Manager(uri, opts);
|
||
if (uri && "object" === typeof uri) {
|
||
opts = uri;
|
||
uri = undefined;
|
||
}
|
||
opts = opts || {};
|
||
opts.path = opts.path || "/socket.io";
|
||
this.nsps = {};
|
||
this.subs = [];
|
||
this.opts = opts;
|
||
this.reconnection(opts.reconnection !== false);
|
||
this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
|
||
this.reconnectionDelay(opts.reconnectionDelay || 1000);
|
||
this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
|
||
this.randomizationFactor(opts.randomizationFactor || 0.5);
|
||
this.backoff = new Backoff({
|
||
min: this.reconnectionDelay(),
|
||
max: this.reconnectionDelayMax(),
|
||
jitter: this.randomizationFactor()
|
||
});
|
||
this.timeout(null == opts.timeout ? 20000 : opts.timeout);
|
||
this.readyState = "closed";
|
||
this.uri = uri;
|
||
this.connecting = [];
|
||
this.lastPing = null;
|
||
this.encoding = false;
|
||
this.packetBuffer = [];
|
||
var _parser = opts.parser || parser;
|
||
this.encoder = new _parser.Encoder();
|
||
this.decoder = new _parser.Decoder();
|
||
this.autoConnect = opts.autoConnect !== false;
|
||
if (this.autoConnect) this.open();
|
||
}
|
||
/**
|
||
* Propagate given event to sockets and emit on `this`
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.emitAll = function() {
|
||
this.emit.apply(this, arguments);
|
||
for(var nsp in this.nsps)if (has.call(this.nsps, nsp)) this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);
|
||
};
|
||
/**
|
||
* Update `socket.id` of all sockets
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.updateSocketIds = function() {
|
||
for(var nsp in this.nsps)if (has.call(this.nsps, nsp)) this.nsps[nsp].id = this.generateId(nsp);
|
||
};
|
||
/**
|
||
* generate `socket.id` for the given `nsp`
|
||
*
|
||
* @param {String} nsp
|
||
* @return {String}
|
||
* @api private
|
||
*/ Manager.prototype.generateId = function(nsp) {
|
||
return (nsp === "/" ? "" : nsp + "#") + this.engine.id;
|
||
};
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/ Emitter(Manager.prototype);
|
||
/**
|
||
* Sets the `reconnection` config.
|
||
*
|
||
* @param {Boolean} true/false if it should automatically reconnect
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/ Manager.prototype.reconnection = function(v) {
|
||
if (!arguments.length) return this._reconnection;
|
||
this._reconnection = !!v;
|
||
return this;
|
||
};
|
||
/**
|
||
* Sets the reconnection attempts config.
|
||
*
|
||
* @param {Number} max reconnection attempts before giving up
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/ Manager.prototype.reconnectionAttempts = function(v) {
|
||
if (!arguments.length) return this._reconnectionAttempts;
|
||
this._reconnectionAttempts = v;
|
||
return this;
|
||
};
|
||
/**
|
||
* Sets the delay between reconnections.
|
||
*
|
||
* @param {Number} delay
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/ Manager.prototype.reconnectionDelay = function(v) {
|
||
if (!arguments.length) return this._reconnectionDelay;
|
||
this._reconnectionDelay = v;
|
||
this.backoff && this.backoff.setMin(v);
|
||
return this;
|
||
};
|
||
Manager.prototype.randomizationFactor = function(v) {
|
||
if (!arguments.length) return this._randomizationFactor;
|
||
this._randomizationFactor = v;
|
||
this.backoff && this.backoff.setJitter(v);
|
||
return this;
|
||
};
|
||
/**
|
||
* Sets the maximum delay between reconnections.
|
||
*
|
||
* @param {Number} delay
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/ Manager.prototype.reconnectionDelayMax = function(v) {
|
||
if (!arguments.length) return this._reconnectionDelayMax;
|
||
this._reconnectionDelayMax = v;
|
||
this.backoff && this.backoff.setMax(v);
|
||
return this;
|
||
};
|
||
/**
|
||
* Sets the connection timeout. `false` to disable
|
||
*
|
||
* @return {Manager} self or value
|
||
* @api public
|
||
*/ Manager.prototype.timeout = function(v) {
|
||
if (!arguments.length) return this._timeout;
|
||
this._timeout = v;
|
||
return this;
|
||
};
|
||
/**
|
||
* Starts trying to reconnect if reconnection is enabled and we have not
|
||
* started reconnecting yet
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.maybeReconnectOnOpen = function() {
|
||
// Only try to reconnect if it's the first time we're connecting
|
||
if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) // keeps reconnection from firing twice for the same reconnection loop
|
||
this.reconnect();
|
||
};
|
||
/**
|
||
* Sets the current transport `socket`.
|
||
*
|
||
* @param {Function} optional, callback
|
||
* @return {Manager} self
|
||
* @api public
|
||
*/ Manager.prototype.open = Manager.prototype.connect = function(fn, opts) {
|
||
debug("readyState %s", this.readyState);
|
||
if (~this.readyState.indexOf("open")) return this;
|
||
debug("opening %s", this.uri);
|
||
this.engine = eio(this.uri, this.opts);
|
||
var socket = this.engine;
|
||
var self = this;
|
||
this.readyState = "opening";
|
||
this.skipReconnect = false;
|
||
// emit `open`
|
||
var openSub = on(socket, "open", function() {
|
||
self.onopen();
|
||
fn && fn();
|
||
});
|
||
// emit `connect_error`
|
||
var errorSub = on(socket, "error", function(data) {
|
||
debug("connect_error");
|
||
self.cleanup();
|
||
self.readyState = "closed";
|
||
self.emitAll("connect_error", data);
|
||
if (fn) {
|
||
var err = new Error("Connection error");
|
||
err.data = data;
|
||
fn(err);
|
||
} else // Only do this if there is no fn to handle the error
|
||
self.maybeReconnectOnOpen();
|
||
});
|
||
// emit `connect_timeout`
|
||
if (false !== this._timeout) {
|
||
var timeout = this._timeout;
|
||
debug("connect attempt will timeout after %d", timeout);
|
||
if (timeout === 0) openSub.destroy(); // prevents a race condition with the 'open' event
|
||
// set timer
|
||
var timer = setTimeout(function() {
|
||
debug("connect attempt timed out after %d", timeout);
|
||
openSub.destroy();
|
||
socket.close();
|
||
socket.emit("error", "timeout");
|
||
self.emitAll("connect_timeout", timeout);
|
||
}, timeout);
|
||
this.subs.push({
|
||
destroy: function() {
|
||
clearTimeout(timer);
|
||
}
|
||
});
|
||
}
|
||
this.subs.push(openSub);
|
||
this.subs.push(errorSub);
|
||
return this;
|
||
};
|
||
/**
|
||
* Called upon transport open.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.onopen = function() {
|
||
debug("open");
|
||
// clear old subs
|
||
this.cleanup();
|
||
// mark as open
|
||
this.readyState = "open";
|
||
this.emit("open");
|
||
// add new subs
|
||
var socket = this.engine;
|
||
this.subs.push(on(socket, "data", bind(this, "ondata")));
|
||
this.subs.push(on(socket, "ping", bind(this, "onping")));
|
||
this.subs.push(on(socket, "pong", bind(this, "onpong")));
|
||
this.subs.push(on(socket, "error", bind(this, "onerror")));
|
||
this.subs.push(on(socket, "close", bind(this, "onclose")));
|
||
this.subs.push(on(this.decoder, "decoded", bind(this, "ondecoded")));
|
||
};
|
||
/**
|
||
* Called upon a ping.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.onping = function() {
|
||
this.lastPing = new Date();
|
||
this.emitAll("ping");
|
||
};
|
||
/**
|
||
* Called upon a packet.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.onpong = function() {
|
||
this.emitAll("pong", new Date() - this.lastPing);
|
||
};
|
||
/**
|
||
* Called with data.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.ondata = function(data) {
|
||
this.decoder.add(data);
|
||
};
|
||
/**
|
||
* Called when parser fully decodes a packet.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.ondecoded = function(packet) {
|
||
this.emit("packet", packet);
|
||
};
|
||
/**
|
||
* Called upon socket error.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.onerror = function(err) {
|
||
debug("error", err);
|
||
this.emitAll("error", err);
|
||
};
|
||
/**
|
||
* Creates a new socket for the given `nsp`.
|
||
*
|
||
* @return {Socket}
|
||
* @api public
|
||
*/ Manager.prototype.socket = function(nsp, opts) {
|
||
var socket = this.nsps[nsp];
|
||
if (!socket) {
|
||
socket = new Socket(this, nsp, opts);
|
||
this.nsps[nsp] = socket;
|
||
var self = this;
|
||
socket.on("connecting", onConnecting);
|
||
socket.on("connect", function() {
|
||
socket.id = self.generateId(nsp);
|
||
});
|
||
if (this.autoConnect) // manually call here since connecting event is fired before listening
|
||
onConnecting();
|
||
}
|
||
function onConnecting() {
|
||
if (!~indexOf(self.connecting, socket)) self.connecting.push(socket);
|
||
}
|
||
return socket;
|
||
};
|
||
/**
|
||
* Called upon a socket close.
|
||
*
|
||
* @param {Socket} socket
|
||
*/ Manager.prototype.destroy = function(socket) {
|
||
var index = indexOf(this.connecting, socket);
|
||
if (~index) this.connecting.splice(index, 1);
|
||
if (this.connecting.length) return;
|
||
this.close();
|
||
};
|
||
/**
|
||
* Writes a packet.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/ Manager.prototype.packet = function(packet) {
|
||
debug("writing packet %j", packet);
|
||
var self = this;
|
||
if (packet.query && packet.type === 0) packet.nsp += "?" + packet.query;
|
||
if (!self.encoding) {
|
||
// encode, then write to engine with result
|
||
self.encoding = true;
|
||
this.encoder.encode(packet, function(encodedPackets) {
|
||
for(var i = 0; i < encodedPackets.length; i++)self.engine.write(encodedPackets[i], packet.options);
|
||
self.encoding = false;
|
||
self.processPacketQueue();
|
||
});
|
||
} else self.packetBuffer.push(packet);
|
||
};
|
||
/**
|
||
* If packet buffer is non-empty, begins encoding the
|
||
* next packet in line.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.processPacketQueue = function() {
|
||
if (this.packetBuffer.length > 0 && !this.encoding) {
|
||
var pack = this.packetBuffer.shift();
|
||
this.packet(pack);
|
||
}
|
||
};
|
||
/**
|
||
* Clean up transport subscriptions and packet buffer.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.cleanup = function() {
|
||
debug("cleanup");
|
||
var subsLength = this.subs.length;
|
||
for(var i = 0; i < subsLength; i++){
|
||
var sub = this.subs.shift();
|
||
sub.destroy();
|
||
}
|
||
this.packetBuffer = [];
|
||
this.encoding = false;
|
||
this.lastPing = null;
|
||
this.decoder.destroy();
|
||
};
|
||
/**
|
||
* Close the current socket.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.close = Manager.prototype.disconnect = function() {
|
||
debug("disconnect");
|
||
this.skipReconnect = true;
|
||
this.reconnecting = false;
|
||
if ("opening" === this.readyState) // `onclose` will not fire because
|
||
// an open event never happened
|
||
this.cleanup();
|
||
this.backoff.reset();
|
||
this.readyState = "closed";
|
||
if (this.engine) this.engine.close();
|
||
};
|
||
/**
|
||
* Called upon engine close.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.onclose = function(reason) {
|
||
debug("onclose");
|
||
this.cleanup();
|
||
this.backoff.reset();
|
||
this.readyState = "closed";
|
||
this.emit("close", reason);
|
||
if (this._reconnection && !this.skipReconnect) this.reconnect();
|
||
};
|
||
/**
|
||
* Attempt a reconnection.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.reconnect = function() {
|
||
if (this.reconnecting || this.skipReconnect) return this;
|
||
var self = this;
|
||
if (this.backoff.attempts >= this._reconnectionAttempts) {
|
||
debug("reconnect failed");
|
||
this.backoff.reset();
|
||
this.emitAll("reconnect_failed");
|
||
this.reconnecting = false;
|
||
} else {
|
||
var delay = this.backoff.duration();
|
||
debug("will wait %dms before reconnect attempt", delay);
|
||
this.reconnecting = true;
|
||
var timer = setTimeout(function() {
|
||
if (self.skipReconnect) return;
|
||
debug("attempting reconnect");
|
||
self.emitAll("reconnect_attempt", self.backoff.attempts);
|
||
self.emitAll("reconnecting", self.backoff.attempts);
|
||
// check again for the case socket closed in above events
|
||
if (self.skipReconnect) return;
|
||
self.open(function(err) {
|
||
if (err) {
|
||
debug("reconnect attempt error");
|
||
self.reconnecting = false;
|
||
self.reconnect();
|
||
self.emitAll("reconnect_error", err.data);
|
||
} else {
|
||
debug("reconnect success");
|
||
self.onreconnect();
|
||
}
|
||
});
|
||
}, delay);
|
||
this.subs.push({
|
||
destroy: function() {
|
||
clearTimeout(timer);
|
||
}
|
||
});
|
||
}
|
||
};
|
||
/**
|
||
* Called upon successful reconnect.
|
||
*
|
||
* @api private
|
||
*/ Manager.prototype.onreconnect = function() {
|
||
var attempt = this.backoff.attempts;
|
||
this.reconnecting = false;
|
||
this.backoff.reset();
|
||
this.updateSocketIds();
|
||
this.emitAll("reconnect", attempt);
|
||
};
|
||
|
||
},{"f57be303c493efd2":"eaoWP","e760c9b2a747031c":"aZLF9","99ae4b9e5778008":"5nHrO","6966ecce58a0bdaf":"iEP88","80141cdb0669abd5":"fRNUp","4b01f94098858aec":"lVL5b","5a5644a1e8ec0623":"l0oUb","4aecf95553dd3ef1":"j5RZX","c2a95f6083d1f904":"kOkss"}],"eaoWP":[function(require,module,exports) {
|
||
module.exports = require("223cccbf1e3e302");
|
||
/**
|
||
* Exports parser
|
||
*
|
||
* @api public
|
||
*
|
||
*/ module.exports.parser = require("c87bd63da73ae985");
|
||
|
||
},{"223cccbf1e3e302":"2w3ez","c87bd63da73ae985":"eUidh"}],"2w3ez":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var transports = require("1c3ef4359d3e35a2");
|
||
var Emitter = require("3d00244de3656a35");
|
||
var debug = require("6a6c4238063d5757")("engine.io-client:socket");
|
||
var index = require("5f33d707d95c57a");
|
||
var parser = require("eed48123680de601");
|
||
var parseuri = require("a2751b8f7442a12a");
|
||
var parseqs = require("3666a06389248ff2");
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = Socket;
|
||
/**
|
||
* Socket constructor.
|
||
*
|
||
* @param {String|Object} uri or options
|
||
* @param {Object} options
|
||
* @api public
|
||
*/ function Socket(uri, opts) {
|
||
if (!(this instanceof Socket)) return new Socket(uri, opts);
|
||
opts = opts || {};
|
||
if (uri && "object" === typeof uri) {
|
||
opts = uri;
|
||
uri = null;
|
||
}
|
||
if (uri) {
|
||
uri = parseuri(uri);
|
||
opts.hostname = uri.host;
|
||
opts.secure = uri.protocol === "https" || uri.protocol === "wss";
|
||
opts.port = uri.port;
|
||
if (uri.query) opts.query = uri.query;
|
||
} else if (opts.host) opts.hostname = parseuri(opts.host).host;
|
||
this.secure = null != opts.secure ? opts.secure : typeof location !== "undefined" && "https:" === location.protocol;
|
||
if (opts.hostname && !opts.port) // if no port is specified manually, use the protocol default
|
||
opts.port = this.secure ? "443" : "80";
|
||
this.agent = opts.agent || false;
|
||
this.hostname = opts.hostname || (typeof location !== "undefined" ? location.hostname : "localhost");
|
||
this.port = opts.port || (typeof location !== "undefined" && location.port ? location.port : this.secure ? 443 : 80);
|
||
this.query = opts.query || {};
|
||
if ("string" === typeof this.query) this.query = parseqs.decode(this.query);
|
||
this.upgrade = false !== opts.upgrade;
|
||
this.path = (opts.path || "/engine.io").replace(/\/$/, "") + "/";
|
||
this.forceJSONP = !!opts.forceJSONP;
|
||
this.jsonp = false !== opts.jsonp;
|
||
this.forceBase64 = !!opts.forceBase64;
|
||
this.enablesXDR = !!opts.enablesXDR;
|
||
this.withCredentials = false !== opts.withCredentials;
|
||
this.timestampParam = opts.timestampParam || "t";
|
||
this.timestampRequests = opts.timestampRequests;
|
||
this.transports = opts.transports || [
|
||
"polling",
|
||
"websocket"
|
||
];
|
||
this.transportOptions = opts.transportOptions || {};
|
||
this.readyState = "";
|
||
this.writeBuffer = [];
|
||
this.prevBufferLen = 0;
|
||
this.policyPort = opts.policyPort || 843;
|
||
this.rememberUpgrade = opts.rememberUpgrade || false;
|
||
this.binaryType = null;
|
||
this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;
|
||
this.perMessageDeflate = false !== opts.perMessageDeflate ? opts.perMessageDeflate || {} : false;
|
||
if (true === this.perMessageDeflate) this.perMessageDeflate = {};
|
||
if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) this.perMessageDeflate.threshold = 1024;
|
||
// SSL options for Node.js client
|
||
this.pfx = opts.pfx || null;
|
||
this.key = opts.key || null;
|
||
this.passphrase = opts.passphrase || null;
|
||
this.cert = opts.cert || null;
|
||
this.ca = opts.ca || null;
|
||
this.ciphers = opts.ciphers || null;
|
||
this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? true : opts.rejectUnauthorized;
|
||
this.forceNode = !!opts.forceNode;
|
||
// detect ReactNative environment
|
||
this.isReactNative = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative";
|
||
// other options for Node.js or ReactNative client
|
||
if (typeof self === "undefined" || this.isReactNative) {
|
||
if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) this.extraHeaders = opts.extraHeaders;
|
||
if (opts.localAddress) this.localAddress = opts.localAddress;
|
||
}
|
||
// set on handshake
|
||
this.id = null;
|
||
this.upgrades = null;
|
||
this.pingInterval = null;
|
||
this.pingTimeout = null;
|
||
// set on heartbeat
|
||
this.pingIntervalTimer = null;
|
||
this.pingTimeoutTimer = null;
|
||
this.open();
|
||
}
|
||
Socket.priorWebsocketSuccess = false;
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/ Emitter(Socket.prototype);
|
||
/**
|
||
* Protocol version.
|
||
*
|
||
* @api public
|
||
*/ Socket.protocol = parser.protocol; // this is an int
|
||
/**
|
||
* Expose deps for legacy compatibility
|
||
* and standalone browser access.
|
||
*/ Socket.Socket = Socket;
|
||
Socket.Transport = require("9df165b21084f311");
|
||
Socket.transports = require("1c3ef4359d3e35a2");
|
||
Socket.parser = require("eed48123680de601");
|
||
/**
|
||
* Creates transport of the given type.
|
||
*
|
||
* @param {String} transport name
|
||
* @return {Transport}
|
||
* @api private
|
||
*/ Socket.prototype.createTransport = function(name) {
|
||
debug('creating transport "%s"', name);
|
||
var query = clone(this.query);
|
||
// append engine.io protocol identifier
|
||
query.EIO = parser.protocol;
|
||
// transport name
|
||
query.transport = name;
|
||
// per-transport options
|
||
var options = this.transportOptions[name] || {};
|
||
// session id if we already have one
|
||
if (this.id) query.sid = this.id;
|
||
var transport = new transports[name]({
|
||
query: query,
|
||
socket: this,
|
||
agent: options.agent || this.agent,
|
||
hostname: options.hostname || this.hostname,
|
||
port: options.port || this.port,
|
||
secure: options.secure || this.secure,
|
||
path: options.path || this.path,
|
||
forceJSONP: options.forceJSONP || this.forceJSONP,
|
||
jsonp: options.jsonp || this.jsonp,
|
||
forceBase64: options.forceBase64 || this.forceBase64,
|
||
enablesXDR: options.enablesXDR || this.enablesXDR,
|
||
withCredentials: options.withCredentials || this.withCredentials,
|
||
timestampRequests: options.timestampRequests || this.timestampRequests,
|
||
timestampParam: options.timestampParam || this.timestampParam,
|
||
policyPort: options.policyPort || this.policyPort,
|
||
pfx: options.pfx || this.pfx,
|
||
key: options.key || this.key,
|
||
passphrase: options.passphrase || this.passphrase,
|
||
cert: options.cert || this.cert,
|
||
ca: options.ca || this.ca,
|
||
ciphers: options.ciphers || this.ciphers,
|
||
rejectUnauthorized: options.rejectUnauthorized || this.rejectUnauthorized,
|
||
perMessageDeflate: options.perMessageDeflate || this.perMessageDeflate,
|
||
extraHeaders: options.extraHeaders || this.extraHeaders,
|
||
forceNode: options.forceNode || this.forceNode,
|
||
localAddress: options.localAddress || this.localAddress,
|
||
requestTimeout: options.requestTimeout || this.requestTimeout,
|
||
protocols: options.protocols || void 0,
|
||
isReactNative: this.isReactNative
|
||
});
|
||
return transport;
|
||
};
|
||
function clone(obj) {
|
||
var o = {};
|
||
for(var i in obj)if (obj.hasOwnProperty(i)) o[i] = obj[i];
|
||
return o;
|
||
}
|
||
/**
|
||
* Initializes transport to use and starts probe.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.open = function() {
|
||
var transport;
|
||
if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1) transport = "websocket";
|
||
else if (0 === this.transports.length) {
|
||
// Emit error on next tick so it can be listened to
|
||
var self1 = this;
|
||
setTimeout(function() {
|
||
self1.emit("error", "No transports available");
|
||
}, 0);
|
||
return;
|
||
} else transport = this.transports[0];
|
||
this.readyState = "opening";
|
||
// Retry with the next transport if the transport is disabled (jsonp: false)
|
||
try {
|
||
transport = this.createTransport(transport);
|
||
} catch (e) {
|
||
this.transports.shift();
|
||
this.open();
|
||
return;
|
||
}
|
||
transport.open();
|
||
this.setTransport(transport);
|
||
};
|
||
/**
|
||
* Sets the current transport. Disables the existing one (if any).
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.setTransport = function(transport) {
|
||
debug("setting transport %s", transport.name);
|
||
var self1 = this;
|
||
if (this.transport) {
|
||
debug("clearing existing transport %s", this.transport.name);
|
||
this.transport.removeAllListeners();
|
||
}
|
||
// set up transport
|
||
this.transport = transport;
|
||
// set up transport listeners
|
||
transport.on("drain", function() {
|
||
self1.onDrain();
|
||
}).on("packet", function(packet) {
|
||
self1.onPacket(packet);
|
||
}).on("error", function(e) {
|
||
self1.onError(e);
|
||
}).on("close", function() {
|
||
self1.onClose("transport close");
|
||
});
|
||
};
|
||
/**
|
||
* Probes a transport.
|
||
*
|
||
* @param {String} transport name
|
||
* @api private
|
||
*/ Socket.prototype.probe = function(name) {
|
||
debug('probing transport "%s"', name);
|
||
var transport = this.createTransport(name, {
|
||
probe: 1
|
||
});
|
||
var failed = false;
|
||
var self1 = this;
|
||
Socket.priorWebsocketSuccess = false;
|
||
function onTransportOpen() {
|
||
if (self1.onlyBinaryUpgrades) {
|
||
var upgradeLosesBinary = !this.supportsBinary && self1.transport.supportsBinary;
|
||
failed = failed || upgradeLosesBinary;
|
||
}
|
||
if (failed) return;
|
||
debug('probe transport "%s" opened', name);
|
||
transport.send([
|
||
{
|
||
type: "ping",
|
||
data: "probe"
|
||
}
|
||
]);
|
||
transport.once("packet", function(msg) {
|
||
if (failed) return;
|
||
if ("pong" === msg.type && "probe" === msg.data) {
|
||
debug('probe transport "%s" pong', name);
|
||
self1.upgrading = true;
|
||
self1.emit("upgrading", transport);
|
||
if (!transport) return;
|
||
Socket.priorWebsocketSuccess = "websocket" === transport.name;
|
||
debug('pausing current transport "%s"', self1.transport.name);
|
||
self1.transport.pause(function() {
|
||
if (failed) return;
|
||
if ("closed" === self1.readyState) return;
|
||
debug("changing transport and sending upgrade packet");
|
||
cleanup();
|
||
self1.setTransport(transport);
|
||
transport.send([
|
||
{
|
||
type: "upgrade"
|
||
}
|
||
]);
|
||
self1.emit("upgrade", transport);
|
||
transport = null;
|
||
self1.upgrading = false;
|
||
self1.flush();
|
||
});
|
||
} else {
|
||
debug('probe transport "%s" failed', name);
|
||
var err = new Error("probe error");
|
||
err.transport = transport.name;
|
||
self1.emit("upgradeError", err);
|
||
}
|
||
});
|
||
}
|
||
function freezeTransport() {
|
||
if (failed) return;
|
||
// Any callback called by transport should be ignored since now
|
||
failed = true;
|
||
cleanup();
|
||
transport.close();
|
||
transport = null;
|
||
}
|
||
// Handle any error that happens while probing
|
||
function onerror(err) {
|
||
var error = new Error("probe error: " + err);
|
||
error.transport = transport.name;
|
||
freezeTransport();
|
||
debug('probe transport "%s" failed because of error: %s', name, err);
|
||
self1.emit("upgradeError", error);
|
||
}
|
||
function onTransportClose() {
|
||
onerror("transport closed");
|
||
}
|
||
// When the socket is closed while we're probing
|
||
function onclose() {
|
||
onerror("socket closed");
|
||
}
|
||
// When the socket is upgraded while we're probing
|
||
function onupgrade(to) {
|
||
if (transport && to.name !== transport.name) {
|
||
debug('"%s" works - aborting "%s"', to.name, transport.name);
|
||
freezeTransport();
|
||
}
|
||
}
|
||
// Remove all listeners on the transport and on self
|
||
function cleanup() {
|
||
transport.removeListener("open", onTransportOpen);
|
||
transport.removeListener("error", onerror);
|
||
transport.removeListener("close", onTransportClose);
|
||
self1.removeListener("close", onclose);
|
||
self1.removeListener("upgrading", onupgrade);
|
||
}
|
||
transport.once("open", onTransportOpen);
|
||
transport.once("error", onerror);
|
||
transport.once("close", onTransportClose);
|
||
this.once("close", onclose);
|
||
this.once("upgrading", onupgrade);
|
||
transport.open();
|
||
};
|
||
/**
|
||
* Called when connection is deemed open.
|
||
*
|
||
* @api public
|
||
*/ Socket.prototype.onOpen = function() {
|
||
debug("socket open");
|
||
this.readyState = "open";
|
||
Socket.priorWebsocketSuccess = "websocket" === this.transport.name;
|
||
this.emit("open");
|
||
this.flush();
|
||
// we check for `readyState` in case an `open`
|
||
// listener already closed the socket
|
||
if ("open" === this.readyState && this.upgrade && this.transport.pause) {
|
||
debug("starting upgrade probes");
|
||
for(var i = 0, l = this.upgrades.length; i < l; i++)this.probe(this.upgrades[i]);
|
||
}
|
||
};
|
||
/**
|
||
* Handles a packet.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.onPacket = function(packet) {
|
||
if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
|
||
debug('socket receive: type "%s", data "%s"', packet.type, packet.data);
|
||
this.emit("packet", packet);
|
||
// Socket is live - any packet counts
|
||
this.emit("heartbeat");
|
||
switch(packet.type){
|
||
case "open":
|
||
this.onHandshake(JSON.parse(packet.data));
|
||
break;
|
||
case "pong":
|
||
this.setPing();
|
||
this.emit("pong");
|
||
break;
|
||
case "error":
|
||
var err = new Error("server error");
|
||
err.code = packet.data;
|
||
this.onError(err);
|
||
break;
|
||
case "message":
|
||
this.emit("data", packet.data);
|
||
this.emit("message", packet.data);
|
||
break;
|
||
}
|
||
} else debug('packet received with socket readyState "%s"', this.readyState);
|
||
};
|
||
/**
|
||
* Called upon handshake completion.
|
||
*
|
||
* @param {Object} handshake obj
|
||
* @api private
|
||
*/ Socket.prototype.onHandshake = function(data) {
|
||
this.emit("handshake", data);
|
||
this.id = data.sid;
|
||
this.transport.query.sid = data.sid;
|
||
this.upgrades = this.filterUpgrades(data.upgrades);
|
||
this.pingInterval = data.pingInterval;
|
||
this.pingTimeout = data.pingTimeout;
|
||
this.onOpen();
|
||
// In case open handler closes socket
|
||
if ("closed" === this.readyState) return;
|
||
this.setPing();
|
||
// Prolong liveness of socket on heartbeat
|
||
this.removeListener("heartbeat", this.onHeartbeat);
|
||
this.on("heartbeat", this.onHeartbeat);
|
||
};
|
||
/**
|
||
* Resets ping timeout.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.onHeartbeat = function(timeout) {
|
||
clearTimeout(this.pingTimeoutTimer);
|
||
var self1 = this;
|
||
self1.pingTimeoutTimer = setTimeout(function() {
|
||
if ("closed" === self1.readyState) return;
|
||
self1.onClose("ping timeout");
|
||
}, timeout || self1.pingInterval + self1.pingTimeout);
|
||
};
|
||
/**
|
||
* Pings server every `this.pingInterval` and expects response
|
||
* within `this.pingTimeout` or closes connection.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.setPing = function() {
|
||
var self1 = this;
|
||
clearTimeout(self1.pingIntervalTimer);
|
||
self1.pingIntervalTimer = setTimeout(function() {
|
||
debug("writing ping packet - expecting pong within %sms", self1.pingTimeout);
|
||
self1.ping();
|
||
self1.onHeartbeat(self1.pingTimeout);
|
||
}, self1.pingInterval);
|
||
};
|
||
/**
|
||
* Sends a ping packet.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.ping = function() {
|
||
var self1 = this;
|
||
this.sendPacket("ping", function() {
|
||
self1.emit("ping");
|
||
});
|
||
};
|
||
/**
|
||
* Called on `drain` event
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.onDrain = function() {
|
||
this.writeBuffer.splice(0, this.prevBufferLen);
|
||
// setting prevBufferLen = 0 is very important
|
||
// for example, when upgrading, upgrade packet is sent over,
|
||
// and a nonzero prevBufferLen could cause problems on `drain`
|
||
this.prevBufferLen = 0;
|
||
if (0 === this.writeBuffer.length) this.emit("drain");
|
||
else this.flush();
|
||
};
|
||
/**
|
||
* Flush write buffers.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.flush = function() {
|
||
if ("closed" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
|
||
debug("flushing %d packets in socket", this.writeBuffer.length);
|
||
this.transport.send(this.writeBuffer);
|
||
// keep track of current length of writeBuffer
|
||
// splice writeBuffer and callbackBuffer on `drain`
|
||
this.prevBufferLen = this.writeBuffer.length;
|
||
this.emit("flush");
|
||
}
|
||
};
|
||
/**
|
||
* Sends a message.
|
||
*
|
||
* @param {String} message.
|
||
* @param {Function} callback function.
|
||
* @param {Object} options.
|
||
* @return {Socket} for chaining.
|
||
* @api public
|
||
*/ Socket.prototype.write = Socket.prototype.send = function(msg, options, fn) {
|
||
this.sendPacket("message", msg, options, fn);
|
||
return this;
|
||
};
|
||
/**
|
||
* Sends a packet.
|
||
*
|
||
* @param {String} packet type.
|
||
* @param {String} data.
|
||
* @param {Object} options.
|
||
* @param {Function} callback function.
|
||
* @api private
|
||
*/ Socket.prototype.sendPacket = function(type, data, options, fn) {
|
||
if ("function" === typeof data) {
|
||
fn = data;
|
||
data = undefined;
|
||
}
|
||
if ("function" === typeof options) {
|
||
fn = options;
|
||
options = null;
|
||
}
|
||
if ("closing" === this.readyState || "closed" === this.readyState) return;
|
||
options = options || {};
|
||
options.compress = false !== options.compress;
|
||
var packet = {
|
||
type: type,
|
||
data: data,
|
||
options: options
|
||
};
|
||
this.emit("packetCreate", packet);
|
||
this.writeBuffer.push(packet);
|
||
if (fn) this.once("flush", fn);
|
||
this.flush();
|
||
};
|
||
/**
|
||
* Closes the connection.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.close = function() {
|
||
if ("opening" === this.readyState || "open" === this.readyState) {
|
||
this.readyState = "closing";
|
||
var self1 = this;
|
||
if (this.writeBuffer.length) this.once("drain", function() {
|
||
if (this.upgrading) waitForUpgrade();
|
||
else close();
|
||
});
|
||
else if (this.upgrading) waitForUpgrade();
|
||
else close();
|
||
}
|
||
function close() {
|
||
self1.onClose("forced close");
|
||
debug("socket closing - telling transport to close");
|
||
self1.transport.close();
|
||
}
|
||
function cleanupAndClose() {
|
||
self1.removeListener("upgrade", cleanupAndClose);
|
||
self1.removeListener("upgradeError", cleanupAndClose);
|
||
close();
|
||
}
|
||
function waitForUpgrade() {
|
||
// wait for upgrade to finish since we can't send packets while pausing a transport
|
||
self1.once("upgrade", cleanupAndClose);
|
||
self1.once("upgradeError", cleanupAndClose);
|
||
}
|
||
return this;
|
||
};
|
||
/**
|
||
* Called upon transport error
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.onError = function(err) {
|
||
debug("socket error %j", err);
|
||
Socket.priorWebsocketSuccess = false;
|
||
this.emit("error", err);
|
||
this.onClose("transport error", err);
|
||
};
|
||
/**
|
||
* Called upon transport close.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.onClose = function(reason, desc) {
|
||
if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
|
||
debug('socket close with reason: "%s"', reason);
|
||
var self1 = this;
|
||
// clear timers
|
||
clearTimeout(this.pingIntervalTimer);
|
||
clearTimeout(this.pingTimeoutTimer);
|
||
// stop event from firing again for transport
|
||
this.transport.removeAllListeners("close");
|
||
// ensure transport won't stay open
|
||
this.transport.close();
|
||
// ignore further transport communication
|
||
this.transport.removeAllListeners();
|
||
// set ready state
|
||
this.readyState = "closed";
|
||
// clear session id
|
||
this.id = null;
|
||
// emit close event
|
||
this.emit("close", reason, desc);
|
||
// clean buffers after, so users can still
|
||
// grab the buffers on `close` event
|
||
self1.writeBuffer = [];
|
||
self1.prevBufferLen = 0;
|
||
}
|
||
};
|
||
/**
|
||
* Filters upgrades, returning only those matching client transports.
|
||
*
|
||
* @param {Array} server upgrades
|
||
* @api private
|
||
*
|
||
*/ Socket.prototype.filterUpgrades = function(upgrades) {
|
||
var filteredUpgrades = [];
|
||
for(var i = 0, j = upgrades.length; i < j; i++)if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);
|
||
return filteredUpgrades;
|
||
};
|
||
|
||
},{"1c3ef4359d3e35a2":"1lXIC","3d00244de3656a35":"5nHrO","6a6c4238063d5757":"l0oUb","5f33d707d95c57a":"j5RZX","eed48123680de601":"eUidh","a2751b8f7442a12a":"7w9JU","3666a06389248ff2":"M504l","9df165b21084f311":"ljuQJ"}],"1lXIC":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies
|
||
*/ var XMLHttpRequest = require("cbec9a0da0675810");
|
||
var XHR = require("44e321efce91ac2c");
|
||
var JSONP = require("7ff7cd97d5ff43d5");
|
||
var websocket = require("2b82f347438ab44e");
|
||
/**
|
||
* Export transports.
|
||
*/ exports.polling = polling;
|
||
exports.websocket = websocket;
|
||
/**
|
||
* Polling transport polymorphic constructor.
|
||
* Decides on xhr vs jsonp based on feature detection.
|
||
*
|
||
* @api private
|
||
*/ function polling(opts) {
|
||
var xhr;
|
||
var xd = false;
|
||
var xs = false;
|
||
var jsonp = false !== opts.jsonp;
|
||
if (typeof location !== "undefined") {
|
||
var isSSL = "https:" === location.protocol;
|
||
var port = location.port;
|
||
// some user agents have empty `location.port`
|
||
if (!port) port = isSSL ? 443 : 80;
|
||
xd = opts.hostname !== location.hostname || port !== opts.port;
|
||
xs = opts.secure !== isSSL;
|
||
}
|
||
opts.xdomain = xd;
|
||
opts.xscheme = xs;
|
||
xhr = new XMLHttpRequest(opts);
|
||
if ("open" in xhr && !opts.forceJSONP) return new XHR(opts);
|
||
else {
|
||
if (!jsonp) throw new Error("JSONP disabled");
|
||
return new JSONP(opts);
|
||
}
|
||
}
|
||
|
||
},{"cbec9a0da0675810":"4tpqf","44e321efce91ac2c":"f1pvu","7ff7cd97d5ff43d5":"7PlrH","2b82f347438ab44e":"cl8V7"}],"4tpqf":[function(require,module,exports) {
|
||
// browser shim for xmlhttprequest module
|
||
var hasCORS = require("795c7660b27a634e");
|
||
var globalThis1 = require("884293c02bd614b0");
|
||
module.exports = function(opts) {
|
||
var xdomain = opts.xdomain;
|
||
// scheme must be same when usign XDomainRequest
|
||
// http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx
|
||
var xscheme = opts.xscheme;
|
||
// XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.
|
||
// https://github.com/Automattic/engine.io-client/pull/217
|
||
var enablesXDR = opts.enablesXDR;
|
||
// XMLHttpRequest can be disabled on IE
|
||
try {
|
||
if ("undefined" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) return new XMLHttpRequest();
|
||
} catch (e) {}
|
||
// Use XDomainRequest for IE8 if enablesXDR is true
|
||
// because loading bar keeps flashing when using jsonp-polling
|
||
// https://github.com/yujiosaka/socke.io-ie8-loading-example
|
||
try {
|
||
if ("undefined" !== typeof XDomainRequest && !xscheme && enablesXDR) return new XDomainRequest();
|
||
} catch (e) {}
|
||
if (!xdomain) try {
|
||
return new globalThis[[
|
||
"Active"
|
||
].concat("Object").join("X")]("Microsoft.XMLHTTP");
|
||
} catch (e) {}
|
||
};
|
||
|
||
},{"795c7660b27a634e":"26eJv","884293c02bd614b0":"68bZg"}],"26eJv":[function(require,module,exports) {
|
||
/**
|
||
* Module exports.
|
||
*
|
||
* Logic borrowed from Modernizr:
|
||
*
|
||
* - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js
|
||
*/ try {
|
||
module.exports = typeof XMLHttpRequest !== "undefined" && "withCredentials" in new XMLHttpRequest();
|
||
} catch (err) {
|
||
// if XMLHttp support is disabled in IE then it will throw
|
||
// when trying to create
|
||
module.exports = false;
|
||
}
|
||
|
||
},{}],"68bZg":[function(require,module,exports) {
|
||
module.exports = function() {
|
||
if (typeof self !== "undefined") return self;
|
||
else if (typeof window !== "undefined") return window;
|
||
else return Function("return this")(); // eslint-disable-line no-new-func
|
||
}();
|
||
|
||
},{}],"f1pvu":[function(require,module,exports) {
|
||
/* global attachEvent */ /**
|
||
* Module requirements.
|
||
*/ var XMLHttpRequest = require("6504fa70f23de824");
|
||
var Polling = require("bfe1cd0d8440bc99");
|
||
var Emitter = require("d329ff04a1f990d7");
|
||
var inherit = require("19d6de1d4992f4cc");
|
||
var debug = require("9664289877a58b59")("engine.io-client:polling-xhr");
|
||
var globalThis1 = require("51978f47eba9f3b9");
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = XHR;
|
||
module.exports.Request = Request;
|
||
/**
|
||
* Empty function
|
||
*/ function empty() {}
|
||
/**
|
||
* XHR Polling constructor.
|
||
*
|
||
* @param {Object} opts
|
||
* @api public
|
||
*/ function XHR(opts) {
|
||
Polling.call(this, opts);
|
||
this.requestTimeout = opts.requestTimeout;
|
||
this.extraHeaders = opts.extraHeaders;
|
||
if (typeof location !== "undefined") {
|
||
var isSSL = "https:" === location.protocol;
|
||
var port = location.port;
|
||
// some user agents have empty `location.port`
|
||
if (!port) port = isSSL ? 443 : 80;
|
||
this.xd = typeof location !== "undefined" && opts.hostname !== location.hostname || port !== opts.port;
|
||
this.xs = opts.secure !== isSSL;
|
||
}
|
||
}
|
||
/**
|
||
* Inherits from Polling.
|
||
*/ inherit(XHR, Polling);
|
||
/**
|
||
* XHR supports binary
|
||
*/ XHR.prototype.supportsBinary = true;
|
||
/**
|
||
* Creates a request.
|
||
*
|
||
* @param {String} method
|
||
* @api private
|
||
*/ XHR.prototype.request = function(opts) {
|
||
opts = opts || {};
|
||
opts.uri = this.uri();
|
||
opts.xd = this.xd;
|
||
opts.xs = this.xs;
|
||
opts.agent = this.agent || false;
|
||
opts.supportsBinary = this.supportsBinary;
|
||
opts.enablesXDR = this.enablesXDR;
|
||
opts.withCredentials = this.withCredentials;
|
||
// SSL options for Node.js client
|
||
opts.pfx = this.pfx;
|
||
opts.key = this.key;
|
||
opts.passphrase = this.passphrase;
|
||
opts.cert = this.cert;
|
||
opts.ca = this.ca;
|
||
opts.ciphers = this.ciphers;
|
||
opts.rejectUnauthorized = this.rejectUnauthorized;
|
||
opts.requestTimeout = this.requestTimeout;
|
||
// other options for Node.js client
|
||
opts.extraHeaders = this.extraHeaders;
|
||
return new Request(opts);
|
||
};
|
||
/**
|
||
* Sends data.
|
||
*
|
||
* @param {String} data to send.
|
||
* @param {Function} called upon flush.
|
||
* @api private
|
||
*/ XHR.prototype.doWrite = function(data, fn) {
|
||
var isBinary = typeof data !== "string" && data !== undefined;
|
||
var req = this.request({
|
||
method: "POST",
|
||
data: data,
|
||
isBinary: isBinary
|
||
});
|
||
var self = this;
|
||
req.on("success", fn);
|
||
req.on("error", function(err) {
|
||
self.onError("xhr post error", err);
|
||
});
|
||
this.sendXhr = req;
|
||
};
|
||
/**
|
||
* Starts a poll cycle.
|
||
*
|
||
* @api private
|
||
*/ XHR.prototype.doPoll = function() {
|
||
debug("xhr poll");
|
||
var req = this.request();
|
||
var self = this;
|
||
req.on("data", function(data) {
|
||
self.onData(data);
|
||
});
|
||
req.on("error", function(err) {
|
||
self.onError("xhr poll error", err);
|
||
});
|
||
this.pollXhr = req;
|
||
};
|
||
/**
|
||
* Request constructor
|
||
*
|
||
* @param {Object} options
|
||
* @api public
|
||
*/ function Request(opts) {
|
||
this.method = opts.method || "GET";
|
||
this.uri = opts.uri;
|
||
this.xd = !!opts.xd;
|
||
this.xs = !!opts.xs;
|
||
this.async = false !== opts.async;
|
||
this.data = undefined !== opts.data ? opts.data : null;
|
||
this.agent = opts.agent;
|
||
this.isBinary = opts.isBinary;
|
||
this.supportsBinary = opts.supportsBinary;
|
||
this.enablesXDR = opts.enablesXDR;
|
||
this.withCredentials = opts.withCredentials;
|
||
this.requestTimeout = opts.requestTimeout;
|
||
// SSL options for Node.js client
|
||
this.pfx = opts.pfx;
|
||
this.key = opts.key;
|
||
this.passphrase = opts.passphrase;
|
||
this.cert = opts.cert;
|
||
this.ca = opts.ca;
|
||
this.ciphers = opts.ciphers;
|
||
this.rejectUnauthorized = opts.rejectUnauthorized;
|
||
// other options for Node.js client
|
||
this.extraHeaders = opts.extraHeaders;
|
||
this.create();
|
||
}
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/ Emitter(Request.prototype);
|
||
/**
|
||
* Creates the XHR object and sends the request.
|
||
*
|
||
* @api private
|
||
*/ Request.prototype.create = function() {
|
||
var opts = {
|
||
agent: this.agent,
|
||
xdomain: this.xd,
|
||
xscheme: this.xs,
|
||
enablesXDR: this.enablesXDR
|
||
};
|
||
// SSL options for Node.js client
|
||
opts.pfx = this.pfx;
|
||
opts.key = this.key;
|
||
opts.passphrase = this.passphrase;
|
||
opts.cert = this.cert;
|
||
opts.ca = this.ca;
|
||
opts.ciphers = this.ciphers;
|
||
opts.rejectUnauthorized = this.rejectUnauthorized;
|
||
var xhr = this.xhr = new XMLHttpRequest(opts);
|
||
var self = this;
|
||
try {
|
||
debug("xhr open %s: %s", this.method, this.uri);
|
||
xhr.open(this.method, this.uri, this.async);
|
||
try {
|
||
if (this.extraHeaders) {
|
||
xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);
|
||
for(var i in this.extraHeaders)if (this.extraHeaders.hasOwnProperty(i)) xhr.setRequestHeader(i, this.extraHeaders[i]);
|
||
}
|
||
} catch (e) {}
|
||
if ("POST" === this.method) try {
|
||
if (this.isBinary) xhr.setRequestHeader("Content-type", "application/octet-stream");
|
||
else xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
|
||
} catch (e) {}
|
||
try {
|
||
xhr.setRequestHeader("Accept", "*/*");
|
||
} catch (e) {}
|
||
// ie6 check
|
||
if ("withCredentials" in xhr) xhr.withCredentials = this.withCredentials;
|
||
if (this.requestTimeout) xhr.timeout = this.requestTimeout;
|
||
if (this.hasXDR()) {
|
||
xhr.onload = function() {
|
||
self.onLoad();
|
||
};
|
||
xhr.onerror = function() {
|
||
self.onError(xhr.responseText);
|
||
};
|
||
} else xhr.onreadystatechange = function() {
|
||
if (xhr.readyState === 2) try {
|
||
var contentType = xhr.getResponseHeader("Content-Type");
|
||
if (self.supportsBinary && contentType === "application/octet-stream" || contentType === "application/octet-stream; charset=UTF-8") xhr.responseType = "arraybuffer";
|
||
} catch (e) {}
|
||
if (4 !== xhr.readyState) return;
|
||
if (200 === xhr.status || 1223 === xhr.status) self.onLoad();
|
||
else // make sure the `error` event handler that's user-set
|
||
// does not throw in the same tick and gets caught here
|
||
setTimeout(function() {
|
||
self.onError(typeof xhr.status === "number" ? xhr.status : 0);
|
||
}, 0);
|
||
};
|
||
debug("xhr data %s", this.data);
|
||
xhr.send(this.data);
|
||
} catch (e) {
|
||
// Need to defer since .create() is called directly fhrom the constructor
|
||
// and thus the 'error' event can only be only bound *after* this exception
|
||
// occurs. Therefore, also, we cannot throw here at all.
|
||
setTimeout(function() {
|
||
self.onError(e);
|
||
}, 0);
|
||
return;
|
||
}
|
||
if (typeof document !== "undefined") {
|
||
this.index = Request.requestsCount++;
|
||
Request.requests[this.index] = this;
|
||
}
|
||
};
|
||
/**
|
||
* Called upon successful response.
|
||
*
|
||
* @api private
|
||
*/ Request.prototype.onSuccess = function() {
|
||
this.emit("success");
|
||
this.cleanup();
|
||
};
|
||
/**
|
||
* Called if we have data.
|
||
*
|
||
* @api private
|
||
*/ Request.prototype.onData = function(data) {
|
||
this.emit("data", data);
|
||
this.onSuccess();
|
||
};
|
||
/**
|
||
* Called upon error.
|
||
*
|
||
* @api private
|
||
*/ Request.prototype.onError = function(err) {
|
||
this.emit("error", err);
|
||
this.cleanup(true);
|
||
};
|
||
/**
|
||
* Cleans up house.
|
||
*
|
||
* @api private
|
||
*/ Request.prototype.cleanup = function(fromError) {
|
||
if ("undefined" === typeof this.xhr || null === this.xhr) return;
|
||
// xmlhttprequest
|
||
if (this.hasXDR()) this.xhr.onload = this.xhr.onerror = empty;
|
||
else this.xhr.onreadystatechange = empty;
|
||
if (fromError) try {
|
||
this.xhr.abort();
|
||
} catch (e) {}
|
||
if (typeof document !== "undefined") delete Request.requests[this.index];
|
||
this.xhr = null;
|
||
};
|
||
/**
|
||
* Called upon load.
|
||
*
|
||
* @api private
|
||
*/ Request.prototype.onLoad = function() {
|
||
var data;
|
||
try {
|
||
var contentType;
|
||
try {
|
||
contentType = this.xhr.getResponseHeader("Content-Type");
|
||
} catch (e) {}
|
||
if (contentType === "application/octet-stream" || contentType === "application/octet-stream; charset=UTF-8") data = this.xhr.response || this.xhr.responseText;
|
||
else data = this.xhr.responseText;
|
||
} catch (e) {
|
||
this.onError(e);
|
||
}
|
||
if (null != data) this.onData(data);
|
||
};
|
||
/**
|
||
* Check if it has XDomainRequest.
|
||
*
|
||
* @api private
|
||
*/ Request.prototype.hasXDR = function() {
|
||
return typeof XDomainRequest !== "undefined" && !this.xs && this.enablesXDR;
|
||
};
|
||
/**
|
||
* Aborts the request.
|
||
*
|
||
* @api public
|
||
*/ Request.prototype.abort = function() {
|
||
this.cleanup();
|
||
};
|
||
/**
|
||
* Aborts pending requests when unloading the window. This is needed to prevent
|
||
* memory leaks (e.g. when using IE) and to ensure that no spurious error is
|
||
* emitted.
|
||
*/ Request.requestsCount = 0;
|
||
Request.requests = {};
|
||
if (typeof document !== "undefined") {
|
||
if (typeof attachEvent === "function") attachEvent("onunload", unloadHandler);
|
||
else if (typeof addEventListener === "function") {
|
||
var terminationEvent = "onpagehide" in globalThis ? "pagehide" : "unload";
|
||
addEventListener(terminationEvent, unloadHandler, false);
|
||
}
|
||
}
|
||
function unloadHandler() {
|
||
for(var i in Request.requests)if (Request.requests.hasOwnProperty(i)) Request.requests[i].abort();
|
||
}
|
||
|
||
},{"6504fa70f23de824":"4tpqf","bfe1cd0d8440bc99":"6Bu9a","d329ff04a1f990d7":"5nHrO","19d6de1d4992f4cc":"idpNN","9664289877a58b59":"l0oUb","51978f47eba9f3b9":"68bZg"}],"6Bu9a":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var Transport = require("41f1129e1faebb49");
|
||
var parseqs = require("89ba3226fc71d2c6");
|
||
var parser = require("fc5b5c50ac2ee456");
|
||
var inherit = require("9d1aa93464a1f382");
|
||
var yeast = require("142e46a65d73e608");
|
||
var debug = require("8a9bddbe3308e4")("engine.io-client:polling");
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = Polling;
|
||
/**
|
||
* Is XHR2 supported?
|
||
*/ var hasXHR2 = function() {
|
||
var XMLHttpRequest = require("d46e5cf6f30d2741");
|
||
var xhr = new XMLHttpRequest({
|
||
xdomain: false
|
||
});
|
||
return null != xhr.responseType;
|
||
}();
|
||
/**
|
||
* Polling interface.
|
||
*
|
||
* @param {Object} opts
|
||
* @api private
|
||
*/ function Polling(opts) {
|
||
var forceBase64 = opts && opts.forceBase64;
|
||
if (!hasXHR2 || forceBase64) this.supportsBinary = false;
|
||
Transport.call(this, opts);
|
||
}
|
||
/**
|
||
* Inherits from Transport.
|
||
*/ inherit(Polling, Transport);
|
||
/**
|
||
* Transport name.
|
||
*/ Polling.prototype.name = "polling";
|
||
/**
|
||
* Opens the socket (triggers polling). We write a PING message to determine
|
||
* when the transport is open.
|
||
*
|
||
* @api private
|
||
*/ Polling.prototype.doOpen = function() {
|
||
this.poll();
|
||
};
|
||
/**
|
||
* Pauses polling.
|
||
*
|
||
* @param {Function} callback upon buffers are flushed and transport is paused
|
||
* @api private
|
||
*/ Polling.prototype.pause = function(onPause) {
|
||
var self = this;
|
||
this.readyState = "pausing";
|
||
function pause() {
|
||
debug("paused");
|
||
self.readyState = "paused";
|
||
onPause();
|
||
}
|
||
if (this.polling || !this.writable) {
|
||
var total = 0;
|
||
if (this.polling) {
|
||
debug("we are currently polling - waiting to pause");
|
||
total++;
|
||
this.once("pollComplete", function() {
|
||
debug("pre-pause polling complete");
|
||
--total || pause();
|
||
});
|
||
}
|
||
if (!this.writable) {
|
||
debug("we are currently writing - waiting to pause");
|
||
total++;
|
||
this.once("drain", function() {
|
||
debug("pre-pause writing complete");
|
||
--total || pause();
|
||
});
|
||
}
|
||
} else pause();
|
||
};
|
||
/**
|
||
* Starts polling cycle.
|
||
*
|
||
* @api public
|
||
*/ Polling.prototype.poll = function() {
|
||
debug("polling");
|
||
this.polling = true;
|
||
this.doPoll();
|
||
this.emit("poll");
|
||
};
|
||
/**
|
||
* Overloads onData to detect payloads.
|
||
*
|
||
* @api private
|
||
*/ Polling.prototype.onData = function(data) {
|
||
var self = this;
|
||
debug("polling got data %s", data);
|
||
var callback = function(packet, index, total) {
|
||
// if its the first message we consider the transport open
|
||
if ("opening" === self.readyState) self.onOpen();
|
||
// if its a close packet, we close the ongoing requests
|
||
if ("close" === packet.type) {
|
||
self.onClose();
|
||
return false;
|
||
}
|
||
// otherwise bypass onData and handle the message
|
||
self.onPacket(packet);
|
||
};
|
||
// decode payload
|
||
parser.decodePayload(data, this.socket.binaryType, callback);
|
||
// if an event did not trigger closing
|
||
if ("closed" !== this.readyState) {
|
||
// if we got data we're not polling
|
||
this.polling = false;
|
||
this.emit("pollComplete");
|
||
if ("open" === this.readyState) this.poll();
|
||
else debug('ignoring poll - transport state "%s"', this.readyState);
|
||
}
|
||
};
|
||
/**
|
||
* For polling, send a close packet.
|
||
*
|
||
* @api private
|
||
*/ Polling.prototype.doClose = function() {
|
||
var self = this;
|
||
function close() {
|
||
debug("writing close packet");
|
||
self.write([
|
||
{
|
||
type: "close"
|
||
}
|
||
]);
|
||
}
|
||
if ("open" === this.readyState) {
|
||
debug("transport open - closing");
|
||
close();
|
||
} else {
|
||
// in case we're trying to close while
|
||
// handshaking is in progress (GH-164)
|
||
debug("transport not open - deferring close");
|
||
this.once("open", close);
|
||
}
|
||
};
|
||
/**
|
||
* Writes a packets payload.
|
||
*
|
||
* @param {Array} data packets
|
||
* @param {Function} drain callback
|
||
* @api private
|
||
*/ Polling.prototype.write = function(packets) {
|
||
var self = this;
|
||
this.writable = false;
|
||
var callbackfn = function() {
|
||
self.writable = true;
|
||
self.emit("drain");
|
||
};
|
||
parser.encodePayload(packets, this.supportsBinary, function(data) {
|
||
self.doWrite(data, callbackfn);
|
||
});
|
||
};
|
||
/**
|
||
* Generates uri for connection.
|
||
*
|
||
* @api private
|
||
*/ Polling.prototype.uri = function() {
|
||
var query = this.query || {};
|
||
var schema = this.secure ? "https" : "http";
|
||
var port = "";
|
||
// cache busting is forced
|
||
if (false !== this.timestampRequests) query[this.timestampParam] = yeast();
|
||
if (!this.supportsBinary && !query.sid) query.b64 = 1;
|
||
query = parseqs.encode(query);
|
||
// avoid port if default for schema
|
||
if (this.port && ("https" === schema && Number(this.port) !== 443 || "http" === schema && Number(this.port) !== 80)) port = ":" + this.port;
|
||
// prepend ? to query
|
||
if (query.length) query = "?" + query;
|
||
var ipv6 = this.hostname.indexOf(":") !== -1;
|
||
return schema + "://" + (ipv6 ? "[" + this.hostname + "]" : this.hostname) + port + this.path + query;
|
||
};
|
||
|
||
},{"41f1129e1faebb49":"ljuQJ","89ba3226fc71d2c6":"M504l","fc5b5c50ac2ee456":"eUidh","9d1aa93464a1f382":"idpNN","142e46a65d73e608":"3CfTu","8a9bddbe3308e4":"l0oUb","d46e5cf6f30d2741":"4tpqf"}],"ljuQJ":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var parser = require("1847fd3ebe220b7");
|
||
var Emitter = require("23bb3bcedf6e6b52");
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = Transport;
|
||
/**
|
||
* Transport abstract constructor.
|
||
*
|
||
* @param {Object} options.
|
||
* @api private
|
||
*/ function Transport(opts) {
|
||
this.path = opts.path;
|
||
this.hostname = opts.hostname;
|
||
this.port = opts.port;
|
||
this.secure = opts.secure;
|
||
this.query = opts.query;
|
||
this.timestampParam = opts.timestampParam;
|
||
this.timestampRequests = opts.timestampRequests;
|
||
this.readyState = "";
|
||
this.agent = opts.agent || false;
|
||
this.socket = opts.socket;
|
||
this.enablesXDR = opts.enablesXDR;
|
||
this.withCredentials = opts.withCredentials;
|
||
// SSL options for Node.js client
|
||
this.pfx = opts.pfx;
|
||
this.key = opts.key;
|
||
this.passphrase = opts.passphrase;
|
||
this.cert = opts.cert;
|
||
this.ca = opts.ca;
|
||
this.ciphers = opts.ciphers;
|
||
this.rejectUnauthorized = opts.rejectUnauthorized;
|
||
this.forceNode = opts.forceNode;
|
||
// results of ReactNative environment detection
|
||
this.isReactNative = opts.isReactNative;
|
||
// other options for Node.js client
|
||
this.extraHeaders = opts.extraHeaders;
|
||
this.localAddress = opts.localAddress;
|
||
}
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/ Emitter(Transport.prototype);
|
||
/**
|
||
* Emits an error.
|
||
*
|
||
* @param {String} str
|
||
* @return {Transport} for chaining
|
||
* @api public
|
||
*/ Transport.prototype.onError = function(msg, desc) {
|
||
var err = new Error(msg);
|
||
err.type = "TransportError";
|
||
err.description = desc;
|
||
this.emit("error", err);
|
||
return this;
|
||
};
|
||
/**
|
||
* Opens the transport.
|
||
*
|
||
* @api public
|
||
*/ Transport.prototype.open = function() {
|
||
if ("closed" === this.readyState || "" === this.readyState) {
|
||
this.readyState = "opening";
|
||
this.doOpen();
|
||
}
|
||
return this;
|
||
};
|
||
/**
|
||
* Closes the transport.
|
||
*
|
||
* @api private
|
||
*/ Transport.prototype.close = function() {
|
||
if ("opening" === this.readyState || "open" === this.readyState) {
|
||
this.doClose();
|
||
this.onClose();
|
||
}
|
||
return this;
|
||
};
|
||
/**
|
||
* Sends multiple packets.
|
||
*
|
||
* @param {Array} packets
|
||
* @api private
|
||
*/ Transport.prototype.send = function(packets) {
|
||
if ("open" === this.readyState) this.write(packets);
|
||
else throw new Error("Transport not open");
|
||
};
|
||
/**
|
||
* Called upon open
|
||
*
|
||
* @api private
|
||
*/ Transport.prototype.onOpen = function() {
|
||
this.readyState = "open";
|
||
this.writable = true;
|
||
this.emit("open");
|
||
};
|
||
/**
|
||
* Called with data.
|
||
*
|
||
* @param {String} data
|
||
* @api private
|
||
*/ Transport.prototype.onData = function(data) {
|
||
var packet = parser.decodePacket(data, this.socket.binaryType);
|
||
this.onPacket(packet);
|
||
};
|
||
/**
|
||
* Called with a decoded packet.
|
||
*/ Transport.prototype.onPacket = function(packet) {
|
||
this.emit("packet", packet);
|
||
};
|
||
/**
|
||
* Called upon close.
|
||
*
|
||
* @api private
|
||
*/ Transport.prototype.onClose = function() {
|
||
this.readyState = "closed";
|
||
this.emit("close");
|
||
};
|
||
|
||
},{"1847fd3ebe220b7":"eUidh","23bb3bcedf6e6b52":"5nHrO"}],"eUidh":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var keys = require("f8f00a524a197d96");
|
||
var hasBinary = require("4d751f4f181dffd3");
|
||
var sliceBuffer = require("e5cf1a50285a5a2a");
|
||
var after = require("280b7fed8b96ec85");
|
||
var utf8 = require("c9b3809000e0242c");
|
||
var base64encoder;
|
||
if (typeof ArrayBuffer !== "undefined") base64encoder = require("33aec57e480c28a9");
|
||
/**
|
||
* Check if we are running an android browser. That requires us to use
|
||
* ArrayBuffer with polling transports...
|
||
*
|
||
* http://ghinda.net/jpeg-blob-ajax-android/
|
||
*/ var isAndroid = typeof navigator !== "undefined" && /Android/i.test(navigator.userAgent);
|
||
/**
|
||
* Check if we are running in PhantomJS.
|
||
* Uploading a Blob with PhantomJS does not work correctly, as reported here:
|
||
* https://github.com/ariya/phantomjs/issues/11395
|
||
* @type boolean
|
||
*/ var isPhantomJS = typeof navigator !== "undefined" && /PhantomJS/i.test(navigator.userAgent);
|
||
/**
|
||
* When true, avoids using Blobs to encode payloads.
|
||
* @type boolean
|
||
*/ var dontSendBlobs = isAndroid || isPhantomJS;
|
||
/**
|
||
* Current protocol version.
|
||
*/ exports.protocol = 3;
|
||
/**
|
||
* Packet types.
|
||
*/ var packets = exports.packets = {
|
||
open: 0 // non-ws
|
||
,
|
||
close: 1 // non-ws
|
||
,
|
||
ping: 2,
|
||
pong: 3,
|
||
message: 4,
|
||
upgrade: 5,
|
||
noop: 6
|
||
};
|
||
var packetslist = keys(packets);
|
||
/**
|
||
* Premade error packet.
|
||
*/ var err = {
|
||
type: "error",
|
||
data: "parser error"
|
||
};
|
||
/**
|
||
* Create a blob api even for blob builder when vendor prefixes exist
|
||
*/ var Blob = require("455850c1d7cf59c3");
|
||
/**
|
||
* Encodes a packet.
|
||
*
|
||
* <packet type id> [ <data> ]
|
||
*
|
||
* Example:
|
||
*
|
||
* 5hello world
|
||
* 3
|
||
* 4
|
||
*
|
||
* Binary is encoded in an identical principle
|
||
*
|
||
* @api private
|
||
*/ exports.encodePacket = function(packet, supportsBinary, utf8encode, callback) {
|
||
if (typeof supportsBinary === "function") {
|
||
callback = supportsBinary;
|
||
supportsBinary = false;
|
||
}
|
||
if (typeof utf8encode === "function") {
|
||
callback = utf8encode;
|
||
utf8encode = null;
|
||
}
|
||
var data = packet.data === undefined ? undefined : packet.data.buffer || packet.data;
|
||
if (typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) return encodeArrayBuffer(packet, supportsBinary, callback);
|
||
else if (typeof Blob !== "undefined" && data instanceof Blob) return encodeBlob(packet, supportsBinary, callback);
|
||
// might be an object with { base64: true, data: dataAsBase64String }
|
||
if (data && data.base64) return encodeBase64Object(packet, callback);
|
||
// Sending data as a utf-8 string
|
||
var encoded = packets[packet.type];
|
||
// data fragment is optional
|
||
if (undefined !== packet.data) encoded += utf8encode ? utf8.encode(String(packet.data), {
|
||
strict: false
|
||
}) : String(packet.data);
|
||
return callback("" + encoded);
|
||
};
|
||
function encodeBase64Object(packet, callback) {
|
||
// packet data is an object { base64: true, data: dataAsBase64String }
|
||
var message = "b" + exports.packets[packet.type] + packet.data.data;
|
||
return callback(message);
|
||
}
|
||
/**
|
||
* Encode packet helpers for binary types
|
||
*/ function encodeArrayBuffer(packet, supportsBinary, callback) {
|
||
if (!supportsBinary) return exports.encodeBase64Packet(packet, callback);
|
||
var data = packet.data;
|
||
var contentArray = new Uint8Array(data);
|
||
var resultBuffer = new Uint8Array(1 + data.byteLength);
|
||
resultBuffer[0] = packets[packet.type];
|
||
for(var i = 0; i < contentArray.length; i++)resultBuffer[i + 1] = contentArray[i];
|
||
return callback(resultBuffer.buffer);
|
||
}
|
||
function encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {
|
||
if (!supportsBinary) return exports.encodeBase64Packet(packet, callback);
|
||
var fr = new FileReader();
|
||
fr.onload = function() {
|
||
exports.encodePacket({
|
||
type: packet.type,
|
||
data: fr.result
|
||
}, supportsBinary, true, callback);
|
||
};
|
||
return fr.readAsArrayBuffer(packet.data);
|
||
}
|
||
function encodeBlob(packet, supportsBinary, callback) {
|
||
if (!supportsBinary) return exports.encodeBase64Packet(packet, callback);
|
||
if (dontSendBlobs) return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);
|
||
var length = new Uint8Array(1);
|
||
length[0] = packets[packet.type];
|
||
var blob = new Blob([
|
||
length.buffer,
|
||
packet.data
|
||
]);
|
||
return callback(blob);
|
||
}
|
||
/**
|
||
* Encodes a packet with binary data in a base64 string
|
||
*
|
||
* @param {Object} packet, has `type` and `data`
|
||
* @return {String} base64 encoded message
|
||
*/ exports.encodeBase64Packet = function(packet, callback) {
|
||
var message = "b" + exports.packets[packet.type];
|
||
if (typeof Blob !== "undefined" && packet.data instanceof Blob) {
|
||
var fr = new FileReader();
|
||
fr.onload = function() {
|
||
var b64 = fr.result.split(",")[1];
|
||
callback(message + b64);
|
||
};
|
||
return fr.readAsDataURL(packet.data);
|
||
}
|
||
var b64data;
|
||
try {
|
||
b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));
|
||
} catch (e) {
|
||
// iPhone Safari doesn't let you apply with typed arrays
|
||
var typed = new Uint8Array(packet.data);
|
||
var basic = new Array(typed.length);
|
||
for(var i = 0; i < typed.length; i++)basic[i] = typed[i];
|
||
b64data = String.fromCharCode.apply(null, basic);
|
||
}
|
||
message += btoa(b64data);
|
||
return callback(message);
|
||
};
|
||
/**
|
||
* Decodes a packet. Changes format to Blob if requested.
|
||
*
|
||
* @return {Object} with `type` and `data` (if any)
|
||
* @api private
|
||
*/ exports.decodePacket = function(data, binaryType, utf8decode) {
|
||
if (data === undefined) return err;
|
||
// String data
|
||
if (typeof data === "string") {
|
||
if (data.charAt(0) === "b") return exports.decodeBase64Packet(data.substr(1), binaryType);
|
||
if (utf8decode) {
|
||
data = tryDecode(data);
|
||
if (data === false) return err;
|
||
}
|
||
var type = data.charAt(0);
|
||
if (Number(type) != type || !packetslist[type]) return err;
|
||
if (data.length > 1) return {
|
||
type: packetslist[type],
|
||
data: data.substring(1)
|
||
};
|
||
else return {
|
||
type: packetslist[type]
|
||
};
|
||
}
|
||
var asArray = new Uint8Array(data);
|
||
var type = asArray[0];
|
||
var rest = sliceBuffer(data, 1);
|
||
if (Blob && binaryType === "blob") rest = new Blob([
|
||
rest
|
||
]);
|
||
return {
|
||
type: packetslist[type],
|
||
data: rest
|
||
};
|
||
};
|
||
function tryDecode(data) {
|
||
try {
|
||
data = utf8.decode(data, {
|
||
strict: false
|
||
});
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
return data;
|
||
}
|
||
/**
|
||
* Decodes a packet encoded in a base64 string
|
||
*
|
||
* @param {String} base64 encoded message
|
||
* @return {Object} with `type` and `data` (if any)
|
||
*/ exports.decodeBase64Packet = function(msg, binaryType) {
|
||
var type = packetslist[msg.charAt(0)];
|
||
if (!base64encoder) return {
|
||
type: type,
|
||
data: {
|
||
base64: true,
|
||
data: msg.substr(1)
|
||
}
|
||
};
|
||
var data = base64encoder.decode(msg.substr(1));
|
||
if (binaryType === "blob" && Blob) data = new Blob([
|
||
data
|
||
]);
|
||
return {
|
||
type: type,
|
||
data: data
|
||
};
|
||
};
|
||
/**
|
||
* Encodes multiple messages (payload).
|
||
*
|
||
* <length>:data
|
||
*
|
||
* Example:
|
||
*
|
||
* 11:hello world2:hi
|
||
*
|
||
* If any contents are binary, they will be encoded as base64 strings. Base64
|
||
* encoded strings are marked with a b before the length specifier
|
||
*
|
||
* @param {Array} packets
|
||
* @api private
|
||
*/ exports.encodePayload = function(packets, supportsBinary, callback) {
|
||
if (typeof supportsBinary === "function") {
|
||
callback = supportsBinary;
|
||
supportsBinary = null;
|
||
}
|
||
var isBinary = hasBinary(packets);
|
||
if (supportsBinary && isBinary) {
|
||
if (Blob && !dontSendBlobs) return exports.encodePayloadAsBlob(packets, callback);
|
||
return exports.encodePayloadAsArrayBuffer(packets, callback);
|
||
}
|
||
if (!packets.length) return callback("0:");
|
||
function setLengthHeader(message) {
|
||
return message.length + ":" + message;
|
||
}
|
||
function encodeOne(packet, doneCallback) {
|
||
exports.encodePacket(packet, !isBinary ? false : supportsBinary, false, function(message) {
|
||
doneCallback(null, setLengthHeader(message));
|
||
});
|
||
}
|
||
map(packets, encodeOne, function(err, results) {
|
||
return callback(results.join(""));
|
||
});
|
||
};
|
||
/**
|
||
* Async array map using after
|
||
*/ function map(ary, each, done) {
|
||
var result = new Array(ary.length);
|
||
var next = after(ary.length, done);
|
||
var eachWithIndex = function(i, el, cb) {
|
||
each(el, function(error, msg) {
|
||
result[i] = msg;
|
||
cb(error, result);
|
||
});
|
||
};
|
||
for(var i = 0; i < ary.length; i++)eachWithIndex(i, ary[i], next);
|
||
}
|
||
/*
|
||
* Decodes data when a payload is maybe expected. Possible binary contents are
|
||
* decoded from their base64 representation
|
||
*
|
||
* @param {String} data, callback method
|
||
* @api public
|
||
*/ exports.decodePayload = function(data, binaryType, callback) {
|
||
if (typeof data !== "string") return exports.decodePayloadAsBinary(data, binaryType, callback);
|
||
if (typeof binaryType === "function") {
|
||
callback = binaryType;
|
||
binaryType = null;
|
||
}
|
||
var packet;
|
||
if (data === "") // parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
var length = "", n, msg;
|
||
for(var i = 0, l = data.length; i < l; i++){
|
||
var chr = data.charAt(i);
|
||
if (chr !== ":") {
|
||
length += chr;
|
||
continue;
|
||
}
|
||
if (length === "" || length != (n = Number(length))) // parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
msg = data.substr(i + 1, n);
|
||
if (length != msg.length) // parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
if (msg.length) {
|
||
packet = exports.decodePacket(msg, binaryType, false);
|
||
if (err.type === packet.type && err.data === packet.data) // parser error in individual packet - ignoring payload
|
||
return callback(err, 0, 1);
|
||
var ret = callback(packet, i + n, l);
|
||
if (false === ret) return;
|
||
}
|
||
// advance cursor
|
||
i += n;
|
||
length = "";
|
||
}
|
||
if (length !== "") // parser error - ignoring payload
|
||
return callback(err, 0, 1);
|
||
};
|
||
/**
|
||
* Encodes multiple messages (payload) as binary.
|
||
*
|
||
* <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number
|
||
* 255><data>
|
||
*
|
||
* Example:
|
||
* 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers
|
||
*
|
||
* @param {Array} packets
|
||
* @return {ArrayBuffer} encoded payload
|
||
* @api private
|
||
*/ exports.encodePayloadAsArrayBuffer = function(packets, callback) {
|
||
if (!packets.length) return callback(new ArrayBuffer(0));
|
||
function encodeOne(packet, doneCallback) {
|
||
exports.encodePacket(packet, true, true, function(data) {
|
||
return doneCallback(null, data);
|
||
});
|
||
}
|
||
map(packets, encodeOne, function(err, encodedPackets) {
|
||
var totalLength = encodedPackets.reduce(function(acc, p) {
|
||
var len;
|
||
if (typeof p === "string") len = p.length;
|
||
else len = p.byteLength;
|
||
return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2
|
||
}, 0);
|
||
var resultArray = new Uint8Array(totalLength);
|
||
var bufferIndex = 0;
|
||
encodedPackets.forEach(function(p) {
|
||
var isString = typeof p === "string";
|
||
var ab = p;
|
||
if (isString) {
|
||
var view = new Uint8Array(p.length);
|
||
for(var i = 0; i < p.length; i++)view[i] = p.charCodeAt(i);
|
||
ab = view.buffer;
|
||
}
|
||
if (isString) resultArray[bufferIndex++] = 0;
|
||
else resultArray[bufferIndex++] = 1;
|
||
var lenStr = ab.byteLength.toString();
|
||
for(var i = 0; i < lenStr.length; i++)resultArray[bufferIndex++] = parseInt(lenStr[i]);
|
||
resultArray[bufferIndex++] = 255;
|
||
var view = new Uint8Array(ab);
|
||
for(var i = 0; i < view.length; i++)resultArray[bufferIndex++] = view[i];
|
||
});
|
||
return callback(resultArray.buffer);
|
||
});
|
||
};
|
||
/**
|
||
* Encode as Blob
|
||
*/ exports.encodePayloadAsBlob = function(packets, callback) {
|
||
function encodeOne(packet, doneCallback) {
|
||
exports.encodePacket(packet, true, true, function(encoded) {
|
||
var binaryIdentifier = new Uint8Array(1);
|
||
binaryIdentifier[0] = 1;
|
||
if (typeof encoded === "string") {
|
||
var view = new Uint8Array(encoded.length);
|
||
for(var i = 0; i < encoded.length; i++)view[i] = encoded.charCodeAt(i);
|
||
encoded = view.buffer;
|
||
binaryIdentifier[0] = 0;
|
||
}
|
||
var len = encoded instanceof ArrayBuffer ? encoded.byteLength : encoded.size;
|
||
var lenStr = len.toString();
|
||
var lengthAry = new Uint8Array(lenStr.length + 1);
|
||
for(var i = 0; i < lenStr.length; i++)lengthAry[i] = parseInt(lenStr[i]);
|
||
lengthAry[lenStr.length] = 255;
|
||
if (Blob) {
|
||
var blob = new Blob([
|
||
binaryIdentifier.buffer,
|
||
lengthAry.buffer,
|
||
encoded
|
||
]);
|
||
doneCallback(null, blob);
|
||
}
|
||
});
|
||
}
|
||
map(packets, encodeOne, function(err, results) {
|
||
return callback(new Blob(results));
|
||
});
|
||
};
|
||
/*
|
||
* Decodes data when a payload is maybe expected. Strings are decoded by
|
||
* interpreting each byte as a key code for entries marked to start with 0. See
|
||
* description of encodePayloadAsBinary
|
||
*
|
||
* @param {ArrayBuffer} data, callback method
|
||
* @api public
|
||
*/ exports.decodePayloadAsBinary = function(data, binaryType, callback) {
|
||
if (typeof binaryType === "function") {
|
||
callback = binaryType;
|
||
binaryType = null;
|
||
}
|
||
var bufferTail = data;
|
||
var buffers = [];
|
||
while(bufferTail.byteLength > 0){
|
||
var tailArray = new Uint8Array(bufferTail);
|
||
var isString = tailArray[0] === 0;
|
||
var msgLength = "";
|
||
for(var i = 1;; i++){
|
||
if (tailArray[i] === 255) break;
|
||
// 310 = char length of Number.MAX_VALUE
|
||
if (msgLength.length > 310) return callback(err, 0, 1);
|
||
msgLength += tailArray[i];
|
||
}
|
||
bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);
|
||
msgLength = parseInt(msgLength);
|
||
var msg = sliceBuffer(bufferTail, 0, msgLength);
|
||
if (isString) try {
|
||
msg = String.fromCharCode.apply(null, new Uint8Array(msg));
|
||
} catch (e) {
|
||
// iPhone Safari doesn't let you apply to typed arrays
|
||
var typed = new Uint8Array(msg);
|
||
msg = "";
|
||
for(var i = 0; i < typed.length; i++)msg += String.fromCharCode(typed[i]);
|
||
}
|
||
buffers.push(msg);
|
||
bufferTail = sliceBuffer(bufferTail, msgLength);
|
||
}
|
||
var total = buffers.length;
|
||
buffers.forEach(function(buffer, i) {
|
||
callback(exports.decodePacket(buffer, binaryType, true), i, total);
|
||
});
|
||
};
|
||
|
||
},{"f8f00a524a197d96":"biMMh","4d751f4f181dffd3":"bvVNt","e5cf1a50285a5a2a":"fcvwH","280b7fed8b96ec85":"I5Mj4","c9b3809000e0242c":"eUyck","33aec57e480c28a9":"dQodo","455850c1d7cf59c3":"hLYO4"}],"biMMh":[function(require,module,exports) {
|
||
/**
|
||
* Gets the keys for an object.
|
||
*
|
||
* @return {Array} keys
|
||
* @api private
|
||
*/ module.exports = Object.keys || function keys(obj) {
|
||
var arr = [];
|
||
var has = Object.prototype.hasOwnProperty;
|
||
for(var i in obj)if (has.call(obj, i)) arr.push(i);
|
||
return arr;
|
||
};
|
||
|
||
},{}],"bvVNt":[function(require,module,exports) {
|
||
/* global Blob File */ /*
|
||
* Module requirements.
|
||
*/ var Buffer = require("92fe6d17ee67fc84").Buffer;
|
||
var isArray = require("311e6a197ed46291");
|
||
var toString = Object.prototype.toString;
|
||
var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && toString.call(Blob) === "[object BlobConstructor]";
|
||
var withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString.call(File) === "[object FileConstructor]";
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = hasBinary;
|
||
/**
|
||
* Checks for binary data.
|
||
*
|
||
* Supports Buffer, ArrayBuffer, Blob and File.
|
||
*
|
||
* @param {Object} anything
|
||
* @api public
|
||
*/ function hasBinary(obj) {
|
||
if (!obj || typeof obj !== "object") return false;
|
||
if (isArray(obj)) {
|
||
for(var i = 0, l = obj.length; i < l; i++){
|
||
if (hasBinary(obj[i])) return true;
|
||
}
|
||
return false;
|
||
}
|
||
if (typeof Buffer === "function" && Buffer.isBuffer && Buffer.isBuffer(obj) || typeof ArrayBuffer === "function" && obj instanceof ArrayBuffer || withNativeBlob && obj instanceof Blob || withNativeFile && obj instanceof File) return true;
|
||
// see: https://github.com/Automattic/has-binary/pull/4
|
||
if (obj.toJSON && typeof obj.toJSON === "function" && arguments.length === 1) return hasBinary(obj.toJSON(), true);
|
||
for(var key in obj){
|
||
if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
},{"92fe6d17ee67fc84":"fCgem","311e6a197ed46291":"hk7XJ"}],"fcvwH":[function(require,module,exports) {
|
||
/**
|
||
* An abstraction for slicing an arraybuffer even when
|
||
* ArrayBuffer.prototype.slice is not supported
|
||
*
|
||
* @api public
|
||
*/ module.exports = function(arraybuffer, start, end) {
|
||
var bytes = arraybuffer.byteLength;
|
||
start = start || 0;
|
||
end = end || bytes;
|
||
if (arraybuffer.slice) return arraybuffer.slice(start, end);
|
||
if (start < 0) start += bytes;
|
||
if (end < 0) end += bytes;
|
||
if (end > bytes) end = bytes;
|
||
if (start >= bytes || start >= end || bytes === 0) return new ArrayBuffer(0);
|
||
var abv = new Uint8Array(arraybuffer);
|
||
var result = new Uint8Array(end - start);
|
||
for(var i = start, ii = 0; i < end; i++, ii++)result[ii] = abv[i];
|
||
return result.buffer;
|
||
};
|
||
|
||
},{}],"I5Mj4":[function(require,module,exports) {
|
||
module.exports = after;
|
||
function after(count, callback, err_cb) {
|
||
var bail = false;
|
||
err_cb = err_cb || noop;
|
||
proxy.count = count;
|
||
return count === 0 ? callback() : proxy;
|
||
function proxy(err, result) {
|
||
if (proxy.count <= 0) throw new Error("after called too many times");
|
||
--proxy.count;
|
||
// after first error, rest are passed to err_cb
|
||
if (err) {
|
||
bail = true;
|
||
callback(err);
|
||
// future error callbacks will go to error handler
|
||
callback = err_cb;
|
||
} else if (proxy.count === 0 && !bail) callback(null, result);
|
||
}
|
||
}
|
||
function noop() {}
|
||
|
||
},{}],"eUyck":[function(require,module,exports) {
|
||
/*! https://mths.be/utf8js v2.1.2 by @mathias */ var stringFromCharCode = String.fromCharCode;
|
||
// Taken from https://mths.be/punycode
|
||
function ucs2decode(string) {
|
||
var output = [];
|
||
var counter = 0;
|
||
var length = string.length;
|
||
var value;
|
||
var extra;
|
||
while(counter < length){
|
||
value = string.charCodeAt(counter++);
|
||
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
|
||
// high surrogate, and there is a next character
|
||
extra = string.charCodeAt(counter++);
|
||
if ((extra & 0xFC00) == 0xDC00) output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
|
||
else {
|
||
// unmatched surrogate; only append this code unit, in case the next
|
||
// code unit is the high surrogate of a surrogate pair
|
||
output.push(value);
|
||
counter--;
|
||
}
|
||
} else output.push(value);
|
||
}
|
||
return output;
|
||
}
|
||
// Taken from https://mths.be/punycode
|
||
function ucs2encode(array) {
|
||
var length = array.length;
|
||
var index = -1;
|
||
var value;
|
||
var output = "";
|
||
while(++index < length){
|
||
value = array[index];
|
||
if (value > 0xFFFF) {
|
||
value -= 0x10000;
|
||
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
|
||
value = 0xDC00 | value & 0x3FF;
|
||
}
|
||
output += stringFromCharCode(value);
|
||
}
|
||
return output;
|
||
}
|
||
function checkScalarValue(codePoint, strict) {
|
||
if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
|
||
if (strict) throw Error("Lone surrogate U+" + codePoint.toString(16).toUpperCase() + " is not a scalar value");
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
/*--------------------------------------------------------------------------*/ function createByte(codePoint, shift) {
|
||
return stringFromCharCode(codePoint >> shift & 0x3F | 0x80);
|
||
}
|
||
function encodeCodePoint(codePoint, strict) {
|
||
if ((codePoint & 0xFFFFFF80) == 0) return stringFromCharCode(codePoint);
|
||
var symbol = "";
|
||
if ((codePoint & 0xFFFFF800) == 0) symbol = stringFromCharCode(codePoint >> 6 & 0x1F | 0xC0);
|
||
else if ((codePoint & 0xFFFF0000) == 0) {
|
||
if (!checkScalarValue(codePoint, strict)) codePoint = 0xFFFD;
|
||
symbol = stringFromCharCode(codePoint >> 12 & 0x0F | 0xE0);
|
||
symbol += createByte(codePoint, 6);
|
||
} else if ((codePoint & 0xFFE00000) == 0) {
|
||
symbol = stringFromCharCode(codePoint >> 18 & 0x07 | 0xF0);
|
||
symbol += createByte(codePoint, 12);
|
||
symbol += createByte(codePoint, 6);
|
||
}
|
||
symbol += stringFromCharCode(codePoint & 0x3F | 0x80);
|
||
return symbol;
|
||
}
|
||
function utf8encode(string, opts) {
|
||
opts = opts || {};
|
||
var strict = false !== opts.strict;
|
||
var codePoints = ucs2decode(string);
|
||
var length = codePoints.length;
|
||
var index = -1;
|
||
var codePoint;
|
||
var byteString = "";
|
||
while(++index < length){
|
||
codePoint = codePoints[index];
|
||
byteString += encodeCodePoint(codePoint, strict);
|
||
}
|
||
return byteString;
|
||
}
|
||
/*--------------------------------------------------------------------------*/ function readContinuationByte() {
|
||
if (byteIndex >= byteCount) throw Error("Invalid byte index");
|
||
var continuationByte = byteArray[byteIndex] & 0xFF;
|
||
byteIndex++;
|
||
if ((continuationByte & 0xC0) == 0x80) return continuationByte & 0x3F;
|
||
// If we end up here, it’s not a continuation byte
|
||
throw Error("Invalid continuation byte");
|
||
}
|
||
function decodeSymbol(strict) {
|
||
var byte1;
|
||
var byte2;
|
||
var byte3;
|
||
var byte4;
|
||
var codePoint;
|
||
if (byteIndex > byteCount) throw Error("Invalid byte index");
|
||
if (byteIndex == byteCount) return false;
|
||
// Read first byte
|
||
byte1 = byteArray[byteIndex] & 0xFF;
|
||
byteIndex++;
|
||
// 1-byte sequence (no continuation bytes)
|
||
if ((byte1 & 0x80) == 0) return byte1;
|
||
// 2-byte sequence
|
||
if ((byte1 & 0xE0) == 0xC0) {
|
||
byte2 = readContinuationByte();
|
||
codePoint = (byte1 & 0x1F) << 6 | byte2;
|
||
if (codePoint >= 0x80) return codePoint;
|
||
else throw Error("Invalid continuation byte");
|
||
}
|
||
// 3-byte sequence (may include unpaired surrogates)
|
||
if ((byte1 & 0xF0) == 0xE0) {
|
||
byte2 = readContinuationByte();
|
||
byte3 = readContinuationByte();
|
||
codePoint = (byte1 & 0x0F) << 12 | byte2 << 6 | byte3;
|
||
if (codePoint >= 0x0800) return checkScalarValue(codePoint, strict) ? codePoint : 0xFFFD;
|
||
else throw Error("Invalid continuation byte");
|
||
}
|
||
// 4-byte sequence
|
||
if ((byte1 & 0xF8) == 0xF0) {
|
||
byte2 = readContinuationByte();
|
||
byte3 = readContinuationByte();
|
||
byte4 = readContinuationByte();
|
||
codePoint = (byte1 & 0x07) << 0x12 | byte2 << 0x0C | byte3 << 0x06 | byte4;
|
||
if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) return codePoint;
|
||
}
|
||
throw Error("Invalid UTF-8 detected");
|
||
}
|
||
var byteArray;
|
||
var byteCount;
|
||
var byteIndex;
|
||
function utf8decode(byteString, opts) {
|
||
opts = opts || {};
|
||
var strict = false !== opts.strict;
|
||
byteArray = ucs2decode(byteString);
|
||
byteCount = byteArray.length;
|
||
byteIndex = 0;
|
||
var codePoints = [];
|
||
var tmp;
|
||
while((tmp = decodeSymbol(strict)) !== false)codePoints.push(tmp);
|
||
return ucs2encode(codePoints);
|
||
}
|
||
module.exports = {
|
||
version: "2.1.2",
|
||
encode: utf8encode,
|
||
decode: utf8decode
|
||
};
|
||
|
||
},{}],"dQodo":[function(require,module,exports) {
|
||
/*
|
||
* base64-arraybuffer
|
||
* https://github.com/niklasvh/base64-arraybuffer
|
||
*
|
||
* Copyright (c) 2012 Niklas von Hertzen
|
||
* Licensed under the MIT license.
|
||
*/ (function(chars) {
|
||
"use strict";
|
||
exports.encode = function(arraybuffer) {
|
||
var bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = "";
|
||
for(i = 0; i < len; i += 3){
|
||
base64 += chars[bytes[i] >> 2];
|
||
base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
|
||
base64 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
|
||
base64 += chars[bytes[i + 2] & 63];
|
||
}
|
||
if (len % 3 === 2) base64 = base64.substring(0, base64.length - 1) + "=";
|
||
else if (len % 3 === 1) base64 = base64.substring(0, base64.length - 2) + "==";
|
||
return base64;
|
||
};
|
||
exports.decode = function(base64) {
|
||
var bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
|
||
if (base64[base64.length - 1] === "=") {
|
||
bufferLength--;
|
||
if (base64[base64.length - 2] === "=") bufferLength--;
|
||
}
|
||
var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
|
||
for(i = 0; i < len; i += 4){
|
||
encoded1 = chars.indexOf(base64[i]);
|
||
encoded2 = chars.indexOf(base64[i + 1]);
|
||
encoded3 = chars.indexOf(base64[i + 2]);
|
||
encoded4 = chars.indexOf(base64[i + 3]);
|
||
bytes[p++] = encoded1 << 2 | encoded2 >> 4;
|
||
bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
|
||
bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
|
||
}
|
||
return arraybuffer;
|
||
};
|
||
})("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
|
||
|
||
},{}],"hLYO4":[function(require,module,exports) {
|
||
/**
|
||
* Create a blob builder even when vendor prefixes exist
|
||
*/ var BlobBuilder = typeof BlobBuilder !== "undefined" ? BlobBuilder : typeof WebKitBlobBuilder !== "undefined" ? WebKitBlobBuilder : typeof MSBlobBuilder !== "undefined" ? MSBlobBuilder : typeof MozBlobBuilder !== "undefined" ? MozBlobBuilder : false;
|
||
/**
|
||
* Check if Blob constructor is supported
|
||
*/ var blobSupported = function() {
|
||
try {
|
||
var a = new Blob([
|
||
"hi"
|
||
]);
|
||
return a.size === 2;
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
}();
|
||
/**
|
||
* Check if Blob constructor supports ArrayBufferViews
|
||
* Fails in Safari 6, so we need to map to ArrayBuffers there.
|
||
*/ var blobSupportsArrayBufferView = blobSupported && function() {
|
||
try {
|
||
var b = new Blob([
|
||
new Uint8Array([
|
||
1,
|
||
2
|
||
])
|
||
]);
|
||
return b.size === 2;
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
}();
|
||
/**
|
||
* Check if BlobBuilder is supported
|
||
*/ var blobBuilderSupported = BlobBuilder && BlobBuilder.prototype.append && BlobBuilder.prototype.getBlob;
|
||
/**
|
||
* Helper function that maps ArrayBufferViews to ArrayBuffers
|
||
* Used by BlobBuilder constructor and old browsers that didn't
|
||
* support it in the Blob constructor.
|
||
*/ function mapArrayBufferViews(ary) {
|
||
return ary.map(function(chunk) {
|
||
if (chunk.buffer instanceof ArrayBuffer) {
|
||
var buf = chunk.buffer;
|
||
// if this is a subarray, make a copy so we only
|
||
// include the subarray region from the underlying buffer
|
||
if (chunk.byteLength !== buf.byteLength) {
|
||
var copy = new Uint8Array(chunk.byteLength);
|
||
copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));
|
||
buf = copy.buffer;
|
||
}
|
||
return buf;
|
||
}
|
||
return chunk;
|
||
});
|
||
}
|
||
function BlobBuilderConstructor(ary, options) {
|
||
options = options || {};
|
||
var bb = new BlobBuilder();
|
||
mapArrayBufferViews(ary).forEach(function(part) {
|
||
bb.append(part);
|
||
});
|
||
return options.type ? bb.getBlob(options.type) : bb.getBlob();
|
||
}
|
||
function BlobConstructor(ary, options) {
|
||
return new Blob(mapArrayBufferViews(ary), options || {});
|
||
}
|
||
if (typeof Blob !== "undefined") {
|
||
BlobBuilderConstructor.prototype = Blob.prototype;
|
||
BlobConstructor.prototype = Blob.prototype;
|
||
}
|
||
module.exports = function() {
|
||
if (blobSupported) return blobSupportsArrayBufferView ? Blob : BlobConstructor;
|
||
else if (blobBuilderSupported) return BlobBuilderConstructor;
|
||
else return undefined;
|
||
}();
|
||
|
||
},{}],"M504l":[function(require,module,exports) {
|
||
/**
|
||
* Compiles a querystring
|
||
* Returns string representation of the object
|
||
*
|
||
* @param {Object}
|
||
* @api private
|
||
*/ exports.encode = function(obj) {
|
||
var str = "";
|
||
for(var i in obj)if (obj.hasOwnProperty(i)) {
|
||
if (str.length) str += "&";
|
||
str += encodeURIComponent(i) + "=" + encodeURIComponent(obj[i]);
|
||
}
|
||
return str;
|
||
};
|
||
/**
|
||
* Parses a simple querystring into an object
|
||
*
|
||
* @param {String} qs
|
||
* @api private
|
||
*/ exports.decode = function(qs) {
|
||
var qry = {};
|
||
var pairs = qs.split("&");
|
||
for(var i = 0, l = pairs.length; i < l; i++){
|
||
var pair = pairs[i].split("=");
|
||
qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
|
||
}
|
||
return qry;
|
||
};
|
||
|
||
},{}],"idpNN":[function(require,module,exports) {
|
||
module.exports = function(a, b) {
|
||
var fn = function() {};
|
||
fn.prototype = b.prototype;
|
||
a.prototype = new fn;
|
||
a.prototype.constructor = a;
|
||
};
|
||
|
||
},{}],"3CfTu":[function(require,module,exports) {
|
||
"use strict";
|
||
var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".split(""), length = 64, map = {}, seed = 0, i = 0, prev;
|
||
/**
|
||
* Return a string representing the specified number.
|
||
*
|
||
* @param {Number} num The number to convert.
|
||
* @returns {String} The string representation of the number.
|
||
* @api public
|
||
*/ function encode(num) {
|
||
var encoded = "";
|
||
do {
|
||
encoded = alphabet[num % length] + encoded;
|
||
num = Math.floor(num / length);
|
||
}while (num > 0);
|
||
return encoded;
|
||
}
|
||
/**
|
||
* Return the integer value specified by the given string.
|
||
*
|
||
* @param {String} str The string to convert.
|
||
* @returns {Number} The integer value represented by the string.
|
||
* @api public
|
||
*/ function decode(str) {
|
||
var decoded = 0;
|
||
for(i = 0; i < str.length; i++)decoded = decoded * length + map[str.charAt(i)];
|
||
return decoded;
|
||
}
|
||
/**
|
||
* Yeast: A tiny growing id generator.
|
||
*
|
||
* @returns {String} A unique id.
|
||
* @api public
|
||
*/ function yeast() {
|
||
var now = encode(+new Date());
|
||
if (now !== prev) return seed = 0, prev = now;
|
||
return now + "." + encode(seed++);
|
||
}
|
||
//
|
||
// Map each character to its index.
|
||
//
|
||
for(; i < length; i++)map[alphabet[i]] = i;
|
||
//
|
||
// Expose the `yeast`, `encode` and `decode` functions.
|
||
//
|
||
yeast.encode = encode;
|
||
yeast.decode = decode;
|
||
module.exports = yeast;
|
||
|
||
},{}],"7PlrH":[function(require,module,exports) {
|
||
/**
|
||
* Module requirements.
|
||
*/ var Polling = require("b95a72800069b181");
|
||
var inherit = require("1bb6e1cb688fc8c7");
|
||
var globalThis1 = require("b34a44212c4ce195");
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = JSONPPolling;
|
||
/**
|
||
* Cached regular expressions.
|
||
*/ var rNewline = /\n/g;
|
||
var rEscapedNewline = /\\n/g;
|
||
/**
|
||
* Global JSONP callbacks.
|
||
*/ var callbacks;
|
||
/**
|
||
* Noop.
|
||
*/ function empty() {}
|
||
/**
|
||
* JSONP Polling constructor.
|
||
*
|
||
* @param {Object} opts.
|
||
* @api public
|
||
*/ function JSONPPolling(opts) {
|
||
Polling.call(this, opts);
|
||
this.query = this.query || {};
|
||
// define global callbacks array if not present
|
||
// we do this here (lazily) to avoid unneeded global pollution
|
||
if (!callbacks) // we need to consider multiple engines in the same page
|
||
callbacks = globalThis.___eio = globalThis.___eio || [];
|
||
// callback identifier
|
||
this.index = callbacks.length;
|
||
// add callback to jsonp global
|
||
var self = this;
|
||
callbacks.push(function(msg) {
|
||
self.onData(msg);
|
||
});
|
||
// append to query string
|
||
this.query.j = this.index;
|
||
// prevent spurious errors from being emitted when the window is unloaded
|
||
if (typeof addEventListener === "function") addEventListener("beforeunload", function() {
|
||
if (self.script) self.script.onerror = empty;
|
||
}, false);
|
||
}
|
||
/**
|
||
* Inherits from Polling.
|
||
*/ inherit(JSONPPolling, Polling);
|
||
/*
|
||
* JSONP only supports binary as base64 encoded strings
|
||
*/ JSONPPolling.prototype.supportsBinary = false;
|
||
/**
|
||
* Closes the socket.
|
||
*
|
||
* @api private
|
||
*/ JSONPPolling.prototype.doClose = function() {
|
||
if (this.script) {
|
||
this.script.parentNode.removeChild(this.script);
|
||
this.script = null;
|
||
}
|
||
if (this.form) {
|
||
this.form.parentNode.removeChild(this.form);
|
||
this.form = null;
|
||
this.iframe = null;
|
||
}
|
||
Polling.prototype.doClose.call(this);
|
||
};
|
||
/**
|
||
* Starts a poll cycle.
|
||
*
|
||
* @api private
|
||
*/ JSONPPolling.prototype.doPoll = function() {
|
||
var self = this;
|
||
var script = document.createElement("script");
|
||
if (this.script) {
|
||
this.script.parentNode.removeChild(this.script);
|
||
this.script = null;
|
||
}
|
||
script.async = true;
|
||
script.src = this.uri();
|
||
script.onerror = function(e) {
|
||
self.onError("jsonp poll error", e);
|
||
};
|
||
var insertAt = document.getElementsByTagName("script")[0];
|
||
if (insertAt) insertAt.parentNode.insertBefore(script, insertAt);
|
||
else (document.head || document.body).appendChild(script);
|
||
this.script = script;
|
||
var isUAgecko = "undefined" !== typeof navigator && /gecko/i.test(navigator.userAgent);
|
||
if (isUAgecko) setTimeout(function() {
|
||
var iframe = document.createElement("iframe");
|
||
document.body.appendChild(iframe);
|
||
document.body.removeChild(iframe);
|
||
}, 100);
|
||
};
|
||
/**
|
||
* Writes with a hidden iframe.
|
||
*
|
||
* @param {String} data to send
|
||
* @param {Function} called upon flush.
|
||
* @api private
|
||
*/ JSONPPolling.prototype.doWrite = function(data, fn) {
|
||
var self = this;
|
||
if (!this.form) {
|
||
var form = document.createElement("form");
|
||
var area = document.createElement("textarea");
|
||
var id = this.iframeId = "eio_iframe_" + this.index;
|
||
var iframe;
|
||
form.className = "socketio";
|
||
form.style.position = "absolute";
|
||
form.style.top = "-1000px";
|
||
form.style.left = "-1000px";
|
||
form.target = id;
|
||
form.method = "POST";
|
||
form.setAttribute("accept-charset", "utf-8");
|
||
area.name = "d";
|
||
form.appendChild(area);
|
||
document.body.appendChild(form);
|
||
this.form = form;
|
||
this.area = area;
|
||
}
|
||
this.form.action = this.uri();
|
||
function complete() {
|
||
initIframe();
|
||
fn();
|
||
}
|
||
function initIframe() {
|
||
if (self.iframe) try {
|
||
self.form.removeChild(self.iframe);
|
||
} catch (e) {
|
||
self.onError("jsonp polling iframe removal error", e);
|
||
}
|
||
try {
|
||
// ie6 dynamic iframes with target="" support (thanks Chris Lambacher)
|
||
var html = '<iframe src="javascript:0" name="' + self.iframeId + '">';
|
||
iframe = document.createElement(html);
|
||
} catch (e) {
|
||
iframe = document.createElement("iframe");
|
||
iframe.name = self.iframeId;
|
||
iframe.src = "javascript:0";
|
||
}
|
||
iframe.id = self.iframeId;
|
||
self.form.appendChild(iframe);
|
||
self.iframe = iframe;
|
||
}
|
||
initIframe();
|
||
// escape \n to prevent it from being converted into \r\n by some UAs
|
||
// double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side
|
||
data = data.replace(rEscapedNewline, "\\\n");
|
||
this.area.value = data.replace(rNewline, "\\n");
|
||
try {
|
||
this.form.submit();
|
||
} catch (e) {}
|
||
if (this.iframe.attachEvent) this.iframe.onreadystatechange = function() {
|
||
if (self.iframe.readyState === "complete") complete();
|
||
};
|
||
else this.iframe.onload = complete;
|
||
};
|
||
|
||
},{"b95a72800069b181":"6Bu9a","1bb6e1cb688fc8c7":"idpNN","b34a44212c4ce195":"68bZg"}],"cl8V7":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var Buffer = require("a0a417939c2096cc").Buffer;
|
||
var Transport = require("dc4e60353351a8bc");
|
||
var parser = require("19826f009c43f394");
|
||
var parseqs = require("e21b6a7be3ab5133");
|
||
var inherit = require("b8a122cd33059508");
|
||
var yeast = require("c9c0d9e2167b05f7");
|
||
var debug = require("ffdcd4d3b6d8069")("engine.io-client:websocket");
|
||
var BrowserWebSocket, NodeWebSocket;
|
||
if (typeof WebSocket !== "undefined") BrowserWebSocket = WebSocket;
|
||
else if (typeof self !== "undefined") BrowserWebSocket = self.WebSocket || self.MozWebSocket;
|
||
if (typeof window === "undefined") try {
|
||
NodeWebSocket = require("6cfaabb4eb595e56");
|
||
} catch (e) {}
|
||
/**
|
||
* Get either the `WebSocket` or `MozWebSocket` globals
|
||
* in the browser or try to resolve WebSocket-compatible
|
||
* interface exposed by `ws` for Node-like environment.
|
||
*/ var WebSocketImpl = BrowserWebSocket || NodeWebSocket;
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = WS;
|
||
/**
|
||
* WebSocket transport constructor.
|
||
*
|
||
* @api {Object} connection options
|
||
* @api public
|
||
*/ function WS(opts) {
|
||
var forceBase64 = opts && opts.forceBase64;
|
||
if (forceBase64) this.supportsBinary = false;
|
||
this.perMessageDeflate = opts.perMessageDeflate;
|
||
this.usingBrowserWebSocket = BrowserWebSocket && !opts.forceNode;
|
||
this.protocols = opts.protocols;
|
||
if (!this.usingBrowserWebSocket) WebSocketImpl = NodeWebSocket;
|
||
Transport.call(this, opts);
|
||
}
|
||
/**
|
||
* Inherits from Transport.
|
||
*/ inherit(WS, Transport);
|
||
/**
|
||
* Transport name.
|
||
*
|
||
* @api public
|
||
*/ WS.prototype.name = "websocket";
|
||
/*
|
||
* WebSockets support binary
|
||
*/ WS.prototype.supportsBinary = true;
|
||
/**
|
||
* Opens socket.
|
||
*
|
||
* @api private
|
||
*/ WS.prototype.doOpen = function() {
|
||
if (!this.check()) // let probe timeout
|
||
return;
|
||
var uri = this.uri();
|
||
var protocols = this.protocols;
|
||
var opts = {};
|
||
if (!this.isReactNative) {
|
||
opts.agent = this.agent;
|
||
opts.perMessageDeflate = this.perMessageDeflate;
|
||
// SSL options for Node.js client
|
||
opts.pfx = this.pfx;
|
||
opts.key = this.key;
|
||
opts.passphrase = this.passphrase;
|
||
opts.cert = this.cert;
|
||
opts.ca = this.ca;
|
||
opts.ciphers = this.ciphers;
|
||
opts.rejectUnauthorized = this.rejectUnauthorized;
|
||
}
|
||
if (this.extraHeaders) opts.headers = this.extraHeaders;
|
||
if (this.localAddress) opts.localAddress = this.localAddress;
|
||
try {
|
||
this.ws = this.usingBrowserWebSocket && !this.isReactNative ? protocols ? new WebSocketImpl(uri, protocols) : new WebSocketImpl(uri) : new WebSocketImpl(uri, protocols, opts);
|
||
} catch (err) {
|
||
return this.emit("error", err);
|
||
}
|
||
if (this.ws.binaryType === undefined) this.supportsBinary = false;
|
||
if (this.ws.supports && this.ws.supports.binary) {
|
||
this.supportsBinary = true;
|
||
this.ws.binaryType = "nodebuffer";
|
||
} else this.ws.binaryType = "arraybuffer";
|
||
this.addEventListeners();
|
||
};
|
||
/**
|
||
* Adds event listeners to the socket
|
||
*
|
||
* @api private
|
||
*/ WS.prototype.addEventListeners = function() {
|
||
var self1 = this;
|
||
this.ws.onopen = function() {
|
||
self1.onOpen();
|
||
};
|
||
this.ws.onclose = function() {
|
||
self1.onClose();
|
||
};
|
||
this.ws.onmessage = function(ev) {
|
||
self1.onData(ev.data);
|
||
};
|
||
this.ws.onerror = function(e) {
|
||
self1.onError("websocket error", e);
|
||
};
|
||
};
|
||
/**
|
||
* Writes data to socket.
|
||
*
|
||
* @param {Array} array of packets.
|
||
* @api private
|
||
*/ WS.prototype.write = function(packets) {
|
||
var self1 = this;
|
||
this.writable = false;
|
||
// encodePacket efficient as it uses WS framing
|
||
// no need for encodePayload
|
||
var total = packets.length;
|
||
for(var i = 0, l = total; i < l; i++)(function(packet) {
|
||
parser.encodePacket(packet, self1.supportsBinary, function(data) {
|
||
if (!self1.usingBrowserWebSocket) {
|
||
// always create a new object (GH-437)
|
||
var opts = {};
|
||
if (packet.options) opts.compress = packet.options.compress;
|
||
if (self1.perMessageDeflate) {
|
||
var len = "string" === typeof data ? Buffer.byteLength(data) : data.length;
|
||
if (len < self1.perMessageDeflate.threshold) opts.compress = false;
|
||
}
|
||
}
|
||
// Sometimes the websocket has already been closed but the browser didn't
|
||
// have a chance of informing us about it yet, in that case send will
|
||
// throw an error
|
||
try {
|
||
if (self1.usingBrowserWebSocket) // TypeError is thrown when passing the second argument on Safari
|
||
self1.ws.send(data);
|
||
else self1.ws.send(data, opts);
|
||
} catch (e) {
|
||
debug("websocket closed before onclose event");
|
||
}
|
||
--total || done();
|
||
});
|
||
})(packets[i]);
|
||
function done() {
|
||
self1.emit("flush");
|
||
// fake drain
|
||
// defer to next tick to allow Socket to clear writeBuffer
|
||
setTimeout(function() {
|
||
self1.writable = true;
|
||
self1.emit("drain");
|
||
}, 0);
|
||
}
|
||
};
|
||
/**
|
||
* Called upon close
|
||
*
|
||
* @api private
|
||
*/ WS.prototype.onClose = function() {
|
||
Transport.prototype.onClose.call(this);
|
||
};
|
||
/**
|
||
* Closes socket.
|
||
*
|
||
* @api private
|
||
*/ WS.prototype.doClose = function() {
|
||
if (typeof this.ws !== "undefined") this.ws.close();
|
||
};
|
||
/**
|
||
* Generates uri for connection.
|
||
*
|
||
* @api private
|
||
*/ WS.prototype.uri = function() {
|
||
var query = this.query || {};
|
||
var schema = this.secure ? "wss" : "ws";
|
||
var port = "";
|
||
// avoid port if default for schema
|
||
if (this.port && ("wss" === schema && Number(this.port) !== 443 || "ws" === schema && Number(this.port) !== 80)) port = ":" + this.port;
|
||
// append timestamp to URI
|
||
if (this.timestampRequests) query[this.timestampParam] = yeast();
|
||
// communicate binary support capabilities
|
||
if (!this.supportsBinary) query.b64 = 1;
|
||
query = parseqs.encode(query);
|
||
// prepend ? to query
|
||
if (query.length) query = "?" + query;
|
||
var ipv6 = this.hostname.indexOf(":") !== -1;
|
||
return schema + "://" + (ipv6 ? "[" + this.hostname + "]" : this.hostname) + port + this.path + query;
|
||
};
|
||
/**
|
||
* Feature detection for WebSocket.
|
||
*
|
||
* @return {Boolean} whether this transport is available.
|
||
* @api public
|
||
*/ WS.prototype.check = function() {
|
||
return !!WebSocketImpl && !("__initialize" in WebSocketImpl && this.name === WS.prototype.name);
|
||
};
|
||
|
||
},{"a0a417939c2096cc":"fCgem","dc4e60353351a8bc":"ljuQJ","19826f009c43f394":"eUidh","e21b6a7be3ab5133":"M504l","b8a122cd33059508":"idpNN","c9c0d9e2167b05f7":"3CfTu","ffdcd4d3b6d8069":"l0oUb","6cfaabb4eb595e56":"jhUEF"}],"jhUEF":[function(require,module,exports) {
|
||
"use strict";
|
||
|
||
},{}],"j5RZX":[function(require,module,exports) {
|
||
var indexOf = [].indexOf;
|
||
module.exports = function(arr, obj) {
|
||
if (indexOf) return arr.indexOf(obj);
|
||
for(var i = 0; i < arr.length; ++i){
|
||
if (arr[i] === obj) return i;
|
||
}
|
||
return -1;
|
||
};
|
||
|
||
},{}],"aZLF9":[function(require,module,exports) {
|
||
/**
|
||
* Module dependencies.
|
||
*/ var parser = require("62860869af69302e");
|
||
var Emitter = require("579d7d3b08eca257");
|
||
var toArray = require("762f918a74841144");
|
||
var on = require("5f486de4e6ba68c2");
|
||
var bind = require("56e2a0d74406281a");
|
||
var debug = require("7f4184a0e1d3cb3a")("socket.io-client:socket");
|
||
var parseqs = require("64b9e3ffd2f3f1b5");
|
||
var hasBin = require("b0d3cdb32b3df3ae");
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = exports = Socket;
|
||
/**
|
||
* Internal events (blacklisted).
|
||
* These events can't be emitted by the user.
|
||
*
|
||
* @api private
|
||
*/ var events = {
|
||
connect: 1,
|
||
connect_error: 1,
|
||
connect_timeout: 1,
|
||
connecting: 1,
|
||
disconnect: 1,
|
||
error: 1,
|
||
reconnect: 1,
|
||
reconnect_attempt: 1,
|
||
reconnect_failed: 1,
|
||
reconnect_error: 1,
|
||
reconnecting: 1,
|
||
ping: 1,
|
||
pong: 1
|
||
};
|
||
/**
|
||
* Shortcut to `Emitter#emit`.
|
||
*/ var emit = Emitter.prototype.emit;
|
||
/**
|
||
* `Socket` constructor.
|
||
*
|
||
* @api public
|
||
*/ function Socket(io, nsp, opts) {
|
||
this.io = io;
|
||
this.nsp = nsp;
|
||
this.json = this; // compat
|
||
this.ids = 0;
|
||
this.acks = {};
|
||
this.receiveBuffer = [];
|
||
this.sendBuffer = [];
|
||
this.connected = false;
|
||
this.disconnected = true;
|
||
this.flags = {};
|
||
if (opts && opts.query) this.query = opts.query;
|
||
if (this.io.autoConnect) this.open();
|
||
}
|
||
/**
|
||
* Mix in `Emitter`.
|
||
*/ Emitter(Socket.prototype);
|
||
/**
|
||
* Subscribe to open, close and packet events
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.subEvents = function() {
|
||
if (this.subs) return;
|
||
var io = this.io;
|
||
this.subs = [
|
||
on(io, "open", bind(this, "onopen")),
|
||
on(io, "packet", bind(this, "onpacket")),
|
||
on(io, "close", bind(this, "onclose"))
|
||
];
|
||
};
|
||
/**
|
||
* "Opens" the socket.
|
||
*
|
||
* @api public
|
||
*/ Socket.prototype.open = Socket.prototype.connect = function() {
|
||
if (this.connected) return this;
|
||
this.subEvents();
|
||
if (!this.io.reconnecting) this.io.open(); // ensure open
|
||
if ("open" === this.io.readyState) this.onopen();
|
||
this.emit("connecting");
|
||
return this;
|
||
};
|
||
/**
|
||
* Sends a `message` event.
|
||
*
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/ Socket.prototype.send = function() {
|
||
var args = toArray(arguments);
|
||
args.unshift("message");
|
||
this.emit.apply(this, args);
|
||
return this;
|
||
};
|
||
/**
|
||
* Override `emit`.
|
||
* If the event is in `events`, it's emitted normally.
|
||
*
|
||
* @param {String} event name
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/ Socket.prototype.emit = function(ev) {
|
||
if (events.hasOwnProperty(ev)) {
|
||
emit.apply(this, arguments);
|
||
return this;
|
||
}
|
||
var args = toArray(arguments);
|
||
var packet = {
|
||
type: (this.flags.binary !== undefined ? this.flags.binary : hasBin(args)) ? parser.BINARY_EVENT : parser.EVENT,
|
||
data: args
|
||
};
|
||
packet.options = {};
|
||
packet.options.compress = !this.flags || false !== this.flags.compress;
|
||
// event ack callback
|
||
if ("function" === typeof args[args.length - 1]) {
|
||
debug("emitting packet with ack id %d", this.ids);
|
||
this.acks[this.ids] = args.pop();
|
||
packet.id = this.ids++;
|
||
}
|
||
if (this.connected) this.packet(packet);
|
||
else this.sendBuffer.push(packet);
|
||
this.flags = {};
|
||
return this;
|
||
};
|
||
/**
|
||
* Sends a packet.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/ Socket.prototype.packet = function(packet) {
|
||
packet.nsp = this.nsp;
|
||
this.io.packet(packet);
|
||
};
|
||
/**
|
||
* Called upon engine `open`.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.onopen = function() {
|
||
debug("transport is open - connecting");
|
||
// write connect packet if necessary
|
||
if ("/" !== this.nsp) {
|
||
if (this.query) {
|
||
var query = typeof this.query === "object" ? parseqs.encode(this.query) : this.query;
|
||
debug("sending connect packet with query %s", query);
|
||
this.packet({
|
||
type: parser.CONNECT,
|
||
query: query
|
||
});
|
||
} else this.packet({
|
||
type: parser.CONNECT
|
||
});
|
||
}
|
||
};
|
||
/**
|
||
* Called upon engine `close`.
|
||
*
|
||
* @param {String} reason
|
||
* @api private
|
||
*/ Socket.prototype.onclose = function(reason) {
|
||
debug("close (%s)", reason);
|
||
this.connected = false;
|
||
this.disconnected = true;
|
||
delete this.id;
|
||
this.emit("disconnect", reason);
|
||
};
|
||
/**
|
||
* Called with socket packet.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/ Socket.prototype.onpacket = function(packet) {
|
||
var sameNamespace = packet.nsp === this.nsp;
|
||
var rootNamespaceError = packet.type === parser.ERROR && packet.nsp === "/";
|
||
if (!sameNamespace && !rootNamespaceError) return;
|
||
switch(packet.type){
|
||
case parser.CONNECT:
|
||
this.onconnect();
|
||
break;
|
||
case parser.EVENT:
|
||
this.onevent(packet);
|
||
break;
|
||
case parser.BINARY_EVENT:
|
||
this.onevent(packet);
|
||
break;
|
||
case parser.ACK:
|
||
this.onack(packet);
|
||
break;
|
||
case parser.BINARY_ACK:
|
||
this.onack(packet);
|
||
break;
|
||
case parser.DISCONNECT:
|
||
this.ondisconnect();
|
||
break;
|
||
case parser.ERROR:
|
||
this.emit("error", packet.data);
|
||
break;
|
||
}
|
||
};
|
||
/**
|
||
* Called upon a server event.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/ Socket.prototype.onevent = function(packet) {
|
||
var args = packet.data || [];
|
||
debug("emitting event %j", args);
|
||
if (null != packet.id) {
|
||
debug("attaching ack callback to event");
|
||
args.push(this.ack(packet.id));
|
||
}
|
||
if (this.connected) emit.apply(this, args);
|
||
else this.receiveBuffer.push(args);
|
||
};
|
||
/**
|
||
* Produces an ack callback to emit with an event.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.ack = function(id) {
|
||
var self = this;
|
||
var sent = false;
|
||
return function() {
|
||
// prevent double callbacks
|
||
if (sent) return;
|
||
sent = true;
|
||
var args = toArray(arguments);
|
||
debug("sending ack %j", args);
|
||
self.packet({
|
||
type: hasBin(args) ? parser.BINARY_ACK : parser.ACK,
|
||
id: id,
|
||
data: args
|
||
});
|
||
};
|
||
};
|
||
/**
|
||
* Called upon a server acknowlegement.
|
||
*
|
||
* @param {Object} packet
|
||
* @api private
|
||
*/ Socket.prototype.onack = function(packet) {
|
||
var ack = this.acks[packet.id];
|
||
if ("function" === typeof ack) {
|
||
debug("calling ack %s with %j", packet.id, packet.data);
|
||
ack.apply(this, packet.data);
|
||
delete this.acks[packet.id];
|
||
} else debug("bad ack %s", packet.id);
|
||
};
|
||
/**
|
||
* Called upon server connect.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.onconnect = function() {
|
||
this.connected = true;
|
||
this.disconnected = false;
|
||
this.emit("connect");
|
||
this.emitBuffered();
|
||
};
|
||
/**
|
||
* Emit buffered events (received and emitted).
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.emitBuffered = function() {
|
||
var i;
|
||
for(i = 0; i < this.receiveBuffer.length; i++)emit.apply(this, this.receiveBuffer[i]);
|
||
this.receiveBuffer = [];
|
||
for(i = 0; i < this.sendBuffer.length; i++)this.packet(this.sendBuffer[i]);
|
||
this.sendBuffer = [];
|
||
};
|
||
/**
|
||
* Called upon server disconnect.
|
||
*
|
||
* @api private
|
||
*/ Socket.prototype.ondisconnect = function() {
|
||
debug("server disconnect (%s)", this.nsp);
|
||
this.destroy();
|
||
this.onclose("io server disconnect");
|
||
};
|
||
/**
|
||
* Called upon forced client/server side disconnections,
|
||
* this method ensures the manager stops tracking us and
|
||
* that reconnections don't get triggered for this.
|
||
*
|
||
* @api private.
|
||
*/ Socket.prototype.destroy = function() {
|
||
if (this.subs) {
|
||
// clean subscriptions to avoid reconnections
|
||
for(var i = 0; i < this.subs.length; i++)this.subs[i].destroy();
|
||
this.subs = null;
|
||
}
|
||
this.io.destroy(this);
|
||
};
|
||
/**
|
||
* Disconnects the socket manually.
|
||
*
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/ Socket.prototype.close = Socket.prototype.disconnect = function() {
|
||
if (this.connected) {
|
||
debug("performing disconnect (%s)", this.nsp);
|
||
this.packet({
|
||
type: parser.DISCONNECT
|
||
});
|
||
}
|
||
// remove socket from pool
|
||
this.destroy();
|
||
if (this.connected) // fire events
|
||
this.onclose("io client disconnect");
|
||
return this;
|
||
};
|
||
/**
|
||
* Sets the compress flag.
|
||
*
|
||
* @param {Boolean} if `true`, compresses the sending data
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/ Socket.prototype.compress = function(compress) {
|
||
this.flags.compress = compress;
|
||
return this;
|
||
};
|
||
/**
|
||
* Sets the binary flag
|
||
*
|
||
* @param {Boolean} whether the emitted data contains binary
|
||
* @return {Socket} self
|
||
* @api public
|
||
*/ Socket.prototype.binary = function(binary) {
|
||
this.flags.binary = binary;
|
||
return this;
|
||
};
|
||
|
||
},{"62860869af69302e":"iEP88","579d7d3b08eca257":"5nHrO","762f918a74841144":"aRpKP","5f486de4e6ba68c2":"fRNUp","56e2a0d74406281a":"lVL5b","7f4184a0e1d3cb3a":"l0oUb","64b9e3ffd2f3f1b5":"M504l","b0d3cdb32b3df3ae":"bvVNt"}],"aRpKP":[function(require,module,exports) {
|
||
module.exports = toArray;
|
||
function toArray(list, index) {
|
||
var array = [];
|
||
index = index || 0;
|
||
for(var i = index || 0; i < list.length; i++)array[i - index] = list[i];
|
||
return array;
|
||
}
|
||
|
||
},{}],"fRNUp":[function(require,module,exports) {
|
||
/**
|
||
* Module exports.
|
||
*/ module.exports = on;
|
||
/**
|
||
* Helper for subscriptions.
|
||
*
|
||
* @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`
|
||
* @param {String} event name
|
||
* @param {Function} callback
|
||
* @api public
|
||
*/ function on(obj, ev, fn) {
|
||
obj.on(ev, fn);
|
||
return {
|
||
destroy: function() {
|
||
obj.removeListener(ev, fn);
|
||
}
|
||
};
|
||
}
|
||
|
||
},{}],"lVL5b":[function(require,module,exports) {
|
||
/**
|
||
* Slice reference.
|
||
*/ var slice = [].slice;
|
||
/**
|
||
* Bind `obj` to `fn`.
|
||
*
|
||
* @param {Object} obj
|
||
* @param {Function|String} fn or string
|
||
* @return {Function}
|
||
* @api public
|
||
*/ module.exports = function(obj, fn) {
|
||
if ("string" == typeof fn) fn = obj[fn];
|
||
if ("function" != typeof fn) throw new Error("bind() requires a function");
|
||
var args = slice.call(arguments, 2);
|
||
return function() {
|
||
return fn.apply(obj, args.concat(slice.call(arguments)));
|
||
};
|
||
};
|
||
|
||
},{}],"kOkss":[function(require,module,exports) {
|
||
/**
|
||
* Expose `Backoff`.
|
||
*/ module.exports = Backoff;
|
||
/**
|
||
* Initialize backoff timer with `opts`.
|
||
*
|
||
* - `min` initial timeout in milliseconds [100]
|
||
* - `max` max timeout [10000]
|
||
* - `jitter` [0]
|
||
* - `factor` [2]
|
||
*
|
||
* @param {Object} opts
|
||
* @api public
|
||
*/ function Backoff(opts) {
|
||
opts = opts || {};
|
||
this.ms = opts.min || 100;
|
||
this.max = opts.max || 10000;
|
||
this.factor = opts.factor || 2;
|
||
this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
|
||
this.attempts = 0;
|
||
}
|
||
/**
|
||
* Return the backoff duration.
|
||
*
|
||
* @return {Number}
|
||
* @api public
|
||
*/ Backoff.prototype.duration = function() {
|
||
var ms = this.ms * Math.pow(this.factor, this.attempts++);
|
||
if (this.jitter) {
|
||
var rand = Math.random();
|
||
var deviation = Math.floor(rand * this.jitter * ms);
|
||
ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
|
||
}
|
||
return Math.min(ms, this.max) | 0;
|
||
};
|
||
/**
|
||
* Reset the number of attempts.
|
||
*
|
||
* @api public
|
||
*/ Backoff.prototype.reset = function() {
|
||
this.attempts = 0;
|
||
};
|
||
/**
|
||
* Set the minimum duration
|
||
*
|
||
* @api public
|
||
*/ Backoff.prototype.setMin = function(min) {
|
||
this.ms = min;
|
||
};
|
||
/**
|
||
* Set the maximum duration
|
||
*
|
||
* @api public
|
||
*/ Backoff.prototype.setMax = function(max) {
|
||
this.max = max;
|
||
};
|
||
/**
|
||
* Set the jitter
|
||
*
|
||
* @api public
|
||
*/ Backoff.prototype.setJitter = function(jitter) {
|
||
this.jitter = jitter;
|
||
};
|
||
|
||
},{}]},["gmPuC","h7u1C"], "h7u1C", "parcelRequire5324")
|
||
|
||
//# sourceMappingURL=index.b71e74eb.js.map
|