{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./src/constants.js","webpack:///./src/utils.js","webpack:///./src/log.js","webpack:///./src/retryProvider.js","webpack:///./src/webSocketManager.js","webpack:///./node_modules/sprintf-js/src/sprintf.js","webpack:///./src/index.js","webpack:///(webpack)/buildin/global.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","LOGS_DESTINATION","WEBSOCKET_RETRY_RATE_MS","ROUTE_KEY","CONN_STATE","Utils","premise","message","Error","assertTrue","undefined","_typeof","sprintf","length","Array","isArray","obj","constructor","apply","wsRegex","RegExp","validWSUrl","wsUrl","test","getSubscriptionResponse","routeKey","isSuccess","topicList","topic","content","status","topics","assertIsObject","isObject","addJitter","base","maxJitter","arguments","Math","min","sign","random","floor","isNetworkOnline","navigator","onLine","isNetworkFailure","reason","_debug","type","Logger","data","LogLevel","DEBUG","INFO","WARN","ERROR","LogManagerImpl","_classCallCheck","this","updateLoggerConfig","consoleLoggerWrapper","createConsoleLogger","level","logStatement","hasClientLogger","_clientLogger","debug","info","warn","error","_level","options","prefix","_logsDestination","LoggerWrapperImpl","inputConfig","config","logger","LoggerWrapper","_this","_possibleConstructorReturn","_getPrototypeOf","_len","args","_key","_log","_len2","_key2","_len3","_key3","_len4","_key4","LogManager","isLevelEnabled","writeToClientLogger","_shouldLog","_convertToSingleStatement","_writeToClientLogger","index","arg","_convertToString","isString","isFunction","toString","toStringResult","JSON","stringify","console","RetryProvider","executor","defaultRetry","retryProvider_classCallCheck","numAttempts","hasActiveReconnection","setTimeout","_execute","_getDelay","calculatedDelay","pow","__webpack_exports__","WebSocketManagerObject","WebSocketManager","getLogger","online","webSocket","primary","secondary","reconnectConfig","reconnectWebSocket","websocketInitFailed","exponentialBackOffTime","exponentialTimeoutHandle","lifeTimeTimeoutHandle","webSocketInitCheckerTimeoutId","connState","metrics","connectWebSocketRetryCount","connectionAttemptStartTime","noOpenConnectionsTimestamp","heartbeatConfig","pendingResponse","intervalHandle","callbacks","initFailure","Set","getWebSocketTransport","subscriptionUpdate","subscriptionFailure","Map","allMessage","connectionGain","connectionLost","connectionOpen","connectionClose","webSocketConfig","connConfig","promiseHandle","promiseCompleted","topicSubscription","subscribed","pending","subscriptionHistory","topicSubscriptionConfig","responseCheckIntervalId","requestCompleted","reSubscribeIntervalId","consecutiveFailedSubscribeAttempts","consecutiveNoResponseRequest","reconnectionClient","getWebSocketConnConfig","invalidSendMessageRouteKeys","networkConnectivityChecker","setInterval","sendInternalLogToServer","ws","getDefaultWebSocket","isWebSocketState","WebSocket","CLOSING","CLOSED","invokeCallbacks","response","forEach","callback","getWebSocketStates","readyState","CONNECTING","OPEN","printWebSocketState","event","webSocketStateCode","isWebSocketOpen","isWebSocketClosed","isDefaultWebSocketOpen","sendHeartBeat","clearInterval","send","createWebSocketPayload","resetWebSocketState","clearTimeout","resetSubscriptions","resetMetrics","webSocketOnOpen","now","Date","connectionEstablishedTime","timeToConnect","timeWithoutConnection","openTimestamp","size","closeSpecificWebSocket","add","clear","subscribePendingTopics","webSocketLifetimeTimeout","webSocketTransport","transportLifeTimeInSeconds","webSocketOnError","webSocketOnMessage","parse","topicName","has","from","close","closeWebSocket","retryWebSocketInitialization","waitTime","urlConnValidTime","initWebSocket","terminateWebSocketManager","validWebSocketConnConfig","isNonEmptyString","url","then","connected","webSocketConnectionFailed","retry","getNewWebSocket","addEventListener","closeTimestamp","connectionDuration","code","webSocketOnClose","logEntry","init","transportHandle","onInitFailure","cb","onConnectionOpen","onConnectionClose","onConnectionGain","onConnectionLost","onSubscriptionUpdate","onSubscriptionFailure","onMessage","assertNotNull","set","onAllMessage","subscribeTopics","assertIsList","sendMessage","payload","setGlobalConfig","loggerConfig","__WEBPACK_AMD_DEFINE_RESULT__","re","not_string","not_bool","not_type","not_primitive","number","numeric_arg","json","not_json","text","modulo","placeholder","key_access","index_access","parse_tree","argv","k","ph","pad","pad_character","pad_length","is_positive","cursor","tree_length","output","keys","param_no","Function","isNaN","TypeError","parseInt","String","fromCharCode","width","precision","parseFloat","toExponential","toFixed","Number","toPrecision","substring","slice","toLowerCase","valueOf","toUpperCase","replace","pad_char","charAt","repeat","align","sprintf_format","fmt","sprintf_cache","match","_fmt","arg_names","exec","push","SyntaxError","field_list","replacement_field","field_match","sprintf_parse","vsprintf","concat","window","global","_webSocketManager__WEBPACK_IMPORTED_MODULE_0__","connect","g","e"],"mappings":"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","file":"amazon-connect-websocket-manager.js","sourcesContent":[" \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 = 2);\n","\nexport const LOGS_DESTINATION = {\n NULL: \"NULL\",\n CLIENT_LOGGER: \"CLIENT_LOGGER\",\n DEBUG: \"DEBUG\"\n};\n\nexport const MIN_WEBSOCKET_LIFETIME_MS = 300000;\nexport const HEARTBEAT_INTERVAL_MS = 10000;\nexport const WEBSOCKET_URL_VALID_TIME_MS = 85000;\nexport const TOPIC_SUBSCRIPTION_RETRY_INTERVAL_MS = 500;\nexport const MAX_CONSECUTIVE_FAILED_SUB_ATTEMPTS = 5;\nexport const MAX_WAIT_TIME_SUB_REQUEST_WITH_NO_RESPONSE_MS = 1000;\nexport const MAX_CONSECUTIVE_SUB_REQUEST_WITH_NO_RESPONSE = 3;\nexport const NETWORK_CONN_CHECK_INTERVAL_MS = 250;\nexport const WEBSOCKET_REINIT_JITTER = 0.3;\nexport const WEBSOCKET_RETRY_RATE_MS = 2000;\nexport const MAX_WEBSOCKET_RETRY_RATE_MS = 30000;\n\nexport const NETWORK_FAILURE = 'NetworkingError';\n\nexport const ROUTE_KEY = {\n SUBSCRIBE: \"aws/subscribe\",\n UNSUBSCRIBE: \"aws/unsubscribe\",\n HEARTBEAT: \"aws/heartbeat\"\n};\n\nexport const CONN_STATE = {\n CONNECTED: \"connected\",\n DISCONNECTED: \"disconnected\"\n};\n","import { sprintf } from \"sprintf-js\";\nimport { NETWORK_FAILURE } from './constants';\n\nconst Utils = {};\n\n/**\n * Asserts that a premise is true.\n */\nUtils.assertTrue = function(premise, message) {\n if (!premise) {\n throw new Error(message);\n }\n};\n\n/**\n * Asserts that a value is not null or undefined.\n */\nUtils.assertNotNull = function(value, name) {\n Utils.assertTrue(\n value !== null && typeof value !== undefined,\n sprintf(\"%s must be provided\", name || \"A value\")\n );\n return value;\n};\n\nUtils.isNonEmptyString = function(value) {\n return typeof value === \"string\" && value.length > 0;\n};\n\nUtils.assertIsList = function(value, key) {\n if (!Array.isArray(value)) {\n throw new Error(key + \" is not an array\");\n }\n};\n\n/**\n * Determine if the given value is a callable function type.\n * Borrowed from Underscore.js.\n */\nUtils.isFunction = function(obj) {\n return !!(obj && obj.constructor && obj.call && obj.apply);\n};\n\nUtils.isObject = function(value) {\n return !(typeof value !== \"object\" || value === null);\n};\n\nUtils.isString = function(value) {\n return typeof value === \"string\";\n};\n\nUtils.isNumber = function(value) {\n return typeof value === \"number\";\n};\n\nconst wsRegex = new RegExp(\"^(wss://)\\\\w*\");\nUtils.validWSUrl = function (wsUrl) {\n return wsRegex.test(wsUrl);\n};\n\nUtils.getSubscriptionResponse = (routeKey, isSuccess, topicList) => {\n return {\n topic: routeKey,\n content : {\n status: isSuccess ? \"success\" : \"failure\",\n topics: topicList\n }\n };\n};\n\nUtils.assertIsObject = function(value, key) {\n if (!Utils.isObject(value)) {\n throw new Error(key + \" is not an object!\");\n }\n};\n\nUtils.addJitter = function (base, maxJitter = 1) {\n maxJitter = Math.min(maxJitter, 1.0);\n const sign = Math.random() > 0.5 ? 1 : -1;\n return Math.floor(base + sign * base * Math.random() * maxJitter);\n};\n\nUtils.isNetworkOnline = () => navigator.onLine;\n\nUtils.isNetworkFailure = (reason) => {\n if(reason._debug && reason._debug.type) {\n return reason._debug.type === NETWORK_FAILURE;\n }\n return false;\n};\n\nexport default Utils;\n","import Utils from \"./utils\";\nimport { LOGS_DESTINATION } from \"./constants\";\n\n/*eslint-disable no-unused-vars*/\nclass Logger {\n debug(data) {}\n\n info(data) {}\n\n warn(data) {}\n\n error(data) {}\n}\n/*eslint-enable no-unused-vars*/\n\nconst LogLevel = {\n DEBUG: 10,\n INFO: 20,\n WARN: 30,\n ERROR: 40\n};\n\nclass LogManagerImpl {\n constructor() {\n this.updateLoggerConfig();\n this.consoleLoggerWrapper = createConsoleLogger();\n }\n\n writeToClientLogger(level, logStatement) {\n if (!this.hasClientLogger()) {\n return;\n }\n switch (level) {\n case LogLevel.DEBUG:\n return this._clientLogger.debug(logStatement);\n case LogLevel.INFO:\n return this._clientLogger.info(logStatement);\n case LogLevel.WARN:\n return this._clientLogger.warn(logStatement);\n case LogLevel.ERROR:\n return this._clientLogger.error(logStatement);\n }\n }\n\n isLevelEnabled(level) {\n return level >= this._level;\n }\n\n hasClientLogger() {\n return this._clientLogger !== null;\n }\n\n getLogger(options) {\n var prefix = options.prefix || \"\";\n if (this._logsDestination === LOGS_DESTINATION.DEBUG) {\n return this.consoleLoggerWrapper;\n }\n return new LoggerWrapperImpl(prefix);\n }\n\n updateLoggerConfig(inputConfig) {\n var config = inputConfig || {};\n this._level = config.level || LogLevel.DEBUG;\n this._clientLogger = config.logger || null;\n this._logsDestination = LOGS_DESTINATION.NULL;\n if (config.debug) {\n this._logsDestination = LOGS_DESTINATION.DEBUG;\n }\n if (config.logger) {\n this._logsDestination = LOGS_DESTINATION.CLIENT_LOGGER;\n }\n }\n}\n\nclass LoggerWrapper {\n debug() {}\n\n info() {}\n\n warn() {}\n\n error() {}\n}\n\nclass LoggerWrapperImpl extends LoggerWrapper {\n constructor(prefix) {\n super();\n this.prefix = prefix || \"\";\n }\n\n debug(...args) {\n return this._log(LogLevel.DEBUG, args);\n }\n\n info(...args) {\n return this._log(LogLevel.INFO, args);\n }\n\n warn(...args) {\n return this._log(LogLevel.WARN, args);\n }\n\n error(...args) {\n return this._log(LogLevel.ERROR, args);\n }\n\n _shouldLog(level) {\n return LogManager.hasClientLogger() && LogManager.isLevelEnabled(level);\n }\n\n _writeToClientLogger(level, logStatement) {\n return LogManager.writeToClientLogger(level, logStatement);\n }\n\n _log(level, args) {\n if (this._shouldLog(level)) {\n var logStatement = this._convertToSingleStatement(args);\n return this._writeToClientLogger(level, logStatement);\n }\n }\n\n _convertToSingleStatement(args) {\n var logStatement = \"\";\n if (this.prefix) {\n logStatement += this.prefix + \" \";\n }\n for (var index = 0; index < args.length; index++) {\n var arg = args[index];\n logStatement += this._convertToString(arg) + \" \";\n }\n return logStatement;\n }\n\n _convertToString(arg) {\n try {\n if (!arg) {\n return \"\";\n }\n if (Utils.isString(arg)) {\n return arg;\n }\n if (Utils.isObject(arg) && Utils.isFunction(arg.toString)) {\n var toStringResult = arg.toString();\n if (toStringResult !== \"[object Object]\") {\n return toStringResult;\n }\n }\n return JSON.stringify(arg);\n } catch (error) {\n console.error(\"Error while converting argument to string\", arg, error);\n return \"\";\n }\n }\n}\n\nvar createConsoleLogger = () => {\n var logger = new LoggerWrapper();\n logger.debug = console.debug;\n logger.info = console.info;\n logger.warn = console.warn;\n logger.error = console.error;\n return logger;\n};\n\nconst LogManager = new LogManagerImpl();\n\nexport { LogManager, Logger, LogLevel };\n","import { WEBSOCKET_RETRY_RATE_MS, MAX_WEBSOCKET_RETRY_RATE_MS } from './constants';\n\nclass RetryProvider {\n constructor(executor, defaultRetry = WEBSOCKET_RETRY_RATE_MS) {\n this.numAttempts = 0;\n this.executor = executor;\n this.hasActiveReconnection = false;\n this.defaultRetry = defaultRetry;\n }\n\n retry() {\n // Don't kickoff another reconnection attempt if we have one pending\n if(!this.hasActiveReconnection) {\n this.hasActiveReconnection = true;\n setTimeout(() => {\n this._execute();\n }, this._getDelay());\n }\n }\n\n _execute() {\n this.hasActiveReconnection = false;\n this.executor();\n this.numAttempts++;\n }\n\n connected() {\n this.numAttempts = 0;\n }\n\n _getDelay() {\n const calculatedDelay = Math.pow(2, this.numAttempts) * this.defaultRetry;\n return calculatedDelay <= MAX_WEBSOCKET_RETRY_RATE_MS ? calculatedDelay : MAX_WEBSOCKET_RETRY_RATE_MS;\n }\n}\n\nexport { RetryProvider };","import Utils from \"./utils\";\nimport { LogManager, LogLevel, Logger } from \"./log\";\nimport {\n MIN_WEBSOCKET_LIFETIME_MS,\n WEBSOCKET_URL_VALID_TIME_MS,\n HEARTBEAT_INTERVAL_MS,\n ROUTE_KEY,\n CONN_STATE,\n MAX_CONSECUTIVE_FAILED_SUB_ATTEMPTS,\n TOPIC_SUBSCRIPTION_RETRY_INTERVAL_MS,\n MAX_WAIT_TIME_SUB_REQUEST_WITH_NO_RESPONSE_MS,\n MAX_CONSECUTIVE_SUB_REQUEST_WITH_NO_RESPONSE,\n NETWORK_CONN_CHECK_INTERVAL_MS,\n WEBSOCKET_REINIT_JITTER,\n} from \"./constants\";\nimport { RetryProvider } from './retryProvider';\n\nconst WebSocketManager = function() {\n\n const logger = LogManager.getLogger({});\n\n let online = Utils.isNetworkOnline();\n\n let webSocket = {\n primary: null,\n secondary: null\n };\n\n let reconnectConfig = {\n reconnectWebSocket: true,\n websocketInitFailed: false,\n exponentialBackOffTime: 1000,\n exponentialTimeoutHandle: null,\n lifeTimeTimeoutHandle: null,\n webSocketInitCheckerTimeoutId: null,\n connState: null\n };\n\n let metrics = {\n connectWebSocketRetryCount: 0,\n connectionAttemptStartTime: null,\n noOpenConnectionsTimestamp: null\n };\n\n let heartbeatConfig = {\n pendingResponse: false,\n intervalHandle: null\n };\n\n let callbacks = {\n initFailure: new Set(),\n getWebSocketTransport: null,\n subscriptionUpdate: new Set(),\n subscriptionFailure: new Set(),\n topic: new Map(),\n allMessage: new Set(),\n connectionGain: new Set(),\n connectionLost: new Set(),\n connectionOpen: new Set(),\n connectionClose: new Set()\n };\n\n let webSocketConfig = {\n connConfig: null,\n promiseHandle: null,\n promiseCompleted: true\n };\n\n let topicSubscription = {\n subscribed: new Set(),\n pending: new Set(),\n subscriptionHistory: new Set()\n };\n\n let topicSubscriptionConfig = {\n responseCheckIntervalId: null,\n requestCompleted: true,\n reSubscribeIntervalId: null,\n consecutiveFailedSubscribeAttempts: 0,\n consecutiveNoResponseRequest: 0\n };\n\n const reconnectionClient = new RetryProvider(() => { getWebSocketConnConfig(); });\n\n const invalidSendMessageRouteKeys = new Set([ROUTE_KEY.SUBSCRIBE, ROUTE_KEY.UNSUBSCRIBE, ROUTE_KEY.HEARTBEAT]);\n\n const networkConnectivityChecker = setInterval(function () {\n if (online !== Utils.isNetworkOnline()) {\n online = Utils.isNetworkOnline();\n if (!online) {\n sendInternalLogToServer(logger.info(\"Network offline\"));\n\n return;\n }\n const ws = getDefaultWebSocket();\n if (online && (!ws || isWebSocketState(ws, WebSocket.CLOSING) || isWebSocketState(ws, WebSocket.CLOSED))) {\n sendInternalLogToServer(logger.info(\"Network online, connecting to WebSocket server\"));\n\n getWebSocketConnConfig();\n }\n }\n }, NETWORK_CONN_CHECK_INTERVAL_MS);\n\n const invokeCallbacks = function(callbacks, response) {\n callbacks.forEach(function (callback) {\n try {\n callback(response);\n } catch (error) {\n sendInternalLogToServer(logger.error(\"Error executing callback\", error));\n }\n });\n };\n\n const getWebSocketStates = function(ws) {\n if (ws === null) return \"NULL\";\n switch (ws.readyState) {\n case WebSocket.CONNECTING:\n return \"CONNECTING\";\n case WebSocket.OPEN:\n return \"OPEN\";\n case WebSocket.CLOSING:\n return \"CLOSING\";\n case WebSocket.CLOSED:\n return \"CLOSED\";\n default:\n return \"UNDEFINED\";\n }\n };\n\n const printWebSocketState = function (event = \"\") {\n sendInternalLogToServer(logger.debug(\"[\" + event + \"] Primary WebSocket: \" + getWebSocketStates(webSocket.primary)\n + \" | \" + \"Secondary WebSocket: \" + getWebSocketStates(webSocket.secondary)));\n };\n\n const isWebSocketState = function(ws, webSocketStateCode) {\n return ws && ws.readyState === webSocketStateCode;\n };\n\n const isWebSocketOpen = function(ws) {\n return isWebSocketState(ws, WebSocket.OPEN);\n };\n\n const isWebSocketClosed = function(ws) {\n // undefined check is to address the limitation of testing framework\n return ws === null || ws.readyState === undefined || isWebSocketState(ws, WebSocket.CLOSED);\n };\n\n /**\n * This function is meant to handle the scenario when we have two web-sockets open\n * in such a scenario we always select secondary web-socket since all future operations\n * are supposed to be done by this secondary web-socket\n */\n const getDefaultWebSocket = function() {\n if (webSocket.secondary !== null) {\n return webSocket.secondary;\n }\n return webSocket.primary;\n };\n\n const isDefaultWebSocketOpen = function() {\n return isWebSocketOpen(getDefaultWebSocket());\n };\n\n const sendHeartBeat = function() {\n if (heartbeatConfig.pendingResponse) {\n sendInternalLogToServer(logger.warn(\"Heartbeat response not received\"));\n\n clearInterval(heartbeatConfig.intervalHandle);\n heartbeatConfig.pendingResponse = false;\n getWebSocketConnConfig();\n return;\n }\n if (isDefaultWebSocketOpen()) {\n sendInternalLogToServer(logger.debug(\"Sending heartbeat\"));\n\n getDefaultWebSocket().send(createWebSocketPayload(ROUTE_KEY.HEARTBEAT));\n heartbeatConfig.pendingResponse = true;\n } else {\n sendInternalLogToServer(logger.warn(\"Failed to send heartbeat since WebSocket is not open\"));\n\n printWebSocketState(\"sendHeartBeat\");\n getWebSocketConnConfig();\n }\n };\n\n const resetWebSocketState = function() {\n reconnectConfig.exponentialBackOffTime = 1000;\n heartbeatConfig.pendingResponse = false;\n reconnectConfig.reconnectWebSocket = true;\n\n clearTimeout(reconnectConfig.lifeTimeTimeoutHandle);\n clearInterval(heartbeatConfig.intervalHandle);\n clearTimeout(reconnectConfig.exponentialTimeoutHandle);\n clearTimeout(reconnectConfig.webSocketInitCheckerTimeoutId);\n };\n\n const resetSubscriptions = function() {\n topicSubscriptionConfig.consecutiveFailedSubscribeAttempts = 0;\n topicSubscriptionConfig.consecutiveNoResponseRequest = 0;\n clearInterval(topicSubscriptionConfig.responseCheckIntervalId);\n clearInterval(topicSubscriptionConfig.reSubscribeIntervalId);\n };\n\n const resetMetrics = function() {\n metrics.connectWebSocketRetryCount = 0;\n metrics.connectionAttemptStartTime = null;\n metrics.noOpenConnectionsTimestamp = null;\n };\n\n const webSocketOnOpen = function() {\n try {\n sendInternalLogToServer(logger.info(\"WebSocket connection established!\"));\n\n printWebSocketState(\"webSocketOnOpen\");\n if (reconnectConfig.connState === null || reconnectConfig.connState === CONN_STATE.DISCONNECTED) {\n invokeCallbacks(callbacks.connectionGain);\n }\n reconnectConfig.connState = CONN_STATE.CONNECTED;\n\n // Report number of retries to open and record ws open time\n const now = Date.now();\n invokeCallbacks(callbacks.connectionOpen, {\n connectWebSocketRetryCount: metrics.connectWebSocketRetryCount,\n connectionAttemptStartTime: metrics.connectionAttemptStartTime,\n noOpenConnectionsTimestamp: metrics.noOpenConnectionsTimestamp,\n connectionEstablishedTime: now,\n timeToConnect: now - metrics.connectionAttemptStartTime,\n timeWithoutConnection:\n metrics.noOpenConnectionsTimestamp ? now - metrics.noOpenConnectionsTimestamp : null\n });\n\n resetMetrics();\n resetWebSocketState();\n getDefaultWebSocket().openTimestamp = Date.now(); // record open time\n\n // early closure of primary web socket\n if (topicSubscription.subscribed.size === 0 && isWebSocketOpen(webSocket.secondary)) {\n closeSpecificWebSocket(webSocket.primary, \"[Primary WebSocket] Closing WebSocket\");\n }\n if (topicSubscription.subscribed.size > 0 || topicSubscription.pending.size > 0) {\n if (isWebSocketOpen(webSocket.secondary)) {\n sendInternalLogToServer(logger.info(\"Subscribing secondary websocket to topics of primary websocket\"));\n }\n topicSubscription.subscribed.forEach(topic => {\n topicSubscription.subscriptionHistory.add(topic);\n topicSubscription.pending.add(topic);\n });\n topicSubscription.subscribed.clear();\n subscribePendingTopics();\n }\n\n sendHeartBeat();\n heartbeatConfig.intervalHandle = setInterval(sendHeartBeat, HEARTBEAT_INTERVAL_MS);\n\n const webSocketLifetimeTimeout = webSocketConfig.connConfig.webSocketTransport.transportLifeTimeInSeconds * 1000;\n sendInternalLogToServer(logger.debug(\"Scheduling WebSocket manager reconnection, after delay \" + webSocketLifetimeTimeout + \" ms\"));\n\n reconnectConfig.lifeTimeTimeoutHandle = setTimeout(function() {\n sendInternalLogToServer(logger.debug(\"Starting scheduled WebSocket manager reconnection\"));\n\n getWebSocketConnConfig();\n }, webSocketLifetimeTimeout);\n } catch (error) {\n sendInternalLogToServer(logger.error(\"Error after establishing WebSocket connection\", error));\n }\n };\n\n const webSocketOnClose = function(event, ws) {\n sendInternalLogToServer(logger.info(\"Socket connection is closed\", event));\n\n printWebSocketState(\"webSocketOnClose before-cleanup\");\n\n invokeCallbacks(callbacks.connectionClose, {\n openTimestamp: ws.openTimestamp,\n closeTimestamp: Date.now(),\n connectionDuration: Date.now() - ws.openTimestamp,\n code: event.code,\n reason: event.reason\n });\n\n if (isWebSocketClosed(webSocket.primary)) {\n webSocket.primary = null;\n }\n if (isWebSocketClosed(webSocket.secondary)) {\n webSocket.secondary = null;\n }\n if (!reconnectConfig.reconnectWebSocket) {\n return;\n }\n if (!isWebSocketOpen(webSocket.primary) && !isWebSocketOpen(webSocket.secondary)) {\n sendInternalLogToServer(logger.warn(\"Neither primary websocket and nor secondary websocket have open connections, attempting to re-establish connection\"));\n\n if (reconnectConfig.connState === CONN_STATE.DISCONNECTED) {\n /**\n * This check is required in the scenario where WS Server shuts-down and closes all active\n * WS Client connections and WS Server takes about a minute to become active again, in this\n * scenario WS Client's onClose is triggered and then WSM start reconnect logic immediately but all\n * connect request to WS Server would fail and WS Client's onError callback would be triggered\n * followed WS Client's onClose callback and hence \"connectionLost\" callback would be invoked several\n * times and this behavior is redundant\n */\n sendInternalLogToServer(logger.info(\"Ignoring connectionLost callback invocation\"));\n } else {\n invokeCallbacks(callbacks.connectionLost, {\n openTimestamp: ws.openTimestamp,\n closeTimestamp: Date.now(),\n connectionDuration: Date.now() - ws.openTimestamp,\n code: event.code,\n reason: event.reason\n });\n metrics.noOpenConnectionsTimestamp = Date.now();\n }\n reconnectConfig.connState = CONN_STATE.DISCONNECTED;\n getWebSocketConnConfig();\n } else if (isWebSocketClosed(webSocket.primary) && isWebSocketOpen(webSocket.secondary)) {\n sendInternalLogToServer(logger.info(\"[Primary] WebSocket Cleanly Closed\"));\n\n webSocket.primary = webSocket.secondary;\n webSocket.secondary = null;\n }\n printWebSocketState(\"webSocketOnClose after-cleanup\");\n };\n\n const webSocketOnError = function(event) {\n printWebSocketState(\"webSocketOnError\");\n sendInternalLogToServer(logger.error(\"WebSocketManager Error, error_event: \", JSON.stringify(event)));\n\n getWebSocketConnConfig();\n };\n\n const webSocketOnMessage = function(event) {\n const response = JSON.parse(event.data);\n\n switch (response.topic) {\n\n case ROUTE_KEY.SUBSCRIBE: {\n sendInternalLogToServer(logger.debug(\"Subscription Message received from webSocket server\", event.data));\n\n topicSubscriptionConfig.requestCompleted = true;\n topicSubscriptionConfig.consecutiveNoResponseRequest = 0;\n\n if (response.content.status === \"success\") {\n topicSubscriptionConfig.consecutiveFailedSubscribeAttempts = 0;\n response.content.topics.forEach( topicName => {\n topicSubscription.subscriptionHistory.delete(topicName);\n topicSubscription.pending.delete(topicName);\n topicSubscription.subscribed.add(topicName);\n });\n if (topicSubscription.subscriptionHistory.size === 0) {\n if (isWebSocketOpen(webSocket.secondary)) {\n sendInternalLogToServer(logger.info(\"Successfully subscribed secondary websocket to all topics of primary websocket\"));\n\n closeSpecificWebSocket(webSocket.primary, \"[Primary WebSocket] Closing WebSocket\");\n }\n } else {\n subscribePendingTopics();\n }\n invokeCallbacks(callbacks.subscriptionUpdate, response);\n\n } else {\n clearInterval(topicSubscriptionConfig.reSubscribeIntervalId);\n ++topicSubscriptionConfig.consecutiveFailedSubscribeAttempts;\n if (topicSubscriptionConfig.consecutiveFailedSubscribeAttempts === MAX_CONSECUTIVE_FAILED_SUB_ATTEMPTS) {\n invokeCallbacks(callbacks.subscriptionFailure, response);\n topicSubscriptionConfig.consecutiveFailedSubscribeAttempts = 0;\n return;\n }\n topicSubscriptionConfig.reSubscribeIntervalId = setInterval(function () {\n subscribePendingTopics();\n }, TOPIC_SUBSCRIPTION_RETRY_INTERVAL_MS);\n }\n break;\n }\n case ROUTE_KEY.HEARTBEAT: {\n sendInternalLogToServer(logger.debug(\"Heartbeat response received\"));\n\n heartbeatConfig.pendingResponse = false;\n break;\n }\n default: {\n if (response.topic) {\n sendInternalLogToServer(logger.debug(\"Message received for topic \" + response.topic));\n\n if (isWebSocketOpen(webSocket.primary) && isWebSocketOpen(webSocket.secondary)\n && topicSubscription.subscriptionHistory.size === 0 && this === webSocket.primary) {\n /**\n * This block is to handle scenario when both primary and secondary socket have subscribed to\n * a common topic but we are facing difficulty in closing the primary socket, then in this\n * situation messages will be received by both primary and secondary web socket\n */\n sendInternalLogToServer(logger.warn(\"Ignoring Message for Topic \" + response.topic + \", to avoid duplicates\"));\n\n return;\n }\n\n if (callbacks.allMessage.size === 0 && callbacks.topic.size === 0) {\n sendInternalLogToServer(logger.warn('No registered callback listener for Topic', response.topic));\n\n return;\n }\n invokeCallbacks(callbacks.allMessage, response);\n if (callbacks.topic.has(response.topic)) {\n invokeCallbacks(callbacks.topic.get(response.topic), response);\n }\n\n } else if (response.message) {\n sendInternalLogToServer(logger.warn(\"WebSocketManager Message Error\", response));\n } else {\n sendInternalLogToServer(logger.warn(\"Invalid incoming message\", response));\n }\n }\n }\n };\n\n const subscribePendingTopics = function() {\n if (topicSubscriptionConfig.consecutiveNoResponseRequest > MAX_CONSECUTIVE_SUB_REQUEST_WITH_NO_RESPONSE) {\n sendInternalLogToServer(logger.warn(\"Ignoring subscribePendingTopics since we have exhausted max subscription retries with no response\"));\n\n invokeCallbacks(callbacks.subscriptionFailure, Utils.getSubscriptionResponse(ROUTE_KEY.SUBSCRIBE, false, Array.from(topicSubscription.pending)));\n return;\n }\n if (!isDefaultWebSocketOpen()) {\n sendInternalLogToServer(logger.warn(\"Ignoring subscribePendingTopics call since Default WebSocket is not open\"));\n\n return;\n }\n\n clearInterval(topicSubscriptionConfig.responseCheckIntervalId);\n\n getDefaultWebSocket().send(createWebSocketPayload(ROUTE_KEY.SUBSCRIBE, {\n \"topics\": Array.from(topicSubscription.pending)\n }));\n topicSubscriptionConfig.requestCompleted = false;\n\n // This callback ensure that some response was received for subscription request\n topicSubscriptionConfig.responseCheckIntervalId = setInterval(function () {\n if (!topicSubscriptionConfig.requestCompleted) {\n ++topicSubscriptionConfig.consecutiveNoResponseRequest;\n subscribePendingTopics();\n }\n }, MAX_WAIT_TIME_SUB_REQUEST_WITH_NO_RESPONSE_MS);\n };\n\n const closeSpecificWebSocket = function(ws, reason) {\n if (isWebSocketState(ws, WebSocket.CONNECTING) || isWebSocketState(ws, WebSocket.OPEN)) {\n ws.close(1000, reason);\n } else {\n sendInternalLogToServer(logger.warn(\"Ignoring WebSocket Close request, WebSocket State: \" + getWebSocketStates(ws)));\n }\n };\n\n const closeWebSocket = function(reason) {\n closeSpecificWebSocket(webSocket.primary, \"[Primary] WebSocket \" + reason);\n closeSpecificWebSocket(webSocket.secondary, \"[Secondary] WebSocket \" + reason);\n };\n\n const retryWebSocketInitialization = function () {\n metrics.connectWebSocketRetryCount++;\n const waitTime = Utils.addJitter(reconnectConfig.exponentialBackOffTime, WEBSOCKET_REINIT_JITTER);\n if (Date.now() + waitTime <= webSocketConfig.connConfig.urlConnValidTime) {\n sendInternalLogToServer(logger.debug(\"Scheduling WebSocket reinitialization, after delay \" + waitTime + \" ms\"));\n\n reconnectConfig.exponentialTimeoutHandle = setTimeout(() => initWebSocket(), waitTime);\n reconnectConfig.exponentialBackOffTime *= 2;\n } else {\n sendInternalLogToServer(logger.warn(\"WebSocket URL cannot be used to establish connection\"));\n\n getWebSocketConnConfig();\n }\n };\n\n const terminateWebSocketManager = function (response) {\n resetWebSocketState();\n resetSubscriptions();\n sendInternalLogToServer(logger.error(\"WebSocket Initialization failed\"));\n\n reconnectConfig.websocketInitFailed = true;\n closeWebSocket(\"Terminating WebSocket Manager\");\n clearInterval(networkConnectivityChecker);\n invokeCallbacks(callbacks.initFailure, {\n connectWebSocketRetryCount: metrics.connectWebSocketRetryCount,\n connectionAttemptStartTime: metrics.connectionAttemptStartTime,\n reason: response\n });\n resetMetrics();\n };\n\n const createWebSocketPayload = function (key, content) {\n return JSON.stringify({\n \"topic\": key,\n \"content\": content\n });\n };\n\n const sendMessage = function(payload) {\n Utils.assertIsObject(payload, \"payload\");\n if (payload.topic === undefined || invalidSendMessageRouteKeys.has(payload.topic)) {\n sendInternalLogToServer(logger.warn(\"Cannot send message, Invalid topic\", payload));\n\n return;\n }\n try {\n payload = JSON.stringify(payload);\n } catch (error) {\n sendInternalLogToServer(logger.warn(\"Error stringify message\", payload));\n\n return;\n }\n if (isDefaultWebSocketOpen()) {\n getDefaultWebSocket().send(payload);\n } else {\n sendInternalLogToServer(logger.warn(\"Cannot send message, web socket connection is not open\"));\n }\n };\n\n const subscribeTopics = function(topics) {\n Utils.assertNotNull(topics, 'topics');\n Utils.assertIsList(topics);\n\n topics.forEach(topic => {\n if (!topicSubscription.subscribed.has(topic)) {\n topicSubscription.pending.add(topic);\n }\n });\n // This ensure all participant-request to subscribe to topic chat are served at least once\n topicSubscriptionConfig.consecutiveNoResponseRequest = 0;\n subscribePendingTopics();\n };\n\n const validWebSocketConnConfig = function (connConfig) {\n if (Utils.isObject(connConfig) && Utils.isObject(connConfig.webSocketTransport)\n && Utils.isNonEmptyString(connConfig.webSocketTransport.url)\n && Utils.validWSUrl(connConfig.webSocketTransport.url) &&\n connConfig.webSocketTransport.transportLifeTimeInSeconds * 1000 >= MIN_WEBSOCKET_LIFETIME_MS) {\n return true;\n }\n sendInternalLogToServer(logger.error(\"Invalid WebSocket Connection Configuration\", connConfig));\n\n return false;\n };\n\n const getWebSocketConnConfig = function () {\n if (!Utils.isNetworkOnline()) {\n sendInternalLogToServer(logger.info(\"Network offline, ignoring this getWebSocketConnConfig request\"));\n\n return;\n }\n if (reconnectConfig.websocketInitFailed) {\n sendInternalLogToServer(logger.debug(\"WebSocket Init had failed, ignoring this getWebSocketConnConfig request\"));\n\n return;\n }\n if (!webSocketConfig.promiseCompleted) {\n sendInternalLogToServer(logger.debug(\"There is an ongoing getWebSocketConnConfig request, this request will be ignored\"));\n\n return;\n }\n resetWebSocketState();\n sendInternalLogToServer(logger.info(\"Fetching new WebSocket connection configuration\"));\n\n metrics.connectionAttemptStartTime = metrics.connectionAttemptStartTime || Date.now();\n webSocketConfig.promiseCompleted = false;\n webSocketConfig.promiseHandle = callbacks.getWebSocketTransport();\n return webSocketConfig.promiseHandle\n .then(function(response) {\n webSocketConfig.promiseCompleted = true;\n sendInternalLogToServer(logger.debug(\"Successfully fetched webSocket connection configuration\", response));\n\n if (!validWebSocketConnConfig(response)) {\n terminateWebSocketManager(\"Invalid WebSocket connection configuration: \" + response);\n return { webSocketConnectionFailed: true };\n }\n webSocketConfig.connConfig = response;\n // Ideally this URL validity time should be provided by server\n webSocketConfig.connConfig.urlConnValidTime = Date.now() + WEBSOCKET_URL_VALID_TIME_MS;\n // Mark as a successful connection, and reset number of reconnect attempts\n reconnectionClient.connected();\n return initWebSocket();\n },\n function(reason) {\n webSocketConfig.promiseCompleted = true;\n sendInternalLogToServer(logger.error(\"Failed to fetch webSocket connection configuration\", reason));\n\n // If our connection fails because of network failure, we want to retry\n if (Utils.isNetworkFailure(reason)) {\n sendInternalLogToServer(logger.info(\"Retrying fetching new WebSocket connection configuration\"));\n reconnectionClient.retry();\n } else {\n // If we're not going to retry, we should terminate WSM\n terminateWebSocketManager(\"Failed to fetch webSocket connection configuration: \" + JSON.stringify(reason));\n }\n return { webSocketConnectionFailed: true };\n });\n };\n\n const initWebSocket = function() {\n if (reconnectConfig.websocketInitFailed) {\n sendInternalLogToServer(logger.info(\"web-socket initializing had failed, aborting re-init\"));\n\n return { webSocketConnectionFailed: true };\n }\n if (!Utils.isNetworkOnline()) {\n sendInternalLogToServer(logger.warn(\"System is offline aborting web-socket init\"));\n\n return { webSocketConnectionFailed: true };\n }\n sendInternalLogToServer(logger.info(\"Initializing Websocket Manager\"));\n\n printWebSocketState(\"initWebSocket\");\n try {\n if (validWebSocketConnConfig(webSocketConfig.connConfig)) {\n let ws = null;\n if (isWebSocketOpen(webSocket.primary)) {\n sendInternalLogToServer(logger.debug(\"Primary Socket connection is already open\"));\n \n if (!isWebSocketState(webSocket.secondary, WebSocket.CONNECTING)) {\n sendInternalLogToServer(logger.debug(\"Establishing a secondary web-socket connection\"));\n\n webSocket.secondary = getNewWebSocket();\n }\n ws = webSocket.secondary;\n } else {\n if (!isWebSocketState(webSocket.primary, WebSocket.CONNECTING)) {\n sendInternalLogToServer(logger.debug(\"Establishing a primary web-socket connection\"));\n\n webSocket.primary = getNewWebSocket();\n }\n ws = webSocket.primary;\n }\n\n // WebSocket creation is async task hence we Wait for 1sec before any potential retry\n reconnectConfig.webSocketInitCheckerTimeoutId = setTimeout(function() {\n if (!isWebSocketOpen(ws)) {\n retryWebSocketInitialization();\n }\n }, 1000);\n return { webSocketConnectionFailed: false };\n }\n } catch (error) {\n sendInternalLogToServer(logger.error(\"Error Initializing web-socket-manager\", error));\n \n terminateWebSocketManager(\"Failed to initialize new WebSocket: \" + error.message);\n return { webSocketConnectionFailed: true };\n }\n };\n\n const getNewWebSocket = function() {\n let ws = new WebSocket(webSocketConfig.connConfig.webSocketTransport.url);\n ws.addEventListener(\"open\", webSocketOnOpen);\n ws.addEventListener(\"message\", webSocketOnMessage);\n ws.addEventListener(\"error\", webSocketOnError);\n ws.addEventListener(\"close\", event => webSocketOnClose(event, ws));\n return ws;\n };\n\n const onConnectionOpen = function(cb) {\n Utils.assertTrue(Utils.isFunction(cb), 'cb must be a function');\n callbacks.connectionOpen.add(cb);\n return () => callbacks.connectionOpen.delete(cb);\n };\n\n const onConnectionClose = function(cb) {\n Utils.assertTrue(Utils.isFunction(cb), 'cb must be a function');\n callbacks.connectionClose.add(cb);\n return () => callbacks.connectionClose.delete(cb);\n };\n\n const onConnectionGain = function(cb) {\n Utils.assertTrue(Utils.isFunction(cb), 'cb must be a function');\n callbacks.connectionGain.add(cb);\n if (isDefaultWebSocketOpen()) {\n cb();\n }\n return () => callbacks.connectionGain.delete(cb);\n };\n\n const onConnectionLost = function(cb) {\n Utils.assertTrue(Utils.isFunction(cb), 'cb must be a function');\n callbacks.connectionLost.add(cb);\n if (reconnectConfig.connState === CONN_STATE.DISCONNECTED) {\n cb();\n }\n return () => callbacks.connectionLost.delete(cb);\n };\n\n const onInitFailure = function(cb) {\n Utils.assertTrue(Utils.isFunction(cb), 'cb must be a function');\n callbacks.initFailure.add(cb);\n if (reconnectConfig.websocketInitFailed) {\n cb();\n }\n return () => callbacks.initFailure.delete(cb);\n };\n\n const init = function(transportHandle) {\n Utils.assertTrue(Utils.isFunction(transportHandle), 'transportHandle must be a function');\n if (callbacks.getWebSocketTransport !== null) {\n sendInternalLogToServer(logger.warn(\"Web Socket Manager was already initialized\"));\n\n return;\n }\n callbacks.getWebSocketTransport = transportHandle;\n\n return getWebSocketConnConfig();\n };\n\n const onSubscriptionUpdate = function(cb) {\n Utils.assertTrue(Utils.isFunction(cb), 'cb must be a function');\n callbacks.subscriptionUpdate.add(cb);\n return () => callbacks.subscriptionUpdate.delete(cb);\n };\n\n const onSubscriptionFailure = function(cb) {\n Utils.assertTrue(Utils.isFunction(cb), 'cb must be a function');\n callbacks.subscriptionFailure.add(cb);\n return () => callbacks.subscriptionFailure.delete(cb);\n };\n\n const onMessage = function(topicName, cb) {\n Utils.assertNotNull(topicName, 'topicName');\n Utils.assertTrue(Utils.isFunction(cb), 'cb must be a function');\n if (callbacks.topic.has(topicName)) {\n callbacks.topic.get(topicName).add(cb);\n } else {\n callbacks.topic.set(topicName, new Set([cb]));\n }\n return () => callbacks.topic.get(topicName).delete(cb);\n };\n\n const onAllMessage = function (cb) {\n Utils.assertTrue(Utils.isFunction(cb), 'cb must be a function');\n callbacks.allMessage.add(cb);\n return () => callbacks.allMessage.delete(cb);\n };\n\n const sendInternalLogToServer = function (logEntry) {\n if (logEntry && typeof logEntry.sendInternalLogToServer === \"function\")\n logEntry.sendInternalLogToServer();\n\n return logEntry;\n };\n\n this.init = init;\n this.onInitFailure = onInitFailure;\n this.onConnectionOpen = onConnectionOpen;\n this.onConnectionClose = onConnectionClose;\n this.onConnectionGain = onConnectionGain;\n this.onConnectionLost = onConnectionLost;\n this.onSubscriptionUpdate = onSubscriptionUpdate;\n this.onSubscriptionFailure = onSubscriptionFailure;\n this.onMessage = onMessage;\n this.onAllMessage = onAllMessage;\n this.subscribeTopics = subscribeTopics;\n this.sendMessage = sendMessage;\n\n this.closeWebSocket = function() {\n resetWebSocketState();\n resetSubscriptions();\n reconnectConfig.reconnectWebSocket = false;\n clearInterval(networkConnectivityChecker);\n closeWebSocket(\"User request to close WebSocket\");\n };\n\n this.terminateWebSocketManager = terminateWebSocketManager;\n};\n\nconst WebSocketManagerConstructor = () => {\n return new WebSocketManager();\n};\n\nconst setGlobalConfig = config => {\n const loggerConfig = config.loggerConfig;\n LogManager.updateLoggerConfig(loggerConfig);\n};\n\nconst WebSocketManagerObject = {\n create: WebSocketManagerConstructor,\n setGlobalConfig: setGlobalConfig,\n LogLevel: LogLevel,\n Logger: Logger\n};\n\nexport { WebSocketManagerObject };\n","/* global window, exports, define */\n\n!function() {\n 'use strict'\n\n var re = {\n not_string: /[^s]/,\n not_bool: /[^t]/,\n not_type: /[^T]/,\n not_primitive: /[^v]/,\n number: /[diefg]/,\n numeric_arg: /[bcdiefguxX]/,\n json: /[j]/,\n not_json: /[^j]/,\n text: /^[^\\x25]+/,\n modulo: /^\\x25{2}/,\n placeholder: /^\\x25(?:([1-9]\\d*)\\$|\\(([^)]+)\\))?(\\+)?(0|'[^$])?(-)?(\\d+)?(?:\\.(\\d+))?([b-gijostTuvxX])/,\n key: /^([a-z_][a-z_\\d]*)/i,\n key_access: /^\\.([a-z_][a-z_\\d]*)/i,\n index_access: /^\\[(\\d+)\\]/,\n sign: /^[+-]/\n }\n\n function sprintf(key) {\n // `arguments` is not an array, but should be fine for this call\n return sprintf_format(sprintf_parse(key), arguments)\n }\n\n function vsprintf(fmt, argv) {\n return sprintf.apply(null, [fmt].concat(argv || []))\n }\n\n function sprintf_format(parse_tree, argv) {\n var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign\n for (i = 0; i < tree_length; i++) {\n if (typeof parse_tree[i] === 'string') {\n output += parse_tree[i]\n }\n else if (typeof parse_tree[i] === 'object') {\n ph = parse_tree[i] // convenience purposes only\n if (ph.keys) { // keyword argument\n arg = argv[cursor]\n for (k = 0; k < ph.keys.length; k++) {\n if (arg == undefined) {\n throw new Error(sprintf('[sprintf] Cannot access property \"%s\" of undefined value \"%s\"', ph.keys[k], ph.keys[k-1]))\n }\n arg = arg[ph.keys[k]]\n }\n }\n else if (ph.param_no) { // positional argument (explicit)\n arg = argv[ph.param_no]\n }\n else { // positional argument (implicit)\n arg = argv[cursor++]\n }\n\n if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {\n arg = arg()\n }\n\n if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) {\n throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))\n }\n\n if (re.number.test(ph.type)) {\n is_positive = arg >= 0\n }\n\n switch (ph.type) {\n case 'b':\n arg = parseInt(arg, 10).toString(2)\n break\n case 'c':\n arg = String.fromCharCode(parseInt(arg, 10))\n break\n case 'd':\n case 'i':\n arg = parseInt(arg, 10)\n break\n case 'j':\n arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)\n break\n case 'e':\n arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()\n break\n case 'f':\n arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)\n break\n case 'g':\n arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)\n break\n case 'o':\n arg = (parseInt(arg, 10) >>> 0).toString(8)\n break\n case 's':\n arg = String(arg)\n arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n break\n case 't':\n arg = String(!!arg)\n arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n break\n case 'T':\n arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()\n arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n break\n case 'u':\n arg = parseInt(arg, 10) >>> 0\n break\n case 'v':\n arg = arg.valueOf()\n arg = (ph.precision ? arg.substring(0, ph.precision) : arg)\n break\n case 'x':\n arg = (parseInt(arg, 10) >>> 0).toString(16)\n break\n case 'X':\n arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()\n break\n }\n if (re.json.test(ph.type)) {\n output += arg\n }\n else {\n if (re.number.test(ph.type) && (!is_positive || ph.sign)) {\n sign = is_positive ? '+' : '-'\n arg = arg.toString().replace(re.sign, '')\n }\n else {\n sign = ''\n }\n pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '\n pad_length = ph.width - (sign + arg).length\n pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''\n output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)\n }\n }\n }\n return output\n }\n\n var sprintf_cache = Object.create(null)\n\n function sprintf_parse(fmt) {\n if (sprintf_cache[fmt]) {\n return sprintf_cache[fmt]\n }\n\n var _fmt = fmt, match, parse_tree = [], arg_names = 0\n while (_fmt) {\n if ((match = re.text.exec(_fmt)) !== null) {\n parse_tree.push(match[0])\n }\n else if ((match = re.modulo.exec(_fmt)) !== null) {\n parse_tree.push('%')\n }\n else if ((match = re.placeholder.exec(_fmt)) !== null) {\n if (match[2]) {\n arg_names |= 1\n var field_list = [], replacement_field = match[2], field_match = []\n if ((field_match = re.key.exec(replacement_field)) !== null) {\n field_list.push(field_match[1])\n while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {\n if ((field_match = re.key_access.exec(replacement_field)) !== null) {\n field_list.push(field_match[1])\n }\n else if ((field_match = re.index_access.exec(replacement_field)) !== null) {\n field_list.push(field_match[1])\n }\n else {\n throw new SyntaxError('[sprintf] failed to parse named argument key')\n }\n }\n }\n else {\n throw new SyntaxError('[sprintf] failed to parse named argument key')\n }\n match[2] = field_list\n }\n else {\n arg_names |= 2\n }\n if (arg_names === 3) {\n throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')\n }\n\n parse_tree.push(\n {\n placeholder: match[0],\n param_no: match[1],\n keys: match[2],\n sign: match[3],\n pad_char: match[4],\n align: match[5],\n width: match[6],\n precision: match[7],\n type: match[8]\n }\n )\n }\n else {\n throw new SyntaxError('[sprintf] unexpected placeholder')\n }\n _fmt = _fmt.substring(match[0].length)\n }\n return sprintf_cache[fmt] = parse_tree\n }\n\n /**\n * export to either browser or node.js\n */\n /* eslint-disable quote-props */\n if (typeof exports !== 'undefined') {\n exports['sprintf'] = sprintf\n exports['vsprintf'] = vsprintf\n }\n if (typeof window !== 'undefined') {\n window['sprintf'] = sprintf\n window['vsprintf'] = vsprintf\n\n if (typeof define === 'function' && define['amd']) {\n define(function() {\n return {\n 'sprintf': sprintf,\n 'vsprintf': vsprintf\n }\n })\n }\n }\n /* eslint-enable quote-props */\n}(); // eslint-disable-line\n","/*eslint no-unused-vars: \"off\"*/\nimport { WebSocketManagerObject } from \"./webSocketManager\";\n\nglobal.connect = global.connect || {};\nconnect.WebSocketManager = WebSocketManagerObject;\n\nexport const WebSocketManager = WebSocketManagerObject;\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"],"sourceRoot":""}