buttplug 3.0.0 → 3.1.1

package/dist/web/buttplug.min.js.map

@@ -1 +1 @@
-{"version":3,"sources":["webpack://Buttplug/webpack/universalModuleDefinition","webpack://Buttplug/webpack/bootstrap","webpack://Buttplug/./node_modules/base64-js/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/ClassTransformer.js","webpack://Buttplug/./node_modules/class-transformer/esm5/MetadataStorage.js","webpack://Buttplug/./node_modules/class-transformer/esm5/TransformOperationExecutor.js","webpack://Buttplug/./node_modules/class-transformer/esm5/constants/default-options.constant.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/exclude.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/expose.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/transform-instance-to-instance.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/transform-instance-to-plain.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/transform-plain-to-instance.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/transform.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/type.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/enums/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/enums/transformation-type.enum.js","webpack://Buttplug/./node_modules/class-transformer/esm5/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/class-constructor.type.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/class-transformer-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/exclude-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/expose-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/transform-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/type-discriminator-descriptor.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/type-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/exclude-metadata.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/expose-metadata.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/transform-fn-params.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/transform-metadata.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/type-metadata.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/target-map.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/type-help-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/storage.js","webpack://Buttplug/./node_modules/class-transformer/esm5/utils/get-global.util.js","webpack://Buttplug/./node_modules/class-transformer/esm5/utils/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/utils/is-promise.util.js","webpack://Buttplug/./node_modules/events/events.js","webpack://Buttplug/./node_modules/ieee754/index.js","webpack://Buttplug/./node_modules/isarray/index.js","webpack://Buttplug/./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack://Buttplug/./node_modules/process/browser.js","webpack://Buttplug/./node_modules/reflect-metadata/Reflect.js","webpack://Buttplug/(webpack)/buildin/global.js","webpack://Buttplug/./src/client/ButtplugBrowserWebsocketClientConnector.ts","webpack://Buttplug/./src/client/ButtplugClientConnectorException.ts","webpack://Buttplug/./src/client/ButtplugClientDevice.ts","webpack://Buttplug/./src/client/Client.ts","webpack://Buttplug/./src/core/Exceptions.ts","webpack://Buttplug/./src/core/Logging.ts","webpack://Buttplug/./src/core/MessageUtils.ts","webpack://Buttplug/./src/core/Messages.ts","webpack://Buttplug/./src/index.ts","webpack://Buttplug/./src/utils/ButtplugBrowserWebsocketConnector.ts","webpack://Buttplug/./src/utils/ButtplugMessageSorter.ts"],"names":["webpackUniversalModuleDefinition","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","getDefault","getModuleExports","object","property","prototype","hasOwnProperty","p","s","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","start","end","num","output","__assign","assign","arguments","apply","this","ClassTransformer","instanceToPlain","options","CLASS_TO_PLAIN","transform","undefined","classToPlainFromExist","plainObject","plainToInstance","cls","plain","PLAIN_TO_CLASS","plainToClassFromExist","clsObject","instanceToInstance","CLASS_TO_CLASS","classToClassFromExist","fromObject","serialize","JSON","stringify","deserialize","json","jsonObject","parse","deserializeArray","MetadataStorage","_typeMetadatas","Map","_transformMetadatas","_exposeMetadatas","_excludeMetadatas","_ancestorsMap","addTypeMetadata","metadata","has","target","set","propertyName","addTransformMetadata","addExposeMetadata","addExcludeMetadata","findTransformMetadatas","transformationType","findMetadatas","filter","toClassOnly","toPlainOnly","findExcludeMetadata","findMetadata","findExposeMetadata","findExposeMetadataByCustomName","getExposedMetadatas","find","findTypeMetadata","getStrategy","excludeMap","exclude","exposeMap","expose","getMetadata","getExcludedMetadatas","getExposedProperties","map","getExcludedProperties","clear","metadatas","metadataFromTarget","metadataFromTargetMap","from","values","meta","metadataFromAncestors","_i","_a","getAncestors","ancestor","ancestorMetadataMap","metadataFromAncestor","concat","ancestorResult","metadataFromAncestorsTarget","slice","reverse","ancestors","baseClass","getPrototypeOf","constructor","__spreadArray","to","pack","ar","TransformOperationExecutor","recursionStack","Set","source","targetType","arrayType","isMap","level","_this","isArray","newValue_1","instantiateArrayType","array","forEach","subValue","index","subSource","enableCircularCheck","isCircular","add","realTargetType","discriminator","subTypes","subType","newObject","newType","typeFunction","keepDiscriminatorProperty","value_1","String","Number","Boolean","Date","valueOf","Buffer","Promise","resolve","reject","then","data","keys","getKeys","newValue","_loop_1","valueKey","newValueKey","this_1","ignoreDecorators","exposeMetadata","Function","type","isSubValueMap","metadata_1","reflectedType","targetMaps","properties","enableImplicitConversion","Reflect","arrayType_1","getReflectedType","descriptor","getOwnPropertyDescriptor","finalValue","applyCustomTransformations","exposeUnsetFields","transformKey","exposeDefaultValues","keys_1","delete","obj","version","checkVersion","since","until","groups","checkGroups","transformFn","strategy","excludeExtraneousValues","exposedProperties","excludedProperties","excludedProperties_1","includes","excludePrefixes","every","prefix","substr","self","decision","some","optionGroup","defaultOptions","Exclude","Expose","TransformInstanceToInstance","params","propertyKey","classTransformer","originalMethod","args","result","isPromise","TransformInstanceToPlain","TransformPlainToInstance","classType","Transform","Type","TransformationType","classToPlain","plainToClass","defaultMetadataStorage","getGlobal","globalThis","global","ReflectOwnKeys","R","ReflectApply","receiver","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","isNaN","EventEmitter","init","once","emitter","errorListener","err","removeListener","resolver","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","handler","flags","on","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","TypeError","_getMaxListeners","that","_addListener","prepend","events","existing","newListener","emit","unshift","warned","w","count","ProcessEmitWarning","warning","console","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","_listeners","unwrap","evlistener","unwrapListeners","ret","arrayClone","listenerCount","copy","addEventListener","wrapListener","arg","removeEventListener","RangeError","setMaxListeners","getMaxListeners","doError","error","er","message","context","listeners","addListener","prependListener","prependOnceListener","list","position","originalListener","shift","spliceOne","pop","off","removeAllListeners","rawListeners","eventNames","read","buffer","offset","isLE","mLen","nBytes","e","eLen","eMax","eBias","nBits","NaN","Infinity","Math","pow","write","rt","abs","floor","log","LN2","toString","base64","ieee754","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","__proto__","encodingOrOffset","allocUnsafe","ArrayBuffer","fromArrayBuffer","byteOffset","fromArrayLike","fromString","string","encoding","isEncoding","actual","isBuffer","checked","isnan","val","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","bidirectionalIndexOf","dir","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","buf","readUInt16BE","foundIndex","found","j","hexWrite","remaining","strLen","parsed","parseInt","utf8Write","blitBuffer","asciiWrite","asciiToBytes","str","byteArray","latin1Write","base64Write","ucs2Write","utf16leToBytes","units","hi","lo","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","decodeCodePointsArray","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","SlowBuffer","alloc","INSPECT_MAX_BYTES","typedArraySupport","foo","subarray","poolSize","_augment","species","configurable","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","pos","swap16","swap32","swap64","equals","inspect","max","match","thisStart","thisEnd","thisCopy","targetCopy","isFinite","toJSON","_arr","out","toHex","bytes","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","leadSurrogate","base64clean","stringtrim","trim","replace","src","dst","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","runClearTimeout","marker","Item","noop","nextTick","title","browser","env","argv","versions","binding","cwd","chdir","umask","exporter","makeExporter","previous","writable","hasOwn","supportsSymbol","toPrimitiveSymbol","toPrimitive","iteratorSymbol","iterator","supportsCreate","supportsProto","downLevel","HashMap","MakeDictionary","functionPrototype","usePolyfill","_Map","entries","CreateMapPolyfill","_Set","CreateSetPolyfill","Metadata","WeakMap","CreateWeakMapPolyfill","decorate","decorators","attributes","IsUndefined","IsArray","IsConstructor","DecorateConstructor","IsObject","IsNull","DecorateProperty","ToPropertyKey","metadataKey","metadataValue","decorator","IsPropertyKey","OrdinaryDefineOwnMetadata","defineMetadata","hasMetadata","OrdinaryHasMetadata","hasOwnMetadata","OrdinaryHasOwnMetadata","OrdinaryGetMetadata","getOwnMetadata","OrdinaryGetOwnMetadata","getMetadataKeys","OrdinaryMetadataKeys","getOwnMetadataKeys","OrdinaryOwnMetadataKeys","deleteMetadata","metadataMap","GetOrCreateMetadataMap","targetMetadata","decorated","O","P","Create","MetadataKey","parent","OrdinaryGetPrototypeOf","ToBoolean","MetadataValue","parentKeys","ownKeys_1","parentKeys_1","GetIterator","k","next","IteratorStep","nextValue","IteratorValue","IteratorClose","IsSymbol","ToPrimitive","input","PreferredType","hint","exoticToPrim","GetMethod","OrdinaryToPrimitive","toString_1","IsCallable","toString_2","argument","ToString","V","func","method","iterResult","done","f","proto","prototypeProto","cacheSentinel","arraySentinel","MapIterator","selector","_index","_keys","_values","_selector","throw","return","_cacheKey","_cacheIndex","_find","getKey","getValue","getEntry","insert","_","_map","UUID_SIZE","rootKey","CreateUniqueKey","_key","table","GetOrCreateWeakMapTable","CreateUUID","FillRandomBytes","random","GenRandomBytes","crypto","getRandomValues","msCrypto","byte","__","g","ButtplugBrowserWebsocketClientConnector","ButtplugBrowserWebsocketConnector","_url","super","_sorter","ButtplugMessageSorter","Send","msg","Connected","PrepareOutgoingMessage","SendMessage","ParseIncomingMessage","event","msgs","FromJSON","emitMsgs","ParseIncomingMessages","Blob","reader","FileReader","ev","OnReaderLoad","readAsText","_ws","ButtplugClientConnectorException","ButtplugError","Messages","ErrorClass","ERROR_UNKNOWN","ButtplugClientDevice","_deviceInfo","DeviceName","displayName","DeviceDisplayName","DeviceIndex","messageTimingGap","DeviceMessageTimingGap","messageAttributes","DeviceMessages","static","sendClosure","_sendClosure","allowedMsgs","update","send","sendExpectOk","response","Ok","FromError","ButtplugMessageError","scalar","ScalarCmd","scalarCommandBuilder","speed","actuator","scalarAttrs","ActuatorType","ButtplugDeviceError","cmds","ScalarSubcommand","Index","vibrateAttributes","Vibrate","vibrate","oscillateAttributes","Oscillate","oscillate","rotateAttributes","RotateCmd","rotate","clockwise","rotateAttrs","linearAttributes","linear","duration","linearAttrs","LinearCmd","sensorRead","sensorIndex","sensorType","SensorReadCmd","SensorReading","Data","hasBattery","batteryAttrs","SensorType","Battery","battery","hasRssi","rssiAttrs","RSSI","rssi","rawRead","endpoint","expectedLength","RawReadCmd","Endpoints","RawReading","rawWrite","writeWithResponse","RawWriteCmd","rawSubscribe","RawSubscribeCmd","rawUnsubscribe","RawUnsubscribeCmd","stop","StopDeviceCmd","emitDisconnected","ButtplugClient","clientName","_pingTimer","_connector","_devices","_logger","ButtplugLogger","Logger","_isScanning","connect","connector","Info","Connect","parseMessages","disconnectHandler","initializeConnection","disconnect","Debug","checkConnector","shutdownConnection","Disconnect","startScanning","sendMsgExpectOk","StartScanning","stopScanning","StopScanning","stopAllDevices","StopAllDevices","DeviceAdded","addedMsg","addedDevice","fromMsg","sendDeviceMessageClosure","DeviceRemoved","removedMsg","removedDevice","ScanningFinished","sendMessage","RequestServerInfo","_clientName","MESSAGE_SPEC_VERSION","ServerInfo","serverinfo","ServerName","MaxPingTime","MessageVersion","LogAndError","ButtplugInitError","requestDeviceList","ErrorMessage","RequestDeviceList","Devices","device","clearInterval","sendDeviceMessage","connected","devices","isScanning","deviceMsg","errorClass","InnerError","innerError","Id","messageId","logger","id","SYSTEM_MESSAGE_ID","ErrorCode","ERROR_DEVICE","ERROR_INIT","ButtplugUnknownError","ERROR_PING","ButtplugPingError","ERROR_MSG","inner","ButtplugLogLevel","LogMessage","logMessage","logLevel","hour","getHours","getMinutes","sec","getSeconds","timestamp","Message","LogLevel","Timestamp","FormattedMessage","sLogger","maximumConsoleLogLevel","Off","maximumEventLogLevel","MaximumConsoleLogLevel","buttplugLogLevel","MaximumEventLogLevel","AddLogMessage","Warn","Trace","logMsg","msgarray","DEFAULT_MESSAGE_ID","MAX_ID","MessageAttributes","SensorSubscribeCmd","GenericDeviceMessageAttributes","RawDeviceMessageAttributes","SensorDeviceMessageAttributes","ButtplugMessage","toProtocolFormat","jsonObj","ButtplugDeviceMessage","ButtplugSystemMessage","Ping","Schemversion","DeviceInfo","DeviceList","ClientName","GenericMessageSubcommand","Scalar","Scalars","RotateSubcommand","Speed","Clockwise","deviceIndex","commands","cmdList","Rotations","VectorSubcommand","Position","Duration","cmd","Vectors","SensorIndex","Endpoint","ExpectedLength","Timeout","WriteWithResponse","ws","WebSocket","rej","conErrorCallback","Initialize","close","_useCounter","_counter","_waitingMsgs","msgPromise","noMatch"],"mappings":"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","file":"buttplug.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([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"buttplug-commonjs\"] = factory();\n\telse\n\t\troot[\"Buttplug\"] = 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 = \"./src/index.ts\");\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","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { TransformOperationExecutor } from './TransformOperationExecutor';\nimport { TransformationType } from './enums';\nimport { defaultOptions } from './constants/default-options.constant';\nvar ClassTransformer = /** @class */ (function () {\n    function ClassTransformer() {\n    }\n    ClassTransformer.prototype.instanceToPlain = function (object, options) {\n        var executor = new TransformOperationExecutor(TransformationType.CLASS_TO_PLAIN, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(undefined, object, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.classToPlainFromExist = function (object, plainObject, options) {\n        var executor = new TransformOperationExecutor(TransformationType.CLASS_TO_PLAIN, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(plainObject, object, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.plainToInstance = function (cls, plain, options) {\n        var executor = new TransformOperationExecutor(TransformationType.PLAIN_TO_CLASS, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(undefined, plain, cls, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.plainToClassFromExist = function (clsObject, plain, options) {\n        var executor = new TransformOperationExecutor(TransformationType.PLAIN_TO_CLASS, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(clsObject, plain, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.instanceToInstance = function (object, options) {\n        var executor = new TransformOperationExecutor(TransformationType.CLASS_TO_CLASS, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(undefined, object, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.classToClassFromExist = function (object, fromObject, options) {\n        var executor = new TransformOperationExecutor(TransformationType.CLASS_TO_CLASS, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(fromObject, object, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.serialize = function (object, options) {\n        return JSON.stringify(this.instanceToPlain(object, options));\n    };\n    /**\n     * Deserializes given JSON string to a object of the given class.\n     */\n    ClassTransformer.prototype.deserialize = function (cls, json, options) {\n        var jsonObject = JSON.parse(json);\n        return this.plainToInstance(cls, jsonObject, options);\n    };\n    /**\n     * Deserializes given JSON string to an array of objects of the given class.\n     */\n    ClassTransformer.prototype.deserializeArray = function (cls, json, options) {\n        var jsonObject = JSON.parse(json);\n        return this.plainToInstance(cls, jsonObject, options);\n    };\n    return ClassTransformer;\n}());\nexport { ClassTransformer };\n//# sourceMappingURL=ClassTransformer.js.map","import { TransformationType } from './enums';\n/**\n * Storage all library metadata.\n */\nvar MetadataStorage = /** @class */ (function () {\n    function MetadataStorage() {\n        // -------------------------------------------------------------------------\n        // Properties\n        // -------------------------------------------------------------------------\n        this._typeMetadatas = new Map();\n        this._transformMetadatas = new Map();\n        this._exposeMetadatas = new Map();\n        this._excludeMetadatas = new Map();\n        this._ancestorsMap = new Map();\n    }\n    // -------------------------------------------------------------------------\n    // Adder Methods\n    // -------------------------------------------------------------------------\n    MetadataStorage.prototype.addTypeMetadata = function (metadata) {\n        if (!this._typeMetadatas.has(metadata.target)) {\n            this._typeMetadatas.set(metadata.target, new Map());\n        }\n        this._typeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);\n    };\n    MetadataStorage.prototype.addTransformMetadata = function (metadata) {\n        if (!this._transformMetadatas.has(metadata.target)) {\n            this._transformMetadatas.set(metadata.target, new Map());\n        }\n        if (!this._transformMetadatas.get(metadata.target).has(metadata.propertyName)) {\n            this._transformMetadatas.get(metadata.target).set(metadata.propertyName, []);\n        }\n        this._transformMetadatas.get(metadata.target).get(metadata.propertyName).push(metadata);\n    };\n    MetadataStorage.prototype.addExposeMetadata = function (metadata) {\n        if (!this._exposeMetadatas.has(metadata.target)) {\n            this._exposeMetadatas.set(metadata.target, new Map());\n        }\n        this._exposeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);\n    };\n    MetadataStorage.prototype.addExcludeMetadata = function (metadata) {\n        if (!this._excludeMetadatas.has(metadata.target)) {\n            this._excludeMetadatas.set(metadata.target, new Map());\n        }\n        this._excludeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);\n    };\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n    MetadataStorage.prototype.findTransformMetadatas = function (target, propertyName, transformationType) {\n        return this.findMetadatas(this._transformMetadatas, target, propertyName).filter(function (metadata) {\n            if (!metadata.options)\n                return true;\n            if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)\n                return true;\n            if (metadata.options.toClassOnly === true) {\n                return (transformationType === TransformationType.CLASS_TO_CLASS ||\n                    transformationType === TransformationType.PLAIN_TO_CLASS);\n            }\n            if (metadata.options.toPlainOnly === true) {\n                return transformationType === TransformationType.CLASS_TO_PLAIN;\n            }\n            return true;\n        });\n    };\n    MetadataStorage.prototype.findExcludeMetadata = function (target, propertyName) {\n        return this.findMetadata(this._excludeMetadatas, target, propertyName);\n    };\n    MetadataStorage.prototype.findExposeMetadata = function (target, propertyName) {\n        return this.findMetadata(this._exposeMetadatas, target, propertyName);\n    };\n    MetadataStorage.prototype.findExposeMetadataByCustomName = function (target, name) {\n        return this.getExposedMetadatas(target).find(function (metadata) {\n            return metadata.options && metadata.options.name === name;\n        });\n    };\n    MetadataStorage.prototype.findTypeMetadata = function (target, propertyName) {\n        return this.findMetadata(this._typeMetadatas, target, propertyName);\n    };\n    MetadataStorage.prototype.getStrategy = function (target) {\n        var excludeMap = this._excludeMetadatas.get(target);\n        var exclude = excludeMap && excludeMap.get(undefined);\n        var exposeMap = this._exposeMetadatas.get(target);\n        var expose = exposeMap && exposeMap.get(undefined);\n        if ((exclude && expose) || (!exclude && !expose))\n            return 'none';\n        return exclude ? 'excludeAll' : 'exposeAll';\n    };\n    MetadataStorage.prototype.getExposedMetadatas = function (target) {\n        return this.getMetadata(this._exposeMetadatas, target);\n    };\n    MetadataStorage.prototype.getExcludedMetadatas = function (target) {\n        return this.getMetadata(this._excludeMetadatas, target);\n    };\n    MetadataStorage.prototype.getExposedProperties = function (target, transformationType) {\n        return this.getExposedMetadatas(target)\n            .filter(function (metadata) {\n            if (!metadata.options)\n                return true;\n            if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)\n                return true;\n            if (metadata.options.toClassOnly === true) {\n                return (transformationType === TransformationType.CLASS_TO_CLASS ||\n                    transformationType === TransformationType.PLAIN_TO_CLASS);\n            }\n            if (metadata.options.toPlainOnly === true) {\n                return transformationType === TransformationType.CLASS_TO_PLAIN;\n            }\n            return true;\n        })\n            .map(function (metadata) { return metadata.propertyName; });\n    };\n    MetadataStorage.prototype.getExcludedProperties = function (target, transformationType) {\n        return this.getExcludedMetadatas(target)\n            .filter(function (metadata) {\n            if (!metadata.options)\n                return true;\n            if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)\n                return true;\n            if (metadata.options.toClassOnly === true) {\n                return (transformationType === TransformationType.CLASS_TO_CLASS ||\n                    transformationType === TransformationType.PLAIN_TO_CLASS);\n            }\n            if (metadata.options.toPlainOnly === true) {\n                return transformationType === TransformationType.CLASS_TO_PLAIN;\n            }\n            return true;\n        })\n            .map(function (metadata) { return metadata.propertyName; });\n    };\n    MetadataStorage.prototype.clear = function () {\n        this._typeMetadatas.clear();\n        this._exposeMetadatas.clear();\n        this._excludeMetadatas.clear();\n        this._ancestorsMap.clear();\n    };\n    // -------------------------------------------------------------------------\n    // Private Methods\n    // -------------------------------------------------------------------------\n    MetadataStorage.prototype.getMetadata = function (metadatas, target) {\n        var metadataFromTargetMap = metadatas.get(target);\n        var metadataFromTarget;\n        if (metadataFromTargetMap) {\n            metadataFromTarget = Array.from(metadataFromTargetMap.values()).filter(function (meta) { return meta.propertyName !== undefined; });\n        }\n        var metadataFromAncestors = [];\n        for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {\n            var ancestor = _a[_i];\n            var ancestorMetadataMap = metadatas.get(ancestor);\n            if (ancestorMetadataMap) {\n                var metadataFromAncestor = Array.from(ancestorMetadataMap.values()).filter(function (meta) { return meta.propertyName !== undefined; });\n                metadataFromAncestors.push.apply(metadataFromAncestors, metadataFromAncestor);\n            }\n        }\n        return metadataFromAncestors.concat(metadataFromTarget || []);\n    };\n    MetadataStorage.prototype.findMetadata = function (metadatas, target, propertyName) {\n        var metadataFromTargetMap = metadatas.get(target);\n        if (metadataFromTargetMap) {\n            var metadataFromTarget = metadataFromTargetMap.get(propertyName);\n            if (metadataFromTarget) {\n                return metadataFromTarget;\n            }\n        }\n        for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {\n            var ancestor = _a[_i];\n            var ancestorMetadataMap = metadatas.get(ancestor);\n            if (ancestorMetadataMap) {\n                var ancestorResult = ancestorMetadataMap.get(propertyName);\n                if (ancestorResult) {\n                    return ancestorResult;\n                }\n            }\n        }\n        return undefined;\n    };\n    MetadataStorage.prototype.findMetadatas = function (metadatas, target, propertyName) {\n        var metadataFromTargetMap = metadatas.get(target);\n        var metadataFromTarget;\n        if (metadataFromTargetMap) {\n            metadataFromTarget = metadataFromTargetMap.get(propertyName);\n        }\n        var metadataFromAncestorsTarget = [];\n        for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {\n            var ancestor = _a[_i];\n            var ancestorMetadataMap = metadatas.get(ancestor);\n            if (ancestorMetadataMap) {\n                if (ancestorMetadataMap.has(propertyName)) {\n                    metadataFromAncestorsTarget.push.apply(metadataFromAncestorsTarget, ancestorMetadataMap.get(propertyName));\n                }\n            }\n        }\n        return metadataFromAncestorsTarget\n            .slice()\n            .reverse()\n            .concat((metadataFromTarget || []).slice().reverse());\n    };\n    MetadataStorage.prototype.getAncestors = function (target) {\n        if (!target)\n            return [];\n        if (!this._ancestorsMap.has(target)) {\n            var ancestors = [];\n            for (var baseClass = Object.getPrototypeOf(target.prototype.constructor); typeof baseClass.prototype !== 'undefined'; baseClass = Object.getPrototypeOf(baseClass.prototype.constructor)) {\n                ancestors.push(baseClass);\n            }\n            this._ancestorsMap.set(target, ancestors);\n        }\n        return this._ancestorsMap.get(target);\n    };\n    return MetadataStorage;\n}());\nexport { MetadataStorage };\n//# sourceMappingURL=MetadataStorage.js.map","var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { defaultMetadataStorage } from './storage';\nimport { TransformationType } from './enums';\nimport { getGlobal, isPromise } from './utils';\nfunction instantiateArrayType(arrayType) {\n    var array = new arrayType();\n    if (!(array instanceof Set) && !('push' in array)) {\n        return [];\n    }\n    return array;\n}\nvar TransformOperationExecutor = /** @class */ (function () {\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n    function TransformOperationExecutor(transformationType, options) {\n        this.transformationType = transformationType;\n        this.options = options;\n        // -------------------------------------------------------------------------\n        // Private Properties\n        // -------------------------------------------------------------------------\n        this.recursionStack = new Set();\n    }\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n    TransformOperationExecutor.prototype.transform = function (source, value, targetType, arrayType, isMap, level) {\n        var _this = this;\n        if (level === void 0) { level = 0; }\n        if (Array.isArray(value) || value instanceof Set) {\n            var newValue_1 = arrayType && this.transformationType === TransformationType.PLAIN_TO_CLASS\n                ? instantiateArrayType(arrayType)\n                : [];\n            value.forEach(function (subValue, index) {\n                var subSource = source ? source[index] : undefined;\n                if (!_this.options.enableCircularCheck || !_this.isCircular(subValue)) {\n                    var realTargetType = void 0;\n                    if (typeof targetType !== 'function' &&\n                        targetType &&\n                        targetType.options &&\n                        targetType.options.discriminator &&\n                        targetType.options.discriminator.property &&\n                        targetType.options.discriminator.subTypes) {\n                        if (_this.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                            realTargetType = targetType.options.discriminator.subTypes.find(function (subType) {\n                                return subType.name === subValue[targetType.options.discriminator.property];\n                            });\n                            var options = { newObject: newValue_1, object: subValue, property: undefined };\n                            var newType = targetType.typeFunction(options);\n                            realTargetType === undefined ? (realTargetType = newType) : (realTargetType = realTargetType.value);\n                            if (!targetType.options.keepDiscriminatorProperty)\n                                delete subValue[targetType.options.discriminator.property];\n                        }\n                        if (_this.transformationType === TransformationType.CLASS_TO_CLASS) {\n                            realTargetType = subValue.constructor;\n                        }\n                        if (_this.transformationType === TransformationType.CLASS_TO_PLAIN) {\n                            subValue[targetType.options.discriminator.property] = targetType.options.discriminator.subTypes.find(function (subType) { return subType.value === subValue.constructor; }).name;\n                        }\n                    }\n                    else {\n                        realTargetType = targetType;\n                    }\n                    var value_1 = _this.transform(subSource, subValue, realTargetType, undefined, subValue instanceof Map, level + 1);\n                    if (newValue_1 instanceof Set) {\n                        newValue_1.add(value_1);\n                    }\n                    else {\n                        newValue_1.push(value_1);\n                    }\n                }\n                else if (_this.transformationType === TransformationType.CLASS_TO_CLASS) {\n                    if (newValue_1 instanceof Set) {\n                        newValue_1.add(subValue);\n                    }\n                    else {\n                        newValue_1.push(subValue);\n                    }\n                }\n            });\n            return newValue_1;\n        }\n        else if (targetType === String && !isMap) {\n            if (value === null || value === undefined)\n                return value;\n            return String(value);\n        }\n        else if (targetType === Number && !isMap) {\n            if (value === null || value === undefined)\n                return value;\n            return Number(value);\n        }\n        else if (targetType === Boolean && !isMap) {\n            if (value === null || value === undefined)\n                return value;\n            return Boolean(value);\n        }\n        else if ((targetType === Date || value instanceof Date) && !isMap) {\n            if (value instanceof Date) {\n                return new Date(value.valueOf());\n            }\n            if (value === null || value === undefined)\n                return value;\n            return new Date(value);\n        }\n        else if (!!getGlobal().Buffer && (targetType === Buffer || value instanceof Buffer) && !isMap) {\n            if (value === null || value === undefined)\n                return value;\n            return Buffer.from(value);\n        }\n        else if (isPromise(value) && !isMap) {\n            return new Promise(function (resolve, reject) {\n                value.then(function (data) { return resolve(_this.transform(undefined, data, targetType, undefined, undefined, level + 1)); }, reject);\n            });\n        }\n        else if (!isMap && value !== null && typeof value === 'object' && typeof value.then === 'function') {\n            // Note: We should not enter this, as promise has been handled above\n            // This option simply returns the Promise preventing a JS error from happening and should be an inaccessible path.\n            return value; // skip promise transformation\n        }\n        else if (typeof value === 'object' && value !== null) {\n            // try to guess the type\n            if (!targetType && value.constructor !== Object /* && TransformationType === TransformationType.CLASS_TO_PLAIN*/)\n                if (!Array.isArray(value) && value.constructor === Array) {\n                    // Somebody attempts to convert special Array like object to Array, eg:\n                    // const evilObject = { '100000000': '100000000', __proto__: [] };\n                    // This could be used to cause Denial-of-service attack so we don't allow it.\n                    // See prevent-array-bomb.spec.ts for more details.\n                }\n                else {\n                    // We are good we can use the built-in constructor\n                    targetType = value.constructor;\n                }\n            if (!targetType && source)\n                targetType = source.constructor;\n            if (this.options.enableCircularCheck) {\n                // add transformed type to prevent circular references\n                this.recursionStack.add(value);\n            }\n            var keys = this.getKeys(targetType, value, isMap);\n            var newValue = source ? source : {};\n            if (!source &&\n                (this.transformationType === TransformationType.PLAIN_TO_CLASS ||\n                    this.transformationType === TransformationType.CLASS_TO_CLASS)) {\n                if (isMap) {\n                    newValue = new Map();\n                }\n                else if (targetType) {\n                    newValue = new targetType();\n                }\n                else {\n                    newValue = {};\n                }\n            }\n            var _loop_1 = function (key) {\n                if (key === '__proto__' || key === 'constructor') {\n                    return \"continue\";\n                }\n                var valueKey = key;\n                var newValueKey = key, propertyName = key;\n                if (!this_1.options.ignoreDecorators && targetType) {\n                    if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                        var exposeMetadata = defaultMetadataStorage.findExposeMetadataByCustomName(targetType, key);\n                        if (exposeMetadata) {\n                            propertyName = exposeMetadata.propertyName;\n                            newValueKey = exposeMetadata.propertyName;\n                        }\n                    }\n                    else if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN ||\n                        this_1.transformationType === TransformationType.CLASS_TO_CLASS) {\n                        var exposeMetadata = defaultMetadataStorage.findExposeMetadata(targetType, key);\n                        if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name) {\n                            newValueKey = exposeMetadata.options.name;\n                        }\n                    }\n                }\n                // get a subvalue\n                var subValue = undefined;\n                if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                    /**\n                     * This section is added for the following report:\n                     * https://github.com/typestack/class-transformer/issues/596\n                     *\n                     * We should not call functions or constructors when transforming to class.\n                     */\n                    subValue = value[valueKey];\n                }\n                else {\n                    if (value instanceof Map) {\n                        subValue = value.get(valueKey);\n                    }\n                    else if (value[valueKey] instanceof Function) {\n                        subValue = value[valueKey]();\n                    }\n                    else {\n                        subValue = value[valueKey];\n                    }\n                }\n                // determine a type\n                var type = undefined, isSubValueMap = subValue instanceof Map;\n                if (targetType && isMap) {\n                    type = targetType;\n                }\n                else if (targetType) {\n                    var metadata_1 = defaultMetadataStorage.findTypeMetadata(targetType, propertyName);\n                    if (metadata_1) {\n                        var options = { newObject: newValue, object: value, property: propertyName };\n                        var newType = metadata_1.typeFunction ? metadata_1.typeFunction(options) : metadata_1.reflectedType;\n                        if (metadata_1.options &&\n                            metadata_1.options.discriminator &&\n                            metadata_1.options.discriminator.property &&\n                            metadata_1.options.discriminator.subTypes) {\n                            if (!(value[valueKey] instanceof Array)) {\n                                if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                                    type = metadata_1.options.discriminator.subTypes.find(function (subType) {\n                                        if (subValue && subValue instanceof Object && metadata_1.options.discriminator.property in subValue) {\n                                            return subType.name === subValue[metadata_1.options.discriminator.property];\n                                        }\n                                    });\n                                    type === undefined ? (type = newType) : (type = type.value);\n                                    if (!metadata_1.options.keepDiscriminatorProperty) {\n                                        if (subValue && subValue instanceof Object && metadata_1.options.discriminator.property in subValue) {\n                                            delete subValue[metadata_1.options.discriminator.property];\n                                        }\n                                    }\n                                }\n                                if (this_1.transformationType === TransformationType.CLASS_TO_CLASS) {\n                                    type = subValue.constructor;\n                                }\n                                if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN) {\n                                    if (subValue) {\n                                        subValue[metadata_1.options.discriminator.property] = metadata_1.options.discriminator.subTypes.find(function (subType) { return subType.value === subValue.constructor; }).name;\n                                    }\n                                }\n                            }\n                            else {\n                                type = metadata_1;\n                            }\n                        }\n                        else {\n                            type = newType;\n                        }\n                        isSubValueMap = isSubValueMap || metadata_1.reflectedType === Map;\n                    }\n                    else if (this_1.options.targetMaps) {\n                        // try to find a type in target maps\n                        this_1.options.targetMaps\n                            .filter(function (map) { return map.target === targetType && !!map.properties[propertyName]; })\n                            .forEach(function (map) { return (type = map.properties[propertyName]); });\n                    }\n                    else if (this_1.options.enableImplicitConversion &&\n                        this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                        // if we have no registererd type via the @Type() decorator then we check if we have any\n                        // type declarations in reflect-metadata (type declaration is emited only if some decorator is added to the property.)\n                        var reflectedType = Reflect.getMetadata('design:type', targetType.prototype, propertyName);\n                        if (reflectedType) {\n                            type = reflectedType;\n                        }\n                    }\n                }\n                // if value is an array try to get its custom array type\n                var arrayType_1 = Array.isArray(value[valueKey])\n                    ? this_1.getReflectedType(targetType, propertyName)\n                    : undefined;\n                // const subValueKey = TransformationType === TransformationType.PLAIN_TO_CLASS && newKeyName ? newKeyName : key;\n                var subSource = source ? source[valueKey] : undefined;\n                // if its deserialization then type if required\n                // if we uncomment this types like string[] will not work\n                // if (this.transformationType === TransformationType.PLAIN_TO_CLASS && !type && subValue instanceof Object && !(subValue instanceof Date))\n                //     throw new Error(`Cannot determine type for ${(targetType as any).name }.${propertyName}, did you forget to specify a @Type?`);\n                // if newValue is a source object that has method that match newKeyName then skip it\n                if (newValue.constructor.prototype) {\n                    var descriptor = Object.getOwnPropertyDescriptor(newValue.constructor.prototype, newValueKey);\n                    if ((this_1.transformationType === TransformationType.PLAIN_TO_CLASS ||\n                        this_1.transformationType === TransformationType.CLASS_TO_CLASS) &&\n                        // eslint-disable-next-line @typescript-eslint/unbound-method\n                        ((descriptor && !descriptor.set) || newValue[newValueKey] instanceof Function))\n                        return \"continue\";\n                }\n                if (!this_1.options.enableCircularCheck || !this_1.isCircular(subValue)) {\n                    var transformKey = this_1.transformationType === TransformationType.PLAIN_TO_CLASS ? newValueKey : key;\n                    var finalValue = void 0;\n                    if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN) {\n                        // Get original value\n                        finalValue = value[transformKey];\n                        // Apply custom transformation\n                        finalValue = this_1.applyCustomTransformations(finalValue, targetType, transformKey, value, this_1.transformationType);\n                        // If nothing change, it means no custom transformation was applied, so use the subValue.\n                        finalValue = value[transformKey] === finalValue ? subValue : finalValue;\n                        // Apply the default transformation\n                        finalValue = this_1.transform(subSource, finalValue, type, arrayType_1, isSubValueMap, level + 1);\n                    }\n                    else {\n                        if (subValue === undefined && this_1.options.exposeDefaultValues) {\n                            // Set default value if nothing provided\n                            finalValue = newValue[newValueKey];\n                        }\n                        else {\n                            finalValue = this_1.transform(subSource, subValue, type, arrayType_1, isSubValueMap, level + 1);\n                            finalValue = this_1.applyCustomTransformations(finalValue, targetType, transformKey, value, this_1.transformationType);\n                        }\n                    }\n                    if (finalValue !== undefined || this_1.options.exposeUnsetFields) {\n                        if (newValue instanceof Map) {\n                            newValue.set(newValueKey, finalValue);\n                        }\n                        else {\n                            newValue[newValueKey] = finalValue;\n                        }\n                    }\n                }\n                else if (this_1.transformationType === TransformationType.CLASS_TO_CLASS) {\n                    var finalValue = subValue;\n                    finalValue = this_1.applyCustomTransformations(finalValue, targetType, key, value, this_1.transformationType);\n                    if (finalValue !== undefined || this_1.options.exposeUnsetFields) {\n                        if (newValue instanceof Map) {\n                            newValue.set(newValueKey, finalValue);\n                        }\n                        else {\n                            newValue[newValueKey] = finalValue;\n                        }\n                    }\n                }\n            };\n            var this_1 = this;\n            // traverse over keys\n            for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n                var key = keys_1[_i];\n                _loop_1(key);\n            }\n            if (this.options.enableCircularCheck) {\n                this.recursionStack.delete(value);\n            }\n            return newValue;\n        }\n        else {\n            return value;\n        }\n    };\n    TransformOperationExecutor.prototype.applyCustomTransformations = function (value, target, key, obj, transformationType) {\n        var _this = this;\n        var metadatas = defaultMetadataStorage.findTransformMetadatas(target, key, this.transformationType);\n        // apply versioning options\n        if (this.options.version !== undefined) {\n            metadatas = metadatas.filter(function (metadata) {\n                if (!metadata.options)\n                    return true;\n                return _this.checkVersion(metadata.options.since, metadata.options.until);\n            });\n        }\n        // apply grouping options\n        if (this.options.groups && this.options.groups.length) {\n            metadatas = metadatas.filter(function (metadata) {\n                if (!metadata.options)\n                    return true;\n                return _this.checkGroups(metadata.options.groups);\n            });\n        }\n        else {\n            metadatas = metadatas.filter(function (metadata) {\n                return !metadata.options || !metadata.options.groups || !metadata.options.groups.length;\n            });\n        }\n        metadatas.forEach(function (metadata) {\n            value = metadata.transformFn({ value: value, key: key, obj: obj, type: transformationType, options: _this.options });\n        });\n        return value;\n    };\n    // preventing circular references\n    TransformOperationExecutor.prototype.isCircular = function (object) {\n        return this.recursionStack.has(object);\n    };\n    TransformOperationExecutor.prototype.getReflectedType = function (target, propertyName) {\n        if (!target)\n            return undefined;\n        var meta = defaultMetadataStorage.findTypeMetadata(target, propertyName);\n        return meta ? meta.reflectedType : undefined;\n    };\n    TransformOperationExecutor.prototype.getKeys = function (target, object, isMap) {\n        var _this = this;\n        // determine exclusion strategy\n        var strategy = defaultMetadataStorage.getStrategy(target);\n        if (strategy === 'none')\n            strategy = this.options.strategy || 'exposeAll'; // exposeAll is default strategy\n        // get all keys that need to expose\n        var keys = [];\n        if (strategy === 'exposeAll' || isMap) {\n            if (object instanceof Map) {\n                keys = Array.from(object.keys());\n            }\n            else {\n                keys = Object.keys(object);\n            }\n        }\n        if (isMap) {\n            // expose & exclude do not apply for map keys only to fields\n            return keys;\n        }\n        /**\n         * If decorators are ignored but we don't want the extraneous values, then we use the\n         * metadata to decide which property is needed, but doesn't apply the decorator effect.\n         */\n        if (this.options.ignoreDecorators && this.options.excludeExtraneousValues && target) {\n            var exposedProperties = defaultMetadataStorage.getExposedProperties(target, this.transformationType);\n            var excludedProperties = defaultMetadataStorage.getExcludedProperties(target, this.transformationType);\n            keys = __spreadArray(__spreadArray([], exposedProperties, true), excludedProperties, true);\n        }\n        if (!this.options.ignoreDecorators && target) {\n            // add all exposed to list of keys\n            var exposedProperties = defaultMetadataStorage.getExposedProperties(target, this.transformationType);\n            if (this.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                exposedProperties = exposedProperties.map(function (key) {\n                    var exposeMetadata = defaultMetadataStorage.findExposeMetadata(target, key);\n                    if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name) {\n                        return exposeMetadata.options.name;\n                    }\n                    return key;\n                });\n            }\n            if (this.options.excludeExtraneousValues) {\n                keys = exposedProperties;\n            }\n            else {\n                keys = keys.concat(exposedProperties);\n            }\n            // exclude excluded properties\n            var excludedProperties_1 = defaultMetadataStorage.getExcludedProperties(target, this.transformationType);\n            if (excludedProperties_1.length > 0) {\n                keys = keys.filter(function (key) {\n                    return !excludedProperties_1.includes(key);\n                });\n            }\n            // apply versioning options\n            if (this.options.version !== undefined) {\n                keys = keys.filter(function (key) {\n                    var exposeMetadata = defaultMetadataStorage.findExposeMetadata(target, key);\n                    if (!exposeMetadata || !exposeMetadata.options)\n                        return true;\n                    return _this.checkVersion(exposeMetadata.options.since, exposeMetadata.options.until);\n                });\n            }\n            // apply grouping options\n            if (this.options.groups && this.options.groups.length) {\n                keys = keys.filter(function (key) {\n                    var exposeMetadata = defaultMetadataStorage.findExposeMetadata(target, key);\n                    if (!exposeMetadata || !exposeMetadata.options)\n                        return true;\n                    return _this.checkGroups(exposeMetadata.options.groups);\n                });\n            }\n            else {\n                keys = keys.filter(function (key) {\n                    var exposeMetadata = defaultMetadataStorage.findExposeMetadata(target, key);\n                    return (!exposeMetadata ||\n                        !exposeMetadata.options ||\n                        !exposeMetadata.options.groups ||\n                        !exposeMetadata.options.groups.length);\n                });\n            }\n        }\n        // exclude prefixed properties\n        if (this.options.excludePrefixes && this.options.excludePrefixes.length) {\n            keys = keys.filter(function (key) {\n                return _this.options.excludePrefixes.every(function (prefix) {\n                    return key.substr(0, prefix.length) !== prefix;\n                });\n            });\n        }\n        // make sure we have unique keys\n        keys = keys.filter(function (key, index, self) {\n            return self.indexOf(key) === index;\n        });\n        return keys;\n    };\n    TransformOperationExecutor.prototype.checkVersion = function (since, until) {\n        var decision = true;\n        if (decision && since)\n            decision = this.options.version >= since;\n        if (decision && until)\n            decision = this.options.version < until;\n        return decision;\n    };\n    TransformOperationExecutor.prototype.checkGroups = function (groups) {\n        if (!groups)\n            return true;\n        return this.options.groups.some(function (optionGroup) { return groups.includes(optionGroup); });\n    };\n    return TransformOperationExecutor;\n}());\nexport { TransformOperationExecutor };\n//# sourceMappingURL=TransformOperationExecutor.js.map","/**\n * These are the default options used by any transformation operation.\n */\nexport var defaultOptions = {\n    enableCircularCheck: false,\n    enableImplicitConversion: false,\n    excludeExtraneousValues: false,\n    excludePrefixes: undefined,\n    exposeDefaultValues: false,\n    exposeUnsetFields: true,\n    groups: undefined,\n    ignoreDecorators: false,\n    strategy: undefined,\n    targetMaps: undefined,\n    version: undefined,\n};\n//# sourceMappingURL=default-options.constant.js.map","import { defaultMetadataStorage } from '../storage';\n/**\n * Marks the given class or property as excluded. By default the property is excluded in both\n * constructorToPlain and plainToConstructor transformations. It can be limited to only one direction\n * via using the `toPlainOnly` or `toClassOnly` option.\n *\n * Can be applied to class definitions and properties.\n */\nexport function Exclude(options) {\n    if (options === void 0) { options = {}; }\n    /**\n     * NOTE: The `propertyName` property must be marked as optional because\n     * this decorator used both as a class and a property decorator and the\n     * Typescript compiler will freak out if we make it mandatory as a class\n     * decorator only receives one parameter.\n     */\n    return function (object, propertyName) {\n        defaultMetadataStorage.addExcludeMetadata({\n            target: object instanceof Function ? object : object.constructor,\n            propertyName: propertyName,\n            options: options,\n        });\n    };\n}\n//# sourceMappingURL=exclude.decorator.js.map","import { defaultMetadataStorage } from '../storage';\n/**\n * Marks the given class or property as included. By default the property is included in both\n * constructorToPlain and plainToConstructor transformations. It can be limited to only one direction\n * via using the `toPlainOnly` or `toClassOnly` option.\n *\n * Can be applied to class definitions and properties.\n */\nexport function Expose(options) {\n    if (options === void 0) { options = {}; }\n    /**\n     * NOTE: The `propertyName` property must be marked as optional because\n     * this decorator used both as a class and a property decorator and the\n     * Typescript compiler will freak out if we make it mandatory as a class\n     * decorator only receives one parameter.\n     */\n    return function (object, propertyName) {\n        defaultMetadataStorage.addExposeMetadata({\n            target: object instanceof Function ? object : object.constructor,\n            propertyName: propertyName,\n            options: options,\n        });\n    };\n}\n//# sourceMappingURL=expose.decorator.js.map","export * from './exclude.decorator';\nexport * from './expose.decorator';\nexport * from './transform-instance-to-instance.decorator';\nexport * from './transform-instance-to-plain.decorator';\nexport * from './transform-plain-to-instance.decorator';\nexport * from './transform.decorator';\nexport * from './type.decorator';\n//# sourceMappingURL=index.js.map","import { ClassTransformer } from '../ClassTransformer';\n/**\n * Return the class instance only with the exposed properties.\n *\n * Can be applied to functions and getters/setters only.\n */\nexport function TransformInstanceToInstance(params) {\n    return function (target, propertyKey, descriptor) {\n        var classTransformer = new ClassTransformer();\n        var originalMethod = descriptor.value;\n        descriptor.value = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var result = originalMethod.apply(this, args);\n            var isPromise = !!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function';\n            return isPromise\n                ? result.then(function (data) { return classTransformer.instanceToInstance(data, params); })\n                : classTransformer.instanceToInstance(result, params);\n        };\n    };\n}\n//# sourceMappingURL=transform-instance-to-instance.decorator.js.map","import { ClassTransformer } from '../ClassTransformer';\n/**\n * Transform the object from class to plain object and return only with the exposed properties.\n *\n * Can be applied to functions and getters/setters only.\n */\nexport function TransformInstanceToPlain(params) {\n    return function (target, propertyKey, descriptor) {\n        var classTransformer = new ClassTransformer();\n        var originalMethod = descriptor.value;\n        descriptor.value = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var result = originalMethod.apply(this, args);\n            var isPromise = !!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function';\n            return isPromise\n                ? result.then(function (data) { return classTransformer.instanceToPlain(data, params); })\n                : classTransformer.instanceToPlain(result, params);\n        };\n    };\n}\n//# sourceMappingURL=transform-instance-to-plain.decorator.js.map","import { ClassTransformer } from '../ClassTransformer';\n/**\n * Return the class instance only with the exposed properties.\n *\n * Can be applied to functions and getters/setters only.\n */\nexport function TransformPlainToInstance(classType, params) {\n    return function (target, propertyKey, descriptor) {\n        var classTransformer = new ClassTransformer();\n        var originalMethod = descriptor.value;\n        descriptor.value = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var result = originalMethod.apply(this, args);\n            var isPromise = !!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function';\n            return isPromise\n                ? result.then(function (data) { return classTransformer.plainToInstance(classType, data, params); })\n                : classTransformer.plainToInstance(classType, result, params);\n        };\n    };\n}\n//# sourceMappingURL=transform-plain-to-instance.decorator.js.map","import { defaultMetadataStorage } from '../storage';\n/**\n * Defines a custom logic for value transformation.\n *\n * Can be applied to properties only.\n */\nexport function Transform(transformFn, options) {\n    if (options === void 0) { options = {}; }\n    return function (target, propertyName) {\n        defaultMetadataStorage.addTransformMetadata({\n            target: target.constructor,\n            propertyName: propertyName,\n            transformFn: transformFn,\n            options: options,\n        });\n    };\n}\n//# sourceMappingURL=transform.decorator.js.map","import { defaultMetadataStorage } from '../storage';\n/**\n * Specifies a type of the property.\n * The given TypeFunction can return a constructor. A discriminator can be given in the options.\n *\n * Can be applied to properties only.\n */\nexport function Type(typeFunction, options) {\n    if (options === void 0) { options = {}; }\n    return function (target, propertyName) {\n        var reflectedType = Reflect.getMetadata('design:type', target, propertyName);\n        defaultMetadataStorage.addTypeMetadata({\n            target: target.constructor,\n            propertyName: propertyName,\n            reflectedType: reflectedType,\n            typeFunction: typeFunction,\n            options: options,\n        });\n    };\n}\n//# sourceMappingURL=type.decorator.js.map","export * from './transformation-type.enum';\n//# sourceMappingURL=index.js.map","export var TransformationType;\n(function (TransformationType) {\n    TransformationType[TransformationType[\"PLAIN_TO_CLASS\"] = 0] = \"PLAIN_TO_CLASS\";\n    TransformationType[TransformationType[\"CLASS_TO_PLAIN\"] = 1] = \"CLASS_TO_PLAIN\";\n    TransformationType[TransformationType[\"CLASS_TO_CLASS\"] = 2] = \"CLASS_TO_CLASS\";\n})(TransformationType || (TransformationType = {}));\n//# sourceMappingURL=transformation-type.enum.js.map","import { ClassTransformer } from './ClassTransformer';\nexport { ClassTransformer } from './ClassTransformer';\nexport * from './decorators';\nexport * from './interfaces';\nexport * from './enums';\nvar classTransformer = new ClassTransformer();\nexport function classToPlain(object, options) {\n    return classTransformer.instanceToPlain(object, options);\n}\nexport function instanceToPlain(object, options) {\n    return classTransformer.instanceToPlain(object, options);\n}\nexport function classToPlainFromExist(object, plainObject, options) {\n    return classTransformer.classToPlainFromExist(object, plainObject, options);\n}\nexport function plainToClass(cls, plain, options) {\n    return classTransformer.plainToInstance(cls, plain, options);\n}\nexport function plainToInstance(cls, plain, options) {\n    return classTransformer.plainToInstance(cls, plain, options);\n}\nexport function plainToClassFromExist(clsObject, plain, options) {\n    return classTransformer.plainToClassFromExist(clsObject, plain, options);\n}\nexport function instanceToInstance(object, options) {\n    return classTransformer.instanceToInstance(object, options);\n}\nexport function classToClassFromExist(object, fromObject, options) {\n    return classTransformer.classToClassFromExist(object, fromObject, options);\n}\nexport function serialize(object, options) {\n    return classTransformer.serialize(object, options);\n}\n/**\n * Deserializes given JSON string to a object of the given class.\n *\n * @deprecated This function is being removed. Please use the following instead:\n * ```\n * instanceToClass(cls, JSON.parse(json), options)\n * ```\n */\nexport function deserialize(cls, json, options) {\n    return classTransformer.deserialize(cls, json, options);\n}\n/**\n * Deserializes given JSON string to an array of objects of the given class.\n *\n * @deprecated This function is being removed. Please use the following instead:\n * ```\n * JSON.parse(json).map(value => instanceToClass(cls, value, options))\n * ```\n *\n */\nexport function deserializeArray(cls, json, options) {\n    return classTransformer.deserializeArray(cls, json, options);\n}\n//# sourceMappingURL=index.js.map","export {};\n//# sourceMappingURL=class-constructor.type.js.map","export {};\n//# sourceMappingURL=class-transformer-options.interface.js.map","export {};\n//# sourceMappingURL=exclude-options.interface.js.map","export {};\n//# sourceMappingURL=expose-options.interface.js.map","export {};\n//# sourceMappingURL=transform-options.interface.js.map","export {};\n//# sourceMappingURL=type-discriminator-descriptor.interface.js.map","export {};\n//# sourceMappingURL=type-options.interface.js.map","export * from './decorator-options/expose-options.interface';\nexport * from './decorator-options/exclude-options.interface';\nexport * from './decorator-options/transform-options.interface';\nexport * from './decorator-options/type-discriminator-descriptor.interface';\nexport * from './decorator-options/type-options.interface';\nexport * from './metadata/exclude-metadata.interface';\nexport * from './metadata/expose-metadata.interface';\nexport * from './metadata/transform-metadata.interface';\nexport * from './metadata/transform-fn-params.interface';\nexport * from './metadata/type-metadata.interface';\nexport * from './class-constructor.type';\nexport * from './class-transformer-options.interface';\nexport * from './target-map.interface';\nexport * from './type-help-options.interface';\n//# sourceMappingURL=index.js.map","export {};\n//# sourceMappingURL=exclude-metadata.interface.js.map","export {};\n//# sourceMappingURL=expose-metadata.interface.js.map","export {};\n//# sourceMappingURL=transform-fn-params.interface.js.map","export {};\n//# sourceMappingURL=transform-metadata.interface.js.map","export {};\n//# sourceMappingURL=type-metadata.interface.js.map","export {};\n//# sourceMappingURL=target-map.interface.js.map","export {};\n//# sourceMappingURL=type-help-options.interface.js.map","import { MetadataStorage } from './MetadataStorage';\n/**\n * Default metadata storage is used as singleton and can be used to storage all metadatas.\n */\nexport var defaultMetadataStorage = new MetadataStorage();\n//# sourceMappingURL=storage.js.map","/**\n * This function returns the global object across Node and browsers.\n *\n * Note: `globalThis` is the standardized approach however it has been added to\n * Node.js in version 12. We need to include this snippet until Node 12 EOL.\n */\nexport function getGlobal() {\n    if (typeof globalThis !== 'undefined') {\n        return globalThis;\n    }\n    if (typeof global !== 'undefined') {\n        return global;\n    }\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore: Cannot find name 'window'.\n    if (typeof window !== 'undefined') {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore: Cannot find name 'window'.\n        return window;\n    }\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore: Cannot find name 'self'.\n    if (typeof self !== 'undefined') {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore: Cannot find name 'self'.\n        return self;\n    }\n}\n//# sourceMappingURL=get-global.util.js.map","export * from './get-global.util';\nexport * from './is-promise.util';\n//# sourceMappingURL=index.js.map","export function isPromise(p) {\n    return p !== null && typeof p === 'object' && typeof p.then === 'function';\n}\n//# sourceMappingURL=is-promise.util.js.map","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\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","/*!\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","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! *****************************************************************************\nCopyright (C) Microsoft. All rights reserved.\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\nthis file except in compliance with the License. You may obtain a copy of the\nLicense at http://www.apache.org/licenses/LICENSE-2.0\n\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\nMERCHANTABLITY OR NON-INFRINGEMENT.\n\nSee the Apache Version 2.0 License for specific language governing permissions\nand limitations under the License.\n***************************************************************************** */\nvar Reflect;\n(function (Reflect) {\n    // Metadata Proposal\n    // https://rbuckton.github.io/reflect-metadata/\n    (function (factory) {\n        var root = typeof global === \"object\" ? global :\n            typeof self === \"object\" ? self :\n                typeof this === \"object\" ? this :\n                    Function(\"return this;\")();\n        var exporter = makeExporter(Reflect);\n        if (typeof root.Reflect === \"undefined\") {\n            root.Reflect = Reflect;\n        }\n        else {\n            exporter = makeExporter(root.Reflect, exporter);\n        }\n        factory(exporter);\n        function makeExporter(target, previous) {\n            return function (key, value) {\n                if (typeof target[key] !== \"function\") {\n                    Object.defineProperty(target, key, { configurable: true, writable: true, value: value });\n                }\n                if (previous)\n                    previous(key, value);\n            };\n        }\n    })(function (exporter) {\n        var hasOwn = Object.prototype.hasOwnProperty;\n        // feature test for Symbol support\n        var supportsSymbol = typeof Symbol === \"function\";\n        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== \"undefined\" ? Symbol.toPrimitive : \"@@toPrimitive\";\n        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== \"undefined\" ? Symbol.iterator : \"@@iterator\";\n        var supportsCreate = typeof Object.create === \"function\"; // feature test for Object.create support\n        var supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support\n        var downLevel = !supportsCreate && !supportsProto;\n        var HashMap = {\n            // create an object in dictionary mode (a.k.a. \"slow\" mode in v8)\n            create: supportsCreate\n                ? function () { return MakeDictionary(Object.create(null)); }\n                : supportsProto\n                    ? function () { return MakeDictionary({ __proto__: null }); }\n                    : function () { return MakeDictionary({}); },\n            has: downLevel\n                ? function (map, key) { return hasOwn.call(map, key); }\n                : function (map, key) { return key in map; },\n            get: downLevel\n                ? function (map, key) { return hasOwn.call(map, key) ? map[key] : undefined; }\n                : function (map, key) { return map[key]; },\n        };\n        // Load global or shim versions of Map, Set, and WeakMap\n        var functionPrototype = Object.getPrototypeOf(Function);\n        var usePolyfill = typeof process === \"object\" && process.env && process.env[\"REFLECT_METADATA_USE_MAP_POLYFILL\"] === \"true\";\n        var _Map = !usePolyfill && typeof Map === \"function\" && typeof Map.prototype.entries === \"function\" ? Map : CreateMapPolyfill();\n        var _Set = !usePolyfill && typeof Set === \"function\" && typeof Set.prototype.entries === \"function\" ? Set : CreateSetPolyfill();\n        var _WeakMap = !usePolyfill && typeof WeakMap === \"function\" ? WeakMap : CreateWeakMapPolyfill();\n        // [[Metadata]] internal slot\n        // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots\n        var Metadata = new _WeakMap();\n        /**\n         * Applies a set of decorators to a property of a target object.\n         * @param decorators An array of decorators.\n         * @param target The target object.\n         * @param propertyKey (Optional) The property key to decorate.\n         * @param attributes (Optional) The property descriptor for the target key.\n         * @remarks Decorators are applied in reverse order.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     Example = Reflect.decorate(decoratorsArray, Example);\n         *\n         *     // property (on constructor)\n         *     Reflect.decorate(decoratorsArray, Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     Reflect.decorate(decoratorsArray, Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     Object.defineProperty(Example, \"staticMethod\",\n         *         Reflect.decorate(decoratorsArray, Example, \"staticMethod\",\n         *             Object.getOwnPropertyDescriptor(Example, \"staticMethod\")));\n         *\n         *     // method (on prototype)\n         *     Object.defineProperty(Example.prototype, \"method\",\n         *         Reflect.decorate(decoratorsArray, Example.prototype, \"method\",\n         *             Object.getOwnPropertyDescriptor(Example.prototype, \"method\")));\n         *\n         */\n        function decorate(decorators, target, propertyKey, attributes) {\n            if (!IsUndefined(propertyKey)) {\n                if (!IsArray(decorators))\n                    throw new TypeError();\n                if (!IsObject(target))\n                    throw new TypeError();\n                if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))\n                    throw new TypeError();\n                if (IsNull(attributes))\n                    attributes = undefined;\n                propertyKey = ToPropertyKey(propertyKey);\n                return DecorateProperty(decorators, target, propertyKey, attributes);\n            }\n            else {\n                if (!IsArray(decorators))\n                    throw new TypeError();\n                if (!IsConstructor(target))\n                    throw new TypeError();\n                return DecorateConstructor(decorators, target);\n            }\n        }\n        exporter(\"decorate\", decorate);\n        // 4.1.2 Reflect.metadata(metadataKey, metadataValue)\n        // https://rbuckton.github.io/reflect-metadata/#reflect.metadata\n        /**\n         * A default metadata decorator factory that can be used on a class, class member, or parameter.\n         * @param metadataKey The key for the metadata entry.\n         * @param metadataValue The value for the metadata entry.\n         * @returns A decorator function.\n         * @remarks\n         * If `metadataKey` is already defined for the target and target key, the\n         * metadataValue for that key will be overwritten.\n         * @example\n         *\n         *     // constructor\n         *     @Reflect.metadata(key, value)\n         *     class Example {\n         *     }\n         *\n         *     // property (on constructor, TypeScript only)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         static staticProperty;\n         *     }\n         *\n         *     // property (on prototype, TypeScript only)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         property;\n         *     }\n         *\n         *     // method (on constructor)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         static staticMethod() { }\n         *     }\n         *\n         *     // method (on prototype)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         method() { }\n         *     }\n         *\n         */\n        function metadata(metadataKey, metadataValue) {\n            function decorator(target, propertyKey) {\n                if (!IsObject(target))\n                    throw new TypeError();\n                if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))\n                    throw new TypeError();\n                OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n            }\n            return decorator;\n        }\n        exporter(\"metadata\", metadata);\n        /**\n         * Define a unique metadata entry on the target.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param metadataValue A value that contains attached metadata.\n         * @param target The target object on which to define metadata.\n         * @param propertyKey (Optional) The property key for the target.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example);\n         *\n         *     // property (on constructor)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"method\");\n         *\n         *     // decorator factory as metadata-producing annotation.\n         *     function MyAnnotation(options): Decorator {\n         *         return (target, key?) => Reflect.defineMetadata(\"custom:annotation\", options, target, key);\n         *     }\n         *\n         */\n        function defineMetadata(metadataKey, metadataValue, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n        }\n        exporter(\"defineMetadata\", defineMetadata);\n        /**\n         * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function hasMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryHasMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"hasMetadata\", hasMetadata);\n        /**\n         * Gets a value indicating whether the target object has the provided metadata key defined.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function hasOwnMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"hasOwnMetadata\", hasOwnMetadata);\n        /**\n         * Gets the metadata value for the provided metadata key on the target object or its prototype chain.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function getMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryGetMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"getMetadata\", getMetadata);\n        /**\n         * Gets the metadata value for the provided metadata key on the target object.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function getOwnMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"getOwnMetadata\", getOwnMetadata);\n        /**\n         * Gets the metadata keys defined on the target object or its prototype chain.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns An array of unique metadata keys.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getMetadataKeys(Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getMetadataKeys(Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getMetadataKeys(Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getMetadataKeys(Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getMetadataKeys(Example.prototype, \"method\");\n         *\n         */\n        function getMetadataKeys(target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryMetadataKeys(target, propertyKey);\n        }\n        exporter(\"getMetadataKeys\", getMetadataKeys);\n        /**\n         * Gets the unique metadata keys defined on the target object.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns An array of unique metadata keys.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getOwnMetadataKeys(Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getOwnMetadataKeys(Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getOwnMetadataKeys(Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getOwnMetadataKeys(Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getOwnMetadataKeys(Example.prototype, \"method\");\n         *\n         */\n        function getOwnMetadataKeys(target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryOwnMetadataKeys(target, propertyKey);\n        }\n        exporter(\"getOwnMetadataKeys\", getOwnMetadataKeys);\n        /**\n         * Deletes the metadata entry from the target object with the provided key.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata entry was found and deleted; otherwise, false.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function deleteMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            var metadataMap = GetOrCreateMetadataMap(target, propertyKey, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return false;\n            if (!metadataMap.delete(metadataKey))\n                return false;\n            if (metadataMap.size > 0)\n                return true;\n            var targetMetadata = Metadata.get(target);\n            targetMetadata.delete(propertyKey);\n            if (targetMetadata.size > 0)\n                return true;\n            Metadata.delete(target);\n            return true;\n        }\n        exporter(\"deleteMetadata\", deleteMetadata);\n        function DecorateConstructor(decorators, target) {\n            for (var i = decorators.length - 1; i >= 0; --i) {\n                var decorator = decorators[i];\n                var decorated = decorator(target);\n                if (!IsUndefined(decorated) && !IsNull(decorated)) {\n                    if (!IsConstructor(decorated))\n                        throw new TypeError();\n                    target = decorated;\n                }\n            }\n            return target;\n        }\n        function DecorateProperty(decorators, target, propertyKey, descriptor) {\n            for (var i = decorators.length - 1; i >= 0; --i) {\n                var decorator = decorators[i];\n                var decorated = decorator(target, propertyKey, descriptor);\n                if (!IsUndefined(decorated) && !IsNull(decorated)) {\n                    if (!IsObject(decorated))\n                        throw new TypeError();\n                    descriptor = decorated;\n                }\n            }\n            return descriptor;\n        }\n        function GetOrCreateMetadataMap(O, P, Create) {\n            var targetMetadata = Metadata.get(O);\n            if (IsUndefined(targetMetadata)) {\n                if (!Create)\n                    return undefined;\n                targetMetadata = new _Map();\n                Metadata.set(O, targetMetadata);\n            }\n            var metadataMap = targetMetadata.get(P);\n            if (IsUndefined(metadataMap)) {\n                if (!Create)\n                    return undefined;\n                metadataMap = new _Map();\n                targetMetadata.set(P, metadataMap);\n            }\n            return metadataMap;\n        }\n        // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata\n        function OrdinaryHasMetadata(MetadataKey, O, P) {\n            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n            if (hasOwn)\n                return true;\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (!IsNull(parent))\n                return OrdinaryHasMetadata(MetadataKey, parent, P);\n            return false;\n        }\n        // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata\n        function OrdinaryHasOwnMetadata(MetadataKey, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return false;\n            return ToBoolean(metadataMap.has(MetadataKey));\n        }\n        // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata\n        function OrdinaryGetMetadata(MetadataKey, O, P) {\n            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n            if (hasOwn)\n                return OrdinaryGetOwnMetadata(MetadataKey, O, P);\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (!IsNull(parent))\n                return OrdinaryGetMetadata(MetadataKey, parent, P);\n            return undefined;\n        }\n        // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata\n        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return undefined;\n            return metadataMap.get(MetadataKey);\n        }\n        // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata\n        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);\n            metadataMap.set(MetadataKey, MetadataValue);\n        }\n        // 3.1.6.1 OrdinaryMetadataKeys(O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys\n        function OrdinaryMetadataKeys(O, P) {\n            var ownKeys = OrdinaryOwnMetadataKeys(O, P);\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (parent === null)\n                return ownKeys;\n            var parentKeys = OrdinaryMetadataKeys(parent, P);\n            if (parentKeys.length <= 0)\n                return ownKeys;\n            if (ownKeys.length <= 0)\n                return parentKeys;\n            var set = new _Set();\n            var keys = [];\n            for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {\n                var key = ownKeys_1[_i];\n                var hasKey = set.has(key);\n                if (!hasKey) {\n                    set.add(key);\n                    keys.push(key);\n                }\n            }\n            for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {\n                var key = parentKeys_1[_a];\n                var hasKey = set.has(key);\n                if (!hasKey) {\n                    set.add(key);\n                    keys.push(key);\n                }\n            }\n            return keys;\n        }\n        // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys\n        function OrdinaryOwnMetadataKeys(O, P) {\n            var keys = [];\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return keys;\n            var keysObj = metadataMap.keys();\n            var iterator = GetIterator(keysObj);\n            var k = 0;\n            while (true) {\n                var next = IteratorStep(iterator);\n                if (!next) {\n                    keys.length = k;\n                    return keys;\n                }\n                var nextValue = IteratorValue(next);\n                try {\n                    keys[k] = nextValue;\n                }\n                catch (e) {\n                    try {\n                        IteratorClose(iterator);\n                    }\n                    finally {\n                        throw e;\n                    }\n                }\n                k++;\n            }\n        }\n        // 6 ECMAScript Data Typ0es and Values\n        // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\n        function Type(x) {\n            if (x === null)\n                return 1 /* Null */;\n            switch (typeof x) {\n                case \"undefined\": return 0 /* Undefined */;\n                case \"boolean\": return 2 /* Boolean */;\n                case \"string\": return 3 /* String */;\n                case \"symbol\": return 4 /* Symbol */;\n                case \"number\": return 5 /* Number */;\n                case \"object\": return x === null ? 1 /* Null */ : 6 /* Object */;\n                default: return 6 /* Object */;\n            }\n        }\n        // 6.1.1 The Undefined Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type\n        function IsUndefined(x) {\n            return x === undefined;\n        }\n        // 6.1.2 The Null Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type\n        function IsNull(x) {\n            return x === null;\n        }\n        // 6.1.5 The Symbol Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type\n        function IsSymbol(x) {\n            return typeof x === \"symbol\";\n        }\n        // 6.1.7 The Object Type\n        // https://tc39.github.io/ecma262/#sec-object-type\n        function IsObject(x) {\n            return typeof x === \"object\" ? x !== null : typeof x === \"function\";\n        }\n        // 7.1 Type Conversion\n        // https://tc39.github.io/ecma262/#sec-type-conversion\n        // 7.1.1 ToPrimitive(input [, PreferredType])\n        // https://tc39.github.io/ecma262/#sec-toprimitive\n        function ToPrimitive(input, PreferredType) {\n            switch (Type(input)) {\n                case 0 /* Undefined */: return input;\n                case 1 /* Null */: return input;\n                case 2 /* Boolean */: return input;\n                case 3 /* String */: return input;\n                case 4 /* Symbol */: return input;\n                case 5 /* Number */: return input;\n            }\n            var hint = PreferredType === 3 /* String */ ? \"string\" : PreferredType === 5 /* Number */ ? \"number\" : \"default\";\n            var exoticToPrim = GetMethod(input, toPrimitiveSymbol);\n            if (exoticToPrim !== undefined) {\n                var result = exoticToPrim.call(input, hint);\n                if (IsObject(result))\n                    throw new TypeError();\n                return result;\n            }\n            return OrdinaryToPrimitive(input, hint === \"default\" ? \"number\" : hint);\n        }\n        // 7.1.1.1 OrdinaryToPrimitive(O, hint)\n        // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive\n        function OrdinaryToPrimitive(O, hint) {\n            if (hint === \"string\") {\n                var toString_1 = O.toString;\n                if (IsCallable(toString_1)) {\n                    var result = toString_1.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n                var valueOf = O.valueOf;\n                if (IsCallable(valueOf)) {\n                    var result = valueOf.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n            }\n            else {\n                var valueOf = O.valueOf;\n                if (IsCallable(valueOf)) {\n                    var result = valueOf.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n                var toString_2 = O.toString;\n                if (IsCallable(toString_2)) {\n                    var result = toString_2.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n            }\n            throw new TypeError();\n        }\n        // 7.1.2 ToBoolean(argument)\n        // https://tc39.github.io/ecma262/2016/#sec-toboolean\n        function ToBoolean(argument) {\n            return !!argument;\n        }\n        // 7.1.12 ToString(argument)\n        // https://tc39.github.io/ecma262/#sec-tostring\n        function ToString(argument) {\n            return \"\" + argument;\n        }\n        // 7.1.14 ToPropertyKey(argument)\n        // https://tc39.github.io/ecma262/#sec-topropertykey\n        function ToPropertyKey(argument) {\n            var key = ToPrimitive(argument, 3 /* String */);\n            if (IsSymbol(key))\n                return key;\n            return ToString(key);\n        }\n        // 7.2 Testing and Comparison Operations\n        // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations\n        // 7.2.2 IsArray(argument)\n        // https://tc39.github.io/ecma262/#sec-isarray\n        function IsArray(argument) {\n            return Array.isArray\n                ? Array.isArray(argument)\n                : argument instanceof Object\n                    ? argument instanceof Array\n                    : Object.prototype.toString.call(argument) === \"[object Array]\";\n        }\n        // 7.2.3 IsCallable(argument)\n        // https://tc39.github.io/ecma262/#sec-iscallable\n        function IsCallable(argument) {\n            // NOTE: This is an approximation as we cannot check for [[Call]] internal method.\n            return typeof argument === \"function\";\n        }\n        // 7.2.4 IsConstructor(argument)\n        // https://tc39.github.io/ecma262/#sec-isconstructor\n        function IsConstructor(argument) {\n            // NOTE: This is an approximation as we cannot check for [[Construct]] internal method.\n            return typeof argument === \"function\";\n        }\n        // 7.2.7 IsPropertyKey(argument)\n        // https://tc39.github.io/ecma262/#sec-ispropertykey\n        function IsPropertyKey(argument) {\n            switch (Type(argument)) {\n                case 3 /* String */: return true;\n                case 4 /* Symbol */: return true;\n                default: return false;\n            }\n        }\n        // 7.3 Operations on Objects\n        // https://tc39.github.io/ecma262/#sec-operations-on-objects\n        // 7.3.9 GetMethod(V, P)\n        // https://tc39.github.io/ecma262/#sec-getmethod\n        function GetMethod(V, P) {\n            var func = V[P];\n            if (func === undefined || func === null)\n                return undefined;\n            if (!IsCallable(func))\n                throw new TypeError();\n            return func;\n        }\n        // 7.4 Operations on Iterator Objects\n        // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects\n        function GetIterator(obj) {\n            var method = GetMethod(obj, iteratorSymbol);\n            if (!IsCallable(method))\n                throw new TypeError(); // from Call\n            var iterator = method.call(obj);\n            if (!IsObject(iterator))\n                throw new TypeError();\n            return iterator;\n        }\n        // 7.4.4 IteratorValue(iterResult)\n        // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue\n        function IteratorValue(iterResult) {\n            return iterResult.value;\n        }\n        // 7.4.5 IteratorStep(iterator)\n        // https://tc39.github.io/ecma262/#sec-iteratorstep\n        function IteratorStep(iterator) {\n            var result = iterator.next();\n            return result.done ? false : result;\n        }\n        // 7.4.6 IteratorClose(iterator, completion)\n        // https://tc39.github.io/ecma262/#sec-iteratorclose\n        function IteratorClose(iterator) {\n            var f = iterator[\"return\"];\n            if (f)\n                f.call(iterator);\n        }\n        // 9.1 Ordinary Object Internal Methods and Internal Slots\n        // https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots\n        // 9.1.1.1 OrdinaryGetPrototypeOf(O)\n        // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof\n        function OrdinaryGetPrototypeOf(O) {\n            var proto = Object.getPrototypeOf(O);\n            if (typeof O !== \"function\" || O === functionPrototype)\n                return proto;\n            // TypeScript doesn't set __proto__ in ES5, as it's non-standard.\n            // Try to determine the superclass constructor. Compatible implementations\n            // must either set __proto__ on a subclass constructor to the superclass constructor,\n            // or ensure each class has a valid `constructor` property on its prototype that\n            // points back to the constructor.\n            // If this is not the same as Function.[[Prototype]], then this is definately inherited.\n            // This is the case when in ES6 or when using __proto__ in a compatible browser.\n            if (proto !== functionPrototype)\n                return proto;\n            // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.\n            var prototype = O.prototype;\n            var prototypeProto = prototype && Object.getPrototypeOf(prototype);\n            if (prototypeProto == null || prototypeProto === Object.prototype)\n                return proto;\n            // If the constructor was not a function, then we cannot determine the heritage.\n            var constructor = prototypeProto.constructor;\n            if (typeof constructor !== \"function\")\n                return proto;\n            // If we have some kind of self-reference, then we cannot determine the heritage.\n            if (constructor === O)\n                return proto;\n            // we have a pretty good guess at the heritage.\n            return constructor;\n        }\n        // naive Map shim\n        function CreateMapPolyfill() {\n            var cacheSentinel = {};\n            var arraySentinel = [];\n            var MapIterator = /** @class */ (function () {\n                function MapIterator(keys, values, selector) {\n                    this._index = 0;\n                    this._keys = keys;\n                    this._values = values;\n                    this._selector = selector;\n                }\n                MapIterator.prototype[\"@@iterator\"] = function () { return this; };\n                MapIterator.prototype[iteratorSymbol] = function () { return this; };\n                MapIterator.prototype.next = function () {\n                    var index = this._index;\n                    if (index >= 0 && index < this._keys.length) {\n                        var result = this._selector(this._keys[index], this._values[index]);\n                        if (index + 1 >= this._keys.length) {\n                            this._index = -1;\n                            this._keys = arraySentinel;\n                            this._values = arraySentinel;\n                        }\n                        else {\n                            this._index++;\n                        }\n                        return { value: result, done: false };\n                    }\n                    return { value: undefined, done: true };\n                };\n                MapIterator.prototype.throw = function (error) {\n                    if (this._index >= 0) {\n                        this._index = -1;\n                        this._keys = arraySentinel;\n                        this._values = arraySentinel;\n                    }\n                    throw error;\n                };\n                MapIterator.prototype.return = function (value) {\n                    if (this._index >= 0) {\n                        this._index = -1;\n                        this._keys = arraySentinel;\n                        this._values = arraySentinel;\n                    }\n                    return { value: value, done: true };\n                };\n                return MapIterator;\n            }());\n            return /** @class */ (function () {\n                function Map() {\n                    this._keys = [];\n                    this._values = [];\n                    this._cacheKey = cacheSentinel;\n                    this._cacheIndex = -2;\n                }\n                Object.defineProperty(Map.prototype, \"size\", {\n                    get: function () { return this._keys.length; },\n                    enumerable: true,\n                    configurable: true\n                });\n                Map.prototype.has = function (key) { return this._find(key, /*insert*/ false) >= 0; };\n                Map.prototype.get = function (key) {\n                    var index = this._find(key, /*insert*/ false);\n                    return index >= 0 ? this._values[index] : undefined;\n                };\n                Map.prototype.set = function (key, value) {\n                    var index = this._find(key, /*insert*/ true);\n                    this._values[index] = value;\n                    return this;\n                };\n                Map.prototype.delete = function (key) {\n                    var index = this._find(key, /*insert*/ false);\n                    if (index >= 0) {\n                        var size = this._keys.length;\n                        for (var i = index + 1; i < size; i++) {\n                            this._keys[i - 1] = this._keys[i];\n                            this._values[i - 1] = this._values[i];\n                        }\n                        this._keys.length--;\n                        this._values.length--;\n                        if (key === this._cacheKey) {\n                            this._cacheKey = cacheSentinel;\n                            this._cacheIndex = -2;\n                        }\n                        return true;\n                    }\n                    return false;\n                };\n                Map.prototype.clear = function () {\n                    this._keys.length = 0;\n                    this._values.length = 0;\n                    this._cacheKey = cacheSentinel;\n                    this._cacheIndex = -2;\n                };\n                Map.prototype.keys = function () { return new MapIterator(this._keys, this._values, getKey); };\n                Map.prototype.values = function () { return new MapIterator(this._keys, this._values, getValue); };\n                Map.prototype.entries = function () { return new MapIterator(this._keys, this._values, getEntry); };\n                Map.prototype[\"@@iterator\"] = function () { return this.entries(); };\n                Map.prototype[iteratorSymbol] = function () { return this.entries(); };\n                Map.prototype._find = function (key, insert) {\n                    if (this._cacheKey !== key) {\n                        this._cacheIndex = this._keys.indexOf(this._cacheKey = key);\n                    }\n                    if (this._cacheIndex < 0 && insert) {\n                        this._cacheIndex = this._keys.length;\n                        this._keys.push(key);\n                        this._values.push(undefined);\n                    }\n                    return this._cacheIndex;\n                };\n                return Map;\n            }());\n            function getKey(key, _) {\n                return key;\n            }\n            function getValue(_, value) {\n                return value;\n            }\n            function getEntry(key, value) {\n                return [key, value];\n            }\n        }\n        // naive Set shim\n        function CreateSetPolyfill() {\n            return /** @class */ (function () {\n                function Set() {\n                    this._map = new _Map();\n                }\n                Object.defineProperty(Set.prototype, \"size\", {\n                    get: function () { return this._map.size; },\n                    enumerable: true,\n                    configurable: true\n                });\n                Set.prototype.has = function (value) { return this._map.has(value); };\n                Set.prototype.add = function (value) { return this._map.set(value, value), this; };\n                Set.prototype.delete = function (value) { return this._map.delete(value); };\n                Set.prototype.clear = function () { this._map.clear(); };\n                Set.prototype.keys = function () { return this._map.keys(); };\n                Set.prototype.values = function () { return this._map.values(); };\n                Set.prototype.entries = function () { return this._map.entries(); };\n                Set.prototype[\"@@iterator\"] = function () { return this.keys(); };\n                Set.prototype[iteratorSymbol] = function () { return this.keys(); };\n                return Set;\n            }());\n        }\n        // naive WeakMap shim\n        function CreateWeakMapPolyfill() {\n            var UUID_SIZE = 16;\n            var keys = HashMap.create();\n            var rootKey = CreateUniqueKey();\n            return /** @class */ (function () {\n                function WeakMap() {\n                    this._key = CreateUniqueKey();\n                }\n                WeakMap.prototype.has = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? HashMap.has(table, this._key) : false;\n                };\n                WeakMap.prototype.get = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? HashMap.get(table, this._key) : undefined;\n                };\n                WeakMap.prototype.set = function (target, value) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ true);\n                    table[this._key] = value;\n                    return this;\n                };\n                WeakMap.prototype.delete = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? delete table[this._key] : false;\n                };\n                WeakMap.prototype.clear = function () {\n                    // NOTE: not a real clear, just makes the previous data unreachable\n                    this._key = CreateUniqueKey();\n                };\n                return WeakMap;\n            }());\n            function CreateUniqueKey() {\n                var key;\n                do\n                    key = \"@@WeakMap@@\" + CreateUUID();\n                while (HashMap.has(keys, key));\n                keys[key] = true;\n                return key;\n            }\n            function GetOrCreateWeakMapTable(target, create) {\n                if (!hasOwn.call(target, rootKey)) {\n                    if (!create)\n                        return undefined;\n                    Object.defineProperty(target, rootKey, { value: HashMap.create() });\n                }\n                return target[rootKey];\n            }\n            function FillRandomBytes(buffer, size) {\n                for (var i = 0; i < size; ++i)\n                    buffer[i] = Math.random() * 0xff | 0;\n                return buffer;\n            }\n            function GenRandomBytes(size) {\n                if (typeof Uint8Array === \"function\") {\n                    if (typeof crypto !== \"undefined\")\n                        return crypto.getRandomValues(new Uint8Array(size));\n                    if (typeof msCrypto !== \"undefined\")\n                        return msCrypto.getRandomValues(new Uint8Array(size));\n                    return FillRandomBytes(new Uint8Array(size), size);\n                }\n                return FillRandomBytes(new Array(size), size);\n            }\n            function CreateUUID() {\n                var data = GenRandomBytes(UUID_SIZE);\n                // mark as random - RFC 4122 § 4.4\n                data[6] = data[6] & 0x4f | 0x40;\n                data[8] = data[8] & 0xbf | 0x80;\n                var result = \"\";\n                for (var offset = 0; offset < UUID_SIZE; ++offset) {\n                    var byte = data[offset];\n                    if (offset === 4 || offset === 6 || offset === 8)\n                        result += \"-\";\n                    if (byte < 16)\n                        result += \"0\";\n                    result += byte.toString(16).toLowerCase();\n                }\n                return result;\n            }\n        }\n        // uses a heuristic used by v8 and chakra to force an object into dictionary mode.\n        function MakeDictionary(obj) {\n            obj.__ = undefined;\n            delete obj.__;\n            return obj;\n        }\n    });\n})(Reflect || (Reflect = {}));\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","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\n\r\nimport { IButtplugClientConnector } from './IButtplugClientConnector';\r\nimport { ButtplugMessage } from '../core/Messages';\r\nimport { FromJSON } from '../core/MessageUtils';\r\nimport { ButtplugMessageSorter } from '../utils/ButtplugMessageSorter';\r\nimport { ButtplugBrowserWebsocketConnector } from '../utils/ButtplugBrowserWebsocketConnector';\r\n\r\nexport class ButtplugBrowserWebsocketClientConnector\r\n  extends ButtplugBrowserWebsocketConnector\r\n  implements IButtplugClientConnector\r\n{\r\n  private _sorter: ButtplugMessageSorter = new ButtplugMessageSorter(true);\r\n  protected _ws: WebSocket | undefined;\r\n\r\n  public constructor(_url: string) {\r\n    super(_url);\r\n  }\r\n\r\n  public get Connected(): boolean {\r\n    return this._ws !== undefined;\r\n  }\r\n\r\n  public Send = async (msg: ButtplugMessage): Promise<ButtplugMessage> => {\r\n    if (!this.Connected) {\r\n      throw new Error('ButtplugClient not connected');\r\n    }\r\n    const p = this._sorter.PrepareOutgoingMessage(msg);\r\n    this.SendMessage(msg);\r\n    return await p;\r\n  };\r\n\r\n  protected ParseIncomingMessage = (event: MessageEvent) => {\r\n    if (typeof event.data === 'string') {\r\n      const msgs = FromJSON(event.data);\r\n      const emitMsgs = this._sorter.ParseIncomingMessages(msgs);\r\n      this.emit('message', emitMsgs);\r\n    } else if (event.data instanceof Blob) {\r\n      const reader = new FileReader();\r\n      reader.addEventListener('load', (ev) => {\r\n        this.OnReaderLoad(ev);\r\n      });\r\n      reader.readAsText(event.data);\r\n    }\r\n  };\r\n\r\n  protected OnReaderLoad(event: Event) {\r\n    const msgs = FromJSON((event.target as FileReader).result);\r\n    const emitMsgs = this._sorter.ParseIncomingMessages(msgs);\r\n    this.emit('message', emitMsgs);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nimport { ButtplugError } from '../core/Exceptions';\r\nimport * as Messages from '../core/Messages';\r\n\r\nexport class ButtplugClientConnectorException extends ButtplugError {\r\n  public constructor(message: string) {\r\n    super(message, Messages.ErrorClass.ERROR_UNKNOWN);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\nimport * as Messages from '../core/Messages';\r\nimport {\r\n  ButtplugDeviceError,\r\n  ButtplugError,\r\n  ButtplugMessageError,\r\n} from '../core/Exceptions';\r\nimport { EventEmitter } from 'events';\r\n\r\n/**\r\n * Represents an abstract device, capable of taking certain kinds of messages.\r\n */\r\nexport class ButtplugClientDevice extends EventEmitter {\r\n  /**\r\n   * Return the name of the device.\r\n   */\r\n  public get name(): string {\r\n    return this._deviceInfo.DeviceName;\r\n  }\r\n\r\n  /**\r\n   * Return the user set name of the device.\r\n   */\r\n  public get displayName(): string | undefined {\r\n    return this._deviceInfo.DeviceDisplayName;\r\n  }\r\n\r\n  /**\r\n   * Return the index of the device.\r\n   */\r\n  public get index(): number {\r\n    return this._deviceInfo.DeviceIndex;\r\n  }\r\n\r\n  /**\r\n   * Return the index of the device.\r\n   */\r\n  public get messageTimingGap(): number | undefined {\r\n    return this._deviceInfo.DeviceMessageTimingGap;\r\n  }\r\n\r\n  /**\r\n   * Return a list of message types the device accepts.\r\n   */\r\n  public get messageAttributes(): Messages.MessageAttributes {\r\n    return this._deviceInfo.DeviceMessages;\r\n  }\r\n\r\n  public static fromMsg(\r\n    msg: Messages.DeviceInfo,\r\n    sendClosure: (\r\n      device: ButtplugClientDevice,\r\n      msg: Messages.ButtplugDeviceMessage\r\n    ) => Promise<Messages.ButtplugMessage>\r\n  ): ButtplugClientDevice {\r\n    return new ButtplugClientDevice(msg, sendClosure);\r\n  }\r\n\r\n  // Map of messages and their attributes (feature count, etc...)\r\n  private allowedMsgs: Map<string, Messages.MessageAttributes> = new Map<\r\n    string,\r\n    Messages.MessageAttributes\r\n  >();\r\n\r\n  /**\r\n   * @param _index Index of the device, as created by the device manager.\r\n   * @param _name Name of the device.\r\n   * @param allowedMsgs Buttplug messages the device can receive.\r\n   */\r\n  constructor(\r\n    private _deviceInfo: Messages.DeviceInfo,\r\n    private _sendClosure: (\r\n      device: ButtplugClientDevice,\r\n      msg: Messages.ButtplugDeviceMessage\r\n    ) => Promise<Messages.ButtplugMessage>\r\n  ) {\r\n    super();\r\n    _deviceInfo.DeviceMessages.update();\r\n  }\r\n\r\n  public async send(\r\n    msg: Messages.ButtplugDeviceMessage\r\n  ): Promise<Messages.ButtplugMessage> {\r\n    // Assume we're getting the closure from ButtplugClient, which does all of\r\n    // the index/existence/connection/message checks for us.\r\n    return await this._sendClosure(this, msg);\r\n  }\r\n\r\n  public async sendExpectOk(\r\n    msg: Messages.ButtplugDeviceMessage\r\n  ): Promise<void> {\r\n    const response = await this.send(msg);\r\n    switch (response.constructor) {\r\n      case Messages.Ok:\r\n        return;\r\n      case Messages.Error:\r\n        throw ButtplugError.FromError(response as Messages.Error);\r\n      default:\r\n        throw new ButtplugMessageError(\r\n          `Message type ${response.constructor} not handled by SendMsgExpectOk`\r\n        );\r\n    }\r\n  }\r\n\r\n  public async scalar(\r\n    scalar: Messages.ScalarSubcommand | Messages.ScalarSubcommand[]\r\n  ): Promise<void> {\r\n    if (Array.isArray(scalar)) {\r\n      await this.sendExpectOk(new Messages.ScalarCmd(scalar, this.index));\r\n    } else {\r\n      await this.sendExpectOk(new Messages.ScalarCmd([scalar], this.index));\r\n    }\r\n  }\r\n\r\n  private async scalarCommandBuilder(\r\n    speed: number | number[],\r\n    actuator: Messages.ActuatorType\r\n  ) {\r\n    const scalarAttrs = this.messageAttributes.ScalarCmd?.filter(\r\n      (x) => x.ActuatorType === actuator\r\n    );\r\n    if (!scalarAttrs || scalarAttrs.length === 0) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no ${actuator} capabilities`\r\n      );\r\n    }\r\n    const cmds: Messages.ScalarSubcommand[] = [];\r\n    if (typeof speed === 'number') {\r\n      scalarAttrs.forEach((x) =>\r\n        cmds.push(new Messages.ScalarSubcommand(x.Index, speed, actuator))\r\n      );\r\n    } else if (Array.isArray(speed)) {\r\n      if (speed.length > scalarAttrs.length) {\r\n        throw new ButtplugDeviceError(\r\n          `${speed.length} commands send to a device with ${scalarAttrs.length} vibrators`\r\n        );\r\n      }\r\n      scalarAttrs.forEach((x, i) => {\r\n        cmds.push(new Messages.ScalarSubcommand(x.Index, speed[i], actuator));\r\n      });\r\n    } else {\r\n      throw new ButtplugDeviceError(\r\n        `${actuator} can only take numbers or arrays of numbers.`\r\n      );\r\n    }\r\n    await this.scalar(cmds);\r\n  }\r\n\r\n  public get vibrateAttributes(): Messages.GenericDeviceMessageAttributes[] {\r\n    return (\r\n      this.messageAttributes.ScalarCmd?.filter(\r\n        (x) => x.ActuatorType === Messages.ActuatorType.Vibrate\r\n      ) ?? []\r\n    );\r\n  }\r\n\r\n  public async vibrate(speed: number | number[]): Promise<void> {\r\n    await this.scalarCommandBuilder(speed, Messages.ActuatorType.Vibrate);\r\n  }\r\n\r\n  public get oscillateAttributes(): Messages.GenericDeviceMessageAttributes[] {\r\n    return (\r\n      this.messageAttributes.ScalarCmd?.filter(\r\n        (x) => x.ActuatorType === Messages.ActuatorType.Oscillate\r\n      ) ?? []\r\n    );\r\n  }\r\n\r\n  public async oscillate(speed: number | number[]): Promise<void> {\r\n    await this.scalarCommandBuilder(speed, Messages.ActuatorType.Oscillate);\r\n  }\r\n\r\n  public get rotateAttributes(): Messages.GenericDeviceMessageAttributes[] {\r\n    return this.messageAttributes.RotateCmd ?? [];\r\n  }\r\n\r\n  public async rotate(\r\n    values: number | [number, boolean][],\r\n    clockwise?: boolean\r\n  ): Promise<void> {\r\n    const rotateAttrs = this.messageAttributes.RotateCmd;\r\n    if (!rotateAttrs || rotateAttrs.length === 0) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no Rotate capabilities`\r\n      );\r\n    }\r\n    let msg: Messages.RotateCmd;\r\n    if (typeof values === 'number') {\r\n      msg = Messages.RotateCmd.Create(\r\n        this.index,\r\n        new Array(rotateAttrs.length).fill([values, clockwise])\r\n      );\r\n    } else if (Array.isArray(values)) {\r\n      msg = Messages.RotateCmd.Create(this.index, values);\r\n    } else {\r\n      throw new ButtplugDeviceError(\r\n        'SendRotateCmd can only take a number and boolean, or an array of number/boolean tuples'\r\n      );\r\n    }\r\n    await this.sendExpectOk(msg);\r\n  }\r\n\r\n  public get linearAttributes(): Messages.GenericDeviceMessageAttributes[] {\r\n    return this.messageAttributes.RotateCmd ?? [];\r\n  }\r\n\r\n  public async linear(\r\n    values: number | [number, number][],\r\n    duration?: number\r\n  ): Promise<void> {\r\n    const linearAttrs = this.messageAttributes.LinearCmd;\r\n    if (!linearAttrs || linearAttrs.length === 0) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no Linear capabilities`\r\n      );\r\n    }\r\n    let msg: Messages.LinearCmd;\r\n    if (typeof values === 'number') {\r\n      msg = Messages.LinearCmd.Create(\r\n        this.index,\r\n        new Array(linearAttrs.length).fill([values, duration])\r\n      );\r\n    } else if (Array.isArray(values)) {\r\n      msg = Messages.LinearCmd.Create(this.index, values);\r\n    } else {\r\n      throw new ButtplugDeviceError(\r\n        'SendLinearCmd can only take a number and number, or an array of number/number tuples'\r\n      );\r\n    }\r\n    await this.sendExpectOk(msg);\r\n  }\r\n\r\n  public async sensorRead(\r\n    sensorIndex: number,\r\n    sensorType: Messages.SensorType\r\n  ): Promise<number[]> {\r\n    const response = await this.send(\r\n      new Messages.SensorReadCmd(this.index, sensorIndex, sensorType)\r\n    );\r\n    switch (response.constructor) {\r\n      case Messages.SensorReading:\r\n        return (response as Messages.SensorReading).Data;\r\n      case Messages.Error:\r\n        throw ButtplugError.FromError(response as Messages.Error);\r\n      default:\r\n        throw new ButtplugMessageError(\r\n          `Message type ${response.constructor} not handled by sensorRead`\r\n        );\r\n    }\r\n  }\r\n\r\n  public get hasBattery(): boolean {\r\n    const batteryAttrs = this.messageAttributes.SensorReadCmd?.filter(\r\n      (x) => x.SensorType === Messages.SensorType.Battery\r\n    );\r\n    return batteryAttrs !== undefined && batteryAttrs.length > 0;\r\n  }\r\n\r\n  public async battery(): Promise<number> {\r\n    if (!this.hasBattery) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no Battery capabilities`\r\n      );\r\n    }\r\n    const batteryAttrs = this.messageAttributes.SensorReadCmd?.filter(\r\n      (x) => x.SensorType === Messages.SensorType.Battery\r\n    );\r\n    // Find the battery sensor, we'll need its index.\r\n    const result = await this.sensorRead(\r\n      batteryAttrs![0].Index,\r\n      Messages.SensorType.Battery\r\n    );\r\n    return result[0] / 100.0;\r\n  }\r\n\r\n  public get hasRssi(): boolean {\r\n    const rssiAttrs = this.messageAttributes.SensorReadCmd?.filter(\r\n      (x) => x.SensorType === Messages.SensorType.RSSI\r\n    );\r\n    return rssiAttrs !== undefined && rssiAttrs.length === 0;\r\n  }\r\n\r\n  public async rssi(): Promise<number> {\r\n    if (!this.hasRssi) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no RSSI capabilities`\r\n      );\r\n    }\r\n    const rssiAttrs = this.messageAttributes.SensorReadCmd?.filter(\r\n      (x) => x.SensorType === Messages.SensorType.RSSI\r\n    );\r\n    // Find the battery sensor, we'll need its index.\r\n    const result = await this.sensorRead(\r\n      rssiAttrs![0].Index,\r\n      Messages.SensorType.RSSI\r\n    );\r\n    return result[0];\r\n  }\r\n\r\n  public async rawRead(\r\n    endpoint: string,\r\n    expectedLength: number,\r\n    timeout: number\r\n  ): Promise<Uint8Array> {\r\n    if (!this.messageAttributes.RawReadCmd) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw read capabilities`\r\n      );\r\n    }\r\n    if (this.messageAttributes.RawReadCmd.Endpoints.indexOf(endpoint) === -1) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw readable endpoint ${endpoint}`\r\n      );\r\n    }\r\n    const response = await this.send(\r\n      new Messages.RawReadCmd(this.index, endpoint, expectedLength, timeout)\r\n    );\r\n    switch (response.constructor) {\r\n      case Messages.RawReading:\r\n        return new Uint8Array((response as Messages.RawReading).Data);\r\n      case Messages.Error:\r\n        throw ButtplugError.FromError(response as Messages.Error);\r\n      default:\r\n        throw new ButtplugMessageError(\r\n          `Message type ${response.constructor} not handled by rawRead`\r\n        );\r\n    }\r\n  }\r\n\r\n  public async rawWrite(\r\n    endpoint: string,\r\n    data: Uint8Array,\r\n    writeWithResponse: boolean\r\n  ): Promise<void> {\r\n    if (!this.messageAttributes.RawWriteCmd) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw write capabilities`\r\n      );\r\n    }\r\n    if (this.messageAttributes.RawWriteCmd.Endpoints.indexOf(endpoint) === -1) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw writable endpoint ${endpoint}`\r\n      );\r\n    }\r\n    await this.sendExpectOk(\r\n      new Messages.RawWriteCmd(this.index, endpoint, data, writeWithResponse)\r\n    );\r\n  }\r\n\r\n  public async rawSubscribe(endpoint: string): Promise<void> {\r\n    if (!this.messageAttributes.RawSubscribeCmd) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw subscribe capabilities`\r\n      );\r\n    }\r\n    if (\r\n      this.messageAttributes.RawSubscribeCmd.Endpoints.indexOf(endpoint) === -1\r\n    ) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw subscribable endpoint ${endpoint}`\r\n      );\r\n    }\r\n    await this.sendExpectOk(new Messages.RawSubscribeCmd(this.index, endpoint));\r\n  }\r\n\r\n  public async rawUnsubscribe(endpoint: string): Promise<void> {\r\n    // This reuses raw subscribe's info.\r\n    if (!this.messageAttributes.RawSubscribeCmd) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw unsubscribe capabilities`\r\n      );\r\n    }\r\n    if (\r\n      this.messageAttributes.RawSubscribeCmd.Endpoints.indexOf(endpoint) === -1\r\n    ) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw unsubscribable endpoint ${endpoint}`\r\n      );\r\n    }\r\n    await this.sendExpectOk(\r\n      new Messages.RawUnsubscribeCmd(this.index, endpoint)\r\n    );\r\n  }\r\n\r\n  public async stop(): Promise<void> {\r\n    await this.sendExpectOk(new Messages.StopDeviceCmd(this.index));\r\n  }\r\n\r\n  public emitDisconnected() {\r\n    this.emit('deviceremoved');\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\n\r\nimport { ButtplugLogger } from '../core/Logging';\r\nimport { EventEmitter } from 'events';\r\nimport { ButtplugClientDevice } from './ButtplugClientDevice';\r\nimport { IButtplugClientConnector } from './IButtplugClientConnector';\r\nimport * as Messages from '../core/Messages';\r\nimport {\r\n  ButtplugDeviceError,\r\n  ButtplugError,\r\n  ButtplugInitError,\r\n  ButtplugMessageError,\r\n} from '../core/Exceptions';\r\nimport { ButtplugClientConnectorException } from './ButtplugClientConnectorException';\r\n\r\nexport class ButtplugClient extends EventEmitter {\r\n  protected _pingTimer: NodeJS.Timeout | null = null;\r\n  protected _connector: IButtplugClientConnector | null = null;\r\n  protected _devices: Map<number, ButtplugClientDevice> = new Map();\r\n  protected _clientName: string;\r\n  protected _logger = ButtplugLogger.Logger;\r\n  protected _isScanning = false;\r\n\r\n  constructor(clientName = 'Generic Buttplug Client') {\r\n    super();\r\n    this._clientName = clientName;\r\n    this._logger.Debug(`ButtplugClient: Client ${clientName} created.`);\r\n  }\r\n\r\n  public get connected(): boolean {\r\n    return this._connector !== null && this._connector.Connected;\r\n  }\r\n\r\n  public get devices(): ButtplugClientDevice[] {\r\n    // While this function doesn't actually send a message, if we don't have a\r\n    // connector, we shouldn't have devices.\r\n    this.checkConnector();\r\n    const devices: ButtplugClientDevice[] = [];\r\n    this._devices.forEach((d) => {\r\n      devices.push(d);\r\n    });\r\n    return devices;\r\n  }\r\n\r\n  public get isScanning(): boolean {\r\n    return this._isScanning;\r\n  }\r\n\r\n  public connect = async (connector: IButtplugClientConnector) => {\r\n    this._logger.Info(\r\n      `ButtplugClient: Connecting using ${connector.constructor.name}`\r\n    );\r\n    await connector.Connect();\r\n    this._connector = connector;\r\n    this._connector.addListener('message', this.parseMessages);\r\n    this._connector.addListener('disconnect', this.disconnectHandler);\r\n    await this.initializeConnection();\r\n  };\r\n\r\n  public disconnect = async () => {\r\n    this._logger.Debug('ButtplugClient: Disconnect called');\r\n    this.checkConnector();\r\n    await this.shutdownConnection();\r\n    await this._connector!.Disconnect();\r\n  };\r\n\r\n  public startScanning = async () => {\r\n    this._logger.Debug('ButtplugClient: StartScanning called');\r\n    this._isScanning = true;\r\n    await this.sendMsgExpectOk(new Messages.StartScanning());\r\n  };\r\n\r\n  public stopScanning = async () => {\r\n    this._logger.Debug('ButtplugClient: StopScanning called');\r\n    this._isScanning = false;\r\n    await this.sendMsgExpectOk(new Messages.StopScanning());\r\n  };\r\n\r\n  public stopAllDevices = async () => {\r\n    this._logger.Debug('ButtplugClient: StopAllDevices');\r\n    await this.sendMsgExpectOk(new Messages.StopAllDevices());\r\n  };\r\n\r\n  private async sendDeviceMessage(\r\n    device: ButtplugClientDevice,\r\n    deviceMsg: Messages.ButtplugDeviceMessage\r\n  ): Promise<Messages.ButtplugMessage> {\r\n    this.checkConnector();\r\n    const dev = this._devices.get(device.index);\r\n    if (dev === undefined) {\r\n      throw ButtplugError.LogAndError(\r\n        ButtplugDeviceError,\r\n        this._logger,\r\n        `Device ${device.index} not available.`\r\n      );\r\n    }\r\n    deviceMsg.DeviceIndex = device.index;\r\n    return await this.sendMessage(deviceMsg);\r\n  }\r\n\r\n  protected disconnectHandler = () => {\r\n    this._logger.Info('ButtplugClient: Disconnect event receieved.');\r\n    this.emit('disconnect');\r\n  };\r\n\r\n  protected parseMessages = (msgs: Messages.ButtplugMessage[]) => {\r\n    for (const x of msgs) {\r\n      switch (x.constructor) {\r\n        case Messages.DeviceAdded: {\r\n          const addedMsg = x as Messages.DeviceAdded;\r\n          const addedDevice = ButtplugClientDevice.fromMsg(\r\n            addedMsg,\r\n            this.sendDeviceMessageClosure\r\n          );\r\n          this._devices.set(addedMsg.DeviceIndex, addedDevice);\r\n          this.emit('deviceadded', addedDevice);\r\n          break;\r\n        }\r\n        case Messages.DeviceRemoved: {\r\n          const removedMsg = x as Messages.DeviceRemoved;\r\n          if (this._devices.has(removedMsg.DeviceIndex)) {\r\n            const removedDevice = this._devices.get(removedMsg.DeviceIndex);\r\n            removedDevice?.emitDisconnected();\r\n            this._devices.delete(removedMsg.DeviceIndex);\r\n            this.emit('deviceremoved', removedDevice);\r\n          }\r\n          break;\r\n        }\r\n        case Messages.ScanningFinished:\r\n          this._isScanning = false;\r\n          this.emit('scanningfinished', x);\r\n          break;\r\n      }\r\n    }\r\n  };\r\n\r\n  protected initializeConnection = async (): Promise<boolean> => {\r\n    this.checkConnector();\r\n    const msg = await this.sendMessage(\r\n      new Messages.RequestServerInfo(\r\n        this._clientName,\r\n        Messages.MESSAGE_SPEC_VERSION\r\n      )\r\n    );\r\n    switch (msg.constructor) {\r\n      case Messages.ServerInfo: {\r\n        const serverinfo = msg as Messages.ServerInfo;\r\n        this._logger.Info(\r\n          `ButtplugClient: Connected to Server ${serverinfo.ServerName}`\r\n        );\r\n        // TODO: maybe store server name, do something with message template version?\r\n        const ping = serverinfo.MaxPingTime;\r\n        if (serverinfo.MessageVersion < Messages.MESSAGE_SPEC_VERSION) {\r\n          // Disconnect and throw an exception explaining the version mismatch problem.\r\n          await this._connector!.Disconnect();\r\n          throw ButtplugError.LogAndError(\r\n            ButtplugInitError,\r\n            this._logger,\r\n            `Server protocol version ${serverinfo.MessageVersion} is older than client protocol version ${Messages.MESSAGE_SPEC_VERSION}. Please update server.`\r\n          );\r\n        }\r\n        if (ping > 0) {\r\n          /*\r\n          this._pingTimer = setInterval(async () => {\r\n            // If we've disconnected, stop trying to ping the server.\r\n            if (!this.Connected) {\r\n              await this.ShutdownConnection();\r\n              return;\r\n            }\r\n            await this.SendMessage(new Messages.Ping());\r\n          } , Math.round(ping / 2));\r\n          */\r\n        }\r\n        await this.requestDeviceList();\r\n        return true;\r\n      }\r\n      case Messages.Error: {\r\n        // Disconnect and throw an exception with the error message we got back.\r\n        // This will usually only error out if we have a version mismatch that the\r\n        // server has detected.\r\n        await this._connector!.Disconnect();\r\n        const err = msg as Messages.Error;\r\n        throw ButtplugError.LogAndError(\r\n          ButtplugInitError,\r\n          this._logger,\r\n          `Cannot connect to server. ${err.ErrorMessage}`\r\n        );\r\n      }\r\n    }\r\n    return false;\r\n  };\r\n\r\n  protected requestDeviceList = async () => {\r\n    this.checkConnector();\r\n    this._logger.Debug('ButtplugClient: ReceiveDeviceList called');\r\n    const deviceList = (await this.sendMessage(\r\n      new Messages.RequestDeviceList()\r\n    )) as Messages.DeviceList;\r\n    deviceList.Devices.forEach((d) => {\r\n      if (!this._devices.has(d.DeviceIndex)) {\r\n        const device = ButtplugClientDevice.fromMsg(\r\n          d,\r\n          this.sendDeviceMessageClosure\r\n        );\r\n        this._logger.Debug(`ButtplugClient: Adding Device: ${device}`);\r\n        this._devices.set(d.DeviceIndex, device);\r\n        this.emit('deviceadded', device);\r\n      } else {\r\n        this._logger.Debug(`ButtplugClient: Device already added: ${d}`);\r\n      }\r\n    });\r\n  };\r\n\r\n  protected shutdownConnection = async () => {\r\n    await this.stopAllDevices();\r\n    if (this._pingTimer !== null) {\r\n      clearInterval(this._pingTimer);\r\n      this._pingTimer = null;\r\n    }\r\n  };\r\n\r\n  protected async sendMessage(\r\n    msg: Messages.ButtplugMessage\r\n  ): Promise<Messages.ButtplugMessage> {\r\n    this.checkConnector();\r\n    return await this._connector!.Send(msg);\r\n  }\r\n\r\n  protected checkConnector() {\r\n    if (!this.connected) {\r\n      throw new ButtplugClientConnectorException(\r\n        'ButtplugClient not connected'\r\n      );\r\n    }\r\n  }\r\n\r\n  protected sendMsgExpectOk = async (\r\n    msg: Messages.ButtplugMessage\r\n  ): Promise<void> => {\r\n    const response = await this.sendMessage(msg);\r\n    switch (response.constructor) {\r\n      case Messages.Ok:\r\n        return;\r\n      case Messages.Error:\r\n        throw ButtplugError.FromError(response as Messages.Error);\r\n      default:\r\n        throw ButtplugError.LogAndError(\r\n          ButtplugMessageError,\r\n          this._logger,\r\n          `Message type ${response.constructor} not handled by SendMsgExpectOk`\r\n        );\r\n    }\r\n  };\r\n\r\n  protected sendDeviceMessageClosure = async (\r\n    device: ButtplugClientDevice,\r\n    msg: Messages.ButtplugDeviceMessage\r\n  ): Promise<Messages.ButtplugMessage> => {\r\n    return await this.sendDeviceMessage(device, msg);\r\n  };\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nimport * as Messages from './Messages';\r\nimport { ButtplugLogger } from './Logging';\r\n\r\nexport class ButtplugError extends Error {\r\n  public get ErrorClass(): Messages.ErrorClass {\r\n    return this.errorClass;\r\n  }\r\n\r\n  public get InnerError(): Error | undefined {\r\n    return this.innerError;\r\n  }\r\n\r\n  public get Id(): number | undefined {\r\n    return this.messageId;\r\n  }\r\n\r\n  public get ErrorMessage(): Messages.ButtplugMessage {\r\n    return new Messages.Error(this.message, this.ErrorClass, this.Id);\r\n  }\r\n\r\n  public static LogAndError<T extends ButtplugError>(\r\n    constructor: new (str: string, num: number) => T,\r\n    logger: ButtplugLogger,\r\n    message: string,\r\n    id: number = Messages.SYSTEM_MESSAGE_ID\r\n  ): T {\r\n    logger.Error(message);\r\n    return new constructor(message, id);\r\n  }\r\n\r\n  public static FromError(error: Messages.Error) {\r\n    switch (error.ErrorCode) {\r\n      case Messages.ErrorClass.ERROR_DEVICE:\r\n        return new ButtplugDeviceError(error.ErrorMessage, error.Id);\r\n      case Messages.ErrorClass.ERROR_INIT:\r\n        return new ButtplugInitError(error.ErrorMessage, error.Id);\r\n      case Messages.ErrorClass.ERROR_UNKNOWN:\r\n        return new ButtplugUnknownError(error.ErrorMessage, error.Id);\r\n      case Messages.ErrorClass.ERROR_PING:\r\n        return new ButtplugPingError(error.ErrorMessage, error.Id);\r\n      case Messages.ErrorClass.ERROR_MSG:\r\n        return new ButtplugMessageError(error.ErrorMessage, error.Id);\r\n      default:\r\n        throw new Error(`Message type ${error.ErrorCode} not handled`);\r\n    }\r\n  }\r\n\r\n  public errorClass: Messages.ErrorClass = Messages.ErrorClass.ERROR_UNKNOWN;\r\n  public innerError: Error | undefined;\r\n  public messageId: number | undefined;\r\n\r\n  protected constructor(\r\n    message: string,\r\n    errorClass: Messages.ErrorClass,\r\n    id: number = Messages.SYSTEM_MESSAGE_ID,\r\n    inner?: Error\r\n  ) {\r\n    super(message);\r\n    this.errorClass = errorClass;\r\n    this.innerError = inner;\r\n    this.messageId = id;\r\n  }\r\n}\r\n\r\nexport class ButtplugInitError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_INIT, id);\r\n  }\r\n}\r\n\r\nexport class ButtplugDeviceError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_DEVICE, id);\r\n  }\r\n}\r\n\r\nexport class ButtplugMessageError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_MSG, id);\r\n  }\r\n}\r\n\r\nexport class ButtplugPingError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_PING, id);\r\n  }\r\n}\r\n\r\nexport class ButtplugUnknownError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_UNKNOWN, id);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nimport { EventEmitter } from 'events';\r\n\r\nexport enum ButtplugLogLevel {\r\n  Off,\r\n  Error,\r\n  Warn,\r\n  Info,\r\n  Debug,\r\n  Trace,\r\n}\r\n\r\n/**\r\n * Representation of log messages for the internal logging utility.\r\n */\r\nexport class LogMessage {\r\n  /** Timestamp for the log message */\r\n  private timestamp: string;\r\n\r\n  /** Log Message */\r\n  private logMessage: string;\r\n\r\n  /** Log Level */\r\n  private logLevel: ButtplugLogLevel;\r\n\r\n  /**\r\n   * @param logMessage Log message.\r\n   * @param logLevel: Log severity level.\r\n   */\r\n  public constructor(logMessage: string, logLevel: ButtplugLogLevel) {\r\n    const a = new Date();\r\n    const hour = a.getHours();\r\n    const min = a.getMinutes();\r\n    const sec = a.getSeconds();\r\n    this.timestamp = `${hour}:${min}:${sec}`;\r\n    this.logMessage = logMessage;\r\n    this.logLevel = logLevel;\r\n  }\r\n\r\n  /**\r\n   * Returns the log message.\r\n   */\r\n  public get Message() {\r\n    return this.logMessage;\r\n  }\r\n\r\n  /**\r\n   * Returns the log message level.\r\n   */\r\n  public get LogLevel() {\r\n    return this.logLevel;\r\n  }\r\n\r\n  /**\r\n   * Returns the log message timestamp.\r\n   */\r\n  public get Timestamp() {\r\n    return this.timestamp;\r\n  }\r\n\r\n  /**\r\n   * Returns a formatted string with timestamp, level, and message.\r\n   */\r\n  public get FormattedMessage() {\r\n    return `${ButtplugLogLevel[this.logLevel]} : ${this.timestamp} : ${\r\n      this.logMessage\r\n    }`;\r\n  }\r\n}\r\n\r\n/**\r\n * Simple, global logging utility for the Buttplug client and server. Keeps an\r\n * internal static reference to an instance of itself (singleton pattern,\r\n * basically), and allows message logging throughout the module.\r\n */\r\nexport class ButtplugLogger extends EventEmitter {\r\n  /** Singleton instance for the logger */\r\n  protected static sLogger: ButtplugLogger | undefined = undefined;\r\n  /** Sets maximum log level to log to console */\r\n  protected maximumConsoleLogLevel: ButtplugLogLevel = ButtplugLogLevel.Off;\r\n  /** Sets maximum log level for all log messages */\r\n  protected maximumEventLogLevel: ButtplugLogLevel = ButtplugLogLevel.Off;\r\n\r\n  /**\r\n   * Returns the stored static instance of the logger, creating one if it\r\n   * doesn't currently exist.\r\n   */\r\n  public static get Logger(): ButtplugLogger {\r\n    if (ButtplugLogger.sLogger === undefined) {\r\n      ButtplugLogger.sLogger = new ButtplugLogger();\r\n    }\r\n    return this.sLogger!;\r\n  }\r\n\r\n  /**\r\n   * Constructor. Can only be called internally since we regulate ButtplugLogger\r\n   * ownership.\r\n   */\r\n  protected constructor() {\r\n    super();\r\n  }\r\n\r\n  /**\r\n   * Set the maximum log level to output to console.\r\n   */\r\n  public get MaximumConsoleLogLevel() {\r\n    return this.maximumConsoleLogLevel;\r\n  }\r\n\r\n  /**\r\n   * Get the maximum log level to output to console.\r\n   */\r\n  public set MaximumConsoleLogLevel(buttplugLogLevel: ButtplugLogLevel) {\r\n    this.maximumConsoleLogLevel = buttplugLogLevel;\r\n  }\r\n\r\n  /**\r\n   * Set the global maximum log level\r\n   */\r\n  public get MaximumEventLogLevel() {\r\n    return this.maximumEventLogLevel;\r\n  }\r\n\r\n  /**\r\n   * Get the global maximum log level\r\n   */\r\n  public set MaximumEventLogLevel(logLevel: ButtplugLogLevel) {\r\n    this.maximumEventLogLevel = logLevel;\r\n  }\r\n\r\n  /**\r\n   * Log new message at Error level.\r\n   */\r\n  public Error(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Error);\r\n  }\r\n\r\n  /**\r\n   * Log new message at Warn level.\r\n   */\r\n  public Warn(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Warn);\r\n  }\r\n\r\n  /**\r\n   * Log new message at Info level.\r\n   */\r\n  public Info(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Info);\r\n  }\r\n\r\n  /**\r\n   * Log new message at Debug level.\r\n   */\r\n  public Debug(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Debug);\r\n  }\r\n\r\n  /**\r\n   * Log new message at Trace level.\r\n   */\r\n  public Trace(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Trace);\r\n  }\r\n\r\n  /**\r\n   * Checks to see if message should be logged, and if so, adds message to the\r\n   * log buffer. May also print message and emit event.\r\n   */\r\n  protected AddLogMessage(msg: string, level: ButtplugLogLevel) {\r\n    // If nothing wants the log message we have, ignore it.\r\n    if (\r\n      level > this.maximumEventLogLevel &&\r\n      level > this.maximumConsoleLogLevel\r\n    ) {\r\n      return;\r\n    }\r\n    const logMsg = new LogMessage(msg, level);\r\n    // Clients and console logging may have different needs. For instance, it\r\n    // could be that the client requests trace level, while all we want in the\r\n    // console is info level. This makes sure the client can't also spam the\r\n    // console.\r\n    if (level <= this.maximumConsoleLogLevel) {\r\n      console.log(logMsg.FormattedMessage);\r\n    }\r\n    if (level <= this.maximumEventLogLevel) {\r\n      this.emit('log', logMsg);\r\n    }\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\nimport { plainToInstance } from 'class-transformer';\r\nimport * as Messages from './Messages';\r\n\r\nexport function FromJSON(str): Messages.ButtplugMessage[] {\r\n  const msgarray: object[] = JSON.parse(str);\r\n  const msgs: Messages.ButtplugMessage[] = [];\r\n  for (const x of Array.from(msgarray)) {\r\n    // Can't get this to resolve nicely as a type, so just start from any and cast\r\n    // after. Not sure how to resolve plainToClass to a type since this is\r\n    // dynamic.\r\n    //\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    const msg: any = plainToInstance(\r\n      Messages[Object.getOwnPropertyNames(x)[0]],\r\n      x[Object.getOwnPropertyNames(x)[0]]\r\n    );\r\n    (msg as Messages.ButtplugMessage).update();\r\n    msgs.push(msg as Messages.ButtplugMessage);\r\n  }\r\n  return msgs;\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n// tslint:disable:max-classes-per-file\r\n'use strict';\r\n\r\nimport { instanceToPlain, Type } from 'class-transformer';\r\nimport 'reflect-metadata';\r\n\r\nexport const SYSTEM_MESSAGE_ID = 0;\r\nexport const DEFAULT_MESSAGE_ID = 1;\r\nexport const MAX_ID = 4294967295;\r\nexport const MESSAGE_SPEC_VERSION = 3;\r\n\r\nexport class MessageAttributes {\r\n  public ScalarCmd?: Array<GenericDeviceMessageAttributes>;\r\n  public RotateCmd?: Array<GenericDeviceMessageAttributes>;\r\n  public LinearCmd?: Array<GenericDeviceMessageAttributes>;\r\n  public RawReadCmd?: RawDeviceMessageAttributes;\r\n  public RawWriteCmd?: RawDeviceMessageAttributes;\r\n  public RawSubscribeCmd?: RawDeviceMessageAttributes;\r\n  public SensorReadCmd?: Array<SensorDeviceMessageAttributes>;\r\n  public SensorSubscribeCmd?: Array<SensorDeviceMessageAttributes>;\r\n  public StopDeviceCmd: {};\r\n\r\n  constructor(data: Partial<MessageAttributes>) {\r\n    Object.assign(this, data);\r\n  }\r\n\r\n  public update() {\r\n    this.ScalarCmd?.forEach((x, i) => (x.Index = i));\r\n    this.RotateCmd?.forEach((x, i) => (x.Index = i));\r\n    this.LinearCmd?.forEach((x, i) => (x.Index = i));\r\n    this.SensorReadCmd?.forEach((x, i) => (x.Index = i));\r\n    this.SensorSubscribeCmd?.forEach((x, i) => (x.Index = i));\r\n  }\r\n}\r\n\r\nexport enum ActuatorType {\r\n  Unknown = 'Unknown',\r\n  Vibrate = 'Vibrate',\r\n  Rotate = 'Rotate',\r\n  Oscillate = 'Oscillate',\r\n  Constrict = 'Constrict',\r\n  Inflate = 'Inflate',\r\n  Position = 'Position',\r\n}\r\n\r\nexport enum SensorType {\r\n  Unknown = 'Unknown',\r\n  Battery = 'Battery',\r\n  RSSI = 'RSSI',\r\n  Button = 'Button',\r\n  Pressure = 'Pressure',\r\n  // Temperature,\r\n  // Accelerometer,\r\n  // Gyro,\r\n}\r\n\r\nexport class GenericDeviceMessageAttributes {\r\n  public FeatureDescriptor: string;\r\n  public ActuatorType: ActuatorType;\r\n  public StepCount: number;\r\n  public Index = 0;\r\n  constructor(data: Partial<GenericDeviceMessageAttributes>) {\r\n    Object.assign(this, data);\r\n  }\r\n}\r\n\r\nexport class RawDeviceMessageAttributes {\r\n  constructor(public Endpoints: Array<string>) {}\r\n}\r\n\r\nexport class SensorDeviceMessageAttributes {\r\n  public FeatureDescriptor: string;\r\n  public SensorType: SensorType;\r\n  public StepRange: Array<number>;\r\n  public Index = 0;\r\n  constructor(data: Partial<GenericDeviceMessageAttributes>) {\r\n    Object.assign(this, data);\r\n  }\r\n}\r\nexport abstract class ButtplugMessage {\r\n  constructor(public Id: number) {}\r\n\r\n  /***\r\n   * Returns the message type name\r\n   *\r\n   * Usually, the message type name will be the same as the message class\r\n   * constructor, so the constructor name is used by default. However, in\r\n   * instances where a message has different versions (i.e. DeviceAddedVersion0\r\n   * and DeviceAddedVersion1), we will need to override this to set the message\r\n   * name.\r\n   */\r\n  // tslint:disable-next-line:ban-types\r\n  public get Type(): Function {\r\n    return this.constructor;\r\n  }\r\n\r\n  public toJSON(): string {\r\n    return JSON.stringify(this.toProtocolFormat());\r\n  }\r\n\r\n  public toProtocolFormat(): object {\r\n    const jsonObj = {};\r\n    jsonObj[this.constructor.name] = instanceToPlain(this);\r\n    return jsonObj;\r\n  }\r\n\r\n  public update() {}\r\n}\r\n\r\nexport abstract class ButtplugDeviceMessage extends ButtplugMessage {\r\n  constructor(public DeviceIndex: number, public Id: number) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport abstract class ButtplugSystemMessage extends ButtplugMessage {\r\n  constructor(public Id: number = SYSTEM_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class Ok extends ButtplugSystemMessage {\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class Ping extends ButtplugMessage {\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport enum ErrorClass {\r\n  ERROR_UNKNOWN,\r\n  ERROR_INIT,\r\n  ERROR_PING,\r\n  ERROR_MSG,\r\n  ERROR_DEVICE,\r\n}\r\n\r\nexport class Error extends ButtplugMessage {\r\n  constructor(\r\n    public ErrorMessage: string,\r\n    public ErrorCode: ErrorClass = ErrorClass.ERROR_UNKNOWN,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(Id);\r\n  }\r\n\r\n  get Schemversion() {\r\n    return 0;\r\n  }\r\n}\r\n\r\nexport class DeviceInfo {\r\n  public DeviceIndex: number;\r\n  public DeviceName: string;\r\n  @Type(() => MessageAttributes)\r\n  public DeviceMessages: MessageAttributes;\r\n  public DeviceDisplayName?: string;\r\n  public DeviceMessageTimingGap?: number;\r\n\r\n  constructor(data: Partial<DeviceInfo>) {\r\n    Object.assign(this, data);\r\n  }\r\n}\r\n\r\nexport class DeviceList extends ButtplugMessage {\r\n  @Type(() => DeviceInfo)\r\n  public Devices: DeviceInfo[];\r\n  public Id: number;\r\n\r\n  constructor(devices: DeviceInfo[], id: number = DEFAULT_MESSAGE_ID) {\r\n    super(id);\r\n    this.Devices = devices;\r\n    this.Id = id;\r\n  }\r\n\r\n  public update() {\r\n    for (const device of this.Devices) {\r\n      device.DeviceMessages.update();\r\n    }\r\n  }\r\n}\r\n\r\nexport class DeviceAdded extends ButtplugSystemMessage {\r\n  public DeviceIndex: number;\r\n  public DeviceName: string;\r\n  @Type(() => MessageAttributes)\r\n  public DeviceMessages: MessageAttributes;\r\n  public DeviceDisplayName?: string;\r\n  public DeviceMessageTimingGap?: number;\r\n\r\n  constructor(data: Partial<DeviceAdded>) {\r\n    super();\r\n    Object.assign(this, data);\r\n  }\r\n\r\n  public update() {\r\n    this.DeviceMessages.update();\r\n  }\r\n}\r\n\r\nexport class DeviceRemoved extends ButtplugSystemMessage {\r\n  constructor(public DeviceIndex: number) {\r\n    super();\r\n  }\r\n}\r\n\r\nexport class RequestDeviceList extends ButtplugMessage {\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class StartScanning extends ButtplugMessage {\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class StopScanning extends ButtplugMessage {\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class ScanningFinished extends ButtplugSystemMessage {\r\n  constructor() {\r\n    super();\r\n  }\r\n}\r\n\r\nexport class RequestServerInfo extends ButtplugMessage {\r\n  constructor(\r\n    public ClientName: string,\r\n    public MessageVersion: number = 0,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class ServerInfo extends ButtplugSystemMessage {\r\n  constructor(\r\n    public MessageVersion: number,\r\n    public MaxPingTime: number,\r\n    public ServerName: string,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super();\r\n  }\r\n}\r\n\r\nexport class StopDeviceCmd extends ButtplugDeviceMessage {\r\n  constructor(\r\n    public DeviceIndex: number = -1,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class StopAllDevices extends ButtplugMessage {\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class GenericMessageSubcommand {\r\n  protected constructor(public Index: number) {}\r\n}\r\n\r\nexport class ScalarSubcommand extends GenericMessageSubcommand {\r\n  constructor(\r\n    Index: number,\r\n    public Scalar: number,\r\n    public ActuatorType: ActuatorType\r\n  ) {\r\n    super(Index);\r\n  }\r\n}\r\n\r\nexport class ScalarCmd extends ButtplugDeviceMessage {\r\n  constructor(\r\n    public Scalars: ScalarSubcommand[],\r\n    public DeviceIndex: number = -1,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RotateSubcommand extends GenericMessageSubcommand {\r\n  constructor(Index: number, public Speed: number, public Clockwise: boolean) {\r\n    super(Index);\r\n  }\r\n}\r\n\r\nexport class RotateCmd extends ButtplugDeviceMessage {\r\n  public static Create(\r\n    deviceIndex: number,\r\n    commands: [number, boolean][]\r\n  ): RotateCmd {\r\n    const cmdList: RotateSubcommand[] = new Array<RotateSubcommand>();\r\n\r\n    let i = 0;\r\n    for (const [speed, clockwise] of commands) {\r\n      cmdList.push(new RotateSubcommand(i, speed, clockwise));\r\n      ++i;\r\n    }\r\n\r\n    return new RotateCmd(cmdList, deviceIndex);\r\n  }\r\n  constructor(\r\n    public Rotations: RotateSubcommand[],\r\n    public DeviceIndex: number = -1,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class VectorSubcommand extends GenericMessageSubcommand {\r\n  constructor(Index: number, public Position: number, public Duration: number) {\r\n    super(Index);\r\n  }\r\n}\r\n\r\nexport class LinearCmd extends ButtplugDeviceMessage {\r\n  public static Create(\r\n    deviceIndex: number,\r\n    commands: [number, number][]\r\n  ): LinearCmd {\r\n    const cmdList: VectorSubcommand[] = new Array<VectorSubcommand>();\r\n\r\n    let i = 0;\r\n    for (const cmd of commands) {\r\n      cmdList.push(new VectorSubcommand(i, cmd[0], cmd[1]));\r\n      ++i;\r\n    }\r\n\r\n    return new LinearCmd(cmdList, deviceIndex);\r\n  }\r\n  constructor(\r\n    public Vectors: VectorSubcommand[],\r\n    public DeviceIndex: number = -1,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class SensorReadCmd extends ButtplugDeviceMessage {\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public SensorIndex: number,\r\n    public SensorType: SensorType,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class SensorReading extends ButtplugDeviceMessage {\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public SensorIndex: number,\r\n    public SensorType: SensorType,\r\n    public Data: number[],\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawReadCmd extends ButtplugDeviceMessage {\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public ExpectedLength: number,\r\n    public Timeout: number,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawWriteCmd extends ButtplugDeviceMessage {\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public Data: Uint8Array,\r\n    public WriteWithResponse: boolean,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawSubscribeCmd extends ButtplugDeviceMessage {\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawUnsubscribeCmd extends ButtplugDeviceMessage {\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawReading extends ButtplugDeviceMessage {\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public Data: number[],\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nexport * from './client/Client';\r\nexport * from './client/ButtplugClientDevice';\r\nexport * from './client/ButtplugBrowserWebsocketClientConnector';\r\nexport * from './client/ButtplugClientConnectorException';\r\nexport * from './utils/ButtplugMessageSorter';\r\nexport * from './client/IButtplugClientConnector';\r\nexport * from './core/Messages';\r\nexport * from './core/MessageUtils';\r\nexport * from './core/Logging';\r\nexport * from './core/Exceptions';\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\n\r\nimport { EventEmitter } from 'events';\r\nimport { ButtplugMessage } from '../core/Messages';\r\nimport { FromJSON } from '../core/MessageUtils';\r\n\r\nexport class ButtplugBrowserWebsocketConnector extends EventEmitter {\r\n  protected _ws: WebSocket | undefined;\r\n\r\n  public constructor(private _url: string) {\r\n    super();\r\n  }\r\n\r\n  public get Connected(): boolean {\r\n    return this._ws !== undefined;\r\n  }\r\n\r\n  public Connect = async (): Promise<void> => {\r\n    const ws = new WebSocket(this._url);\r\n    let res;\r\n    let rej;\r\n    const p = new Promise<void>((resolve, reject) => {\r\n      res = resolve;\r\n      rej = reject;\r\n    });\r\n    // In websockets, our error rarely tells us much, as for security reasons\r\n    // browsers usually only throw Error Code 1006. It's up to those using this\r\n    // library to state what the problem might be.\r\n    const conErrorCallback = () => rej();\r\n    ws.addEventListener('open', async () => {\r\n      this._ws = ws;\r\n      try {\r\n        await this.Initialize();\r\n        this._ws.addEventListener('message', (msg) => {\r\n          this.ParseIncomingMessage(msg);\r\n        });\r\n        this._ws.removeEventListener('close', conErrorCallback);\r\n        this._ws.addEventListener('close', this.Disconnect);\r\n        // TODO This doesn't really communicate the chain why our initializer failed\r\n        res();\r\n      } catch (e) {\r\n        console.log(e);\r\n        rej();\r\n      }\r\n    });\r\n    ws.addEventListener('close', conErrorCallback);\r\n    return p;\r\n  };\r\n\r\n  public Disconnect = async (): Promise<void> => {\r\n    if (!this.Connected) {\r\n      return;\r\n    }\r\n    this._ws!.close();\r\n    this._ws = undefined;\r\n    this.emit('disconnect');\r\n  };\r\n\r\n  public SendMessage(msg: ButtplugMessage) {\r\n    if (!this.Connected) {\r\n      throw new Error('ButtplugBrowserWebsocketConnector not connected');\r\n    }\r\n    this._ws!.send('[' + msg.toJSON() + ']');\r\n  }\r\n\r\n  public Initialize = async (): Promise<void> => {\r\n    return Promise.resolve();\r\n  };\r\n\r\n  protected ParseIncomingMessage(event: MessageEvent) {\r\n    console.log('Calling parent parse incoming');\r\n    if (typeof event.data === 'string') {\r\n      const msgs = FromJSON(event.data);\r\n      this.emit('message', msgs);\r\n    } else if (event.data instanceof Blob) {\r\n      const reader = new FileReader();\r\n      reader.addEventListener('load', (ev) => {\r\n        this.OnReaderLoad(ev);\r\n      });\r\n      reader.readAsText(event.data);\r\n    }\r\n  }\r\n\r\n  protected OnReaderLoad(event: Event) {\r\n    const msgs = FromJSON((event.target as FileReader).result);\r\n    this.emit('message', msgs);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nimport * as Messages from '../core/Messages';\r\nimport { ButtplugError } from '../core/Exceptions';\r\n\r\nexport class ButtplugMessageSorter {\r\n  protected _counter = 1;\r\n  protected _waitingMsgs: Map<\r\n    number,\r\n    [(val: Messages.ButtplugMessage) => void, (err: Error) => void]\r\n  > = new Map();\r\n\r\n  public constructor(private _useCounter: boolean) {}\r\n\r\n  // One of the places we should actually return a promise, as we need to store\r\n  // them while waiting for them to return across the line.\r\n  // tslint:disable:promise-function-async\r\n  public PrepareOutgoingMessage(\r\n    msg: Messages.ButtplugMessage\r\n  ): Promise<Messages.ButtplugMessage> {\r\n    if (this._useCounter) {\r\n      msg.Id = this._counter;\r\n      // Always increment last, otherwise we might lose sync\r\n      this._counter += 1;\r\n    }\r\n    let res;\r\n    let rej;\r\n    const msgPromise = new Promise<Messages.ButtplugMessage>(\r\n      (resolve, reject) => {\r\n        res = resolve;\r\n        rej = reject;\r\n      }\r\n    );\r\n    this._waitingMsgs.set(msg.Id, [res, rej]);\r\n    return msgPromise;\r\n  }\r\n\r\n  public ParseIncomingMessages(\r\n    msgs: Messages.ButtplugMessage[]\r\n  ): Messages.ButtplugMessage[] {\r\n    const noMatch: Messages.ButtplugMessage[] = [];\r\n    for (const x of msgs) {\r\n      if (x.Id !== Messages.SYSTEM_MESSAGE_ID && this._waitingMsgs.has(x.Id)) {\r\n        const [res, rej] = this._waitingMsgs.get(x.Id)!;\r\n        // If we've gotten back an error, reject the related promise using a\r\n        // ButtplugException derived type.\r\n        if (x.Type === Messages.Error) {\r\n          rej(ButtplugError.FromError(x as Messages.Error));\r\n          continue;\r\n        }\r\n        res(x);\r\n        continue;\r\n      } else {\r\n        noMatch.push(x);\r\n      }\r\n    }\r\n    return noMatch;\r\n  }\r\n}\r\n"],"sourceRoot":""}
+{"version":3,"sources":["webpack://Buttplug/webpack/universalModuleDefinition","webpack://Buttplug/webpack/bootstrap","webpack://Buttplug/./node_modules/base64-js/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/ClassTransformer.js","webpack://Buttplug/./node_modules/class-transformer/esm5/MetadataStorage.js","webpack://Buttplug/./node_modules/class-transformer/esm5/TransformOperationExecutor.js","webpack://Buttplug/./node_modules/class-transformer/esm5/constants/default-options.constant.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/exclude.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/expose.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/transform-instance-to-instance.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/transform-instance-to-plain.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/transform-plain-to-instance.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/transform.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/decorators/type.decorator.js","webpack://Buttplug/./node_modules/class-transformer/esm5/enums/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/enums/transformation-type.enum.js","webpack://Buttplug/./node_modules/class-transformer/esm5/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/class-constructor.type.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/class-transformer-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/exclude-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/expose-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/transform-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/type-discriminator-descriptor.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/decorator-options/type-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/exclude-metadata.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/expose-metadata.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/transform-fn-params.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/transform-metadata.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/metadata/type-metadata.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/target-map.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/interfaces/type-help-options.interface.js","webpack://Buttplug/./node_modules/class-transformer/esm5/storage.js","webpack://Buttplug/./node_modules/class-transformer/esm5/utils/get-global.util.js","webpack://Buttplug/./node_modules/class-transformer/esm5/utils/index.js","webpack://Buttplug/./node_modules/class-transformer/esm5/utils/is-promise.util.js","webpack://Buttplug/./node_modules/eventemitter3/index.js","webpack://Buttplug/./node_modules/ieee754/index.js","webpack://Buttplug/./node_modules/isarray/index.js","webpack://Buttplug/./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack://Buttplug/./node_modules/process/browser.js","webpack://Buttplug/./node_modules/reflect-metadata/Reflect.js","webpack://Buttplug/(webpack)/buildin/global.js","webpack://Buttplug/./node_modules/ws/browser.js","webpack://Buttplug/./src/client/ButtplugBrowserWebsocketClientConnector.ts","webpack://Buttplug/./src/client/ButtplugClientConnectorException.ts","webpack://Buttplug/./src/client/ButtplugClientDevice.ts","webpack://Buttplug/./src/client/ButtplugNodeWebsocketClientConnector.ts","webpack://Buttplug/./src/client/Client.ts","webpack://Buttplug/./src/core/Exceptions.ts","webpack://Buttplug/./src/core/Logging.ts","webpack://Buttplug/./src/core/MessageUtils.ts","webpack://Buttplug/./src/core/Messages.ts","webpack://Buttplug/./src/index.ts","webpack://Buttplug/./src/utils/ButtplugBrowserWebsocketConnector.ts","webpack://Buttplug/./src/utils/ButtplugMessageSorter.ts"],"names":["webpackUniversalModuleDefinition","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","getDefault","getModuleExports","object","property","prototype","hasOwnProperty","p","s","byteLength","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","arr","Arr","_byteLength","curByte","len","revLookup","charCodeAt","fromByteArray","uint8","length","extraBytes","parts","maxChunkLength","len2","push","encodeChunk","lookup","join","Uint8Array","Array","code","Error","indexOf","start","end","num","output","__assign","assign","arguments","apply","this","ClassTransformer","instanceToPlain","options","CLASS_TO_PLAIN","transform","undefined","classToPlainFromExist","plainObject","plainToInstance","cls","plain","PLAIN_TO_CLASS","plainToClassFromExist","clsObject","instanceToInstance","CLASS_TO_CLASS","classToClassFromExist","fromObject","serialize","JSON","stringify","deserialize","json","jsonObject","parse","deserializeArray","MetadataStorage","_typeMetadatas","Map","_transformMetadatas","_exposeMetadatas","_excludeMetadatas","_ancestorsMap","addTypeMetadata","metadata","has","target","set","propertyName","addTransformMetadata","addExposeMetadata","addExcludeMetadata","findTransformMetadatas","transformationType","findMetadatas","filter","toClassOnly","toPlainOnly","findExcludeMetadata","findMetadata","findExposeMetadata","findExposeMetadataByCustomName","getExposedMetadatas","find","findTypeMetadata","getStrategy","excludeMap","exclude","exposeMap","expose","getMetadata","getExcludedMetadatas","getExposedProperties","map","getExcludedProperties","clear","metadatas","metadataFromTarget","metadataFromTargetMap","from","values","meta","metadataFromAncestors","_i","_a","getAncestors","ancestor","ancestorMetadataMap","metadataFromAncestor","concat","ancestorResult","metadataFromAncestorsTarget","slice","reverse","ancestors","baseClass","getPrototypeOf","constructor","__spreadArray","to","pack","ar","TransformOperationExecutor","recursionStack","Set","source","targetType","arrayType","isMap","level","_this","isArray","newValue_1","instantiateArrayType","array","forEach","subValue","index","subSource","enableCircularCheck","isCircular","add","realTargetType","discriminator","subTypes","subType","newObject","newType","typeFunction","keepDiscriminatorProperty","value_1","String","Number","Boolean","Date","valueOf","Buffer","Promise","resolve","reject","then","data","keys","getKeys","newValue","_loop_1","valueKey","newValueKey","this_1","ignoreDecorators","exposeMetadata","Function","type","isSubValueMap","metadata_1","reflectedType","targetMaps","properties","enableImplicitConversion","Reflect","arrayType_1","getReflectedType","descriptor","getOwnPropertyDescriptor","finalValue","applyCustomTransformations","exposeUnsetFields","transformKey","exposeDefaultValues","keys_1","delete","obj","version","checkVersion","since","until","groups","checkGroups","transformFn","strategy","excludeExtraneousValues","exposedProperties","excludedProperties","excludedProperties_1","includes","excludePrefixes","every","prefix","substr","self","decision","some","optionGroup","defaultOptions","Exclude","Expose","TransformInstanceToInstance","params","propertyKey","classTransformer","originalMethod","args","result","TransformInstanceToPlain","TransformPlainToInstance","classType","Transform","Type","TransformationType","classToPlain","plainToClass","defaultMetadataStorage","getGlobal","globalThis","global","isPromise","Events","EE","fn","context","once","addListener","emitter","event","TypeError","listener","evt","_events","_eventsCount","clearEvent","EventEmitter","__proto__","eventNames","events","names","getOwnPropertySymbols","listeners","handlers","ee","listenerCount","emit","a1","a2","a3","a4","a5","removeListener","j","on","removeAllListeners","off","prefixed","read","buffer","offset","isLE","mLen","nBytes","e","eLen","eMax","eBias","nBits","NaN","Infinity","Math","pow","write","rt","abs","isNaN","floor","log","LN2","toString","base64","ieee754","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","arg","encodingOrOffset","allocUnsafe","ArrayBuffer","fromArrayBuffer","byteOffset","fromArrayLike","fromString","string","encoding","isEncoding","actual","isBuffer","checked","copy","isnan","val","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","bidirectionalIndexOf","dir","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","buf","readUInt16BE","foundIndex","found","hexWrite","remaining","strLen","parsed","parseInt","utf8Write","blitBuffer","asciiWrite","asciiToBytes","str","byteArray","latin1Write","base64Write","ucs2Write","utf16leToBytes","units","hi","lo","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","decodeCodePointsArray","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","SlowBuffer","alloc","INSPECT_MAX_BYTES","typedArraySupport","foo","subarray","poolSize","_augment","species","configurable","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","list","pos","swap16","swap32","swap64","equals","inspect","max","match","thisStart","thisEnd","thisCopy","targetCopy","isFinite","toJSON","_arr","ret","out","toHex","bytes","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","leadSurrogate","base64clean","stringtrim","trim","replace","src","dst","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","runClearTimeout","marker","Item","noop","nextTick","title","browser","env","argv","versions","prependListener","prependOnceListener","binding","cwd","chdir","umask","exporter","makeExporter","previous","writable","hasOwn","supportsSymbol","toPrimitiveSymbol","toPrimitive","iteratorSymbol","iterator","supportsCreate","supportsProto","downLevel","HashMap","MakeDictionary","functionPrototype","usePolyfill","_Map","entries","CreateMapPolyfill","_Set","CreateSetPolyfill","Metadata","WeakMap","CreateWeakMapPolyfill","decorate","decorators","attributes","IsUndefined","IsArray","IsConstructor","DecorateConstructor","IsObject","IsNull","DecorateProperty","ToPropertyKey","metadataKey","metadataValue","decorator","IsPropertyKey","OrdinaryDefineOwnMetadata","defineMetadata","hasMetadata","OrdinaryHasMetadata","hasOwnMetadata","OrdinaryHasOwnMetadata","OrdinaryGetMetadata","getOwnMetadata","OrdinaryGetOwnMetadata","getMetadataKeys","OrdinaryMetadataKeys","getOwnMetadataKeys","OrdinaryOwnMetadataKeys","deleteMetadata","metadataMap","GetOrCreateMetadataMap","targetMetadata","decorated","O","P","Create","MetadataKey","parent","OrdinaryGetPrototypeOf","ToBoolean","MetadataValue","ownKeys","parentKeys","ownKeys_1","parentKeys_1","GetIterator","k","next","IteratorStep","nextValue","IteratorValue","IteratorClose","IsSymbol","ToPrimitive","input","PreferredType","hint","exoticToPrim","GetMethod","OrdinaryToPrimitive","toString_1","IsCallable","toString_2","argument","ToString","V","func","method","iterResult","done","f","proto","prototypeProto","cacheSentinel","arraySentinel","MapIterator","selector","_index","_keys","_values","_selector","throw","error","return","_cacheKey","_cacheIndex","_find","getKey","getValue","getEntry","insert","_","_map","UUID_SIZE","rootKey","CreateUniqueKey","_key","table","GetOrCreateWeakMapTable","CreateUUID","FillRandomBytes","random","GenRandomBytes","crypto","getRandomValues","msCrypto","byte","__","g","ButtplugBrowserWebsocketClientConnector","ButtplugBrowserWebsocketConnector","_sorter","ButtplugMessageSorter","Send","msg","Connected","PrepareOutgoingMessage","SendMessage","ParseIncomingMessage","msgs","FromJSON","emitMsgs","ParseIncomingMessages","Blob","OnReaderLoad","ButtplugClientConnectorException","ButtplugError","message","super","Messages","ErrorClass","ERROR_UNKNOWN","ButtplugClientDevice","_deviceInfo","DeviceName","displayName","DeviceDisplayName","DeviceIndex","messageTimingGap","DeviceMessageTimingGap","messageAttributes","DeviceMessages","static","sendClosure","_sendClosure","allowedMsgs","update","send","sendExpectOk","response","Ok","FromError","ButtplugMessageError","scalar","ScalarCmd","scalarCommandBuilder","speed","actuator","scalarAttrs","ActuatorType","ButtplugDeviceError","cmds","ScalarSubcommand","Index","vibrateAttributes","Vibrate","vibrate","oscillateAttributes","Oscillate","oscillate","rotateAttributes","RotateCmd","rotate","clockwise","rotateAttrs","linearAttributes","linear","duration","linearAttrs","LinearCmd","sensorRead","sensorIndex","sensorType","SensorReadCmd","SensorReading","Data","hasBattery","batteryAttrs","SensorType","Battery","battery","hasRssi","rssiAttrs","RSSI","rssi","rawRead","endpoint","expectedLength","RawReadCmd","Endpoints","RawReading","rawWrite","writeWithResponse","RawWriteCmd","rawSubscribe","RawSubscribeCmd","rawUnsubscribe","RawUnsubscribeCmd","stop","StopDeviceCmd","emitDisconnected","ButtplugNodeWebsocketClientConnector","_websocketConstructor","ButtplugClient","clientName","_pingTimer","_connector","_devices","_logger","ButtplugLogger","Logger","_isScanning","connect","connector","Info","Connect","parseMessages","disconnectHandler","initializeConnection","disconnect","Debug","checkConnector","shutdownConnection","Disconnect","startScanning","sendMsgExpectOk","StartScanning","stopScanning","StopScanning","stopAllDevices","StopAllDevices","DeviceAdded","addedMsg","addedDevice","fromMsg","sendDeviceMessageClosure","DeviceRemoved","removedMsg","removedDevice","ScanningFinished","sendMessage","RequestServerInfo","_clientName","MESSAGE_SPEC_VERSION","ServerInfo","serverinfo","ServerName","MaxPingTime","MessageVersion","LogAndError","ButtplugInitError","requestDeviceList","err","ErrorMessage","RequestDeviceList","Devices","device","clearInterval","sendDeviceMessage","connected","devices","isScanning","deviceMsg","errorClass","InnerError","innerError","Id","messageId","logger","id","SYSTEM_MESSAGE_ID","ErrorCode","ERROR_DEVICE","ERROR_INIT","ButtplugUnknownError","ERROR_PING","ButtplugPingError","ERROR_MSG","inner","ButtplugLogLevel","LogMessage","logMessage","logLevel","hour","getHours","getMinutes","sec","getSeconds","timestamp","Message","LogLevel","Timestamp","FormattedMessage","sLogger","maximumConsoleLogLevel","Off","maximumEventLogLevel","MaximumConsoleLogLevel","buttplugLogLevel","MaximumEventLogLevel","AddLogMessage","Warn","Trace","logMsg","console","getMessageClass","Name","msgarray","getOwnPropertyNames","DEFAULT_MESSAGE_ID","MAX_ID","MessageAttributes","SensorSubscribeCmd","GenericDeviceMessageAttributes","RawDeviceMessageAttributes","SensorDeviceMessageAttributes","ButtplugMessage","toProtocolFormat","jsonObj","ButtplugDeviceMessage","ButtplugSystemMessage","Ping","Schemversion","DeviceInfo","DeviceList","ClientName","GenericMessageSubcommand","Scalar","Scalars","RotateSubcommand","Speed","Clockwise","deviceIndex","commands","cmdList","Rotations","VectorSubcommand","Position","Duration","cmd","Vectors","SensorIndex","Endpoint","ExpectedLength","Timeout","WriteWithResponse","_url","ws","WebSocket","rej","conErrorCallback","addEventListener","_ws","Initialize","removeEventListener","close","_useCounter","_counter","_waitingMsgs","msgPromise","noMatch"],"mappings":"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","file":"buttplug.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([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"buttplug-commonjs\"] = factory();\n\telse\n\t\troot[\"Buttplug\"] = 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 = \"./src/index.ts\");\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","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { TransformOperationExecutor } from './TransformOperationExecutor';\nimport { TransformationType } from './enums';\nimport { defaultOptions } from './constants/default-options.constant';\nvar ClassTransformer = /** @class */ (function () {\n    function ClassTransformer() {\n    }\n    ClassTransformer.prototype.instanceToPlain = function (object, options) {\n        var executor = new TransformOperationExecutor(TransformationType.CLASS_TO_PLAIN, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(undefined, object, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.classToPlainFromExist = function (object, plainObject, options) {\n        var executor = new TransformOperationExecutor(TransformationType.CLASS_TO_PLAIN, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(plainObject, object, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.plainToInstance = function (cls, plain, options) {\n        var executor = new TransformOperationExecutor(TransformationType.PLAIN_TO_CLASS, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(undefined, plain, cls, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.plainToClassFromExist = function (clsObject, plain, options) {\n        var executor = new TransformOperationExecutor(TransformationType.PLAIN_TO_CLASS, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(clsObject, plain, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.instanceToInstance = function (object, options) {\n        var executor = new TransformOperationExecutor(TransformationType.CLASS_TO_CLASS, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(undefined, object, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.classToClassFromExist = function (object, fromObject, options) {\n        var executor = new TransformOperationExecutor(TransformationType.CLASS_TO_CLASS, __assign(__assign({}, defaultOptions), options));\n        return executor.transform(fromObject, object, undefined, undefined, undefined, undefined);\n    };\n    ClassTransformer.prototype.serialize = function (object, options) {\n        return JSON.stringify(this.instanceToPlain(object, options));\n    };\n    /**\n     * Deserializes given JSON string to a object of the given class.\n     */\n    ClassTransformer.prototype.deserialize = function (cls, json, options) {\n        var jsonObject = JSON.parse(json);\n        return this.plainToInstance(cls, jsonObject, options);\n    };\n    /**\n     * Deserializes given JSON string to an array of objects of the given class.\n     */\n    ClassTransformer.prototype.deserializeArray = function (cls, json, options) {\n        var jsonObject = JSON.parse(json);\n        return this.plainToInstance(cls, jsonObject, options);\n    };\n    return ClassTransformer;\n}());\nexport { ClassTransformer };\n//# sourceMappingURL=ClassTransformer.js.map","import { TransformationType } from './enums';\n/**\n * Storage all library metadata.\n */\nvar MetadataStorage = /** @class */ (function () {\n    function MetadataStorage() {\n        // -------------------------------------------------------------------------\n        // Properties\n        // -------------------------------------------------------------------------\n        this._typeMetadatas = new Map();\n        this._transformMetadatas = new Map();\n        this._exposeMetadatas = new Map();\n        this._excludeMetadatas = new Map();\n        this._ancestorsMap = new Map();\n    }\n    // -------------------------------------------------------------------------\n    // Adder Methods\n    // -------------------------------------------------------------------------\n    MetadataStorage.prototype.addTypeMetadata = function (metadata) {\n        if (!this._typeMetadatas.has(metadata.target)) {\n            this._typeMetadatas.set(metadata.target, new Map());\n        }\n        this._typeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);\n    };\n    MetadataStorage.prototype.addTransformMetadata = function (metadata) {\n        if (!this._transformMetadatas.has(metadata.target)) {\n            this._transformMetadatas.set(metadata.target, new Map());\n        }\n        if (!this._transformMetadatas.get(metadata.target).has(metadata.propertyName)) {\n            this._transformMetadatas.get(metadata.target).set(metadata.propertyName, []);\n        }\n        this._transformMetadatas.get(metadata.target).get(metadata.propertyName).push(metadata);\n    };\n    MetadataStorage.prototype.addExposeMetadata = function (metadata) {\n        if (!this._exposeMetadatas.has(metadata.target)) {\n            this._exposeMetadatas.set(metadata.target, new Map());\n        }\n        this._exposeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);\n    };\n    MetadataStorage.prototype.addExcludeMetadata = function (metadata) {\n        if (!this._excludeMetadatas.has(metadata.target)) {\n            this._excludeMetadatas.set(metadata.target, new Map());\n        }\n        this._excludeMetadatas.get(metadata.target).set(metadata.propertyName, metadata);\n    };\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n    MetadataStorage.prototype.findTransformMetadatas = function (target, propertyName, transformationType) {\n        return this.findMetadatas(this._transformMetadatas, target, propertyName).filter(function (metadata) {\n            if (!metadata.options)\n                return true;\n            if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)\n                return true;\n            if (metadata.options.toClassOnly === true) {\n                return (transformationType === TransformationType.CLASS_TO_CLASS ||\n                    transformationType === TransformationType.PLAIN_TO_CLASS);\n            }\n            if (metadata.options.toPlainOnly === true) {\n                return transformationType === TransformationType.CLASS_TO_PLAIN;\n            }\n            return true;\n        });\n    };\n    MetadataStorage.prototype.findExcludeMetadata = function (target, propertyName) {\n        return this.findMetadata(this._excludeMetadatas, target, propertyName);\n    };\n    MetadataStorage.prototype.findExposeMetadata = function (target, propertyName) {\n        return this.findMetadata(this._exposeMetadatas, target, propertyName);\n    };\n    MetadataStorage.prototype.findExposeMetadataByCustomName = function (target, name) {\n        return this.getExposedMetadatas(target).find(function (metadata) {\n            return metadata.options && metadata.options.name === name;\n        });\n    };\n    MetadataStorage.prototype.findTypeMetadata = function (target, propertyName) {\n        return this.findMetadata(this._typeMetadatas, target, propertyName);\n    };\n    MetadataStorage.prototype.getStrategy = function (target) {\n        var excludeMap = this._excludeMetadatas.get(target);\n        var exclude = excludeMap && excludeMap.get(undefined);\n        var exposeMap = this._exposeMetadatas.get(target);\n        var expose = exposeMap && exposeMap.get(undefined);\n        if ((exclude && expose) || (!exclude && !expose))\n            return 'none';\n        return exclude ? 'excludeAll' : 'exposeAll';\n    };\n    MetadataStorage.prototype.getExposedMetadatas = function (target) {\n        return this.getMetadata(this._exposeMetadatas, target);\n    };\n    MetadataStorage.prototype.getExcludedMetadatas = function (target) {\n        return this.getMetadata(this._excludeMetadatas, target);\n    };\n    MetadataStorage.prototype.getExposedProperties = function (target, transformationType) {\n        return this.getExposedMetadatas(target)\n            .filter(function (metadata) {\n            if (!metadata.options)\n                return true;\n            if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)\n                return true;\n            if (metadata.options.toClassOnly === true) {\n                return (transformationType === TransformationType.CLASS_TO_CLASS ||\n                    transformationType === TransformationType.PLAIN_TO_CLASS);\n            }\n            if (metadata.options.toPlainOnly === true) {\n                return transformationType === TransformationType.CLASS_TO_PLAIN;\n            }\n            return true;\n        })\n            .map(function (metadata) { return metadata.propertyName; });\n    };\n    MetadataStorage.prototype.getExcludedProperties = function (target, transformationType) {\n        return this.getExcludedMetadatas(target)\n            .filter(function (metadata) {\n            if (!metadata.options)\n                return true;\n            if (metadata.options.toClassOnly === true && metadata.options.toPlainOnly === true)\n                return true;\n            if (metadata.options.toClassOnly === true) {\n                return (transformationType === TransformationType.CLASS_TO_CLASS ||\n                    transformationType === TransformationType.PLAIN_TO_CLASS);\n            }\n            if (metadata.options.toPlainOnly === true) {\n                return transformationType === TransformationType.CLASS_TO_PLAIN;\n            }\n            return true;\n        })\n            .map(function (metadata) { return metadata.propertyName; });\n    };\n    MetadataStorage.prototype.clear = function () {\n        this._typeMetadatas.clear();\n        this._exposeMetadatas.clear();\n        this._excludeMetadatas.clear();\n        this._ancestorsMap.clear();\n    };\n    // -------------------------------------------------------------------------\n    // Private Methods\n    // -------------------------------------------------------------------------\n    MetadataStorage.prototype.getMetadata = function (metadatas, target) {\n        var metadataFromTargetMap = metadatas.get(target);\n        var metadataFromTarget;\n        if (metadataFromTargetMap) {\n            metadataFromTarget = Array.from(metadataFromTargetMap.values()).filter(function (meta) { return meta.propertyName !== undefined; });\n        }\n        var metadataFromAncestors = [];\n        for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {\n            var ancestor = _a[_i];\n            var ancestorMetadataMap = metadatas.get(ancestor);\n            if (ancestorMetadataMap) {\n                var metadataFromAncestor = Array.from(ancestorMetadataMap.values()).filter(function (meta) { return meta.propertyName !== undefined; });\n                metadataFromAncestors.push.apply(metadataFromAncestors, metadataFromAncestor);\n            }\n        }\n        return metadataFromAncestors.concat(metadataFromTarget || []);\n    };\n    MetadataStorage.prototype.findMetadata = function (metadatas, target, propertyName) {\n        var metadataFromTargetMap = metadatas.get(target);\n        if (metadataFromTargetMap) {\n            var metadataFromTarget = metadataFromTargetMap.get(propertyName);\n            if (metadataFromTarget) {\n                return metadataFromTarget;\n            }\n        }\n        for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {\n            var ancestor = _a[_i];\n            var ancestorMetadataMap = metadatas.get(ancestor);\n            if (ancestorMetadataMap) {\n                var ancestorResult = ancestorMetadataMap.get(propertyName);\n                if (ancestorResult) {\n                    return ancestorResult;\n                }\n            }\n        }\n        return undefined;\n    };\n    MetadataStorage.prototype.findMetadatas = function (metadatas, target, propertyName) {\n        var metadataFromTargetMap = metadatas.get(target);\n        var metadataFromTarget;\n        if (metadataFromTargetMap) {\n            metadataFromTarget = metadataFromTargetMap.get(propertyName);\n        }\n        var metadataFromAncestorsTarget = [];\n        for (var _i = 0, _a = this.getAncestors(target); _i < _a.length; _i++) {\n            var ancestor = _a[_i];\n            var ancestorMetadataMap = metadatas.get(ancestor);\n            if (ancestorMetadataMap) {\n                if (ancestorMetadataMap.has(propertyName)) {\n                    metadataFromAncestorsTarget.push.apply(metadataFromAncestorsTarget, ancestorMetadataMap.get(propertyName));\n                }\n            }\n        }\n        return metadataFromAncestorsTarget\n            .slice()\n            .reverse()\n            .concat((metadataFromTarget || []).slice().reverse());\n    };\n    MetadataStorage.prototype.getAncestors = function (target) {\n        if (!target)\n            return [];\n        if (!this._ancestorsMap.has(target)) {\n            var ancestors = [];\n            for (var baseClass = Object.getPrototypeOf(target.prototype.constructor); typeof baseClass.prototype !== 'undefined'; baseClass = Object.getPrototypeOf(baseClass.prototype.constructor)) {\n                ancestors.push(baseClass);\n            }\n            this._ancestorsMap.set(target, ancestors);\n        }\n        return this._ancestorsMap.get(target);\n    };\n    return MetadataStorage;\n}());\nexport { MetadataStorage };\n//# sourceMappingURL=MetadataStorage.js.map","var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { defaultMetadataStorage } from './storage';\nimport { TransformationType } from './enums';\nimport { getGlobal, isPromise } from './utils';\nfunction instantiateArrayType(arrayType) {\n    var array = new arrayType();\n    if (!(array instanceof Set) && !('push' in array)) {\n        return [];\n    }\n    return array;\n}\nvar TransformOperationExecutor = /** @class */ (function () {\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n    function TransformOperationExecutor(transformationType, options) {\n        this.transformationType = transformationType;\n        this.options = options;\n        // -------------------------------------------------------------------------\n        // Private Properties\n        // -------------------------------------------------------------------------\n        this.recursionStack = new Set();\n    }\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n    TransformOperationExecutor.prototype.transform = function (source, value, targetType, arrayType, isMap, level) {\n        var _this = this;\n        if (level === void 0) { level = 0; }\n        if (Array.isArray(value) || value instanceof Set) {\n            var newValue_1 = arrayType && this.transformationType === TransformationType.PLAIN_TO_CLASS\n                ? instantiateArrayType(arrayType)\n                : [];\n            value.forEach(function (subValue, index) {\n                var subSource = source ? source[index] : undefined;\n                if (!_this.options.enableCircularCheck || !_this.isCircular(subValue)) {\n                    var realTargetType = void 0;\n                    if (typeof targetType !== 'function' &&\n                        targetType &&\n                        targetType.options &&\n                        targetType.options.discriminator &&\n                        targetType.options.discriminator.property &&\n                        targetType.options.discriminator.subTypes) {\n                        if (_this.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                            realTargetType = targetType.options.discriminator.subTypes.find(function (subType) {\n                                return subType.name === subValue[targetType.options.discriminator.property];\n                            });\n                            var options = { newObject: newValue_1, object: subValue, property: undefined };\n                            var newType = targetType.typeFunction(options);\n                            realTargetType === undefined ? (realTargetType = newType) : (realTargetType = realTargetType.value);\n                            if (!targetType.options.keepDiscriminatorProperty)\n                                delete subValue[targetType.options.discriminator.property];\n                        }\n                        if (_this.transformationType === TransformationType.CLASS_TO_CLASS) {\n                            realTargetType = subValue.constructor;\n                        }\n                        if (_this.transformationType === TransformationType.CLASS_TO_PLAIN) {\n                            subValue[targetType.options.discriminator.property] = targetType.options.discriminator.subTypes.find(function (subType) { return subType.value === subValue.constructor; }).name;\n                        }\n                    }\n                    else {\n                        realTargetType = targetType;\n                    }\n                    var value_1 = _this.transform(subSource, subValue, realTargetType, undefined, subValue instanceof Map, level + 1);\n                    if (newValue_1 instanceof Set) {\n                        newValue_1.add(value_1);\n                    }\n                    else {\n                        newValue_1.push(value_1);\n                    }\n                }\n                else if (_this.transformationType === TransformationType.CLASS_TO_CLASS) {\n                    if (newValue_1 instanceof Set) {\n                        newValue_1.add(subValue);\n                    }\n                    else {\n                        newValue_1.push(subValue);\n                    }\n                }\n            });\n            return newValue_1;\n        }\n        else if (targetType === String && !isMap) {\n            if (value === null || value === undefined)\n                return value;\n            return String(value);\n        }\n        else if (targetType === Number && !isMap) {\n            if (value === null || value === undefined)\n                return value;\n            return Number(value);\n        }\n        else if (targetType === Boolean && !isMap) {\n            if (value === null || value === undefined)\n                return value;\n            return Boolean(value);\n        }\n        else if ((targetType === Date || value instanceof Date) && !isMap) {\n            if (value instanceof Date) {\n                return new Date(value.valueOf());\n            }\n            if (value === null || value === undefined)\n                return value;\n            return new Date(value);\n        }\n        else if (!!getGlobal().Buffer && (targetType === Buffer || value instanceof Buffer) && !isMap) {\n            if (value === null || value === undefined)\n                return value;\n            return Buffer.from(value);\n        }\n        else if (isPromise(value) && !isMap) {\n            return new Promise(function (resolve, reject) {\n                value.then(function (data) { return resolve(_this.transform(undefined, data, targetType, undefined, undefined, level + 1)); }, reject);\n            });\n        }\n        else if (!isMap && value !== null && typeof value === 'object' && typeof value.then === 'function') {\n            // Note: We should not enter this, as promise has been handled above\n            // This option simply returns the Promise preventing a JS error from happening and should be an inaccessible path.\n            return value; // skip promise transformation\n        }\n        else if (typeof value === 'object' && value !== null) {\n            // try to guess the type\n            if (!targetType && value.constructor !== Object /* && TransformationType === TransformationType.CLASS_TO_PLAIN*/)\n                if (!Array.isArray(value) && value.constructor === Array) {\n                    // Somebody attempts to convert special Array like object to Array, eg:\n                    // const evilObject = { '100000000': '100000000', __proto__: [] };\n                    // This could be used to cause Denial-of-service attack so we don't allow it.\n                    // See prevent-array-bomb.spec.ts for more details.\n                }\n                else {\n                    // We are good we can use the built-in constructor\n                    targetType = value.constructor;\n                }\n            if (!targetType && source)\n                targetType = source.constructor;\n            if (this.options.enableCircularCheck) {\n                // add transformed type to prevent circular references\n                this.recursionStack.add(value);\n            }\n            var keys = this.getKeys(targetType, value, isMap);\n            var newValue = source ? source : {};\n            if (!source &&\n                (this.transformationType === TransformationType.PLAIN_TO_CLASS ||\n                    this.transformationType === TransformationType.CLASS_TO_CLASS)) {\n                if (isMap) {\n                    newValue = new Map();\n                }\n                else if (targetType) {\n                    newValue = new targetType();\n                }\n                else {\n                    newValue = {};\n                }\n            }\n            var _loop_1 = function (key) {\n                if (key === '__proto__' || key === 'constructor') {\n                    return \"continue\";\n                }\n                var valueKey = key;\n                var newValueKey = key, propertyName = key;\n                if (!this_1.options.ignoreDecorators && targetType) {\n                    if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                        var exposeMetadata = defaultMetadataStorage.findExposeMetadataByCustomName(targetType, key);\n                        if (exposeMetadata) {\n                            propertyName = exposeMetadata.propertyName;\n                            newValueKey = exposeMetadata.propertyName;\n                        }\n                    }\n                    else if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN ||\n                        this_1.transformationType === TransformationType.CLASS_TO_CLASS) {\n                        var exposeMetadata = defaultMetadataStorage.findExposeMetadata(targetType, key);\n                        if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name) {\n                            newValueKey = exposeMetadata.options.name;\n                        }\n                    }\n                }\n                // get a subvalue\n                var subValue = undefined;\n                if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                    /**\n                     * This section is added for the following report:\n                     * https://github.com/typestack/class-transformer/issues/596\n                     *\n                     * We should not call functions or constructors when transforming to class.\n                     */\n                    subValue = value[valueKey];\n                }\n                else {\n                    if (value instanceof Map) {\n                        subValue = value.get(valueKey);\n                    }\n                    else if (value[valueKey] instanceof Function) {\n                        subValue = value[valueKey]();\n                    }\n                    else {\n                        subValue = value[valueKey];\n                    }\n                }\n                // determine a type\n                var type = undefined, isSubValueMap = subValue instanceof Map;\n                if (targetType && isMap) {\n                    type = targetType;\n                }\n                else if (targetType) {\n                    var metadata_1 = defaultMetadataStorage.findTypeMetadata(targetType, propertyName);\n                    if (metadata_1) {\n                        var options = { newObject: newValue, object: value, property: propertyName };\n                        var newType = metadata_1.typeFunction ? metadata_1.typeFunction(options) : metadata_1.reflectedType;\n                        if (metadata_1.options &&\n                            metadata_1.options.discriminator &&\n                            metadata_1.options.discriminator.property &&\n                            metadata_1.options.discriminator.subTypes) {\n                            if (!(value[valueKey] instanceof Array)) {\n                                if (this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                                    type = metadata_1.options.discriminator.subTypes.find(function (subType) {\n                                        if (subValue && subValue instanceof Object && metadata_1.options.discriminator.property in subValue) {\n                                            return subType.name === subValue[metadata_1.options.discriminator.property];\n                                        }\n                                    });\n                                    type === undefined ? (type = newType) : (type = type.value);\n                                    if (!metadata_1.options.keepDiscriminatorProperty) {\n                                        if (subValue && subValue instanceof Object && metadata_1.options.discriminator.property in subValue) {\n                                            delete subValue[metadata_1.options.discriminator.property];\n                                        }\n                                    }\n                                }\n                                if (this_1.transformationType === TransformationType.CLASS_TO_CLASS) {\n                                    type = subValue.constructor;\n                                }\n                                if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN) {\n                                    if (subValue) {\n                                        subValue[metadata_1.options.discriminator.property] = metadata_1.options.discriminator.subTypes.find(function (subType) { return subType.value === subValue.constructor; }).name;\n                                    }\n                                }\n                            }\n                            else {\n                                type = metadata_1;\n                            }\n                        }\n                        else {\n                            type = newType;\n                        }\n                        isSubValueMap = isSubValueMap || metadata_1.reflectedType === Map;\n                    }\n                    else if (this_1.options.targetMaps) {\n                        // try to find a type in target maps\n                        this_1.options.targetMaps\n                            .filter(function (map) { return map.target === targetType && !!map.properties[propertyName]; })\n                            .forEach(function (map) { return (type = map.properties[propertyName]); });\n                    }\n                    else if (this_1.options.enableImplicitConversion &&\n                        this_1.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                        // if we have no registererd type via the @Type() decorator then we check if we have any\n                        // type declarations in reflect-metadata (type declaration is emited only if some decorator is added to the property.)\n                        var reflectedType = Reflect.getMetadata('design:type', targetType.prototype, propertyName);\n                        if (reflectedType) {\n                            type = reflectedType;\n                        }\n                    }\n                }\n                // if value is an array try to get its custom array type\n                var arrayType_1 = Array.isArray(value[valueKey])\n                    ? this_1.getReflectedType(targetType, propertyName)\n                    : undefined;\n                // const subValueKey = TransformationType === TransformationType.PLAIN_TO_CLASS && newKeyName ? newKeyName : key;\n                var subSource = source ? source[valueKey] : undefined;\n                // if its deserialization then type if required\n                // if we uncomment this types like string[] will not work\n                // if (this.transformationType === TransformationType.PLAIN_TO_CLASS && !type && subValue instanceof Object && !(subValue instanceof Date))\n                //     throw new Error(`Cannot determine type for ${(targetType as any).name }.${propertyName}, did you forget to specify a @Type?`);\n                // if newValue is a source object that has method that match newKeyName then skip it\n                if (newValue.constructor.prototype) {\n                    var descriptor = Object.getOwnPropertyDescriptor(newValue.constructor.prototype, newValueKey);\n                    if ((this_1.transformationType === TransformationType.PLAIN_TO_CLASS ||\n                        this_1.transformationType === TransformationType.CLASS_TO_CLASS) &&\n                        // eslint-disable-next-line @typescript-eslint/unbound-method\n                        ((descriptor && !descriptor.set) || newValue[newValueKey] instanceof Function))\n                        return \"continue\";\n                }\n                if (!this_1.options.enableCircularCheck || !this_1.isCircular(subValue)) {\n                    var transformKey = this_1.transformationType === TransformationType.PLAIN_TO_CLASS ? newValueKey : key;\n                    var finalValue = void 0;\n                    if (this_1.transformationType === TransformationType.CLASS_TO_PLAIN) {\n                        // Get original value\n                        finalValue = value[transformKey];\n                        // Apply custom transformation\n                        finalValue = this_1.applyCustomTransformations(finalValue, targetType, transformKey, value, this_1.transformationType);\n                        // If nothing change, it means no custom transformation was applied, so use the subValue.\n                        finalValue = value[transformKey] === finalValue ? subValue : finalValue;\n                        // Apply the default transformation\n                        finalValue = this_1.transform(subSource, finalValue, type, arrayType_1, isSubValueMap, level + 1);\n                    }\n                    else {\n                        if (subValue === undefined && this_1.options.exposeDefaultValues) {\n                            // Set default value if nothing provided\n                            finalValue = newValue[newValueKey];\n                        }\n                        else {\n                            finalValue = this_1.transform(subSource, subValue, type, arrayType_1, isSubValueMap, level + 1);\n                            finalValue = this_1.applyCustomTransformations(finalValue, targetType, transformKey, value, this_1.transformationType);\n                        }\n                    }\n                    if (finalValue !== undefined || this_1.options.exposeUnsetFields) {\n                        if (newValue instanceof Map) {\n                            newValue.set(newValueKey, finalValue);\n                        }\n                        else {\n                            newValue[newValueKey] = finalValue;\n                        }\n                    }\n                }\n                else if (this_1.transformationType === TransformationType.CLASS_TO_CLASS) {\n                    var finalValue = subValue;\n                    finalValue = this_1.applyCustomTransformations(finalValue, targetType, key, value, this_1.transformationType);\n                    if (finalValue !== undefined || this_1.options.exposeUnsetFields) {\n                        if (newValue instanceof Map) {\n                            newValue.set(newValueKey, finalValue);\n                        }\n                        else {\n                            newValue[newValueKey] = finalValue;\n                        }\n                    }\n                }\n            };\n            var this_1 = this;\n            // traverse over keys\n            for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n                var key = keys_1[_i];\n                _loop_1(key);\n            }\n            if (this.options.enableCircularCheck) {\n                this.recursionStack.delete(value);\n            }\n            return newValue;\n        }\n        else {\n            return value;\n        }\n    };\n    TransformOperationExecutor.prototype.applyCustomTransformations = function (value, target, key, obj, transformationType) {\n        var _this = this;\n        var metadatas = defaultMetadataStorage.findTransformMetadatas(target, key, this.transformationType);\n        // apply versioning options\n        if (this.options.version !== undefined) {\n            metadatas = metadatas.filter(function (metadata) {\n                if (!metadata.options)\n                    return true;\n                return _this.checkVersion(metadata.options.since, metadata.options.until);\n            });\n        }\n        // apply grouping options\n        if (this.options.groups && this.options.groups.length) {\n            metadatas = metadatas.filter(function (metadata) {\n                if (!metadata.options)\n                    return true;\n                return _this.checkGroups(metadata.options.groups);\n            });\n        }\n        else {\n            metadatas = metadatas.filter(function (metadata) {\n                return !metadata.options || !metadata.options.groups || !metadata.options.groups.length;\n            });\n        }\n        metadatas.forEach(function (metadata) {\n            value = metadata.transformFn({ value: value, key: key, obj: obj, type: transformationType, options: _this.options });\n        });\n        return value;\n    };\n    // preventing circular references\n    TransformOperationExecutor.prototype.isCircular = function (object) {\n        return this.recursionStack.has(object);\n    };\n    TransformOperationExecutor.prototype.getReflectedType = function (target, propertyName) {\n        if (!target)\n            return undefined;\n        var meta = defaultMetadataStorage.findTypeMetadata(target, propertyName);\n        return meta ? meta.reflectedType : undefined;\n    };\n    TransformOperationExecutor.prototype.getKeys = function (target, object, isMap) {\n        var _this = this;\n        // determine exclusion strategy\n        var strategy = defaultMetadataStorage.getStrategy(target);\n        if (strategy === 'none')\n            strategy = this.options.strategy || 'exposeAll'; // exposeAll is default strategy\n        // get all keys that need to expose\n        var keys = [];\n        if (strategy === 'exposeAll' || isMap) {\n            if (object instanceof Map) {\n                keys = Array.from(object.keys());\n            }\n            else {\n                keys = Object.keys(object);\n            }\n        }\n        if (isMap) {\n            // expose & exclude do not apply for map keys only to fields\n            return keys;\n        }\n        /**\n         * If decorators are ignored but we don't want the extraneous values, then we use the\n         * metadata to decide which property is needed, but doesn't apply the decorator effect.\n         */\n        if (this.options.ignoreDecorators && this.options.excludeExtraneousValues && target) {\n            var exposedProperties = defaultMetadataStorage.getExposedProperties(target, this.transformationType);\n            var excludedProperties = defaultMetadataStorage.getExcludedProperties(target, this.transformationType);\n            keys = __spreadArray(__spreadArray([], exposedProperties, true), excludedProperties, true);\n        }\n        if (!this.options.ignoreDecorators && target) {\n            // add all exposed to list of keys\n            var exposedProperties = defaultMetadataStorage.getExposedProperties(target, this.transformationType);\n            if (this.transformationType === TransformationType.PLAIN_TO_CLASS) {\n                exposedProperties = exposedProperties.map(function (key) {\n                    var exposeMetadata = defaultMetadataStorage.findExposeMetadata(target, key);\n                    if (exposeMetadata && exposeMetadata.options && exposeMetadata.options.name) {\n                        return exposeMetadata.options.name;\n                    }\n                    return key;\n                });\n            }\n            if (this.options.excludeExtraneousValues) {\n                keys = exposedProperties;\n            }\n            else {\n                keys = keys.concat(exposedProperties);\n            }\n            // exclude excluded properties\n            var excludedProperties_1 = defaultMetadataStorage.getExcludedProperties(target, this.transformationType);\n            if (excludedProperties_1.length > 0) {\n                keys = keys.filter(function (key) {\n                    return !excludedProperties_1.includes(key);\n                });\n            }\n            // apply versioning options\n            if (this.options.version !== undefined) {\n                keys = keys.filter(function (key) {\n                    var exposeMetadata = defaultMetadataStorage.findExposeMetadata(target, key);\n                    if (!exposeMetadata || !exposeMetadata.options)\n                        return true;\n                    return _this.checkVersion(exposeMetadata.options.since, exposeMetadata.options.until);\n                });\n            }\n            // apply grouping options\n            if (this.options.groups && this.options.groups.length) {\n                keys = keys.filter(function (key) {\n                    var exposeMetadata = defaultMetadataStorage.findExposeMetadata(target, key);\n                    if (!exposeMetadata || !exposeMetadata.options)\n                        return true;\n                    return _this.checkGroups(exposeMetadata.options.groups);\n                });\n            }\n            else {\n                keys = keys.filter(function (key) {\n                    var exposeMetadata = defaultMetadataStorage.findExposeMetadata(target, key);\n                    return (!exposeMetadata ||\n                        !exposeMetadata.options ||\n                        !exposeMetadata.options.groups ||\n                        !exposeMetadata.options.groups.length);\n                });\n            }\n        }\n        // exclude prefixed properties\n        if (this.options.excludePrefixes && this.options.excludePrefixes.length) {\n            keys = keys.filter(function (key) {\n                return _this.options.excludePrefixes.every(function (prefix) {\n                    return key.substr(0, prefix.length) !== prefix;\n                });\n            });\n        }\n        // make sure we have unique keys\n        keys = keys.filter(function (key, index, self) {\n            return self.indexOf(key) === index;\n        });\n        return keys;\n    };\n    TransformOperationExecutor.prototype.checkVersion = function (since, until) {\n        var decision = true;\n        if (decision && since)\n            decision = this.options.version >= since;\n        if (decision && until)\n            decision = this.options.version < until;\n        return decision;\n    };\n    TransformOperationExecutor.prototype.checkGroups = function (groups) {\n        if (!groups)\n            return true;\n        return this.options.groups.some(function (optionGroup) { return groups.includes(optionGroup); });\n    };\n    return TransformOperationExecutor;\n}());\nexport { TransformOperationExecutor };\n//# sourceMappingURL=TransformOperationExecutor.js.map","/**\n * These are the default options used by any transformation operation.\n */\nexport var defaultOptions = {\n    enableCircularCheck: false,\n    enableImplicitConversion: false,\n    excludeExtraneousValues: false,\n    excludePrefixes: undefined,\n    exposeDefaultValues: false,\n    exposeUnsetFields: true,\n    groups: undefined,\n    ignoreDecorators: false,\n    strategy: undefined,\n    targetMaps: undefined,\n    version: undefined,\n};\n//# sourceMappingURL=default-options.constant.js.map","import { defaultMetadataStorage } from '../storage';\n/**\n * Marks the given class or property as excluded. By default the property is excluded in both\n * constructorToPlain and plainToConstructor transformations. It can be limited to only one direction\n * via using the `toPlainOnly` or `toClassOnly` option.\n *\n * Can be applied to class definitions and properties.\n */\nexport function Exclude(options) {\n    if (options === void 0) { options = {}; }\n    /**\n     * NOTE: The `propertyName` property must be marked as optional because\n     * this decorator used both as a class and a property decorator and the\n     * Typescript compiler will freak out if we make it mandatory as a class\n     * decorator only receives one parameter.\n     */\n    return function (object, propertyName) {\n        defaultMetadataStorage.addExcludeMetadata({\n            target: object instanceof Function ? object : object.constructor,\n            propertyName: propertyName,\n            options: options,\n        });\n    };\n}\n//# sourceMappingURL=exclude.decorator.js.map","import { defaultMetadataStorage } from '../storage';\n/**\n * Marks the given class or property as included. By default the property is included in both\n * constructorToPlain and plainToConstructor transformations. It can be limited to only one direction\n * via using the `toPlainOnly` or `toClassOnly` option.\n *\n * Can be applied to class definitions and properties.\n */\nexport function Expose(options) {\n    if (options === void 0) { options = {}; }\n    /**\n     * NOTE: The `propertyName` property must be marked as optional because\n     * this decorator used both as a class and a property decorator and the\n     * Typescript compiler will freak out if we make it mandatory as a class\n     * decorator only receives one parameter.\n     */\n    return function (object, propertyName) {\n        defaultMetadataStorage.addExposeMetadata({\n            target: object instanceof Function ? object : object.constructor,\n            propertyName: propertyName,\n            options: options,\n        });\n    };\n}\n//# sourceMappingURL=expose.decorator.js.map","export * from './exclude.decorator';\nexport * from './expose.decorator';\nexport * from './transform-instance-to-instance.decorator';\nexport * from './transform-instance-to-plain.decorator';\nexport * from './transform-plain-to-instance.decorator';\nexport * from './transform.decorator';\nexport * from './type.decorator';\n//# sourceMappingURL=index.js.map","import { ClassTransformer } from '../ClassTransformer';\n/**\n * Return the class instance only with the exposed properties.\n *\n * Can be applied to functions and getters/setters only.\n */\nexport function TransformInstanceToInstance(params) {\n    return function (target, propertyKey, descriptor) {\n        var classTransformer = new ClassTransformer();\n        var originalMethod = descriptor.value;\n        descriptor.value = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var result = originalMethod.apply(this, args);\n            var isPromise = !!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function';\n            return isPromise\n                ? result.then(function (data) { return classTransformer.instanceToInstance(data, params); })\n                : classTransformer.instanceToInstance(result, params);\n        };\n    };\n}\n//# sourceMappingURL=transform-instance-to-instance.decorator.js.map","import { ClassTransformer } from '../ClassTransformer';\n/**\n * Transform the object from class to plain object and return only with the exposed properties.\n *\n * Can be applied to functions and getters/setters only.\n */\nexport function TransformInstanceToPlain(params) {\n    return function (target, propertyKey, descriptor) {\n        var classTransformer = new ClassTransformer();\n        var originalMethod = descriptor.value;\n        descriptor.value = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var result = originalMethod.apply(this, args);\n            var isPromise = !!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function';\n            return isPromise\n                ? result.then(function (data) { return classTransformer.instanceToPlain(data, params); })\n                : classTransformer.instanceToPlain(result, params);\n        };\n    };\n}\n//# sourceMappingURL=transform-instance-to-plain.decorator.js.map","import { ClassTransformer } from '../ClassTransformer';\n/**\n * Return the class instance only with the exposed properties.\n *\n * Can be applied to functions and getters/setters only.\n */\nexport function TransformPlainToInstance(classType, params) {\n    return function (target, propertyKey, descriptor) {\n        var classTransformer = new ClassTransformer();\n        var originalMethod = descriptor.value;\n        descriptor.value = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var result = originalMethod.apply(this, args);\n            var isPromise = !!result && (typeof result === 'object' || typeof result === 'function') && typeof result.then === 'function';\n            return isPromise\n                ? result.then(function (data) { return classTransformer.plainToInstance(classType, data, params); })\n                : classTransformer.plainToInstance(classType, result, params);\n        };\n    };\n}\n//# sourceMappingURL=transform-plain-to-instance.decorator.js.map","import { defaultMetadataStorage } from '../storage';\n/**\n * Defines a custom logic for value transformation.\n *\n * Can be applied to properties only.\n */\nexport function Transform(transformFn, options) {\n    if (options === void 0) { options = {}; }\n    return function (target, propertyName) {\n        defaultMetadataStorage.addTransformMetadata({\n            target: target.constructor,\n            propertyName: propertyName,\n            transformFn: transformFn,\n            options: options,\n        });\n    };\n}\n//# sourceMappingURL=transform.decorator.js.map","import { defaultMetadataStorage } from '../storage';\n/**\n * Specifies a type of the property.\n * The given TypeFunction can return a constructor. A discriminator can be given in the options.\n *\n * Can be applied to properties only.\n */\nexport function Type(typeFunction, options) {\n    if (options === void 0) { options = {}; }\n    return function (target, propertyName) {\n        var reflectedType = Reflect.getMetadata('design:type', target, propertyName);\n        defaultMetadataStorage.addTypeMetadata({\n            target: target.constructor,\n            propertyName: propertyName,\n            reflectedType: reflectedType,\n            typeFunction: typeFunction,\n            options: options,\n        });\n    };\n}\n//# sourceMappingURL=type.decorator.js.map","export * from './transformation-type.enum';\n//# sourceMappingURL=index.js.map","export var TransformationType;\n(function (TransformationType) {\n    TransformationType[TransformationType[\"PLAIN_TO_CLASS\"] = 0] = \"PLAIN_TO_CLASS\";\n    TransformationType[TransformationType[\"CLASS_TO_PLAIN\"] = 1] = \"CLASS_TO_PLAIN\";\n    TransformationType[TransformationType[\"CLASS_TO_CLASS\"] = 2] = \"CLASS_TO_CLASS\";\n})(TransformationType || (TransformationType = {}));\n//# sourceMappingURL=transformation-type.enum.js.map","import { ClassTransformer } from './ClassTransformer';\nexport { ClassTransformer } from './ClassTransformer';\nexport * from './decorators';\nexport * from './interfaces';\nexport * from './enums';\nvar classTransformer = new ClassTransformer();\nexport function classToPlain(object, options) {\n    return classTransformer.instanceToPlain(object, options);\n}\nexport function instanceToPlain(object, options) {\n    return classTransformer.instanceToPlain(object, options);\n}\nexport function classToPlainFromExist(object, plainObject, options) {\n    return classTransformer.classToPlainFromExist(object, plainObject, options);\n}\nexport function plainToClass(cls, plain, options) {\n    return classTransformer.plainToInstance(cls, plain, options);\n}\nexport function plainToInstance(cls, plain, options) {\n    return classTransformer.plainToInstance(cls, plain, options);\n}\nexport function plainToClassFromExist(clsObject, plain, options) {\n    return classTransformer.plainToClassFromExist(clsObject, plain, options);\n}\nexport function instanceToInstance(object, options) {\n    return classTransformer.instanceToInstance(object, options);\n}\nexport function classToClassFromExist(object, fromObject, options) {\n    return classTransformer.classToClassFromExist(object, fromObject, options);\n}\nexport function serialize(object, options) {\n    return classTransformer.serialize(object, options);\n}\n/**\n * Deserializes given JSON string to a object of the given class.\n *\n * @deprecated This function is being removed. Please use the following instead:\n * ```\n * instanceToClass(cls, JSON.parse(json), options)\n * ```\n */\nexport function deserialize(cls, json, options) {\n    return classTransformer.deserialize(cls, json, options);\n}\n/**\n * Deserializes given JSON string to an array of objects of the given class.\n *\n * @deprecated This function is being removed. Please use the following instead:\n * ```\n * JSON.parse(json).map(value => instanceToClass(cls, value, options))\n * ```\n *\n */\nexport function deserializeArray(cls, json, options) {\n    return classTransformer.deserializeArray(cls, json, options);\n}\n//# sourceMappingURL=index.js.map","export {};\n//# sourceMappingURL=class-constructor.type.js.map","export {};\n//# sourceMappingURL=class-transformer-options.interface.js.map","export {};\n//# sourceMappingURL=exclude-options.interface.js.map","export {};\n//# sourceMappingURL=expose-options.interface.js.map","export {};\n//# sourceMappingURL=transform-options.interface.js.map","export {};\n//# sourceMappingURL=type-discriminator-descriptor.interface.js.map","export {};\n//# sourceMappingURL=type-options.interface.js.map","export * from './decorator-options/expose-options.interface';\nexport * from './decorator-options/exclude-options.interface';\nexport * from './decorator-options/transform-options.interface';\nexport * from './decorator-options/type-discriminator-descriptor.interface';\nexport * from './decorator-options/type-options.interface';\nexport * from './metadata/exclude-metadata.interface';\nexport * from './metadata/expose-metadata.interface';\nexport * from './metadata/transform-metadata.interface';\nexport * from './metadata/transform-fn-params.interface';\nexport * from './metadata/type-metadata.interface';\nexport * from './class-constructor.type';\nexport * from './class-transformer-options.interface';\nexport * from './target-map.interface';\nexport * from './type-help-options.interface';\n//# sourceMappingURL=index.js.map","export {};\n//# sourceMappingURL=exclude-metadata.interface.js.map","export {};\n//# sourceMappingURL=expose-metadata.interface.js.map","export {};\n//# sourceMappingURL=transform-fn-params.interface.js.map","export {};\n//# sourceMappingURL=transform-metadata.interface.js.map","export {};\n//# sourceMappingURL=type-metadata.interface.js.map","export {};\n//# sourceMappingURL=target-map.interface.js.map","export {};\n//# sourceMappingURL=type-help-options.interface.js.map","import { MetadataStorage } from './MetadataStorage';\n/**\n * Default metadata storage is used as singleton and can be used to storage all metadatas.\n */\nexport var defaultMetadataStorage = new MetadataStorage();\n//# sourceMappingURL=storage.js.map","/**\n * This function returns the global object across Node and browsers.\n *\n * Note: `globalThis` is the standardized approach however it has been added to\n * Node.js in version 12. We need to include this snippet until Node 12 EOL.\n */\nexport function getGlobal() {\n    if (typeof globalThis !== 'undefined') {\n        return globalThis;\n    }\n    if (typeof global !== 'undefined') {\n        return global;\n    }\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore: Cannot find name 'window'.\n    if (typeof window !== 'undefined') {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore: Cannot find name 'window'.\n        return window;\n    }\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore: Cannot find name 'self'.\n    if (typeof self !== 'undefined') {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore: Cannot find name 'self'.\n        return self;\n    }\n}\n//# sourceMappingURL=get-global.util.js.map","export * from './get-global.util';\nexport * from './is-promise.util';\n//# sourceMappingURL=index.js.map","export function isPromise(p) {\n    return p !== null && typeof p === 'object' && typeof p.then === 'function';\n}\n//# sourceMappingURL=is-promise.util.js.map","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n  Events.prototype = Object.create(null);\n\n  //\n  // This hack is needed because the `__proto__` property is still inherited in\n  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n  //\n  if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n  this.fn = fn;\n  this.context = context;\n  this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('The listener must be a function');\n  }\n\n  var listener = new EE(fn, context || emitter, once)\n    , evt = prefix ? prefix + event : event;\n\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n  else emitter._events[evt] = [emitter._events[evt], listener];\n\n  return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\n  else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n  this._events = new Events();\n  this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n  var names = []\n    , events\n    , name;\n\n  if (this._eventsCount === 0) return names;\n\n  for (name in (events = this._events)) {\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n  }\n\n  if (Object.getOwnPropertySymbols) {\n    return names.concat(Object.getOwnPropertySymbols(events));\n  }\n\n  return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n  var evt = prefix ? prefix + event : event\n    , handlers = this._events[evt];\n\n  if (!handlers) return [];\n  if (handlers.fn) return [handlers.fn];\n\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n    ee[i] = handlers[i].fn;\n  }\n\n  return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n  var evt = prefix ? prefix + event : event\n    , listeners = this._events[evt];\n\n  if (!listeners) return 0;\n  if (listeners.fn) return 1;\n  return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return false;\n\n  var listeners = this._events[evt]\n    , len = arguments.length\n    , args\n    , i;\n\n  if (listeners.fn) {\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n    switch (len) {\n      case 1: return listeners.fn.call(listeners.context), true;\n      case 2: return listeners.fn.call(listeners.context, a1), true;\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n    }\n\n    for (i = 1, args = new Array(len -1); i < len; i++) {\n      args[i - 1] = arguments[i];\n    }\n\n    listeners.fn.apply(listeners.context, args);\n  } else {\n    var length = listeners.length\n      , j;\n\n    for (i = 0; i < length; i++) {\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n      switch (len) {\n        case 1: listeners[i].fn.call(listeners[i].context); break;\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n        default:\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n            args[j - 1] = arguments[j];\n          }\n\n          listeners[i].fn.apply(listeners[i].context, args);\n      }\n    }\n  }\n\n  return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n  return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n  return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n  var evt = prefix ? prefix + event : event;\n\n  if (!this._events[evt]) return this;\n  if (!fn) {\n    clearEvent(this, evt);\n    return this;\n  }\n\n  var listeners = this._events[evt];\n\n  if (listeners.fn) {\n    if (\n      listeners.fn === fn &&\n      (!once || listeners.once) &&\n      (!context || listeners.context === context)\n    ) {\n      clearEvent(this, evt);\n    }\n  } else {\n    for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n      if (\n        listeners[i].fn !== fn ||\n        (once && !listeners[i].once) ||\n        (context && listeners[i].context !== context)\n      ) {\n        events.push(listeners[i]);\n      }\n    }\n\n    //\n    // Reset the array, or remove it completely if we have no more listeners.\n    //\n    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n    else clearEvent(this, evt);\n  }\n\n  return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n  var evt;\n\n  if (event) {\n    evt = prefix ? prefix + event : event;\n    if (this._events[evt]) clearEvent(this, evt);\n  } else {\n    this._events = new Events();\n    this._eventsCount = 0;\n  }\n\n  return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n  module.exports = EventEmitter;\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","/*!\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","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*! *****************************************************************************\nCopyright (C) Microsoft. All rights reserved.\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\nthis file except in compliance with the License. You may obtain a copy of the\nLicense at http://www.apache.org/licenses/LICENSE-2.0\n\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\nMERCHANTABLITY OR NON-INFRINGEMENT.\n\nSee the Apache Version 2.0 License for specific language governing permissions\nand limitations under the License.\n***************************************************************************** */\nvar Reflect;\n(function (Reflect) {\n    // Metadata Proposal\n    // https://rbuckton.github.io/reflect-metadata/\n    (function (factory) {\n        var root = typeof global === \"object\" ? global :\n            typeof self === \"object\" ? self :\n                typeof this === \"object\" ? this :\n                    Function(\"return this;\")();\n        var exporter = makeExporter(Reflect);\n        if (typeof root.Reflect === \"undefined\") {\n            root.Reflect = Reflect;\n        }\n        else {\n            exporter = makeExporter(root.Reflect, exporter);\n        }\n        factory(exporter);\n        function makeExporter(target, previous) {\n            return function (key, value) {\n                if (typeof target[key] !== \"function\") {\n                    Object.defineProperty(target, key, { configurable: true, writable: true, value: value });\n                }\n                if (previous)\n                    previous(key, value);\n            };\n        }\n    })(function (exporter) {\n        var hasOwn = Object.prototype.hasOwnProperty;\n        // feature test for Symbol support\n        var supportsSymbol = typeof Symbol === \"function\";\n        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== \"undefined\" ? Symbol.toPrimitive : \"@@toPrimitive\";\n        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== \"undefined\" ? Symbol.iterator : \"@@iterator\";\n        var supportsCreate = typeof Object.create === \"function\"; // feature test for Object.create support\n        var supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support\n        var downLevel = !supportsCreate && !supportsProto;\n        var HashMap = {\n            // create an object in dictionary mode (a.k.a. \"slow\" mode in v8)\n            create: supportsCreate\n                ? function () { return MakeDictionary(Object.create(null)); }\n                : supportsProto\n                    ? function () { return MakeDictionary({ __proto__: null }); }\n                    : function () { return MakeDictionary({}); },\n            has: downLevel\n                ? function (map, key) { return hasOwn.call(map, key); }\n                : function (map, key) { return key in map; },\n            get: downLevel\n                ? function (map, key) { return hasOwn.call(map, key) ? map[key] : undefined; }\n                : function (map, key) { return map[key]; },\n        };\n        // Load global or shim versions of Map, Set, and WeakMap\n        var functionPrototype = Object.getPrototypeOf(Function);\n        var usePolyfill = typeof process === \"object\" && process.env && process.env[\"REFLECT_METADATA_USE_MAP_POLYFILL\"] === \"true\";\n        var _Map = !usePolyfill && typeof Map === \"function\" && typeof Map.prototype.entries === \"function\" ? Map : CreateMapPolyfill();\n        var _Set = !usePolyfill && typeof Set === \"function\" && typeof Set.prototype.entries === \"function\" ? Set : CreateSetPolyfill();\n        var _WeakMap = !usePolyfill && typeof WeakMap === \"function\" ? WeakMap : CreateWeakMapPolyfill();\n        // [[Metadata]] internal slot\n        // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots\n        var Metadata = new _WeakMap();\n        /**\n         * Applies a set of decorators to a property of a target object.\n         * @param decorators An array of decorators.\n         * @param target The target object.\n         * @param propertyKey (Optional) The property key to decorate.\n         * @param attributes (Optional) The property descriptor for the target key.\n         * @remarks Decorators are applied in reverse order.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     Example = Reflect.decorate(decoratorsArray, Example);\n         *\n         *     // property (on constructor)\n         *     Reflect.decorate(decoratorsArray, Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     Reflect.decorate(decoratorsArray, Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     Object.defineProperty(Example, \"staticMethod\",\n         *         Reflect.decorate(decoratorsArray, Example, \"staticMethod\",\n         *             Object.getOwnPropertyDescriptor(Example, \"staticMethod\")));\n         *\n         *     // method (on prototype)\n         *     Object.defineProperty(Example.prototype, \"method\",\n         *         Reflect.decorate(decoratorsArray, Example.prototype, \"method\",\n         *             Object.getOwnPropertyDescriptor(Example.prototype, \"method\")));\n         *\n         */\n        function decorate(decorators, target, propertyKey, attributes) {\n            if (!IsUndefined(propertyKey)) {\n                if (!IsArray(decorators))\n                    throw new TypeError();\n                if (!IsObject(target))\n                    throw new TypeError();\n                if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))\n                    throw new TypeError();\n                if (IsNull(attributes))\n                    attributes = undefined;\n                propertyKey = ToPropertyKey(propertyKey);\n                return DecorateProperty(decorators, target, propertyKey, attributes);\n            }\n            else {\n                if (!IsArray(decorators))\n                    throw new TypeError();\n                if (!IsConstructor(target))\n                    throw new TypeError();\n                return DecorateConstructor(decorators, target);\n            }\n        }\n        exporter(\"decorate\", decorate);\n        // 4.1.2 Reflect.metadata(metadataKey, metadataValue)\n        // https://rbuckton.github.io/reflect-metadata/#reflect.metadata\n        /**\n         * A default metadata decorator factory that can be used on a class, class member, or parameter.\n         * @param metadataKey The key for the metadata entry.\n         * @param metadataValue The value for the metadata entry.\n         * @returns A decorator function.\n         * @remarks\n         * If `metadataKey` is already defined for the target and target key, the\n         * metadataValue for that key will be overwritten.\n         * @example\n         *\n         *     // constructor\n         *     @Reflect.metadata(key, value)\n         *     class Example {\n         *     }\n         *\n         *     // property (on constructor, TypeScript only)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         static staticProperty;\n         *     }\n         *\n         *     // property (on prototype, TypeScript only)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         property;\n         *     }\n         *\n         *     // method (on constructor)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         static staticMethod() { }\n         *     }\n         *\n         *     // method (on prototype)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         method() { }\n         *     }\n         *\n         */\n        function metadata(metadataKey, metadataValue) {\n            function decorator(target, propertyKey) {\n                if (!IsObject(target))\n                    throw new TypeError();\n                if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))\n                    throw new TypeError();\n                OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n            }\n            return decorator;\n        }\n        exporter(\"metadata\", metadata);\n        /**\n         * Define a unique metadata entry on the target.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param metadataValue A value that contains attached metadata.\n         * @param target The target object on which to define metadata.\n         * @param propertyKey (Optional) The property key for the target.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example);\n         *\n         *     // property (on constructor)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"method\");\n         *\n         *     // decorator factory as metadata-producing annotation.\n         *     function MyAnnotation(options): Decorator {\n         *         return (target, key?) => Reflect.defineMetadata(\"custom:annotation\", options, target, key);\n         *     }\n         *\n         */\n        function defineMetadata(metadataKey, metadataValue, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n        }\n        exporter(\"defineMetadata\", defineMetadata);\n        /**\n         * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function hasMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryHasMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"hasMetadata\", hasMetadata);\n        /**\n         * Gets a value indicating whether the target object has the provided metadata key defined.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function hasOwnMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"hasOwnMetadata\", hasOwnMetadata);\n        /**\n         * Gets the metadata value for the provided metadata key on the target object or its prototype chain.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function getMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryGetMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"getMetadata\", getMetadata);\n        /**\n         * Gets the metadata value for the provided metadata key on the target object.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function getOwnMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"getOwnMetadata\", getOwnMetadata);\n        /**\n         * Gets the metadata keys defined on the target object or its prototype chain.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns An array of unique metadata keys.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getMetadataKeys(Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getMetadataKeys(Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getMetadataKeys(Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getMetadataKeys(Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getMetadataKeys(Example.prototype, \"method\");\n         *\n         */\n        function getMetadataKeys(target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryMetadataKeys(target, propertyKey);\n        }\n        exporter(\"getMetadataKeys\", getMetadataKeys);\n        /**\n         * Gets the unique metadata keys defined on the target object.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns An array of unique metadata keys.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getOwnMetadataKeys(Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getOwnMetadataKeys(Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getOwnMetadataKeys(Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getOwnMetadataKeys(Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getOwnMetadataKeys(Example.prototype, \"method\");\n         *\n         */\n        function getOwnMetadataKeys(target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryOwnMetadataKeys(target, propertyKey);\n        }\n        exporter(\"getOwnMetadataKeys\", getOwnMetadataKeys);\n        /**\n         * Deletes the metadata entry from the target object with the provided key.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata entry was found and deleted; otherwise, false.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function deleteMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            var metadataMap = GetOrCreateMetadataMap(target, propertyKey, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return false;\n            if (!metadataMap.delete(metadataKey))\n                return false;\n            if (metadataMap.size > 0)\n                return true;\n            var targetMetadata = Metadata.get(target);\n            targetMetadata.delete(propertyKey);\n            if (targetMetadata.size > 0)\n                return true;\n            Metadata.delete(target);\n            return true;\n        }\n        exporter(\"deleteMetadata\", deleteMetadata);\n        function DecorateConstructor(decorators, target) {\n            for (var i = decorators.length - 1; i >= 0; --i) {\n                var decorator = decorators[i];\n                var decorated = decorator(target);\n                if (!IsUndefined(decorated) && !IsNull(decorated)) {\n                    if (!IsConstructor(decorated))\n                        throw new TypeError();\n                    target = decorated;\n                }\n            }\n            return target;\n        }\n        function DecorateProperty(decorators, target, propertyKey, descriptor) {\n            for (var i = decorators.length - 1; i >= 0; --i) {\n                var decorator = decorators[i];\n                var decorated = decorator(target, propertyKey, descriptor);\n                if (!IsUndefined(decorated) && !IsNull(decorated)) {\n                    if (!IsObject(decorated))\n                        throw new TypeError();\n                    descriptor = decorated;\n                }\n            }\n            return descriptor;\n        }\n        function GetOrCreateMetadataMap(O, P, Create) {\n            var targetMetadata = Metadata.get(O);\n            if (IsUndefined(targetMetadata)) {\n                if (!Create)\n                    return undefined;\n                targetMetadata = new _Map();\n                Metadata.set(O, targetMetadata);\n            }\n            var metadataMap = targetMetadata.get(P);\n            if (IsUndefined(metadataMap)) {\n                if (!Create)\n                    return undefined;\n                metadataMap = new _Map();\n                targetMetadata.set(P, metadataMap);\n            }\n            return metadataMap;\n        }\n        // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata\n        function OrdinaryHasMetadata(MetadataKey, O, P) {\n            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n            if (hasOwn)\n                return true;\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (!IsNull(parent))\n                return OrdinaryHasMetadata(MetadataKey, parent, P);\n            return false;\n        }\n        // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata\n        function OrdinaryHasOwnMetadata(MetadataKey, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return false;\n            return ToBoolean(metadataMap.has(MetadataKey));\n        }\n        // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata\n        function OrdinaryGetMetadata(MetadataKey, O, P) {\n            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n            if (hasOwn)\n                return OrdinaryGetOwnMetadata(MetadataKey, O, P);\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (!IsNull(parent))\n                return OrdinaryGetMetadata(MetadataKey, parent, P);\n            return undefined;\n        }\n        // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata\n        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return undefined;\n            return metadataMap.get(MetadataKey);\n        }\n        // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata\n        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);\n            metadataMap.set(MetadataKey, MetadataValue);\n        }\n        // 3.1.6.1 OrdinaryMetadataKeys(O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys\n        function OrdinaryMetadataKeys(O, P) {\n            var ownKeys = OrdinaryOwnMetadataKeys(O, P);\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (parent === null)\n                return ownKeys;\n            var parentKeys = OrdinaryMetadataKeys(parent, P);\n            if (parentKeys.length <= 0)\n                return ownKeys;\n            if (ownKeys.length <= 0)\n                return parentKeys;\n            var set = new _Set();\n            var keys = [];\n            for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {\n                var key = ownKeys_1[_i];\n                var hasKey = set.has(key);\n                if (!hasKey) {\n                    set.add(key);\n                    keys.push(key);\n                }\n            }\n            for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {\n                var key = parentKeys_1[_a];\n                var hasKey = set.has(key);\n                if (!hasKey) {\n                    set.add(key);\n                    keys.push(key);\n                }\n            }\n            return keys;\n        }\n        // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys\n        function OrdinaryOwnMetadataKeys(O, P) {\n            var keys = [];\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return keys;\n            var keysObj = metadataMap.keys();\n            var iterator = GetIterator(keysObj);\n            var k = 0;\n            while (true) {\n                var next = IteratorStep(iterator);\n                if (!next) {\n                    keys.length = k;\n                    return keys;\n                }\n                var nextValue = IteratorValue(next);\n                try {\n                    keys[k] = nextValue;\n                }\n                catch (e) {\n                    try {\n                        IteratorClose(iterator);\n                    }\n                    finally {\n                        throw e;\n                    }\n                }\n                k++;\n            }\n        }\n        // 6 ECMAScript Data Typ0es and Values\n        // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\n        function Type(x) {\n            if (x === null)\n                return 1 /* Null */;\n            switch (typeof x) {\n                case \"undefined\": return 0 /* Undefined */;\n                case \"boolean\": return 2 /* Boolean */;\n                case \"string\": return 3 /* String */;\n                case \"symbol\": return 4 /* Symbol */;\n                case \"number\": return 5 /* Number */;\n                case \"object\": return x === null ? 1 /* Null */ : 6 /* Object */;\n                default: return 6 /* Object */;\n            }\n        }\n        // 6.1.1 The Undefined Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type\n        function IsUndefined(x) {\n            return x === undefined;\n        }\n        // 6.1.2 The Null Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type\n        function IsNull(x) {\n            return x === null;\n        }\n        // 6.1.5 The Symbol Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type\n        function IsSymbol(x) {\n            return typeof x === \"symbol\";\n        }\n        // 6.1.7 The Object Type\n        // https://tc39.github.io/ecma262/#sec-object-type\n        function IsObject(x) {\n            return typeof x === \"object\" ? x !== null : typeof x === \"function\";\n        }\n        // 7.1 Type Conversion\n        // https://tc39.github.io/ecma262/#sec-type-conversion\n        // 7.1.1 ToPrimitive(input [, PreferredType])\n        // https://tc39.github.io/ecma262/#sec-toprimitive\n        function ToPrimitive(input, PreferredType) {\n            switch (Type(input)) {\n                case 0 /* Undefined */: return input;\n                case 1 /* Null */: return input;\n                case 2 /* Boolean */: return input;\n                case 3 /* String */: return input;\n                case 4 /* Symbol */: return input;\n                case 5 /* Number */: return input;\n            }\n            var hint = PreferredType === 3 /* String */ ? \"string\" : PreferredType === 5 /* Number */ ? \"number\" : \"default\";\n            var exoticToPrim = GetMethod(input, toPrimitiveSymbol);\n            if (exoticToPrim !== undefined) {\n                var result = exoticToPrim.call(input, hint);\n                if (IsObject(result))\n                    throw new TypeError();\n                return result;\n            }\n            return OrdinaryToPrimitive(input, hint === \"default\" ? \"number\" : hint);\n        }\n        // 7.1.1.1 OrdinaryToPrimitive(O, hint)\n        // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive\n        function OrdinaryToPrimitive(O, hint) {\n            if (hint === \"string\") {\n                var toString_1 = O.toString;\n                if (IsCallable(toString_1)) {\n                    var result = toString_1.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n                var valueOf = O.valueOf;\n                if (IsCallable(valueOf)) {\n                    var result = valueOf.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n            }\n            else {\n                var valueOf = O.valueOf;\n                if (IsCallable(valueOf)) {\n                    var result = valueOf.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n                var toString_2 = O.toString;\n                if (IsCallable(toString_2)) {\n                    var result = toString_2.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n            }\n            throw new TypeError();\n        }\n        // 7.1.2 ToBoolean(argument)\n        // https://tc39.github.io/ecma262/2016/#sec-toboolean\n        function ToBoolean(argument) {\n            return !!argument;\n        }\n        // 7.1.12 ToString(argument)\n        // https://tc39.github.io/ecma262/#sec-tostring\n        function ToString(argument) {\n            return \"\" + argument;\n        }\n        // 7.1.14 ToPropertyKey(argument)\n        // https://tc39.github.io/ecma262/#sec-topropertykey\n        function ToPropertyKey(argument) {\n            var key = ToPrimitive(argument, 3 /* String */);\n            if (IsSymbol(key))\n                return key;\n            return ToString(key);\n        }\n        // 7.2 Testing and Comparison Operations\n        // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations\n        // 7.2.2 IsArray(argument)\n        // https://tc39.github.io/ecma262/#sec-isarray\n        function IsArray(argument) {\n            return Array.isArray\n                ? Array.isArray(argument)\n                : argument instanceof Object\n                    ? argument instanceof Array\n                    : Object.prototype.toString.call(argument) === \"[object Array]\";\n        }\n        // 7.2.3 IsCallable(argument)\n        // https://tc39.github.io/ecma262/#sec-iscallable\n        function IsCallable(argument) {\n            // NOTE: This is an approximation as we cannot check for [[Call]] internal method.\n            return typeof argument === \"function\";\n        }\n        // 7.2.4 IsConstructor(argument)\n        // https://tc39.github.io/ecma262/#sec-isconstructor\n        function IsConstructor(argument) {\n            // NOTE: This is an approximation as we cannot check for [[Construct]] internal method.\n            return typeof argument === \"function\";\n        }\n        // 7.2.7 IsPropertyKey(argument)\n        // https://tc39.github.io/ecma262/#sec-ispropertykey\n        function IsPropertyKey(argument) {\n            switch (Type(argument)) {\n                case 3 /* String */: return true;\n                case 4 /* Symbol */: return true;\n                default: return false;\n            }\n        }\n        // 7.3 Operations on Objects\n        // https://tc39.github.io/ecma262/#sec-operations-on-objects\n        // 7.3.9 GetMethod(V, P)\n        // https://tc39.github.io/ecma262/#sec-getmethod\n        function GetMethod(V, P) {\n            var func = V[P];\n            if (func === undefined || func === null)\n                return undefined;\n            if (!IsCallable(func))\n                throw new TypeError();\n            return func;\n        }\n        // 7.4 Operations on Iterator Objects\n        // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects\n        function GetIterator(obj) {\n            var method = GetMethod(obj, iteratorSymbol);\n            if (!IsCallable(method))\n                throw new TypeError(); // from Call\n            var iterator = method.call(obj);\n            if (!IsObject(iterator))\n                throw new TypeError();\n            return iterator;\n        }\n        // 7.4.4 IteratorValue(iterResult)\n        // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue\n        function IteratorValue(iterResult) {\n            return iterResult.value;\n        }\n        // 7.4.5 IteratorStep(iterator)\n        // https://tc39.github.io/ecma262/#sec-iteratorstep\n        function IteratorStep(iterator) {\n            var result = iterator.next();\n            return result.done ? false : result;\n        }\n        // 7.4.6 IteratorClose(iterator, completion)\n        // https://tc39.github.io/ecma262/#sec-iteratorclose\n        function IteratorClose(iterator) {\n            var f = iterator[\"return\"];\n            if (f)\n                f.call(iterator);\n        }\n        // 9.1 Ordinary Object Internal Methods and Internal Slots\n        // https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots\n        // 9.1.1.1 OrdinaryGetPrototypeOf(O)\n        // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof\n        function OrdinaryGetPrototypeOf(O) {\n            var proto = Object.getPrototypeOf(O);\n            if (typeof O !== \"function\" || O === functionPrototype)\n                return proto;\n            // TypeScript doesn't set __proto__ in ES5, as it's non-standard.\n            // Try to determine the superclass constructor. Compatible implementations\n            // must either set __proto__ on a subclass constructor to the superclass constructor,\n            // or ensure each class has a valid `constructor` property on its prototype that\n            // points back to the constructor.\n            // If this is not the same as Function.[[Prototype]], then this is definately inherited.\n            // This is the case when in ES6 or when using __proto__ in a compatible browser.\n            if (proto !== functionPrototype)\n                return proto;\n            // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.\n            var prototype = O.prototype;\n            var prototypeProto = prototype && Object.getPrototypeOf(prototype);\n            if (prototypeProto == null || prototypeProto === Object.prototype)\n                return proto;\n            // If the constructor was not a function, then we cannot determine the heritage.\n            var constructor = prototypeProto.constructor;\n            if (typeof constructor !== \"function\")\n                return proto;\n            // If we have some kind of self-reference, then we cannot determine the heritage.\n            if (constructor === O)\n                return proto;\n            // we have a pretty good guess at the heritage.\n            return constructor;\n        }\n        // naive Map shim\n        function CreateMapPolyfill() {\n            var cacheSentinel = {};\n            var arraySentinel = [];\n            var MapIterator = /** @class */ (function () {\n                function MapIterator(keys, values, selector) {\n                    this._index = 0;\n                    this._keys = keys;\n                    this._values = values;\n                    this._selector = selector;\n                }\n                MapIterator.prototype[\"@@iterator\"] = function () { return this; };\n                MapIterator.prototype[iteratorSymbol] = function () { return this; };\n                MapIterator.prototype.next = function () {\n                    var index = this._index;\n                    if (index >= 0 && index < this._keys.length) {\n                        var result = this._selector(this._keys[index], this._values[index]);\n                        if (index + 1 >= this._keys.length) {\n                            this._index = -1;\n                            this._keys = arraySentinel;\n                            this._values = arraySentinel;\n                        }\n                        else {\n                            this._index++;\n                        }\n                        return { value: result, done: false };\n                    }\n                    return { value: undefined, done: true };\n                };\n                MapIterator.prototype.throw = function (error) {\n                    if (this._index >= 0) {\n                        this._index = -1;\n                        this._keys = arraySentinel;\n                        this._values = arraySentinel;\n                    }\n                    throw error;\n                };\n                MapIterator.prototype.return = function (value) {\n                    if (this._index >= 0) {\n                        this._index = -1;\n                        this._keys = arraySentinel;\n                        this._values = arraySentinel;\n                    }\n                    return { value: value, done: true };\n                };\n                return MapIterator;\n            }());\n            return /** @class */ (function () {\n                function Map() {\n                    this._keys = [];\n                    this._values = [];\n                    this._cacheKey = cacheSentinel;\n                    this._cacheIndex = -2;\n                }\n                Object.defineProperty(Map.prototype, \"size\", {\n                    get: function () { return this._keys.length; },\n                    enumerable: true,\n                    configurable: true\n                });\n                Map.prototype.has = function (key) { return this._find(key, /*insert*/ false) >= 0; };\n                Map.prototype.get = function (key) {\n                    var index = this._find(key, /*insert*/ false);\n                    return index >= 0 ? this._values[index] : undefined;\n                };\n                Map.prototype.set = function (key, value) {\n                    var index = this._find(key, /*insert*/ true);\n                    this._values[index] = value;\n                    return this;\n                };\n                Map.prototype.delete = function (key) {\n                    var index = this._find(key, /*insert*/ false);\n                    if (index >= 0) {\n                        var size = this._keys.length;\n                        for (var i = index + 1; i < size; i++) {\n                            this._keys[i - 1] = this._keys[i];\n                            this._values[i - 1] = this._values[i];\n                        }\n                        this._keys.length--;\n                        this._values.length--;\n                        if (key === this._cacheKey) {\n                            this._cacheKey = cacheSentinel;\n                            this._cacheIndex = -2;\n                        }\n                        return true;\n                    }\n                    return false;\n                };\n                Map.prototype.clear = function () {\n                    this._keys.length = 0;\n                    this._values.length = 0;\n                    this._cacheKey = cacheSentinel;\n                    this._cacheIndex = -2;\n                };\n                Map.prototype.keys = function () { return new MapIterator(this._keys, this._values, getKey); };\n                Map.prototype.values = function () { return new MapIterator(this._keys, this._values, getValue); };\n                Map.prototype.entries = function () { return new MapIterator(this._keys, this._values, getEntry); };\n                Map.prototype[\"@@iterator\"] = function () { return this.entries(); };\n                Map.prototype[iteratorSymbol] = function () { return this.entries(); };\n                Map.prototype._find = function (key, insert) {\n                    if (this._cacheKey !== key) {\n                        this._cacheIndex = this._keys.indexOf(this._cacheKey = key);\n                    }\n                    if (this._cacheIndex < 0 && insert) {\n                        this._cacheIndex = this._keys.length;\n                        this._keys.push(key);\n                        this._values.push(undefined);\n                    }\n                    return this._cacheIndex;\n                };\n                return Map;\n            }());\n            function getKey(key, _) {\n                return key;\n            }\n            function getValue(_, value) {\n                return value;\n            }\n            function getEntry(key, value) {\n                return [key, value];\n            }\n        }\n        // naive Set shim\n        function CreateSetPolyfill() {\n            return /** @class */ (function () {\n                function Set() {\n                    this._map = new _Map();\n                }\n                Object.defineProperty(Set.prototype, \"size\", {\n                    get: function () { return this._map.size; },\n                    enumerable: true,\n                    configurable: true\n                });\n                Set.prototype.has = function (value) { return this._map.has(value); };\n                Set.prototype.add = function (value) { return this._map.set(value, value), this; };\n                Set.prototype.delete = function (value) { return this._map.delete(value); };\n                Set.prototype.clear = function () { this._map.clear(); };\n                Set.prototype.keys = function () { return this._map.keys(); };\n                Set.prototype.values = function () { return this._map.values(); };\n                Set.prototype.entries = function () { return this._map.entries(); };\n                Set.prototype[\"@@iterator\"] = function () { return this.keys(); };\n                Set.prototype[iteratorSymbol] = function () { return this.keys(); };\n                return Set;\n            }());\n        }\n        // naive WeakMap shim\n        function CreateWeakMapPolyfill() {\n            var UUID_SIZE = 16;\n            var keys = HashMap.create();\n            var rootKey = CreateUniqueKey();\n            return /** @class */ (function () {\n                function WeakMap() {\n                    this._key = CreateUniqueKey();\n                }\n                WeakMap.prototype.has = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? HashMap.has(table, this._key) : false;\n                };\n                WeakMap.prototype.get = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? HashMap.get(table, this._key) : undefined;\n                };\n                WeakMap.prototype.set = function (target, value) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ true);\n                    table[this._key] = value;\n                    return this;\n                };\n                WeakMap.prototype.delete = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? delete table[this._key] : false;\n                };\n                WeakMap.prototype.clear = function () {\n                    // NOTE: not a real clear, just makes the previous data unreachable\n                    this._key = CreateUniqueKey();\n                };\n                return WeakMap;\n            }());\n            function CreateUniqueKey() {\n                var key;\n                do\n                    key = \"@@WeakMap@@\" + CreateUUID();\n                while (HashMap.has(keys, key));\n                keys[key] = true;\n                return key;\n            }\n            function GetOrCreateWeakMapTable(target, create) {\n                if (!hasOwn.call(target, rootKey)) {\n                    if (!create)\n                        return undefined;\n                    Object.defineProperty(target, rootKey, { value: HashMap.create() });\n                }\n                return target[rootKey];\n            }\n            function FillRandomBytes(buffer, size) {\n                for (var i = 0; i < size; ++i)\n                    buffer[i] = Math.random() * 0xff | 0;\n                return buffer;\n            }\n            function GenRandomBytes(size) {\n                if (typeof Uint8Array === \"function\") {\n                    if (typeof crypto !== \"undefined\")\n                        return crypto.getRandomValues(new Uint8Array(size));\n                    if (typeof msCrypto !== \"undefined\")\n                        return msCrypto.getRandomValues(new Uint8Array(size));\n                    return FillRandomBytes(new Uint8Array(size), size);\n                }\n                return FillRandomBytes(new Array(size), size);\n            }\n            function CreateUUID() {\n                var data = GenRandomBytes(UUID_SIZE);\n                // mark as random - RFC 4122 § 4.4\n                data[6] = data[6] & 0x4f | 0x40;\n                data[8] = data[8] & 0xbf | 0x80;\n                var result = \"\";\n                for (var offset = 0; offset < UUID_SIZE; ++offset) {\n                    var byte = data[offset];\n                    if (offset === 4 || offset === 6 || offset === 8)\n                        result += \"-\";\n                    if (byte < 16)\n                        result += \"0\";\n                    result += byte.toString(16).toLowerCase();\n                }\n                return result;\n            }\n        }\n        // uses a heuristic used by v8 and chakra to force an object into dictionary mode.\n        function MakeDictionary(obj) {\n            obj.__ = undefined;\n            delete obj.__;\n            return obj;\n        }\n    });\n})(Reflect || (Reflect = {}));\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\nmodule.exports = function () {\n  throw new Error(\n    'ws does not work in the browser. Browser clients must use the native ' +\n      'WebSocket object'\n  );\n};\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\n\r\nimport { IButtplugClientConnector } from './IButtplugClientConnector';\r\nimport { ButtplugMessage } from '../core/Messages';\r\nimport { FromJSON } from '../core/MessageUtils';\r\nimport { ButtplugMessageSorter } from '../utils/ButtplugMessageSorter';\r\nimport { ButtplugBrowserWebsocketConnector } from '../utils/ButtplugBrowserWebsocketConnector';\r\n\r\nexport class ButtplugBrowserWebsocketClientConnector\r\n  extends ButtplugBrowserWebsocketConnector\r\n  implements IButtplugClientConnector\r\n{\r\n  private _sorter: ButtplugMessageSorter = new ButtplugMessageSorter(true);\r\n\r\n  public Send = async (msg: ButtplugMessage): Promise<ButtplugMessage> => {\r\n    if (!this.Connected) {\r\n      throw new Error('ButtplugClient not connected');\r\n    }\r\n    const p = this._sorter.PrepareOutgoingMessage(msg);\r\n    this.SendMessage(msg);\r\n    return await p;\r\n  };\r\n\r\n  protected ParseIncomingMessage = (event: MessageEvent) => {\r\n    if (typeof event.data === 'string') {\r\n      const msgs = FromJSON(event.data);\r\n      const emitMsgs = this._sorter.ParseIncomingMessages(msgs);\r\n      this.emit('message', emitMsgs);\r\n    } else if (event.data instanceof Blob) {\r\n      // No-op, buttplug only uses text formatting.\r\n    }\r\n  };\r\n\r\n  protected OnReaderLoad(event: Event) {\r\n    const msgs = FromJSON((event.target as FileReader).result);\r\n    const emitMsgs = this._sorter.ParseIncomingMessages(msgs);\r\n    this.emit('message', emitMsgs);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nimport { ButtplugError } from '../core/Exceptions';\r\nimport * as Messages from '../core/Messages';\r\n\r\nexport class ButtplugClientConnectorException extends ButtplugError {\r\n  public constructor(message: string) {\r\n    super(message, Messages.ErrorClass.ERROR_UNKNOWN);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\nimport * as Messages from '../core/Messages';\r\nimport {\r\n  ButtplugDeviceError,\r\n  ButtplugError,\r\n  ButtplugMessageError,\r\n} from '../core/Exceptions';\r\nimport { EventEmitter } from 'eventemitter3';\r\n\r\n/**\r\n * Represents an abstract device, capable of taking certain kinds of messages.\r\n */\r\nexport class ButtplugClientDevice extends EventEmitter {\r\n  /**\r\n   * Return the name of the device.\r\n   */\r\n  public get name(): string {\r\n    return this._deviceInfo.DeviceName;\r\n  }\r\n\r\n  /**\r\n   * Return the user set name of the device.\r\n   */\r\n  public get displayName(): string | undefined {\r\n    return this._deviceInfo.DeviceDisplayName;\r\n  }\r\n\r\n  /**\r\n   * Return the index of the device.\r\n   */\r\n  public get index(): number {\r\n    return this._deviceInfo.DeviceIndex;\r\n  }\r\n\r\n  /**\r\n   * Return the index of the device.\r\n   */\r\n  public get messageTimingGap(): number | undefined {\r\n    return this._deviceInfo.DeviceMessageTimingGap;\r\n  }\r\n\r\n  /**\r\n   * Return a list of message types the device accepts.\r\n   */\r\n  public get messageAttributes(): Messages.MessageAttributes {\r\n    return this._deviceInfo.DeviceMessages;\r\n  }\r\n\r\n  public static fromMsg(\r\n    msg: Messages.DeviceInfo,\r\n    sendClosure: (\r\n      device: ButtplugClientDevice,\r\n      msg: Messages.ButtplugDeviceMessage\r\n    ) => Promise<Messages.ButtplugMessage>\r\n  ): ButtplugClientDevice {\r\n    return new ButtplugClientDevice(msg, sendClosure);\r\n  }\r\n\r\n  // Map of messages and their attributes (feature count, etc...)\r\n  private allowedMsgs: Map<string, Messages.MessageAttributes> = new Map<\r\n    string,\r\n    Messages.MessageAttributes\r\n  >();\r\n\r\n  /**\r\n   * @param _index Index of the device, as created by the device manager.\r\n   * @param _name Name of the device.\r\n   * @param allowedMsgs Buttplug messages the device can receive.\r\n   */\r\n  constructor(\r\n    private _deviceInfo: Messages.DeviceInfo,\r\n    private _sendClosure: (\r\n      device: ButtplugClientDevice,\r\n      msg: Messages.ButtplugDeviceMessage\r\n    ) => Promise<Messages.ButtplugMessage>\r\n  ) {\r\n    super();\r\n    _deviceInfo.DeviceMessages.update();\r\n  }\r\n\r\n  public async send(\r\n    msg: Messages.ButtplugDeviceMessage\r\n  ): Promise<Messages.ButtplugMessage> {\r\n    // Assume we're getting the closure from ButtplugClient, which does all of\r\n    // the index/existence/connection/message checks for us.\r\n    return await this._sendClosure(this, msg);\r\n  }\r\n\r\n  public async sendExpectOk(\r\n    msg: Messages.ButtplugDeviceMessage\r\n  ): Promise<void> {\r\n    const response = await this.send(msg);\r\n    switch (response.constructor) {\r\n      case Messages.Ok:\r\n        return;\r\n      case Messages.Error:\r\n        throw ButtplugError.FromError(response as Messages.Error);\r\n      default:\r\n        throw new ButtplugMessageError(\r\n          `Message type ${response.constructor} not handled by SendMsgExpectOk`\r\n        );\r\n    }\r\n  }\r\n\r\n  public async scalar(\r\n    scalar: Messages.ScalarSubcommand | Messages.ScalarSubcommand[]\r\n  ): Promise<void> {\r\n    if (Array.isArray(scalar)) {\r\n      await this.sendExpectOk(new Messages.ScalarCmd(scalar, this.index));\r\n    } else {\r\n      await this.sendExpectOk(new Messages.ScalarCmd([scalar], this.index));\r\n    }\r\n  }\r\n\r\n  private async scalarCommandBuilder(\r\n    speed: number | number[],\r\n    actuator: Messages.ActuatorType\r\n  ) {\r\n    const scalarAttrs = this.messageAttributes.ScalarCmd?.filter(\r\n      (x) => x.ActuatorType === actuator\r\n    );\r\n    if (!scalarAttrs || scalarAttrs.length === 0) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no ${actuator} capabilities`\r\n      );\r\n    }\r\n    const cmds: Messages.ScalarSubcommand[] = [];\r\n    if (typeof speed === 'number') {\r\n      scalarAttrs.forEach((x) =>\r\n        cmds.push(new Messages.ScalarSubcommand(x.Index, speed, actuator))\r\n      );\r\n    } else if (Array.isArray(speed)) {\r\n      if (speed.length > scalarAttrs.length) {\r\n        throw new ButtplugDeviceError(\r\n          `${speed.length} commands send to a device with ${scalarAttrs.length} vibrators`\r\n        );\r\n      }\r\n      scalarAttrs.forEach((x, i) => {\r\n        cmds.push(new Messages.ScalarSubcommand(x.Index, speed[i], actuator));\r\n      });\r\n    } else {\r\n      throw new ButtplugDeviceError(\r\n        `${actuator} can only take numbers or arrays of numbers.`\r\n      );\r\n    }\r\n    await this.scalar(cmds);\r\n  }\r\n\r\n  public get vibrateAttributes(): Messages.GenericDeviceMessageAttributes[] {\r\n    return (\r\n      this.messageAttributes.ScalarCmd?.filter(\r\n        (x) => x.ActuatorType === Messages.ActuatorType.Vibrate\r\n      ) ?? []\r\n    );\r\n  }\r\n\r\n  public async vibrate(speed: number | number[]): Promise<void> {\r\n    await this.scalarCommandBuilder(speed, Messages.ActuatorType.Vibrate);\r\n  }\r\n\r\n  public get oscillateAttributes(): Messages.GenericDeviceMessageAttributes[] {\r\n    return (\r\n      this.messageAttributes.ScalarCmd?.filter(\r\n        (x) => x.ActuatorType === Messages.ActuatorType.Oscillate\r\n      ) ?? []\r\n    );\r\n  }\r\n\r\n  public async oscillate(speed: number | number[]): Promise<void> {\r\n    await this.scalarCommandBuilder(speed, Messages.ActuatorType.Oscillate);\r\n  }\r\n\r\n  public get rotateAttributes(): Messages.GenericDeviceMessageAttributes[] {\r\n    return this.messageAttributes.RotateCmd ?? [];\r\n  }\r\n\r\n  public async rotate(\r\n    values: number | [number, boolean][],\r\n    clockwise?: boolean\r\n  ): Promise<void> {\r\n    const rotateAttrs = this.messageAttributes.RotateCmd;\r\n    if (!rotateAttrs || rotateAttrs.length === 0) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no Rotate capabilities`\r\n      );\r\n    }\r\n    let msg: Messages.RotateCmd;\r\n    if (typeof values === 'number') {\r\n      msg = Messages.RotateCmd.Create(\r\n        this.index,\r\n        new Array(rotateAttrs.length).fill([values, clockwise])\r\n      );\r\n    } else if (Array.isArray(values)) {\r\n      msg = Messages.RotateCmd.Create(this.index, values);\r\n    } else {\r\n      throw new ButtplugDeviceError(\r\n        'SendRotateCmd can only take a number and boolean, or an array of number/boolean tuples'\r\n      );\r\n    }\r\n    await this.sendExpectOk(msg);\r\n  }\r\n\r\n  public get linearAttributes(): Messages.GenericDeviceMessageAttributes[] {\r\n    return this.messageAttributes.RotateCmd ?? [];\r\n  }\r\n\r\n  public async linear(\r\n    values: number | [number, number][],\r\n    duration?: number\r\n  ): Promise<void> {\r\n    const linearAttrs = this.messageAttributes.LinearCmd;\r\n    if (!linearAttrs || linearAttrs.length === 0) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no Linear capabilities`\r\n      );\r\n    }\r\n    let msg: Messages.LinearCmd;\r\n    if (typeof values === 'number') {\r\n      msg = Messages.LinearCmd.Create(\r\n        this.index,\r\n        new Array(linearAttrs.length).fill([values, duration])\r\n      );\r\n    } else if (Array.isArray(values)) {\r\n      msg = Messages.LinearCmd.Create(this.index, values);\r\n    } else {\r\n      throw new ButtplugDeviceError(\r\n        'SendLinearCmd can only take a number and number, or an array of number/number tuples'\r\n      );\r\n    }\r\n    await this.sendExpectOk(msg);\r\n  }\r\n\r\n  public async sensorRead(\r\n    sensorIndex: number,\r\n    sensorType: Messages.SensorType\r\n  ): Promise<number[]> {\r\n    const response = await this.send(\r\n      new Messages.SensorReadCmd(this.index, sensorIndex, sensorType)\r\n    );\r\n    switch (response.constructor) {\r\n      case Messages.SensorReading:\r\n        return (response as Messages.SensorReading).Data;\r\n      case Messages.Error:\r\n        throw ButtplugError.FromError(response as Messages.Error);\r\n      default:\r\n        throw new ButtplugMessageError(\r\n          `Message type ${response.constructor} not handled by sensorRead`\r\n        );\r\n    }\r\n  }\r\n\r\n  public get hasBattery(): boolean {\r\n    const batteryAttrs = this.messageAttributes.SensorReadCmd?.filter(\r\n      (x) => x.SensorType === Messages.SensorType.Battery\r\n    );\r\n    return batteryAttrs !== undefined && batteryAttrs.length > 0;\r\n  }\r\n\r\n  public async battery(): Promise<number> {\r\n    if (!this.hasBattery) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no Battery capabilities`\r\n      );\r\n    }\r\n    const batteryAttrs = this.messageAttributes.SensorReadCmd?.filter(\r\n      (x) => x.SensorType === Messages.SensorType.Battery\r\n    );\r\n    // Find the battery sensor, we'll need its index.\r\n    const result = await this.sensorRead(\r\n      batteryAttrs![0].Index,\r\n      Messages.SensorType.Battery\r\n    );\r\n    return result[0] / 100.0;\r\n  }\r\n\r\n  public get hasRssi(): boolean {\r\n    const rssiAttrs = this.messageAttributes.SensorReadCmd?.filter(\r\n      (x) => x.SensorType === Messages.SensorType.RSSI\r\n    );\r\n    return rssiAttrs !== undefined && rssiAttrs.length === 0;\r\n  }\r\n\r\n  public async rssi(): Promise<number> {\r\n    if (!this.hasRssi) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no RSSI capabilities`\r\n      );\r\n    }\r\n    const rssiAttrs = this.messageAttributes.SensorReadCmd?.filter(\r\n      (x) => x.SensorType === Messages.SensorType.RSSI\r\n    );\r\n    // Find the battery sensor, we'll need its index.\r\n    const result = await this.sensorRead(\r\n      rssiAttrs![0].Index,\r\n      Messages.SensorType.RSSI\r\n    );\r\n    return result[0];\r\n  }\r\n\r\n  public async rawRead(\r\n    endpoint: string,\r\n    expectedLength: number,\r\n    timeout: number\r\n  ): Promise<Uint8Array> {\r\n    if (!this.messageAttributes.RawReadCmd) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw read capabilities`\r\n      );\r\n    }\r\n    if (this.messageAttributes.RawReadCmd.Endpoints.indexOf(endpoint) === -1) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw readable endpoint ${endpoint}`\r\n      );\r\n    }\r\n    const response = await this.send(\r\n      new Messages.RawReadCmd(this.index, endpoint, expectedLength, timeout)\r\n    );\r\n    switch (response.constructor) {\r\n      case Messages.RawReading:\r\n        return new Uint8Array((response as Messages.RawReading).Data);\r\n      case Messages.Error:\r\n        throw ButtplugError.FromError(response as Messages.Error);\r\n      default:\r\n        throw new ButtplugMessageError(\r\n          `Message type ${response.constructor} not handled by rawRead`\r\n        );\r\n    }\r\n  }\r\n\r\n  public async rawWrite(\r\n    endpoint: string,\r\n    data: Uint8Array,\r\n    writeWithResponse: boolean\r\n  ): Promise<void> {\r\n    if (!this.messageAttributes.RawWriteCmd) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw write capabilities`\r\n      );\r\n    }\r\n    if (this.messageAttributes.RawWriteCmd.Endpoints.indexOf(endpoint) === -1) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw writable endpoint ${endpoint}`\r\n      );\r\n    }\r\n    await this.sendExpectOk(\r\n      new Messages.RawWriteCmd(this.index, endpoint, data, writeWithResponse)\r\n    );\r\n  }\r\n\r\n  public async rawSubscribe(endpoint: string): Promise<void> {\r\n    if (!this.messageAttributes.RawSubscribeCmd) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw subscribe capabilities`\r\n      );\r\n    }\r\n    if (\r\n      this.messageAttributes.RawSubscribeCmd.Endpoints.indexOf(endpoint) === -1\r\n    ) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw subscribable endpoint ${endpoint}`\r\n      );\r\n    }\r\n    await this.sendExpectOk(new Messages.RawSubscribeCmd(this.index, endpoint));\r\n  }\r\n\r\n  public async rawUnsubscribe(endpoint: string): Promise<void> {\r\n    // This reuses raw subscribe's info.\r\n    if (!this.messageAttributes.RawSubscribeCmd) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw unsubscribe capabilities`\r\n      );\r\n    }\r\n    if (\r\n      this.messageAttributes.RawSubscribeCmd.Endpoints.indexOf(endpoint) === -1\r\n    ) {\r\n      throw new ButtplugDeviceError(\r\n        `Device ${this.name} has no raw unsubscribable endpoint ${endpoint}`\r\n      );\r\n    }\r\n    await this.sendExpectOk(\r\n      new Messages.RawUnsubscribeCmd(this.index, endpoint)\r\n    );\r\n  }\r\n\r\n  public async stop(): Promise<void> {\r\n    await this.sendExpectOk(new Messages.StopDeviceCmd(this.index));\r\n  }\r\n\r\n  public emitDisconnected() {\r\n    this.emit('deviceremoved');\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\n\r\nimport { ButtplugBrowserWebsocketClientConnector } from './ButtplugBrowserWebsocketClientConnector';\r\nimport { WebSocket as NodeWebSocket } from 'ws';\r\n\r\nexport class ButtplugNodeWebsocketClientConnector extends ButtplugBrowserWebsocketClientConnector {\r\n  protected _websocketConstructor =\r\n    NodeWebSocket as unknown as typeof WebSocket;\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\n\r\nimport { ButtplugLogger } from '../core/Logging';\r\nimport { EventEmitter } from 'eventemitter3';\r\nimport { ButtplugClientDevice } from './ButtplugClientDevice';\r\nimport { IButtplugClientConnector } from './IButtplugClientConnector';\r\nimport * as Messages from '../core/Messages';\r\nimport {\r\n  ButtplugDeviceError,\r\n  ButtplugError,\r\n  ButtplugInitError,\r\n  ButtplugMessageError,\r\n} from '../core/Exceptions';\r\nimport { ButtplugClientConnectorException } from './ButtplugClientConnectorException';\r\n\r\nexport class ButtplugClient extends EventEmitter {\r\n  protected _pingTimer: NodeJS.Timeout | null = null;\r\n  protected _connector: IButtplugClientConnector | null = null;\r\n  protected _devices: Map<number, ButtplugClientDevice> = new Map();\r\n  protected _clientName: string;\r\n  protected _logger = ButtplugLogger.Logger;\r\n  protected _isScanning = false;\r\n\r\n  constructor(clientName = 'Generic Buttplug Client') {\r\n    super();\r\n    this._clientName = clientName;\r\n    this._logger.Debug(`ButtplugClient: Client ${clientName} created.`);\r\n  }\r\n\r\n  public get connected(): boolean {\r\n    return this._connector !== null && this._connector.Connected;\r\n  }\r\n\r\n  public get devices(): ButtplugClientDevice[] {\r\n    // While this function doesn't actually send a message, if we don't have a\r\n    // connector, we shouldn't have devices.\r\n    this.checkConnector();\r\n    const devices: ButtplugClientDevice[] = [];\r\n    this._devices.forEach((d) => {\r\n      devices.push(d);\r\n    });\r\n    return devices;\r\n  }\r\n\r\n  public get isScanning(): boolean {\r\n    return this._isScanning;\r\n  }\r\n\r\n  public connect = async (connector: IButtplugClientConnector) => {\r\n    this._logger.Info(\r\n      `ButtplugClient: Connecting using ${connector.constructor.name}`\r\n    );\r\n    await connector.Connect();\r\n    this._connector = connector;\r\n    this._connector.addListener('message', this.parseMessages);\r\n    this._connector.addListener('disconnect', this.disconnectHandler);\r\n    await this.initializeConnection();\r\n  };\r\n\r\n  public disconnect = async () => {\r\n    this._logger.Debug('ButtplugClient: Disconnect called');\r\n    this.checkConnector();\r\n    await this.shutdownConnection();\r\n    await this._connector!.Disconnect();\r\n  };\r\n\r\n  public startScanning = async () => {\r\n    this._logger.Debug('ButtplugClient: StartScanning called');\r\n    this._isScanning = true;\r\n    await this.sendMsgExpectOk(new Messages.StartScanning());\r\n  };\r\n\r\n  public stopScanning = async () => {\r\n    this._logger.Debug('ButtplugClient: StopScanning called');\r\n    this._isScanning = false;\r\n    await this.sendMsgExpectOk(new Messages.StopScanning());\r\n  };\r\n\r\n  public stopAllDevices = async () => {\r\n    this._logger.Debug('ButtplugClient: StopAllDevices');\r\n    await this.sendMsgExpectOk(new Messages.StopAllDevices());\r\n  };\r\n\r\n  private async sendDeviceMessage(\r\n    device: ButtplugClientDevice,\r\n    deviceMsg: Messages.ButtplugDeviceMessage\r\n  ): Promise<Messages.ButtplugMessage> {\r\n    this.checkConnector();\r\n    const dev = this._devices.get(device.index);\r\n    if (dev === undefined) {\r\n      throw ButtplugError.LogAndError(\r\n        ButtplugDeviceError,\r\n        this._logger,\r\n        `Device ${device.index} not available.`\r\n      );\r\n    }\r\n    deviceMsg.DeviceIndex = device.index;\r\n    return await this.sendMessage(deviceMsg);\r\n  }\r\n\r\n  protected disconnectHandler = () => {\r\n    this._logger.Info('ButtplugClient: Disconnect event receieved.');\r\n    this.emit('disconnect');\r\n  };\r\n\r\n  protected parseMessages = (msgs: Messages.ButtplugMessage[]) => {\r\n    for (const x of msgs) {\r\n      switch (x.constructor) {\r\n        case Messages.DeviceAdded: {\r\n          const addedMsg = x as Messages.DeviceAdded;\r\n          const addedDevice = ButtplugClientDevice.fromMsg(\r\n            addedMsg,\r\n            this.sendDeviceMessageClosure\r\n          );\r\n          this._devices.set(addedMsg.DeviceIndex, addedDevice);\r\n          this.emit('deviceadded', addedDevice);\r\n          break;\r\n        }\r\n        case Messages.DeviceRemoved: {\r\n          const removedMsg = x as Messages.DeviceRemoved;\r\n          if (this._devices.has(removedMsg.DeviceIndex)) {\r\n            const removedDevice = this._devices.get(removedMsg.DeviceIndex);\r\n            removedDevice?.emitDisconnected();\r\n            this._devices.delete(removedMsg.DeviceIndex);\r\n            this.emit('deviceremoved', removedDevice);\r\n          }\r\n          break;\r\n        }\r\n        case Messages.ScanningFinished:\r\n          this._isScanning = false;\r\n          this.emit('scanningfinished', x);\r\n          break;\r\n      }\r\n    }\r\n  };\r\n\r\n  protected initializeConnection = async (): Promise<boolean> => {\r\n    this.checkConnector();\r\n    const msg = await this.sendMessage(\r\n      new Messages.RequestServerInfo(\r\n        this._clientName,\r\n        Messages.MESSAGE_SPEC_VERSION\r\n      )\r\n    );\r\n    switch (msg.constructor) {\r\n      case Messages.ServerInfo: {\r\n        const serverinfo = msg as Messages.ServerInfo;\r\n        this._logger.Info(\r\n          `ButtplugClient: Connected to Server ${serverinfo.ServerName}`\r\n        );\r\n        // TODO: maybe store server name, do something with message template version?\r\n        const ping = serverinfo.MaxPingTime;\r\n        if (serverinfo.MessageVersion < Messages.MESSAGE_SPEC_VERSION) {\r\n          // Disconnect and throw an exception explaining the version mismatch problem.\r\n          await this._connector!.Disconnect();\r\n          throw ButtplugError.LogAndError(\r\n            ButtplugInitError,\r\n            this._logger,\r\n            `Server protocol version ${serverinfo.MessageVersion} is older than client protocol version ${Messages.MESSAGE_SPEC_VERSION}. Please update server.`\r\n          );\r\n        }\r\n        if (ping > 0) {\r\n          /*\r\n          this._pingTimer = setInterval(async () => {\r\n            // If we've disconnected, stop trying to ping the server.\r\n            if (!this.Connected) {\r\n              await this.ShutdownConnection();\r\n              return;\r\n            }\r\n            await this.SendMessage(new Messages.Ping());\r\n          } , Math.round(ping / 2));\r\n          */\r\n        }\r\n        await this.requestDeviceList();\r\n        return true;\r\n      }\r\n      case Messages.Error: {\r\n        // Disconnect and throw an exception with the error message we got back.\r\n        // This will usually only error out if we have a version mismatch that the\r\n        // server has detected.\r\n        await this._connector!.Disconnect();\r\n        const err = msg as Messages.Error;\r\n        throw ButtplugError.LogAndError(\r\n          ButtplugInitError,\r\n          this._logger,\r\n          `Cannot connect to server. ${err.ErrorMessage}`\r\n        );\r\n      }\r\n    }\r\n    return false;\r\n  };\r\n\r\n  protected requestDeviceList = async () => {\r\n    this.checkConnector();\r\n    this._logger.Debug('ButtplugClient: ReceiveDeviceList called');\r\n    const deviceList = (await this.sendMessage(\r\n      new Messages.RequestDeviceList()\r\n    )) as Messages.DeviceList;\r\n    deviceList.Devices.forEach((d) => {\r\n      if (!this._devices.has(d.DeviceIndex)) {\r\n        const device = ButtplugClientDevice.fromMsg(\r\n          d,\r\n          this.sendDeviceMessageClosure\r\n        );\r\n        this._logger.Debug(`ButtplugClient: Adding Device: ${device}`);\r\n        this._devices.set(d.DeviceIndex, device);\r\n        this.emit('deviceadded', device);\r\n      } else {\r\n        this._logger.Debug(`ButtplugClient: Device already added: ${d}`);\r\n      }\r\n    });\r\n  };\r\n\r\n  protected shutdownConnection = async () => {\r\n    await this.stopAllDevices();\r\n    if (this._pingTimer !== null) {\r\n      clearInterval(this._pingTimer);\r\n      this._pingTimer = null;\r\n    }\r\n  };\r\n\r\n  protected async sendMessage(\r\n    msg: Messages.ButtplugMessage\r\n  ): Promise<Messages.ButtplugMessage> {\r\n    this.checkConnector();\r\n    return await this._connector!.Send(msg);\r\n  }\r\n\r\n  protected checkConnector() {\r\n    if (!this.connected) {\r\n      throw new ButtplugClientConnectorException(\r\n        'ButtplugClient not connected'\r\n      );\r\n    }\r\n  }\r\n\r\n  protected sendMsgExpectOk = async (\r\n    msg: Messages.ButtplugMessage\r\n  ): Promise<void> => {\r\n    const response = await this.sendMessage(msg);\r\n    switch (response.constructor) {\r\n      case Messages.Ok:\r\n        return;\r\n      case Messages.Error:\r\n        throw ButtplugError.FromError(response as Messages.Error);\r\n      default:\r\n        throw ButtplugError.LogAndError(\r\n          ButtplugMessageError,\r\n          this._logger,\r\n          `Message type ${response.constructor} not handled by SendMsgExpectOk`\r\n        );\r\n    }\r\n  };\r\n\r\n  protected sendDeviceMessageClosure = async (\r\n    device: ButtplugClientDevice,\r\n    msg: Messages.ButtplugDeviceMessage\r\n  ): Promise<Messages.ButtplugMessage> => {\r\n    return await this.sendDeviceMessage(device, msg);\r\n  };\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nimport * as Messages from './Messages';\r\nimport { ButtplugLogger } from './Logging';\r\n\r\nexport class ButtplugError extends Error {\r\n  public get ErrorClass(): Messages.ErrorClass {\r\n    return this.errorClass;\r\n  }\r\n\r\n  public get InnerError(): Error | undefined {\r\n    return this.innerError;\r\n  }\r\n\r\n  public get Id(): number | undefined {\r\n    return this.messageId;\r\n  }\r\n\r\n  public get ErrorMessage(): Messages.ButtplugMessage {\r\n    return new Messages.Error(this.message, this.ErrorClass, this.Id);\r\n  }\r\n\r\n  public static LogAndError<T extends ButtplugError>(\r\n    constructor: new (str: string, num: number) => T,\r\n    logger: ButtplugLogger,\r\n    message: string,\r\n    id: number = Messages.SYSTEM_MESSAGE_ID\r\n  ): T {\r\n    logger.Error(message);\r\n    return new constructor(message, id);\r\n  }\r\n\r\n  public static FromError(error: Messages.Error) {\r\n    switch (error.ErrorCode) {\r\n      case Messages.ErrorClass.ERROR_DEVICE:\r\n        return new ButtplugDeviceError(error.ErrorMessage, error.Id);\r\n      case Messages.ErrorClass.ERROR_INIT:\r\n        return new ButtplugInitError(error.ErrorMessage, error.Id);\r\n      case Messages.ErrorClass.ERROR_UNKNOWN:\r\n        return new ButtplugUnknownError(error.ErrorMessage, error.Id);\r\n      case Messages.ErrorClass.ERROR_PING:\r\n        return new ButtplugPingError(error.ErrorMessage, error.Id);\r\n      case Messages.ErrorClass.ERROR_MSG:\r\n        return new ButtplugMessageError(error.ErrorMessage, error.Id);\r\n      default:\r\n        throw new Error(`Message type ${error.ErrorCode} not handled`);\r\n    }\r\n  }\r\n\r\n  public errorClass: Messages.ErrorClass = Messages.ErrorClass.ERROR_UNKNOWN;\r\n  public innerError: Error | undefined;\r\n  public messageId: number | undefined;\r\n\r\n  protected constructor(\r\n    message: string,\r\n    errorClass: Messages.ErrorClass,\r\n    id: number = Messages.SYSTEM_MESSAGE_ID,\r\n    inner?: Error\r\n  ) {\r\n    super(message);\r\n    this.errorClass = errorClass;\r\n    this.innerError = inner;\r\n    this.messageId = id;\r\n  }\r\n}\r\n\r\nexport class ButtplugInitError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_INIT, id);\r\n  }\r\n}\r\n\r\nexport class ButtplugDeviceError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_DEVICE, id);\r\n  }\r\n}\r\n\r\nexport class ButtplugMessageError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_MSG, id);\r\n  }\r\n}\r\n\r\nexport class ButtplugPingError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_PING, id);\r\n  }\r\n}\r\n\r\nexport class ButtplugUnknownError extends ButtplugError {\r\n  public constructor(message: string, id: number = Messages.SYSTEM_MESSAGE_ID) {\r\n    super(message, Messages.ErrorClass.ERROR_UNKNOWN, id);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nimport { EventEmitter } from 'eventemitter3';\r\n\r\nexport enum ButtplugLogLevel {\r\n  Off,\r\n  Error,\r\n  Warn,\r\n  Info,\r\n  Debug,\r\n  Trace,\r\n}\r\n\r\n/**\r\n * Representation of log messages for the internal logging utility.\r\n */\r\nexport class LogMessage {\r\n  /** Timestamp for the log message */\r\n  private timestamp: string;\r\n\r\n  /** Log Message */\r\n  private logMessage: string;\r\n\r\n  /** Log Level */\r\n  private logLevel: ButtplugLogLevel;\r\n\r\n  /**\r\n   * @param logMessage Log message.\r\n   * @param logLevel: Log severity level.\r\n   */\r\n  public constructor(logMessage: string, logLevel: ButtplugLogLevel) {\r\n    const a = new Date();\r\n    const hour = a.getHours();\r\n    const min = a.getMinutes();\r\n    const sec = a.getSeconds();\r\n    this.timestamp = `${hour}:${min}:${sec}`;\r\n    this.logMessage = logMessage;\r\n    this.logLevel = logLevel;\r\n  }\r\n\r\n  /**\r\n   * Returns the log message.\r\n   */\r\n  public get Message() {\r\n    return this.logMessage;\r\n  }\r\n\r\n  /**\r\n   * Returns the log message level.\r\n   */\r\n  public get LogLevel() {\r\n    return this.logLevel;\r\n  }\r\n\r\n  /**\r\n   * Returns the log message timestamp.\r\n   */\r\n  public get Timestamp() {\r\n    return this.timestamp;\r\n  }\r\n\r\n  /**\r\n   * Returns a formatted string with timestamp, level, and message.\r\n   */\r\n  public get FormattedMessage() {\r\n    return `${ButtplugLogLevel[this.logLevel]} : ${this.timestamp} : ${\r\n      this.logMessage\r\n    }`;\r\n  }\r\n}\r\n\r\n/**\r\n * Simple, global logging utility for the Buttplug client and server. Keeps an\r\n * internal static reference to an instance of itself (singleton pattern,\r\n * basically), and allows message logging throughout the module.\r\n */\r\nexport class ButtplugLogger extends EventEmitter {\r\n  /** Singleton instance for the logger */\r\n  protected static sLogger: ButtplugLogger | undefined = undefined;\r\n  /** Sets maximum log level to log to console */\r\n  protected maximumConsoleLogLevel: ButtplugLogLevel = ButtplugLogLevel.Off;\r\n  /** Sets maximum log level for all log messages */\r\n  protected maximumEventLogLevel: ButtplugLogLevel = ButtplugLogLevel.Off;\r\n\r\n  /**\r\n   * Returns the stored static instance of the logger, creating one if it\r\n   * doesn't currently exist.\r\n   */\r\n  public static get Logger(): ButtplugLogger {\r\n    if (ButtplugLogger.sLogger === undefined) {\r\n      ButtplugLogger.sLogger = new ButtplugLogger();\r\n    }\r\n    return this.sLogger!;\r\n  }\r\n\r\n  /**\r\n   * Constructor. Can only be called internally since we regulate ButtplugLogger\r\n   * ownership.\r\n   */\r\n  protected constructor() {\r\n    super();\r\n  }\r\n\r\n  /**\r\n   * Set the maximum log level to output to console.\r\n   */\r\n  public get MaximumConsoleLogLevel() {\r\n    return this.maximumConsoleLogLevel;\r\n  }\r\n\r\n  /**\r\n   * Get the maximum log level to output to console.\r\n   */\r\n  public set MaximumConsoleLogLevel(buttplugLogLevel: ButtplugLogLevel) {\r\n    this.maximumConsoleLogLevel = buttplugLogLevel;\r\n  }\r\n\r\n  /**\r\n   * Set the global maximum log level\r\n   */\r\n  public get MaximumEventLogLevel() {\r\n    return this.maximumEventLogLevel;\r\n  }\r\n\r\n  /**\r\n   * Get the global maximum log level\r\n   */\r\n  public set MaximumEventLogLevel(logLevel: ButtplugLogLevel) {\r\n    this.maximumEventLogLevel = logLevel;\r\n  }\r\n\r\n  /**\r\n   * Log new message at Error level.\r\n   */\r\n  public Error(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Error);\r\n  }\r\n\r\n  /**\r\n   * Log new message at Warn level.\r\n   */\r\n  public Warn(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Warn);\r\n  }\r\n\r\n  /**\r\n   * Log new message at Info level.\r\n   */\r\n  public Info(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Info);\r\n  }\r\n\r\n  /**\r\n   * Log new message at Debug level.\r\n   */\r\n  public Debug(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Debug);\r\n  }\r\n\r\n  /**\r\n   * Log new message at Trace level.\r\n   */\r\n  public Trace(msg: string) {\r\n    this.AddLogMessage(msg, ButtplugLogLevel.Trace);\r\n  }\r\n\r\n  /**\r\n   * Checks to see if message should be logged, and if so, adds message to the\r\n   * log buffer. May also print message and emit event.\r\n   */\r\n  protected AddLogMessage(msg: string, level: ButtplugLogLevel) {\r\n    // If nothing wants the log message we have, ignore it.\r\n    if (\r\n      level > this.maximumEventLogLevel &&\r\n      level > this.maximumConsoleLogLevel\r\n    ) {\r\n      return;\r\n    }\r\n    const logMsg = new LogMessage(msg, level);\r\n    // Clients and console logging may have different needs. For instance, it\r\n    // could be that the client requests trace level, while all we want in the\r\n    // console is info level. This makes sure the client can't also spam the\r\n    // console.\r\n    if (level <= this.maximumConsoleLogLevel) {\r\n      console.log(logMsg.FormattedMessage);\r\n    }\r\n    if (level <= this.maximumEventLogLevel) {\r\n      this.emit('log', logMsg);\r\n    }\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\nimport { plainToInstance } from 'class-transformer';\r\nimport * as Messages from './Messages';\r\n\r\nfunction getMessageClass(\r\n  type: string\r\n): (new (...args: unknown[]) => Messages.ButtplugMessage) | null {\r\n  for (const value of Object.values(Messages)) {\r\n    if (typeof value === 'function' && 'Name' in value && value.Name === type) {\r\n      return value;\r\n    }\r\n  }\r\n  return null;\r\n}\r\n\r\nexport function FromJSON(str): Messages.ButtplugMessage[] {\r\n  const msgarray: object[] = JSON.parse(str);\r\n  const msgs: Messages.ButtplugMessage[] = [];\r\n  for (const x of Array.from(msgarray)) {\r\n    const type = Object.getOwnPropertyNames(x)[0];\r\n    const cls = getMessageClass(type);\r\n    if (cls) {\r\n      const msg = plainToInstance<Messages.ButtplugMessage, unknown>(\r\n        cls,\r\n        x[type]\r\n      );\r\n      msg.update();\r\n      msgs.push(msg);\r\n    }\r\n  }\r\n  return msgs;\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n// tslint:disable:max-classes-per-file\r\n'use strict';\r\n\r\nimport { instanceToPlain, Type } from 'class-transformer';\r\nimport 'reflect-metadata';\r\n\r\nexport const SYSTEM_MESSAGE_ID = 0;\r\nexport const DEFAULT_MESSAGE_ID = 1;\r\nexport const MAX_ID = 4294967295;\r\nexport const MESSAGE_SPEC_VERSION = 3;\r\n\r\nexport class MessageAttributes {\r\n  public ScalarCmd?: Array<GenericDeviceMessageAttributes>;\r\n  public RotateCmd?: Array<GenericDeviceMessageAttributes>;\r\n  public LinearCmd?: Array<GenericDeviceMessageAttributes>;\r\n  public RawReadCmd?: RawDeviceMessageAttributes;\r\n  public RawWriteCmd?: RawDeviceMessageAttributes;\r\n  public RawSubscribeCmd?: RawDeviceMessageAttributes;\r\n  public SensorReadCmd?: Array<SensorDeviceMessageAttributes>;\r\n  public SensorSubscribeCmd?: Array<SensorDeviceMessageAttributes>;\r\n  public StopDeviceCmd: {};\r\n\r\n  constructor(data: Partial<MessageAttributes>) {\r\n    Object.assign(this, data);\r\n  }\r\n\r\n  public update() {\r\n    this.ScalarCmd?.forEach((x, i) => (x.Index = i));\r\n    this.RotateCmd?.forEach((x, i) => (x.Index = i));\r\n    this.LinearCmd?.forEach((x, i) => (x.Index = i));\r\n    this.SensorReadCmd?.forEach((x, i) => (x.Index = i));\r\n    this.SensorSubscribeCmd?.forEach((x, i) => (x.Index = i));\r\n  }\r\n}\r\n\r\nexport enum ActuatorType {\r\n  Unknown = 'Unknown',\r\n  Vibrate = 'Vibrate',\r\n  Rotate = 'Rotate',\r\n  Oscillate = 'Oscillate',\r\n  Constrict = 'Constrict',\r\n  Inflate = 'Inflate',\r\n  Position = 'Position',\r\n}\r\n\r\nexport enum SensorType {\r\n  Unknown = 'Unknown',\r\n  Battery = 'Battery',\r\n  RSSI = 'RSSI',\r\n  Button = 'Button',\r\n  Pressure = 'Pressure',\r\n  // Temperature,\r\n  // Accelerometer,\r\n  // Gyro,\r\n}\r\n\r\nexport class GenericDeviceMessageAttributes {\r\n  public FeatureDescriptor: string;\r\n  public ActuatorType: ActuatorType;\r\n  public StepCount: number;\r\n  public Index = 0;\r\n  constructor(data: Partial<GenericDeviceMessageAttributes>) {\r\n    Object.assign(this, data);\r\n  }\r\n}\r\n\r\nexport class RawDeviceMessageAttributes {\r\n  constructor(public Endpoints: Array<string>) {}\r\n}\r\n\r\nexport class SensorDeviceMessageAttributes {\r\n  public FeatureDescriptor: string;\r\n  public SensorType: SensorType;\r\n  public StepRange: Array<number>;\r\n  public Index = 0;\r\n  constructor(data: Partial<GenericDeviceMessageAttributes>) {\r\n    Object.assign(this, data);\r\n  }\r\n}\r\n\r\nexport abstract class ButtplugMessage {\r\n  constructor(public Id: number) {}\r\n\r\n  // tslint:disable-next-line:ban-types\r\n  public get Type(): Function {\r\n    return this.constructor;\r\n  }\r\n\r\n  public toJSON(): string {\r\n    return JSON.stringify(this.toProtocolFormat());\r\n  }\r\n\r\n  public toProtocolFormat(): object {\r\n    const jsonObj = {};\r\n    jsonObj[(this.constructor as unknown as { Name: string }).Name] =\r\n      instanceToPlain(this);\r\n    return jsonObj;\r\n  }\r\n\r\n  public update() {}\r\n}\r\n\r\nexport abstract class ButtplugDeviceMessage extends ButtplugMessage {\r\n  constructor(public DeviceIndex: number, public Id: number) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport abstract class ButtplugSystemMessage extends ButtplugMessage {\r\n  constructor(public Id: number = SYSTEM_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class Ok extends ButtplugSystemMessage {\r\n  static Name = 'Ok';\r\n\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class Ping extends ButtplugMessage {\r\n  static Name = 'Ping';\r\n\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport enum ErrorClass {\r\n  ERROR_UNKNOWN,\r\n  ERROR_INIT,\r\n  ERROR_PING,\r\n  ERROR_MSG,\r\n  ERROR_DEVICE,\r\n}\r\n\r\nexport class Error extends ButtplugMessage {\r\n  static Name = 'Error';\r\n\r\n  constructor(\r\n    public ErrorMessage: string,\r\n    public ErrorCode: ErrorClass = ErrorClass.ERROR_UNKNOWN,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(Id);\r\n  }\r\n\r\n  get Schemversion() {\r\n    return 0;\r\n  }\r\n}\r\n\r\nexport class DeviceInfo {\r\n  public DeviceIndex: number;\r\n  public DeviceName: string;\r\n  @Type(() => MessageAttributes)\r\n  public DeviceMessages: MessageAttributes;\r\n  public DeviceDisplayName?: string;\r\n  public DeviceMessageTimingGap?: number;\r\n\r\n  constructor(data: Partial<DeviceInfo>) {\r\n    Object.assign(this, data);\r\n  }\r\n}\r\n\r\nexport class DeviceList extends ButtplugMessage {\r\n  static Name = 'DeviceList';\r\n\r\n  @Type(() => DeviceInfo)\r\n  public Devices: DeviceInfo[];\r\n  public Id: number;\r\n\r\n  constructor(devices: DeviceInfo[], id: number = DEFAULT_MESSAGE_ID) {\r\n    super(id);\r\n    this.Devices = devices;\r\n    this.Id = id;\r\n  }\r\n\r\n  public update() {\r\n    for (const device of this.Devices) {\r\n      device.DeviceMessages.update();\r\n    }\r\n  }\r\n}\r\n\r\nexport class DeviceAdded extends ButtplugSystemMessage {\r\n  static Name = 'DeviceAdded';\r\n\r\n  public DeviceIndex: number;\r\n  public DeviceName: string;\r\n  @Type(() => MessageAttributes)\r\n  public DeviceMessages: MessageAttributes;\r\n  public DeviceDisplayName?: string;\r\n  public DeviceMessageTimingGap?: number;\r\n\r\n  constructor(data: Partial<DeviceAdded>) {\r\n    super();\r\n    Object.assign(this, data);\r\n  }\r\n\r\n  public update() {\r\n    this.DeviceMessages.update();\r\n  }\r\n}\r\n\r\nexport class DeviceRemoved extends ButtplugSystemMessage {\r\n  static Name = 'DeviceRemoved';\r\n\r\n  constructor(public DeviceIndex: number) {\r\n    super();\r\n  }\r\n}\r\n\r\nexport class RequestDeviceList extends ButtplugMessage {\r\n  static Name = 'RequestDeviceList';\r\n\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class StartScanning extends ButtplugMessage {\r\n  static Name = 'StartScanning';\r\n\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class StopScanning extends ButtplugMessage {\r\n  static Name = 'StopScanning';\r\n\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class ScanningFinished extends ButtplugSystemMessage {\r\n  static Name = 'ScanningFinished';\r\n\r\n  constructor() {\r\n    super();\r\n  }\r\n}\r\n\r\nexport class RequestServerInfo extends ButtplugMessage {\r\n  static Name = 'RequestServerInfo';\r\n\r\n  constructor(\r\n    public ClientName: string,\r\n    public MessageVersion: number = 0,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class ServerInfo extends ButtplugSystemMessage {\r\n  static Name = 'ServerInfo';\r\n\r\n  constructor(\r\n    public MessageVersion: number,\r\n    public MaxPingTime: number,\r\n    public ServerName: string,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super();\r\n  }\r\n}\r\n\r\nexport class StopDeviceCmd extends ButtplugDeviceMessage {\r\n  static Name = 'StopDeviceCmd';\r\n\r\n  constructor(\r\n    public DeviceIndex: number = -1,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class StopAllDevices extends ButtplugMessage {\r\n  static Name = 'StopAllDevices';\r\n\r\n  constructor(public Id: number = DEFAULT_MESSAGE_ID) {\r\n    super(Id);\r\n  }\r\n}\r\n\r\nexport class GenericMessageSubcommand {\r\n  protected constructor(public Index: number) {}\r\n}\r\n\r\nexport class ScalarSubcommand extends GenericMessageSubcommand {\r\n  constructor(\r\n    Index: number,\r\n    public Scalar: number,\r\n    public ActuatorType: ActuatorType\r\n  ) {\r\n    super(Index);\r\n  }\r\n}\r\n\r\nexport class ScalarCmd extends ButtplugDeviceMessage {\r\n  static Name = 'ScalarCmd';\r\n\r\n  constructor(\r\n    public Scalars: ScalarSubcommand[],\r\n    public DeviceIndex: number = -1,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RotateSubcommand extends GenericMessageSubcommand {\r\n  constructor(Index: number, public Speed: number, public Clockwise: boolean) {\r\n    super(Index);\r\n  }\r\n}\r\n\r\nexport class RotateCmd extends ButtplugDeviceMessage {\r\n  static Name = 'RotateCmd';\r\n\r\n  public static Create(\r\n    deviceIndex: number,\r\n    commands: [number, boolean][]\r\n  ): RotateCmd {\r\n    const cmdList: RotateSubcommand[] = new Array<RotateSubcommand>();\r\n\r\n    let i = 0;\r\n    for (const [speed, clockwise] of commands) {\r\n      cmdList.push(new RotateSubcommand(i, speed, clockwise));\r\n      ++i;\r\n    }\r\n\r\n    return new RotateCmd(cmdList, deviceIndex);\r\n  }\r\n  constructor(\r\n    public Rotations: RotateSubcommand[],\r\n    public DeviceIndex: number = -1,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class VectorSubcommand extends GenericMessageSubcommand {\r\n  constructor(Index: number, public Position: number, public Duration: number) {\r\n    super(Index);\r\n  }\r\n}\r\n\r\nexport class LinearCmd extends ButtplugDeviceMessage {\r\n  static Name = 'LinearCmd';\r\n\r\n  public static Create(\r\n    deviceIndex: number,\r\n    commands: [number, number][]\r\n  ): LinearCmd {\r\n    const cmdList: VectorSubcommand[] = new Array<VectorSubcommand>();\r\n\r\n    let i = 0;\r\n    for (const cmd of commands) {\r\n      cmdList.push(new VectorSubcommand(i, cmd[0], cmd[1]));\r\n      ++i;\r\n    }\r\n\r\n    return new LinearCmd(cmdList, deviceIndex);\r\n  }\r\n  constructor(\r\n    public Vectors: VectorSubcommand[],\r\n    public DeviceIndex: number = -1,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class SensorReadCmd extends ButtplugDeviceMessage {\r\n  static Name = 'SensorReadCmd';\r\n\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public SensorIndex: number,\r\n    public SensorType: SensorType,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class SensorReading extends ButtplugDeviceMessage {\r\n  static Name = 'SensorReading';\r\n\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public SensorIndex: number,\r\n    public SensorType: SensorType,\r\n    public Data: number[],\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawReadCmd extends ButtplugDeviceMessage {\r\n  static Name = 'RawReadCmd';\r\n\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public ExpectedLength: number,\r\n    public Timeout: number,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawWriteCmd extends ButtplugDeviceMessage {\r\n  static Name = 'RawWriteCmd';\r\n\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public Data: Uint8Array,\r\n    public WriteWithResponse: boolean,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawSubscribeCmd extends ButtplugDeviceMessage {\r\n  static Name = 'RawSubscribeCmd';\r\n\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawUnsubscribeCmd extends ButtplugDeviceMessage {\r\n  static Name = 'RawUnsubscribeCmd';\r\n\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n\r\nexport class RawReading extends ButtplugDeviceMessage {\r\n  static Name = 'RawReading';\r\n\r\n  constructor(\r\n    public DeviceIndex: number,\r\n    public Endpoint: string,\r\n    public Data: number[],\r\n    public Id: number = DEFAULT_MESSAGE_ID\r\n  ) {\r\n    super(DeviceIndex, Id);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nexport * from './client/Client';\r\nexport * from './client/ButtplugClientDevice';\r\nexport * from './client/ButtplugBrowserWebsocketClientConnector';\r\nexport * from './client/ButtplugNodeWebsocketClientConnector';\r\nexport * from './client/ButtplugClientConnectorException';\r\nexport * from './utils/ButtplugMessageSorter';\r\nexport * from './client/IButtplugClientConnector';\r\nexport * from './core/Messages';\r\nexport * from './core/MessageUtils';\r\nexport * from './core/Logging';\r\nexport * from './core/Exceptions';\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\n'use strict';\r\n\r\nimport { EventEmitter } from 'eventemitter3';\r\nimport { ButtplugMessage } from '../core/Messages';\r\nimport { FromJSON } from '../core/MessageUtils';\r\n\r\nexport class ButtplugBrowserWebsocketConnector extends EventEmitter {\r\n  protected _ws: WebSocket | undefined;\r\n  protected _websocketConstructor: typeof WebSocket | null = null;\r\n\r\n  public constructor(private _url: string) {\r\n    super();\r\n  }\r\n\r\n  public get Connected(): boolean {\r\n    return this._ws !== undefined;\r\n  }\r\n\r\n  public Connect = async (): Promise<void> => {\r\n    const ws = new (this._websocketConstructor ?? WebSocket)(this._url);\r\n    let res;\r\n    let rej;\r\n    const p = new Promise<void>((resolve, reject) => {\r\n      res = resolve;\r\n      rej = reject;\r\n    });\r\n    // In websockets, our error rarely tells us much, as for security reasons\r\n    // browsers usually only throw Error Code 1006. It's up to those using this\r\n    // library to state what the problem might be.\r\n    const conErrorCallback = () => rej();\r\n    ws.addEventListener('open', async () => {\r\n      this._ws = ws;\r\n      try {\r\n        await this.Initialize();\r\n        this._ws.addEventListener('message', (msg) => {\r\n          this.ParseIncomingMessage(msg);\r\n        });\r\n        this._ws.removeEventListener('close', conErrorCallback);\r\n        this._ws.addEventListener('close', this.Disconnect);\r\n        // TODO This doesn't really communicate the chain why our initializer failed\r\n        res();\r\n      } catch (e) {\r\n        console.log(e);\r\n        rej();\r\n      }\r\n    });\r\n    ws.addEventListener('close', conErrorCallback);\r\n    return p;\r\n  };\r\n\r\n  public Disconnect = async (): Promise<void> => {\r\n    if (!this.Connected) {\r\n      return;\r\n    }\r\n    this._ws!.close();\r\n    this._ws = undefined;\r\n    this.emit('disconnect');\r\n  };\r\n\r\n  public SendMessage(msg: ButtplugMessage) {\r\n    if (!this.Connected) {\r\n      throw new Error('ButtplugBrowserWebsocketConnector not connected');\r\n    }\r\n    this._ws!.send('[' + msg.toJSON() + ']');\r\n  }\r\n\r\n  public Initialize = async (): Promise<void> => {\r\n    return Promise.resolve();\r\n  };\r\n\r\n  protected ParseIncomingMessage(event: MessageEvent) {\r\n    if (typeof event.data === 'string') {\r\n      const msgs = FromJSON(event.data);\r\n      this.emit('message', msgs);\r\n    } else if (event.data instanceof Blob) {\r\n      // No-op, we only use text message types.\r\n    }\r\n  }\r\n\r\n  protected OnReaderLoad(event: Event) {\r\n    const msgs = FromJSON((event.target as FileReader).result);\r\n    this.emit('message', msgs);\r\n  }\r\n}\r\n","/*!\r\n * Buttplug JS Source Code File - Visit https://buttplug.io for more info about\r\n * the project. Licensed under the BSD 3-Clause license. See LICENSE file in the\r\n * project root for full license information.\r\n *\r\n * @copyright Copyright (c) Nonpolynomial Labs LLC. All rights reserved.\r\n */\r\n\r\nimport * as Messages from '../core/Messages';\r\nimport { ButtplugError } from '../core/Exceptions';\r\n\r\nexport class ButtplugMessageSorter {\r\n  protected _counter = 1;\r\n  protected _waitingMsgs: Map<\r\n    number,\r\n    [(val: Messages.ButtplugMessage) => void, (err: Error) => void]\r\n  > = new Map();\r\n\r\n  public constructor(private _useCounter: boolean) {}\r\n\r\n  // One of the places we should actually return a promise, as we need to store\r\n  // them while waiting for them to return across the line.\r\n  // tslint:disable:promise-function-async\r\n  public PrepareOutgoingMessage(\r\n    msg: Messages.ButtplugMessage\r\n  ): Promise<Messages.ButtplugMessage> {\r\n    if (this._useCounter) {\r\n      msg.Id = this._counter;\r\n      // Always increment last, otherwise we might lose sync\r\n      this._counter += 1;\r\n    }\r\n    let res;\r\n    let rej;\r\n    const msgPromise = new Promise<Messages.ButtplugMessage>(\r\n      (resolve, reject) => {\r\n        res = resolve;\r\n        rej = reject;\r\n      }\r\n    );\r\n    this._waitingMsgs.set(msg.Id, [res, rej]);\r\n    return msgPromise;\r\n  }\r\n\r\n  public ParseIncomingMessages(\r\n    msgs: Messages.ButtplugMessage[]\r\n  ): Messages.ButtplugMessage[] {\r\n    const noMatch: Messages.ButtplugMessage[] = [];\r\n    for (const x of msgs) {\r\n      if (x.Id !== Messages.SYSTEM_MESSAGE_ID && this._waitingMsgs.has(x.Id)) {\r\n        const [res, rej] = this._waitingMsgs.get(x.Id)!;\r\n        // If we've gotten back an error, reject the related promise using a\r\n        // ButtplugException derived type.\r\n        if (x.Type === Messages.Error) {\r\n          rej(ButtplugError.FromError(x as Messages.Error));\r\n          continue;\r\n        }\r\n        res(x);\r\n        continue;\r\n      } else {\r\n        noMatch.push(x);\r\n      }\r\n    }\r\n    return noMatch;\r\n  }\r\n}\r\n"],"sourceRoot":""}