{"version":3,"sources":["webpack:////workdir/node_modules/socket.io-parser/dist/is-binary.js","webpack:////workdir/node_modules/socket.io-client/build/manager.js","webpack:////workdir/node_modules/uuid/v4.js","webpack:////workdir/node_modules/util-deprecate/browser.js","webpack:////workdir/node_modules/uuid/lib/bytesToUuid.js","webpack:////workdir/node_modules/uuid/v1.js","webpack:////workdir/node_modules/socket.io-client/build/url.js","webpack:////workdir/node_modules/socket.io-client/build/typed-events.js","webpack:////workdir/node_modules/socket.io-parser/dist/index.js","webpack:////workdir/node_modules/uuid/index.js","webpack:////workdir/node_modules/uuid/lib/rng-browser.js","webpack:////workdir/node_modules/socket.io-client/build/on.js","webpack:////workdir/node_modules/throttle-debounce/throttle.js","webpack:////workdir/node_modules/socket.io-parser/dist/binary.js","webpack:////workdir/node_modules/socket.io-client/build/index.js","webpack:////workdir/node_modules/socket.io-client/build/socket.js","webpack:////workdir/node_modules/throttle-debounce/debounce.js","webpack:////workdir/node_modules/string_decoder/lib/string_decoder.js","webpack:////workdir/node_modules/smoothscroll-polyfill/dist/smoothscroll.js","webpack:////workdir/node_modules/throttle-debounce/index.js","webpack:////workdir/node_modules/stream-browserify/index.js"],"names":["Object","defineProperty","exports","value","hasBinary","isBinary","withNativeArrayBuffer","ArrayBuffer","isView","obj","buffer","toString","prototype","withNativeBlob","Blob","call","withNativeFile","File","toJSON","Array","isArray","i","l","length","arguments","key","hasOwnProperty","Manager","eio","util_1","socket_1","parser","on_1","Backoff","typed_events_1","debug","StrictEventEmitter","uri","opts","_a","super","this","nsps","subs","undefined","path","installTimerFunctions","reconnection","reconnectionAttempts","Infinity","reconnectionDelay","reconnectionDelayMax","randomizationFactor","backoff","min","max","jitter","timeout","_readyState","_parser","encoder","Encoder","decoder","Decoder","_autoConnect","autoConnect","open","v","_reconnection","_reconnectionAttempts","_reconnectionDelay","setMin","_randomizationFactor","setJitter","_reconnectionDelayMax","setMax","_timeout","_reconnecting","attempts","reconnect","fn","indexOf","engine","socket","self","skipReconnect","openSubDestroy","on","onopen","errorSub","err","cleanup","emitReserved","maybeReconnectOnOpen","timer","setTimeoutFn","close","emit","Error","autoUnref","unref","push","clearTimeout","onping","bind","ondata","onerror","onclose","ondecoded","data","add","packet","nsp","Socket","keys","active","_close","encodedPackets","encode","write","options","forEach","subDestroy","destroy","reset","reason","delay","duration","onreconnect","attempt","rng","bytesToUuid","v4","buf","offset","rnds","random","ii","module","deprecate","msg","config","warned","deprecated","console","trace","warn","apply","name","global","localStorage","_","val","String","toLowerCase","byteToHex","substr","bth","join","_nodeId","_clockseq","_lastMSecs","_lastNSecs","v1","b","node","clockseq","seedBytes","msecs","Date","getTime","nsecs","dt","tl","tmh","n","url","parseuri","loc","location","protocol","host","charAt","test","port","ipv6","id","href","Emitter","ev","listener","once","args","event","listeners","PacketType","binary_1","is_binary_1","type","EVENT","ACK","encodeAsString","BINARY_EVENT","BINARY_ACK","encodeAsBinary","str","attachments","JSON","stringify","deconstruction","deconstructPacket","pack","buffers","unshift","reconstructor","decodeString","BinaryReconstructor","base64","takeBinaryData","p","Number","start","substring","c","next","payload","tryParse","isPayloadValid","CONNECT","DISCONNECT","CONNECT_ERROR","finishedReconstruction","parse","e","reconPack","binData","reconstructPacket","uuid","getRandomValues","crypto","window","msCrypto","rnds8","Uint8Array","r","Math","off","noTrailing","callback","debounceMode","timeoutID","lastExec","wrapper","elapsed","exec","clear","setTimeout","packetData","_deconstructPacket","placeholder","_placeholder","num","newData","_reconstructPacket","isIndexValid","io","url_1","manager_1","lookup","cache","managers","parsed","source","sameNamespace","newConnection","forceNew","multiplex","query","queryKey","socket_io_parser_1","enumerable","get","connect","manager_2","default","RESERVED_EVENTS","freeze","connect_error","disconnect","disconnecting","newListener","removeListener","connected","disconnected","receiveBuffer","sendBuffer","ids","acks","flags","auth","onpacket","subEvents","compress","pop","isTransportWritable","transport","writable","discardPacket","volatile","_packet","sid","onconnect","onevent","onack","ondisconnect","message","ack","emitEvent","_anyListeners","slice","sent","emitBuffered","splice","throttle","atBegin","Buffer","isEncoding","encoding","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","StringDecoder","nb","text","utf16Text","end","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","allocUnsafe","utf8CheckByte","byte","utf8CheckIncomplete","j","utf8CheckExtraBytes","copy","utf8Text","total","utf8End","charCodeAt","polyfill","w","d","document","documentElement","style","__forceSmoothScrollPolyfill__","Element","HTMLElement","SCROLL_TIME","original","scroll","scrollTo","scrollBy","elementScroll","scrollElement","scrollIntoView","now","performance","ROUNDING_TOLERANCE","isMicrosoftBrowser","navigator","userAgent","shouldBailOut","smoothScroll","body","left","scrollX","pageXOffset","top","scrollY","pageYOffset","scrollLeft","scrollTop","SyntaxError","behavior","scrollableParent","findScrollableParent","parentRects","getBoundingClientRect","clientRects","getComputedStyle","position","userAgentPatterns","RegExp","x","y","ease","k","cos","PI","firstArg","TypeError","hasScrollableSpace","el","axis","clientHeight","scrollHeight","clientWidth","scrollWidth","canOverflow","overflowValue","isScrollable","isScrollableY","isScrollableX","parentNode","step","context","currentX","currentY","time","startTime","startX","startY","method","scrollable","requestAnimationFrame","debounce","Stream","EE","EventEmitter","inherits","Readable","Writable","Duplex","Transform","PassThrough","pipe","dest","chunk","pause","ondrain","readable","resume","_isStdio","onend","didOnEnd","er","listenerCount"],"mappings":"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","file":"static/js/app-73424ab8.js","sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hasBinary = exports.isBinary = void 0;\nconst withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\nconst isView = (obj) => {\n    return typeof ArrayBuffer.isView === \"function\"\n        ? ArrayBuffer.isView(obj)\n        : obj.buffer instanceof ArrayBuffer;\n};\nconst toString = Object.prototype.toString;\nconst withNativeBlob = typeof Blob === \"function\" ||\n    (typeof Blob !== \"undefined\" &&\n        toString.call(Blob) === \"[object BlobConstructor]\");\nconst withNativeFile = typeof File === \"function\" ||\n    (typeof File !== \"undefined\" &&\n        toString.call(File) === \"[object FileConstructor]\");\n/**\n * Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.\n *\n * @private\n */\nfunction isBinary(obj) {\n    return ((withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj))) ||\n        (withNativeBlob && obj instanceof Blob) ||\n        (withNativeFile && obj instanceof File));\n}\nexports.isBinary = isBinary;\nfunction hasBinary(obj, toJSON) {\n    if (!obj || typeof obj !== \"object\") {\n        return false;\n    }\n    if (Array.isArray(obj)) {\n        for (let i = 0, l = obj.length; i < l; i++) {\n            if (hasBinary(obj[i])) {\n                return true;\n            }\n        }\n        return false;\n    }\n    if (isBinary(obj)) {\n        return true;\n    }\n    if (obj.toJSON &&\n        typeof obj.toJSON === \"function\" &&\n        arguments.length === 1) {\n        return hasBinary(obj.toJSON(), true);\n    }\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {\n            return true;\n        }\n    }\n    return false;\n}\nexports.hasBinary = hasBinary;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Manager = void 0;\nconst eio = require(\"engine.io-client\");\nconst util_1 = require(\"engine.io-client/lib/util\");\nconst socket_1 = require(\"./socket\");\nconst parser = require(\"socket.io-parser\");\nconst on_1 = require(\"./on\");\nconst Backoff = require(\"backo2\");\nconst typed_events_1 = require(\"./typed-events\");\nconst debug = require(\"debug\")(\"socket.io-client:manager\");\nclass Manager extends typed_events_1.StrictEventEmitter {\n    constructor(uri, opts) {\n        var _a;\n        super();\n        this.nsps = {};\n        this.subs = [];\n        if (uri && \"object\" === typeof uri) {\n            opts = uri;\n            uri = undefined;\n        }\n        opts = opts || {};\n        opts.path = opts.path || \"/socket.io\";\n        this.opts = opts;\n        (0, util_1.installTimerFunctions)(this, opts);\n        this.reconnection(opts.reconnection !== false);\n        this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n        this.reconnectionDelay(opts.reconnectionDelay || 1000);\n        this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n        this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5);\n        this.backoff = new Backoff({\n            min: this.reconnectionDelay(),\n            max: this.reconnectionDelayMax(),\n            jitter: this.randomizationFactor(),\n        });\n        this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n        this._readyState = \"closed\";\n        this.uri = uri;\n        const _parser = opts.parser || parser;\n        this.encoder = new _parser.Encoder();\n        this.decoder = new _parser.Decoder();\n        this._autoConnect = opts.autoConnect !== false;\n        if (this._autoConnect)\n            this.open();\n    }\n    reconnection(v) {\n        if (!arguments.length)\n            return this._reconnection;\n        this._reconnection = !!v;\n        return this;\n    }\n    reconnectionAttempts(v) {\n        if (v === undefined)\n            return this._reconnectionAttempts;\n        this._reconnectionAttempts = v;\n        return this;\n    }\n    reconnectionDelay(v) {\n        var _a;\n        if (v === undefined)\n            return this._reconnectionDelay;\n        this._reconnectionDelay = v;\n        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v);\n        return this;\n    }\n    randomizationFactor(v) {\n        var _a;\n        if (v === undefined)\n            return this._randomizationFactor;\n        this._randomizationFactor = v;\n        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v);\n        return this;\n    }\n    reconnectionDelayMax(v) {\n        var _a;\n        if (v === undefined)\n            return this._reconnectionDelayMax;\n        this._reconnectionDelayMax = v;\n        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v);\n        return this;\n    }\n    timeout(v) {\n        if (!arguments.length)\n            return this._timeout;\n        this._timeout = v;\n        return this;\n    }\n    /**\n     * Starts trying to reconnect if reconnection is enabled and we have not\n     * started reconnecting yet\n     *\n     * @private\n     */\n    maybeReconnectOnOpen() {\n        // Only try to reconnect if it's the first time we're connecting\n        if (!this._reconnecting &&\n            this._reconnection &&\n            this.backoff.attempts === 0) {\n            // keeps reconnection from firing twice for the same reconnection loop\n            this.reconnect();\n        }\n    }\n    /**\n     * Sets the current transport `socket`.\n     *\n     * @param {Function} fn - optional, callback\n     * @return self\n     * @public\n     */\n    open(fn) {\n        debug(\"readyState %s\", this._readyState);\n        if (~this._readyState.indexOf(\"open\"))\n            return this;\n        debug(\"opening %s\", this.uri);\n        this.engine = eio(this.uri, this.opts);\n        const socket = this.engine;\n        const self = this;\n        this._readyState = \"opening\";\n        this.skipReconnect = false;\n        // emit `open`\n        const openSubDestroy = (0, on_1.on)(socket, \"open\", function () {\n            self.onopen();\n            fn && fn();\n        });\n        // emit `error`\n        const errorSub = (0, on_1.on)(socket, \"error\", (err) => {\n            debug(\"error\");\n            self.cleanup();\n            self._readyState = \"closed\";\n            this.emitReserved(\"error\", err);\n            if (fn) {\n                fn(err);\n            }\n            else {\n                // Only do this if there is no fn to handle the error\n                self.maybeReconnectOnOpen();\n            }\n        });\n        if (false !== this._timeout) {\n            const timeout = this._timeout;\n            debug(\"connect attempt will timeout after %d\", timeout);\n            if (timeout === 0) {\n                openSubDestroy(); // prevents a race condition with the 'open' event\n            }\n            // set timer\n            const timer = this.setTimeoutFn(() => {\n                debug(\"connect attempt timed out after %d\", timeout);\n                openSubDestroy();\n                socket.close();\n                socket.emit(\"error\", new Error(\"timeout\"));\n            }, timeout);\n            if (this.opts.autoUnref) {\n                timer.unref();\n            }\n            this.subs.push(function subDestroy() {\n                clearTimeout(timer);\n            });\n        }\n        this.subs.push(openSubDestroy);\n        this.subs.push(errorSub);\n        return this;\n    }\n    /**\n     * Alias for open()\n     *\n     * @return self\n     * @public\n     */\n    connect(fn) {\n        return this.open(fn);\n    }\n    /**\n     * Called upon transport open.\n     *\n     * @private\n     */\n    onopen() {\n        debug(\"open\");\n        // clear old subs\n        this.cleanup();\n        // mark as open\n        this._readyState = \"open\";\n        this.emitReserved(\"open\");\n        // add new subs\n        const socket = this.engine;\n        this.subs.push((0, on_1.on)(socket, \"ping\", this.onping.bind(this)), (0, on_1.on)(socket, \"data\", this.ondata.bind(this)), (0, on_1.on)(socket, \"error\", this.onerror.bind(this)), (0, on_1.on)(socket, \"close\", this.onclose.bind(this)), (0, on_1.on)(this.decoder, \"decoded\", this.ondecoded.bind(this)));\n    }\n    /**\n     * Called upon a ping.\n     *\n     * @private\n     */\n    onping() {\n        this.emitReserved(\"ping\");\n    }\n    /**\n     * Called with data.\n     *\n     * @private\n     */\n    ondata(data) {\n        this.decoder.add(data);\n    }\n    /**\n     * Called when parser fully decodes a packet.\n     *\n     * @private\n     */\n    ondecoded(packet) {\n        this.emitReserved(\"packet\", packet);\n    }\n    /**\n     * Called upon socket error.\n     *\n     * @private\n     */\n    onerror(err) {\n        debug(\"error\", err);\n        this.emitReserved(\"error\", err);\n    }\n    /**\n     * Creates a new socket for the given `nsp`.\n     *\n     * @return {Socket}\n     * @public\n     */\n    socket(nsp, opts) {\n        let socket = this.nsps[nsp];\n        if (!socket) {\n            socket = new socket_1.Socket(this, nsp, opts);\n            this.nsps[nsp] = socket;\n        }\n        return socket;\n    }\n    /**\n     * Called upon a socket close.\n     *\n     * @param socket\n     * @private\n     */\n    _destroy(socket) {\n        const nsps = Object.keys(this.nsps);\n        for (const nsp of nsps) {\n            const socket = this.nsps[nsp];\n            if (socket.active) {\n                debug(\"socket %s is still active, skipping close\", nsp);\n                return;\n            }\n        }\n        this._close();\n    }\n    /**\n     * Writes a packet.\n     *\n     * @param packet\n     * @private\n     */\n    _packet(packet) {\n        debug(\"writing packet %j\", packet);\n        const encodedPackets = this.encoder.encode(packet);\n        for (let i = 0; i < encodedPackets.length; i++) {\n            this.engine.write(encodedPackets[i], packet.options);\n        }\n    }\n    /**\n     * Clean up transport subscriptions and packet buffer.\n     *\n     * @private\n     */\n    cleanup() {\n        debug(\"cleanup\");\n        this.subs.forEach((subDestroy) => subDestroy());\n        this.subs.length = 0;\n        this.decoder.destroy();\n    }\n    /**\n     * Close the current socket.\n     *\n     * @private\n     */\n    _close() {\n        debug(\"disconnect\");\n        this.skipReconnect = true;\n        this._reconnecting = false;\n        if (\"opening\" === this._readyState) {\n            // `onclose` will not fire because\n            // an open event never happened\n            this.cleanup();\n        }\n        this.backoff.reset();\n        this._readyState = \"closed\";\n        if (this.engine)\n            this.engine.close();\n    }\n    /**\n     * Alias for close()\n     *\n     * @private\n     */\n    disconnect() {\n        return this._close();\n    }\n    /**\n     * Called upon engine close.\n     *\n     * @private\n     */\n    onclose(reason) {\n        debug(\"onclose\");\n        this.cleanup();\n        this.backoff.reset();\n        this._readyState = \"closed\";\n        this.emitReserved(\"close\", reason);\n        if (this._reconnection && !this.skipReconnect) {\n            this.reconnect();\n        }\n    }\n    /**\n     * Attempt a reconnection.\n     *\n     * @private\n     */\n    reconnect() {\n        if (this._reconnecting || this.skipReconnect)\n            return this;\n        const self = this;\n        if (this.backoff.attempts >= this._reconnectionAttempts) {\n            debug(\"reconnect failed\");\n            this.backoff.reset();\n            this.emitReserved(\"reconnect_failed\");\n            this._reconnecting = false;\n        }\n        else {\n            const delay = this.backoff.duration();\n            debug(\"will wait %dms before reconnect attempt\", delay);\n            this._reconnecting = true;\n            const timer = this.setTimeoutFn(() => {\n                if (self.skipReconnect)\n                    return;\n                debug(\"attempting reconnect\");\n                this.emitReserved(\"reconnect_attempt\", self.backoff.attempts);\n                // check again for the case socket closed in above events\n                if (self.skipReconnect)\n                    return;\n                self.open((err) => {\n                    if (err) {\n                        debug(\"reconnect attempt error\");\n                        self._reconnecting = false;\n                        self.reconnect();\n                        this.emitReserved(\"reconnect_error\", err);\n                    }\n                    else {\n                        debug(\"reconnect success\");\n                        self.onreconnect();\n                    }\n                });\n            }, delay);\n            if (this.opts.autoUnref) {\n                timer.unref();\n            }\n            this.subs.push(function subDestroy() {\n                clearTimeout(timer);\n            });\n        }\n    }\n    /**\n     * Called upon successful reconnect.\n     *\n     * @private\n     */\n    onreconnect() {\n        const attempt = this.backoff.attempts;\n        this._reconnecting = false;\n        this.backoff.reset();\n        this.emitReserved(\"reconnect\", attempt);\n    }\n}\nexports.Manager = Manager;\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\nfunction v4(options, buf, offset) {\n  var i = buf && offset || 0;\n\n  if (typeof(options) == 'string') {\n    buf = options === 'binary' ? new Array(16) : null;\n    options = null;\n  }\n  options = options || {};\n\n  var rnds = options.random || (options.rng || rng)();\n\n  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n  rnds[6] = (rnds[6] & 0x0f) | 0x40;\n  rnds[8] = (rnds[8] & 0x3f) | 0x80;\n\n  // Copy bytes to buffer, if provided\n  if (buf) {\n    for (var ii = 0; ii < 16; ++ii) {\n      buf[i + ii] = rnds[ii];\n    }\n  }\n\n  return buf || bytesToUuid(rnds);\n}\n\nmodule.exports = v4;\n","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\nvar byteToHex = [];\nfor (var i = 0; i < 256; ++i) {\n  byteToHex[i] = (i + 0x100).toString(16).substr(1);\n}\n\nfunction bytesToUuid(buf, offset) {\n  var i = offset || 0;\n  var bth = byteToHex;\n  // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n  return ([\n    bth[buf[i++]], bth[buf[i++]],\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]], '-',\n    bth[buf[i++]], bth[buf[i++]],\n    bth[buf[i++]], bth[buf[i++]],\n    bth[buf[i++]], bth[buf[i++]]\n  ]).join('');\n}\n\nmodule.exports = bytesToUuid;\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\n// **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\nvar _nodeId;\nvar _clockseq;\n\n// Previous uuid creation time\nvar _lastMSecs = 0;\nvar _lastNSecs = 0;\n\n// See https://github.com/uuidjs/uuid for API details\nfunction v1(options, buf, offset) {\n  var i = buf && offset || 0;\n  var b = buf || [];\n\n  options = options || {};\n  var node = options.node || _nodeId;\n  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;\n\n  // node and clockseq need to be initialized to random values if they're not\n  // specified.  We do this lazily to minimize issues related to insufficient\n  // system entropy.  See #189\n  if (node == null || clockseq == null) {\n    var seedBytes = rng();\n    if (node == null) {\n      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\n      node = _nodeId = [\n        seedBytes[0] | 0x01,\n        seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]\n      ];\n    }\n    if (clockseq == null) {\n      // Per 4.2.2, randomize (14 bit) clockseq\n      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\n    }\n  }\n\n  // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so\n  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n  var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();\n\n  // Per 4.2.1.2, use count of uuid's generated during the current clock\n  // cycle to simulate higher resolution clock\n  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;\n\n  // Time since last uuid creation (in msecs)\n  var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;\n\n  // Per 4.2.1.2, Bump clockseq on clock regression\n  if (dt < 0 && options.clockseq === undefined) {\n    clockseq = clockseq + 1 & 0x3fff;\n  }\n\n  // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n  // time interval\n  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n    nsecs = 0;\n  }\n\n  // Per 4.2.1.2 Throw error if too many uuids are requested\n  if (nsecs >= 10000) {\n    throw new Error('uuid.v1(): Can\\'t create more than 10M uuids/sec');\n  }\n\n  _lastMSecs = msecs;\n  _lastNSecs = nsecs;\n  _clockseq = clockseq;\n\n  // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n  msecs += 12219292800000;\n\n  // `time_low`\n  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n  b[i++] = tl >>> 24 & 0xff;\n  b[i++] = tl >>> 16 & 0xff;\n  b[i++] = tl >>> 8 & 0xff;\n  b[i++] = tl & 0xff;\n\n  // `time_mid`\n  var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;\n  b[i++] = tmh >>> 8 & 0xff;\n  b[i++] = tmh & 0xff;\n\n  // `time_high_and_version`\n  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n  b[i++] = tmh >>> 16 & 0xff;\n\n  // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n  b[i++] = clockseq >>> 8 | 0x80;\n\n  // `clock_seq_low`\n  b[i++] = clockseq & 0xff;\n\n  // `node`\n  for (var n = 0; n < 6; ++n) {\n    b[i + n] = node[n];\n  }\n\n  return buf ? buf : bytesToUuid(b);\n}\n\nmodule.exports = v1;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.url = void 0;\nconst parseuri = require(\"parseuri\");\nconst debug = require(\"debug\")(\"socket.io-client:url\");\n/**\n * URL parser.\n *\n * @param uri - url\n * @param path - the request path of the connection\n * @param loc - An object meant to mimic window.location.\n *        Defaults to window.location.\n * @public\n */\nfunction url(uri, path = \"\", loc) {\n    let obj = uri;\n    // default to window.location\n    loc = loc || (typeof location !== \"undefined\" && location);\n    if (null == uri)\n        uri = loc.protocol + \"//\" + loc.host;\n    // relative path support\n    if (typeof uri === \"string\") {\n        if (\"/\" === uri.charAt(0)) {\n            if (\"/\" === uri.charAt(1)) {\n                uri = loc.protocol + uri;\n            }\n            else {\n                uri = loc.host + uri;\n            }\n        }\n        if (!/^(https?|wss?):\\/\\//.test(uri)) {\n            debug(\"protocol-less url %s\", uri);\n            if (\"undefined\" !== typeof loc) {\n                uri = loc.protocol + \"//\" + uri;\n            }\n            else {\n                uri = \"https://\" + uri;\n            }\n        }\n        // parse\n        debug(\"parse %s\", uri);\n        obj = parseuri(uri);\n    }\n    // make sure we treat `localhost:80` and `localhost` equally\n    if (!obj.port) {\n        if (/^(http|ws)$/.test(obj.protocol)) {\n            obj.port = \"80\";\n        }\n        else if (/^(http|ws)s$/.test(obj.protocol)) {\n            obj.port = \"443\";\n        }\n    }\n    obj.path = obj.path || \"/\";\n    const ipv6 = obj.host.indexOf(\":\") !== -1;\n    const host = ipv6 ? \"[\" + obj.host + \"]\" : obj.host;\n    // define unique id\n    obj.id = obj.protocol + \"://\" + host + \":\" + obj.port + path;\n    // define href\n    obj.href =\n        obj.protocol +\n            \"://\" +\n            host +\n            (loc && loc.port === obj.port ? \"\" : \":\" + obj.port);\n    return obj;\n}\nexports.url = url;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.StrictEventEmitter = void 0;\nconst Emitter = require(\"component-emitter\");\n/**\n * Strictly typed version of an `EventEmitter`. A `TypedEventEmitter` takes type\n * parameters for mappings of event names to event data types, and strictly\n * types method calls to the `EventEmitter` according to these event maps.\n *\n * @typeParam ListenEvents - `EventsMap` of user-defined events that can be\n * listened to with `on` or `once`\n * @typeParam EmitEvents - `EventsMap` of user-defined events that can be\n * emitted with `emit`\n * @typeParam ReservedEvents - `EventsMap` of reserved events, that can be\n * emitted by socket.io with `emitReserved`, and can be listened to with\n * `listen`.\n */\nclass StrictEventEmitter extends Emitter {\n    /**\n     * Adds the `listener` function as an event listener for `ev`.\n     *\n     * @param ev Name of the event\n     * @param listener Callback function\n     */\n    on(ev, listener) {\n        super.on(ev, listener);\n        return this;\n    }\n    /**\n     * Adds a one-time `listener` function as an event listener for `ev`.\n     *\n     * @param ev Name of the event\n     * @param listener Callback function\n     */\n    once(ev, listener) {\n        super.once(ev, listener);\n        return this;\n    }\n    /**\n     * Emits an event.\n     *\n     * @param ev Name of the event\n     * @param args Values to send to listeners of this event\n     */\n    emit(ev, ...args) {\n        super.emit(ev, ...args);\n        return this;\n    }\n    /**\n     * Emits a reserved event.\n     *\n     * This method is `protected`, so that only a class extending\n     * `StrictEventEmitter` can emit its own reserved events.\n     *\n     * @param ev Reserved event name\n     * @param args Arguments to emit along with the event\n     */\n    emitReserved(ev, ...args) {\n        super.emit(ev, ...args);\n        return this;\n    }\n    /**\n     * Returns the listeners listening to an event.\n     *\n     * @param event Event name\n     * @returns Array of listeners subscribed to `event`\n     */\n    listeners(event) {\n        return super.listeners(event);\n    }\n}\nexports.StrictEventEmitter = StrictEventEmitter;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Decoder = exports.Encoder = exports.PacketType = exports.protocol = void 0;\nconst Emitter = require(\"component-emitter\");\nconst binary_1 = require(\"./binary\");\nconst is_binary_1 = require(\"./is-binary\");\nconst debug = require(\"debug\")(\"socket.io-parser\");\n/**\n * Protocol version.\n *\n * @public\n */\nexports.protocol = 5;\nvar PacketType;\n(function (PacketType) {\n    PacketType[PacketType[\"CONNECT\"] = 0] = \"CONNECT\";\n    PacketType[PacketType[\"DISCONNECT\"] = 1] = \"DISCONNECT\";\n    PacketType[PacketType[\"EVENT\"] = 2] = \"EVENT\";\n    PacketType[PacketType[\"ACK\"] = 3] = \"ACK\";\n    PacketType[PacketType[\"CONNECT_ERROR\"] = 4] = \"CONNECT_ERROR\";\n    PacketType[PacketType[\"BINARY_EVENT\"] = 5] = \"BINARY_EVENT\";\n    PacketType[PacketType[\"BINARY_ACK\"] = 6] = \"BINARY_ACK\";\n})(PacketType = exports.PacketType || (exports.PacketType = {}));\n/**\n * A socket.io Encoder instance\n */\nclass Encoder {\n    /**\n     * Encode a packet as a single string if non-binary, or as a\n     * buffer sequence, depending on packet type.\n     *\n     * @param {Object} obj - packet object\n     */\n    encode(obj) {\n        debug(\"encoding packet %j\", obj);\n        if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {\n            if (is_binary_1.hasBinary(obj)) {\n                obj.type =\n                    obj.type === PacketType.EVENT\n                        ? PacketType.BINARY_EVENT\n                        : PacketType.BINARY_ACK;\n                return this.encodeAsBinary(obj);\n            }\n        }\n        return [this.encodeAsString(obj)];\n    }\n    /**\n     * Encode packet as string.\n     */\n    encodeAsString(obj) {\n        // first is type\n        let str = \"\" + obj.type;\n        // attachments if we have them\n        if (obj.type === PacketType.BINARY_EVENT ||\n            obj.type === PacketType.BINARY_ACK) {\n            str += obj.attachments + \"-\";\n        }\n        // if we have a namespace other than `/`\n        // we append it followed by a comma `,`\n        if (obj.nsp && \"/\" !== obj.nsp) {\n            str += obj.nsp + \",\";\n        }\n        // immediately followed by the id\n        if (null != obj.id) {\n            str += obj.id;\n        }\n        // json data\n        if (null != obj.data) {\n            str += JSON.stringify(obj.data);\n        }\n        debug(\"encoded %j as %s\", obj, str);\n        return str;\n    }\n    /**\n     * Encode packet as 'buffer sequence' by removing blobs, and\n     * deconstructing packet into object with placeholders and\n     * a list of buffers.\n     */\n    encodeAsBinary(obj) {\n        const deconstruction = binary_1.deconstructPacket(obj);\n        const pack = this.encodeAsString(deconstruction.packet);\n        const buffers = deconstruction.buffers;\n        buffers.unshift(pack); // add packet info to beginning of data list\n        return buffers; // write all the buffers\n    }\n}\nexports.Encoder = Encoder;\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n */\nclass Decoder extends Emitter {\n    constructor() {\n        super();\n    }\n    /**\n     * Decodes an encoded packet string into packet JSON.\n     *\n     * @param {String} obj - encoded packet\n     */\n    add(obj) {\n        let packet;\n        if (typeof obj === \"string\") {\n            if (this.reconstructor) {\n                throw new Error(\"got plaintext data when reconstructing a packet\");\n            }\n            packet = this.decodeString(obj);\n            if (packet.type === PacketType.BINARY_EVENT ||\n                packet.type === PacketType.BINARY_ACK) {\n                // binary packet's json\n                this.reconstructor = new BinaryReconstructor(packet);\n                // no attachments, labeled binary but no binary data to follow\n                if (packet.attachments === 0) {\n                    super.emit(\"decoded\", packet);\n                }\n            }\n            else {\n                // non-binary full packet\n                super.emit(\"decoded\", packet);\n            }\n        }\n        else if (is_binary_1.isBinary(obj) || obj.base64) {\n            // raw binary data\n            if (!this.reconstructor) {\n                throw new Error(\"got binary data when not reconstructing a packet\");\n            }\n            else {\n                packet = this.reconstructor.takeBinaryData(obj);\n                if (packet) {\n                    // received final buffer\n                    this.reconstructor = null;\n                    super.emit(\"decoded\", packet);\n                }\n            }\n        }\n        else {\n            throw new Error(\"Unknown type: \" + obj);\n        }\n    }\n    /**\n     * Decode a packet String (JSON data)\n     *\n     * @param {String} str\n     * @return {Object} packet\n     */\n    decodeString(str) {\n        let i = 0;\n        // look up type\n        const p = {\n            type: Number(str.charAt(0)),\n        };\n        if (PacketType[p.type] === undefined) {\n            throw new Error(\"unknown packet type \" + p.type);\n        }\n        // look up attachments if type binary\n        if (p.type === PacketType.BINARY_EVENT ||\n            p.type === PacketType.BINARY_ACK) {\n            const start = i + 1;\n            while (str.charAt(++i) !== \"-\" && i != str.length) { }\n            const buf = str.substring(start, i);\n            if (buf != Number(buf) || str.charAt(i) !== \"-\") {\n                throw new Error(\"Illegal attachments\");\n            }\n            p.attachments = Number(buf);\n        }\n        // look up namespace (if any)\n        if (\"/\" === str.charAt(i + 1)) {\n            const start = i + 1;\n            while (++i) {\n                const c = str.charAt(i);\n                if (\",\" === c)\n                    break;\n                if (i === str.length)\n                    break;\n            }\n            p.nsp = str.substring(start, i);\n        }\n        else {\n            p.nsp = \"/\";\n        }\n        // look up id\n        const next = str.charAt(i + 1);\n        if (\"\" !== next && Number(next) == next) {\n            const start = i + 1;\n            while (++i) {\n                const c = str.charAt(i);\n                if (null == c || Number(c) != c) {\n                    --i;\n                    break;\n                }\n                if (i === str.length)\n                    break;\n            }\n            p.id = Number(str.substring(start, i + 1));\n        }\n        // look up json data\n        if (str.charAt(++i)) {\n            const payload = tryParse(str.substr(i));\n            if (Decoder.isPayloadValid(p.type, payload)) {\n                p.data = payload;\n            }\n            else {\n                throw new Error(\"invalid payload\");\n            }\n        }\n        debug(\"decoded %s as %j\", str, p);\n        return p;\n    }\n    static isPayloadValid(type, payload) {\n        switch (type) {\n            case PacketType.CONNECT:\n                return typeof payload === \"object\";\n            case PacketType.DISCONNECT:\n                return payload === undefined;\n            case PacketType.CONNECT_ERROR:\n                return typeof payload === \"string\" || typeof payload === \"object\";\n            case PacketType.EVENT:\n            case PacketType.BINARY_EVENT:\n                return Array.isArray(payload) && payload.length > 0;\n            case PacketType.ACK:\n            case PacketType.BINARY_ACK:\n                return Array.isArray(payload);\n        }\n    }\n    /**\n     * Deallocates a parser's resources\n     */\n    destroy() {\n        if (this.reconstructor) {\n            this.reconstructor.finishedReconstruction();\n        }\n    }\n}\nexports.Decoder = Decoder;\nfunction tryParse(str) {\n    try {\n        return JSON.parse(str);\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n */\nclass BinaryReconstructor {\n    constructor(packet) {\n        this.packet = packet;\n        this.buffers = [];\n        this.reconPack = packet;\n    }\n    /**\n     * Method to be called when binary data received from connection\n     * after a BINARY_EVENT packet.\n     *\n     * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n     * @return {null | Object} returns null if more binary data is expected or\n     *   a reconstructed packet object if all buffers have been received.\n     */\n    takeBinaryData(binData) {\n        this.buffers.push(binData);\n        if (this.buffers.length === this.reconPack.attachments) {\n            // done with buffer list\n            const packet = binary_1.reconstructPacket(this.reconPack, this.buffers);\n            this.finishedReconstruction();\n            return packet;\n        }\n        return null;\n    }\n    /**\n     * Cleans up binary packet reconstruction variables.\n     */\n    finishedReconstruction() {\n        this.reconPack = null;\n        this.buffers = [];\n    }\n}\n","var v1 = require('./v1');\nvar v4 = require('./v4');\n\nvar uuid = v4;\nuuid.v1 = v1;\nuuid.v4 = v4;\n\nmodule.exports = uuid;\n","// Unique ID creation requires a high quality random # generator.  In the\n// browser this is a little complicated due to unknown quality of Math.random()\n// and inconsistent support for the `crypto` API.  We do the best we can via\n// feature-detection\n\n// getRandomValues needs to be invoked in a context where \"this\" is a Crypto\n// implementation. Also, find the complete implementation of crypto on IE11.\nvar getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||\n                      (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));\n\nif (getRandomValues) {\n  // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto\n  var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef\n\n  module.exports = function whatwgRNG() {\n    getRandomValues(rnds8);\n    return rnds8;\n  };\n} else {\n  // Math.random()-based (RNG)\n  //\n  // If all else fails, use Math.random().  It's fast, but is of unspecified\n  // quality.\n  var rnds = new Array(16);\n\n  module.exports = function mathRNG() {\n    for (var i = 0, r; i < 16; i++) {\n      if ((i & 0x03) === 0) r = Math.random() * 0x100000000;\n      rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;\n    }\n\n    return rnds;\n  };\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.on = void 0;\nfunction on(obj, ev, fn) {\n    obj.on(ev, fn);\n    return function subDestroy() {\n        obj.off(ev, fn);\n    };\n}\nexports.on = on;\n","/* eslint-disable no-undefined,no-param-reassign,no-shadow */\n\n/**\n * Throttle execution of a function. Especially useful for rate limiting\n * execution of handlers on events like resize and scroll.\n *\n * @param  {Number}    delay          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.\n * @param  {Boolean}   [noTrailing]   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds while the\n *                                    throttled-function is being called. If noTrailing is false or unspecified, callback will be executed one final time\n *                                    after the last throttled-function call. (After the throttled-function has not been called for `delay` milliseconds,\n *                                    the internal counter is reset)\n * @param  {Function}  callback       A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,\n *                                    to `callback` when the throttled-function is executed.\n * @param  {Boolean}   [debounceMode] If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is false (at end),\n *                                    schedule `callback` to execute after `delay` ms.\n *\n * @return {Function}  A new, throttled, function.\n */\nmodule.exports = function ( delay, noTrailing, callback, debounceMode ) {\n\n\t// After wrapper has stopped being called, this timeout ensures that\n\t// `callback` is executed at the proper times in `throttle` and `end`\n\t// debounce modes.\n\tvar timeoutID;\n\n\t// Keep track of the last time `callback` was executed.\n\tvar lastExec = 0;\n\n\t// `noTrailing` defaults to falsy.\n\tif ( typeof noTrailing !== 'boolean' ) {\n\t\tdebounceMode = callback;\n\t\tcallback = noTrailing;\n\t\tnoTrailing = undefined;\n\t}\n\n\t// The `wrapper` function encapsulates all of the throttling / debouncing\n\t// functionality and when executed will limit the rate at which `callback`\n\t// is executed.\n\tfunction wrapper () {\n\n\t\tvar self = this;\n\t\tvar elapsed = Number(new Date()) - lastExec;\n\t\tvar args = arguments;\n\n\t\t// Execute `callback` and update the `lastExec` timestamp.\n\t\tfunction exec () {\n\t\t\tlastExec = Number(new Date());\n\t\t\tcallback.apply(self, args);\n\t\t}\n\n\t\t// If `debounceMode` is true (at begin) this is used to clear the flag\n\t\t// to allow future `callback` executions.\n\t\tfunction clear () {\n\t\t\ttimeoutID = undefined;\n\t\t}\n\n\t\tif ( debounceMode && !timeoutID ) {\n\t\t\t// Since `wrapper` is being called for the first time and\n\t\t\t// `debounceMode` is true (at begin), execute `callback`.\n\t\t\texec();\n\t\t}\n\n\t\t// Clear any existing timeout.\n\t\tif ( timeoutID ) {\n\t\t\tclearTimeout(timeoutID);\n\t\t}\n\n\t\tif ( debounceMode === undefined && elapsed > delay ) {\n\t\t\t// In throttle mode, if `delay` time has been exceeded, execute\n\t\t\t// `callback`.\n\t\t\texec();\n\n\t\t} else if ( noTrailing !== true ) {\n\t\t\t// In trailing throttle mode, since `delay` time has not been\n\t\t\t// exceeded, schedule `callback` to execute `delay` ms after most\n\t\t\t// recent execution.\n\t\t\t//\n\t\t\t// If `debounceMode` is true (at begin), schedule `clear` to execute\n\t\t\t// after `delay` ms.\n\t\t\t//\n\t\t\t// If `debounceMode` is false (at end), schedule `callback` to\n\t\t\t// execute after `delay` ms.\n\t\t\ttimeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);\n\t\t}\n\n\t}\n\n\t// Return the wrapper function.\n\treturn wrapper;\n\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.reconstructPacket = exports.deconstructPacket = void 0;\nconst is_binary_1 = require(\"./is-binary\");\n/**\n * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @public\n */\nfunction deconstructPacket(packet) {\n    const buffers = [];\n    const packetData = packet.data;\n    const pack = packet;\n    pack.data = _deconstructPacket(packetData, buffers);\n    pack.attachments = buffers.length; // number of binary 'attachments'\n    return { packet: pack, buffers: buffers };\n}\nexports.deconstructPacket = deconstructPacket;\nfunction _deconstructPacket(data, buffers) {\n    if (!data)\n        return data;\n    if (is_binary_1.isBinary(data)) {\n        const placeholder = { _placeholder: true, num: buffers.length };\n        buffers.push(data);\n        return placeholder;\n    }\n    else if (Array.isArray(data)) {\n        const newData = new Array(data.length);\n        for (let i = 0; i < data.length; i++) {\n            newData[i] = _deconstructPacket(data[i], buffers);\n        }\n        return newData;\n    }\n    else if (typeof data === \"object\" && !(data instanceof Date)) {\n        const newData = {};\n        for (const key in data) {\n            if (data.hasOwnProperty(key)) {\n                newData[key] = _deconstructPacket(data[key], buffers);\n            }\n        }\n        return newData;\n    }\n    return data;\n}\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @public\n */\nfunction reconstructPacket(packet, buffers) {\n    packet.data = _reconstructPacket(packet.data, buffers);\n    packet.attachments = undefined; // no longer useful\n    return packet;\n}\nexports.reconstructPacket = reconstructPacket;\nfunction _reconstructPacket(data, buffers) {\n    if (!data)\n        return data;\n    if (data && data._placeholder === true) {\n        const isIndexValid = typeof data.num === \"number\" &&\n            data.num >= 0 &&\n            data.num < buffers.length;\n        if (isIndexValid) {\n            return buffers[data.num]; // appropriate buffer (should be natural order anyway)\n        }\n        else {\n            throw new Error(\"illegal attachments\");\n        }\n    }\n    else if (Array.isArray(data)) {\n        for (let i = 0; i < data.length; i++) {\n            data[i] = _reconstructPacket(data[i], buffers);\n        }\n    }\n    else if (typeof data === \"object\") {\n        for (const key in data) {\n            if (data.hasOwnProperty(key)) {\n                data[key] = _reconstructPacket(data[key], buffers);\n            }\n        }\n    }\n    return data;\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.io = exports.Socket = exports.Manager = exports.protocol = void 0;\nconst url_1 = require(\"./url\");\nconst manager_1 = require(\"./manager\");\nconst debug = require(\"debug\")(\"socket.io-client\");\n/**\n * Module exports.\n */\nmodule.exports = exports = lookup;\n/**\n * Managers cache.\n */\nconst cache = (exports.managers = {});\nfunction lookup(uri, opts) {\n    if (typeof uri === \"object\") {\n        opts = uri;\n        uri = undefined;\n    }\n    opts = opts || {};\n    const parsed = (0, url_1.url)(uri, opts.path || \"/socket.io\");\n    const source = parsed.source;\n    const id = parsed.id;\n    const path = parsed.path;\n    const sameNamespace = cache[id] && path in cache[id][\"nsps\"];\n    const newConnection = opts.forceNew ||\n        opts[\"force new connection\"] ||\n        false === opts.multiplex ||\n        sameNamespace;\n    let io;\n    if (newConnection) {\n        debug(\"ignoring socket cache for %s\", source);\n        io = new manager_1.Manager(source, opts);\n    }\n    else {\n        if (!cache[id]) {\n            debug(\"new io instance for %s\", source);\n            cache[id] = new manager_1.Manager(source, opts);\n        }\n        io = cache[id];\n    }\n    if (parsed.query && !opts.query) {\n        opts.query = parsed.queryKey;\n    }\n    return io.socket(parsed.path, opts);\n}\nexports.io = lookup;\n/**\n * Protocol version.\n *\n * @public\n */\nvar socket_io_parser_1 = require(\"socket.io-parser\");\nObject.defineProperty(exports, \"protocol\", { enumerable: true, get: function () { return socket_io_parser_1.protocol; } });\n/**\n * `connect`.\n *\n * @param {String} uri\n * @public\n */\nexports.connect = lookup;\n/**\n * Expose constructors for standalone build.\n *\n * @public\n */\nvar manager_2 = require(\"./manager\");\nObject.defineProperty(exports, \"Manager\", { enumerable: true, get: function () { return manager_2.Manager; } });\nvar socket_1 = require(\"./socket\");\nObject.defineProperty(exports, \"Socket\", { enumerable: true, get: function () { return socket_1.Socket; } });\nexports.default = lookup;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Socket = void 0;\nconst socket_io_parser_1 = require(\"socket.io-parser\");\nconst on_1 = require(\"./on\");\nconst typed_events_1 = require(\"./typed-events\");\nconst debug = require(\"debug\")(\"socket.io-client:socket\");\n/**\n * Internal events.\n * These events can't be emitted by the user.\n */\nconst RESERVED_EVENTS = Object.freeze({\n    connect: 1,\n    connect_error: 1,\n    disconnect: 1,\n    disconnecting: 1,\n    // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener\n    newListener: 1,\n    removeListener: 1,\n});\nclass Socket extends typed_events_1.StrictEventEmitter {\n    /**\n     * `Socket` constructor.\n     *\n     * @public\n     */\n    constructor(io, nsp, opts) {\n        super();\n        this.connected = false;\n        this.disconnected = true;\n        this.receiveBuffer = [];\n        this.sendBuffer = [];\n        this.ids = 0;\n        this.acks = {};\n        this.flags = {};\n        this.io = io;\n        this.nsp = nsp;\n        if (opts && opts.auth) {\n            this.auth = opts.auth;\n        }\n        if (this.io._autoConnect)\n            this.open();\n    }\n    /**\n     * Subscribe to open, close and packet events\n     *\n     * @private\n     */\n    subEvents() {\n        if (this.subs)\n            return;\n        const io = this.io;\n        this.subs = [\n            (0, on_1.on)(io, \"open\", this.onopen.bind(this)),\n            (0, on_1.on)(io, \"packet\", this.onpacket.bind(this)),\n            (0, on_1.on)(io, \"error\", this.onerror.bind(this)),\n            (0, on_1.on)(io, \"close\", this.onclose.bind(this)),\n        ];\n    }\n    /**\n     * Whether the Socket will try to reconnect when its Manager connects or reconnects\n     */\n    get active() {\n        return !!this.subs;\n    }\n    /**\n     * \"Opens\" the socket.\n     *\n     * @public\n     */\n    connect() {\n        if (this.connected)\n            return this;\n        this.subEvents();\n        if (!this.io[\"_reconnecting\"])\n            this.io.open(); // ensure open\n        if (\"open\" === this.io._readyState)\n            this.onopen();\n        return this;\n    }\n    /**\n     * Alias for connect()\n     */\n    open() {\n        return this.connect();\n    }\n    /**\n     * Sends a `message` event.\n     *\n     * @return self\n     * @public\n     */\n    send(...args) {\n        args.unshift(\"message\");\n        this.emit.apply(this, args);\n        return this;\n    }\n    /**\n     * Override `emit`.\n     * If the event is in `events`, it's emitted normally.\n     *\n     * @return self\n     * @public\n     */\n    emit(ev, ...args) {\n        if (RESERVED_EVENTS.hasOwnProperty(ev)) {\n            throw new Error('\"' + ev + '\" is a reserved event name');\n        }\n        args.unshift(ev);\n        const packet = {\n            type: socket_io_parser_1.PacketType.EVENT,\n            data: args,\n        };\n        packet.options = {};\n        packet.options.compress = this.flags.compress !== false;\n        // event ack callback\n        if (\"function\" === typeof args[args.length - 1]) {\n            debug(\"emitting packet with ack id %d\", this.ids);\n            this.acks[this.ids] = args.pop();\n            packet.id = this.ids++;\n        }\n        const isTransportWritable = this.io.engine &&\n            this.io.engine.transport &&\n            this.io.engine.transport.writable;\n        const discardPacket = this.flags.volatile && (!isTransportWritable || !this.connected);\n        if (discardPacket) {\n            debug(\"discard packet as the transport is not currently writable\");\n        }\n        else if (this.connected) {\n            this.packet(packet);\n        }\n        else {\n            this.sendBuffer.push(packet);\n        }\n        this.flags = {};\n        return this;\n    }\n    /**\n     * Sends a packet.\n     *\n     * @param packet\n     * @private\n     */\n    packet(packet) {\n        packet.nsp = this.nsp;\n        this.io._packet(packet);\n    }\n    /**\n     * Called upon engine `open`.\n     *\n     * @private\n     */\n    onopen() {\n        debug(\"transport is open - connecting\");\n        if (typeof this.auth == \"function\") {\n            this.auth((data) => {\n                this.packet({ type: socket_io_parser_1.PacketType.CONNECT, data });\n            });\n        }\n        else {\n            this.packet({ type: socket_io_parser_1.PacketType.CONNECT, data: this.auth });\n        }\n    }\n    /**\n     * Called upon engine or manager `error`.\n     *\n     * @param err\n     * @private\n     */\n    onerror(err) {\n        if (!this.connected) {\n            this.emitReserved(\"connect_error\", err);\n        }\n    }\n    /**\n     * Called upon engine `close`.\n     *\n     * @param reason\n     * @private\n     */\n    onclose(reason) {\n        debug(\"close (%s)\", reason);\n        this.connected = false;\n        this.disconnected = true;\n        delete this.id;\n        this.emitReserved(\"disconnect\", reason);\n    }\n    /**\n     * Called with socket packet.\n     *\n     * @param packet\n     * @private\n     */\n    onpacket(packet) {\n        const sameNamespace = packet.nsp === this.nsp;\n        if (!sameNamespace)\n            return;\n        switch (packet.type) {\n            case socket_io_parser_1.PacketType.CONNECT:\n                if (packet.data && packet.data.sid) {\n                    const id = packet.data.sid;\n                    this.onconnect(id);\n                }\n                else {\n                    this.emitReserved(\"connect_error\", new Error(\"It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)\"));\n                }\n                break;\n            case socket_io_parser_1.PacketType.EVENT:\n                this.onevent(packet);\n                break;\n            case socket_io_parser_1.PacketType.BINARY_EVENT:\n                this.onevent(packet);\n                break;\n            case socket_io_parser_1.PacketType.ACK:\n                this.onack(packet);\n                break;\n            case socket_io_parser_1.PacketType.BINARY_ACK:\n                this.onack(packet);\n                break;\n            case socket_io_parser_1.PacketType.DISCONNECT:\n                this.ondisconnect();\n                break;\n            case socket_io_parser_1.PacketType.CONNECT_ERROR:\n                const err = new Error(packet.data.message);\n                // @ts-ignore\n                err.data = packet.data.data;\n                this.emitReserved(\"connect_error\", err);\n                break;\n        }\n    }\n    /**\n     * Called upon a server event.\n     *\n     * @param packet\n     * @private\n     */\n    onevent(packet) {\n        const args = packet.data || [];\n        debug(\"emitting event %j\", args);\n        if (null != packet.id) {\n            debug(\"attaching ack callback to event\");\n            args.push(this.ack(packet.id));\n        }\n        if (this.connected) {\n            this.emitEvent(args);\n        }\n        else {\n            this.receiveBuffer.push(Object.freeze(args));\n        }\n    }\n    emitEvent(args) {\n        if (this._anyListeners && this._anyListeners.length) {\n            const listeners = this._anyListeners.slice();\n            for (const listener of listeners) {\n                listener.apply(this, args);\n            }\n        }\n        super.emit.apply(this, args);\n    }\n    /**\n     * Produces an ack callback to emit with an event.\n     *\n     * @private\n     */\n    ack(id) {\n        const self = this;\n        let sent = false;\n        return function (...args) {\n            // prevent double callbacks\n            if (sent)\n                return;\n            sent = true;\n            debug(\"sending ack %j\", args);\n            self.packet({\n                type: socket_io_parser_1.PacketType.ACK,\n                id: id,\n                data: args,\n            });\n        };\n    }\n    /**\n     * Called upon a server acknowlegement.\n     *\n     * @param packet\n     * @private\n     */\n    onack(packet) {\n        const ack = this.acks[packet.id];\n        if (\"function\" === typeof ack) {\n            debug(\"calling ack %s with %j\", packet.id, packet.data);\n            ack.apply(this, packet.data);\n            delete this.acks[packet.id];\n        }\n        else {\n            debug(\"bad ack %s\", packet.id);\n        }\n    }\n    /**\n     * Called upon server connect.\n     *\n     * @private\n     */\n    onconnect(id) {\n        debug(\"socket connected with id %s\", id);\n        this.id = id;\n        this.connected = true;\n        this.disconnected = false;\n        this.emitBuffered();\n        this.emitReserved(\"connect\");\n    }\n    /**\n     * Emit buffered events (received and emitted).\n     *\n     * @private\n     */\n    emitBuffered() {\n        this.receiveBuffer.forEach((args) => this.emitEvent(args));\n        this.receiveBuffer = [];\n        this.sendBuffer.forEach((packet) => this.packet(packet));\n        this.sendBuffer = [];\n    }\n    /**\n     * Called upon server disconnect.\n     *\n     * @private\n     */\n    ondisconnect() {\n        debug(\"server disconnect (%s)\", this.nsp);\n        this.destroy();\n        this.onclose(\"io server disconnect\");\n    }\n    /**\n     * Called upon forced client/server side disconnections,\n     * this method ensures the manager stops tracking us and\n     * that reconnections don't get triggered for this.\n     *\n     * @private\n     */\n    destroy() {\n        if (this.subs) {\n            // clean subscriptions to avoid reconnections\n            this.subs.forEach((subDestroy) => subDestroy());\n            this.subs = undefined;\n        }\n        this.io[\"_destroy\"](this);\n    }\n    /**\n     * Disconnects the socket manually.\n     *\n     * @return self\n     * @public\n     */\n    disconnect() {\n        if (this.connected) {\n            debug(\"performing disconnect (%s)\", this.nsp);\n            this.packet({ type: socket_io_parser_1.PacketType.DISCONNECT });\n        }\n        // remove socket from pool\n        this.destroy();\n        if (this.connected) {\n            // fire events\n            this.onclose(\"io client disconnect\");\n        }\n        return this;\n    }\n    /**\n     * Alias for disconnect()\n     *\n     * @return self\n     * @public\n     */\n    close() {\n        return this.disconnect();\n    }\n    /**\n     * Sets the compress flag.\n     *\n     * @param compress - if `true`, compresses the sending data\n     * @return self\n     * @public\n     */\n    compress(compress) {\n        this.flags.compress = compress;\n        return this;\n    }\n    /**\n     * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not\n     * ready to send messages.\n     *\n     * @returns self\n     * @public\n     */\n    get volatile() {\n        this.flags.volatile = true;\n        return this;\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback.\n     *\n     * @param listener\n     * @public\n     */\n    onAny(listener) {\n        this._anyListeners = this._anyListeners || [];\n        this._anyListeners.push(listener);\n        return this;\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback. The listener is added to the beginning of the listeners array.\n     *\n     * @param listener\n     * @public\n     */\n    prependAny(listener) {\n        this._anyListeners = this._anyListeners || [];\n        this._anyListeners.unshift(listener);\n        return this;\n    }\n    /**\n     * Removes the listener that will be fired when any event is emitted.\n     *\n     * @param listener\n     * @public\n     */\n    offAny(listener) {\n        if (!this._anyListeners) {\n            return this;\n        }\n        if (listener) {\n            const listeners = this._anyListeners;\n            for (let i = 0; i < listeners.length; i++) {\n                if (listener === listeners[i]) {\n                    listeners.splice(i, 1);\n                    return this;\n                }\n            }\n        }\n        else {\n            this._anyListeners = [];\n        }\n        return this;\n    }\n    /**\n     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,\n     * e.g. to remove listeners.\n     *\n     * @public\n     */\n    listenersAny() {\n        return this._anyListeners || [];\n    }\n}\nexports.Socket = Socket;\n","/* eslint-disable no-undefined */\n\nvar throttle = require('./throttle');\n\n/**\n * Debounce execution of a function. Debouncing, unlike throttling,\n * guarantees that a function is only executed a single time, either at the\n * very beginning of a series of calls, or at the very end.\n *\n * @param  {Number}   delay         A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.\n * @param  {Boolean}  [atBegin]     Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds\n *                                  after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.\n *                                  (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).\n * @param  {Function} callback      A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,\n *                                  to `callback` when the debounced-function is executed.\n *\n * @return {Function} A new, debounced function.\n */\nmodule.exports = function ( delay, atBegin, callback ) {\n\treturn callback === undefined ? throttle(delay, atBegin, false) : throttle(delay, callback, atBegin !== false);\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","/* smoothscroll v0.4.4 - 2019 - Dustan Kasten, Jeremias Menichelli - MIT License */\n(function () {\n  'use strict';\n\n  // polyfill\n  function polyfill() {\n    // aliases\n    var w = window;\n    var d = document;\n\n    // return if scroll behavior is supported and polyfill is not forced\n    if (\n      'scrollBehavior' in d.documentElement.style &&\n      w.__forceSmoothScrollPolyfill__ !== true\n    ) {\n      return;\n    }\n\n    // globals\n    var Element = w.HTMLElement || w.Element;\n    var SCROLL_TIME = 468;\n\n    // object gathering original scroll methods\n    var original = {\n      scroll: w.scroll || w.scrollTo,\n      scrollBy: w.scrollBy,\n      elementScroll: Element.prototype.scroll || scrollElement,\n      scrollIntoView: Element.prototype.scrollIntoView\n    };\n\n    // define timing method\n    var now =\n      w.performance && w.performance.now\n        ? w.performance.now.bind(w.performance)\n        : Date.now;\n\n    /**\n     * indicates if a the current browser is made by Microsoft\n     * @method isMicrosoftBrowser\n     * @param {String} userAgent\n     * @returns {Boolean}\n     */\n    function isMicrosoftBrowser(userAgent) {\n      var userAgentPatterns = ['MSIE ', 'Trident/', 'Edge/'];\n\n      return new RegExp(userAgentPatterns.join('|')).test(userAgent);\n    }\n\n    /*\n     * IE has rounding bug rounding down clientHeight and clientWidth and\n     * rounding up scrollHeight and scrollWidth causing false positives\n     * on hasScrollableSpace\n     */\n    var ROUNDING_TOLERANCE = isMicrosoftBrowser(w.navigator.userAgent) ? 1 : 0;\n\n    /**\n     * changes scroll position inside an element\n     * @method scrollElement\n     * @param {Number} x\n     * @param {Number} y\n     * @returns {undefined}\n     */\n    function scrollElement(x, y) {\n      this.scrollLeft = x;\n      this.scrollTop = y;\n    }\n\n    /**\n     * returns result of applying ease math function to a number\n     * @method ease\n     * @param {Number} k\n     * @returns {Number}\n     */\n    function ease(k) {\n      return 0.5 * (1 - Math.cos(Math.PI * k));\n    }\n\n    /**\n     * indicates if a smooth behavior should be applied\n     * @method shouldBailOut\n     * @param {Number|Object} firstArg\n     * @returns {Boolean}\n     */\n    function shouldBailOut(firstArg) {\n      if (\n        firstArg === null ||\n        typeof firstArg !== 'object' ||\n        firstArg.behavior === undefined ||\n        firstArg.behavior === 'auto' ||\n        firstArg.behavior === 'instant'\n      ) {\n        // first argument is not an object/null\n        // or behavior is auto, instant or undefined\n        return true;\n      }\n\n      if (typeof firstArg === 'object' && firstArg.behavior === 'smooth') {\n        // first argument is an object and behavior is smooth\n        return false;\n      }\n\n      // throw error when behavior is not supported\n      throw new TypeError(\n        'behavior member of ScrollOptions ' +\n          firstArg.behavior +\n          ' is not a valid value for enumeration ScrollBehavior.'\n      );\n    }\n\n    /**\n     * indicates if an element has scrollable space in the provided axis\n     * @method hasScrollableSpace\n     * @param {Node} el\n     * @param {String} axis\n     * @returns {Boolean}\n     */\n    function hasScrollableSpace(el, axis) {\n      if (axis === 'Y') {\n        return el.clientHeight + ROUNDING_TOLERANCE < el.scrollHeight;\n      }\n\n      if (axis === 'X') {\n        return el.clientWidth + ROUNDING_TOLERANCE < el.scrollWidth;\n      }\n    }\n\n    /**\n     * indicates if an element has a scrollable overflow property in the axis\n     * @method canOverflow\n     * @param {Node} el\n     * @param {String} axis\n     * @returns {Boolean}\n     */\n    function canOverflow(el, axis) {\n      var overflowValue = w.getComputedStyle(el, null)['overflow' + axis];\n\n      return overflowValue === 'auto' || overflowValue === 'scroll';\n    }\n\n    /**\n     * indicates if an element can be scrolled in either axis\n     * @method isScrollable\n     * @param {Node} el\n     * @param {String} axis\n     * @returns {Boolean}\n     */\n    function isScrollable(el) {\n      var isScrollableY = hasScrollableSpace(el, 'Y') && canOverflow(el, 'Y');\n      var isScrollableX = hasScrollableSpace(el, 'X') && canOverflow(el, 'X');\n\n      return isScrollableY || isScrollableX;\n    }\n\n    /**\n     * finds scrollable parent of an element\n     * @method findScrollableParent\n     * @param {Node} el\n     * @returns {Node} el\n     */\n    function findScrollableParent(el) {\n      while (el !== d.body && isScrollable(el) === false) {\n        el = el.parentNode || el.host;\n      }\n\n      return el;\n    }\n\n    /**\n     * self invoked function that, given a context, steps through scrolling\n     * @method step\n     * @param {Object} context\n     * @returns {undefined}\n     */\n    function step(context) {\n      var time = now();\n      var value;\n      var currentX;\n      var currentY;\n      var elapsed = (time - context.startTime) / SCROLL_TIME;\n\n      // avoid elapsed times higher than one\n      elapsed = elapsed > 1 ? 1 : elapsed;\n\n      // apply easing to elapsed time\n      value = ease(elapsed);\n\n      currentX = context.startX + (context.x - context.startX) * value;\n      currentY = context.startY + (context.y - context.startY) * value;\n\n      context.method.call(context.scrollable, currentX, currentY);\n\n      // scroll more if we have not reached our destination\n      if (currentX !== context.x || currentY !== context.y) {\n        w.requestAnimationFrame(step.bind(w, context));\n      }\n    }\n\n    /**\n     * scrolls window or element with a smooth behavior\n     * @method smoothScroll\n     * @param {Object|Node} el\n     * @param {Number} x\n     * @param {Number} y\n     * @returns {undefined}\n     */\n    function smoothScroll(el, x, y) {\n      var scrollable;\n      var startX;\n      var startY;\n      var method;\n      var startTime = now();\n\n      // define scroll context\n      if (el === d.body) {\n        scrollable = w;\n        startX = w.scrollX || w.pageXOffset;\n        startY = w.scrollY || w.pageYOffset;\n        method = original.scroll;\n      } else {\n        scrollable = el;\n        startX = el.scrollLeft;\n        startY = el.scrollTop;\n        method = scrollElement;\n      }\n\n      // scroll looping over a frame\n      step({\n        scrollable: scrollable,\n        method: method,\n        startTime: startTime,\n        startX: startX,\n        startY: startY,\n        x: x,\n        y: y\n      });\n    }\n\n    // ORIGINAL METHODS OVERRIDES\n    // w.scroll and w.scrollTo\n    w.scroll = w.scrollTo = function() {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      }\n\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0]) === true) {\n        original.scroll.call(\n          w,\n          arguments[0].left !== undefined\n            ? arguments[0].left\n            : typeof arguments[0] !== 'object'\n              ? arguments[0]\n              : w.scrollX || w.pageXOffset,\n          // use top prop, second argument if present or fallback to scrollY\n          arguments[0].top !== undefined\n            ? arguments[0].top\n            : arguments[1] !== undefined\n              ? arguments[1]\n              : w.scrollY || w.pageYOffset\n        );\n\n        return;\n      }\n\n      // LET THE SMOOTHNESS BEGIN!\n      smoothScroll.call(\n        w,\n        d.body,\n        arguments[0].left !== undefined\n          ? ~~arguments[0].left\n          : w.scrollX || w.pageXOffset,\n        arguments[0].top !== undefined\n          ? ~~arguments[0].top\n          : w.scrollY || w.pageYOffset\n      );\n    };\n\n    // w.scrollBy\n    w.scrollBy = function() {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      }\n\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0])) {\n        original.scrollBy.call(\n          w,\n          arguments[0].left !== undefined\n            ? arguments[0].left\n            : typeof arguments[0] !== 'object' ? arguments[0] : 0,\n          arguments[0].top !== undefined\n            ? arguments[0].top\n            : arguments[1] !== undefined ? arguments[1] : 0\n        );\n\n        return;\n      }\n\n      // LET THE SMOOTHNESS BEGIN!\n      smoothScroll.call(\n        w,\n        d.body,\n        ~~arguments[0].left + (w.scrollX || w.pageXOffset),\n        ~~arguments[0].top + (w.scrollY || w.pageYOffset)\n      );\n    };\n\n    // Element.prototype.scroll and Element.prototype.scrollTo\n    Element.prototype.scroll = Element.prototype.scrollTo = function() {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      }\n\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0]) === true) {\n        // if one number is passed, throw error to match Firefox implementation\n        if (typeof arguments[0] === 'number' && arguments[1] === undefined) {\n          throw new SyntaxError('Value could not be converted');\n        }\n\n        original.elementScroll.call(\n          this,\n          // use left prop, first number argument or fallback to scrollLeft\n          arguments[0].left !== undefined\n            ? ~~arguments[0].left\n            : typeof arguments[0] !== 'object' ? ~~arguments[0] : this.scrollLeft,\n          // use top prop, second argument or fallback to scrollTop\n          arguments[0].top !== undefined\n            ? ~~arguments[0].top\n            : arguments[1] !== undefined ? ~~arguments[1] : this.scrollTop\n        );\n\n        return;\n      }\n\n      var left = arguments[0].left;\n      var top = arguments[0].top;\n\n      // LET THE SMOOTHNESS BEGIN!\n      smoothScroll.call(\n        this,\n        this,\n        typeof left === 'undefined' ? this.scrollLeft : ~~left,\n        typeof top === 'undefined' ? this.scrollTop : ~~top\n      );\n    };\n\n    // Element.prototype.scrollBy\n    Element.prototype.scrollBy = function() {\n      // avoid action when no arguments are passed\n      if (arguments[0] === undefined) {\n        return;\n      }\n\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0]) === true) {\n        original.elementScroll.call(\n          this,\n          arguments[0].left !== undefined\n            ? ~~arguments[0].left + this.scrollLeft\n            : ~~arguments[0] + this.scrollLeft,\n          arguments[0].top !== undefined\n            ? ~~arguments[0].top + this.scrollTop\n            : ~~arguments[1] + this.scrollTop\n        );\n\n        return;\n      }\n\n      this.scroll({\n        left: ~~arguments[0].left + this.scrollLeft,\n        top: ~~arguments[0].top + this.scrollTop,\n        behavior: arguments[0].behavior\n      });\n    };\n\n    // Element.prototype.scrollIntoView\n    Element.prototype.scrollIntoView = function() {\n      // avoid smooth behavior if not required\n      if (shouldBailOut(arguments[0]) === true) {\n        original.scrollIntoView.call(\n          this,\n          arguments[0] === undefined ? true : arguments[0]\n        );\n\n        return;\n      }\n\n      // LET THE SMOOTHNESS BEGIN!\n      var scrollableParent = findScrollableParent(this);\n      var parentRects = scrollableParent.getBoundingClientRect();\n      var clientRects = this.getBoundingClientRect();\n\n      if (scrollableParent !== d.body) {\n        // reveal element inside parent\n        smoothScroll.call(\n          this,\n          scrollableParent,\n          scrollableParent.scrollLeft + clientRects.left - parentRects.left,\n          scrollableParent.scrollTop + clientRects.top - parentRects.top\n        );\n\n        // reveal parent in viewport unless is fixed\n        if (w.getComputedStyle(scrollableParent).position !== 'fixed') {\n          w.scrollBy({\n            left: parentRects.left,\n            top: parentRects.top,\n            behavior: 'smooth'\n          });\n        }\n      } else {\n        // reveal element in viewport\n        w.scrollBy({\n          left: clientRects.left,\n          top: clientRects.top,\n          behavior: 'smooth'\n        });\n      }\n    };\n  }\n\n  if (typeof exports === 'object' && typeof module !== 'undefined') {\n    // commonjs\n    module.exports = { polyfill: polyfill };\n  } else {\n    // global\n    polyfill();\n  }\n\n}());\n","var throttle = require('./throttle');\nvar debounce = require('./debounce');\n\nmodule.exports = {\n\tthrottle: throttle,\n\tdebounce: debounce\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n"],"sourceRoot":""}