{"version":3,"sources":["../node_modules/browser-pack/_prelude.js","../lib/Mapper.js","../lib/clients/index.js","../lib/clients/jsonrpcclient.js","../lib/clients/transports/index.js","../lib/clients/transports/webSocketWithReconnection.js","../lib/index.js","../lib/packers/JsonRPC.js","../lib/packers/XmlRPC.js","../lib/packers/index.js","../node_modules/grunt-browserify/node_modules/events/events.js","../node_modules/inherits/inherits_browser.js"],"names":["Mapper","sources","this","forEach","callback","key","source","key2","get","id","ids","undefined","remove","i","set","value","prototype","pop","module","exports","JsonRpcClient","require","configuration","updateNotReconnectIfLessThan","Logger","debug","pingNextNum","notReconnectIfNumLessThan","sendPing","enabledPings","params","interval","heartbeat","PING_INTERVAL","self","send","pingNum","error","result","message","ws","reconnectWs","usePing","pingPongStarted","pingInterval","setInterval","wsConfig","status","DISCONNECTED","onreconnecting","onreconnected","onconnected","onerror","rpc","pull","request","reply","RECONNECTING","CONNECTED","WebSocketWithReconnection","uri","rpcBuilderOptions","request_timeout","requestTimeout","ping_request_timeout","heartbeatRequestTimeout","RpcBuilder","packers","JsonRPC","JSON","stringify","func","method","err","requestTime","Date","now","encode","data","e","close","clearInterval","sendCloseMessage","forceClose","millis","reconnect","console","config","logConnected","wsUri","reconnectToSameUri","maxRetries","numRetries","reconnecting","warn","forcingDisconnection","reconnectToNewUri","newWsUriOnReconnection","newWsUri","setTimeout","RETRY_TIME_MS","reconnectWsUri","newWs","useSockJS","SockJS","WebSocket","onopen","registerMessageHandler","onclose","reconnectionOnClose","onErrorOrClose","ondisconnect","closing","readyState","CLOSED","MAX_RETRIES","goodWsUri","addEventListener","type","BrowserWebSocket","global","MozWebSocket","window","CONNECTING","OPEN","CLOSING","unifyResponseMethods","responseMethods","response","unifyTransport","transport","Function","postMessage","write","onmessage","pause","SyntaxError","RpcNotification","defineProperty_IE8","Object","defineProperty","enumerable","packer","options","onRequest","transportMessage","event","decode","toString","storeResponse","dest","timeout","responses","response_timeout","storeProcessedResponse","ack","from","processedResponses","duplicates_timeout","RpcRequest","call","getTransport","setTransport","bind","duplicated","Boolean","responseMethod","pack","clearTimeout","peerID","cancel","message2Key","requests","unpack","EventEmitter","on","max_retries","removeEventListener","removeListener","addListener","BASE_TIMEOUT","requestID","inherits","dispatchCallback","sendRequest","rt","Math","pow","retried","encode_transport","retry","Error","processRequest","idAck","emit","processResponse","duplicatedResponse","TypeError","notification","processed","oThis","aArgs","Array","slice","arguments","fToBind","fNOP","fBound","apply","concat","clients","transports","jsonrpc","String","parse","version","result_defined","error_defined","XmlRPC","_events","hasOwnProperty","objectCreate","_eventsCount","_maxListeners","$getMaxListeners","that","defaultMaxListeners","emitNone","handler","isFn","len","length","listeners","arrayClone","emitOne","arg1","emitTwo","arg2","emitThree","arg3","emitMany","args","_addListener","target","listener","prepend","m","events","existing","newListener","unshift","push","warned","w","name","emitter","count","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","_listeners","unwrap","evlistener","unwrapListeners","listenerCount","spliceOne","list","index","k","n","arr","copy","ret","objectCreatePolyfill","proto","F","objectKeysPolyfill","obj","keys","functionBindPolyfill","context","fn","create","objectKeys","hasDefineProperty","o","x","arg","setMaxListeners","isNaN","getMaxListeners","er","doError","prependListener","once","prependOnceListener","position","originalListener","shift","removeAllListeners","rawListeners","eventNames","Reflect","ownKeys","ctor","superCtor","super_","constructor","writable","configurable","TempCtor"],"mappings":"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","file":"bundle.js","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","function Mapper() {\n  var sources = {};\n\n  this.forEach = function (callback) {\n    for (var key in sources) {\n      var source = sources[key];\n\n      for (var key2 in source)\n        callback(source[key2]);\n    };\n  };\n\n  this.get = function (id, source) {\n    var ids = sources[source];\n    if (ids == undefined)\n      return undefined;\n\n    return ids[id];\n  };\n\n  this.remove = function (id, source) {\n    var ids = sources[source];\n    if (ids == undefined)\n      return;\n\n    delete ids[id];\n\n    // Check it's empty\n    for (var i in ids) {\n      return false\n    }\n\n    delete sources[source];\n  };\n\n  this.set = function (value, id, source) {\n    if (value == undefined)\n      return this.remove(id, source);\n\n    var ids = sources[source];\n    if (ids == undefined)\n      sources[source] = ids = {};\n\n    ids[id] = value;\n  };\n};\n\nMapper.prototype.pop = function (id, source) {\n  var value = this.get(id, source);\n  if (value == undefined)\n    return undefined;\n\n  this.remove(id, source);\n\n  return value;\n};\n\nmodule.exports = Mapper;\n","/*\n * (C) Copyright 2014 Kurento (http://kurento.org/)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\nvar JsonRpcClient = require('./jsonrpcclient');\n\nexports.JsonRpcClient = JsonRpcClient;\n","/*\n * (C) Copyright 2014 Kurento (http://kurento.org/)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\nvar RpcBuilder = require('../..');\nvar WebSocketWithReconnection = require(\n  './transports/webSocketWithReconnection');\n\nDate.now = Date.now || function () {\n  return +new Date;\n};\n\nvar PING_INTERVAL = 5000;\n\nvar RECONNECTING = 'RECONNECTING';\nvar CONNECTED = 'CONNECTED';\nvar DISCONNECTED = 'DISCONNECTED';\n\nvar Logger = console;\n\n/**\n *\n * heartbeat: interval in ms for each heartbeat message,\n * sendCloseMessage : true / false, before closing the connection, it sends a closeSession message\n * <pre>\n * ws : {\n * \turi : URI to conntect to,\n *  useSockJS : true (use SockJS) / false (use WebSocket) by default,\n * \tonconnected : callback method to invoke when connection is successful,\n * \tondisconnect : callback method to invoke when the connection is lost,\n * \tonreconnecting : callback method to invoke when the client is reconnecting,\n * \tonreconnected : callback method to invoke when the client succesfully reconnects,\n * \tonerror : callback method to invoke when there is an error\n * },\n * rpc : {\n * \trequestTimeout : timeout for a request,\n * \tsessionStatusChanged: callback method for changes in session status,\n * \tmediaRenegotiation: mediaRenegotiation\n * }\n * </pre>\n */\nfunction JsonRpcClient(configuration) {\n\n  var self = this;\n\n  var wsConfig = configuration.ws;\n\n  var notReconnectIfNumLessThan = -1;\n\n  var pingNextNum = 0;\n  var enabledPings = true;\n  var pingPongStarted = false;\n  var pingInterval;\n\n  var status = DISCONNECTED;\n\n  var onreconnecting = wsConfig.onreconnecting;\n  var onreconnected = wsConfig.onreconnected;\n  var onconnected = wsConfig.onconnected;\n  var onerror = wsConfig.onerror;\n\n  configuration.rpc.pull = function (params, request) {\n    request.reply(null, \"push\");\n  }\n\n  wsConfig.onreconnecting = function () {\n    Logger.debug(\"--------- ONRECONNECTING -----------\");\n    if (status === RECONNECTING) {\n      Logger.error(\n        \"Websocket already in RECONNECTING state when receiving a new ONRECONNECTING message. Ignoring it\"\n      );\n      return;\n    }\n\n    status = RECONNECTING;\n    if (onreconnecting) {\n      onreconnecting();\n    }\n  }\n\n  wsConfig.onreconnected = function () {\n    Logger.debug(\"--------- ONRECONNECTED -----------\");\n    if (status === CONNECTED) {\n      Logger.error(\n        \"Websocket already in CONNECTED state when receiving a new ONRECONNECTED message. Ignoring it\"\n      );\n      return;\n    }\n    status = CONNECTED;\n\n    enabledPings = true;\n    updateNotReconnectIfLessThan();\n    usePing();\n\n    if (onreconnected) {\n      onreconnected();\n    }\n  }\n\n  wsConfig.onconnected = function () {\n    Logger.debug(\"--------- ONCONNECTED -----------\");\n    if (status === CONNECTED) {\n      Logger.error(\n        \"Websocket already in CONNECTED state when receiving a new ONCONNECTED message. Ignoring it\"\n      );\n      return;\n    }\n    status = CONNECTED;\n\n    enabledPings = true;\n    usePing();\n\n    if (onconnected) {\n      onconnected();\n    }\n  }\n\n  wsConfig.onerror = function (error) {\n    Logger.debug(\"--------- ONERROR -----------\");\n\n    status = DISCONNECTED;\n\n    if (onerror) {\n      onerror(error);\n    }\n  }\n\n  var ws = new WebSocketWithReconnection(wsConfig);\n\n  Logger.debug('Connecting websocket to URI: ' + wsConfig.uri);\n\n  var rpcBuilderOptions = {\n    request_timeout: configuration.rpc.requestTimeout,\n    ping_request_timeout: configuration.rpc.heartbeatRequestTimeout\n  };\n\n  var rpc = new RpcBuilder(RpcBuilder.packers.JsonRPC, rpcBuilderOptions, ws,\n    function (request) {\n\n      Logger.debug('Received request: ' + JSON.stringify(request));\n\n      try {\n        var func = configuration.rpc[request.method];\n\n        if (func === undefined) {\n          Logger.error(\"Method \" + request.method +\n            \" not registered in client\");\n        } else {\n          func(request.params, request);\n        }\n      } catch (err) {\n        Logger.error('Exception processing request: ' + JSON.stringify(\n          request));\n        Logger.error(err);\n      }\n    });\n\n  this.send = function (method, params, callback) {\n    if (method !== 'ping') {\n      Logger.debug('Request: method:' + method + \" params:\" + JSON.stringify(\n        params));\n    }\n\n    var requestTime = Date.now();\n\n    rpc.encode(method, params, function (error, result) {\n      if (error) {\n        try {\n          Logger.error(\"ERROR:\" + error.message + \" in Request: method:\" +\n            method + \" params:\" + JSON.stringify(params) + \" request:\" +\n            error.request);\n          if (error.data) {\n            Logger.error(\"ERROR DATA:\" + JSON.stringify(error.data));\n          }\n        } catch (e) {}\n        error.requestTime = requestTime;\n      }\n      if (callback) {\n        if (result != undefined && result.value !== 'pong') {\n          Logger.debug('Response: ' + JSON.stringify(result));\n        }\n        callback(error, result);\n      }\n    });\n  }\n\n  function updateNotReconnectIfLessThan() {\n    Logger.debug(\"notReconnectIfNumLessThan = \" + pingNextNum + ' (old=' +\n      notReconnectIfNumLessThan + ')');\n    notReconnectIfNumLessThan = pingNextNum;\n  }\n\n  function sendPing() {\n    if (enabledPings) {\n      var params = null;\n      if (pingNextNum == 0 || pingNextNum == notReconnectIfNumLessThan) {\n        params = {\n          interval: configuration.heartbeat || PING_INTERVAL\n        };\n      }\n      pingNextNum++;\n\n      self.send('ping', params, (function (pingNum) {\n        return function (error, result) {\n          if (error) {\n            Logger.debug(\"Error in ping request #\" + pingNum + \" (\" +\n              error.message + \")\");\n            if (pingNum > notReconnectIfNumLessThan) {\n              enabledPings = false;\n              updateNotReconnectIfLessThan();\n              Logger.debug(\"Server did not respond to ping message #\" +\n                pingNum + \". Reconnecting... \");\n              ws.reconnectWs();\n            }\n          }\n        }\n      })(pingNextNum));\n    } else {\n      Logger.debug(\"Trying to send ping, but ping is not enabled\");\n    }\n  }\n\n  /*\n   * If configuration.hearbeat has any value, the ping-pong will work with the interval\n   * of configuration.hearbeat\n   */\n  function usePing() {\n    if (!pingPongStarted) {\n      Logger.debug(\"Starting ping (if configured)\")\n      pingPongStarted = true;\n\n      if (configuration.heartbeat != undefined) {\n        pingInterval = setInterval(sendPing, configuration.heartbeat);\n        sendPing();\n      }\n    }\n  }\n\n  this.close = function () {\n    Logger.debug(\"Closing jsonRpcClient explicitly by client\");\n\n    if (pingInterval != undefined) {\n      Logger.debug(\"Clearing ping interval\");\n      clearInterval(pingInterval);\n    }\n    pingPongStarted = false;\n    enabledPings = false;\n\n    if (configuration.sendCloseMessage) {\n      Logger.debug(\"Sending close message\")\n      this.send('closeSession', null, function (error, result) {\n        if (error) {\n          Logger.error(\"Error sending close message: \" + JSON.stringify(\n            error));\n        }\n        ws.close();\n      });\n    } else {\n      ws.close();\n    }\n  }\n\n  // This method is only for testing\n  this.forceClose = function (millis) {\n    ws.forceClose(millis);\n  }\n\n  this.reconnect = function () {\n    ws.reconnectWs();\n  }\n}\n\nmodule.exports = JsonRpcClient;\n","/*\n * (C) Copyright 2014 Kurento (http://kurento.org/)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\nvar WebSocketWithReconnection = require('./webSocketWithReconnection');\n\nexports.WebSocketWithReconnection = WebSocketWithReconnection;\n","/*\n * (C) Copyright 2013-2015 Kurento (http://kurento.org/)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\"use strict\";\n\nvar BrowserWebSocket = global.WebSocket || global.MozWebSocket;\n\nvar Logger = console;\n\n/**\n * Get either the `WebSocket` or `MozWebSocket` globals\n * in the browser or try to resolve WebSocket-compatible\n * interface exposed by `ws` for Node-like environment.\n */\n\nvar WebSocket = BrowserWebSocket;\nif (!WebSocket && typeof window === 'undefined') {\n  try {\n    WebSocket = require('ws');\n  } catch (e) {}\n}\n\n//var SockJS = require('sockjs-client');\n\nvar MAX_RETRIES = 2000; // Forever...\nvar RETRY_TIME_MS = 3000; // FIXME: Implement exponential wait times...\n\nvar CONNECTING = 0;\nvar OPEN = 1;\nvar CLOSING = 2;\nvar CLOSED = 3;\n\n/*\nconfig = {\n\t\turi : wsUri,\n\t\tuseSockJS : true (use SockJS) / false (use WebSocket) by default,\n\t\tonconnected : callback method to invoke when connection is successful,\n\t\tondisconnect : callback method to invoke when the connection is lost,\n\t\tonreconnecting : callback method to invoke when the client is reconnecting,\n\t\tonreconnected : callback method to invoke when the client succesfully reconnects,\n\t};\n*/\nfunction WebSocketWithReconnection(config) {\n\n  var closing = false;\n  var registerMessageHandler;\n  var wsUri = config.uri;\n  var useSockJS = config.useSockJS;\n  var reconnecting = false;\n\n  var forcingDisconnection = false;\n\n  var ws;\n\n  if (useSockJS) {\n    ws = new SockJS(wsUri);\n  } else {\n    ws = new WebSocket(wsUri);\n  }\n\n  ws.onopen = function () {\n    logConnected(ws, wsUri);\n    if (config.onconnected) {\n      config.onconnected();\n    }\n  };\n\n  ws.onerror = function (error) {\n    Logger.error(\"Could not connect to \" + wsUri +\n      \" (invoking onerror if defined)\", error);\n    if (config.onerror) {\n      config.onerror(error);\n    }\n  };\n\n  function logConnected(ws, wsUri) {\n    try {\n      Logger.debug(\"WebSocket connected to \" + wsUri);\n    } catch (e) {\n      Logger.error(e);\n    }\n  }\n\n  var reconnectionOnClose = function () {\n    if (ws.readyState === CLOSED) {\n      if (closing) {\n        Logger.debug(\"Connection closed by user\");\n      } else {\n        Logger.debug(\"Connection closed unexpectecly. Reconnecting...\");\n        reconnectToSameUri(MAX_RETRIES, 1);\n      }\n    } else {\n      Logger.debug(\"Close callback from previous websocket. Ignoring it\");\n    }\n  };\n\n  ws.onclose = reconnectionOnClose;\n\n  function reconnectToSameUri(maxRetries, numRetries) {\n    Logger.debug(\"reconnectToSameUri (attempt #\" + numRetries + \", max=\" +\n      maxRetries + \")\");\n\n    if (numRetries === 1) {\n      if (reconnecting) {\n        Logger.warn(\n          \"Trying to reconnectToNewUri when reconnecting... Ignoring this reconnection.\"\n        )\n        return;\n      } else {\n        reconnecting = true;\n      }\n\n      if (config.onreconnecting) {\n        config.onreconnecting();\n      }\n    }\n\n    if (forcingDisconnection) {\n      reconnectToNewUri(maxRetries, numRetries, wsUri);\n\n    } else {\n      if (config.newWsUriOnReconnection) {\n        config.newWsUriOnReconnection(function (error, newWsUri) {\n\n          if (error) {\n            Logger.debug(error);\n            setTimeout(function () {\n              reconnectToSameUri(maxRetries, numRetries + 1);\n            }, RETRY_TIME_MS);\n          } else {\n            reconnectToNewUri(maxRetries, numRetries, newWsUri);\n          }\n        })\n      } else {\n        reconnectToNewUri(maxRetries, numRetries, wsUri);\n      }\n    }\n  }\n\n  // TODO Test retries. How to force not connection?\n  function reconnectToNewUri(maxRetries, numRetries, reconnectWsUri) {\n    Logger.debug(\"Reconnection attempt #\" + numRetries);\n\n    ws.close();\n\n    wsUri = reconnectWsUri || wsUri;\n\n    var newWs;\n    if (useSockJS) {\n      newWs = new SockJS(wsUri);\n    } else {\n      newWs = new WebSocket(wsUri);\n    }\n\n    newWs.onopen = function () {\n      Logger.debug(\"Reconnected after \" + numRetries + \" attempts...\");\n      logConnected(newWs, wsUri);\n      reconnecting = false;\n      registerMessageHandler();\n      if (config.onreconnected()) {\n        config.onreconnected();\n      }\n\n      newWs.onclose = reconnectionOnClose;\n    };\n\n    var onErrorOrClose = function (error) {\n      Logger.warn(\"Reconnection error: \", error);\n\n      if (numRetries === maxRetries) {\n        if (config.ondisconnect) {\n          config.ondisconnect();\n        }\n      } else {\n        setTimeout(function () {\n          reconnectToSameUri(maxRetries, numRetries + 1);\n        }, RETRY_TIME_MS);\n      }\n    };\n\n    newWs.onerror = onErrorOrClose;\n\n    ws = newWs;\n  }\n\n  this.close = function () {\n    closing = true;\n    ws.close();\n  };\n\n  // This method is only for testing\n  this.forceClose = function (millis) {\n    Logger.debug(\"Testing: Force WebSocket close\");\n\n    if (millis) {\n      Logger.debug(\"Testing: Change wsUri for \" + millis +\n        \" millis to simulate net failure\");\n      var goodWsUri = wsUri;\n      wsUri = \"wss://21.234.12.34.4:443/\";\n\n      forcingDisconnection = true;\n\n      setTimeout(function () {\n        Logger.debug(\"Testing: Recover good wsUri \" + goodWsUri);\n        wsUri = goodWsUri;\n\n        forcingDisconnection = false;\n\n      }, millis);\n    }\n\n    ws.close();\n  };\n\n  this.reconnectWs = function () {\n    Logger.debug(\"reconnectWs\");\n    reconnectToSameUri(MAX_RETRIES, 1, wsUri);\n  };\n\n  this.send = function (message) {\n    ws.send(message);\n  };\n\n  this.addEventListener = function (type, callback) {\n    registerMessageHandler = function () {\n      ws.addEventListener(type, callback);\n    };\n\n    registerMessageHandler();\n  };\n}\n\nmodule.exports = WebSocketWithReconnection;\n","/*\n * (C) Copyright 2014 Kurento (http://kurento.org/)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\nvar defineProperty_IE8 = false\nif (Object.defineProperty) {\n  try {\n    Object.defineProperty({}, \"x\", {});\n  } catch (e) {\n    defineProperty_IE8 = true\n  }\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind\nif (!Function.prototype.bind) {\n  Function.prototype.bind = function (oThis) {\n    if (typeof this !== 'function') {\n      // closest thing possible to the ECMAScript 5\n      // internal IsCallable function\n      throw new TypeError(\n        'Function.prototype.bind - what is trying to be bound is not callable'\n      );\n    }\n\n    var aArgs = Array.prototype.slice.call(arguments, 1),\n      fToBind = this,\n      fNOP = function () {},\n      fBound = function () {\n        return fToBind.apply(this instanceof fNOP && oThis ?\n          this :\n          oThis,\n          aArgs.concat(Array.prototype.slice.call(arguments)));\n      };\n\n    fNOP.prototype = this.prototype;\n    fBound.prototype = new fNOP();\n\n    return fBound;\n  };\n}\n\nvar EventEmitter = require('events').EventEmitter;\n\nvar inherits = require('inherits');\n\nvar packers = require('./packers');\nvar Mapper = require('./Mapper');\n\nvar BASE_TIMEOUT = 5000;\n\nfunction unifyResponseMethods(responseMethods) {\n  if (!responseMethods) return {};\n\n  for (var key in responseMethods) {\n    var value = responseMethods[key];\n\n    if (typeof value == 'string')\n      responseMethods[key] = {\n        response: value\n      }\n  };\n\n  return responseMethods;\n};\n\nfunction unifyTransport(transport) {\n  if (!transport) return;\n\n  // Transport as a function\n  if (transport instanceof Function)\n    return {\n      send: transport\n    };\n\n  // WebSocket & DataChannel\n  if (transport.send instanceof Function)\n    return transport;\n\n  // Message API (Inter-window & WebWorker)\n  if (transport.postMessage instanceof Function) {\n    transport.send = transport.postMessage;\n    return transport;\n  }\n\n  // Stream API\n  if (transport.write instanceof Function) {\n    transport.send = transport.write;\n    return transport;\n  }\n\n  // Transports that only can receive messages, but not send\n  if (transport.onmessage !== undefined) return;\n  if (transport.pause instanceof Function) return;\n\n  throw new SyntaxError(\"Transport is not a function nor a valid object\");\n};\n\n/**\n * Representation of a RPC notification\n *\n * @class\n *\n * @constructor\n *\n * @param {String} method -method of the notification\n * @param params - parameters of the notification\n */\nfunction RpcNotification(method, params) {\n  if (defineProperty_IE8) {\n    this.method = method\n    this.params = params\n  } else {\n    Object.defineProperty(this, 'method', {\n      value: method,\n      enumerable: true\n    });\n    Object.defineProperty(this, 'params', {\n      value: params,\n      enumerable: true\n    });\n  }\n};\n\n/**\n * @class\n *\n * @constructor\n *\n * @param {object} packer\n *\n * @param {object} [options]\n *\n * @param {object} [transport]\n *\n * @param {Function} [onRequest]\n */\nfunction RpcBuilder(packer, options, transport, onRequest) {\n  var self = this;\n\n  if (!packer)\n    throw new SyntaxError('Packer is not defined');\n\n  if (!packer.pack || !packer.unpack)\n    throw new SyntaxError('Packer is invalid');\n\n  var responseMethods = unifyResponseMethods(packer.responseMethods);\n\n  if (options instanceof Function) {\n    if (transport != undefined)\n      throw new SyntaxError(\"There can't be parameters after onRequest\");\n\n    onRequest = options;\n    transport = undefined;\n    options = undefined;\n  };\n\n  if (options && options.send instanceof Function) {\n    if (transport && !(transport instanceof Function))\n      throw new SyntaxError(\"Only a function can be after transport\");\n\n    onRequest = transport;\n    transport = options;\n    options = undefined;\n  };\n\n  if (transport instanceof Function) {\n    if (onRequest != undefined)\n      throw new SyntaxError(\"There can't be parameters after onRequest\");\n\n    onRequest = transport;\n    transport = undefined;\n  };\n\n  if (transport && transport.send instanceof Function)\n    if (onRequest && !(onRequest instanceof Function))\n      throw new SyntaxError(\"Only a function can be after transport\");\n\n  options = options || {};\n\n  EventEmitter.call(this);\n\n  if (onRequest)\n    this.on('request', onRequest);\n\n  if (defineProperty_IE8)\n    this.peerID = options.peerID\n  else\n    Object.defineProperty(this, 'peerID', {\n      value: options.peerID\n    });\n\n  var max_retries = options.max_retries || 0;\n\n  function transportMessage(event) {\n    self.decode(event.data || event.toString());\n  };\n\n  this.getTransport = function () {\n    return transport;\n  }\n  this.setTransport = function (value) {\n    // Remove listener from old transport\n    if (transport) {\n      // W3C transports\n      if (transport.removeEventListener)\n        transport.removeEventListener('message', transportMessage);\n\n      // Node.js Streams API\n      else if (transport.removeListener)\n        transport.removeListener('data', transportMessage);\n    };\n\n    // Set listener on new transport\n    if (value) {\n      // W3C transports\n      if (value.addEventListener)\n        value.addEventListener('message', transportMessage);\n\n      // Node.js Streams API\n      else if (value.addListener)\n        value.addListener('data', transportMessage);\n    };\n\n    transport = unifyTransport(value);\n  }\n\n  if (!defineProperty_IE8)\n    Object.defineProperty(this, 'transport', {\n      get: this.getTransport.bind(this),\n      set: this.setTransport.bind(this)\n    })\n\n  this.setTransport(transport);\n\n  var request_timeout = options.request_timeout || BASE_TIMEOUT;\n  var ping_request_timeout = options.ping_request_timeout || request_timeout;\n  var response_timeout = options.response_timeout || BASE_TIMEOUT;\n  var duplicates_timeout = options.duplicates_timeout || BASE_TIMEOUT;\n\n  var requestID = 0;\n\n  var requests = new Mapper();\n  var responses = new Mapper();\n  var processedResponses = new Mapper();\n\n  var message2Key = {};\n\n  /**\n   * Store the response to prevent to process duplicate request later\n   */\n  function storeResponse(message, id, dest) {\n    var response = {\n      message: message,\n      /** Timeout to auto-clean old responses */\n      timeout: setTimeout(function () {\n          responses.remove(id, dest);\n        },\n        response_timeout)\n    };\n\n    responses.set(response, id, dest);\n  };\n\n  /**\n   * Store the response to ignore duplicated messages later\n   */\n  function storeProcessedResponse(ack, from) {\n    var timeout = setTimeout(function () {\n        processedResponses.remove(ack, from);\n      },\n      duplicates_timeout);\n\n    processedResponses.set(timeout, ack, from);\n  };\n\n  /**\n   * Representation of a RPC request\n   *\n   * @class\n   * @extends RpcNotification\n   *\n   * @constructor\n   *\n   * @param {String} method -method of the notification\n   * @param params - parameters of the notification\n   * @param {Integer} id - identifier of the request\n   * @param [from] - source of the notification\n   */\n  function RpcRequest(method, params, id, from, transport) {\n    RpcNotification.call(this, method, params);\n\n    this.getTransport = function () {\n      return transport;\n    }\n    this.setTransport = function (value) {\n      transport = unifyTransport(value);\n    }\n\n    if (!defineProperty_IE8)\n      Object.defineProperty(this, 'transport', {\n        get: this.getTransport.bind(this),\n        set: this.setTransport.bind(this)\n      })\n\n    var response = responses.get(id, from);\n\n    /**\n     * @constant {Boolean} duplicated\n     */\n    if (!(transport || self.getTransport())) {\n      if (defineProperty_IE8)\n        this.duplicated = Boolean(response)\n      else\n        Object.defineProperty(this, 'duplicated', {\n          value: Boolean(response)\n        });\n    }\n\n    var responseMethod = responseMethods[method];\n\n    this.pack = packer.pack.bind(packer, this, id)\n\n    /**\n     * Generate a response to this request\n     *\n     * @param {Error} [error]\n     * @param {*} [result]\n     *\n     * @returns {string}\n     */\n    this.reply = function (error, result, transport) {\n      // Fix optional parameters\n      if (error instanceof Function || error && error\n        .send instanceof Function) {\n        if (result != undefined)\n          throw new SyntaxError(\"There can't be parameters after callback\");\n\n        transport = error;\n        result = null;\n        error = undefined;\n      } else if (result instanceof Function ||\n        result && result.send instanceof Function) {\n        if (transport != undefined)\n          throw new SyntaxError(\"There can't be parameters after callback\");\n\n        transport = result;\n        result = null;\n      };\n\n      transport = unifyTransport(transport);\n\n      // Duplicated request, remove old response timeout\n      if (response)\n        clearTimeout(response.timeout);\n\n      if (from != undefined) {\n        if (error)\n          error.dest = from;\n\n        if (result)\n          result.dest = from;\n      };\n\n      var message;\n\n      // New request or overriden one, create new response with provided data\n      if (error || result != undefined) {\n        if (self.peerID != undefined) {\n          if (error)\n            error.from = self.peerID;\n          else\n            result.from = self.peerID;\n        }\n\n        // Protocol indicates that responses has own request methods\n        if (responseMethod) {\n          if (responseMethod.error == undefined && error)\n            message = {\n              error: error\n            };\n\n          else {\n            var method = error ?\n              responseMethod.error :\n              responseMethod.response;\n\n            message = {\n              method: method,\n              params: error || result\n            };\n          }\n        } else\n          message = {\n            error: error,\n            result: result\n          };\n\n        message = packer.pack(message, id);\n      }\n\n      // Duplicate & not-overriden request, re-send old response\n      else if (response)\n        message = response.message;\n\n      // New empty reply, response null value\n      else\n        message = packer.pack({\n          result: null\n        }, id);\n\n      // Store the response to prevent to process a duplicated request later\n      storeResponse(message, id, from);\n\n      // Return the stored response so it can be directly send back\n      transport = transport || this.getTransport() || self.getTransport();\n\n      if (transport)\n        return transport.send(message);\n\n      return message;\n    }\n  };\n  inherits(RpcRequest, RpcNotification);\n\n  function cancel(message) {\n    var key = message2Key[message];\n    if (!key) return;\n\n    delete message2Key[message];\n\n    var request = requests.pop(key.id, key.dest);\n    if (!request) return;\n\n    clearTimeout(request.timeout);\n\n    // Start duplicated responses timeout\n    storeProcessedResponse(key.id, key.dest);\n  };\n\n  /**\n   * Allow to cancel a request and don't wait for a response\n   *\n   * If `message` is not given, cancel all the request\n   */\n  this.cancel = function (message) {\n    if (message) return cancel(message);\n\n    for (var message in message2Key)\n      cancel(message);\n  };\n\n  this.close = function () {\n    // Prevent to receive new messages\n    var transport = this.getTransport();\n    if (transport && transport.close)\n      transport.close();\n\n    // Request & processed responses\n    this.cancel();\n\n    processedResponses.forEach(clearTimeout);\n\n    // Responses\n    responses.forEach(function (response) {\n      clearTimeout(response.timeout);\n    });\n  };\n\n  /**\n   * Generates and encode a JsonRPC 2.0 message\n   *\n   * @param {String} method -method of the notification\n   * @param params - parameters of the notification\n   * @param [dest] - destination of the notification\n   * @param {object} [transport] - transport where to send the message\n   * @param [callback] - function called when a response to this request is\n   *   received. If not defined, a notification will be send instead\n   *\n   * @returns {string} A raw JsonRPC 2.0 request or notification string\n   */\n  this.encode = function (method, params, dest, transport, callback) {\n    // Fix optional parameters\n    if (params instanceof Function) {\n      if (dest != undefined)\n        throw new SyntaxError(\"There can't be parameters after callback\");\n\n      callback = params;\n      transport = undefined;\n      dest = undefined;\n      params = undefined;\n    } else if (dest instanceof Function) {\n      if (transport != undefined)\n        throw new SyntaxError(\"There can't be parameters after callback\");\n\n      callback = dest;\n      transport = undefined;\n      dest = undefined;\n    } else if (transport instanceof Function) {\n      if (callback != undefined)\n        throw new SyntaxError(\"There can't be parameters after callback\");\n\n      callback = transport;\n      transport = undefined;\n    };\n\n    if (self.peerID != undefined) {\n      params = params || {};\n\n      params.from = self.peerID;\n    };\n\n    if (dest != undefined) {\n      params = params || {};\n\n      params.dest = dest;\n    };\n\n    // Encode message\n    var message = {\n      method: method,\n      params: params\n    };\n\n    if (callback) {\n      var id = requestID++;\n      var retried = 0;\n\n      message = packer.pack(message, id);\n\n      function dispatchCallback(error, result) {\n        self.cancel(message);\n\n        callback(error, result);\n      };\n\n      var request = {\n        message: message,\n        callback: dispatchCallback,\n        responseMethods: responseMethods[method] || {}\n      };\n\n      var encode_transport = unifyTransport(transport);\n\n      function sendRequest(transport) {\n        var rt = (method === 'ping' ? ping_request_timeout : request_timeout);\n        request.timeout = setTimeout(timeout, rt * Math.pow(2, retried++));\n        message2Key[message] = {\n          id: id,\n          dest: dest\n        };\n        requests.set(request, id, dest);\n\n        transport = transport || encode_transport || self.getTransport();\n        if (transport)\n          return transport.send(message);\n\n        return message;\n      };\n\n      function retry(transport) {\n        transport = unifyTransport(transport);\n\n        console.warn(retried + ' retry for request message:', message);\n\n        var timeout = processedResponses.pop(id, dest);\n        clearTimeout(timeout);\n\n        return sendRequest(transport);\n      };\n\n      function timeout() {\n        if (retried < max_retries)\n          return retry(transport);\n\n        var error = new Error('Request has timed out');\n        error.request = message;\n\n        error.retry = retry;\n\n        dispatchCallback(error)\n      };\n\n      return sendRequest(transport);\n    };\n\n    // Return the packed message\n    message = packer.pack(message);\n\n    transport = transport || this.getTransport();\n    if (transport)\n      return transport.send(message);\n\n    return message;\n  };\n\n  /**\n   * Decode and process a JsonRPC 2.0 message\n   *\n   * @param {string} message - string with the content of the message\n   *\n   * @returns {RpcNotification|RpcRequest|undefined} - the representation of the\n   *   notification or the request. If a response was processed, it will return\n   *   `undefined` to notify that it was processed\n   *\n   * @throws {TypeError} - Message is not defined\n   */\n  this.decode = function (message, transport) {\n    if (!message)\n      throw new TypeError(\"Message is not defined\");\n\n    try {\n      message = packer.unpack(message);\n    } catch (e) {\n      // Ignore invalid messages\n      return console.debug(e, message);\n    };\n\n    var id = message.id;\n    var ack = message.ack;\n    var method = message.method;\n    var params = message.params || {};\n\n    var from = params.from;\n    var dest = params.dest;\n\n    // Ignore messages send by us\n    if (self.peerID != undefined && from == self.peerID) return;\n\n    // Notification\n    if (id == undefined && ack == undefined) {\n      var notification = new RpcNotification(method, params);\n\n      if (self.emit('request', notification)) return;\n      return notification;\n    };\n\n    function processRequest() {\n      // If we have a transport and it's a duplicated request, reply inmediatly\n      transport = unifyTransport(transport) || self.getTransport();\n      if (transport) {\n        var response = responses.get(id, from);\n        if (response)\n          return transport.send(response.message);\n      };\n\n      var idAck = (id != undefined) ? id : ack;\n      var request = new RpcRequest(method, params, idAck, from, transport);\n\n      if (self.emit('request', request)) return;\n      return request;\n    };\n\n    function processResponse(request, error, result) {\n      request.callback(error, result);\n    };\n\n    function duplicatedResponse(timeout) {\n      console.warn(\"Response already processed\", message);\n\n      // Update duplicated responses timeout\n      clearTimeout(timeout);\n      storeProcessedResponse(ack, from);\n    };\n\n    // Request, or response with own method\n    if (method) {\n      // Check if it's a response with own method\n      if (dest == undefined || dest == self.peerID) {\n        var request = requests.get(ack, from);\n        if (request) {\n          var responseMethods = request.responseMethods;\n\n          if (method == responseMethods.error)\n            return processResponse(request, params);\n\n          if (method == responseMethods.response)\n            return processResponse(request, null, params);\n\n          return processRequest();\n        }\n\n        var processed = processedResponses.get(ack, from);\n        if (processed)\n          return duplicatedResponse(processed);\n      }\n\n      // Request\n      return processRequest();\n    };\n\n    var error = message.error;\n    var result = message.result;\n\n    // Ignore responses not send to us\n    if (error && error.dest && error.dest != self.peerID) return;\n    if (result && result.dest && result.dest != self.peerID) return;\n\n    // Response\n    var request = requests.get(ack, from);\n    if (!request) {\n      var processed = processedResponses.get(ack, from);\n      if (processed)\n        return duplicatedResponse(processed);\n\n      return console.warn(\"No callback was defined for this message\",\n        message);\n    };\n\n    // Process response\n    processResponse(request, error, result);\n  };\n};\ninherits(RpcBuilder, EventEmitter);\n\nRpcBuilder.RpcNotification = RpcNotification;\n\nmodule.exports = RpcBuilder;\n\nvar clients = require('./clients');\nvar transports = require('./clients/transports');\n\nRpcBuilder.clients = clients;\nRpcBuilder.clients.transports = transports;\nRpcBuilder.packers = packers;\n","/**\n * JsonRPC 2.0 packer\n */\n\n/**\n * Pack a JsonRPC 2.0 message\n *\n * @param {Object} message - object to be packaged. It requires to have all the\n *   fields needed by the JsonRPC 2.0 message that it's going to be generated\n *\n * @return {String} - the stringified JsonRPC 2.0 message\n */\nfunction pack(message, id) {\n  var result = {\n    jsonrpc: \"2.0\"\n  };\n\n  // Request\n  if (message.method) {\n    result.method = message.method;\n\n    if (message.params)\n      result.params = message.params;\n\n    // Request is a notification\n    if (id != undefined)\n      result.id = id;\n  }\n\n  // Response\n  else if (id != undefined) {\n    if (message.error) {\n      if (message.result !== undefined)\n        throw new TypeError(\"Both result and error are defined\");\n\n      result.error = message.error;\n    } else if (message.result !== undefined)\n      result.result = message.result;\n    else\n      throw new TypeError(\"No result or error is defined\");\n\n    result.id = id;\n  };\n\n  return JSON.stringify(result);\n};\n\n/**\n * Unpack a JsonRPC 2.0 message\n *\n * @param {String} message - string with the content of the JsonRPC 2.0 message\n *\n * @throws {TypeError} - Invalid JsonRPC version\n *\n * @return {Object} - object filled with the JsonRPC 2.0 message content\n */\nfunction unpack(message) {\n  var result = message;\n\n  if (typeof message === 'string' || message instanceof String) {\n    result = JSON.parse(message);\n  }\n\n  // Check if it's a valid message\n\n  var version = result.jsonrpc;\n  if (version !== '2.0')\n    throw new TypeError(\"Invalid JsonRPC version '\" + version + \"': \" +\n      message);\n\n  // Response\n  if (result.method == undefined) {\n    if (result.id == undefined)\n      throw new TypeError(\"Invalid message: \" + message);\n\n    var result_defined = result.result !== undefined;\n    var error_defined = result.error !== undefined;\n\n    // Check only result or error is defined, not both or none\n    if (result_defined && error_defined)\n      throw new TypeError(\"Both result and error are defined: \" + message);\n\n    if (!result_defined && !error_defined)\n      throw new TypeError(\"No result or error is defined: \" + message);\n\n    result.ack = result.id;\n    delete result.id;\n  }\n\n  // Return unpacked message\n  return result;\n};\n\nexports.pack = pack;\nexports.unpack = unpack;\n","function pack(message) {\n  throw new TypeError(\"Not yet implemented\");\n};\n\nfunction unpack(message) {\n  throw new TypeError(\"Not yet implemented\");\n};\n\nexports.pack = pack;\nexports.unpack = unpack;\n","var JsonRPC = require('./JsonRPC');\nvar XmlRPC = require('./XmlRPC');\n\nexports.JsonRPC = JsonRPC;\nexports.XmlRPC = XmlRPC;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar objectCreate = Object.create || objectCreatePolyfill\nvar objectKeys = Object.keys || objectKeysPolyfill\nvar bind = Function.prototype.bind || functionBindPolyfill\n\nfunction EventEmitter() {\n  if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {\n    this._events = objectCreate(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\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\nvar hasDefineProperty;\ntry {\n  var o = {};\n  if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });\n  hasDefineProperty = o.x === 0;\n} catch (err) { hasDefineProperty = false }\nif (hasDefineProperty) {\n  Object.defineProperty(EventEmitter, 'defaultMaxListeners', {\n    enumerable: true,\n    get: function() {\n      return defaultMaxListeners;\n    },\n    set: function(arg) {\n      // check whether the input is a positive number (whose value is zero or\n      // greater and not a NaN).\n      if (typeof arg !== 'number' || arg < 0 || arg !== arg)\n        throw new TypeError('\"defaultMaxListeners\" must be a positive number');\n      defaultMaxListeners = arg;\n    }\n  });\n} else {\n  EventEmitter.defaultMaxListeners = defaultMaxListeners;\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 || isNaN(n))\n    throw new TypeError('\"n\" argument must be a positive number');\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\n// These standalone emit* functions are used to optimize calling of event\n// handlers for fast cases because emit() itself often has a variable number of\n// arguments and can be deoptimized because of that. These functions always have\n// the same number of arguments and thus do not get deoptimized, so the code\n// inside them can execute faster.\nfunction emitNone(handler, isFn, self) {\n  if (isFn)\n    handler.call(self);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self);\n  }\n}\nfunction emitOne(handler, isFn, self, arg1) {\n  if (isFn)\n    handler.call(self, arg1);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1);\n  }\n}\nfunction emitTwo(handler, isFn, self, arg1, arg2) {\n  if (isFn)\n    handler.call(self, arg1, arg2);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1, arg2);\n  }\n}\nfunction emitThree(handler, isFn, self, arg1, arg2, arg3) {\n  if (isFn)\n    handler.call(self, arg1, arg2, arg3);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1, arg2, arg3);\n  }\n}\n\nfunction emitMany(handler, isFn, self, args) {\n  if (isFn)\n    handler.apply(self, args);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].apply(self, args);\n  }\n}\n\nEventEmitter.prototype.emit = function emit(type) {\n  var er, handler, len, args, i, events;\n  var doError = (type === 'error');\n\n  events = this._events;\n  if (events)\n    doError = (doError && events.error == null);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    if (arguments.length > 1)\n      er = arguments[1];\n    if (er instanceof Error) {\n      throw er; // Unhandled 'error' event\n    } else {\n      // At least give some kind of context to the user\n      var err = new Error('Unhandled \"error\" event. (' + er + ')');\n      err.context = er;\n      throw err;\n    }\n    return false;\n  }\n\n  handler = events[type];\n\n  if (!handler)\n    return false;\n\n  var isFn = typeof handler === 'function';\n  len = arguments.length;\n  switch (len) {\n      // fast cases\n    case 1:\n      emitNone(handler, isFn, this);\n      break;\n    case 2:\n      emitOne(handler, isFn, this, arguments[1]);\n      break;\n    case 3:\n      emitTwo(handler, isFn, this, arguments[1], arguments[2]);\n      break;\n    case 4:\n      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);\n      break;\n      // slower\n    default:\n      args = new Array(len - 1);\n      for (i = 1; i < len; i++)\n        args[i - 1] = arguments[i];\n      emitMany(handler, isFn, 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  if (typeof listener !== 'function')\n    throw new TypeError('\"listener\" argument must be a function');\n\n  events = target._events;\n  if (!events) {\n    events = target._events = objectCreate(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) {\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) {\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    } else {\n      // If we've already got an array, just append.\n      if (prepend) {\n        existing.unshift(listener);\n      } else {\n        existing.push(listener);\n      }\n    }\n\n    // Check for listener leak\n    if (!existing.warned) {\n      m = $getMaxListeners(target);\n      if (m && m > 0 && existing.length > m) {\n        existing.warned = true;\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        if (typeof console === 'object' && console.warn) {\n          console.warn('%s: %s', w.name, w.message);\n        }\n      }\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    switch (arguments.length) {\n      case 0:\n        return this.listener.call(this.target);\n      case 1:\n        return this.listener.call(this.target, arguments[0]);\n      case 2:\n        return this.listener.call(this.target, arguments[0], arguments[1]);\n      case 3:\n        return this.listener.call(this.target, arguments[0], arguments[1],\n            arguments[2]);\n      default:\n        var args = new Array(arguments.length);\n        for (var i = 0; i < args.length; ++i)\n          args[i] = arguments[i];\n        this.listener.apply(this.target, args);\n    }\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = bind.call(onceWrapper, state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  if (typeof listener !== 'function')\n    throw new TypeError('\"listener\" argument must be a function');\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      if (typeof listener !== 'function')\n        throw new TypeError('\"listener\" argument must be a function');\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      if (typeof listener !== 'function')\n        throw new TypeError('\"listener\" argument must be a function');\n\n      events = this._events;\n      if (!events)\n        return this;\n\n      list = events[type];\n      if (!list)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = objectCreate(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        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (!events)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (!events.removeListener) {\n        if (arguments.length === 0) {\n          this._events = objectCreate(null);\n          this._eventsCount = 0;\n        } else if (events[type]) {\n          if (--this._eventsCount === 0)\n            this._events = objectCreate(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 = objectKeys(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 = objectCreate(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) {\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)\n    return [];\n\n  var evlistener = events[type];\n  if (!evlistener)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ? 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) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];\n};\n\n// About 1.5x faster than the two-arg version of Array#splice().\nfunction spliceOne(list, index) {\n  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)\n    list[i] = list[k];\n  list.pop();\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 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 objectCreatePolyfill(proto) {\n  var F = function() {};\n  F.prototype = proto;\n  return new F;\n}\nfunction objectKeysPolyfill(obj) {\n  var keys = [];\n  for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {\n    keys.push(k);\n  }\n  return k;\n}\nfunction functionBindPolyfill(context) {\n  var fn = this;\n  return function () {\n    return fn.apply(context, arguments);\n  };\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n"]}