imjoy-rpc-socketio.min.js.map

{"version":3,"sources":["webpack://[name]/webpack/universalModuleDefinition","webpack://[name]/webpack/bootstrap","webpack://[name]/./src/utils.js","webpack://[name]/./src/rpc.js","webpack://[name]/./node_modules/@socket.io/component-emitter/index.js","webpack://[name]/./node_modules/engine.io-client/build/esm/globalThis.browser.js","webpack://[name]/./node_modules/engine.io-client/build/esm/util.js","webpack://[name]/./src/pluginIframe.js","webpack://[name]/./node_modules/engine.io-client/build/esm/transports/websocket-constructor.browser.js","webpack://[name]/./node_modules/engine.io-parser/build/esm/commons.js","webpack://[name]/./node_modules/engine.io-parser/build/esm/encodePacket.browser.js","webpack://[name]/./node_modules/@socket.io/base64-arraybuffer/dist/base64-arraybuffer.es5.js","webpack://[name]/./node_modules/engine.io-parser/build/esm/decodePacket.browser.js","webpack://[name]/./node_modules/engine.io-parser/build/esm/index.js","webpack://[name]/./src/pluginCore.js","webpack://[name]/./node_modules/engine.io-client/build/esm/transport.js","webpack://[name]/./node_modules/parseqs/index.js","webpack://[name]/./src/main.js","webpack://[name]/./src/plugin.webworker.js","webpack://[name]/./node_modules/parseuri/index.js","webpack://[name]/./node_modules/yeast/index.js","webpack://[name]/./node_modules/worker-loader/dist/workers/InlineWorker.js","webpack://[name]/./node_modules/has-cors/index.js","webpack://[name]/./node_modules/engine.io-client/build/esm/transports/websocket.js","webpack://[name]/./node_modules/backo2/index.js","webpack://[name]/./node_modules/buffer/index.js","webpack://[name]/(webpack)/buildin/global.js","webpack://[name]/./node_modules/base64-js/index.js","webpack://[name]/./node_modules/ieee754/index.js","webpack://[name]/./node_modules/isarray/index.js","webpack://[name]/./node_modules/engine.io-client/build/esm/transports/xmlhttprequest.browser.js","webpack://[name]/./node_modules/engine.io-client/build/esm/transports/polling.js","webpack://[name]/./node_modules/engine.io-client/build/esm/transports/polling-xhr.js","webpack://[name]/./node_modules/engine.io-client/build/esm/transports/index.js","webpack://[name]/./node_modules/engine.io-client/build/esm/socket.js","webpack://[name]/./node_modules/engine.io-client/build/esm/index.js","webpack://[name]/./node_modules/socket.io-client/node_modules/socket.io-parser/build/esm/is-binary.js","webpack://[name]/./node_modules/socket.io-client/node_modules/socket.io-parser/build/esm/binary.js","webpack://[name]/./node_modules/socket.io-client/node_modules/socket.io-parser/build/esm/index.js","webpack://[name]/./node_modules/socket.io-client/build/esm/on.js","webpack://[name]/./node_modules/socket.io-client/build/esm/socket.js","webpack://[name]/./node_modules/socket.io-client/build/esm/manager.js","webpack://[name]/./node_modules/socket.io-client/build/esm/index.js","webpack://[name]/./node_modules/socket.io-client/build/esm/url.js","webpack://[name]/./src/socketIOMain.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","randId","Math","random","toString","substr","Date","getTime","dtypeToTypedArray","int8","Int8Array","int16","Int16Array","int32","Int32Array","uint8","Uint8Array","uint16","Uint16Array","uint32","Uint32Array","float32","Float32Array","float64","Float64Array","array","Array","async","loadRequirementsInWindow","requirements","_importScript","url","Promise","resolve","reject","scriptTag","document","createElement","src","type","onload","onreadystatechange","this","readyState","onerror","head","appendChild","importScripts","args","slice","arguments","len","length","isArray","link_node","toLowerCase","endsWith","startsWith","rel","href","import","console","log","e","loadRequirementsInWebworker","loadRequirements","WorkerGlobalScope","self","normalizeConfig","config","version","description","id","target_origin","allow_execution","keys","reduce","typedArrayToDtypeMapping","typedArrayToDtypeKeys","arrType","push","eval","typedArrayToDtype","obj","dtype","constructor","pt","getPrototypeOf","cacheUrlInServiceWorker","message","command","navigator","serviceWorker","register","messageChannel","MessageChannel","port1","onmessage","event","data","error","result","controller","postMessage","port2","cacheRequirements","req","catch","setupServiceWorker","baseUrl","targetOrigin","cacheCallback","then","registration","scope","err","Error","addEventListener","origin","urlJoin","join","replace","MessageEmitter","debug","_event_handlers","_once_handlers","_debug","emit","on","handler","once","___event_run_once","off","idx","indexOf","splice","_fire","warn","API_VERSION","ArrayBufferView","_appendBuffer","buffer1","buffer2","tmp","byteLength","set","buffer","indexObject","is","split","RPC","connection","codecs","super","_connection","_codecs","_object_store","_method_weakmap","WeakMap","_object_weakmap","_local_api","_remote_set","execute","_store","ReferenceStore","_method_refs","onReady","onBusy","_setupMessageHanlders","init","peer_id","setConfig","k","getRemoteCallStack","getStack","getRemote","_remote_interface","setInterface","_interface","forwarding_functions","func_name","_remote","Function","sendInterface","_encode","api","_disposeObject","objectId","disposeObject","has","object_id","code","String","method","method_this","promise","_unwrap","includes","apply","fetch","_setRemoteInterface","disconnect","requestRemote","_ndarray","typedArray","shape","_dtype","_rtype","_rvalue","_rshape","_rdtype","_decode","intf","assign","_reportRemoteSet","_genRemoteMethod","targetId","me","remoteMethod","put","wrapped_resolve","wrapped_reject","encodedPromise","_wrap","__promise_pair","argLength","withKwargs","_rkwargs","transferables","__transferables__","target_id","with_kwargs","__remote_method","aObject","asInterface","aType","ArrayBuffer","bObject","_rtarget_id","_rintf","cid","_rname","temp","_transfer","isarray","tp","codec","encoder","encodedObj","tf","Tensor","v_buffer","dataSync","nj","NdArray","selection","File","_rpath","_path","webkitRelativePath","Boolean","RegExp","ImageData","FileList","FileSystemDirectoryHandle","FileSystemFileHandle","FileSystemHandle","FileSystemWritableFileStream","_rmime","Blob","DataView","Set","from","Map","getOwnPropertyNames","concat","hasFunction","withPromise","decoder","_genRemoteCallback","Uint8","reshape","arraytype","tensor","v","undefined","remoteCallback","reset","setTimeout","_indices","_readyHandler","_busyHandler","readyHandler","busyHandler","_genId","shift","_releaseId","pop","Emitter","mixin","fn","_callbacks","removeListener","removeAllListeners","removeEventListener","cb","callbacks","emitReserved","listeners","hasListeners","pick","attr","acc","NATIVE_SET_TIMEOUT","NATIVE_CLEAR_TIMEOUT","clearTimeout","installTimerFunctions","opts","useNativeTimers","setTimeoutFn","clearTimeoutFn","_htmlToElement","html","template","trim","innerHTML","content","firstChild","_inWebWorker","executeEsModule","dataUri","encodeURIComponent","Connection","connect","broadcastChannel","BroadcastChannel","globalThis","location","handleEvent","parent","script_node","setAttribute","attrs","lang","node","createTextNode","body","style_node","link_node_","stack","setupIframe","dedicated_thread","api_version","conn","connectRPC","nextTick","WebSocket","MozWebSocket","usingBrowserWebSocket","defaultBinaryType","PACKET_TYPES","PACKET_TYPES_REVERSE","forEach","ERROR_PACKET","withNativeBlob","withNativeArrayBuffer","encodeBlobAsBase64","callback","fileReader","FileReader","readAsDataURL","supportsBinary","isView","chars","lookup","charCodeAt","decodeBase64Packet","binaryType","decoded","base64","encoded1","encoded2","encoded3","encoded4","bufferLength","arraybuffer","bytes","decode","mapBinary","encodedPacket","charAt","substring","SEPARATOR","fromCharCode","encodePayload","packets","encodedPackets","count","packet","decodePayload","encodedPayload","decodedPacket","protocol","rpc","launchConnected","registerCodec","setup","export","onLoad","checkHandler","connected","connectedHandlers","dispose","_rpc","dispatchEvent","CustomEvent","detail","Transport","writable","query","socket","msg","desc","doOpen","doClose","onClose","write","onPacket","encode","str","qs","qry","pairs","pair","decodeURIComponent","waitForInitialization","enable_service_worker","base_url","cache_requirements","credential_required","verify_credential","cfg","credential","auth","setupRPC","expose_api_globally","top","_inIframe","worker","PluginWorker","fallbackTimeout","terminate","setupWebWorker","re","parts","b","exec","uri","source","host","authority","ipv6uri","pathNames","path","names","queryKey","$0","$1","$2","prev","alphabet","map","seed","num","encoded","floor","yeast","now","URL","webkitURL","blob","BlobBuilder","WebKitBlobBuilder","MozBlobBuilder","MSBlobBuilder","append","getBlob","Worker","createObjectURL","XMLHttpRequest","isReactNative","product","WS","forceBase64","check","protocols","extraHeaders","headers","ws","addEventListeners","onopen","autoUnref","_socket","unref","onOpen","onclose","ev","onData","onError","lastPacket","options","compress","perMessageDeflate","Buffer","threshold","send","close","schema","secure","port","Number","timestampRequests","timestampParam","b64","encodedQuery","hostname","Backoff","ms","min","max","factor","jitter","attempts","duration","pow","rand","deviation","setMin","setMax","setJitter","ieee754","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","__proto__","arg","encodingOrOffset","allocUnsafe","TypeError","byteOffset","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","fromString","isBuffer","checked","copy","val","fromObject","assertSize","size","loweredCase","utf8ToBytes","base64ToBytes","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","isNaN","arrayIndexOf","lastIndexOf","arr","indexSize","arrLength","valLength","read","buf","readUInt16BE","foundIndex","found","j","hexWrite","offset","remaining","strLen","parsed","parseInt","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","typedArraySupport","poolSize","_augment","species","configurable","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","list","pos","swap16","swap32","swap64","equals","inspect","match","target","thisStart","thisEnd","thisCopy","targetCopy","isFinite","toJSON","_arr","ret","out","toHex","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","stringtrim","base64clean","dst","g","lens","getLens","validLen","placeHoldersLen","Arr","_byteLength","curByte","revLookup","extraBytes","len2","encodeChunk","output","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","abs","LN2","xdomain","polling","poll","onPause","pause","total","doPoll","doWrite","sid","empty","hasXHR2","responseType","xd","xscheme","xs","xhr","open","setDisableHeaderCheck","setRequestHeader","withCredentials","requestTimeout","timeout","status","index","requestsCount","requests","cleanup","onSuccess","fromError","abort","responseText","attachEvent","unloadHandler","terminationEvent","transports","websocket","isSSL","request","pollXhr","writeBuffer","prevBufferLen","agent","upgrade","rememberUpgrade","rejectUnauthorized","transportOptions","closeOnBeforeunload","upgrades","pingInterval","pingTimeout","pingTimeoutTimer","transport","offlineEventListener","clone","EIO","priorWebsocketSuccess","createTransport","setTransport","onDrain","failed","onTransportOpen","upgrading","flush","freezeTransport","onTransportClose","onupgrade","to","probe","onHandshake","JSON","parse","resetPingTimeout","sendPacket","filterUpgrades","cleanupAndClose","waitForUpgrade","reason","filteredUpgrades","withNativeFile","isBinary","deconstructPacket","buffers","packetData","pack","_deconstructPacket","placeholder","_placeholder","newData","attachments","reconstructPacket","_reconstructPacket","PacketType","EVENT","ACK","hasBinary","encodeAsString","BINARY_EVENT","BINARY_ACK","encodeAsBinary","nsp","stringify","deconstruction","unshift","decodeString","reconstructor","takeBinaryData","next","payload","tryParse","isPayloadValid","CONNECT","DISCONNECT","CONNECT_ERROR","finishedReconstruction","reconPack","binData","RESERVED_EVENTS","freeze","connect_error","disconnecting","newListener","io","disconnected","receiveBuffer","sendBuffer","ids","acks","flags","_autoConnect","subs","onpacket","subEvents","_readyState","ack","_registerAckCallback","isTransportWritable","engine","volatile","timer","_packet","onconnect","onevent","onack","ondisconnect","destroy","emitEvent","_anyListeners","listener","sent","emitBuffered","subDestroy","_a","nsps","reconnection","reconnectionAttempts","reconnectionDelay","reconnectionDelayMax","randomizationFactor","backoff","_parser","parser","Encoder","Decoder","autoConnect","_reconnection","_reconnectionAttempts","_reconnectionDelay","_randomizationFactor","_reconnectionDelayMax","_timeout","_reconnecting","reconnect","skipReconnect","openSubDestroy","errorSub","maybeReconnectOnOpen","onping","ondata","ondecoded","add","active","_close","delay","onreconnect","attempt","cache","loc","test","sameNamespace","forceNew","multiplex","Manager","Socket","server_url","token","Authorization","basePath","pathname","success","plugin_id","_disconnected","connectToServer"],"mappings":"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","file":"imjoy-rpc-socketio.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"imjoyRPCSocketIO\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"imjoyRPCSocketIO\"] = factory();\n\telse\n\t\troot[\"imjoyRPCSocketIO\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 29);\n","export function randId() {\n  return (\n    Math.random()\n      .toString(36)\n      .substr(2, 10) + new Date().getTime()\n  );\n}\n\nexport const dtypeToTypedArray = {\n  int8: Int8Array,\n  int16: Int16Array,\n  int32: Int32Array,\n  uint8: Uint8Array,\n  uint16: Uint16Array,\n  uint32: Uint32Array,\n  float32: Float32Array,\n  float64: Float64Array,\n  array: Array\n};\n\nexport async function loadRequirementsInWindow(requirements) {\n  function _importScript(url) {\n    //url is URL of external file, implementationCode is the code\n    //to be called from the file, location is the location to\n    //insert the <script> element\n    return new Promise((resolve, reject) => {\n      var scriptTag = document.createElement(\"script\");\n      scriptTag.src = url;\n      scriptTag.type = \"text/javascript\";\n      scriptTag.onload = resolve;\n      scriptTag.onreadystatechange = function() {\n        if (this.readyState === \"loaded\" || this.readyState === \"complete\") {\n          resolve();\n        }\n      };\n      scriptTag.onerror = reject;\n      document.head.appendChild(scriptTag);\n    });\n  }\n\n  // support importScripts outside web worker\n  async function importScripts() {\n    var args = Array.prototype.slice.call(arguments),\n      len = args.length,\n      i = 0;\n    for (; i < len; i++) {\n      await _importScript(args[i]);\n    }\n  }\n\n  if (\n    requirements &&\n    (Array.isArray(requirements) || typeof requirements === \"string\")\n  ) {\n    try {\n      var link_node;\n      requirements =\n        typeof requirements === \"string\" ? [requirements] : requirements;\n      if (Array.isArray(requirements)) {\n        for (var i = 0; i < requirements.length; i++) {\n          if (\n            requirements[i].toLowerCase().endsWith(\".css\") ||\n            requirements[i].startsWith(\"css:\")\n          ) {\n            if (requirements[i].startsWith(\"css:\")) {\n              requirements[i] = requirements[i].slice(4);\n            }\n            link_node = document.createElement(\"link\");\n            link_node.rel = \"stylesheet\";\n            link_node.href = requirements[i];\n            document.head.appendChild(link_node);\n          } else if (\n            requirements[i].toLowerCase().endsWith(\".mjs\") ||\n            requirements[i].startsWith(\"mjs:\")\n          ) {\n            // import esmodule\n            if (requirements[i].startsWith(\"mjs:\")) {\n              requirements[i] = requirements[i].slice(4);\n            }\n            await import(/* webpackIgnore: true */ requirements[i]);\n          } else if (\n            requirements[i].toLowerCase().endsWith(\".js\") ||\n            requirements[i].startsWith(\"js:\")\n          ) {\n            if (requirements[i].startsWith(\"js:\")) {\n              requirements[i] = requirements[i].slice(3);\n            }\n            await importScripts(requirements[i]);\n          } else if (requirements[i].startsWith(\"http\")) {\n            await importScripts(requirements[i]);\n          } else if (requirements[i].startsWith(\"cache:\")) {\n            //ignore cache\n          } else {\n            console.log(\"Unprocessed requirements url: \" + requirements[i]);\n          }\n        }\n      } else {\n        throw \"unsupported requirements definition\";\n      }\n    } catch (e) {\n      throw \"failed to import required scripts: \" + requirements.toString();\n    }\n  }\n}\n\nexport async function loadRequirementsInWebworker(requirements) {\n  if (\n    requirements &&\n    (Array.isArray(requirements) || typeof requirements === \"string\")\n  ) {\n    try {\n      if (!Array.isArray(requirements)) {\n        requirements = [requirements];\n      }\n      for (var i = 0; i < requirements.length; i++) {\n        if (\n          requirements[i].toLowerCase().endsWith(\".css\") ||\n          requirements[i].startsWith(\"css:\")\n        ) {\n          throw \"unable to import css in a webworker\";\n        } else if (\n          requirements[i].toLowerCase().endsWith(\".js\") ||\n          requirements[i].startsWith(\"js:\")\n        ) {\n          if (requirements[i].startsWith(\"js:\")) {\n            requirements[i] = requirements[i].slice(3);\n          }\n          importScripts(requirements[i]);\n        } else if (requirements[i].startsWith(\"http\")) {\n          importScripts(requirements[i]);\n        } else if (requirements[i].startsWith(\"cache:\")) {\n          //ignore cache\n        } else {\n          console.log(\"Unprocessed requirements url: \" + requirements[i]);\n        }\n      }\n    } catch (e) {\n      throw \"failed to import required scripts: \" + requirements.toString();\n    }\n  }\n}\n\nexport function loadRequirements(requirements) {\n  if (\n    typeof WorkerGlobalScope !== \"undefined\" &&\n    self instanceof WorkerGlobalScope\n  ) {\n    return loadRequirementsInWebworker(requirements);\n  } else {\n    return loadRequirementsInWindow(requirements);\n  }\n}\n\nexport function normalizeConfig(config) {\n  config.version = config.version || \"0.1.0\";\n  config.description =\n    config.description || `[TODO: add description for ${config.name} ]`;\n  config.type = config.type || \"rpc-window\";\n  config.id = config.id || randId();\n  config.target_origin = config.target_origin || \"*\";\n  config.allow_execution = config.allow_execution || false;\n  // remove functions\n  config = Object.keys(config).reduce((p, c) => {\n    if (typeof config[c] !== \"function\") p[c] = config[c];\n    return p;\n  }, {});\n  return config;\n}\nexport const typedArrayToDtypeMapping = {\n  Int8Array: \"int8\",\n  Int16Array: \"int16\",\n  Int32Array: \"int32\",\n  Uint8Array: \"uint8\",\n  Uint16Array: \"uint16\",\n  Uint32Array: \"uint32\",\n  Float32Array: \"float32\",\n  Float64Array: \"float64\",\n  Array: \"array\"\n};\n\nconst typedArrayToDtypeKeys = [];\nfor (const arrType of Object.keys(typedArrayToDtypeMapping)) {\n  typedArrayToDtypeKeys.push(eval(arrType));\n}\n\nexport function typedArrayToDtype(obj) {\n  let dtype = typedArrayToDtypeMapping[obj.constructor.name];\n  if (!dtype) {\n    const pt = Object.getPrototypeOf(obj);\n    for (const arrType of typedArrayToDtypeKeys) {\n      if (pt instanceof arrType) {\n        dtype = typedArrayToDtypeMapping[arrType.name];\n        break;\n      }\n    }\n  }\n  return dtype;\n}\n\nfunction cacheUrlInServiceWorker(url) {\n  return new Promise(function(resolve, reject) {\n    const message = {\n      command: \"add\",\n      url: url\n    };\n    if (!navigator.serviceWorker || !navigator.serviceWorker.register) {\n      reject(\"Service worker is not supported.\");\n      return;\n    }\n    const messageChannel = new MessageChannel();\n    messageChannel.port1.onmessage = function(event) {\n      if (event.data && event.data.error) {\n        reject(event.data.error);\n      } else {\n        resolve(event.data && event.data.result);\n      }\n    };\n\n    if (navigator.serviceWorker && navigator.serviceWorker.controller) {\n      navigator.serviceWorker.controller.postMessage(message, [\n        messageChannel.port2\n      ]);\n    } else {\n      reject(\"Service worker controller is not available\");\n    }\n  });\n}\n\nexport async function cacheRequirements(requirements) {\n  requirements = requirements || [];\n  if (!Array.isArray(requirements)) {\n    requirements = [requirements];\n  }\n  for (let req of requirements) {\n    //remove prefix\n    if (req.startsWith(\"js:\")) req = req.slice(3);\n    if (req.startsWith(\"css:\")) req = req.slice(4);\n    if (req.startsWith(\"cache:\")) req = req.slice(6);\n    if (!req.startsWith(\"http\")) continue;\n\n    await cacheUrlInServiceWorker(req).catch(e => {\n      console.error(e);\n    });\n  }\n}\n\nexport function setupServiceWorker(baseUrl, targetOrigin, cacheCallback) {\n  // register service worker for offline access\n  if (\"serviceWorker\" in navigator) {\n    baseUrl = baseUrl || \"/\";\n    navigator.serviceWorker.register(baseUrl + \"plugin-service-worker.js\").then(\n      function(registration) {\n        // Registration was successful\n        console.log(\n          \"ServiceWorker registration successful with scope: \",\n          registration.scope\n        );\n      },\n      function(err) {\n        // registration failed :(\n        console.log(\"ServiceWorker registration failed: \", err);\n      }\n    );\n    targetOrigin = targetOrigin || \"*\";\n    cacheCallback = cacheCallback || cacheRequirements;\n    if (cacheCallback && typeof cacheCallback !== \"function\") {\n      throw new Error(\"config.cache_requirements must be a function\");\n    }\n    window.addEventListener(\"message\", function(e) {\n      if (targetOrigin === \"*\" || e.origin === targetOrigin) {\n        const m = e.data;\n        if (m.type === \"cacheRequirements\") {\n          cacheCallback(m.requirements);\n        }\n      }\n    });\n  }\n}\n\n//#Source https://bit.ly/2neWfJ2\nexport function urlJoin(...args) {\n  return args\n    .join(\"/\")\n    .replace(/[\\/]+/g, \"/\")\n    .replace(/^(.+):\\//, \"$1://\")\n    .replace(/^file:/, \"file:/\")\n    .replace(/\\/(\\?|&|#[^!])/g, \"$1\")\n    .replace(/\\?/g, \"&\")\n    .replace(\"&\", \"?\");\n}\n\nexport class MessageEmitter {\n  constructor(debug) {\n    this._event_handlers = {};\n    this._once_handlers = {};\n    this._debug = debug;\n  }\n  emit() {\n    throw new Error(\"emit is not implemented\");\n  }\n  on(event, handler) {\n    if (!this._event_handlers[event]) {\n      this._event_handlers[event] = [];\n    }\n    this._event_handlers[event].push(handler);\n  }\n  once(event, handler) {\n    handler.___event_run_once = true;\n    this.on(event, handler);\n  }\n  off(event, handler) {\n    if (!event && !handler) {\n      // remove all events handlers\n      this._event_handlers = {};\n    } else if (event && !handler) {\n      // remove all hanlders for the event\n      if (this._event_handlers[event]) this._event_handlers[event] = [];\n    } else {\n      // remove a specific handler\n      if (this._event_handlers[event]) {\n        const idx = this._event_handlers[event].indexOf(handler);\n        if (idx >= 0) {\n          this._event_handlers[event].splice(idx, 1);\n        }\n      }\n    }\n  }\n  _fire(event, data) {\n    if (this._event_handlers[event]) {\n      var i = this._event_handlers[event].length;\n      while (i--) {\n        const handler = this._event_handlers[event][i];\n        try {\n          handler(data);\n        } catch (e) {\n          console.error(e);\n        } finally {\n          if (handler.___event_run_once) {\n            this._event_handlers[event].splice(i, 1);\n          }\n        }\n      }\n    } else {\n      if (this._debug) {\n        console.warn(\"unhandled event\", event, data);\n      }\n    }\n  }\n}\n","/**\n * Contains the RPC object used both by the application\n * site, and by each plugin\n */\nimport {\n  randId,\n  typedArrayToDtype,\n  dtypeToTypedArray,\n  MessageEmitter\n} from \"./utils.js\";\n\nexport const API_VERSION = \"0.2.3\";\n\nconst ArrayBufferView = Object.getPrototypeOf(\n  Object.getPrototypeOf(new Uint8Array())\n).constructor;\n\nfunction _appendBuffer(buffer1, buffer2) {\n  const tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);\n  tmp.set(new Uint8Array(buffer1), 0);\n  tmp.set(new Uint8Array(buffer2), buffer1.byteLength);\n  return tmp.buffer;\n}\n\nfunction indexObject(obj, is) {\n  if (!is) throw new Error(\"undefined index\");\n  if (typeof is === \"string\") return indexObject(obj, is.split(\".\"));\n  else if (is.length === 0) return obj;\n  else return indexObject(obj[is[0]], is.slice(1));\n}\n\n/**\n * RPC object represents a single site in the\n * communication protocol between the application and the plugin\n *\n * @param {Object} connection a special object allowing to send\n * and receive messages from the opposite site (basically it\n * should only provide send() and onMessage() methods)\n */\nexport class RPC extends MessageEmitter {\n  constructor(connection, config, codecs) {\n    super(config && config.debug);\n    this._connection = connection;\n    this.config = config || {};\n    this._codecs = codecs || {};\n    this._object_store = {};\n    this._method_weakmap = new WeakMap();\n    this._object_weakmap = new WeakMap();\n    this._local_api = null;\n    this._remote_set = false;\n    // make sure there is an execute function\n    const name = this.config.name;\n    this._connection.execute =\n      this._connection.execute ||\n      function() {\n        throw new Error(`connection.execute not implemented (in \"${name}\")`);\n      };\n    this._store = new ReferenceStore();\n    this._method_refs = new ReferenceStore();\n    this._method_refs.onReady(() => {\n      this._fire(\"remoteIdle\");\n    });\n    this._method_refs.onBusy(() => {\n      this._fire(\"remoteBusy\");\n    });\n    this._setupMessageHanlders();\n  }\n\n  init() {\n    this._connection.emit({\n      type: \"initialized\",\n      config: this.config,\n      peer_id: this._connection.peer_id\n    });\n  }\n\n  setConfig(config) {\n    if (config)\n      for (const k of Object.keys(config)) {\n        this.config[k] = config[k];\n      }\n  }\n  /**\n   * Set a handler to be called when received a responce from the\n   * remote site reporting that the previously provided interface\n   * has been successfully set as remote for that site\n   *\n   * @param {Function} handler\n   */\n\n  getRemoteCallStack() {\n    return this._method_refs.getStack();\n  }\n\n  /**\n   * @returns {Object} set of remote interface methods\n   */\n  getRemote() {\n    return this._remote_interface;\n  }\n\n  /**\n   * Sets the interface of this site making it available to the\n   * remote site by sending a message with a set of methods names\n   *\n   * @param {Object} _interface to set\n   */\n  setInterface(_interface, config) {\n    config = config || {};\n    this.config.name = config.name || this.config.name;\n    this.config.description = config.description || this.config.description;\n    if (this.config.forwarding_functions) {\n      for (let func_name of this.config.forwarding_functions) {\n        const _remote = this._remote_interface;\n        if (_remote[func_name]) {\n          if (_interface.constructor === Object) {\n            if (!_interface[func_name]) {\n              _interface[func_name] = (...args) => {\n                _remote[func_name](...args);\n              };\n            }\n          } else if (_interface.constructor.constructor === Function) {\n            if (!_interface.constructor.prototype[func_name]) {\n              _interface.constructor.prototype[func_name] = (...args) => {\n                _remote[func_name](...args);\n              };\n            }\n          }\n        }\n      }\n    }\n    this._local_api = _interface;\n    if (!this._remote_set) this._fire(\"interfaceAvailable\");\n    else this.sendInterface();\n    return new Promise(resolve => {\n      this.once(\"interfaceSetAsRemote\", resolve);\n    });\n  }\n\n  /**\n   * Sends the actual interface to the remote site upon it was\n   * updated or by a special request of the remote site\n   */\n  sendInterface() {\n    if (!this._local_api) {\n      throw new Error(\"interface is not set.\");\n    }\n    this._encode(this._local_api, true).then(api => {\n      this._connection.emit({ type: \"setInterface\", api: api });\n    });\n  }\n\n  _disposeObject(objectId) {\n    if (this._object_store[objectId]) {\n      delete this._object_store[objectId];\n    } else {\n      throw new Error(`Object (id=${objectId}) not found.`);\n    }\n  }\n\n  disposeObject(obj) {\n    return new Promise((resolve, reject) => {\n      if (this._object_weakmap.has(obj)) {\n        const objectId = this._object_weakmap.get(obj);\n        this._connection.once(\"disposed\", data => {\n          if (data.error) reject(new Error(data.error));\n          else resolve();\n        });\n        this._connection.emit({\n          type: \"disposeObject\",\n          object_id: objectId\n        });\n      } else {\n        throw new Error(\"Invalid object\");\n      }\n    });\n  }\n\n  /**\n   * Handles a message from the remote site\n   */\n  _setupMessageHanlders() {\n    this._connection.on(\"init\", this.init);\n    this._connection.on(\"execute\", data => {\n      Promise.resolve(this._connection.execute(data.code))\n        .then(() => {\n          this._connection.emit({ type: \"executed\" });\n        })\n        .catch(e => {\n          console.error(e);\n          this._connection.emit({\n            type: \"executed\",\n            error: String(e)\n          });\n        });\n    });\n\n    this._connection.on(\"method\", async data => {\n      let resolve, reject, method, method_this, args, result;\n      try {\n        if (data.promise) {\n          [resolve, reject] = await this._unwrap(data.promise, false);\n        }\n        const _interface = this._object_store[data.object_id];\n        method = indexObject(_interface, data.name);\n        if (data.name.includes(\".\")) {\n          const tmp = data.name.split(\".\");\n          const intf_index = tmp.slice(0, tmp.length - 1).join(\".\");\n          method_this = indexObject(_interface, intf_index);\n        } else {\n          method_this = _interface;\n        }\n        args = await this._unwrap(data.args, true);\n        if (data.promise) {\n          result = method.apply(method_this, args);\n          if (\n            result instanceof Promise ||\n            (method.constructor && method.constructor.name === \"AsyncFunction\")\n          ) {\n            result.then(resolve).catch(reject);\n          } else {\n            resolve(result);\n          }\n        } else {\n          method.apply(method_this, args);\n        }\n      } catch (err) {\n        console.error(this.config.name, err);\n        if (reject) {\n          reject(err);\n        }\n      }\n    });\n\n    this._connection.on(\"callback\", async data => {\n      let resolve, reject, method, args, result;\n      try {\n        if (data.promise) {\n          [resolve, reject] = await this._unwrap(data.promise, false);\n        }\n        if (data.promise) {\n          method = this._store.fetch(data.id);\n          args = await this._unwrap(data.args, true);\n          if (!method) {\n            throw new Error(\n              \"Callback function can only called once, if you want to call a function for multiple times, please make it as a plugin api function. See https://imjoy.io/docs for more details.\"\n            );\n          }\n          result = method.apply(null, args);\n          if (\n            result instanceof Promise ||\n            (method.constructor && method.constructor.name === \"AsyncFunction\")\n          ) {\n            result.then(resolve).catch(reject);\n          } else {\n            resolve(result);\n          }\n        } else {\n          method = this._store.fetch(data.id);\n          args = await this._unwrap(data.args, true);\n          if (!method) {\n            throw new Error(\n              \"Please notice that callback function can only called once, if you want to call a function for multiple times, please make it as a plugin api function. See https://imjoy.io/docs for more details.\"\n            );\n          }\n          method.apply(null, args);\n        }\n      } catch (err) {\n        console.error(this.config.name, err);\n        if (reject) {\n          reject(err);\n        }\n      }\n    });\n    this._connection.on(\"disposeObject\", data => {\n      try {\n        this._disposeObject(data.object_id);\n        this._connection.emit({\n          type: \"disposed\"\n        });\n      } catch (e) {\n        console.error(e);\n        this._connection.emit({\n          type: \"disposed\",\n          error: String(e)\n        });\n      }\n    });\n    this._connection.on(\"setInterface\", data => {\n      this._setRemoteInterface(data.api);\n    });\n    this._connection.on(\"getInterface\", () => {\n      this._fire(\"getInterface\");\n      if (this._local_api) {\n        this.sendInterface();\n      } else {\n        this.once(\"interfaceAvailable\", () => {\n          this.sendInterface();\n        });\n      }\n    });\n    this._connection.on(\"interfaceSetAsRemote\", () => {\n      this._remote_set = true;\n      this._fire(\"interfaceSetAsRemote\");\n    });\n    this._connection.on(\"disconnect\", () => {\n      this._fire(\"beforeDisconnect\");\n      this._connection.disconnect();\n      this._fire(\"disconnected\");\n    });\n  }\n\n  /**\n   * Sends a requests to the remote site asking it to provide its\n   * current interface\n   */\n  requestRemote() {\n    this._connection.emit({ type: \"getInterface\" });\n  }\n\n  _ndarray(typedArray, shape, dtype) {\n    const _dtype = typedArrayToDtype(typedArray);\n    if (dtype && dtype !== _dtype) {\n      throw \"dtype doesn't match the type of the array: \" +\n        _dtype +\n        \" != \" +\n        dtype;\n    }\n    shape = shape || [typedArray.length];\n    return {\n      _rtype: \"ndarray\",\n      _rvalue: typedArray.buffer,\n      _rshape: shape,\n      _rdtype: _dtype\n    };\n  }\n\n  /**\n   * Sets the new remote interface provided by the other site\n   *\n   * @param {Array} names list of function names\n   */\n  _setRemoteInterface(api) {\n    this._decode(api).then(intf => {\n      // update existing interface instead of recreating it\n      // this will preserve the object reference\n      if (this._remote_interface) {\n        // clear the interface\n        for (let k in this._remote_interface) delete this._remote_interface[k];\n        // then assign the new interfaces\n        Object.assign(this._remote_interface, intf);\n      } else this._remote_interface = intf;\n      this._fire(\"remoteReady\");\n      this._reportRemoteSet();\n    });\n  }\n\n  /**\n   * Generates the wrapped function corresponding to a single remote\n   * method. When the generated function is called, it will send the\n   * corresponding message to the remote site asking it to execute\n   * the particular method of its interface\n   *\n   * @param {String} name of the remote method\n   *\n   * @returns {Function} wrapped remote method\n   */\n  _genRemoteMethod(targetId, name, objectId) {\n    const me = this;\n    const remoteMethod = function() {\n      return new Promise(async (resolve, reject) => {\n        let id = null;\n        try {\n          id = me._method_refs.put(objectId ? objectId + \"/\" + name : name);\n          const wrapped_resolve = function() {\n            if (id !== null) me._method_refs.fetch(id);\n            return resolve.apply(this, arguments);\n          };\n          const wrapped_reject = function() {\n            if (id !== null) me._method_refs.fetch(id);\n            return reject.apply(this, arguments);\n          };\n\n          const encodedPromise = await me._wrap([\n            wrapped_resolve,\n            wrapped_reject\n          ]);\n\n          // store the key id for removing them from the reference store together\n          wrapped_resolve.__promise_pair = encodedPromise[1]._rvalue;\n          wrapped_reject.__promise_pair = encodedPromise[0]._rvalue;\n\n          let args = Array.prototype.slice.call(arguments);\n          const argLength = args.length;\n          // if the last argument is an object, mark it as kwargs\n          const withKwargs =\n            argLength > 0 &&\n            typeof args[argLength - 1] === \"object\" &&\n            args[argLength - 1] !== null &&\n            args[argLength - 1]._rkwargs;\n          if (withKwargs) delete args[argLength - 1]._rkwargs;\n          if (\n            name === \"register\" ||\n            name === \"registerService\" ||\n            name === \"register_service\" ||\n            name === \"export\" ||\n            name === \"on\"\n          ) {\n            args = await me._wrap(args, true);\n          } else {\n            args = await me._wrap(args);\n          }\n          const transferables = args.__transferables__;\n          if (transferables) delete args.__transferables__;\n          me._connection.emit(\n            {\n              type: \"method\",\n              target_id: targetId,\n              name: name,\n              object_id: objectId,\n              args: args,\n              promise: encodedPromise,\n              with_kwargs: withKwargs\n            },\n            transferables\n          );\n        } catch (e) {\n          if (id) me._method_refs.fetch(id);\n          reject(\n            `Failed to exectue remote method (interface: ${objectId ||\n              me.id}, method: ${name}), error: ${e}`\n          );\n        }\n      });\n    };\n    remoteMethod.__remote_method = true;\n    return remoteMethod;\n  }\n\n  /**\n   * Sends a responce reporting that interface just provided by the\n   * remote site was successfully set by this site as remote\n   */\n  _reportRemoteSet() {\n    this._connection.emit({ type: \"interfaceSetAsRemote\" });\n  }\n\n  /**\n   * Prepares the provided set of remote method arguments for\n   * sending to the remote site, replaces all the callbacks with\n   * identifiers\n   *\n   * @param {Array} args to wrap\n   *\n   * @returns {Array} wrapped arguments\n   */\n  async _encode(aObject, asInterface, objectId) {\n    const aType = typeof aObject;\n    if (\n      aType === \"number\" ||\n      aType === \"string\" ||\n      aType === \"boolean\" ||\n      aObject === null ||\n      aObject === undefined ||\n      aObject instanceof ArrayBuffer\n    ) {\n      return aObject;\n    }\n\n    let bObject;\n    if (typeof aObject === \"function\") {\n      if (asInterface) {\n        if (!objectId) throw new Error(\"objectId is not specified.\");\n        bObject = {\n          _rtype: \"interface\",\n          _rtarget_id: this._connection.peer_id,\n          _rintf: objectId,\n          _rvalue: asInterface\n        };\n        this._method_weakmap.set(aObject, bObject);\n      } else if (this._method_weakmap.has(aObject)) {\n        bObject = this._method_weakmap.get(aObject);\n      } else {\n        const cid = this._store.put(aObject);\n        bObject = {\n          _rtype: \"callback\",\n          _rtarget_id: this._connection.peer_id,\n          _rname: (aObject.constructor && aObject.constructor.name) || cid,\n          _rvalue: cid\n        };\n      }\n      return bObject;\n    }\n\n    // skip if already encoded\n    if (aObject.constructor instanceof Object && aObject._rtype) {\n      // make sure the interface functions are encoded\n      if (aObject._rintf) {\n        const temp = aObject._rtype;\n        delete aObject._rtype;\n\n        bObject = await this._encode(aObject, asInterface, objectId);\n        bObject._rtype = temp;\n      } else {\n        bObject = aObject;\n      }\n      return bObject;\n    }\n\n    const transferables = [];\n    const _transfer = aObject._transfer;\n    const isarray = Array.isArray(aObject);\n\n    for (let tp of Object.keys(this._codecs)) {\n      const codec = this._codecs[tp];\n      if (codec.encoder && aObject instanceof codec.type) {\n        // TODO: what if multiple encoders found\n        let encodedObj = await Promise.resolve(codec.encoder(aObject));\n        if (encodedObj && !encodedObj._rtype) encodedObj._rtype = codec.name;\n        // encode the functions in the interface object\n        if (encodedObj && encodedObj._rintf) {\n          const temp = encodedObj._rtype;\n          delete encodedObj._rtype;\n          encodedObj = await this._encode(encodedObj, asInterface, objectId);\n          encodedObj._rtype = temp;\n        }\n        bObject = encodedObj;\n        return bObject;\n      }\n    }\n\n    if (\n      /*global tf*/\n      typeof tf !== \"undefined\" &&\n      tf.Tensor &&\n      aObject instanceof tf.Tensor\n    ) {\n      const v_buffer = aObject.dataSync();\n      if (aObject._transfer || _transfer) {\n        transferables.push(v_buffer.buffer);\n        delete aObject._transfer;\n      }\n      bObject = {\n        _rtype: \"ndarray\",\n        _rvalue: v_buffer.buffer,\n        _rshape: aObject.shape,\n        _rdtype: aObject.dtype\n      };\n    } else if (\n      /*global nj*/\n      typeof nj !== \"undefined\" &&\n      nj.NdArray &&\n      aObject instanceof nj.NdArray\n    ) {\n      const dtype = typedArrayToDtype(aObject.selection.data);\n      if (aObject._transfer || _transfer) {\n        transferables.push(aObject.selection.data.buffer);\n        delete aObject._transfer;\n      }\n      bObject = {\n        _rtype: \"ndarray\",\n        _rvalue: aObject.selection.data.buffer,\n        _rshape: aObject.shape,\n        _rdtype: dtype\n      };\n    } else if (aObject instanceof Error) {\n      console.error(aObject);\n      bObject = { _rtype: \"error\", _rvalue: aObject.toString() };\n    } else if (typeof File !== \"undefined\" && aObject instanceof File) {\n      bObject = {\n        _rtype: \"file\",\n        _rvalue: aObject,\n        _rpath: aObject._path || aObject.webkitRelativePath\n      };\n    }\n    // send objects supported by structure clone algorithm\n    // https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\n    else if (\n      aObject !== Object(aObject) ||\n      aObject instanceof Boolean ||\n      aObject instanceof String ||\n      aObject instanceof Date ||\n      aObject instanceof RegExp ||\n      aObject instanceof ImageData ||\n      (typeof FileList !== \"undefined\" && aObject instanceof FileList) ||\n      (typeof FileSystemDirectoryHandle !== \"undefined\" &&\n        aObject instanceof FileSystemDirectoryHandle) ||\n      (typeof FileSystemFileHandle !== \"undefined\" &&\n        aObject instanceof FileSystemFileHandle) ||\n      (typeof FileSystemHandle !== \"undefined\" &&\n        aObject instanceof FileSystemHandle) ||\n      (typeof FileSystemWritableFileStream !== \"undefined\" &&\n        aObject instanceof FileSystemWritableFileStream)\n    ) {\n      bObject = aObject;\n      // TODO: avoid object such as DynamicPlugin instance.\n    } else if (typeof File !== \"undefined\" && aObject instanceof File) {\n      bObject = {\n        _rtype: \"file\",\n        _rname: aObject.name,\n        _rmime: aObject.type,\n        _rvalue: aObject,\n        _rpath: aObject._path || aObject.webkitRelativePath\n      };\n    } else if (aObject instanceof Blob) {\n      bObject = { _rtype: \"blob\", _rvalue: aObject };\n    } else if (aObject instanceof ArrayBufferView) {\n      if (aObject._transfer || _transfer) {\n        transferables.push(aObject.buffer);\n        delete aObject._transfer;\n      }\n      const dtype = typedArrayToDtype(aObject);\n      bObject = {\n        _rtype: \"typedarray\",\n        _rvalue: aObject.buffer,\n        _rdtype: dtype\n      };\n    } else if (aObject instanceof DataView) {\n      if (aObject._transfer || _transfer) {\n        transferables.push(aObject.buffer);\n        delete aObject._transfer;\n      }\n      bObject = { _rtype: \"memoryview\", _rvalue: aObject.buffer };\n    } else if (aObject instanceof Set) {\n      bObject = {\n        _rtype: \"set\",\n        _rvalue: await this._encode(Array.from(aObject), asInterface)\n      };\n    } else if (aObject instanceof Map) {\n      bObject = {\n        _rtype: \"orderedmap\",\n        _rvalue: await this._encode(Array.from(aObject), asInterface)\n      };\n    } else if (\n      aObject.constructor instanceof Object ||\n      Array.isArray(aObject)\n    ) {\n      bObject = isarray ? [] : {};\n      let keys;\n      // an object/array\n      if (aObject.constructor === Object || Array.isArray(aObject)) {\n        keys = Object.keys(aObject);\n      }\n      // a class\n      else if (aObject.constructor === Function) {\n        throw new Error(\"Please instantiate the class before exportting it.\");\n      }\n      // instance of a class\n      else if (aObject.constructor.constructor === Function) {\n        keys = Object.getOwnPropertyNames(\n          Object.getPrototypeOf(aObject)\n        ).concat(Object.keys(aObject));\n        // TODO: use a proxy object to represent the actual object\n        // always encode class instance as interface\n        asInterface = true;\n      } else {\n        throw Error(\"Unsupported interface type\");\n      }\n\n      let hasFunction = false;\n      // encode interfaces\n      if (aObject._rintf || asInterface) {\n        if (!objectId) {\n          if (typeof aObject._rintf === \"string\" && aObject._rintf.length > 0) {\n            objectId = aObject._rintf; // enable custom object id\n          } else {\n            objectId = randId();\n          }\n          // Note: object with the same id will be overwritten\n          if (this._object_store[objectId])\n            console.warn(\n              `Overwritting interface object with the same id: ${objectId}`\n            );\n          this._object_store[objectId] = aObject;\n        }\n        for (let k of keys) {\n          if (k === \"constructor\") continue;\n          if (k.startsWith(\"_\")) {\n            continue;\n          }\n          bObject[k] = await this._encode(\n            aObject[k],\n            typeof asInterface === \"string\" ? asInterface + \".\" + k : k,\n            objectId\n          );\n          if (typeof aObject[k] === \"function\") {\n            hasFunction = true;\n          }\n        }\n        // object id for dispose the object remotely\n        if (hasFunction) bObject._rintf = objectId;\n        // remove interface when closed\n        if (aObject.on && typeof aObject.on === \"function\") {\n          aObject.on(\"close\", () => {\n            delete this._object_store[objectId];\n          });\n        }\n      } else {\n        for (let k of keys) {\n          if ([\"hasOwnProperty\", \"constructor\"].includes(k)) continue;\n          bObject[k] = await this._encode(aObject[k]);\n        }\n      }\n      // for example, browserFS object\n    } else if (typeof aObject === \"object\") {\n      const keys = Object.getOwnPropertyNames(\n        Object.getPrototypeOf(aObject)\n      ).concat(Object.keys(aObject));\n      const objectId = randId();\n\n      for (let k of keys) {\n        if ([\"hasOwnProperty\", \"constructor\"].includes(k)) continue;\n        // encode as interface\n        bObject[k] = await this._encode(aObject[k], k, bObject);\n      }\n      // object id, used for dispose the object\n      bObject._rintf = objectId;\n    } else {\n      throw \"imjoy-rpc: Unsupported data type:\" + aObject;\n    }\n\n    if (transferables.length > 0) {\n      bObject.__transferables__ = transferables;\n    }\n    if (!bObject) {\n      throw new Error(\"Failed to encode object\");\n    }\n    return bObject;\n  }\n\n  async _decode(aObject, withPromise) {\n    if (!aObject) {\n      return aObject;\n    }\n    let bObject;\n    if (aObject[\"_rtype\"]) {\n      if (\n        this._codecs[aObject._rtype] &&\n        this._codecs[aObject._rtype].decoder\n      ) {\n        if (aObject._rintf) {\n          const temp = aObject._rtype;\n          delete aObject._rtype;\n          aObject = await this._decode(aObject, withPromise);\n          aObject._rtype = temp;\n        }\n        bObject = await Promise.resolve(\n          this._codecs[aObject._rtype].decoder(aObject)\n        );\n      } else if (aObject._rtype === \"callback\") {\n        bObject = this._genRemoteCallback(\n          aObject._rtarget_id,\n          aObject._rvalue,\n          withPromise\n        );\n      } else if (aObject._rtype === \"interface\") {\n        bObject = this._genRemoteMethod(\n          aObject._rtarget_id,\n          aObject._rvalue,\n          aObject._rintf\n        );\n      } else if (aObject._rtype === \"ndarray\") {\n        /*global nj tf*/\n        //create build array/tensor if used in the plugin\n        if (typeof nj !== \"undefined\" && nj.array) {\n          if (Array.isArray(aObject._rvalue)) {\n            aObject._rvalue = aObject._rvalue.reduce(_appendBuffer);\n          }\n          bObject = nj\n            .array(new Uint8(aObject._rvalue), aObject._rdtype)\n            .reshape(aObject._rshape);\n        } else if (typeof tf !== \"undefined\" && tf.Tensor) {\n          if (Array.isArray(aObject._rvalue)) {\n            aObject._rvalue = aObject._rvalue.reduce(_appendBuffer);\n          }\n          const arraytype = dtypeToTypedArray[aObject._rdtype];\n          bObject = tf.tensor(\n            new arraytype(aObject._rvalue),\n            aObject._rshape,\n            aObject._rdtype\n          );\n        } else {\n          //keep it as regular if transfered to the main app\n          bObject = aObject;\n        }\n      } else if (aObject._rtype === \"error\") {\n        bObject = new Error(aObject._rvalue);\n      } else if (aObject._rtype === \"file\") {\n        if (aObject._rvalue instanceof File) {\n          bObject = aObject._rvalue;\n          //patch _path\n          bObject._path = aObject._rpath;\n        } else {\n          bObject = new File([aObject._rvalue], aObject._rname, {\n            type: aObject._rmime\n          });\n          bObject._path = aObject._rpath;\n        }\n      } else if (aObject._rtype === \"typedarray\") {\n        const arraytype = dtypeToTypedArray[aObject._rdtype];\n        if (!arraytype)\n          throw new Error(\"unsupported dtype: \" + aObject._rdtype);\n        bObject = new arraytype(aObject._rvalue);\n      } else if (aObject._rtype === \"memoryview\") {\n        bObject = new DataView(aObject._rvalue);\n      } else if (aObject._rtype === \"blob\") {\n        if (aObject._rvalue instanceof Blob) {\n          bObject = aObject._rvalue;\n        } else {\n          bObject = new Blob([aObject._rvalue], { type: aObject._rmime });\n        }\n      } else if (aObject._rtype === \"orderedmap\") {\n        bObject = new Map(await this._decode(aObject._rvalue, withPromise));\n      } else if (aObject._rtype === \"set\") {\n        bObject = new Set(await this._decode(aObject._rvalue, withPromise));\n      } else {\n        // make sure all the interface functions are decoded\n        if (aObject._rintf) {\n          const temp = aObject._rtype;\n          delete aObject._rtype;\n          bObject = await this._decode(aObject, withPromise);\n          bObject._rtype = temp;\n        } else bObject = aObject;\n      }\n    } else if (aObject.constructor === Object || Array.isArray(aObject)) {\n      const isarray = Array.isArray(aObject);\n      bObject = isarray ? [] : {};\n      for (let k of Object.keys(aObject)) {\n        if (isarray || aObject.hasOwnProperty(k)) {\n          const v = aObject[k];\n          bObject[k] = await this._decode(v, withPromise);\n        }\n      }\n    } else {\n      bObject = aObject;\n    }\n    if (bObject === undefined) {\n      throw new Error(\"Failed to decode object\");\n    }\n    // store the object id for dispose\n    if (aObject._rintf) {\n      this._object_weakmap.set(bObject, aObject._rintf);\n    }\n    return bObject;\n  }\n\n  async _wrap(args, asInterface) {\n    return await this._encode(args, asInterface);\n  }\n\n  /**\n   * Unwraps the set of arguments delivered from the remote site,\n   * replaces all callback identifiers with a function which will\n   * initiate sending that callback identifier back to other site\n   *\n   * @param {Object} args to unwrap\n   *\n   * @param {Boolean} withPromise is true means this the callback should contain a promise\n   *\n   * @returns {Array} unwrapped args\n   */\n  async _unwrap(args, withPromise) {\n    return await this._decode(args, withPromise);\n  }\n\n  /**\n   * Generates the wrapped function corresponding to a single remote\n   * callback. When the generated function is called, it will send\n   * the corresponding message to the remote site asking it to\n   * execute the particular callback previously saved during a call\n   * by the remote site a method from the interface of this site\n   *\n   * @param {Number} id of the remote callback to execute\n   * @param {Number} argNum argument index of the callback\n   * @param {Boolean} withPromise is true means this the callback should contain a promise\n   *\n   * @returns {Function} wrapped remote callback\n   */\n  _genRemoteCallback(targetId, cid, withPromise) {\n    const me = this;\n    let remoteCallback;\n    if (withPromise) {\n      remoteCallback = function() {\n        return new Promise(async (resolve, reject) => {\n          const args = await me._wrap(Array.prototype.slice.call(arguments));\n          const argLength = args.length;\n          // if the last argument is an object, mark it as kwargs\n          const withKwargs =\n            argLength > 0 &&\n            typeof args[argLength - 1] === \"object\" &&\n            args[argLength - 1] !== null &&\n            args[argLength - 1]._rkwargs;\n          if (withKwargs) delete args[argLength - 1]._rkwargs;\n          const transferables = args.__transferables__;\n          if (transferables) delete args.__transferables__;\n\n          const encodedPromise = await me._wrap([resolve, reject]);\n          // store the key id for removing them from the reference store together\n          resolve.__promise_pair = encodedPromise[1]._rvalue;\n          reject.__promise_pair = encodedPromise[0]._rvalue;\n          try {\n            me._connection.emit(\n              {\n                type: \"callback\",\n                target_id: targetId,\n                id: cid,\n                args: args,\n                promise: encodedPromise,\n                with_kwargs: withKwargs\n              },\n              transferables\n            );\n          } catch (e) {\n            reject(`Failed to exectue remote callback ( id: ${cid}).`);\n          }\n        });\n      };\n      return remoteCallback;\n    } else {\n      remoteCallback = async function() {\n        const args = await me._wrap(Array.prototype.slice.call(arguments));\n        const argLength = args.length;\n        // if the last argument is an object, mark it as kwargs\n        const withKwargs =\n          argLength > 0 &&\n          typeof args[argLength - 1] === \"object\" &&\n          args[argLength - 1] !== null &&\n          args[argLength - 1]._rkwargs;\n        if (withKwargs) delete args[argLength - 1]._rkwargs;\n        const transferables = args.__transferables__;\n        if (transferables) delete args.__transferables__;\n        return me._connection.emit(\n          {\n            type: \"callback\",\n            target_id: targetId,\n            id: cid,\n            args: args,\n            with_kwargs: withKwargs\n          },\n          transferables\n        );\n      };\n      return remoteCallback;\n    }\n  }\n\n  reset() {\n    this._event_handlers = {};\n    this._once_handlers = {};\n    this._remote_interface = null;\n    this._object_store = {};\n    this._method_weakmap = new WeakMap();\n    this._object_weakmap = new WeakMap();\n    this._local_api = null;\n    this._store = new ReferenceStore();\n    this._method_refs = new ReferenceStore();\n  }\n\n  /**\n   * Sends the notification message and breaks the connection\n   */\n  disconnect() {\n    this._connection.emit({ type: \"disconnect\" });\n    this.reset();\n    setTimeout(() => {\n      this._connection.disconnect();\n    }, 2000);\n  }\n}\n\n/**\n * ReferenceStore is a special object which stores other objects\n * and provides the references (number) instead. This reference\n * may then be sent over a json-based communication channel (IPC\n * to another Node.js process or a message to the Worker). Other\n * site may then provide the reference in the responce message\n * implying the given object should be activated.\n *\n * Primary usage for the ReferenceStore is a storage for the\n * callbacks, which therefore makes it possible to initiate a\n * callback execution by the opposite site (which normally cannot\n * directly execute functions over the communication channel).\n *\n * Each stored object can only be fetched once and is not\n * available for the second time. Each stored object must be\n * fetched, since otherwise it will remain stored forever and\n * consume memory.\n *\n * Stored object indeces are simply the numbers, which are however\n * released along with the objects, and are later reused again (in\n * order to postpone the overflow, which should not likely happen,\n * but anyway).\n */\nclass ReferenceStore {\n  constructor() {\n    this._store = {}; // stored object\n    this._indices = [0]; // smallest available indices\n    this._readyHandler = function() {};\n    this._busyHandler = function() {};\n    this._readyHandler();\n  }\n\n  /**\n   * call handler when the store is empty\n   *\n   * @param {FUNCTION} id of a handler\n   */\n  onReady(readyHandler) {\n    this._readyHandler = readyHandler || function() {};\n  }\n\n  /**\n   * call handler when the store is not empty\n   *\n   * @param {FUNCTION} id of a handler\n   */\n  onBusy(busyHandler) {\n    this._busyHandler = busyHandler || function() {};\n  }\n\n  /**\n   * get the length of the store\n   *\n   */\n  getStack() {\n    return Object.keys(this._store).length;\n  }\n\n  /**\n   * @function _genId() generates the new reference id\n   *\n   * @returns {Number} smallest available id and reserves it\n   */\n  _genId() {\n    let id;\n    if (this._indices.length === 1) {\n      id = this._indices[0]++;\n    } else {\n      id = this._indices.shift();\n    }\n\n    return id;\n  }\n\n  /**\n   * Releases the given reference id so that it will be available by\n   * another object stored\n   *\n   * @param {Number} id to release\n   */\n  _releaseId(id) {\n    for (let i = 0; i < this._indices.length; i++) {\n      if (id < this._indices[i]) {\n        this._indices.splice(i, 0, id);\n        break;\n      }\n    }\n\n    // cleaning-up the sequence tail\n    for (let i = this._indices.length - 1; i >= 0; i--) {\n      if (this._indices[i] - 1 === this._indices[i - 1]) {\n        this._indices.pop();\n      } else {\n        break;\n      }\n    }\n  }\n\n  /**\n   * Stores the given object and returns the refernce id instead\n   *\n   * @param {Object} obj to store\n   *\n   * @returns {Number} reference id of the stored object\n   */\n  put(obj) {\n    if (this._busyHandler && Object.keys(this._store).length === 0) {\n      this._busyHandler();\n    }\n    const id = this._genId();\n    this._store[id] = obj;\n    return id;\n  }\n\n  /**\n   * Retrieves previously stored object and releases its reference\n   *\n   * @param {Number} id of an object to retrieve\n   */\n  fetch(id) {\n    const obj = this._store[id];\n    if (obj && !obj.__remote_method) {\n      delete this._store[id];\n      this._releaseId(id);\n      if (this._readyHandler && Object.keys(this._store).length === 0) {\n        this._readyHandler();\n      }\n    }\n    if (obj && obj.__promise_pair) {\n      this.fetch(obj.__promise_pair);\n    }\n    return obj;\n  }\n}\n","\n/**\n * Expose `Emitter`.\n */\n\nexports.Emitter = Emitter;\n\n/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nfunction Emitter(obj) {\n  if (obj) return mixin(obj);\n}\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in Emitter.prototype) {\n    obj[key] = Emitter.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on =\nEmitter.prototype.addEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\n    .push(fn);\n  return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function(event, fn){\n  function on() {\n    this.off(event, on);\n    fn.apply(this, arguments);\n  }\n\n  on.fn = fn;\n  this.on(event, on);\n  return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off =\nEmitter.prototype.removeListener =\nEmitter.prototype.removeAllListeners =\nEmitter.prototype.removeEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n\n  // all\n  if (0 == arguments.length) {\n    this._callbacks = {};\n    return this;\n  }\n\n  // specific event\n  var callbacks = this._callbacks['$' + event];\n  if (!callbacks) return this;\n\n  // remove all handlers\n  if (1 == arguments.length) {\n    delete this._callbacks['$' + event];\n    return this;\n  }\n\n  // remove specific handler\n  var cb;\n  for (var i = 0; i < callbacks.length; i++) {\n    cb = callbacks[i];\n    if (cb === fn || cb.fn === fn) {\n      callbacks.splice(i, 1);\n      break;\n    }\n  }\n\n  // Remove event specific arrays for event types that no\n  // one is subscribed for to avoid memory leak.\n  if (callbacks.length === 0) {\n    delete this._callbacks['$' + event];\n  }\n\n  return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function(event){\n  this._callbacks = this._callbacks || {};\n\n  var args = new Array(arguments.length - 1)\n    , callbacks = this._callbacks['$' + event];\n\n  for (var i = 1; i < arguments.length; i++) {\n    args[i - 1] = arguments[i];\n  }\n\n  if (callbacks) {\n    callbacks = callbacks.slice(0);\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\n      callbacks[i].apply(this, args);\n    }\n  }\n\n  return this;\n};\n\n// alias used for reserved events (protected method)\nEmitter.prototype.emitReserved = Emitter.prototype.emit;\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function(event){\n  this._callbacks = this._callbacks || {};\n  return this._callbacks['$' + event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function(event){\n  return !! this.listeners(event).length;\n};\n","export default (() => {\n    if (typeof self !== \"undefined\") {\n        return self;\n    }\n    else if (typeof window !== \"undefined\") {\n        return window;\n    }\n    else {\n        return Function(\"return this\")();\n    }\n})();\n","import globalThis from \"./globalThis.js\";\nexport function pick(obj, ...attr) {\n    return attr.reduce((acc, k) => {\n        if (obj.hasOwnProperty(k)) {\n            acc[k] = obj[k];\n        }\n        return acc;\n    }, {});\n}\n// Keep a reference to the real timeout functions so they can be used when overridden\nconst NATIVE_SET_TIMEOUT = setTimeout;\nconst NATIVE_CLEAR_TIMEOUT = clearTimeout;\nexport function installTimerFunctions(obj, opts) {\n    if (opts.useNativeTimers) {\n        obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThis);\n        obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThis);\n    }\n    else {\n        obj.setTimeoutFn = setTimeout.bind(globalThis);\n        obj.clearTimeoutFn = clearTimeout.bind(globalThis);\n    }\n}\n","/**\n * Contains the routines loaded by the plugin iframe under web-browser\n * in case when worker failed to initialize\n *\n * Initializes the web environment version of the platform-dependent\n * connection object for the plugin site\n */\nimport { connectRPC } from \"./pluginCore.js\";\nimport { API_VERSION } from \"./rpc.js\";\nimport { loadRequirementsInWindow, MessageEmitter, randId } from \"./utils.js\";\n// Create a new, plain <span> element\nfunction _htmlToElement(html) {\n  var template = document.createElement(\"template\");\n  html = html.trim(); // Never return a text node of whitespace as the result\n  template.innerHTML = html;\n  return template.content.firstChild;\n}\n\nconst _inWebWorker =\n  typeof WorkerGlobalScope !== \"undefined\" && self instanceof WorkerGlobalScope;\n\nasync function executeEsModule(content) {\n  const dataUri =\n    \"data:text/javascript;charset=utf-8,\" + encodeURIComponent(content);\n  await import(/* webpackIgnore: true */ dataUri);\n}\n\nexport class Connection extends MessageEmitter {\n  constructor(config) {\n    super(config && config.debug);\n    this.config = config || {};\n    this.peer_id = randId();\n  }\n  connect() {\n    this.config.target_origin = this.config.target_origin || \"*\";\n    // this will call handleEvent function\n    if (this.config.broadcastChannel) {\n      this.broadcastChannel = new BroadcastChannel(\n        this.config.broadcastChannel\n      );\n    } else {\n      this.broadcastChannel = null;\n    }\n    if (this.broadcastChannel)\n      this.broadcastChannel.addEventListener(\"message\", this);\n    else globalThis.addEventListener(\"message\", this);\n    this.emit({\n      type: \"initialized\",\n      config: this.config,\n      origin: globalThis.location.origin,\n      peer_id: this.peer_id\n    });\n    this._fire(\"connected\");\n  }\n  handleEvent(e) {\n    if (\n      e.type === \"message\" &&\n      (this.broadcastChannel ||\n        this.config.target_origin === \"*\" ||\n        !e.origin ||\n        e.origin === this.config.target_origin)\n    ) {\n      if (e.data.peer_id === this.peer_id) {\n        this._fire(e.data.type, e.data);\n      } else if (this.config.debug) {\n        console.log(\n          `connection peer id mismatch ${e.data.peer_id} !== ${this.peer_id}`\n        );\n      }\n    }\n  }\n  disconnect() {\n    this._fire(\"beforeDisconnect\");\n    globalThis.removeEventListener(\"message\", this);\n    this._fire(\"disconnected\");\n  }\n  emit(data) {\n    let transferables;\n    if (this.broadcastChannel) this.broadcastChannel.postMessage(data);\n    else {\n      if (data.__transferables__) {\n        transferables = data.__transferables__;\n        delete data.__transferables__;\n      } else if (_inWebWorker) self.postMessage(data, transferables);\n      else parent.postMessage(data, this.config.target_origin, transferables);\n    }\n  }\n  async execute(code) {\n    try {\n      if (code.type === \"requirements\") {\n        await loadRequirementsInWindow(code.requirements);\n      } else if (code.type === \"script\") {\n        if (code.src) {\n          var script_node = document.createElement(\"script\");\n          script_node.setAttribute(\"type\", code.attrs.type);\n          script_node.setAttribute(\"src\", code.src);\n          document.head.appendChild(script_node);\n        } else {\n          if (code.content && code.attrs.lang === \"javascript\") {\n            // document.addEventListener(\"DOMContentLoaded\", function(){\n            if (code.attrs.type === \"module\") {\n              await executeEsModule(code.content);\n            } else {\n              eval(code.content);\n            }\n            // });\n          } else {\n            var node = document.createElement(\"script\");\n            for (let k in code.attrs) {\n              node.setAttribute(k, code.attrs[k]);\n            }\n            node.appendChild(document.createTextNode(code.content));\n            document.body.appendChild(node);\n          }\n        }\n      } else if (code.type === \"style\") {\n        const style_node = document.createElement(\"style\");\n        if (code.src) {\n          style_node.src = code.src;\n        }\n        style_node.innerHTML = code.content;\n        document.head.appendChild(style_node);\n      } else if (code.type === \"link\") {\n        const link_node_ = document.createElement(\"link\");\n        if (code.rel) {\n          link_node_.rel = code.rel;\n        }\n        if (code.href) {\n          link_node_.href = code.href;\n        }\n        if (code.attrs && code.attrs.type) {\n          link_node_.type = code.attrs.type;\n        }\n        document.head.appendChild(link_node_);\n      } else if (code.type === \"html\") {\n        document.body.appendChild(_htmlToElement(code.content));\n      } else {\n        throw \"unsupported code type.\";\n      }\n      if (_inWebWorker) self.postMessage({ type: \"executed\" });\n      else parent.postMessage({ type: \"executed\" }, this.config.target_origin);\n    } catch (e) {\n      console.error(\"failed to execute scripts: \", code, e);\n      if (_inWebWorker)\n        self.postMessage({ type: \"executed\", error: e.stack || String(e) });\n      else\n        parent.postMessage(\n          { type: \"executed\", error: e.stack || String(e) },\n          this.config.target_origin\n        );\n    }\n  }\n}\n\nexport default function setupIframe(config) {\n  config = config || {};\n  config.dedicated_thread = false;\n  config.lang = \"javascript\";\n  config.api_version = API_VERSION;\n  const conn = new Connection(config);\n  connectRPC(conn, config);\n  conn.connect();\n}\n","import globalThis from \"../globalThis.js\";\nexport const nextTick = (() => {\n    const isPromiseAvailable = typeof Promise === \"function\" && typeof Promise.resolve === \"function\";\n    if (isPromiseAvailable) {\n        return cb => Promise.resolve().then(cb);\n    }\n    else {\n        return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);\n    }\n})();\nexport const WebSocket = globalThis.WebSocket || globalThis.MozWebSocket;\nexport const usingBrowserWebSocket = true;\nexport const defaultBinaryType = \"arraybuffer\";\n","const PACKET_TYPES = Object.create(null); // no Map = no polyfill\nPACKET_TYPES[\"open\"] = \"0\";\nPACKET_TYPES[\"close\"] = \"1\";\nPACKET_TYPES[\"ping\"] = \"2\";\nPACKET_TYPES[\"pong\"] = \"3\";\nPACKET_TYPES[\"message\"] = \"4\";\nPACKET_TYPES[\"upgrade\"] = \"5\";\nPACKET_TYPES[\"noop\"] = \"6\";\nconst PACKET_TYPES_REVERSE = Object.create(null);\nObject.keys(PACKET_TYPES).forEach(key => {\n    PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;\n});\nconst ERROR_PACKET = { type: \"error\", data: \"parser error\" };\nexport { PACKET_TYPES, PACKET_TYPES_REVERSE, ERROR_PACKET };\n","import { PACKET_TYPES } from \"./commons.js\";\nconst withNativeBlob = typeof Blob === \"function\" ||\n    (typeof Blob !== \"undefined\" &&\n        Object.prototype.toString.call(Blob) === \"[object BlobConstructor]\");\nconst withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\n// ArrayBuffer.isView method is not defined in IE10\nconst isView = obj => {\n    return typeof ArrayBuffer.isView === \"function\"\n        ? ArrayBuffer.isView(obj)\n        : obj && obj.buffer instanceof ArrayBuffer;\n};\nconst encodePacket = ({ type, data }, supportsBinary, callback) => {\n    if (withNativeBlob && data instanceof Blob) {\n        if (supportsBinary) {\n            return callback(data);\n        }\n        else {\n            return encodeBlobAsBase64(data, callback);\n        }\n    }\n    else if (withNativeArrayBuffer &&\n        (data instanceof ArrayBuffer || isView(data))) {\n        if (supportsBinary) {\n            return callback(data);\n        }\n        else {\n            return encodeBlobAsBase64(new Blob([data]), callback);\n        }\n    }\n    // plain string\n    return callback(PACKET_TYPES[type] + (data || \"\"));\n};\nconst encodeBlobAsBase64 = (data, callback) => {\n    const fileReader = new FileReader();\n    fileReader.onload = function () {\n        const content = fileReader.result.split(\",\")[1];\n        callback(\"b\" + content);\n    };\n    return fileReader.readAsDataURL(data);\n};\nexport default encodePacket;\n","/*\n * base64-arraybuffer 1.0.1 <https://github.com/niklasvh/base64-arraybuffer>\n * Copyright (c) 2022 Niklas von Hertzen <https://hertzen.com>\n * Released under MIT License\n */\nvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n// Use a lookup table to find the index.\nvar lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);\nfor (var i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n}\nvar encode = function (arraybuffer) {\n    var bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';\n    for (i = 0; i < len; i += 3) {\n        base64 += chars[bytes[i] >> 2];\n        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n        base64 += chars[bytes[i + 2] & 63];\n    }\n    if (len % 3 === 2) {\n        base64 = base64.substring(0, base64.length - 1) + '=';\n    }\n    else if (len % 3 === 1) {\n        base64 = base64.substring(0, base64.length - 2) + '==';\n    }\n    return base64;\n};\nvar decode = function (base64) {\n    var bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;\n    if (base64[base64.length - 1] === '=') {\n        bufferLength--;\n        if (base64[base64.length - 2] === '=') {\n            bufferLength--;\n        }\n    }\n    var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);\n    for (i = 0; i < len; i += 4) {\n        encoded1 = lookup[base64.charCodeAt(i)];\n        encoded2 = lookup[base64.charCodeAt(i + 1)];\n        encoded3 = lookup[base64.charCodeAt(i + 2)];\n        encoded4 = lookup[base64.charCodeAt(i + 3)];\n        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n    return arraybuffer;\n};\n\nexport { decode, encode };\n//# sourceMappingURL=base64-arraybuffer.es5.js.map\n","import { ERROR_PACKET, PACKET_TYPES_REVERSE } from \"./commons.js\";\nimport { decode } from \"@socket.io/base64-arraybuffer\";\nconst withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\nconst decodePacket = (encodedPacket, binaryType) => {\n    if (typeof encodedPacket !== \"string\") {\n        return {\n            type: \"message\",\n            data: mapBinary(encodedPacket, binaryType)\n        };\n    }\n    const type = encodedPacket.charAt(0);\n    if (type === \"b\") {\n        return {\n            type: \"message\",\n            data: decodeBase64Packet(encodedPacket.substring(1), binaryType)\n        };\n    }\n    const packetType = PACKET_TYPES_REVERSE[type];\n    if (!packetType) {\n        return ERROR_PACKET;\n    }\n    return encodedPacket.length > 1\n        ? {\n            type: PACKET_TYPES_REVERSE[type],\n            data: encodedPacket.substring(1)\n        }\n        : {\n            type: PACKET_TYPES_REVERSE[type]\n        };\n};\nconst decodeBase64Packet = (data, binaryType) => {\n    if (withNativeArrayBuffer) {\n        const decoded = decode(data);\n        return mapBinary(decoded, binaryType);\n    }\n    else {\n        return { base64: true, data }; // fallback for old browsers\n    }\n};\nconst mapBinary = (data, binaryType) => {\n    switch (binaryType) {\n        case \"blob\":\n            return data instanceof ArrayBuffer ? new Blob([data]) : data;\n        case \"arraybuffer\":\n        default:\n            return data; // assuming the data is already an ArrayBuffer\n    }\n};\nexport default decodePacket;\n","import encodePacket from \"./encodePacket.js\";\nimport decodePacket from \"./decodePacket.js\";\nconst SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text\nconst encodePayload = (packets, callback) => {\n    // some packets may be added to the array while encoding, so the initial length must be saved\n    const length = packets.length;\n    const encodedPackets = new Array(length);\n    let count = 0;\n    packets.forEach((packet, i) => {\n        // force base64 encoding for binary packets\n        encodePacket(packet, false, encodedPacket => {\n            encodedPackets[i] = encodedPacket;\n            if (++count === length) {\n                callback(encodedPackets.join(SEPARATOR));\n            }\n        });\n    });\n};\nconst decodePayload = (encodedPayload, binaryType) => {\n    const encodedPackets = encodedPayload.split(SEPARATOR);\n    const packets = [];\n    for (let i = 0; i < encodedPackets.length; i++) {\n        const decodedPacket = decodePacket(encodedPackets[i], binaryType);\n        packets.push(decodedPacket);\n        if (decodedPacket.type === \"error\") {\n            break;\n        }\n    }\n    return packets;\n};\nexport const protocol = 4;\nexport { encodePacket, encodePayload, decodePacket, decodePayload };\n","/**\n * Core plugin script loaded into the plugin process/thread.\n *\n * Initializes the plugin-site API global methods.\n */\nimport { RPC } from \"./rpc.js\";\n\nexport function connectRPC(connection, config) {\n  config = config || {};\n  const codecs = {};\n\n  const rpc = new RPC(connection, config, codecs);\n  rpc.on(\"getInterface\", function() {\n    launchConnected();\n  });\n\n  rpc.on(\"remoteReady\", function() {\n    const api = rpc.getRemote() || {};\n    api.registerCodec = function(config) {\n      if (!config[\"name\"] || (!config[\"encoder\"] && !config[\"decoder\"])) {\n        throw new Error(\n          \"Invalid codec format, please make sure you provide a name, type, encoder and decoder.\"\n        );\n      } else {\n        if (config.type) {\n          for (let k of Object.keys(codecs)) {\n            if (codecs[k].type === config.type || k === config.name) {\n              delete codecs[k];\n              console.warn(\"Remove duplicated codec: \" + k);\n            }\n          }\n        }\n        codecs[config[\"name\"]] = config;\n      }\n    };\n    api.init = function(config) {\n      // register a minimal plugin api\n      rpc.setInterface({ setup() {} }, config);\n    };\n    api.disposeObject = function(obj) {\n      rpc.disposeObject(obj);\n    };\n    api.export = function(_interface, config) {\n      rpc.setInterface(_interface, config);\n    };\n    api.onLoad = function(handler) {\n      handler = checkHandler(handler);\n      if (connected) {\n        handler();\n      } else {\n        connectedHandlers.push(handler);\n      }\n    };\n    api.dispose = function(_interface) {\n      rpc.disconnect();\n    };\n    api._rpc = rpc;\n\n    if (\n      typeof WorkerGlobalScope !== \"undefined\" &&\n      self instanceof WorkerGlobalScope\n    ) {\n      self.api = api;\n      self.postMessage({\n        type: \"imjoy_remote_api_ready\"\n      });\n      self.dispatchEvent(\n        new CustomEvent(\"imjoy_remote_api_ready\", { detail: api })\n      );\n    } else if (typeof window) {\n      window.dispatchEvent(\n        new CustomEvent(\"imjoy_remote_api_ready\", { detail: api })\n      );\n    }\n  });\n\n  let connected = false;\n  const connectedHandlers = [];\n\n  const launchConnected = function() {\n    if (!connected) {\n      connected = true;\n\n      let handler;\n      while ((handler = connectedHandlers.pop())) {\n        handler();\n      }\n    }\n  };\n\n  const checkHandler = function(handler) {\n    const type = typeof handler;\n    if (type !== \"function\") {\n      const msg =\n        \"A function may only be subsribed to the event, \" +\n        type +\n        \" was provided instead\";\n      throw new Error(msg);\n    }\n    return handler;\n  };\n\n  return rpc;\n}\n","import { decodePacket } from \"engine.io-parser\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nimport { installTimerFunctions } from \"./util.js\";\nexport class Transport extends Emitter {\n    /**\n     * Transport abstract constructor.\n     *\n     * @param {Object} options.\n     * @api private\n     */\n    constructor(opts) {\n        super();\n        this.writable = false;\n        installTimerFunctions(this, opts);\n        this.opts = opts;\n        this.query = opts.query;\n        this.readyState = \"\";\n        this.socket = opts.socket;\n    }\n    /**\n     * Emits an error.\n     *\n     * @param {String} str\n     * @return {Transport} for chaining\n     * @api protected\n     */\n    onError(msg, desc) {\n        const err = new Error(msg);\n        // @ts-ignore\n        err.type = \"TransportError\";\n        // @ts-ignore\n        err.description = desc;\n        super.emit(\"error\", err);\n        return this;\n    }\n    /**\n     * Opens the transport.\n     *\n     * @api public\n     */\n    open() {\n        if (\"closed\" === this.readyState || \"\" === this.readyState) {\n            this.readyState = \"opening\";\n            this.doOpen();\n        }\n        return this;\n    }\n    /**\n     * Closes the transport.\n     *\n     * @api public\n     */\n    close() {\n        if (\"opening\" === this.readyState || \"open\" === this.readyState) {\n            this.doClose();\n            this.onClose();\n        }\n        return this;\n    }\n    /**\n     * Sends multiple packets.\n     *\n     * @param {Array} packets\n     * @api public\n     */\n    send(packets) {\n        if (\"open\" === this.readyState) {\n            this.write(packets);\n        }\n        else {\n            // this might happen if the transport was silently closed in the beforeunload event handler\n        }\n    }\n    /**\n     * Called upon open\n     *\n     * @api protected\n     */\n    onOpen() {\n        this.readyState = \"open\";\n        this.writable = true;\n        super.emit(\"open\");\n    }\n    /**\n     * Called with data.\n     *\n     * @param {String} data\n     * @api protected\n     */\n    onData(data) {\n        const packet = decodePacket(data, this.socket.binaryType);\n        this.onPacket(packet);\n    }\n    /**\n     * Called with a decoded packet.\n     *\n     * @api protected\n     */\n    onPacket(packet) {\n        super.emit(\"packet\", packet);\n    }\n    /**\n     * Called upon close.\n     *\n     * @api protected\n     */\n    onClose() {\n        this.readyState = \"closed\";\n        super.emit(\"close\");\n    }\n}\n","/**\n * Compiles a querystring\n * Returns string representation of the object\n *\n * @param {Object}\n * @api private\n */\n\nexports.encode = function (obj) {\n  var str = '';\n\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      if (str.length) str += '&';\n      str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\n    }\n  }\n\n  return str;\n};\n\n/**\n * Parses a simple querystring into an object\n *\n * @param {String} qs\n * @api private\n */\n\nexports.decode = function(qs){\n  var qry = {};\n  var pairs = qs.split('&');\n  for (var i = 0, l = pairs.length; i < l; i++) {\n    var pair = pairs[i].split('=');\n    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\n  }\n  return qry;\n};\n","/**\n * Contains the code executed in the sandboxed frame under web-browser\n *\n * Tries to create a Web-Worker inside the frame and set up the\n * communication between the worker and the parent window. Some\n * browsers restrict creating a worker inside a sandboxed iframe - if\n * this happens, the plugin initialized right inside the frame (in the\n * same thread)\n */\nimport PluginWorker from \"./plugin.webworker.js\";\nimport setupIframe from \"./pluginIframe.js\";\nimport {\n  randId,\n  normalizeConfig,\n  setupServiceWorker,\n  loadRequirements\n} from \"./utils.js\";\n\nexport { RPC, API_VERSION } from \"./rpc.js\";\nexport { version as VERSION } from \"../package.json\";\nexport { loadRequirements };\n\nfunction _inIframe() {\n  try {\n    return window.self !== window.top;\n  } catch (e) {\n    return true;\n  }\n}\n\nfunction _inWebWorker() {\n  return (\n    typeof WorkerGlobalScope !== \"undefined\" &&\n    self instanceof WorkerGlobalScope\n  );\n}\n\n/**\n * Initializes the plugin inside a web worker. May throw an exception\n * in case this was not permitted by the browser.\n */\nfunction setupWebWorker(config) {\n  if (!config.allow_execution)\n    throw new Error(\n      \"web-worker plugin can only work with allow_execution=true\"\n    );\n  let broadcastChannel = null;\n  if (config.broadcastChannel) {\n    broadcastChannel = new BroadcastChannel(config.broadcastChannel);\n  }\n  const worker = new PluginWorker();\n  // mixed content warning in Chrome silently skips worker\n  // initialization without exception, handling this with timeout\n  const fallbackTimeout = setTimeout(function() {\n    worker.terminate();\n    console.warn(\n      `Plugin failed to start as a web-worker, running in an iframe instead.`\n    );\n    setupIframe(config);\n  }, 2000);\n  const peer_id = randId();\n\n  // forwarding messages between the worker and parent window\n  worker.addEventListener(\"message\", function(e) {\n    let transferables = undefined;\n    const m = e.data;\n    if (m.type === \"worker-ready\") {\n      // send config to the worker\n      worker.postMessage({ type: \"connectRPC\", config: config });\n      clearTimeout(fallbackTimeout);\n      return;\n    } else if (m.type === \"initialized\") {\n      // complete the missing fields\n      m.config = Object.assign({}, config, m.config);\n      m.origin = window.location.origin;\n      m.peer_id = peer_id;\n    } else if (m.type === \"imjoy_remote_api_ready\") {\n      // if it's a webworker, there will be no api object returned\n      window.dispatchEvent(\n        new CustomEvent(\"imjoy_remote_api_ready\", { detail: null })\n      );\n    } else if (\n      m.type === \"cacheRequirements\" &&\n      typeof cache_requirements === \"function\"\n    ) {\n      cache_requirements(m.requirements);\n    } else if (m.type === \"disconnect\") {\n      worker.terminate();\n    } else {\n      if (m.__transferables__) {\n        transferables = m.__transferables__;\n        delete m.__transferables__;\n      }\n    }\n    if (broadcastChannel) broadcastChannel.postMessage(m);\n    else parent.postMessage(m, config.target_origin || \"*\", transferables);\n  });\n\n  (broadcastChannel || window).addEventListener(\"message\", function(e) {\n    if (\n      e.type === \"message\" &&\n      (broadcastChannel ||\n        config.target_origin === \"*\" ||\n        e.origin === config.target_origin)\n    ) {\n      let transferables = undefined;\n      const m = e.data;\n      if (m.__transferables__) {\n        transferables = m.__transferables__;\n        delete m.__transferables__;\n      }\n      if (m.peer_id === peer_id) {\n        worker.postMessage(m, transferables);\n      } else if (config.debug) {\n        console.log(`connection peer id mismatch ${m.peer_id} !== ${peer_id}`);\n      }\n    }\n  });\n}\n\nexport function waitForInitialization(config) {\n  if (_inWebWorker()) {\n    globalThis.parent = self;\n  }\n  config = config || {};\n  if (config.enable_service_worker) {\n    setupServiceWorker(\n      config.base_url,\n      config.target_origin,\n      config.cache_requirements\n    );\n    config.enable_service_worker = false;\n  }\n  if (config.cache_requirements) {\n    delete config.cache_requirements;\n  }\n  const targetOrigin = config.target_origin || \"*\";\n  if (\n    config.credential_required &&\n    typeof config.verify_credential !== \"function\"\n  ) {\n    throw new Error(\n      \"Please also provide the `verify_credential` function with `credential_required`.\"\n    );\n  }\n  if (config.credential_required && targetOrigin === \"*\") {\n    throw new Error(\n      \"`target_origin` was set to `*` with `credential_required=true`, there is a security risk that you may leak the credential to website from other origin. Please specify the `target_origin` explicitly.\"\n    );\n  }\n  const done = () => {\n    globalThis.removeEventListener(\"message\", handleEvent);\n  };\n  const peer_id = randId();\n  const handleEvent = e => {\n    if (\n      e.type === \"message\" &&\n      (!e.origin || targetOrigin === \"*\" || e.origin === targetOrigin)\n    ) {\n      if (e.data.type === \"initialize\") {\n        done();\n        if (e.data.peer_id !== peer_id) {\n          // TODO: throw an error when we are sure all the peers will send the peer_id\n          console.warn(\n            `${e.data.config &&\n              e.data.config.name}: connection peer id mismatch ${\n              e.data.peer_id\n            } !== ${peer_id}`\n          );\n        }\n        const cfg = e.data.config;\n        // override the target_origin setting if it's configured by the rpc client\n        // otherwise take the setting from the core\n        if (targetOrigin !== \"*\") {\n          cfg.target_origin = targetOrigin;\n        }\n        if (config.credential_required) {\n          config.verify_credential(cfg.credential).then(result => {\n            if (result && result.auth && !result.error) {\n              // pass the authentication information with tokens\n              cfg.auth = result.auth;\n              setupRPC(cfg).then(() => {\n                console.log(\"ImJoy RPC loaded successfully!\");\n              });\n            } else {\n              throw new Error(\n                \"Failed to verify the credentail:\" + (result && result.error)\n              );\n            }\n          });\n        } else {\n          setupRPC(cfg).then(() => {\n            console.log(\"ImJoy RPC loaded successfully!\");\n          });\n        }\n      } else {\n        throw new Error(`unrecognized message: ${e.data}`);\n      }\n    }\n  };\n  globalThis.addEventListener(\"message\", handleEvent);\n\n  if (_inWebWorker()) {\n    parent.postMessage({\n      type: \"imjoyRPCReady\",\n      config: config,\n      peer_id: peer_id\n    });\n  } else {\n    parent.postMessage(\n      { type: \"imjoyRPCReady\", config: config, peer_id: peer_id },\n      \"*\"\n    );\n  }\n}\n\nexport function setupRPC(config) {\n  config = config || {};\n  config.name = config.name || randId();\n  config = normalizeConfig(config);\n  if (config.enable_service_worker) {\n    setupServiceWorker(\n      config.base_url,\n      config.target_origin,\n      config.cache_requirements\n    );\n  }\n  if (config.cache_requirements) {\n    delete config.cache_requirements;\n  }\n  return new Promise((resolve, reject) => {\n    const handleEvent = e => {\n      const api = e.detail;\n      if (config.expose_api_globally) {\n        globalThis.api = api;\n      }\n      // imjoy plugin api\n      resolve(api);\n      globalThis.removeEventListener(\"imjoy_remote_api_ready\", handleEvent);\n    };\n    if (_inIframe()) {\n      if (config.type === \"web-worker\") {\n        try {\n          setupWebWorker(config);\n        } catch (e) {\n          // fallback to iframe\n          setupIframe(config);\n        }\n      } else if (\n        [\"rpc-window\", \"rpc-worker\", \"iframe\", \"window\"].includes(config.type)\n      ) {\n        setupIframe(config);\n      } else {\n        console.error(\"Unsupported plugin type: \" + config.type);\n        reject(\"Unsupported plugin type: \" + config.type);\n        return;\n      }\n      globalThis.addEventListener(\"imjoy_remote_api_ready\", handleEvent);\n    } else if (_inWebWorker()) {\n      // inside a webworker\n      setupIframe(config);\n    } else {\n      reject(\n        new Error(\"imjoy-rpc should only run inside an iframe or a webworker.\")\n      );\n    }\n  });\n}\n","module.exports = function() {\n  return require(\"!!/home/runner/work/imjoy-rpc/imjoy-rpc/javascript/node_modules/worker-loader/dist/workers/InlineWorker.js\")(\"!function(e){var t={};function r(n){if(t[n])return t[n].exports;var i=t[n]={i:n,l:!1,exports:{}};return e[n].call(i.exports,i,i.exports,r),i.l=!0,i.exports}r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){\\\"undefined\\\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:\\\"Module\\\"}),Object.defineProperty(e,\\\"__esModule\\\",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&\\\"object\\\"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,\\\"default\\\",{enumerable:!0,value:e}),2&t&&\\\"string\\\"!=typeof e)for(var i in e)r.d(n,i,function(t){return e[t]}.bind(null,i));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,\\\"a\\\",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p=\\\"\\\",r(r.s=3)}([function(module,__webpack_exports__,__webpack_require__){\\\"use strict\\\";function randId(){return Math.random().toString(36).substr(2,10)+(new Date).getTime()}__webpack_require__.d(__webpack_exports__,\\\"d\\\",(function(){return randId})),__webpack_require__.d(__webpack_exports__,\\\"b\\\",(function(){return dtypeToTypedArray})),__webpack_require__.d(__webpack_exports__,\\\"c\\\",(function(){return loadRequirementsInWebworker})),__webpack_require__.d(__webpack_exports__,\\\"e\\\",(function(){return typedArrayToDtype})),__webpack_require__.d(__webpack_exports__,\\\"a\\\",(function(){return MessageEmitter}));const dtypeToTypedArray={int8:Int8Array,int16:Int16Array,int32:Int32Array,uint8:Uint8Array,uint16:Uint16Array,uint32:Uint32Array,float32:Float32Array,float64:Float64Array,array:Array};async function loadRequirementsInWindow(e){function t(e){return new Promise((t,r)=>{var n=document.createElement(\\\"script\\\");n.src=e,n.type=\\\"text/javascript\\\",n.onload=t,n.onreadystatechange=function(){\\\"loaded\\\"!==this.readyState&&\\\"complete\\\"!==this.readyState||t()},n.onerror=r,document.head.appendChild(n)})}async function r(){for(var e=Array.prototype.slice.call(arguments),r=e.length,n=0;n<r;n++)await t(e[n])}if(e&&(Array.isArray(e)||\\\"string\\\"==typeof e))try{var n;if(e=\\\"string\\\"==typeof e?[e]:e,!Array.isArray(e))throw\\\"unsupported requirements definition\\\";for(var i=0;i<e.length;i++)e[i].toLowerCase().endsWith(\\\".css\\\")||e[i].startsWith(\\\"css:\\\")?(e[i].startsWith(\\\"css:\\\")&&(e[i]=e[i].slice(4)),(n=document.createElement(\\\"link\\\")).rel=\\\"stylesheet\\\",n.href=e[i],document.head.appendChild(n)):e[i].toLowerCase().endsWith(\\\".mjs\\\")||e[i].startsWith(\\\"mjs:\\\")?(e[i].startsWith(\\\"mjs:\\\")&&(e[i]=e[i].slice(4)),await import(e[i])):e[i].toLowerCase().endsWith(\\\".js\\\")||e[i].startsWith(\\\"js:\\\")?(e[i].startsWith(\\\"js:\\\")&&(e[i]=e[i].slice(3)),await r(e[i])):e[i].startsWith(\\\"http\\\")?await r(e[i]):e[i].startsWith(\\\"cache:\\\")||console.log(\\\"Unprocessed requirements url: \\\"+e[i])}catch(t){throw\\\"failed to import required scripts: \\\"+e.toString()}}async function loadRequirementsInWebworker(e){if(e&&(Array.isArray(e)||\\\"string\\\"==typeof e))try{Array.isArray(e)||(e=[e]);for(var t=0;t<e.length;t++){if(e[t].toLowerCase().endsWith(\\\".css\\\")||e[t].startsWith(\\\"css:\\\"))throw\\\"unable to import css in a webworker\\\";e[t].toLowerCase().endsWith(\\\".js\\\")||e[t].startsWith(\\\"js:\\\")?(e[t].startsWith(\\\"js:\\\")&&(e[t]=e[t].slice(3)),importScripts(e[t])):e[t].startsWith(\\\"http\\\")?importScripts(e[t]):e[t].startsWith(\\\"cache:\\\")||console.log(\\\"Unprocessed requirements url: \\\"+e[t])}}catch(t){throw\\\"failed to import required scripts: \\\"+e.toString()}}function loadRequirements(e){return\\\"undefined\\\"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?loadRequirementsInWebworker(e):loadRequirementsInWindow(e)}function normalizeConfig(e){return e.version=e.version||\\\"0.1.0\\\",e.description=e.description||`[TODO: add description for ${e.name} ]`,e.type=e.type||\\\"rpc-window\\\",e.id=e.id||randId(),e.target_origin=e.target_origin||\\\"*\\\",e.allow_execution=e.allow_execution||!1,e=Object.keys(e).reduce((t,r)=>(\\\"function\\\"!=typeof e[r]&&(t[r]=e[r]),t),{})}const typedArrayToDtypeMapping={Int8Array:\\\"int8\\\",Int16Array:\\\"int16\\\",Int32Array:\\\"int32\\\",Uint8Array:\\\"uint8\\\",Uint16Array:\\\"uint16\\\",Uint32Array:\\\"uint32\\\",Float32Array:\\\"float32\\\",Float64Array:\\\"float64\\\",Array:\\\"array\\\"},typedArrayToDtypeKeys=[];for(const arrType of Object.keys(typedArrayToDtypeMapping))typedArrayToDtypeKeys.push(eval(arrType));function typedArrayToDtype(e){let t=typedArrayToDtypeMapping[e.constructor.name];if(!t){const r=Object.getPrototypeOf(e);for(const e of typedArrayToDtypeKeys)if(r instanceof e){t=typedArrayToDtypeMapping[e.name];break}}return t}function cacheUrlInServiceWorker(e){return new Promise((function(t,r){const n={command:\\\"add\\\",url:e};if(!navigator.serviceWorker||!navigator.serviceWorker.register)return void r(\\\"Service worker is not supported.\\\");const i=new MessageChannel;i.port1.onmessage=function(e){e.data&&e.data.error?r(e.data.error):t(e.data&&e.data.result)},navigator.serviceWorker&&navigator.serviceWorker.controller?navigator.serviceWorker.controller.postMessage(n,[i.port2]):r(\\\"Service worker controller is not available\\\")}))}async function cacheRequirements(e){e=e||[],Array.isArray(e)||(e=[e]);for(let t of e)t.startsWith(\\\"js:\\\")&&(t=t.slice(3)),t.startsWith(\\\"css:\\\")&&(t=t.slice(4)),t.startsWith(\\\"cache:\\\")&&(t=t.slice(6)),t.startsWith(\\\"http\\\")&&await cacheUrlInServiceWorker(t).catch(e=>{console.error(e)})}function setupServiceWorker(e,t,r){if(\\\"serviceWorker\\\"in navigator){if(e=e||\\\"/\\\",navigator.serviceWorker.register(e+\\\"plugin-service-worker.js\\\").then((function(e){console.log(\\\"ServiceWorker registration successful with scope: \\\",e.scope)}),(function(e){console.log(\\\"ServiceWorker registration failed: \\\",e)})),t=t||\\\"*\\\",(r=r||cacheRequirements)&&\\\"function\\\"!=typeof r)throw new Error(\\\"config.cache_requirements must be a function\\\");window.addEventListener(\\\"message\\\",(function(e){if(\\\"*\\\"===t||e.origin===t){const t=e.data;\\\"cacheRequirements\\\"===t.type&&r(t.requirements)}}))}}function urlJoin(...e){return e.join(\\\"/\\\").replace(/[\\\\/]+/g,\\\"/\\\").replace(/^(.+):\\\\//,\\\"$1://\\\").replace(/^file:/,\\\"file:/\\\").replace(/\\\\/(\\\\?|&|#[^!])/g,\\\"$1\\\").replace(/\\\\?/g,\\\"&\\\").replace(\\\"&\\\",\\\"?\\\")}class MessageEmitter{constructor(e){this._event_handlers={},this._once_handlers={},this._debug=e}emit(){throw new Error(\\\"emit is not implemented\\\")}on(e,t){this._event_handlers[e]||(this._event_handlers[e]=[]),this._event_handlers[e].push(t)}once(e,t){t.___event_run_once=!0,this.on(e,t)}off(e,t){if(e||t){if(e&&!t)this._event_handlers[e]&&(this._event_handlers[e]=[]);else if(this._event_handlers[e]){const r=this._event_handlers[e].indexOf(t);r>=0&&this._event_handlers[e].splice(r,1)}}else this._event_handlers={}}_fire(e,t){if(this._event_handlers[e])for(var r=this._event_handlers[e].length;r--;){const n=this._event_handlers[e][r];try{n(t)}catch(e){console.error(e)}finally{n.___event_run_once&&this._event_handlers[e].splice(r,1)}}else this._debug&&console.warn(\\\"unhandled event\\\",e,t)}}},function(e,t,r){\\\"use strict\\\";r.d(t,\\\"a\\\",(function(){return i})),r.d(t,\\\"b\\\",(function(){return c}));var n=r(0);const i=\\\"0.2.3\\\",o=Object.getPrototypeOf(Object.getPrototypeOf(new Uint8Array)).constructor;function s(e,t){const r=new Uint8Array(e.byteLength+t.byteLength);return r.set(new Uint8Array(e),0),r.set(new Uint8Array(t),e.byteLength),r.buffer}function a(e,t){if(!t)throw new Error(\\\"undefined index\\\");return\\\"string\\\"==typeof t?a(e,t.split(\\\".\\\")):0===t.length?e:a(e[t[0]],t.slice(1))}class c extends n.a{constructor(e,t,r){super(t&&t.debug),this._connection=e,this.config=t||{},this._codecs=r||{},this._object_store={},this._method_weakmap=new WeakMap,this._object_weakmap=new WeakMap,this._local_api=null,this._remote_set=!1;const n=this.config.name;this._connection.execute=this._connection.execute||function(){throw new Error(`connection.execute not implemented (in \\\"${n}\\\")`)},this._store=new _,this._method_refs=new _,this._method_refs.onReady(()=>{this._fire(\\\"remoteIdle\\\")}),this._method_refs.onBusy(()=>{this._fire(\\\"remoteBusy\\\")}),this._setupMessageHanlders()}init(){this._connection.emit({type:\\\"initialized\\\",config:this.config,peer_id:this._connection.peer_id})}setConfig(e){if(e)for(const t of Object.keys(e))this.config[t]=e[t]}getRemoteCallStack(){return this._method_refs.getStack()}getRemote(){return this._remote_interface}setInterface(e,t){if(t=t||{},this.config.name=t.name||this.config.name,this.config.description=t.description||this.config.description,this.config.forwarding_functions)for(let t of this.config.forwarding_functions){const r=this._remote_interface;r[t]&&(e.constructor===Object?e[t]||(e[t]=(...e)=>{r[t](...e)}):e.constructor.constructor===Function&&(e.constructor.prototype[t]||(e.constructor.prototype[t]=(...e)=>{r[t](...e)})))}return this._local_api=e,this._remote_set?this.sendInterface():this._fire(\\\"interfaceAvailable\\\"),new Promise(e=>{this.once(\\\"interfaceSetAsRemote\\\",e)})}sendInterface(){if(!this._local_api)throw new Error(\\\"interface is not set.\\\");this._encode(this._local_api,!0).then(e=>{this._connection.emit({type:\\\"setInterface\\\",api:e})})}_disposeObject(e){if(!this._object_store[e])throw new Error(`Object (id=${e}) not found.`);delete this._object_store[e]}disposeObject(e){return new Promise((t,r)=>{if(!this._object_weakmap.has(e))throw new Error(\\\"Invalid object\\\");{const n=this._object_weakmap.get(e);this._connection.once(\\\"disposed\\\",e=>{e.error?r(new Error(e.error)):t()}),this._connection.emit({type:\\\"disposeObject\\\",object_id:n})}})}_setupMessageHanlders(){this._connection.on(\\\"init\\\",this.init),this._connection.on(\\\"execute\\\",e=>{Promise.resolve(this._connection.execute(e.code)).then(()=>{this._connection.emit({type:\\\"executed\\\"})}).catch(e=>{console.error(e),this._connection.emit({type:\\\"executed\\\",error:String(e)})})}),this._connection.on(\\\"method\\\",async e=>{let t,r,n,i,o,s;try{e.promise&&([t,r]=await this._unwrap(e.promise,!1));const c=this._object_store[e.object_id];if(n=a(c,e.name),e.name.includes(\\\".\\\")){const t=e.name.split(\\\".\\\");i=a(c,t.slice(0,t.length-1).join(\\\".\\\"))}else i=c;o=await this._unwrap(e.args,!0),e.promise?(s=n.apply(i,o),s instanceof Promise||n.constructor&&\\\"AsyncFunction\\\"===n.constructor.name?s.then(t).catch(r):t(s)):n.apply(i,o)}catch(e){console.error(this.config.name,e),r&&r(e)}}),this._connection.on(\\\"callback\\\",async e=>{let t,r,n,i,o;try{if(e.promise&&([t,r]=await this._unwrap(e.promise,!1)),e.promise){if(n=this._store.fetch(e.id),i=await this._unwrap(e.args,!0),!n)throw new Error(\\\"Callback function can only called once, if you want to call a function for multiple times, please make it as a plugin api function. See https://imjoy.io/docs for more details.\\\");o=n.apply(null,i),o instanceof Promise||n.constructor&&\\\"AsyncFunction\\\"===n.constructor.name?o.then(t).catch(r):t(o)}else{if(n=this._store.fetch(e.id),i=await this._unwrap(e.args,!0),!n)throw new Error(\\\"Please notice that callback function can only called once, if you want to call a function for multiple times, please make it as a plugin api function. See https://imjoy.io/docs for more details.\\\");n.apply(null,i)}}catch(e){console.error(this.config.name,e),r&&r(e)}}),this._connection.on(\\\"disposeObject\\\",e=>{try{this._disposeObject(e.object_id),this._connection.emit({type:\\\"disposed\\\"})}catch(e){console.error(e),this._connection.emit({type:\\\"disposed\\\",error:String(e)})}}),this._connection.on(\\\"setInterface\\\",e=>{this._setRemoteInterface(e.api)}),this._connection.on(\\\"getInterface\\\",()=>{this._fire(\\\"getInterface\\\"),this._local_api?this.sendInterface():this.once(\\\"interfaceAvailable\\\",()=>{this.sendInterface()})}),this._connection.on(\\\"interfaceSetAsRemote\\\",()=>{this._remote_set=!0,this._fire(\\\"interfaceSetAsRemote\\\")}),this._connection.on(\\\"disconnect\\\",()=>{this._fire(\\\"beforeDisconnect\\\"),this._connection.disconnect(),this._fire(\\\"disconnected\\\")})}requestRemote(){this._connection.emit({type:\\\"getInterface\\\"})}_ndarray(e,t,r){const i=Object(n.e)(e);if(r&&r!==i)throw\\\"dtype doesn't match the type of the array: \\\"+i+\\\" != \\\"+r;return t=t||[e.length],{_rtype:\\\"ndarray\\\",_rvalue:e.buffer,_rshape:t,_rdtype:i}}_setRemoteInterface(e){this._decode(e).then(e=>{if(this._remote_interface){for(let e in this._remote_interface)delete this._remote_interface[e];Object.assign(this._remote_interface,e)}else this._remote_interface=e;this._fire(\\\"remoteReady\\\"),this._reportRemoteSet()})}_genRemoteMethod(e,t,r){const n=this,i=function(){return new Promise(async(i,o)=>{let s=null;try{s=n._method_refs.put(r?r+\\\"/\\\"+t:t);const a=function(){return null!==s&&n._method_refs.fetch(s),i.apply(this,arguments)},c=function(){return null!==s&&n._method_refs.fetch(s),o.apply(this,arguments)},_=await n._wrap([a,c]);a.__promise_pair=_[1]._rvalue,c.__promise_pair=_[0]._rvalue;let l=Array.prototype.slice.call(arguments);const f=l.length,d=f>0&&\\\"object\\\"==typeof l[f-1]&&null!==l[f-1]&&l[f-1]._rkwargs;d&&delete l[f-1]._rkwargs,l=\\\"register\\\"===t||\\\"registerService\\\"===t||\\\"register_service\\\"===t||\\\"export\\\"===t||\\\"on\\\"===t?await n._wrap(l,!0):await n._wrap(l);const p=l.__transferables__;p&&delete l.__transferables__,n._connection.emit({type:\\\"method\\\",target_id:e,name:t,object_id:r,args:l,promise:_,with_kwargs:d},p)}catch(e){s&&n._method_refs.fetch(s),o(`Failed to exectue remote method (interface: ${r||n.id}, method: ${t}), error: ${e}`)}})};return i.__remote_method=!0,i}_reportRemoteSet(){this._connection.emit({type:\\\"interfaceSetAsRemote\\\"})}async _encode(e,t,r){const i=typeof e;if(\\\"number\\\"===i||\\\"string\\\"===i||\\\"boolean\\\"===i||null==e||e instanceof ArrayBuffer)return e;let s;if(\\\"function\\\"==typeof e){if(t){if(!r)throw new Error(\\\"objectId is not specified.\\\");s={_rtype:\\\"interface\\\",_rtarget_id:this._connection.peer_id,_rintf:r,_rvalue:t},this._method_weakmap.set(e,s)}else if(this._method_weakmap.has(e))s=this._method_weakmap.get(e);else{const t=this._store.put(e);s={_rtype:\\\"callback\\\",_rtarget_id:this._connection.peer_id,_rname:e.constructor&&e.constructor.name||t,_rvalue:t}}return s}if(e.constructor instanceof Object&&e._rtype){if(e._rintf){const n=e._rtype;delete e._rtype,s=await this._encode(e,t,r),s._rtype=n}else s=e;return s}const a=[],c=e._transfer,_=Array.isArray(e);for(let n of Object.keys(this._codecs)){const i=this._codecs[n];if(i.encoder&&e instanceof i.type){let n=await Promise.resolve(i.encoder(e));if(n&&!n._rtype&&(n._rtype=i.name),n&&n._rintf){const e=n._rtype;delete n._rtype,n=await this._encode(n,t,r),n._rtype=e}return s=n,s}}if(\\\"undefined\\\"!=typeof tf&&tf.Tensor&&e instanceof tf.Tensor){const t=e.dataSync();(e._transfer||c)&&(a.push(t.buffer),delete e._transfer),s={_rtype:\\\"ndarray\\\",_rvalue:t.buffer,_rshape:e.shape,_rdtype:e.dtype}}else if(\\\"undefined\\\"!=typeof nj&&nj.NdArray&&e instanceof nj.NdArray){const t=Object(n.e)(e.selection.data);(e._transfer||c)&&(a.push(e.selection.data.buffer),delete e._transfer),s={_rtype:\\\"ndarray\\\",_rvalue:e.selection.data.buffer,_rshape:e.shape,_rdtype:t}}else if(e instanceof Error)console.error(e),s={_rtype:\\\"error\\\",_rvalue:e.toString()};else if(\\\"undefined\\\"!=typeof File&&e instanceof File)s={_rtype:\\\"file\\\",_rvalue:e,_rpath:e._path||e.webkitRelativePath};else if(e!==Object(e)||e instanceof Boolean||e instanceof String||e instanceof Date||e instanceof RegExp||e instanceof ImageData||\\\"undefined\\\"!=typeof FileList&&e instanceof FileList||\\\"undefined\\\"!=typeof FileSystemDirectoryHandle&&e instanceof FileSystemDirectoryHandle||\\\"undefined\\\"!=typeof FileSystemFileHandle&&e instanceof FileSystemFileHandle||\\\"undefined\\\"!=typeof FileSystemHandle&&e instanceof FileSystemHandle||\\\"undefined\\\"!=typeof FileSystemWritableFileStream&&e instanceof FileSystemWritableFileStream)s=e;else if(\\\"undefined\\\"!=typeof File&&e instanceof File)s={_rtype:\\\"file\\\",_rname:e.name,_rmime:e.type,_rvalue:e,_rpath:e._path||e.webkitRelativePath};else if(e instanceof Blob)s={_rtype:\\\"blob\\\",_rvalue:e};else if(e instanceof o){(e._transfer||c)&&(a.push(e.buffer),delete e._transfer);const t=Object(n.e)(e);s={_rtype:\\\"typedarray\\\",_rvalue:e.buffer,_rdtype:t}}else if(e instanceof DataView)(e._transfer||c)&&(a.push(e.buffer),delete e._transfer),s={_rtype:\\\"memoryview\\\",_rvalue:e.buffer};else if(e instanceof Set)s={_rtype:\\\"set\\\",_rvalue:await this._encode(Array.from(e),t)};else if(e instanceof Map)s={_rtype:\\\"orderedmap\\\",_rvalue:await this._encode(Array.from(e),t)};else if(e.constructor instanceof Object||Array.isArray(e)){let i;if(s=_?[]:{},e.constructor===Object||Array.isArray(e))i=Object.keys(e);else{if(e.constructor===Function)throw new Error(\\\"Please instantiate the class before exportting it.\\\");if(e.constructor.constructor!==Function)throw Error(\\\"Unsupported interface type\\\");i=Object.getOwnPropertyNames(Object.getPrototypeOf(e)).concat(Object.keys(e)),t=!0}let o=!1;if(e._rintf||t){r||(r=\\\"string\\\"==typeof e._rintf&&e._rintf.length>0?e._rintf:Object(n.d)(),this._object_store[r]&&console.warn(\\\"Overwritting interface object with the same id: \\\"+r),this._object_store[r]=e);for(let n of i)\\\"constructor\\\"!==n&&(n.startsWith(\\\"_\\\")||(s[n]=await this._encode(e[n],\\\"string\\\"==typeof t?t+\\\".\\\"+n:n,r),\\\"function\\\"==typeof e[n]&&(o=!0)));o&&(s._rintf=r),e.on&&\\\"function\\\"==typeof e.on&&e.on(\\\"close\\\",()=>{delete this._object_store[r]})}else for(let t of i)[\\\"hasOwnProperty\\\",\\\"constructor\\\"].includes(t)||(s[t]=await this._encode(e[t]))}else{if(\\\"object\\\"!=typeof e)throw\\\"imjoy-rpc: Unsupported data type:\\\"+e;{const t=Object.getOwnPropertyNames(Object.getPrototypeOf(e)).concat(Object.keys(e)),r=Object(n.d)();for(let r of t)[\\\"hasOwnProperty\\\",\\\"constructor\\\"].includes(r)||(s[r]=await this._encode(e[r],r,s));s._rintf=r}}if(a.length>0&&(s.__transferables__=a),!s)throw new Error(\\\"Failed to encode object\\\");return s}async _decode(e,t){if(!e)return e;let r;if(e._rtype)if(this._codecs[e._rtype]&&this._codecs[e._rtype].decoder){if(e._rintf){const r=e._rtype;delete e._rtype,(e=await this._decode(e,t))._rtype=r}r=await Promise.resolve(this._codecs[e._rtype].decoder(e))}else if(\\\"callback\\\"===e._rtype)r=this._genRemoteCallback(e._rtarget_id,e._rvalue,t);else if(\\\"interface\\\"===e._rtype)r=this._genRemoteMethod(e._rtarget_id,e._rvalue,e._rintf);else if(\\\"ndarray\\\"===e._rtype)if(\\\"undefined\\\"!=typeof nj&&nj.array)Array.isArray(e._rvalue)&&(e._rvalue=e._rvalue.reduce(s)),r=nj.array(new Uint8(e._rvalue),e._rdtype).reshape(e._rshape);else if(\\\"undefined\\\"!=typeof tf&&tf.Tensor){Array.isArray(e._rvalue)&&(e._rvalue=e._rvalue.reduce(s));const t=n.b[e._rdtype];r=tf.tensor(new t(e._rvalue),e._rshape,e._rdtype)}else r=e;else if(\\\"error\\\"===e._rtype)r=new Error(e._rvalue);else if(\\\"file\\\"===e._rtype)e._rvalue instanceof File?(r=e._rvalue,r._path=e._rpath):(r=new File([e._rvalue],e._rname,{type:e._rmime}),r._path=e._rpath);else if(\\\"typedarray\\\"===e._rtype){const t=n.b[e._rdtype];if(!t)throw new Error(\\\"unsupported dtype: \\\"+e._rdtype);r=new t(e._rvalue)}else if(\\\"memoryview\\\"===e._rtype)r=new DataView(e._rvalue);else if(\\\"blob\\\"===e._rtype)r=e._rvalue instanceof Blob?e._rvalue:new Blob([e._rvalue],{type:e._rmime});else if(\\\"orderedmap\\\"===e._rtype)r=new Map(await this._decode(e._rvalue,t));else if(\\\"set\\\"===e._rtype)r=new Set(await this._decode(e._rvalue,t));else if(e._rintf){const n=e._rtype;delete e._rtype,r=await this._decode(e,t),r._rtype=n}else r=e;else if(e.constructor===Object||Array.isArray(e)){const n=Array.isArray(e);r=n?[]:{};for(let i of Object.keys(e))if(n||e.hasOwnProperty(i)){const n=e[i];r[i]=await this._decode(n,t)}}else r=e;if(void 0===r)throw new Error(\\\"Failed to decode object\\\");return e._rintf&&this._object_weakmap.set(r,e._rintf),r}async _wrap(e,t){return await this._encode(e,t)}async _unwrap(e,t){return await this._decode(e,t)}_genRemoteCallback(e,t,r){const n=this;let i;return r?(i=function(){return new Promise(async(r,i)=>{const o=await n._wrap(Array.prototype.slice.call(arguments)),s=o.length,a=s>0&&\\\"object\\\"==typeof o[s-1]&&null!==o[s-1]&&o[s-1]._rkwargs;a&&delete o[s-1]._rkwargs;const c=o.__transferables__;c&&delete o.__transferables__;const _=await n._wrap([r,i]);r.__promise_pair=_[1]._rvalue,i.__promise_pair=_[0]._rvalue;try{n._connection.emit({type:\\\"callback\\\",target_id:e,id:t,args:o,promise:_,with_kwargs:a},c)}catch(e){i(`Failed to exectue remote callback ( id: ${t}).`)}})},i):(i=async function(){const r=await n._wrap(Array.prototype.slice.call(arguments)),i=r.length,o=i>0&&\\\"object\\\"==typeof r[i-1]&&null!==r[i-1]&&r[i-1]._rkwargs;o&&delete r[i-1]._rkwargs;const s=r.__transferables__;return s&&delete r.__transferables__,n._connection.emit({type:\\\"callback\\\",target_id:e,id:t,args:r,with_kwargs:o},s)},i)}reset(){this._event_handlers={},this._once_handlers={},this._remote_interface=null,this._object_store={},this._method_weakmap=new WeakMap,this._object_weakmap=new WeakMap,this._local_api=null,this._store=new _,this._method_refs=new _}disconnect(){this._connection.emit({type:\\\"disconnect\\\"}),this.reset(),setTimeout(()=>{this._connection.disconnect()},2e3)}}class _{constructor(){this._store={},this._indices=[0],this._readyHandler=function(){},this._busyHandler=function(){},this._readyHandler()}onReady(e){this._readyHandler=e||function(){}}onBusy(e){this._busyHandler=e||function(){}}getStack(){return Object.keys(this._store).length}_genId(){let e;return e=1===this._indices.length?this._indices[0]++:this._indices.shift(),e}_releaseId(e){for(let t=0;t<this._indices.length;t++)if(e<this._indices[t]){this._indices.splice(t,0,e);break}for(let e=this._indices.length-1;e>=0&&this._indices[e]-1===this._indices[e-1];e--)this._indices.pop()}put(e){this._busyHandler&&0===Object.keys(this._store).length&&this._busyHandler();const t=this._genId();return this._store[t]=e,t}fetch(e){const t=this._store[e];return t&&!t.__remote_method&&(delete this._store[e],this._releaseId(e),this._readyHandler&&0===Object.keys(this._store).length&&this._readyHandler()),t&&t.__promise_pair&&this.fetch(t.__promise_pair),t}}},function(e,t,r){\\\"use strict\\\";r.d(t,\\\"a\\\",(function(){return i}));var n=r(1);function i(e,t){t=t||{};const r={},i=new n.b(e,t,r);i.on(\\\"getInterface\\\",(function(){a()})),i.on(\\\"remoteReady\\\",(function(){const e=i.getRemote()||{};e.registerCodec=function(e){if(!e.name||!e.encoder&&!e.decoder)throw new Error(\\\"Invalid codec format, please make sure you provide a name, type, encoder and decoder.\\\");if(e.type)for(let t of Object.keys(r))r[t].type!==e.type&&t!==e.name||(delete r[t],console.warn(\\\"Remove duplicated codec: \\\"+t));r[e.name]=e},e.init=function(e){i.setInterface({setup(){}},e)},e.disposeObject=function(e){i.disposeObject(e)},e.export=function(e,t){i.setInterface(e,t)},e.onLoad=function(e){e=c(e),o?e():s.push(e)},e.dispose=function(e){i.disconnect()},e._rpc=i,\\\"undefined\\\"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?(self.api=e,self.postMessage({type:\\\"imjoy_remote_api_ready\\\"}),self.dispatchEvent(new CustomEvent(\\\"imjoy_remote_api_ready\\\",{detail:e}))):window.dispatchEvent(new CustomEvent(\\\"imjoy_remote_api_ready\\\",{detail:e}))}));let o=!1;const s=[],a=function(){if(!o){let e;for(o=!0;e=s.pop();)e()}},c=function(e){const t=typeof e;if(\\\"function\\\"!==t){throw new Error(\\\"A function may only be subsribed to the event, \\\"+t+\\\" was provided instead\\\")}return e};return i}},function(module,__webpack_exports__,__webpack_require__){\\\"use strict\\\";__webpack_require__.r(__webpack_exports__);var _pluginCore_js__WEBPACK_IMPORTED_MODULE_0__=__webpack_require__(2),_rpc_js__WEBPACK_IMPORTED_MODULE_1__=__webpack_require__(1),_utils_js__WEBPACK_IMPORTED_MODULE_2__=__webpack_require__(0);if(!(\\\"undefined\\\"!=typeof WorkerGlobalScope&&self&&self instanceof WorkerGlobalScope))throw new Error(\\\"This script can only loaded in a webworker\\\");async function executeEsModule(e){const t=\\\"data:text/javascript;charset=utf-8,\\\"+encodeURIComponent(e);await import(t)}class Connection extends _utils_js__WEBPACK_IMPORTED_MODULE_2__.a{constructor(e){super(e&&e.debug),this.config=e||{}}connect(){self.addEventListener(\\\"message\\\",e=>{this._fire(e.data.type,e.data)}),this.emit({type:\\\"initialized\\\",config:this.config})}disconnect(){this._fire(\\\"beforeDisconnect\\\"),self.close(),this._fire(\\\"disconnected\\\")}emit(e){let t=void 0;e.__transferables__&&(t=e.__transferables__,delete e.__transferables__),self.postMessage(e,t)}async execute(code){if(\\\"requirements\\\"===code.type)await Object(_utils_js__WEBPACK_IMPORTED_MODULE_2__.c)(code.requirements);else{if(\\\"script\\\"!==code.type)throw\\\"unsupported code type.\\\";try{\\\"module\\\"===code.attrs.type?await executeEsModule(code.content):eval(code.content)}catch(e){throw console.error(e.message,e.stack),e}}\\\"requirements\\\"===code.type&&self.postMessage({type:\\\"cacheRequirements\\\",requirements:code.requirements})}}const config={type:\\\"web-worker\\\",dedicated_thread:!0,allow_execution:!0,lang:\\\"javascript\\\",api_version:_rpc_js__WEBPACK_IMPORTED_MODULE_1__.a},conn=new Connection(config);conn.on(\\\"connectRPC\\\",e=>{Object(_pluginCore_js__WEBPACK_IMPORTED_MODULE_0__.a)(conn,Object.assign(e.config,config))}),conn.connect(),self.postMessage({type:\\\"worker-ready\\\"})}]);\\n//# sourceMappingURL=plugin.webworker.js.map\", null);\n};","/**\n * Parses an URI\n *\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\n * @api private\n */\n\nvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\n\nvar parts = [\n    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\n];\n\nmodule.exports = function parseuri(str) {\n    var src = str,\n        b = str.indexOf('['),\n        e = str.indexOf(']');\n\n    if (b != -1 && e != -1) {\n        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\n    }\n\n    var m = re.exec(str || ''),\n        uri = {},\n        i = 14;\n\n    while (i--) {\n        uri[parts[i]] = m[i] || '';\n    }\n\n    if (b != -1 && e != -1) {\n        uri.source = src;\n        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\n        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\n        uri.ipv6uri = true;\n    }\n\n    uri.pathNames = pathNames(uri, uri['path']);\n    uri.queryKey = queryKey(uri, uri['query']);\n\n    return uri;\n};\n\nfunction pathNames(obj, path) {\n    var regx = /\\/{2,9}/g,\n        names = path.replace(regx, \"/\").split(\"/\");\n\n    if (path.substr(0, 1) == '/' || path.length === 0) {\n        names.splice(0, 1);\n    }\n    if (path.substr(path.length - 1, 1) == '/') {\n        names.splice(names.length - 1, 1);\n    }\n\n    return names;\n}\n\nfunction queryKey(uri, query) {\n    var data = {};\n\n    query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {\n        if ($1) {\n            data[$1] = $2;\n        }\n    });\n\n    return data;\n}\n","'use strict';\n\nvar alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')\n  , length = 64\n  , map = {}\n  , seed = 0\n  , i = 0\n  , prev;\n\n/**\n * Return a string representing the specified number.\n *\n * @param {Number} num The number to convert.\n * @returns {String} The string representation of the number.\n * @api public\n */\nfunction encode(num) {\n  var encoded = '';\n\n  do {\n    encoded = alphabet[num % length] + encoded;\n    num = Math.floor(num / length);\n  } while (num > 0);\n\n  return encoded;\n}\n\n/**\n * Return the integer value specified by the given string.\n *\n * @param {String} str The string to convert.\n * @returns {Number} The integer value represented by the string.\n * @api public\n */\nfunction decode(str) {\n  var decoded = 0;\n\n  for (i = 0; i < str.length; i++) {\n    decoded = decoded * length + map[str.charAt(i)];\n  }\n\n  return decoded;\n}\n\n/**\n * Yeast: A tiny growing id generator.\n *\n * @returns {String} A unique id.\n * @api public\n */\nfunction yeast() {\n  var now = encode(+new Date());\n\n  if (now !== prev) return seed = 0, prev = now;\n  return now +'.'+ encode(seed++);\n}\n\n//\n// Map each character to its index.\n//\nfor (; i < length; i++) map[alphabet[i]] = i;\n\n//\n// Expose the `yeast`, `encode` and `decode` functions.\n//\nyeast.encode = encode;\nyeast.decode = decode;\nmodule.exports = yeast;\n","'use strict';\n\n// http://stackoverflow.com/questions/10343913/how-to-create-a-web-worker-from-a-string\n\nvar URL = window.URL || window.webkitURL;\n\nmodule.exports = function (content, url) {\n  try {\n    try {\n      var blob;\n\n      try {\n        // BlobBuilder = Deprecated, but widely implemented\n        var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;\n\n        blob = new BlobBuilder();\n\n        blob.append(content);\n\n        blob = blob.getBlob();\n      } catch (e) {\n        // The proposed API\n        blob = new Blob([content]);\n      }\n\n      return new Worker(URL.createObjectURL(blob));\n    } catch (e) {\n      return new Worker('data:application/javascript,' + encodeURIComponent(content));\n    }\n  } catch (e) {\n    if (!url) {\n      throw Error('Inline worker is not supported');\n    }\n\n    return new Worker(url);\n  }\n};","\n/**\n * Module exports.\n *\n * Logic borrowed from Modernizr:\n *\n *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js\n */\n\ntry {\n  module.exports = typeof XMLHttpRequest !== 'undefined' &&\n    'withCredentials' in new XMLHttpRequest();\n} catch (err) {\n  // if XMLHttp support is disabled in IE then it will throw\n  // when trying to create\n  module.exports = false;\n}\n","import { Transport } from \"../transport.js\";\nimport parseqs from \"parseqs\";\nimport yeast from \"yeast\";\nimport { pick } from \"../util.js\";\nimport { defaultBinaryType, nextTick, usingBrowserWebSocket, WebSocket } from \"./websocket-constructor.js\";\nimport { encodePacket } from \"engine.io-parser\";\n// detect ReactNative environment\nconst isReactNative = typeof navigator !== \"undefined\" &&\n    typeof navigator.product === \"string\" &&\n    navigator.product.toLowerCase() === \"reactnative\";\nexport class WS extends Transport {\n    /**\n     * WebSocket transport constructor.\n     *\n     * @api {Object} connection options\n     * @api public\n     */\n    constructor(opts) {\n        super(opts);\n        this.supportsBinary = !opts.forceBase64;\n    }\n    /**\n     * Transport name.\n     *\n     * @api public\n     */\n    get name() {\n        return \"websocket\";\n    }\n    /**\n     * Opens socket.\n     *\n     * @api private\n     */\n    doOpen() {\n        if (!this.check()) {\n            // let probe timeout\n            return;\n        }\n        const uri = this.uri();\n        const protocols = this.opts.protocols;\n        // React Native only supports the 'headers' option, and will print a warning if anything else is passed\n        const opts = isReactNative\n            ? {}\n            : pick(this.opts, \"agent\", \"perMessageDeflate\", \"pfx\", \"key\", \"passphrase\", \"cert\", \"ca\", \"ciphers\", \"rejectUnauthorized\", \"localAddress\", \"protocolVersion\", \"origin\", \"maxPayload\", \"family\", \"checkServerIdentity\");\n        if (this.opts.extraHeaders) {\n            opts.headers = this.opts.extraHeaders;\n        }\n        try {\n            this.ws =\n                usingBrowserWebSocket && !isReactNative\n                    ? protocols\n                        ? new WebSocket(uri, protocols)\n                        : new WebSocket(uri)\n                    : new WebSocket(uri, protocols, opts);\n        }\n        catch (err) {\n            return this.emit(\"error\", err);\n        }\n        this.ws.binaryType = this.socket.binaryType || defaultBinaryType;\n        this.addEventListeners();\n    }\n    /**\n     * Adds event listeners to the socket\n     *\n     * @api private\n     */\n    addEventListeners() {\n        this.ws.onopen = () => {\n            if (this.opts.autoUnref) {\n                this.ws._socket.unref();\n            }\n            this.onOpen();\n        };\n        this.ws.onclose = this.onClose.bind(this);\n        this.ws.onmessage = ev => this.onData(ev.data);\n        this.ws.onerror = e => this.onError(\"websocket error\", e);\n    }\n    /**\n     * Writes data to socket.\n     *\n     * @param {Array} array of packets.\n     * @api private\n     */\n    write(packets) {\n        this.writable = false;\n        // encodePacket efficient as it uses WS framing\n        // no need for encodePayload\n        for (let i = 0; i < packets.length; i++) {\n            const packet = packets[i];\n            const lastPacket = i === packets.length - 1;\n            encodePacket(packet, this.supportsBinary, data => {\n                // always create a new object (GH-437)\n                const opts = {};\n                if (!usingBrowserWebSocket) {\n                    if (packet.options) {\n                        opts.compress = packet.options.compress;\n                    }\n                    if (this.opts.perMessageDeflate) {\n                        const len = \"string\" === typeof data ? Buffer.byteLength(data) : data.length;\n                        if (len < this.opts.perMessageDeflate.threshold) {\n                            opts.compress = false;\n                        }\n                    }\n                }\n                // Sometimes the websocket has already been closed but the browser didn't\n                // have a chance of informing us about it yet, in that case send will\n                // throw an error\n                try {\n                    if (usingBrowserWebSocket) {\n                        // TypeError is thrown when passing the second argument on Safari\n                        this.ws.send(data);\n                    }\n                    else {\n                        this.ws.send(data, opts);\n                    }\n                }\n                catch (e) {\n                }\n                if (lastPacket) {\n                    // fake drain\n                    // defer to next tick to allow Socket to clear writeBuffer\n                    nextTick(() => {\n                        this.writable = true;\n                        this.emit(\"drain\");\n                    }, this.setTimeoutFn);\n                }\n            });\n        }\n    }\n    /**\n     * Closes socket.\n     *\n     * @api private\n     */\n    doClose() {\n        if (typeof this.ws !== \"undefined\") {\n            this.ws.close();\n            this.ws = null;\n        }\n    }\n    /**\n     * Generates uri for connection.\n     *\n     * @api private\n     */\n    uri() {\n        let query = this.query || {};\n        const schema = this.opts.secure ? \"wss\" : \"ws\";\n        let port = \"\";\n        // avoid port if default for schema\n        if (this.opts.port &&\n            ((\"wss\" === schema && Number(this.opts.port) !== 443) ||\n                (\"ws\" === schema && Number(this.opts.port) !== 80))) {\n            port = \":\" + this.opts.port;\n        }\n        // append timestamp to URI\n        if (this.opts.timestampRequests) {\n            query[this.opts.timestampParam] = yeast();\n        }\n        // communicate binary support capabilities\n        if (!this.supportsBinary) {\n            query.b64 = 1;\n        }\n        const encodedQuery = parseqs.encode(query);\n        const ipv6 = this.opts.hostname.indexOf(\":\") !== -1;\n        return (schema +\n            \"://\" +\n            (ipv6 ? \"[\" + this.opts.hostname + \"]\" : this.opts.hostname) +\n            port +\n            this.opts.path +\n            (encodedQuery.length ? \"?\" + encodedQuery : \"\"));\n    }\n    /**\n     * Feature detection for WebSocket.\n     *\n     * @return {Boolean} whether this transport is available.\n     * @api public\n     */\n    check() {\n        return (!!WebSocket &&\n            !(\"__initialize\" in WebSocket && this.name === WS.prototype.name));\n    }\n}\n","\n/**\n * Expose `Backoff`.\n */\n\nmodule.exports = Backoff;\n\n/**\n * Initialize backoff timer with `opts`.\n *\n * - `min` initial timeout in milliseconds [100]\n * - `max` max timeout [10000]\n * - `jitter` [0]\n * - `factor` [2]\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction Backoff(opts) {\n  opts = opts || {};\n  this.ms = opts.min || 100;\n  this.max = opts.max || 10000;\n  this.factor = opts.factor || 2;\n  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n  this.attempts = 0;\n}\n\n/**\n * Return the backoff duration.\n *\n * @return {Number}\n * @api public\n */\n\nBackoff.prototype.duration = function(){\n  var ms = this.ms * Math.pow(this.factor, this.attempts++);\n  if (this.jitter) {\n    var rand =  Math.random();\n    var deviation = Math.floor(rand * this.jitter * ms);\n    ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;\n  }\n  return Math.min(ms, this.max) | 0;\n};\n\n/**\n * Reset the number of attempts.\n *\n * @api public\n */\n\nBackoff.prototype.reset = function(){\n  this.attempts = 0;\n};\n\n/**\n * Set the minimum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMin = function(min){\n  this.ms = min;\n};\n\n/**\n * Set the maximum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMax = function(max){\n  this.max = max;\n};\n\n/**\n * Set the jitter\n *\n * @api public\n */\n\nBackoff.prototype.setJitter = function(jitter){\n  this.jitter = jitter;\n};\n\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","// browser shim for xmlhttprequest module\nimport hasCORS from \"has-cors\";\nimport globalThis from \"../globalThis.js\";\nexport default function (opts) {\n    const xdomain = opts.xdomain;\n    // XMLHttpRequest can be disabled on IE\n    try {\n        if (\"undefined\" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n            return new XMLHttpRequest();\n        }\n    }\n    catch (e) { }\n    if (!xdomain) {\n        try {\n            return new globalThis[[\"Active\"].concat(\"Object\").join(\"X\")](\"Microsoft.XMLHTTP\");\n        }\n        catch (e) { }\n    }\n}\n","import { Transport } from \"../transport.js\";\nimport yeast from \"yeast\";\nimport parseqs from \"parseqs\";\nimport { encodePayload, decodePayload } from \"engine.io-parser\";\nexport class Polling extends Transport {\n    constructor() {\n        super(...arguments);\n        this.polling = false;\n    }\n    /**\n     * Transport name.\n     */\n    get name() {\n        return \"polling\";\n    }\n    /**\n     * Opens the socket (triggers polling). We write a PING message to determine\n     * when the transport is open.\n     *\n     * @api private\n     */\n    doOpen() {\n        this.poll();\n    }\n    /**\n     * Pauses polling.\n     *\n     * @param {Function} callback upon buffers are flushed and transport is paused\n     * @api private\n     */\n    pause(onPause) {\n        this.readyState = \"pausing\";\n        const pause = () => {\n            this.readyState = \"paused\";\n            onPause();\n        };\n        if (this.polling || !this.writable) {\n            let total = 0;\n            if (this.polling) {\n                total++;\n                this.once(\"pollComplete\", function () {\n                    --total || pause();\n                });\n            }\n            if (!this.writable) {\n                total++;\n                this.once(\"drain\", function () {\n                    --total || pause();\n                });\n            }\n        }\n        else {\n            pause();\n        }\n    }\n    /**\n     * Starts polling cycle.\n     *\n     * @api public\n     */\n    poll() {\n        this.polling = true;\n        this.doPoll();\n        this.emit(\"poll\");\n    }\n    /**\n     * Overloads onData to detect payloads.\n     *\n     * @api private\n     */\n    onData(data) {\n        const callback = packet => {\n            // if its the first message we consider the transport open\n            if (\"opening\" === this.readyState && packet.type === \"open\") {\n                this.onOpen();\n            }\n            // if its a close packet, we close the ongoing requests\n            if (\"close\" === packet.type) {\n                this.onClose();\n                return false;\n            }\n            // otherwise bypass onData and handle the message\n            this.onPacket(packet);\n        };\n        // decode payload\n        decodePayload(data, this.socket.binaryType).forEach(callback);\n        // if an event did not trigger closing\n        if (\"closed\" !== this.readyState) {\n            // if we got data we're not polling\n            this.polling = false;\n            this.emit(\"pollComplete\");\n            if (\"open\" === this.readyState) {\n                this.poll();\n            }\n            else {\n            }\n        }\n    }\n    /**\n     * For polling, send a close packet.\n     *\n     * @api private\n     */\n    doClose() {\n        const close = () => {\n            this.write([{ type: \"close\" }]);\n        };\n        if (\"open\" === this.readyState) {\n            close();\n        }\n        else {\n            // in case we're trying to close while\n            // handshaking is in progress (GH-164)\n            this.once(\"open\", close);\n        }\n    }\n    /**\n     * Writes a packets payload.\n     *\n     * @param {Array} data packets\n     * @param {Function} drain callback\n     * @api private\n     */\n    write(packets) {\n        this.writable = false;\n        encodePayload(packets, data => {\n            this.doWrite(data, () => {\n                this.writable = true;\n                this.emit(\"drain\");\n            });\n        });\n    }\n    /**\n     * Generates uri for connection.\n     *\n     * @api private\n     */\n    uri() {\n        let query = this.query || {};\n        const schema = this.opts.secure ? \"https\" : \"http\";\n        let port = \"\";\n        // cache busting is forced\n        if (false !== this.opts.timestampRequests) {\n            query[this.opts.timestampParam] = yeast();\n        }\n        if (!this.supportsBinary && !query.sid) {\n            query.b64 = 1;\n        }\n        // avoid port if default for schema\n        if (this.opts.port &&\n            ((\"https\" === schema && Number(this.opts.port) !== 443) ||\n                (\"http\" === schema && Number(this.opts.port) !== 80))) {\n            port = \":\" + this.opts.port;\n        }\n        const encodedQuery = parseqs.encode(query);\n        const ipv6 = this.opts.hostname.indexOf(\":\") !== -1;\n        return (schema +\n            \"://\" +\n            (ipv6 ? \"[\" + this.opts.hostname + \"]\" : this.opts.hostname) +\n            port +\n            this.opts.path +\n            (encodedQuery.length ? \"?\" + encodedQuery : \"\"));\n    }\n}\n","/* global attachEvent */\nimport XMLHttpRequest from \"./xmlhttprequest.js\";\nimport globalThis from \"../globalThis.js\";\nimport { installTimerFunctions, pick } from \"../util.js\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nimport { Polling } from \"./polling.js\";\n/**\n * Empty function\n */\nfunction empty() { }\nconst hasXHR2 = (function () {\n    const xhr = new XMLHttpRequest({\n        xdomain: false\n    });\n    return null != xhr.responseType;\n})();\nexport class XHR extends Polling {\n    /**\n     * XHR Polling constructor.\n     *\n     * @param {Object} opts\n     * @api public\n     */\n    constructor(opts) {\n        super(opts);\n        if (typeof location !== \"undefined\") {\n            const isSSL = \"https:\" === location.protocol;\n            let port = location.port;\n            // some user agents have empty `location.port`\n            if (!port) {\n                port = isSSL ? \"443\" : \"80\";\n            }\n            this.xd =\n                (typeof location !== \"undefined\" &&\n                    opts.hostname !== location.hostname) ||\n                    port !== opts.port;\n            this.xs = opts.secure !== isSSL;\n        }\n        /**\n         * XHR supports binary\n         */\n        const forceBase64 = opts && opts.forceBase64;\n        this.supportsBinary = hasXHR2 && !forceBase64;\n    }\n    /**\n     * Creates a request.\n     *\n     * @param {String} method\n     * @api private\n     */\n    request(opts = {}) {\n        Object.assign(opts, { xd: this.xd, xs: this.xs }, this.opts);\n        return new Request(this.uri(), opts);\n    }\n    /**\n     * Sends data.\n     *\n     * @param {String} data to send.\n     * @param {Function} called upon flush.\n     * @api private\n     */\n    doWrite(data, fn) {\n        const req = this.request({\n            method: \"POST\",\n            data: data\n        });\n        req.on(\"success\", fn);\n        req.on(\"error\", err => {\n            this.onError(\"xhr post error\", err);\n        });\n    }\n    /**\n     * Starts a poll cycle.\n     *\n     * @api private\n     */\n    doPoll() {\n        const req = this.request();\n        req.on(\"data\", this.onData.bind(this));\n        req.on(\"error\", err => {\n            this.onError(\"xhr poll error\", err);\n        });\n        this.pollXhr = req;\n    }\n}\nexport class Request extends Emitter {\n    /**\n     * Request constructor\n     *\n     * @param {Object} options\n     * @api public\n     */\n    constructor(uri, opts) {\n        super();\n        installTimerFunctions(this, opts);\n        this.opts = opts;\n        this.method = opts.method || \"GET\";\n        this.uri = uri;\n        this.async = false !== opts.async;\n        this.data = undefined !== opts.data ? opts.data : null;\n        this.create();\n    }\n    /**\n     * Creates the XHR object and sends the request.\n     *\n     * @api private\n     */\n    create() {\n        const opts = pick(this.opts, \"agent\", \"pfx\", \"key\", \"passphrase\", \"cert\", \"ca\", \"ciphers\", \"rejectUnauthorized\", \"autoUnref\");\n        opts.xdomain = !!this.opts.xd;\n        opts.xscheme = !!this.opts.xs;\n        const xhr = (this.xhr = new XMLHttpRequest(opts));\n        try {\n            xhr.open(this.method, this.uri, this.async);\n            try {\n                if (this.opts.extraHeaders) {\n                    xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);\n                    for (let i in this.opts.extraHeaders) {\n                        if (this.opts.extraHeaders.hasOwnProperty(i)) {\n                            xhr.setRequestHeader(i, this.opts.extraHeaders[i]);\n                        }\n                    }\n                }\n            }\n            catch (e) { }\n            if (\"POST\" === this.method) {\n                try {\n                    xhr.setRequestHeader(\"Content-type\", \"text/plain;charset=UTF-8\");\n                }\n                catch (e) { }\n            }\n            try {\n                xhr.setRequestHeader(\"Accept\", \"*/*\");\n            }\n            catch (e) { }\n            // ie6 check\n            if (\"withCredentials\" in xhr) {\n                xhr.withCredentials = this.opts.withCredentials;\n            }\n            if (this.opts.requestTimeout) {\n                xhr.timeout = this.opts.requestTimeout;\n            }\n            xhr.onreadystatechange = () => {\n                if (4 !== xhr.readyState)\n                    return;\n                if (200 === xhr.status || 1223 === xhr.status) {\n                    this.onLoad();\n                }\n                else {\n                    // make sure the `error` event handler that's user-set\n                    // does not throw in the same tick and gets caught here\n                    this.setTimeoutFn(() => {\n                        this.onError(typeof xhr.status === \"number\" ? xhr.status : 0);\n                    }, 0);\n                }\n            };\n            xhr.send(this.data);\n        }\n        catch (e) {\n            // Need to defer since .create() is called directly from the constructor\n            // and thus the 'error' event can only be only bound *after* this exception\n            // occurs.  Therefore, also, we cannot throw here at all.\n            this.setTimeoutFn(() => {\n                this.onError(e);\n            }, 0);\n            return;\n        }\n        if (typeof document !== \"undefined\") {\n            this.index = Request.requestsCount++;\n            Request.requests[this.index] = this;\n        }\n    }\n    /**\n     * Called upon successful response.\n     *\n     * @api private\n     */\n    onSuccess() {\n        this.emit(\"success\");\n        this.cleanup();\n    }\n    /**\n     * Called if we have data.\n     *\n     * @api private\n     */\n    onData(data) {\n        this.emit(\"data\", data);\n        this.onSuccess();\n    }\n    /**\n     * Called upon error.\n     *\n     * @api private\n     */\n    onError(err) {\n        this.emit(\"error\", err);\n        this.cleanup(true);\n    }\n    /**\n     * Cleans up house.\n     *\n     * @api private\n     */\n    cleanup(fromError) {\n        if (\"undefined\" === typeof this.xhr || null === this.xhr) {\n            return;\n        }\n        this.xhr.onreadystatechange = empty;\n        if (fromError) {\n            try {\n                this.xhr.abort();\n            }\n            catch (e) { }\n        }\n        if (typeof document !== \"undefined\") {\n            delete Request.requests[this.index];\n        }\n        this.xhr = null;\n    }\n    /**\n     * Called upon load.\n     *\n     * @api private\n     */\n    onLoad() {\n        const data = this.xhr.responseText;\n        if (data !== null) {\n            this.onData(data);\n        }\n    }\n    /**\n     * Aborts the request.\n     *\n     * @api public\n     */\n    abort() {\n        this.cleanup();\n    }\n}\nRequest.requestsCount = 0;\nRequest.requests = {};\n/**\n * Aborts pending requests when unloading the window. This is needed to prevent\n * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n * emitted.\n */\nif (typeof document !== \"undefined\") {\n    // @ts-ignore\n    if (typeof attachEvent === \"function\") {\n        // @ts-ignore\n        attachEvent(\"onunload\", unloadHandler);\n    }\n    else if (typeof addEventListener === \"function\") {\n        const terminationEvent = \"onpagehide\" in globalThis ? \"pagehide\" : \"unload\";\n        addEventListener(terminationEvent, unloadHandler, false);\n    }\n}\nfunction unloadHandler() {\n    for (let i in Request.requests) {\n        if (Request.requests.hasOwnProperty(i)) {\n            Request.requests[i].abort();\n        }\n    }\n}\n","import { XHR } from \"./polling-xhr.js\";\nimport { WS } from \"./websocket.js\";\nexport const transports = {\n    websocket: WS,\n    polling: XHR\n};\n","import { transports } from \"./transports/index.js\";\nimport { installTimerFunctions } from \"./util.js\";\nimport parseqs from \"parseqs\";\nimport parseuri from \"parseuri\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nimport { protocol } from \"engine.io-parser\";\nexport class Socket extends Emitter {\n    /**\n     * Socket constructor.\n     *\n     * @param {String|Object} uri or options\n     * @param {Object} opts - options\n     * @api public\n     */\n    constructor(uri, opts = {}) {\n        super();\n        if (uri && \"object\" === typeof uri) {\n            opts = uri;\n            uri = null;\n        }\n        if (uri) {\n            uri = parseuri(uri);\n            opts.hostname = uri.host;\n            opts.secure = uri.protocol === \"https\" || uri.protocol === \"wss\";\n            opts.port = uri.port;\n            if (uri.query)\n                opts.query = uri.query;\n        }\n        else if (opts.host) {\n            opts.hostname = parseuri(opts.host).host;\n        }\n        installTimerFunctions(this, opts);\n        this.secure =\n            null != opts.secure\n                ? opts.secure\n                : typeof location !== \"undefined\" && \"https:\" === location.protocol;\n        if (opts.hostname && !opts.port) {\n            // if no port is specified manually, use the protocol default\n            opts.port = this.secure ? \"443\" : \"80\";\n        }\n        this.hostname =\n            opts.hostname ||\n                (typeof location !== \"undefined\" ? location.hostname : \"localhost\");\n        this.port =\n            opts.port ||\n                (typeof location !== \"undefined\" && location.port\n                    ? location.port\n                    : this.secure\n                        ? \"443\"\n                        : \"80\");\n        this.transports = opts.transports || [\"polling\", \"websocket\"];\n        this.readyState = \"\";\n        this.writeBuffer = [];\n        this.prevBufferLen = 0;\n        this.opts = Object.assign({\n            path: \"/engine.io\",\n            agent: false,\n            withCredentials: false,\n            upgrade: true,\n            timestampParam: \"t\",\n            rememberUpgrade: false,\n            rejectUnauthorized: true,\n            perMessageDeflate: {\n                threshold: 1024\n            },\n            transportOptions: {},\n            closeOnBeforeunload: true\n        }, opts);\n        this.opts.path = this.opts.path.replace(/\\/$/, \"\") + \"/\";\n        if (typeof this.opts.query === \"string\") {\n            this.opts.query = parseqs.decode(this.opts.query);\n        }\n        // set on handshake\n        this.id = null;\n        this.upgrades = null;\n        this.pingInterval = null;\n        this.pingTimeout = null;\n        // set on heartbeat\n        this.pingTimeoutTimer = null;\n        if (typeof addEventListener === \"function\") {\n            if (this.opts.closeOnBeforeunload) {\n                // Firefox closes the connection when the \"beforeunload\" event is emitted but not Chrome. This event listener\n                // ensures every browser behaves the same (no \"disconnect\" event at the Socket.IO level when the page is\n                // closed/reloaded)\n                addEventListener(\"beforeunload\", () => {\n                    if (this.transport) {\n                        // silently close the transport\n                        this.transport.removeAllListeners();\n                        this.transport.close();\n                    }\n                }, false);\n            }\n            if (this.hostname !== \"localhost\") {\n                this.offlineEventListener = () => {\n                    this.onClose(\"transport close\");\n                };\n                addEventListener(\"offline\", this.offlineEventListener, false);\n            }\n        }\n        this.open();\n    }\n    /**\n     * Creates transport of the given type.\n     *\n     * @param {String} transport name\n     * @return {Transport}\n     * @api private\n     */\n    createTransport(name) {\n        const query = clone(this.opts.query);\n        // append engine.io protocol identifier\n        query.EIO = protocol;\n        // transport name\n        query.transport = name;\n        // session id if we already have one\n        if (this.id)\n            query.sid = this.id;\n        const opts = Object.assign({}, this.opts.transportOptions[name], this.opts, {\n            query,\n            socket: this,\n            hostname: this.hostname,\n            secure: this.secure,\n            port: this.port\n        });\n        return new transports[name](opts);\n    }\n    /**\n     * Initializes transport to use and starts probe.\n     *\n     * @api private\n     */\n    open() {\n        let transport;\n        if (this.opts.rememberUpgrade &&\n            Socket.priorWebsocketSuccess &&\n            this.transports.indexOf(\"websocket\") !== -1) {\n            transport = \"websocket\";\n        }\n        else if (0 === this.transports.length) {\n            // Emit error on next tick so it can be listened to\n            this.setTimeoutFn(() => {\n                this.emitReserved(\"error\", \"No transports available\");\n            }, 0);\n            return;\n        }\n        else {\n            transport = this.transports[0];\n        }\n        this.readyState = \"opening\";\n        // Retry with the next transport if the transport is disabled (jsonp: false)\n        try {\n            transport = this.createTransport(transport);\n        }\n        catch (e) {\n            this.transports.shift();\n            this.open();\n            return;\n        }\n        transport.open();\n        this.setTransport(transport);\n    }\n    /**\n     * Sets the current transport. Disables the existing one (if any).\n     *\n     * @api private\n     */\n    setTransport(transport) {\n        if (this.transport) {\n            this.transport.removeAllListeners();\n        }\n        // set up transport\n        this.transport = transport;\n        // set up transport listeners\n        transport\n            .on(\"drain\", this.onDrain.bind(this))\n            .on(\"packet\", this.onPacket.bind(this))\n            .on(\"error\", this.onError.bind(this))\n            .on(\"close\", () => {\n            this.onClose(\"transport close\");\n        });\n    }\n    /**\n     * Probes a transport.\n     *\n     * @param {String} transport name\n     * @api private\n     */\n    probe(name) {\n        let transport = this.createTransport(name);\n        let failed = false;\n        Socket.priorWebsocketSuccess = false;\n        const onTransportOpen = () => {\n            if (failed)\n                return;\n            transport.send([{ type: \"ping\", data: \"probe\" }]);\n            transport.once(\"packet\", msg => {\n                if (failed)\n                    return;\n                if (\"pong\" === msg.type && \"probe\" === msg.data) {\n                    this.upgrading = true;\n                    this.emitReserved(\"upgrading\", transport);\n                    if (!transport)\n                        return;\n                    Socket.priorWebsocketSuccess = \"websocket\" === transport.name;\n                    this.transport.pause(() => {\n                        if (failed)\n                            return;\n                        if (\"closed\" === this.readyState)\n                            return;\n                        cleanup();\n                        this.setTransport(transport);\n                        transport.send([{ type: \"upgrade\" }]);\n                        this.emitReserved(\"upgrade\", transport);\n                        transport = null;\n                        this.upgrading = false;\n                        this.flush();\n                    });\n                }\n                else {\n                    const err = new Error(\"probe error\");\n                    // @ts-ignore\n                    err.transport = transport.name;\n                    this.emitReserved(\"upgradeError\", err);\n                }\n            });\n        };\n        function freezeTransport() {\n            if (failed)\n                return;\n            // Any callback called by transport should be ignored since now\n            failed = true;\n            cleanup();\n            transport.close();\n            transport = null;\n        }\n        // Handle any error that happens while probing\n        const onerror = err => {\n            const error = new Error(\"probe error: \" + err);\n            // @ts-ignore\n            error.transport = transport.name;\n            freezeTransport();\n            this.emitReserved(\"upgradeError\", error);\n        };\n        function onTransportClose() {\n            onerror(\"transport closed\");\n        }\n        // When the socket is closed while we're probing\n        function onclose() {\n            onerror(\"socket closed\");\n        }\n        // When the socket is upgraded while we're probing\n        function onupgrade(to) {\n            if (transport && to.name !== transport.name) {\n                freezeTransport();\n            }\n        }\n        // Remove all listeners on the transport and on self\n        const cleanup = () => {\n            transport.removeListener(\"open\", onTransportOpen);\n            transport.removeListener(\"error\", onerror);\n            transport.removeListener(\"close\", onTransportClose);\n            this.off(\"close\", onclose);\n            this.off(\"upgrading\", onupgrade);\n        };\n        transport.once(\"open\", onTransportOpen);\n        transport.once(\"error\", onerror);\n        transport.once(\"close\", onTransportClose);\n        this.once(\"close\", onclose);\n        this.once(\"upgrading\", onupgrade);\n        transport.open();\n    }\n    /**\n     * Called when connection is deemed open.\n     *\n     * @api private\n     */\n    onOpen() {\n        this.readyState = \"open\";\n        Socket.priorWebsocketSuccess = \"websocket\" === this.transport.name;\n        this.emitReserved(\"open\");\n        this.flush();\n        // we check for `readyState` in case an `open`\n        // listener already closed the socket\n        if (\"open\" === this.readyState &&\n            this.opts.upgrade &&\n            this.transport.pause) {\n            let i = 0;\n            const l = this.upgrades.length;\n            for (; i < l; i++) {\n                this.probe(this.upgrades[i]);\n            }\n        }\n    }\n    /**\n     * Handles a packet.\n     *\n     * @api private\n     */\n    onPacket(packet) {\n        if (\"opening\" === this.readyState ||\n            \"open\" === this.readyState ||\n            \"closing\" === this.readyState) {\n            this.emitReserved(\"packet\", packet);\n            // Socket is live - any packet counts\n            this.emitReserved(\"heartbeat\");\n            switch (packet.type) {\n                case \"open\":\n                    this.onHandshake(JSON.parse(packet.data));\n                    break;\n                case \"ping\":\n                    this.resetPingTimeout();\n                    this.sendPacket(\"pong\");\n                    this.emitReserved(\"ping\");\n                    this.emitReserved(\"pong\");\n                    break;\n                case \"error\":\n                    const err = new Error(\"server error\");\n                    // @ts-ignore\n                    err.code = packet.data;\n                    this.onError(err);\n                    break;\n                case \"message\":\n                    this.emitReserved(\"data\", packet.data);\n                    this.emitReserved(\"message\", packet.data);\n                    break;\n            }\n        }\n        else {\n        }\n    }\n    /**\n     * Called upon handshake completion.\n     *\n     * @param {Object} data - handshake obj\n     * @api private\n     */\n    onHandshake(data) {\n        this.emitReserved(\"handshake\", data);\n        this.id = data.sid;\n        this.transport.query.sid = data.sid;\n        this.upgrades = this.filterUpgrades(data.upgrades);\n        this.pingInterval = data.pingInterval;\n        this.pingTimeout = data.pingTimeout;\n        this.onOpen();\n        // In case open handler closes socket\n        if (\"closed\" === this.readyState)\n            return;\n        this.resetPingTimeout();\n    }\n    /**\n     * Sets and resets ping timeout timer based on server pings.\n     *\n     * @api private\n     */\n    resetPingTimeout() {\n        this.clearTimeoutFn(this.pingTimeoutTimer);\n        this.pingTimeoutTimer = this.setTimeoutFn(() => {\n            this.onClose(\"ping timeout\");\n        }, this.pingInterval + this.pingTimeout);\n        if (this.opts.autoUnref) {\n            this.pingTimeoutTimer.unref();\n        }\n    }\n    /**\n     * Called on `drain` event\n     *\n     * @api private\n     */\n    onDrain() {\n        this.writeBuffer.splice(0, this.prevBufferLen);\n        // setting prevBufferLen = 0 is very important\n        // for example, when upgrading, upgrade packet is sent over,\n        // and a nonzero prevBufferLen could cause problems on `drain`\n        this.prevBufferLen = 0;\n        if (0 === this.writeBuffer.length) {\n            this.emitReserved(\"drain\");\n        }\n        else {\n            this.flush();\n        }\n    }\n    /**\n     * Flush write buffers.\n     *\n     * @api private\n     */\n    flush() {\n        if (\"closed\" !== this.readyState &&\n            this.transport.writable &&\n            !this.upgrading &&\n            this.writeBuffer.length) {\n            this.transport.send(this.writeBuffer);\n            // keep track of current length of writeBuffer\n            // splice writeBuffer and callbackBuffer on `drain`\n            this.prevBufferLen = this.writeBuffer.length;\n            this.emitReserved(\"flush\");\n        }\n    }\n    /**\n     * Sends a message.\n     *\n     * @param {String} message.\n     * @param {Function} callback function.\n     * @param {Object} options.\n     * @return {Socket} for chaining.\n     * @api public\n     */\n    write(msg, options, fn) {\n        this.sendPacket(\"message\", msg, options, fn);\n        return this;\n    }\n    send(msg, options, fn) {\n        this.sendPacket(\"message\", msg, options, fn);\n        return this;\n    }\n    /**\n     * Sends a packet.\n     *\n     * @param {String} packet type.\n     * @param {String} data.\n     * @param {Object} options.\n     * @param {Function} callback function.\n     * @api private\n     */\n    sendPacket(type, data, options, fn) {\n        if (\"function\" === typeof data) {\n            fn = data;\n            data = undefined;\n        }\n        if (\"function\" === typeof options) {\n            fn = options;\n            options = null;\n        }\n        if (\"closing\" === this.readyState || \"closed\" === this.readyState) {\n            return;\n        }\n        options = options || {};\n        options.compress = false !== options.compress;\n        const packet = {\n            type: type,\n            data: data,\n            options: options\n        };\n        this.emitReserved(\"packetCreate\", packet);\n        this.writeBuffer.push(packet);\n        if (fn)\n            this.once(\"flush\", fn);\n        this.flush();\n    }\n    /**\n     * Closes the connection.\n     *\n     * @api public\n     */\n    close() {\n        const close = () => {\n            this.onClose(\"forced close\");\n            this.transport.close();\n        };\n        const cleanupAndClose = () => {\n            this.off(\"upgrade\", cleanupAndClose);\n            this.off(\"upgradeError\", cleanupAndClose);\n            close();\n        };\n        const waitForUpgrade = () => {\n            // wait for upgrade to finish since we can't send packets while pausing a transport\n            this.once(\"upgrade\", cleanupAndClose);\n            this.once(\"upgradeError\", cleanupAndClose);\n        };\n        if (\"opening\" === this.readyState || \"open\" === this.readyState) {\n            this.readyState = \"closing\";\n            if (this.writeBuffer.length) {\n                this.once(\"drain\", () => {\n                    if (this.upgrading) {\n                        waitForUpgrade();\n                    }\n                    else {\n                        close();\n                    }\n                });\n            }\n            else if (this.upgrading) {\n                waitForUpgrade();\n            }\n            else {\n                close();\n            }\n        }\n        return this;\n    }\n    /**\n     * Called upon transport error\n     *\n     * @api private\n     */\n    onError(err) {\n        Socket.priorWebsocketSuccess = false;\n        this.emitReserved(\"error\", err);\n        this.onClose(\"transport error\", err);\n    }\n    /**\n     * Called upon transport close.\n     *\n     * @api private\n     */\n    onClose(reason, desc) {\n        if (\"opening\" === this.readyState ||\n            \"open\" === this.readyState ||\n            \"closing\" === this.readyState) {\n            // clear timers\n            this.clearTimeoutFn(this.pingTimeoutTimer);\n            // stop event from firing again for transport\n            this.transport.removeAllListeners(\"close\");\n            // ensure transport won't stay open\n            this.transport.close();\n            // ignore further transport communication\n            this.transport.removeAllListeners();\n            if (typeof removeEventListener === \"function\") {\n                removeEventListener(\"offline\", this.offlineEventListener, false);\n            }\n            // set ready state\n            this.readyState = \"closed\";\n            // clear session id\n            this.id = null;\n            // emit close event\n            this.emitReserved(\"close\", reason, desc);\n            // clean buffers after, so users can still\n            // grab the buffers on `close` event\n            this.writeBuffer = [];\n            this.prevBufferLen = 0;\n        }\n    }\n    /**\n     * Filters upgrades, returning only those matching client transports.\n     *\n     * @param {Array} server upgrades\n     * @api private\n     *\n     */\n    filterUpgrades(upgrades) {\n        const filteredUpgrades = [];\n        let i = 0;\n        const j = upgrades.length;\n        for (; i < j; i++) {\n            if (~this.transports.indexOf(upgrades[i]))\n                filteredUpgrades.push(upgrades[i]);\n        }\n        return filteredUpgrades;\n    }\n}\nSocket.protocol = protocol;\nfunction clone(obj) {\n    const o = {};\n    for (let i in obj) {\n        if (obj.hasOwnProperty(i)) {\n            o[i] = obj[i];\n        }\n    }\n    return o;\n}\n","import { Socket } from \"./socket.js\";\nexport { Socket };\nexport const protocol = Socket.protocol;\nexport { Transport } from \"./transport.js\";\nexport { transports } from \"./transports/index.js\";\nexport { installTimerFunctions } from \"./util.js\";\n","const 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 */\nexport function isBinary(obj) {\n    return ((withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj))) ||\n        (withNativeBlob && obj instanceof Blob) ||\n        (withNativeFile && obj instanceof File));\n}\nexport function 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}\n","import { isBinary } from \"./is-binary.js\";\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 */\nexport function 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}\nfunction _deconstructPacket(data, buffers) {\n    if (!data)\n        return data;\n    if (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 */\nexport function reconstructPacket(packet, buffers) {\n    packet.data = _reconstructPacket(packet.data, buffers);\n    packet.attachments = undefined; // no longer useful\n    return packet;\n}\nfunction _reconstructPacket(data, buffers) {\n    if (!data)\n        return data;\n    if (data && data._placeholder) {\n        return buffers[data.num]; // appropriate buffer (should be natural order anyway)\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","import { Emitter } from \"@socket.io/component-emitter\";\nimport { deconstructPacket, reconstructPacket } from \"./binary.js\";\nimport { isBinary, hasBinary } from \"./is-binary.js\";\n/**\n * Protocol version.\n *\n * @public\n */\nexport const protocol = 5;\nexport var 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 || (PacketType = {}));\n/**\n * A socket.io Encoder instance\n */\nexport class 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        if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {\n            if (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        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 = 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}\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n */\nexport class 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            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.emitReserved(\"decoded\", packet);\n                }\n            }\n            else {\n                // non-binary full packet\n                super.emitReserved(\"decoded\", packet);\n            }\n        }\n        else if (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.emitReserved(\"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        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}\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 = 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","export function on(obj, ev, fn) {\n    obj.on(ev, fn);\n    return function subDestroy() {\n        obj.off(ev, fn);\n    };\n}\n","import { PacketType } from \"socket.io-parser\";\nimport { on } from \"./on.js\";\nimport { Emitter, } from \"@socket.io/component-emitter\";\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});\nexport class Socket extends Emitter {\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            on(io, \"open\", this.onopen.bind(this)),\n            on(io, \"packet\", this.onpacket.bind(this)),\n            on(io, \"error\", this.onerror.bind(this)),\n            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: 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            const id = this.ids++;\n            const ack = args.pop();\n            this._registerAckCallback(id, ack);\n            packet.id = id;\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        }\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     * @private\n     */\n    _registerAckCallback(id, ack) {\n        const timeout = this.flags.timeout;\n        if (timeout === undefined) {\n            this.acks[id] = ack;\n            return;\n        }\n        // @ts-ignore\n        const timer = this.io.setTimeoutFn(() => {\n            delete this.acks[id];\n            for (let i = 0; i < this.sendBuffer.length; i++) {\n                if (this.sendBuffer[i].id === id) {\n                    this.sendBuffer.splice(i, 1);\n                }\n            }\n            ack.call(this, new Error(\"operation has timed out\"));\n        }, timeout);\n        this.acks[id] = (...args) => {\n            // @ts-ignore\n            this.io.clearTimeoutFn(timer);\n            ack.apply(this, [null, ...args]);\n        };\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        if (typeof this.auth == \"function\") {\n            this.auth((data) => {\n                this.packet({ type: PacketType.CONNECT, data });\n            });\n        }\n        else {\n            this.packet({ type: 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        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 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 PacketType.EVENT:\n                this.onevent(packet);\n                break;\n            case PacketType.BINARY_EVENT:\n                this.onevent(packet);\n                break;\n            case PacketType.ACK:\n                this.onack(packet);\n                break;\n            case PacketType.BINARY_ACK:\n                this.onack(packet);\n                break;\n            case PacketType.DISCONNECT:\n                this.ondisconnect();\n                break;\n            case PacketType.CONNECT_ERROR:\n                this.destroy();\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        if (null != packet.id) {\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            self.packet({\n                type: 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            ack.apply(this, packet.data);\n            delete this.acks[packet.id];\n        }\n        else {\n        }\n    }\n    /**\n     * Called upon server connect.\n     *\n     * @private\n     */\n    onconnect(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        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            this.packet({ type: 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     * Sets a modifier for a subsequent event emission that the callback will be called with an error when the\n     * given number of milliseconds have elapsed without an acknowledgement from the server:\n     *\n     * ```\n     * socket.timeout(5000).emit(\"my-event\", (err) => {\n     *   if (err) {\n     *     // the server did not acknowledge the event in the given delay\n     *   }\n     * });\n     * ```\n     *\n     * @returns self\n     * @public\n     */\n    timeout(timeout) {\n        this.flags.timeout = timeout;\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}\n","import { Socket as Engine, installTimerFunctions, } from \"engine.io-client\";\nimport { Socket } from \"./socket.js\";\nimport * as parser from \"socket.io-parser\";\nimport { on } from \"./on.js\";\nimport Backoff from \"backo2\";\nimport { Emitter, } from \"@socket.io/component-emitter\";\nexport class Manager extends Emitter {\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        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        if (~this._readyState.indexOf(\"open\"))\n            return this;\n        this.engine = new Engine(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 = on(socket, \"open\", function () {\n            self.onopen();\n            fn && fn();\n        });\n        // emit `error`\n        const errorSub = on(socket, \"error\", (err) => {\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            if (timeout === 0) {\n                openSubDestroy(); // prevents a race condition with the 'open' event\n            }\n            // set timer\n            const timer = this.setTimeoutFn(() => {\n                openSubDestroy();\n                socket.close();\n                // @ts-ignore\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        // 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(on(socket, \"ping\", this.onping.bind(this)), on(socket, \"data\", this.ondata.bind(this)), on(socket, \"error\", this.onerror.bind(this)), on(socket, \"close\", this.onclose.bind(this)), 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        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(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                return;\n            }\n        }\n        this._close();\n    }\n    /**\n     * Writes a packet.\n     *\n     * @param packet\n     * @private\n     */\n    _packet(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        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        this.skipReconnect = true;\n        this._reconnecting = false;\n        this.onclose(\"forced close\");\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        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            this.backoff.reset();\n            this.emitReserved(\"reconnect_failed\");\n            this._reconnecting = false;\n        }\n        else {\n            const delay = this.backoff.duration();\n            this._reconnecting = true;\n            const timer = this.setTimeoutFn(() => {\n                if (self.skipReconnect)\n                    return;\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                        self._reconnecting = false;\n                        self.reconnect();\n                        this.emitReserved(\"reconnect_error\", err);\n                    }\n                    else {\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}\n","import { url } from \"./url.js\";\nimport { Manager } from \"./manager.js\";\nimport { Socket } from \"./socket.js\";\n/**\n * Managers cache.\n */\nconst cache = {};\nfunction lookup(uri, opts) {\n    if (typeof uri === \"object\") {\n        opts = uri;\n        uri = undefined;\n    }\n    opts = opts || {};\n    const parsed = 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        io = new Manager(source, opts);\n    }\n    else {\n        if (!cache[id]) {\n            cache[id] = new 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}\n// so that \"lookup\" can be used both as a function (e.g. `io(...)`) and as a\n// namespace (e.g. `io.connect(...)`), for backward compatibility\nObject.assign(lookup, {\n    Manager,\n    Socket,\n    io: lookup,\n    connect: lookup,\n});\n/**\n * Protocol version.\n *\n * @public\n */\nexport { protocol } from \"socket.io-parser\";\n/**\n * Expose constructors for standalone build.\n *\n * @public\n */\nexport { Manager, Socket, lookup as io, lookup as connect, lookup as default, };\n","import parseuri from \"parseuri\";\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 */\nexport function 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            if (\"undefined\" !== typeof loc) {\n                uri = loc.protocol + \"//\" + uri;\n            }\n            else {\n                uri = \"https://\" + uri;\n            }\n        }\n        // parse\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}\n","/**\n * Contains the routines loaded by the plugin iframe under web-browser\n * in case when worker failed to initialize\n *\n * Initializes the web environment version of the platform-dependent\n * connection object for the plugin site\n */\nimport { connectRPC } from \"./pluginCore.js\";\nimport { RPC, API_VERSION } from \"./rpc.js\";\nimport {\n  MessageEmitter,\n  randId,\n  normalizeConfig,\n  loadRequirements\n} from \"./utils.js\";\nimport io from \"socket.io-client\";\n\nexport { setupRPC, waitForInitialization } from \"./main.js\";\nexport { version as VERSION } from \"../package.json\";\nexport { RPC, API_VERSION };\nexport { loadRequirements };\n\nexport class Connection extends MessageEmitter {\n  constructor(config) {\n    super(config && config.debug);\n    this.config = config || {};\n    this.peer_id = randId();\n  }\n  init() {\n    return new Promise((resolve, reject) => {\n      const config = this.config;\n      const url = config.server_url;\n      const extraHeaders = {};\n      if (config.token) {\n        extraHeaders.Authorization = \"Bearer \" + config.token;\n      }\n      const basePath = new URL(url).pathname;\n      // Note: extraHeaders only works for polling transport (the default)\n      // If we switch to websocket only, the headers won't be respected\n      const socket = io(url, {\n        withCredentials: true,\n        extraHeaders,\n        path:\n          (basePath.endsWith(\"/\") ? basePath.slice(0, -1) : basePath) +\n          \"/socket.io\"\n      });\n      let connected = false;\n      socket.on(\"connect\", () => {\n        if (connected) {\n          console.warn(\"Skipping reconnect to the server\");\n          return;\n        }\n        socket.emit(\"register_plugin\", config, result => {\n          if (!result.success) {\n            console.error(result.detail);\n            reject(result.detail);\n            return;\n          }\n          connected = true;\n          this.plugin_id = result.plugin_id;\n          socket.on(\"plugin_message\", data => {\n            if (data.peer_id === this.peer_id) {\n              this._fire(data.type, data);\n            } else if (this.config.debug) {\n              console.log(\n                `connection peer id mismatch ${data.peer_id} !== ${this.peer_id}`\n              );\n            }\n          });\n\n          this.once(\"initialize\", () => {\n            if (!this.rpc) {\n              this.rpc = connectRPC(this, config);\n            } else {\n              this.rpc.once(\"remoteReady\", () => {\n                this.rpc.sendInterface();\n              });\n            }\n            this.connect();\n            resolve();\n          });\n          this.emit({\n            type: \"imjoyRPCReady\",\n            config: config,\n            peer_id: this.peer_id\n          });\n        });\n        this._disconnected = false;\n      });\n      socket.on(\"connect_error\", () => {\n        reject(\"connection error\");\n        this._fire(\"connectFailure\");\n      });\n      socket.on(\"disconnect\", () => {\n        reject(\"disconnected\");\n        this.disconnect();\n        this._fire(\"disconnected\");\n      });\n      this.socket = socket;\n    });\n  }\n  connect() {\n    this.emit({\n      type: \"initialized\",\n      config: this.config,\n      origin: globalThis.location.origin,\n      peer_id: this.peer_id\n    });\n    this._fire(\"connected\");\n  }\n  reset() {\n    this._event_handlers = {};\n    this._once_handlers = {};\n  }\n  execute() {\n    throw new Error(\"Execution is not allowed for socketio connection\");\n  }\n  disconnect() {\n    this._fire(\"beforeDisconnect\");\n    this.socket.disconnect();\n    this.init();\n    this._fire(\"disconnected\");\n  }\n  emit(data) {\n    data.plugin_id = this.plugin_id;\n    this.socket.emit(\"plugin_message\", data, result => {\n      if (!result.success) this._fire(\"error\", data.detail);\n    });\n  }\n}\n\nexport function connectToServer(config) {\n  config = config || {};\n  if (!config.server_url) throw new Error(\"Server URL is not specified.\");\n  config.name = config.name || randId();\n  config = normalizeConfig(config);\n  return new Promise((resolve, reject) => {\n    const handleEvent = e => {\n      const api = e.detail;\n      if (config.expose_api_globally) {\n        globalThis.api = api;\n      }\n      // imjoy plugin api\n      resolve(api);\n      globalThis.removeEventListener(\"imjoy_remote_api_ready\", handleEvent);\n    };\n    globalThis.addEventListener(\"imjoy_remote_api_ready\", handleEvent);\n    config = config || {};\n    config.dedicated_thread = false;\n    config.lang = \"javascript\";\n    config.api_version = API_VERSION;\n    const conn = new Connection(config);\n    conn.init().catch(reject);\n  });\n}\n"],"sourceRoot":""}