zetapush-js/dist/zetapush.min.js.map

{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///zetapush.min.js","webpack:///webpack/bootstrap 4e1c3ddbe1098a00e90a","webpack:///./~/whatwg-fetch/fetch.js","webpack:///./lib/index.js","webpack:///./lib/authentication/handshake.js","webpack:///./~/babel-runtime/core-js/object/get-prototype-of.js","webpack:///./~/core-js/library/fn/object/get-prototype-of.js","webpack:///./~/core-js/library/modules/es6.object.get-prototype-of.js","webpack:///./~/core-js/library/modules/_to-object.js","webpack:///./~/core-js/library/modules/_defined.js","webpack:///./~/core-js/library/modules/_object-gpo.js","webpack:///./~/core-js/library/modules/_has.js","webpack:///./~/core-js/library/modules/_shared-key.js","webpack:///./~/core-js/library/modules/_shared.js","webpack:///./~/core-js/library/modules/_global.js","webpack:///./~/core-js/library/modules/_uid.js","webpack:///./~/core-js/library/modules/_object-sap.js","webpack:///./~/core-js/library/modules/_export.js","webpack:///./~/core-js/library/modules/_core.js","webpack:///./~/core-js/library/modules/_ctx.js","webpack:///./~/core-js/library/modules/_a-function.js","webpack:///./~/core-js/library/modules/_hide.js","webpack:///./~/core-js/library/modules/_object-dp.js","webpack:///./~/core-js/library/modules/_an-object.js","webpack:///./~/core-js/library/modules/_is-object.js","webpack:///./~/core-js/library/modules/_ie8-dom-define.js","webpack:///./~/core-js/library/modules/_descriptors.js","webpack:///./~/core-js/library/modules/_fails.js","webpack:///./~/core-js/library/modules/_dom-create.js","webpack:///./~/core-js/library/modules/_to-primitive.js","webpack:///./~/core-js/library/modules/_property-desc.js","webpack:///./~/babel-runtime/helpers/possibleConstructorReturn.js","webpack:///./~/babel-runtime/helpers/typeof.js","webpack:///./~/babel-runtime/core-js/symbol/iterator.js","webpack:///./~/core-js/library/fn/symbol/iterator.js","webpack:///./~/core-js/library/modules/es6.string.iterator.js","webpack:///./~/core-js/library/modules/_string-at.js","webpack:///./~/core-js/library/modules/_to-integer.js","webpack:///./~/core-js/library/modules/_iter-define.js","webpack:///./~/core-js/library/modules/_library.js","webpack:///./~/core-js/library/modules/_redefine.js","webpack:///./~/core-js/library/modules/_iterators.js","webpack:///./~/core-js/library/modules/_iter-create.js","webpack:///./~/core-js/library/modules/_object-create.js","webpack:///./~/core-js/library/modules/_object-dps.js","webpack:///./~/core-js/library/modules/_object-keys.js","webpack:///./~/core-js/library/modules/_object-keys-internal.js","webpack:///./~/core-js/library/modules/_to-iobject.js","webpack:///./~/core-js/library/modules/_iobject.js","webpack:///./~/core-js/library/modules/_cof.js","webpack:///./~/core-js/library/modules/_array-includes.js","webpack:///./~/core-js/library/modules/_to-length.js","webpack:///./~/core-js/library/modules/_to-index.js","webpack:///./~/core-js/library/modules/_enum-bug-keys.js","webpack:///./~/core-js/library/modules/_html.js","webpack:///./~/core-js/library/modules/_set-to-string-tag.js","webpack:///./~/core-js/library/modules/_wks.js","webpack:///./~/core-js/library/modules/web.dom.iterable.js","webpack:///./~/core-js/library/modules/es6.array.iterator.js","webpack:///./~/core-js/library/modules/_add-to-unscopables.js","webpack:///./~/core-js/library/modules/_iter-step.js","webpack:///./~/core-js/library/modules/_wks-ext.js","webpack:///./~/babel-runtime/core-js/symbol.js","webpack:///./~/core-js/library/fn/symbol/index.js","webpack:///./~/core-js/library/modules/es6.symbol.js","webpack:///./~/core-js/library/modules/_meta.js","webpack:///./~/core-js/library/modules/_wks-define.js","webpack:///./~/core-js/library/modules/_keyof.js","webpack:///./~/core-js/library/modules/_enum-keys.js","webpack:///./~/core-js/library/modules/_object-gops.js","webpack:///./~/core-js/library/modules/_object-pie.js","webpack:///./~/core-js/library/modules/_is-array.js","webpack:///./~/core-js/library/modules/_object-gopn-ext.js","webpack:///./~/core-js/library/modules/_object-gopn.js","webpack:///./~/core-js/library/modules/_object-gopd.js","webpack:///./~/core-js/library/modules/es7.symbol.async-iterator.js","webpack:///./~/core-js/library/modules/es7.symbol.observable.js","webpack:///./~/babel-runtime/helpers/inherits.js","webpack:///./~/babel-runtime/core-js/object/set-prototype-of.js","webpack:///./~/core-js/library/fn/object/set-prototype-of.js","webpack:///./~/core-js/library/modules/es6.object.set-prototype-of.js","webpack:///./~/core-js/library/modules/_set-proto.js","webpack:///./~/babel-runtime/core-js/object/create.js","webpack:///./~/core-js/library/fn/object/create.js","webpack:///./~/core-js/library/modules/es6.object.create.js","webpack:///./~/babel-runtime/helpers/classCallCheck.js","webpack:///./~/babel-runtime/helpers/createClass.js","webpack:///./~/babel-runtime/core-js/object/define-property.js","webpack:///./~/core-js/library/fn/object/define-property.js","webpack:///./~/core-js/library/modules/es6.object.define-property.js","webpack:///./lib/mapping/authentications.js","webpack:///./lib/mapping/core.js","webpack:///./lib/connection/connection-status.js","webpack:///./lib/connection/cometd.js","webpack:///./~/babel-runtime/core-js/object/assign.js","webpack:///./~/core-js/library/fn/object/assign.js","webpack:///./~/core-js/library/modules/es6.object.assign.js","webpack:///./~/core-js/library/modules/_object-assign.js","webpack:///./~/zetapush-cometd/index.js","webpack:///./~/zetapush-cometd/lib/CallbackPollingTransport.js","webpack:///./~/zetapush-cometd/lib/Transport.js","webpack:///./~/zetapush-cometd/lib/Utils.js","webpack:///./~/zetapush-cometd/lib/RequestTransport.js","webpack:///./~/zetapush-cometd/lib/CometD.js","webpack:///./~/zetapush-cometd/lib/TransportRegistry.js","webpack:///./~/zetapush-cometd/lib/LongPollingTransport.js","webpack:///./~/zetapush-cometd/lib/WebSocketTransport.js","webpack:///./lib/client/basic.js","webpack:///./~/babel-runtime/helpers/defineProperty.js","webpack:///./~/babel-runtime/core-js/object/get-own-property-names.js","webpack:///./~/core-js/library/fn/object/get-own-property-names.js","webpack:///./~/core-js/library/modules/es6.object.get-own-property-names.js","webpack:///./lib/client/helper.js","webpack:///./~/babel-runtime/core-js/promise.js","webpack:///./~/core-js/library/fn/promise.js","webpack:///./~/core-js/library/modules/es6.promise.js","webpack:///./~/core-js/library/modules/_classof.js","webpack:///./~/core-js/library/modules/_an-instance.js","webpack:///./~/core-js/library/modules/_for-of.js","webpack:///./~/core-js/library/modules/_iter-call.js","webpack:///./~/core-js/library/modules/_is-array-iter.js","webpack:///./~/core-js/library/modules/core.get-iterator-method.js","webpack:///./~/core-js/library/modules/_species-constructor.js","webpack:///./~/core-js/library/modules/_task.js","webpack:///./~/core-js/library/modules/_invoke.js","webpack:///./~/core-js/library/modules/_microtask.js","webpack:///./~/core-js/library/modules/_redefine-all.js","webpack:///./~/core-js/library/modules/_set-species.js","webpack:///./~/core-js/library/modules/_iter-detect.js","webpack:///./lib/mapping/services.js","webpack:///./lib/utils/index.js","webpack:///./~/babel-runtime/core-js/array/from.js","webpack:///./~/core-js/library/fn/array/from.js","webpack:///./~/core-js/library/modules/es6.array.from.js","webpack:///./~/core-js/library/modules/_create-property.js","webpack:///./~/babel-runtime/core-js/object/values.js","webpack:///./~/core-js/library/fn/object/values.js","webpack:///./~/core-js/library/modules/es7.object.values.js","webpack:///./~/core-js/library/modules/_object-to-array.js","webpack:///./lib/client/smart.js","webpack:///./~/babel-runtime/helpers/get.js","webpack:///./~/babel-runtime/core-js/object/get-own-property-descriptor.js","webpack:///./~/core-js/library/fn/object/get-own-property-descriptor.js","webpack:///./~/core-js/library/modules/es6.object.get-own-property-descriptor.js","webpack:///./lib/utils/session-persistence.js","webpack:///./~/babel-runtime/core-js/json/stringify.js","webpack:///./~/core-js/library/fn/json/stringify.js","webpack:///./lib/client/weak.js","webpack:///./lib/mapping/index.js"],"names":["root","factory","exports","module","define","amd","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","self","normalizeName","name","String","test","TypeError","toLowerCase","normalizeValue","value","iteratorFor","items","iterator","next","shift","done","undefined","support","iterable","Symbol","Headers","headers","map","forEach","append","Object","getOwnPropertyNames","consumed","body","bodyUsed","Promise","reject","fileReaderReady","reader","resolve","onload","result","onerror","error","readBlobAsArrayBuffer","blob","FileReader","readAsArrayBuffer","readBlobAsText","readAsText","Body","_initBody","_bodyInit","_bodyText","Blob","prototype","isPrototypeOf","_bodyBlob","formData","FormData","_bodyFormData","searchParams","URLSearchParams","toString","arrayBuffer","ArrayBuffer","Error","get","set","type","rejected","then","text","decode","json","JSON","parse","normalizeMethod","method","upcased","toUpperCase","methods","indexOf","Request","input","options","url","credentials","mode","referrer","form","trim","split","bytes","replace","join","decodeURIComponent","xhr","head","pairs","getAllResponseHeaders","header","key","Response","bodyInit","status","ok","statusText","fetch","e","list","push","values","getAll","has","hasOwnProperty","callback","thisArg","keys","entries","clone","response","redirectStatuses","redirect","RangeError","location","init","responseURL","getResponseHeader","request","XMLHttpRequest","responseText","ontimeout","open","withCredentials","responseType","setRequestHeader","send","polyfill","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","global","apply","_handshake","_connectionStatus","_cometd","_basic","_smart","_weak","_mapping","defineProperty","enumerable","Authentication","ConnectionStatusListener","TransportTypes","Client","SmartClient","WeakClient","services","VERSION","_getPrototypeOf","_possibleConstructorReturn2","_inherits2","_classCallCheck2","_createClass2","_authentications","_interopRequireDefault","obj","__esModule","default","_getPrototypeOf2","_possibleConstructorReturn3","_inherits3","_classCallCheck3","_createClass3","DeployableNames","AUTH_SIMPLE","AUTH_WEAK","AUTH_DELEGATING","AbstractHandshake","_ref","authType","sandboxId","deploymentId","client","authentication","data","authData","getSandboxId","version","authVersion","getResource","resource","ext","TokenHandshake","_AbstractHandshake","_ref2","token","_this","__proto__","CredentialsHandshake","_AbstractHandshake2","_ref3","login","password","_this2","_ref4","_ref4$deploymentId","Simple","DEFAULT_DEPLOYMENT_ID","create","_ref5","_ref5$deploymentId","Weak","_ref6","_ref6$deploymentId","Delegating","_ref7","getPrototypeOf","toObject","$getPrototypeOf","it","defined","IE_PROTO","ObjectProto","O","constructor","shared","uid","SHARED","store","window","Math","Function","__g","px","random","concat","$export","core","fails","KEY","exec","fn","exp","S","F","ctx","hide","PROTOTYPE","source","own","out","IS_FORCED","IS_GLOBAL","G","IS_STATIC","IS_PROTO","P","IS_BIND","B","IS_WRAP","W","expProto","target","C","a","b","arguments","length","virtual","R","U","__e","aFunction","that","dP","createDesc","object","f","anObject","IE8_DOM_DEFINE","toPrimitive","Attributes","isObject","document","is","createElement","val","valueOf","bitmap","configurable","writable","_typeof2","_typeof3","ReferenceError","_iterator","_iterator2","_symbol","_symbol2","_typeof","$at","iterated","_t","_i","point","index","toInteger","TO_STRING","pos","s","i","l","charCodeAt","charAt","slice","ceil","floor","isNaN","LIBRARY","redefine","Iterators","$iterCreate","setToStringTag","ITERATOR","BUGGY","FF_ITERATOR","KEYS","VALUES","returnThis","Base","NAME","Constructor","DEFAULT","IS_SET","FORCED","IteratorPrototype","getMethod","kind","proto","TAG","DEF_VALUES","VALUES_BUG","$native","$default","$entries","$anyNative","descriptor","dPs","enumBugKeys","Empty","createDict","iframeDocument","iframe","lt","gt","style","display","appendChild","src","contentWindow","write","close","Properties","getKeys","defineProperties","$keys","toIObject","arrayIndexOf","names","IObject","cof","propertyIsEnumerable","toLength","toIndex","IS_INCLUDES","$this","el","fromIndex","min","max","documentElement","def","tag","stat","USE_SYMBOL","$exports","TO_STRING_TAG","collections","Collection","Array","addToUnscopables","step","_k","Arguments","DESCRIPTORS","META","$fails","wks","wksExt","wksDefine","keyOf","enumKeys","isArray","_create","gOPNExt","$GOPD","$DP","gOPD","gOPN","$Symbol","$JSON","_stringify","stringify","HIDDEN","TO_PRIMITIVE","isEnum","SymbolRegistry","AllSymbols","OPSymbols","USE_NATIVE","QObject","setter","findChild","setSymbolDesc","D","protoDesc","wrap","sym","isSymbol","$defineProperty","$defineProperties","$create","$propertyIsEnumerable","E","$getOwnPropertyDescriptor","$getOwnPropertyNames","$getOwnPropertySymbols","IS_OP","$set","symbols","for","keyFor","useSetter","useSimple","getOwnPropertyDescriptor","getOwnPropertySymbols","replacer","$replacer","args","setDesc","isExtensible","FREEZE","preventExtensions","setMeta","w","fastKey","getWeak","onFreeze","meta","NEED","gOPS","pIE","getSymbols","arg","windowNames","getWindowNames","hiddenKeys","_setPrototypeOf","_setPrototypeOf2","_create2","subClass","superClass","setPrototypeOf","check","buggy","$Object","instance","_defineProperty","_defineProperty2","props","protoProps","staticProps","desc","_core","_Service","Service","_Service2","_Service3","fullRights","publicToken","$publish","failure","_assign","_zetapushCometd","FetchLongPollingTransport","_super","LongPollingTransport","Transport","derive","xhrSend","packet","_assign2","Content-Type","onSuccess","catch","onError","TransportLayers","LONG_POLLING","WEBSOCKET","assign","$assign","A","K","k","T","aLen","j","CallbackPollingTransport","CometD","RequestTransport","TransportRegistry","Utils","WebSocketTransport","_failTransportFn","envelope","x","transportFailure","_self","accept","crossDomain","jsonpSend","transportSend","start","messages","lengths","urlLength","encodeURI","maxLength","getConfiguration","maxURILength","getType","setTimeout","envelopeToSend","begin","end","_debug","_mixin","onFailure","nextEnvelope","metaConnect","sameStack","transport","sync","requestHeaders","responses","success","received","convertToMessages","httpCode","transportSuccess","exception","reason","xx","_type","_url","registered","cometd","unregistered","getAdvice","funktion","delay","clearTimeout","handle","isString","getURL","setURL","reset","abort","baseObject","inArray","element","array","timeoutHandle","_coalesceEnvelopes","_envelopes","envelopeAndRequest","newEnvelope","newRequest","_transportSend","expired","maxDelay","maxNetworkDelay","timeout","errorMessage","xhrStatus","abortXHR","complete","_queueSend","requestId","_requestIds","_requests","maxConnections","_metaConnectComplete","_metaConnectRequest","_complete","splice","nextRequest","autoBatch","_metaConnectSend","state","readyState","UNSENT","_fieldValue","_isString","_isFunction","_zeroPad","pow","_log","level","console","logger","now","Date","getHours","getMinutes","getSeconds","getMilliseconds","_splitURL","_configure","configuration","_config","urlParts","hostAndPort","uri","afterURI","_crossDomain","_isCrossDomain","appendMessageTypeToURL","_info","uriSegments","lastSegmentIndex","match","_removeListener","subscription","subscriptions","_listeners","channel","listener","_removeSubscription","_clearSubscriptions","_setStatus","newStatus","_status","_isDisconnected","_nextMessageId","_messageId","_applyExtension","scope","message","outgoing","handler","onExtensionException","_applyIncomingExtensions","_extensions","reverseIncomingExtensions","extension","incoming","_applyOutgoingExtensions","_notify","onListenerException","_notifyListeners","channelParts","last","channelPart","_cancelDelayedSend","_scheduledSend","_delayedSend","operation","_backoff","time","_advice","interval","_send","extraPath","messageId","_clientId","clientId","_callbacks","rcvdMessages","_handleMessages","conduit","getTransport","connectionType","_handleFailure","_transport","_batch","_internalBatch","_messageQueue","_resetBackoff","_increaseBackoff","maxBackoff","backoffIncrement","_startBatch","_flushBatch","_endBatch","_connect","bayeuxMessage","_connected","advice","_delayedConnect","_updateAdvice","newAdvice","_disconnect","_notifyTransportFailure","oldTransport","newTransport","onTransportException","handshakeProps","handshakeCallback","_transports","reconnect","_handshakeProps","_handshakeCallback","transportTypes","findTransportTypes","minimumVersion","supportedConnectionTypes","_putCallback","negotiateTransport","getTransportTypes","_warn","_delayedHandshake","_notifyCallback","onCallbackException","_handleCallback","_getCallback","_handleRemoteCall","context","_remoteCalls","_failHandshake","retry","_handshakeResponse","successful","reestablish","_reestablish","action","_handshakeFailure","_failConnect","_connectResponse","_connectFailure","_failDisconnect","_disconnectResponse","_disconnectFailure","_failSubscribe","_subscribeResponse","_subscribeFailure","_failUnsubscribe","_unsubscribeResponse","_unsubscribeFailure","_failMessage","_messageResponse","_handshakeMessages","_messageFailure","_receive","_unconnectTime","_hasSubscriptions","_resolveScopedCallback","delegate","_addListener","isListener","_name","protocol","stickyReconnect","connectTimeout","logLevel","urls","maxInterval","deep","objects","propName","prop","targ","host","receive","failureMessage","registerTransport","add","unregisterTransport","remove","unregisterTransports","clear","findTransport","find","getTransportRegistry","configure","handshake","disconnect","disconnectProps","disconnectCallback","startBatch","endBatch","batch","addListener","removeListener","clearListeners","subscribe","subscribeProps","subscribeCallback","unsubscribe","unsubscribeProps","unsubscribeCallback","resubscribe","clearSubscriptions","publish","content","publishProps","publishCallback","remoteCall","getStatus","isDisconnected","setBackoffIncrement","period","getBackoffIncrement","getBackoffPeriod","increaseBackoffPeriod","resetBackoffPeriod","setLogLevel","registerExtension","existing","existingExtension","unregisterExtension","getExtension","getName","getClientId","_types","types","_supportsCrossDomain","_forceClose","event","webSocketClose","code","onClose","_sameContext","_connecting","_context","_storeEnvelope","messageIds","envelopes","_websocketConnect","webSocket","WebSocket","_webSocketSupported","_stickyReconnect","connectTimer","onopen","_webSocketConnected","onOpen","onclose","onmessage","wsMessage","onMessage","_webSocketSend","timeouts","_successCallback","_notifySuccess","_notifyFailure","removed","ids","websocketCode","websocketEnabled","_getOwnPropertyNames","_helper","_index","_defineProperty3","_getOwnPropertyNames2","_ref$apiUrl","apiUrl","API_URL","_ref$forceHttps","forceHttps","isHttpsProtocol","transports","helper","ClientHelper","addConnectionStatusListener","isConnected","onConnectionClosed","removeConnectionStatusListener","connect","Type","createAsyncMacroService","createService","getUserId","setAuthentication","setResource","service","$subscriptions","_promise","_values","_services","_promise2","_values2","Message","RECONNECT_HANDSHAKE_VALUE","RECONNECT_NONE_VALUE","RECONNECT_RETRY_VALUE","AllTransports","UPDATE_SERVER_URL_DELAY","DEFAULT_MACRO_CHANNEL","_ref$resource","_ref$transports","userId","uniqId","uuid","servers","getServers","connectionListeners","connected","wasConnected","serverUrl","sessionId","subscribeQueue","filter","includes","updateServerUrl","_ext$authentication","initialized","handshakeFailure","authenticationFailed","negotiate","connectionWillClose","prefix","connectionEstablished","connectionBroken","_ref8","connectionClosed","enabled","_ref9","_ref10","onFailedHandshake","shuffle","getHandshakeFields","_ref11","_ref12","onConnectionBroken","_ref13","_ref14","_ref15","_ref16","onConnectionEstablished","_ref17","_ref18","onConnectionWillClose","_ref19","_ref19$deploymentId","getAsyncMacroPublisher","createServiceByPublisher","_ref20","_ref20$deploymentId","isMacroType","isDerivedOf","Macro","getMacroPublisher","getServicePublisher","_ref21","_this3","parameters","hardFail","debug","uniqRequestId","getUniqRequestId","_listener","_ref22","_ref22$data","_data$result","_data$errors","errors","_this4","findIndex","queued","_this5","_ref23","_ref24","onSuccessfulHandshake","_ref25","_ref26","onMessageLost","_getQueuedSubscriptio","getQueuedSubscription","_this6","_getQueuedSubscriptio2","Internal","GenericPromiseCapability","Wrapper","classof","anInstance","forOf","speciesConstructor","task","microtask","PROMISE","process","$Promise","isNode","empty","promise","FakePromise","PromiseRejectionEvent","sameConstructor","isThenable","newPromiseCapability","PromiseCapability","$$resolve","$$reject","perform","notify","isReject","_n","chain","_c","_v","_s","run","reaction","fail","domain","_h","onHandleUnhandled","enter","exit","onUnhandled","abrupt","isUnhandled","emit","onunhandledrejection","_a","onrejectionhandled","$reject","_d","_w","$resolve","wrapper","executor","err","onFulfilled","onRejected","r","capability","iter","all","remaining","$index","alreadyCalled","race","ARG","tryGet","callee","forbiddenField","isArrayIter","getIterFn","BREAK","RETURN","iterFn","ret","ArrayProto","getIteratorMethod","SPECIES","defer","port","invoke","html","cel","setTask","setImmediate","clearTask","clearImmediate","MessageChannel","counter","queue","ONREADYSTATECHANGE","nextTick","port2","port1","postMessage","addEventListener","importScripts","removeChild","un","macrotask","Observer","MutationObserver","WebKitMutationObserver","flush","parent","toggle","node","createTextNode","observe","characterData","safe","SAFE_CLOSING","riter","from","skipClosing","arr","Userdir","Zpfs_s3compat","Zpfs_hdfs","Zpfs_s3","Template","Search","Cron","Sms_ovh","Notif","Queue","Messaging","Sendmail","MacroDebug","Httpclient","GroupManagement","Remoting","Gda","Game","GameEngine","Echo","Stack","Aggreg","owner","stack","page","guids","listeners","guid","parameter","_Service4","callerId","msgId","payload","gameInfo","maxGames","gameId","_Service5","role","userName","_Service6","table","column","key2","columns","rows","stop","_ref27","_ref28","_ref29","_ref30","_Service7","_ref31","cmd","fromResource","_ref32","answeringResource","askingResource","capabilities","_ref33","_ref34","_ref35","_ref36","available","user","_ref37","_Service8","_ref38","group","_ref39","_ref40","users","_ref41","_ref42","groupName","_ref43","_ref44","_ref45","_ref46","_ref47","_ref48","_ref49","_ref50","_ref51","_ref52","_ref53","actions","_ref54","_ref55","_ref56","_Service9","_ref57","_Service10","_ref58","_Service11","_ref59","breakpoint","_ref60","frame","_ref61","breakpoints","_ref62","_ref63","_Service12","_Service13","_ref64","_Service14","_ref65","description","originBusinessId","originDeploymentId","_ref66","taskId","_ref67","capacity","_ref68","_Service15","_Service16","_Service17","_ref69","_ref70","cronName","_Service18","_ref71","_ref72","_ref73","_ref74","indices","query","sort","_Service19","_ref75","languageTag","_Service20","_ref76","oldPath","path","_ref77","_ref78","_ref79","folder","_ref80","parents","_ref81","_ref82","metadata","tags","_ref83","contentType","_ref84","_ref85","_ref86","metadataFiles","_Service21","_ref87","_ref88","_ref89","_ref90","_ref91","_ref92","_ref93","_ref94","_ref95","_ref96","_ref97","_Service22","_ref98","_ref99","_ref100","_ref101","_ref102","_ref103","_ref104","_ref105","_ref106","_ref107","_ref108","_Service23","_ref109","_ref110","userKeys","_from","getSecureUrl","_from2","HTTP_PATTERN","HTTPS_PROTOCOL","DICTIONARY","secureApiUrl","server","Derived","Parent","entropy","dictionary","reduce","previous","createProperty","arrayLike","mapfn","mapping","$values","isEntries","_get2","_sessionPersistence","_get3","_Client","persistence","SessionPersistenceStrategy","session","hasCredentials","_this$getCredentials","getCredentials","setCredentials","simple","isStronglyAuthenticated","weak","lifeCycleConnectionHandler","_getCredentials","isWeaklyAuthenticated","_getOwnPropertyDescriptor","_getOwnPropertyDescriptor2","property","receiver","getter","ZETAPUSH_SESSION_KEY","_stringify2","_ref$storage","storage","localStorage","getItem","setItem","getToken","strategy","_strategy$get","_interopRequireWildcard","newObj","authentications"],"mappings":"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","file":"zetapush.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"ZetaPush\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ZetaPush\"] = factory();\n\telse\n\t\troot[\"ZetaPush\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"ZetaPush\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ZetaPush\"] = factory();\n\telse\n\t\troot[\"ZetaPush\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \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/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\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.loaded = 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// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(1);\n\tmodule.exports = __webpack_require__(2);\n\n\n/***/ },\n/* 1 */\n/***/ function(module, exports) {\n\n\t(function(self) {\n\t  'use strict';\n\t\n\t  if (self.fetch) {\n\t    return\n\t  }\n\t\n\t  var support = {\n\t    searchParams: 'URLSearchParams' in self,\n\t    iterable: 'Symbol' in self && 'iterator' in Symbol,\n\t    blob: 'FileReader' in self && 'Blob' in self && (function() {\n\t      try {\n\t        new Blob()\n\t        return true\n\t      } catch(e) {\n\t        return false\n\t      }\n\t    })(),\n\t    formData: 'FormData' in self,\n\t    arrayBuffer: 'ArrayBuffer' in self\n\t  }\n\t\n\t  function normalizeName(name) {\n\t    if (typeof name !== 'string') {\n\t      name = String(name)\n\t    }\n\t    if (/[^a-z0-9\\-#$%&'*+.\\^_`|~]/i.test(name)) {\n\t      throw new TypeError('Invalid character in header field name')\n\t    }\n\t    return name.toLowerCase()\n\t  }\n\t\n\t  function normalizeValue(value) {\n\t    if (typeof value !== 'string') {\n\t      value = String(value)\n\t    }\n\t    return value\n\t  }\n\t\n\t  // Build a destructive iterator for the value list\n\t  function iteratorFor(items) {\n\t    var iterator = {\n\t      next: function() {\n\t        var value = items.shift()\n\t        return {done: value === undefined, value: value}\n\t      }\n\t    }\n\t\n\t    if (support.iterable) {\n\t      iterator[Symbol.iterator] = function() {\n\t        return iterator\n\t      }\n\t    }\n\t\n\t    return iterator\n\t  }\n\t\n\t  function Headers(headers) {\n\t    this.map = {}\n\t\n\t    if (headers instanceof Headers) {\n\t      headers.forEach(function(value, name) {\n\t        this.append(name, value)\n\t      }, this)\n\t\n\t    } else if (headers) {\n\t      Object.getOwnPropertyNames(headers).forEach(function(name) {\n\t        this.append(name, headers[name])\n\t      }, this)\n\t    }\n\t  }\n\t\n\t  Headers.prototype.append = function(name, value) {\n\t    name = normalizeName(name)\n\t    value = normalizeValue(value)\n\t    var list = this.map[name]\n\t    if (!list) {\n\t      list = []\n\t      this.map[name] = list\n\t    }\n\t    list.push(value)\n\t  }\n\t\n\t  Headers.prototype['delete'] = function(name) {\n\t    delete this.map[normalizeName(name)]\n\t  }\n\t\n\t  Headers.prototype.get = function(name) {\n\t    var values = this.map[normalizeName(name)]\n\t    return values ? values[0] : null\n\t  }\n\t\n\t  Headers.prototype.getAll = function(name) {\n\t    return this.map[normalizeName(name)] || []\n\t  }\n\t\n\t  Headers.prototype.has = function(name) {\n\t    return this.map.hasOwnProperty(normalizeName(name))\n\t  }\n\t\n\t  Headers.prototype.set = function(name, value) {\n\t    this.map[normalizeName(name)] = [normalizeValue(value)]\n\t  }\n\t\n\t  Headers.prototype.forEach = function(callback, thisArg) {\n\t    Object.getOwnPropertyNames(this.map).forEach(function(name) {\n\t      this.map[name].forEach(function(value) {\n\t        callback.call(thisArg, value, name, this)\n\t      }, this)\n\t    }, this)\n\t  }\n\t\n\t  Headers.prototype.keys = function() {\n\t    var items = []\n\t    this.forEach(function(value, name) { items.push(name) })\n\t    return iteratorFor(items)\n\t  }\n\t\n\t  Headers.prototype.values = function() {\n\t    var items = []\n\t    this.forEach(function(value) { items.push(value) })\n\t    return iteratorFor(items)\n\t  }\n\t\n\t  Headers.prototype.entries = function() {\n\t    var items = []\n\t    this.forEach(function(value, name) { items.push([name, value]) })\n\t    return iteratorFor(items)\n\t  }\n\t\n\t  if (support.iterable) {\n\t    Headers.prototype[Symbol.iterator] = Headers.prototype.entries\n\t  }\n\t\n\t  function consumed(body) {\n\t    if (body.bodyUsed) {\n\t      return Promise.reject(new TypeError('Already read'))\n\t    }\n\t    body.bodyUsed = true\n\t  }\n\t\n\t  function fileReaderReady(reader) {\n\t    return new Promise(function(resolve, reject) {\n\t      reader.onload = function() {\n\t        resolve(reader.result)\n\t      }\n\t      reader.onerror = function() {\n\t        reject(reader.error)\n\t      }\n\t    })\n\t  }\n\t\n\t  function readBlobAsArrayBuffer(blob) {\n\t    var reader = new FileReader()\n\t    reader.readAsArrayBuffer(blob)\n\t    return fileReaderReady(reader)\n\t  }\n\t\n\t  function readBlobAsText(blob) {\n\t    var reader = new FileReader()\n\t    reader.readAsText(blob)\n\t    return fileReaderReady(reader)\n\t  }\n\t\n\t  function Body() {\n\t    this.bodyUsed = false\n\t\n\t    this._initBody = function(body) {\n\t      this._bodyInit = body\n\t      if (typeof body === 'string') {\n\t        this._bodyText = body\n\t      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n\t        this._bodyBlob = body\n\t      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n\t        this._bodyFormData = body\n\t      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n\t        this._bodyText = body.toString()\n\t      } else if (!body) {\n\t        this._bodyText = ''\n\t      } else if (support.arrayBuffer && ArrayBuffer.prototype.isPrototypeOf(body)) {\n\t        // Only support ArrayBuffers for POST method.\n\t        // Receiving ArrayBuffers happens via Blobs, instead.\n\t      } else {\n\t        throw new Error('unsupported BodyInit type')\n\t      }\n\t\n\t      if (!this.headers.get('content-type')) {\n\t        if (typeof body === 'string') {\n\t          this.headers.set('content-type', 'text/plain;charset=UTF-8')\n\t        } else if (this._bodyBlob && this._bodyBlob.type) {\n\t          this.headers.set('content-type', this._bodyBlob.type)\n\t        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n\t          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')\n\t        }\n\t      }\n\t    }\n\t\n\t    if (support.blob) {\n\t      this.blob = function() {\n\t        var rejected = consumed(this)\n\t        if (rejected) {\n\t          return rejected\n\t        }\n\t\n\t        if (this._bodyBlob) {\n\t          return Promise.resolve(this._bodyBlob)\n\t        } else if (this._bodyFormData) {\n\t          throw new Error('could not read FormData body as blob')\n\t        } else {\n\t          return Promise.resolve(new Blob([this._bodyText]))\n\t        }\n\t      }\n\t\n\t      this.arrayBuffer = function() {\n\t        return this.blob().then(readBlobAsArrayBuffer)\n\t      }\n\t\n\t      this.text = function() {\n\t        var rejected = consumed(this)\n\t        if (rejected) {\n\t          return rejected\n\t        }\n\t\n\t        if (this._bodyBlob) {\n\t          return readBlobAsText(this._bodyBlob)\n\t        } else if (this._bodyFormData) {\n\t          throw new Error('could not read FormData body as text')\n\t        } else {\n\t          return Promise.resolve(this._bodyText)\n\t        }\n\t      }\n\t    } else {\n\t      this.text = function() {\n\t        var rejected = consumed(this)\n\t        return rejected ? rejected : Promise.resolve(this._bodyText)\n\t      }\n\t    }\n\t\n\t    if (support.formData) {\n\t      this.formData = function() {\n\t        return this.text().then(decode)\n\t      }\n\t    }\n\t\n\t    this.json = function() {\n\t      return this.text().then(JSON.parse)\n\t    }\n\t\n\t    return this\n\t  }\n\t\n\t  // HTTP methods whose capitalization should be normalized\n\t  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']\n\t\n\t  function normalizeMethod(method) {\n\t    var upcased = method.toUpperCase()\n\t    return (methods.indexOf(upcased) > -1) ? upcased : method\n\t  }\n\t\n\t  function Request(input, options) {\n\t    options = options || {}\n\t    var body = options.body\n\t    if (Request.prototype.isPrototypeOf(input)) {\n\t      if (input.bodyUsed) {\n\t        throw new TypeError('Already read')\n\t      }\n\t      this.url = input.url\n\t      this.credentials = input.credentials\n\t      if (!options.headers) {\n\t        this.headers = new Headers(input.headers)\n\t      }\n\t      this.method = input.method\n\t      this.mode = input.mode\n\t      if (!body) {\n\t        body = input._bodyInit\n\t        input.bodyUsed = true\n\t      }\n\t    } else {\n\t      this.url = input\n\t    }\n\t\n\t    this.credentials = options.credentials || this.credentials || 'omit'\n\t    if (options.headers || !this.headers) {\n\t      this.headers = new Headers(options.headers)\n\t    }\n\t    this.method = normalizeMethod(options.method || this.method || 'GET')\n\t    this.mode = options.mode || this.mode || null\n\t    this.referrer = null\n\t\n\t    if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n\t      throw new TypeError('Body not allowed for GET or HEAD requests')\n\t    }\n\t    this._initBody(body)\n\t  }\n\t\n\t  Request.prototype.clone = function() {\n\t    return new Request(this)\n\t  }\n\t\n\t  function decode(body) {\n\t    var form = new FormData()\n\t    body.trim().split('&').forEach(function(bytes) {\n\t      if (bytes) {\n\t        var split = bytes.split('=')\n\t        var name = split.shift().replace(/\\+/g, ' ')\n\t        var value = split.join('=').replace(/\\+/g, ' ')\n\t        form.append(decodeURIComponent(name), decodeURIComponent(value))\n\t      }\n\t    })\n\t    return form\n\t  }\n\t\n\t  function headers(xhr) {\n\t    var head = new Headers()\n\t    var pairs = (xhr.getAllResponseHeaders() || '').trim().split('\\n')\n\t    pairs.forEach(function(header) {\n\t      var split = header.trim().split(':')\n\t      var key = split.shift().trim()\n\t      var value = split.join(':').trim()\n\t      head.append(key, value)\n\t    })\n\t    return head\n\t  }\n\t\n\t  Body.call(Request.prototype)\n\t\n\t  function Response(bodyInit, options) {\n\t    if (!options) {\n\t      options = {}\n\t    }\n\t\n\t    this.type = 'default'\n\t    this.status = options.status\n\t    this.ok = this.status >= 200 && this.status < 300\n\t    this.statusText = options.statusText\n\t    this.headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers)\n\t    this.url = options.url || ''\n\t    this._initBody(bodyInit)\n\t  }\n\t\n\t  Body.call(Response.prototype)\n\t\n\t  Response.prototype.clone = function() {\n\t    return new Response(this._bodyInit, {\n\t      status: this.status,\n\t      statusText: this.statusText,\n\t      headers: new Headers(this.headers),\n\t      url: this.url\n\t    })\n\t  }\n\t\n\t  Response.error = function() {\n\t    var response = new Response(null, {status: 0, statusText: ''})\n\t    response.type = 'error'\n\t    return response\n\t  }\n\t\n\t  var redirectStatuses = [301, 302, 303, 307, 308]\n\t\n\t  Response.redirect = function(url, status) {\n\t    if (redirectStatuses.indexOf(status) === -1) {\n\t      throw new RangeError('Invalid status code')\n\t    }\n\t\n\t    return new Response(null, {status: status, headers: {location: url}})\n\t  }\n\t\n\t  self.Headers = Headers\n\t  self.Request = Request\n\t  self.Response = Response\n\t\n\t  self.fetch = function(input, init) {\n\t    return new Promise(function(resolve, reject) {\n\t      var request\n\t      if (Request.prototype.isPrototypeOf(input) && !init) {\n\t        request = input\n\t      } else {\n\t        request = new Request(input, init)\n\t      }\n\t\n\t      var xhr = new XMLHttpRequest()\n\t\n\t      function responseURL() {\n\t        if ('responseURL' in xhr) {\n\t          return xhr.responseURL\n\t        }\n\t\n\t        // Avoid security warnings on getResponseHeader when not allowed by CORS\n\t        if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {\n\t          return xhr.getResponseHeader('X-Request-URL')\n\t        }\n\t\n\t        return\n\t      }\n\t\n\t      xhr.onload = function() {\n\t        var options = {\n\t          status: xhr.status,\n\t          statusText: xhr.statusText,\n\t          headers: headers(xhr),\n\t          url: responseURL()\n\t        }\n\t        var body = 'response' in xhr ? xhr.response : xhr.responseText\n\t        resolve(new Response(body, options))\n\t      }\n\t\n\t      xhr.onerror = function() {\n\t        reject(new TypeError('Network request failed'))\n\t      }\n\t\n\t      xhr.ontimeout = function() {\n\t        reject(new TypeError('Network request failed'))\n\t      }\n\t\n\t      xhr.open(request.method, request.url, true)\n\t\n\t      if (request.credentials === 'include') {\n\t        xhr.withCredentials = true\n\t      }\n\t\n\t      if ('responseType' in xhr && support.blob) {\n\t        xhr.responseType = 'blob'\n\t      }\n\t\n\t      request.headers.forEach(function(value, name) {\n\t        xhr.setRequestHeader(name, value)\n\t      })\n\t\n\t      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)\n\t    })\n\t  }\n\t  self.fetch.polyfill = true\n\t})(typeof self !== 'undefined' ? self : this);\n\n\n/***/ },\n/* 2 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(3), __webpack_require__(92), __webpack_require__(93), __webpack_require__(107), __webpack_require__(139), __webpack_require__(147), __webpack_require__(148)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('./authentication/handshake'), require('./connection/connection-status'), require('./connection/cometd'), require('./client/basic'), require('./client/smart'), require('./client/weak'), require('./mapping'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.handshake, global.connectionStatus, global.cometd, global.basic, global.smart, global.weak, global.mapping);\n\t    global.index = mod.exports;\n\t  }\n\t})(this, function (exports, _handshake, _connectionStatus, _cometd, _basic, _smart, _weak, _mapping) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  Object.defineProperty(exports, 'Authentication', {\n\t    enumerable: true,\n\t    get: function () {\n\t      return _handshake.Authentication;\n\t    }\n\t  });\n\t  Object.defineProperty(exports, 'ConnectionStatusListener', {\n\t    enumerable: true,\n\t    get: function () {\n\t      return _connectionStatus.ConnectionStatusListener;\n\t    }\n\t  });\n\t  Object.defineProperty(exports, 'TransportTypes', {\n\t    enumerable: true,\n\t    get: function () {\n\t      return _cometd.TransportTypes;\n\t    }\n\t  });\n\t  Object.defineProperty(exports, 'Client', {\n\t    enumerable: true,\n\t    get: function () {\n\t      return _basic.Client;\n\t    }\n\t  });\n\t  Object.defineProperty(exports, 'SmartClient', {\n\t    enumerable: true,\n\t    get: function () {\n\t      return _smart.SmartClient;\n\t    }\n\t  });\n\t  Object.defineProperty(exports, 'WeakClient', {\n\t    enumerable: true,\n\t    get: function () {\n\t      return _weak.WeakClient;\n\t    }\n\t  });\n\t  Object.defineProperty(exports, 'services', {\n\t    enumerable: true,\n\t    get: function () {\n\t      return _mapping.services;\n\t    }\n\t  });\n\t\n\t\n\t  /**\n\t   * SDK Version\n\t   * @type {string}\n\t   */\n\t  var VERSION = exports.VERSION = '3.1.0-alpha.2';\n\t});\n\n/***/ },\n/* 3 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(4), __webpack_require__(30), __webpack_require__(77), __webpack_require__(85), __webpack_require__(86), __webpack_require__(90)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('babel-runtime/core-js/object/get-prototype-of'), require('babel-runtime/helpers/possibleConstructorReturn'), require('babel-runtime/helpers/inherits'), require('babel-runtime/helpers/classCallCheck'), require('babel-runtime/helpers/createClass'), require('../mapping/authentications'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.getPrototypeOf, global.possibleConstructorReturn, global.inherits, global.classCallCheck, global.createClass, global.authentications);\n\t    global.handshake = mod.exports;\n\t  }\n\t})(this, function (exports, _getPrototypeOf, _possibleConstructorReturn2, _inherits2, _classCallCheck2, _createClass2, _authentications) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.Authentication = undefined;\n\t\n\t  var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);\n\t\n\t  var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);\n\t\n\t  var _inherits3 = _interopRequireDefault(_inherits2);\n\t\n\t  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t  var _createClass3 = _interopRequireDefault(_createClass2);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  /**\n\t   * ZetaPush deployables names\n\t   */\n\t  var DeployableNames = {\n\t    AUTH_SIMPLE: 'simple',\n\t    AUTH_WEAK: 'weak',\n\t    AUTH_DELEGATING: 'delegating'\n\t  };\n\t\n\t  /**\n\t   * Provide abstraction over CometD handshake data structure\n\t   * @access protected\n\t   */\n\t\n\t  var AbstractHandshake = function () {\n\t    /**\n\t     * Create a new handshake manager\n\t     * @param {{authType: string, sandboxId: string, deploymentId: string}} parameters\n\t     */\n\t    function AbstractHandshake(_ref) {\n\t      var authType = _ref.authType,\n\t          sandboxId = _ref.sandboxId,\n\t          deploymentId = _ref.deploymentId;\n\t      (0, _classCallCheck3.default)(this, AbstractHandshake);\n\t\n\t      /**\n\t       * @access protected\n\t       * @type {string}\n\t       */\n\t      this.authType = authType;\n\t      /**\n\t       * @access protected\n\t       * @type {string}\n\t       */\n\t      this.sandboxId = sandboxId;\n\t      /**\n\t       * @access protected\n\t       * @type {string}\n\t       */\n\t      this.deploymentId = deploymentId;\n\t    }\n\t    /**\n\t     * @param {ClientHelper} client\n\t     * @return {Object}\n\t     */\n\t\n\t\n\t    (0, _createClass3.default)(AbstractHandshake, [{\n\t      key: 'getHandshakeFields',\n\t      value: function getHandshakeFields(client) {\n\t        var authentication = {\n\t          data: this.authData,\n\t          type: client.getSandboxId() + '.' + this.deploymentId + '.' + this.authType,\n\t          version: this.authVersion\n\t        };\n\t        if (client.getResource()) {\n\t          authentication.resource = client.getResource();\n\t        }\n\t        return {\n\t          ext: {\n\t            authentication: authentication\n\t          }\n\t        };\n\t      }\n\t    }, {\n\t      key: 'authVersion',\n\t      get: function get() {\n\t        return 'none';\n\t      }\n\t    }]);\n\t    return AbstractHandshake;\n\t  }();\n\t\n\t  var TokenHandshake = function (_AbstractHandshake) {\n\t    (0, _inherits3.default)(TokenHandshake, _AbstractHandshake);\n\t\n\t    /**\n\t     * @param {{authType: string, deploymentId: string, token: string}} parameters\n\t     */\n\t    function TokenHandshake(_ref2) {\n\t      var authType = _ref2.authType,\n\t          deploymentId = _ref2.deploymentId,\n\t          token = _ref2.token;\n\t      (0, _classCallCheck3.default)(this, TokenHandshake);\n\t\n\t      var _this = (0, _possibleConstructorReturn3.default)(this, (TokenHandshake.__proto__ || (0, _getPrototypeOf2.default)(TokenHandshake)).call(this, { deploymentId: deploymentId, authType: authType }));\n\t\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      _this.token = token;\n\t      return _this;\n\t    }\n\t    /**\n\t     * @return {token: string}\n\t     */\n\t\n\t\n\t    (0, _createClass3.default)(TokenHandshake, [{\n\t      key: 'authData',\n\t      get: function get() {\n\t        var token = this.token;\n\t\n\t        return {\n\t          token: token\n\t        };\n\t      }\n\t    }]);\n\t    return TokenHandshake;\n\t  }(AbstractHandshake);\n\t\n\t  var CredentialsHandshake = function (_AbstractHandshake2) {\n\t    (0, _inherits3.default)(CredentialsHandshake, _AbstractHandshake2);\n\t\n\t    /**\n\t     * @param {{authType: string, deploymentId: string, login: string, password: string}} parameters\n\t     */\n\t    function CredentialsHandshake(_ref3) {\n\t      var authType = _ref3.authType,\n\t          deploymentId = _ref3.deploymentId,\n\t          login = _ref3.login,\n\t          password = _ref3.password;\n\t      (0, _classCallCheck3.default)(this, CredentialsHandshake);\n\t\n\t      var _this2 = (0, _possibleConstructorReturn3.default)(this, (CredentialsHandshake.__proto__ || (0, _getPrototypeOf2.default)(CredentialsHandshake)).call(this, { authType: authType, deploymentId: deploymentId }));\n\t\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      _this2.login = login;\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      _this2.password = password;\n\t      return _this2;\n\t    }\n\t    /**\n\t     * Get auth data\n\t     * @return {login: string, password: string}\n\t     */\n\t\n\t\n\t    (0, _createClass3.default)(CredentialsHandshake, [{\n\t      key: 'authData',\n\t      get: function get() {\n\t        var login = this.login,\n\t            password = this.password;\n\t\n\t        return {\n\t          login: login, password: password\n\t        };\n\t      }\n\t    }]);\n\t    return CredentialsHandshake;\n\t  }(AbstractHandshake);\n\t\n\t  var Authentication = exports.Authentication = function () {\n\t    function Authentication() {\n\t      (0, _classCallCheck3.default)(this, Authentication);\n\t    }\n\t\n\t    (0, _createClass3.default)(Authentication, null, [{\n\t      key: 'simple',\n\t\n\t      /**\n\t       * @param {{deploymentId: string, login: string, password: string}} parameters\n\t       * @return {CredentialsHandshake}\n\t       * @example\n\t       * // Explicit deploymentId\n\t       * // Authentication provide optional deployment id, according to the following convention `${ServiceType.toLowerCase()_0}`\n\t       * Authentication.delegating({\n\t       *   deploymentId: '<YOUR-SIMPLE-AUTHENTICATION-DEPLOYMENT-ID>',\n\t       *   login: <USER-LOGIN>,\n\t       *   password: '<USER-PASSWORD>'\n\t       * })\n\t       */\n\t      value: function simple(_ref4) {\n\t        var _ref4$deploymentId = _ref4.deploymentId,\n\t            deploymentId = _ref4$deploymentId === undefined ? _authentications.Simple.DEFAULT_DEPLOYMENT_ID : _ref4$deploymentId,\n\t            login = _ref4.login,\n\t            password = _ref4.password;\n\t\n\t        return Authentication.create({\n\t          authType: DeployableNames.AUTH_SIMPLE,\n\t          deploymentId: deploymentId,\n\t          login: login,\n\t          password: password\n\t        });\n\t      }\n\t      /**\n\t       * @param {{deploymentId: string, token: string}} parameters\n\t       * @return {TokenHandshake}\n\t       * @example\n\t       * // Explicit deploymentId\n\t       * // Authentication provide optional deployment id, according to the following convention `${ServiceType.toLowerCase()_0}`\n\t       * Authentication.delegating({\n\t       *   deploymentId: '<YOUR-WEAK-AUTHENTICATION-DEPLOYMENT-ID>',\n\t       *   token: null\n\t       * })\n\t       */\n\t\n\t    }, {\n\t      key: 'weak',\n\t      value: function weak(_ref5) {\n\t        var _ref5$deploymentId = _ref5.deploymentId,\n\t            deploymentId = _ref5$deploymentId === undefined ? _authentications.Weak.DEFAULT_DEPLOYMENT_ID : _ref5$deploymentId,\n\t            token = _ref5.token;\n\t\n\t        return Authentication.create({\n\t          authType: DeployableNames.AUTH_WEAK,\n\t          deploymentId: deploymentId,\n\t          login: token,\n\t          password: null\n\t        });\n\t      }\n\t      /**\n\t       * @param {{deploymentId: string, token: string}} parameters\n\t       * @return {TokenHandshake}\n\t       * @example\n\t       * // Explicit deploymentId\n\t       * // Authentication provide optional deployment id, according to the following convention `${ServiceType.toLowerCase()_0}`\n\t       * Authentication.delegating({\n\t       *   deploymentId: '<YOUR-DELEGATING-AUTHENTICATION-DEPLOYMENT-ID>',\n\t       *   token: null\n\t       * })\n\t       */\n\t\n\t    }, {\n\t      key: 'delegating',\n\t      value: function delegating(_ref6) {\n\t        var _ref6$deploymentId = _ref6.deploymentId,\n\t            deploymentId = _ref6$deploymentId === undefined ? _authentications.Delegating.DEFAULT_DEPLOYMENT_ID : _ref6$deploymentId,\n\t            token = _ref6.token;\n\t\n\t        return Authentication.create({\n\t          authType: DeployableNames.AUTH_DELEGATING,\n\t          deploymentId: deploymentId,\n\t          login: token,\n\t          password: null\n\t        });\n\t      }\n\t      /**\n\t       * @param {{authType: string, deploymentId: string, login: string, password: string}} parameters\n\t       * @return {TokenHandshake|CredentialsHandshake}\n\t       */\n\t\n\t    }, {\n\t      key: 'create',\n\t      value: function create(_ref7) {\n\t        var authType = _ref7.authType,\n\t            deploymentId = _ref7.deploymentId,\n\t            login = _ref7.login,\n\t            password = _ref7.password;\n\t\n\t        if (password === null) {\n\t          return new TokenHandshake({ authType: authType, deploymentId: deploymentId, token: login });\n\t        }\n\t        return new CredentialsHandshake({ authType: authType, deploymentId: deploymentId, login: login, password: password });\n\t      }\n\t    }]);\n\t    return Authentication;\n\t  }();\n\t});\n\n/***/ },\n/* 4 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(5), __esModule: true };\n\n/***/ },\n/* 5 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(6);\n\tmodule.exports = __webpack_require__(17).Object.getPrototypeOf;\n\n/***/ },\n/* 6 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 19.1.2.9 Object.getPrototypeOf(O)\n\tvar toObject        = __webpack_require__(7)\n\t  , $getPrototypeOf = __webpack_require__(9);\n\t\n\t__webpack_require__(15)('getPrototypeOf', function(){\n\t  return function getPrototypeOf(it){\n\t    return $getPrototypeOf(toObject(it));\n\t  };\n\t});\n\n/***/ },\n/* 7 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 7.1.13 ToObject(argument)\n\tvar defined = __webpack_require__(8);\n\tmodule.exports = function(it){\n\t  return Object(defined(it));\n\t};\n\n/***/ },\n/* 8 */\n/***/ function(module, exports) {\n\n\t// 7.2.1 RequireObjectCoercible(argument)\n\tmodule.exports = function(it){\n\t  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n\t  return it;\n\t};\n\n/***/ },\n/* 9 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\n\tvar has         = __webpack_require__(10)\n\t  , toObject    = __webpack_require__(7)\n\t  , IE_PROTO    = __webpack_require__(11)('IE_PROTO')\n\t  , ObjectProto = Object.prototype;\n\t\n\tmodule.exports = Object.getPrototypeOf || function(O){\n\t  O = toObject(O);\n\t  if(has(O, IE_PROTO))return O[IE_PROTO];\n\t  if(typeof O.constructor == 'function' && O instanceof O.constructor){\n\t    return O.constructor.prototype;\n\t  } return O instanceof Object ? ObjectProto : null;\n\t};\n\n/***/ },\n/* 10 */\n/***/ function(module, exports) {\n\n\tvar hasOwnProperty = {}.hasOwnProperty;\n\tmodule.exports = function(it, key){\n\t  return hasOwnProperty.call(it, key);\n\t};\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar shared = __webpack_require__(12)('keys')\n\t  , uid    = __webpack_require__(14);\n\tmodule.exports = function(key){\n\t  return shared[key] || (shared[key] = uid(key));\n\t};\n\n/***/ },\n/* 12 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar global = __webpack_require__(13)\n\t  , SHARED = '__core-js_shared__'\n\t  , store  = global[SHARED] || (global[SHARED] = {});\n\tmodule.exports = function(key){\n\t  return store[key] || (store[key] = {});\n\t};\n\n/***/ },\n/* 13 */\n/***/ function(module, exports) {\n\n\t// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\n\tvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n\t  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\n\tif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n/***/ },\n/* 14 */\n/***/ function(module, exports) {\n\n\tvar id = 0\n\t  , px = Math.random();\n\tmodule.exports = function(key){\n\t  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n\t};\n\n/***/ },\n/* 15 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// most Object methods by ES6 should accept primitives\n\tvar $export = __webpack_require__(16)\n\t  , core    = __webpack_require__(17)\n\t  , fails   = __webpack_require__(26);\n\tmodule.exports = function(KEY, exec){\n\t  var fn  = (core.Object || {})[KEY] || Object[KEY]\n\t    , exp = {};\n\t  exp[KEY] = exec(fn);\n\t  $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);\n\t};\n\n/***/ },\n/* 16 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar global    = __webpack_require__(13)\n\t  , core      = __webpack_require__(17)\n\t  , ctx       = __webpack_require__(18)\n\t  , hide      = __webpack_require__(20)\n\t  , PROTOTYPE = 'prototype';\n\t\n\tvar $export = function(type, name, source){\n\t  var IS_FORCED = type & $export.F\n\t    , IS_GLOBAL = type & $export.G\n\t    , IS_STATIC = type & $export.S\n\t    , IS_PROTO  = type & $export.P\n\t    , IS_BIND   = type & $export.B\n\t    , IS_WRAP   = type & $export.W\n\t    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n\t    , expProto  = exports[PROTOTYPE]\n\t    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n\t    , key, own, out;\n\t  if(IS_GLOBAL)source = name;\n\t  for(key in source){\n\t    // contains in native\n\t    own = !IS_FORCED && target && target[key] !== undefined;\n\t    if(own && key in exports)continue;\n\t    // export native or passed\n\t    out = own ? target[key] : source[key];\n\t    // prevent global pollution for namespaces\n\t    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n\t    // bind timers to global for call from export context\n\t    : IS_BIND && own ? ctx(out, global)\n\t    // wrap global constructors for prevent change them in library\n\t    : IS_WRAP && target[key] == out ? (function(C){\n\t      var F = function(a, b, c){\n\t        if(this instanceof C){\n\t          switch(arguments.length){\n\t            case 0: return new C;\n\t            case 1: return new C(a);\n\t            case 2: return new C(a, b);\n\t          } return new C(a, b, c);\n\t        } return C.apply(this, arguments);\n\t      };\n\t      F[PROTOTYPE] = C[PROTOTYPE];\n\t      return F;\n\t    // make static versions for prototype methods\n\t    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n\t    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n\t    if(IS_PROTO){\n\t      (exports.virtual || (exports.virtual = {}))[key] = out;\n\t      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n\t      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n\t    }\n\t  }\n\t};\n\t// type bitmap\n\t$export.F = 1;   // forced\n\t$export.G = 2;   // global\n\t$export.S = 4;   // static\n\t$export.P = 8;   // proto\n\t$export.B = 16;  // bind\n\t$export.W = 32;  // wrap\n\t$export.U = 64;  // safe\n\t$export.R = 128; // real proto method for `library` \n\tmodule.exports = $export;\n\n/***/ },\n/* 17 */\n/***/ function(module, exports) {\n\n\tvar core = module.exports = {version: '2.4.0'};\n\tif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n/***/ },\n/* 18 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// optional / simple context binding\n\tvar aFunction = __webpack_require__(19);\n\tmodule.exports = function(fn, that, length){\n\t  aFunction(fn);\n\t  if(that === undefined)return fn;\n\t  switch(length){\n\t    case 1: return function(a){\n\t      return fn.call(that, a);\n\t    };\n\t    case 2: return function(a, b){\n\t      return fn.call(that, a, b);\n\t    };\n\t    case 3: return function(a, b, c){\n\t      return fn.call(that, a, b, c);\n\t    };\n\t  }\n\t  return function(/* ...args */){\n\t    return fn.apply(that, arguments);\n\t  };\n\t};\n\n/***/ },\n/* 19 */\n/***/ function(module, exports) {\n\n\tmodule.exports = function(it){\n\t  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n\t  return it;\n\t};\n\n/***/ },\n/* 20 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar dP         = __webpack_require__(21)\n\t  , createDesc = __webpack_require__(29);\n\tmodule.exports = __webpack_require__(25) ? function(object, key, value){\n\t  return dP.f(object, key, createDesc(1, value));\n\t} : function(object, key, value){\n\t  object[key] = value;\n\t  return object;\n\t};\n\n/***/ },\n/* 21 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar anObject       = __webpack_require__(22)\n\t  , IE8_DOM_DEFINE = __webpack_require__(24)\n\t  , toPrimitive    = __webpack_require__(28)\n\t  , dP             = Object.defineProperty;\n\t\n\texports.f = __webpack_require__(25) ? Object.defineProperty : function defineProperty(O, P, Attributes){\n\t  anObject(O);\n\t  P = toPrimitive(P, true);\n\t  anObject(Attributes);\n\t  if(IE8_DOM_DEFINE)try {\n\t    return dP(O, P, Attributes);\n\t  } catch(e){ /* empty */ }\n\t  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n\t  if('value' in Attributes)O[P] = Attributes.value;\n\t  return O;\n\t};\n\n/***/ },\n/* 22 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar isObject = __webpack_require__(23);\n\tmodule.exports = function(it){\n\t  if(!isObject(it))throw TypeError(it + ' is not an object!');\n\t  return it;\n\t};\n\n/***/ },\n/* 23 */\n/***/ function(module, exports) {\n\n\tmodule.exports = function(it){\n\t  return typeof it === 'object' ? it !== null : typeof it === 'function';\n\t};\n\n/***/ },\n/* 24 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = !__webpack_require__(25) && !__webpack_require__(26)(function(){\n\t  return Object.defineProperty(__webpack_require__(27)('div'), 'a', {get: function(){ return 7; }}).a != 7;\n\t});\n\n/***/ },\n/* 25 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// Thank's IE8 for his funny defineProperty\n\tmodule.exports = !__webpack_require__(26)(function(){\n\t  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n\t});\n\n/***/ },\n/* 26 */\n/***/ function(module, exports) {\n\n\tmodule.exports = function(exec){\n\t  try {\n\t    return !!exec();\n\t  } catch(e){\n\t    return true;\n\t  }\n\t};\n\n/***/ },\n/* 27 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar isObject = __webpack_require__(23)\n\t  , document = __webpack_require__(13).document\n\t  // in old IE typeof document.createElement is 'object'\n\t  , is = isObject(document) && isObject(document.createElement);\n\tmodule.exports = function(it){\n\t  return is ? document.createElement(it) : {};\n\t};\n\n/***/ },\n/* 28 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 7.1.1 ToPrimitive(input [, PreferredType])\n\tvar isObject = __webpack_require__(23);\n\t// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n\t// and the second argument - flag - preferred type is a string\n\tmodule.exports = function(it, S){\n\t  if(!isObject(it))return it;\n\t  var fn, val;\n\t  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n\t  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n\t  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n\t  throw TypeError(\"Can't convert object to primitive value\");\n\t};\n\n/***/ },\n/* 29 */\n/***/ function(module, exports) {\n\n\tmodule.exports = function(bitmap, value){\n\t  return {\n\t    enumerable  : !(bitmap & 1),\n\t    configurable: !(bitmap & 2),\n\t    writable    : !(bitmap & 4),\n\t    value       : value\n\t  };\n\t};\n\n/***/ },\n/* 30 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\texports.__esModule = true;\n\t\n\tvar _typeof2 = __webpack_require__(31);\n\t\n\tvar _typeof3 = _interopRequireDefault(_typeof2);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\texports.default = function (self, call) {\n\t  if (!self) {\n\t    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n\t  }\n\t\n\t  return call && ((typeof call === \"undefined\" ? \"undefined\" : (0, _typeof3.default)(call)) === \"object\" || typeof call === \"function\") ? call : self;\n\t};\n\n/***/ },\n/* 31 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\texports.__esModule = true;\n\t\n\tvar _iterator = __webpack_require__(32);\n\t\n\tvar _iterator2 = _interopRequireDefault(_iterator);\n\t\n\tvar _symbol = __webpack_require__(61);\n\t\n\tvar _symbol2 = _interopRequireDefault(_symbol);\n\t\n\tvar _typeof = typeof _symbol2.default === \"function\" && typeof _iterator2.default === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default ? \"symbol\" : typeof obj; };\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\texports.default = typeof _symbol2.default === \"function\" && _typeof(_iterator2.default) === \"symbol\" ? function (obj) {\n\t  return typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n\t} : function (obj) {\n\t  return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default ? \"symbol\" : typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n\t};\n\n/***/ },\n/* 32 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(33), __esModule: true };\n\n/***/ },\n/* 33 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(34);\n\t__webpack_require__(56);\n\tmodule.exports = __webpack_require__(60).f('iterator');\n\n/***/ },\n/* 34 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar $at  = __webpack_require__(35)(true);\n\t\n\t// 21.1.3.27 String.prototype[@@iterator]()\n\t__webpack_require__(37)(String, 'String', function(iterated){\n\t  this._t = String(iterated); // target\n\t  this._i = 0;                // next index\n\t// 21.1.5.2.1 %StringIteratorPrototype%.next()\n\t}, function(){\n\t  var O     = this._t\n\t    , index = this._i\n\t    , point;\n\t  if(index >= O.length)return {value: undefined, done: true};\n\t  point = $at(O, index);\n\t  this._i += point.length;\n\t  return {value: point, done: false};\n\t});\n\n/***/ },\n/* 35 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar toInteger = __webpack_require__(36)\n\t  , defined   = __webpack_require__(8);\n\t// true  -> String#at\n\t// false -> String#codePointAt\n\tmodule.exports = function(TO_STRING){\n\t  return function(that, pos){\n\t    var s = String(defined(that))\n\t      , i = toInteger(pos)\n\t      , l = s.length\n\t      , a, b;\n\t    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n\t    a = s.charCodeAt(i);\n\t    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n\t      ? TO_STRING ? s.charAt(i) : a\n\t      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n\t  };\n\t};\n\n/***/ },\n/* 36 */\n/***/ function(module, exports) {\n\n\t// 7.1.4 ToInteger\n\tvar ceil  = Math.ceil\n\t  , floor = Math.floor;\n\tmodule.exports = function(it){\n\t  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n\t};\n\n/***/ },\n/* 37 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar LIBRARY        = __webpack_require__(38)\n\t  , $export        = __webpack_require__(16)\n\t  , redefine       = __webpack_require__(39)\n\t  , hide           = __webpack_require__(20)\n\t  , has            = __webpack_require__(10)\n\t  , Iterators      = __webpack_require__(40)\n\t  , $iterCreate    = __webpack_require__(41)\n\t  , setToStringTag = __webpack_require__(54)\n\t  , getPrototypeOf = __webpack_require__(9)\n\t  , ITERATOR       = __webpack_require__(55)('iterator')\n\t  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n\t  , FF_ITERATOR    = '@@iterator'\n\t  , KEYS           = 'keys'\n\t  , VALUES         = 'values';\n\t\n\tvar returnThis = function(){ return this; };\n\t\n\tmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n\t  $iterCreate(Constructor, NAME, next);\n\t  var getMethod = function(kind){\n\t    if(!BUGGY && kind in proto)return proto[kind];\n\t    switch(kind){\n\t      case KEYS: return function keys(){ return new Constructor(this, kind); };\n\t      case VALUES: return function values(){ return new Constructor(this, kind); };\n\t    } return function entries(){ return new Constructor(this, kind); };\n\t  };\n\t  var TAG        = NAME + ' Iterator'\n\t    , DEF_VALUES = DEFAULT == VALUES\n\t    , VALUES_BUG = false\n\t    , proto      = Base.prototype\n\t    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n\t    , $default   = $native || getMethod(DEFAULT)\n\t    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n\t    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n\t    , methods, key, IteratorPrototype;\n\t  // Fix native\n\t  if($anyNative){\n\t    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n\t    if(IteratorPrototype !== Object.prototype){\n\t      // Set @@toStringTag to native iterators\n\t      setToStringTag(IteratorPrototype, TAG, true);\n\t      // fix for some old engines\n\t      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n\t    }\n\t  }\n\t  // fix Array#{values, @@iterator}.name in V8 / FF\n\t  if(DEF_VALUES && $native && $native.name !== VALUES){\n\t    VALUES_BUG = true;\n\t    $default = function values(){ return $native.call(this); };\n\t  }\n\t  // Define iterator\n\t  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n\t    hide(proto, ITERATOR, $default);\n\t  }\n\t  // Plug for library\n\t  Iterators[NAME] = $default;\n\t  Iterators[TAG]  = returnThis;\n\t  if(DEFAULT){\n\t    methods = {\n\t      values:  DEF_VALUES ? $default : getMethod(VALUES),\n\t      keys:    IS_SET     ? $default : getMethod(KEYS),\n\t      entries: $entries\n\t    };\n\t    if(FORCED)for(key in methods){\n\t      if(!(key in proto))redefine(proto, key, methods[key]);\n\t    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n\t  }\n\t  return methods;\n\t};\n\n/***/ },\n/* 38 */\n/***/ function(module, exports) {\n\n\tmodule.exports = true;\n\n/***/ },\n/* 39 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = __webpack_require__(20);\n\n/***/ },\n/* 40 */\n/***/ function(module, exports) {\n\n\tmodule.exports = {};\n\n/***/ },\n/* 41 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar create         = __webpack_require__(42)\n\t  , descriptor     = __webpack_require__(29)\n\t  , setToStringTag = __webpack_require__(54)\n\t  , IteratorPrototype = {};\n\t\n\t// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\n\t__webpack_require__(20)(IteratorPrototype, __webpack_require__(55)('iterator'), function(){ return this; });\n\t\n\tmodule.exports = function(Constructor, NAME, next){\n\t  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n\t  setToStringTag(Constructor, NAME + ' Iterator');\n\t};\n\n/***/ },\n/* 42 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\n\tvar anObject    = __webpack_require__(22)\n\t  , dPs         = __webpack_require__(43)\n\t  , enumBugKeys = __webpack_require__(52)\n\t  , IE_PROTO    = __webpack_require__(11)('IE_PROTO')\n\t  , Empty       = function(){ /* empty */ }\n\t  , PROTOTYPE   = 'prototype';\n\t\n\t// Create object with fake `null` prototype: use iframe Object with cleared prototype\n\tvar createDict = function(){\n\t  // Thrash, waste and sodomy: IE GC bug\n\t  var iframe = __webpack_require__(27)('iframe')\n\t    , i      = enumBugKeys.length\n\t    , lt     = '<'\n\t    , gt     = '>'\n\t    , iframeDocument;\n\t  iframe.style.display = 'none';\n\t  __webpack_require__(53).appendChild(iframe);\n\t  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n\t  // createDict = iframe.contentWindow.Object;\n\t  // html.removeChild(iframe);\n\t  iframeDocument = iframe.contentWindow.document;\n\t  iframeDocument.open();\n\t  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n\t  iframeDocument.close();\n\t  createDict = iframeDocument.F;\n\t  while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\n\t  return createDict();\n\t};\n\t\n\tmodule.exports = Object.create || function create(O, Properties){\n\t  var result;\n\t  if(O !== null){\n\t    Empty[PROTOTYPE] = anObject(O);\n\t    result = new Empty;\n\t    Empty[PROTOTYPE] = null;\n\t    // add \"__proto__\" for Object.getPrototypeOf polyfill\n\t    result[IE_PROTO] = O;\n\t  } else result = createDict();\n\t  return Properties === undefined ? result : dPs(result, Properties);\n\t};\n\n\n/***/ },\n/* 43 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar dP       = __webpack_require__(21)\n\t  , anObject = __webpack_require__(22)\n\t  , getKeys  = __webpack_require__(44);\n\t\n\tmodule.exports = __webpack_require__(25) ? Object.defineProperties : function defineProperties(O, Properties){\n\t  anObject(O);\n\t  var keys   = getKeys(Properties)\n\t    , length = keys.length\n\t    , i = 0\n\t    , P;\n\t  while(length > i)dP.f(O, P = keys[i++], Properties[P]);\n\t  return O;\n\t};\n\n/***/ },\n/* 44 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 19.1.2.14 / 15.2.3.14 Object.keys(O)\n\tvar $keys       = __webpack_require__(45)\n\t  , enumBugKeys = __webpack_require__(52);\n\t\n\tmodule.exports = Object.keys || function keys(O){\n\t  return $keys(O, enumBugKeys);\n\t};\n\n/***/ },\n/* 45 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar has          = __webpack_require__(10)\n\t  , toIObject    = __webpack_require__(46)\n\t  , arrayIndexOf = __webpack_require__(49)(false)\n\t  , IE_PROTO     = __webpack_require__(11)('IE_PROTO');\n\t\n\tmodule.exports = function(object, names){\n\t  var O      = toIObject(object)\n\t    , i      = 0\n\t    , result = []\n\t    , key;\n\t  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\n\t  // Don't enum bug & hidden keys\n\t  while(names.length > i)if(has(O, key = names[i++])){\n\t    ~arrayIndexOf(result, key) || result.push(key);\n\t  }\n\t  return result;\n\t};\n\n/***/ },\n/* 46 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// to indexed object, toObject with fallback for non-array-like ES3 strings\n\tvar IObject = __webpack_require__(47)\n\t  , defined = __webpack_require__(8);\n\tmodule.exports = function(it){\n\t  return IObject(defined(it));\n\t};\n\n/***/ },\n/* 47 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// fallback for non-array-like ES3 and non-enumerable old V8 strings\n\tvar cof = __webpack_require__(48);\n\tmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n\t  return cof(it) == 'String' ? it.split('') : Object(it);\n\t};\n\n/***/ },\n/* 48 */\n/***/ function(module, exports) {\n\n\tvar toString = {}.toString;\n\t\n\tmodule.exports = function(it){\n\t  return toString.call(it).slice(8, -1);\n\t};\n\n/***/ },\n/* 49 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// false -> Array#indexOf\n\t// true  -> Array#includes\n\tvar toIObject = __webpack_require__(46)\n\t  , toLength  = __webpack_require__(50)\n\t  , toIndex   = __webpack_require__(51);\n\tmodule.exports = function(IS_INCLUDES){\n\t  return function($this, el, fromIndex){\n\t    var O      = toIObject($this)\n\t      , length = toLength(O.length)\n\t      , index  = toIndex(fromIndex, length)\n\t      , value;\n\t    // Array#includes uses SameValueZero equality algorithm\n\t    if(IS_INCLUDES && el != el)while(length > index){\n\t      value = O[index++];\n\t      if(value != value)return true;\n\t    // Array#toIndex ignores holes, Array#includes - not\n\t    } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n\t      if(O[index] === el)return IS_INCLUDES || index || 0;\n\t    } return !IS_INCLUDES && -1;\n\t  };\n\t};\n\n/***/ },\n/* 50 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 7.1.15 ToLength\n\tvar toInteger = __webpack_require__(36)\n\t  , min       = Math.min;\n\tmodule.exports = function(it){\n\t  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n\t};\n\n/***/ },\n/* 51 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar toInteger = __webpack_require__(36)\n\t  , max       = Math.max\n\t  , min       = Math.min;\n\tmodule.exports = function(index, length){\n\t  index = toInteger(index);\n\t  return index < 0 ? max(index + length, 0) : min(index, length);\n\t};\n\n/***/ },\n/* 52 */\n/***/ function(module, exports) {\n\n\t// IE 8- don't enum bug keys\n\tmodule.exports = (\n\t  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n\t).split(',');\n\n/***/ },\n/* 53 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = __webpack_require__(13).document && document.documentElement;\n\n/***/ },\n/* 54 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar def = __webpack_require__(21).f\n\t  , has = __webpack_require__(10)\n\t  , TAG = __webpack_require__(55)('toStringTag');\n\t\n\tmodule.exports = function(it, tag, stat){\n\t  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n\t};\n\n/***/ },\n/* 55 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar store      = __webpack_require__(12)('wks')\n\t  , uid        = __webpack_require__(14)\n\t  , Symbol     = __webpack_require__(13).Symbol\n\t  , USE_SYMBOL = typeof Symbol == 'function';\n\t\n\tvar $exports = module.exports = function(name){\n\t  return store[name] || (store[name] =\n\t    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n\t};\n\t\n\t$exports.store = store;\n\n/***/ },\n/* 56 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(57);\n\tvar global        = __webpack_require__(13)\n\t  , hide          = __webpack_require__(20)\n\t  , Iterators     = __webpack_require__(40)\n\t  , TO_STRING_TAG = __webpack_require__(55)('toStringTag');\n\t\n\tfor(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){\n\t  var NAME       = collections[i]\n\t    , Collection = global[NAME]\n\t    , proto      = Collection && Collection.prototype;\n\t  if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);\n\t  Iterators[NAME] = Iterators.Array;\n\t}\n\n/***/ },\n/* 57 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar addToUnscopables = __webpack_require__(58)\n\t  , step             = __webpack_require__(59)\n\t  , Iterators        = __webpack_require__(40)\n\t  , toIObject        = __webpack_require__(46);\n\t\n\t// 22.1.3.4 Array.prototype.entries()\n\t// 22.1.3.13 Array.prototype.keys()\n\t// 22.1.3.29 Array.prototype.values()\n\t// 22.1.3.30 Array.prototype[@@iterator]()\n\tmodule.exports = __webpack_require__(37)(Array, 'Array', function(iterated, kind){\n\t  this._t = toIObject(iterated); // target\n\t  this._i = 0;                   // next index\n\t  this._k = kind;                // kind\n\t// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n\t}, function(){\n\t  var O     = this._t\n\t    , kind  = this._k\n\t    , index = this._i++;\n\t  if(!O || index >= O.length){\n\t    this._t = undefined;\n\t    return step(1);\n\t  }\n\t  if(kind == 'keys'  )return step(0, index);\n\t  if(kind == 'values')return step(0, O[index]);\n\t  return step(0, [index, O[index]]);\n\t}, 'values');\n\t\n\t// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\n\tIterators.Arguments = Iterators.Array;\n\t\n\taddToUnscopables('keys');\n\taddToUnscopables('values');\n\taddToUnscopables('entries');\n\n/***/ },\n/* 58 */\n/***/ function(module, exports) {\n\n\tmodule.exports = function(){ /* empty */ };\n\n/***/ },\n/* 59 */\n/***/ function(module, exports) {\n\n\tmodule.exports = function(done, value){\n\t  return {value: value, done: !!done};\n\t};\n\n/***/ },\n/* 60 */\n/***/ function(module, exports, __webpack_require__) {\n\n\texports.f = __webpack_require__(55);\n\n/***/ },\n/* 61 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(62), __esModule: true };\n\n/***/ },\n/* 62 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(63);\n\t__webpack_require__(74);\n\t__webpack_require__(75);\n\t__webpack_require__(76);\n\tmodule.exports = __webpack_require__(17).Symbol;\n\n/***/ },\n/* 63 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t// ECMAScript 6 symbols shim\n\tvar global         = __webpack_require__(13)\n\t  , has            = __webpack_require__(10)\n\t  , DESCRIPTORS    = __webpack_require__(25)\n\t  , $export        = __webpack_require__(16)\n\t  , redefine       = __webpack_require__(39)\n\t  , META           = __webpack_require__(64).KEY\n\t  , $fails         = __webpack_require__(26)\n\t  , shared         = __webpack_require__(12)\n\t  , setToStringTag = __webpack_require__(54)\n\t  , uid            = __webpack_require__(14)\n\t  , wks            = __webpack_require__(55)\n\t  , wksExt         = __webpack_require__(60)\n\t  , wksDefine      = __webpack_require__(65)\n\t  , keyOf          = __webpack_require__(66)\n\t  , enumKeys       = __webpack_require__(67)\n\t  , isArray        = __webpack_require__(70)\n\t  , anObject       = __webpack_require__(22)\n\t  , toIObject      = __webpack_require__(46)\n\t  , toPrimitive    = __webpack_require__(28)\n\t  , createDesc     = __webpack_require__(29)\n\t  , _create        = __webpack_require__(42)\n\t  , gOPNExt        = __webpack_require__(71)\n\t  , $GOPD          = __webpack_require__(73)\n\t  , $DP            = __webpack_require__(21)\n\t  , $keys          = __webpack_require__(44)\n\t  , gOPD           = $GOPD.f\n\t  , dP             = $DP.f\n\t  , gOPN           = gOPNExt.f\n\t  , $Symbol        = global.Symbol\n\t  , $JSON          = global.JSON\n\t  , _stringify     = $JSON && $JSON.stringify\n\t  , PROTOTYPE      = 'prototype'\n\t  , HIDDEN         = wks('_hidden')\n\t  , TO_PRIMITIVE   = wks('toPrimitive')\n\t  , isEnum         = {}.propertyIsEnumerable\n\t  , SymbolRegistry = shared('symbol-registry')\n\t  , AllSymbols     = shared('symbols')\n\t  , OPSymbols      = shared('op-symbols')\n\t  , ObjectProto    = Object[PROTOTYPE]\n\t  , USE_NATIVE     = typeof $Symbol == 'function'\n\t  , QObject        = global.QObject;\n\t// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\n\tvar setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\t\n\t// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\n\tvar setSymbolDesc = DESCRIPTORS && $fails(function(){\n\t  return _create(dP({}, 'a', {\n\t    get: function(){ return dP(this, 'a', {value: 7}).a; }\n\t  })).a != 7;\n\t}) ? function(it, key, D){\n\t  var protoDesc = gOPD(ObjectProto, key);\n\t  if(protoDesc)delete ObjectProto[key];\n\t  dP(it, key, D);\n\t  if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc);\n\t} : dP;\n\t\n\tvar wrap = function(tag){\n\t  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);\n\t  sym._k = tag;\n\t  return sym;\n\t};\n\t\n\tvar isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){\n\t  return typeof it == 'symbol';\n\t} : function(it){\n\t  return it instanceof $Symbol;\n\t};\n\t\n\tvar $defineProperty = function defineProperty(it, key, D){\n\t  if(it === ObjectProto)$defineProperty(OPSymbols, key, D);\n\t  anObject(it);\n\t  key = toPrimitive(key, true);\n\t  anObject(D);\n\t  if(has(AllSymbols, key)){\n\t    if(!D.enumerable){\n\t      if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {}));\n\t      it[HIDDEN][key] = true;\n\t    } else {\n\t      if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;\n\t      D = _create(D, {enumerable: createDesc(0, false)});\n\t    } return setSymbolDesc(it, key, D);\n\t  } return dP(it, key, D);\n\t};\n\tvar $defineProperties = function defineProperties(it, P){\n\t  anObject(it);\n\t  var keys = enumKeys(P = toIObject(P))\n\t    , i    = 0\n\t    , l = keys.length\n\t    , key;\n\t  while(l > i)$defineProperty(it, key = keys[i++], P[key]);\n\t  return it;\n\t};\n\tvar $create = function create(it, P){\n\t  return P === undefined ? _create(it) : $defineProperties(_create(it), P);\n\t};\n\tvar $propertyIsEnumerable = function propertyIsEnumerable(key){\n\t  var E = isEnum.call(this, key = toPrimitive(key, true));\n\t  if(this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return false;\n\t  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;\n\t};\n\tvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){\n\t  it  = toIObject(it);\n\t  key = toPrimitive(key, true);\n\t  if(it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return;\n\t  var D = gOPD(it, key);\n\t  if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;\n\t  return D;\n\t};\n\tvar $getOwnPropertyNames = function getOwnPropertyNames(it){\n\t  var names  = gOPN(toIObject(it))\n\t    , result = []\n\t    , i      = 0\n\t    , key;\n\t  while(names.length > i){\n\t    if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key);\n\t  } return result;\n\t};\n\tvar $getOwnPropertySymbols = function getOwnPropertySymbols(it){\n\t  var IS_OP  = it === ObjectProto\n\t    , names  = gOPN(IS_OP ? OPSymbols : toIObject(it))\n\t    , result = []\n\t    , i      = 0\n\t    , key;\n\t  while(names.length > i){\n\t    if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]);\n\t  } return result;\n\t};\n\t\n\t// 19.4.1.1 Symbol([description])\n\tif(!USE_NATIVE){\n\t  $Symbol = function Symbol(){\n\t    if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!');\n\t    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);\n\t    var $set = function(value){\n\t      if(this === ObjectProto)$set.call(OPSymbols, value);\n\t      if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;\n\t      setSymbolDesc(this, tag, createDesc(1, value));\n\t    };\n\t    if(DESCRIPTORS && setter)setSymbolDesc(ObjectProto, tag, {configurable: true, set: $set});\n\t    return wrap(tag);\n\t  };\n\t  redefine($Symbol[PROTOTYPE], 'toString', function toString(){\n\t    return this._k;\n\t  });\n\t\n\t  $GOPD.f = $getOwnPropertyDescriptor;\n\t  $DP.f   = $defineProperty;\n\t  __webpack_require__(72).f = gOPNExt.f = $getOwnPropertyNames;\n\t  __webpack_require__(69).f  = $propertyIsEnumerable;\n\t  __webpack_require__(68).f = $getOwnPropertySymbols;\n\t\n\t  if(DESCRIPTORS && !__webpack_require__(38)){\n\t    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);\n\t  }\n\t\n\t  wksExt.f = function(name){\n\t    return wrap(wks(name));\n\t  }\n\t}\n\t\n\t$export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol});\n\t\n\tfor(var symbols = (\n\t  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14\n\t  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'\n\t).split(','), i = 0; symbols.length > i; )wks(symbols[i++]);\n\t\n\tfor(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]);\n\t\n\t$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {\n\t  // 19.4.2.1 Symbol.for(key)\n\t  'for': function(key){\n\t    return has(SymbolRegistry, key += '')\n\t      ? SymbolRegistry[key]\n\t      : SymbolRegistry[key] = $Symbol(key);\n\t  },\n\t  // 19.4.2.5 Symbol.keyFor(sym)\n\t  keyFor: function keyFor(key){\n\t    if(isSymbol(key))return keyOf(SymbolRegistry, key);\n\t    throw TypeError(key + ' is not a symbol!');\n\t  },\n\t  useSetter: function(){ setter = true; },\n\t  useSimple: function(){ setter = false; }\n\t});\n\t\n\t$export($export.S + $export.F * !USE_NATIVE, 'Object', {\n\t  // 19.1.2.2 Object.create(O [, Properties])\n\t  create: $create,\n\t  // 19.1.2.4 Object.defineProperty(O, P, Attributes)\n\t  defineProperty: $defineProperty,\n\t  // 19.1.2.3 Object.defineProperties(O, Properties)\n\t  defineProperties: $defineProperties,\n\t  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n\t  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,\n\t  // 19.1.2.7 Object.getOwnPropertyNames(O)\n\t  getOwnPropertyNames: $getOwnPropertyNames,\n\t  // 19.1.2.8 Object.getOwnPropertySymbols(O)\n\t  getOwnPropertySymbols: $getOwnPropertySymbols\n\t});\n\t\n\t// 24.3.2 JSON.stringify(value [, replacer [, space]])\n\t$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){\n\t  var S = $Symbol();\n\t  // MS Edge converts symbol values to JSON as {}\n\t  // WebKit converts symbol values to JSON as null\n\t  // V8 throws on boxed symbols\n\t  return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';\n\t})), 'JSON', {\n\t  stringify: function stringify(it){\n\t    if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined\n\t    var args = [it]\n\t      , i    = 1\n\t      , replacer, $replacer;\n\t    while(arguments.length > i)args.push(arguments[i++]);\n\t    replacer = args[1];\n\t    if(typeof replacer == 'function')$replacer = replacer;\n\t    if($replacer || !isArray(replacer))replacer = function(key, value){\n\t      if($replacer)value = $replacer.call(this, key, value);\n\t      if(!isSymbol(value))return value;\n\t    };\n\t    args[1] = replacer;\n\t    return _stringify.apply($JSON, args);\n\t  }\n\t});\n\t\n\t// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)\n\t$Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(20)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);\n\t// 19.4.3.5 Symbol.prototype[@@toStringTag]\n\tsetToStringTag($Symbol, 'Symbol');\n\t// 20.2.1.9 Math[@@toStringTag]\n\tsetToStringTag(Math, 'Math', true);\n\t// 24.3.3 JSON[@@toStringTag]\n\tsetToStringTag(global.JSON, 'JSON', true);\n\n/***/ },\n/* 64 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar META     = __webpack_require__(14)('meta')\n\t  , isObject = __webpack_require__(23)\n\t  , has      = __webpack_require__(10)\n\t  , setDesc  = __webpack_require__(21).f\n\t  , id       = 0;\n\tvar isExtensible = Object.isExtensible || function(){\n\t  return true;\n\t};\n\tvar FREEZE = !__webpack_require__(26)(function(){\n\t  return isExtensible(Object.preventExtensions({}));\n\t});\n\tvar setMeta = function(it){\n\t  setDesc(it, META, {value: {\n\t    i: 'O' + ++id, // object ID\n\t    w: {}          // weak collections IDs\n\t  }});\n\t};\n\tvar fastKey = function(it, create){\n\t  // return primitive with prefix\n\t  if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n\t  if(!has(it, META)){\n\t    // can't set metadata to uncaught frozen object\n\t    if(!isExtensible(it))return 'F';\n\t    // not necessary to add metadata\n\t    if(!create)return 'E';\n\t    // add missing metadata\n\t    setMeta(it);\n\t  // return object ID\n\t  } return it[META].i;\n\t};\n\tvar getWeak = function(it, create){\n\t  if(!has(it, META)){\n\t    // can't set metadata to uncaught frozen object\n\t    if(!isExtensible(it))return true;\n\t    // not necessary to add metadata\n\t    if(!create)return false;\n\t    // add missing metadata\n\t    setMeta(it);\n\t  // return hash weak collections IDs\n\t  } return it[META].w;\n\t};\n\t// add metadata on freeze-family methods calling\n\tvar onFreeze = function(it){\n\t  if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it);\n\t  return it;\n\t};\n\tvar meta = module.exports = {\n\t  KEY:      META,\n\t  NEED:     false,\n\t  fastKey:  fastKey,\n\t  getWeak:  getWeak,\n\t  onFreeze: onFreeze\n\t};\n\n/***/ },\n/* 65 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar global         = __webpack_require__(13)\n\t  , core           = __webpack_require__(17)\n\t  , LIBRARY        = __webpack_require__(38)\n\t  , wksExt         = __webpack_require__(60)\n\t  , defineProperty = __webpack_require__(21).f;\n\tmodule.exports = function(name){\n\t  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});\n\t  if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)});\n\t};\n\n/***/ },\n/* 66 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar getKeys   = __webpack_require__(44)\n\t  , toIObject = __webpack_require__(46);\n\tmodule.exports = function(object, el){\n\t  var O      = toIObject(object)\n\t    , keys   = getKeys(O)\n\t    , length = keys.length\n\t    , index  = 0\n\t    , key;\n\t  while(length > index)if(O[key = keys[index++]] === el)return key;\n\t};\n\n/***/ },\n/* 67 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// all enumerable object keys, includes symbols\n\tvar getKeys = __webpack_require__(44)\n\t  , gOPS    = __webpack_require__(68)\n\t  , pIE     = __webpack_require__(69);\n\tmodule.exports = function(it){\n\t  var result     = getKeys(it)\n\t    , getSymbols = gOPS.f;\n\t  if(getSymbols){\n\t    var symbols = getSymbols(it)\n\t      , isEnum  = pIE.f\n\t      , i       = 0\n\t      , key;\n\t    while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key);\n\t  } return result;\n\t};\n\n/***/ },\n/* 68 */\n/***/ function(module, exports) {\n\n\texports.f = Object.getOwnPropertySymbols;\n\n/***/ },\n/* 69 */\n/***/ function(module, exports) {\n\n\texports.f = {}.propertyIsEnumerable;\n\n/***/ },\n/* 70 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 7.2.2 IsArray(argument)\n\tvar cof = __webpack_require__(48);\n\tmodule.exports = Array.isArray || function isArray(arg){\n\t  return cof(arg) == 'Array';\n\t};\n\n/***/ },\n/* 71 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\n\tvar toIObject = __webpack_require__(46)\n\t  , gOPN      = __webpack_require__(72).f\n\t  , toString  = {}.toString;\n\t\n\tvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n\t  ? Object.getOwnPropertyNames(window) : [];\n\t\n\tvar getWindowNames = function(it){\n\t  try {\n\t    return gOPN(it);\n\t  } catch(e){\n\t    return windowNames.slice();\n\t  }\n\t};\n\t\n\tmodule.exports.f = function getOwnPropertyNames(it){\n\t  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));\n\t};\n\n\n/***/ },\n/* 72 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)\n\tvar $keys      = __webpack_require__(45)\n\t  , hiddenKeys = __webpack_require__(52).concat('length', 'prototype');\n\t\n\texports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){\n\t  return $keys(O, hiddenKeys);\n\t};\n\n/***/ },\n/* 73 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar pIE            = __webpack_require__(69)\n\t  , createDesc     = __webpack_require__(29)\n\t  , toIObject      = __webpack_require__(46)\n\t  , toPrimitive    = __webpack_require__(28)\n\t  , has            = __webpack_require__(10)\n\t  , IE8_DOM_DEFINE = __webpack_require__(24)\n\t  , gOPD           = Object.getOwnPropertyDescriptor;\n\t\n\texports.f = __webpack_require__(25) ? gOPD : function getOwnPropertyDescriptor(O, P){\n\t  O = toIObject(O);\n\t  P = toPrimitive(P, true);\n\t  if(IE8_DOM_DEFINE)try {\n\t    return gOPD(O, P);\n\t  } catch(e){ /* empty */ }\n\t  if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);\n\t};\n\n/***/ },\n/* 74 */\n/***/ function(module, exports) {\n\n\n\n/***/ },\n/* 75 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(65)('asyncIterator');\n\n/***/ },\n/* 76 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(65)('observable');\n\n/***/ },\n/* 77 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\texports.__esModule = true;\n\t\n\tvar _setPrototypeOf = __webpack_require__(78);\n\t\n\tvar _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);\n\t\n\tvar _create = __webpack_require__(82);\n\t\n\tvar _create2 = _interopRequireDefault(_create);\n\t\n\tvar _typeof2 = __webpack_require__(31);\n\t\n\tvar _typeof3 = _interopRequireDefault(_typeof2);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\texports.default = function (subClass, superClass) {\n\t  if (typeof superClass !== \"function\" && superClass !== null) {\n\t    throw new TypeError(\"Super expression must either be null or a function, not \" + (typeof superClass === \"undefined\" ? \"undefined\" : (0, _typeof3.default)(superClass)));\n\t  }\n\t\n\t  subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, {\n\t    constructor: {\n\t      value: subClass,\n\t      enumerable: false,\n\t      writable: true,\n\t      configurable: true\n\t    }\n\t  });\n\t  if (superClass) _setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass;\n\t};\n\n/***/ },\n/* 78 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(79), __esModule: true };\n\n/***/ },\n/* 79 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(80);\n\tmodule.exports = __webpack_require__(17).Object.setPrototypeOf;\n\n/***/ },\n/* 80 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 19.1.3.19 Object.setPrototypeOf(O, proto)\n\tvar $export = __webpack_require__(16);\n\t$export($export.S, 'Object', {setPrototypeOf: __webpack_require__(81).set});\n\n/***/ },\n/* 81 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// Works with __proto__ only. Old v8 can't work with null proto objects.\n\t/* eslint-disable no-proto */\n\tvar isObject = __webpack_require__(23)\n\t  , anObject = __webpack_require__(22);\n\tvar check = function(O, proto){\n\t  anObject(O);\n\t  if(!isObject(proto) && proto !== null)throw TypeError(proto + \": can't set as prototype!\");\n\t};\n\tmodule.exports = {\n\t  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line\n\t    function(test, buggy, set){\n\t      try {\n\t        set = __webpack_require__(18)(Function.call, __webpack_require__(73).f(Object.prototype, '__proto__').set, 2);\n\t        set(test, []);\n\t        buggy = !(test instanceof Array);\n\t      } catch(e){ buggy = true; }\n\t      return function setPrototypeOf(O, proto){\n\t        check(O, proto);\n\t        if(buggy)O.__proto__ = proto;\n\t        else set(O, proto);\n\t        return O;\n\t      };\n\t    }({}, false) : undefined),\n\t  check: check\n\t};\n\n/***/ },\n/* 82 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(83), __esModule: true };\n\n/***/ },\n/* 83 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(84);\n\tvar $Object = __webpack_require__(17).Object;\n\tmodule.exports = function create(P, D){\n\t  return $Object.create(P, D);\n\t};\n\n/***/ },\n/* 84 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar $export = __webpack_require__(16)\n\t// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\n\t$export($export.S, 'Object', {create: __webpack_require__(42)});\n\n/***/ },\n/* 85 */\n/***/ function(module, exports) {\n\n\t\"use strict\";\n\t\n\texports.__esModule = true;\n\t\n\texports.default = function (instance, Constructor) {\n\t  if (!(instance instanceof Constructor)) {\n\t    throw new TypeError(\"Cannot call a class as a function\");\n\t  }\n\t};\n\n/***/ },\n/* 86 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\texports.__esModule = true;\n\t\n\tvar _defineProperty = __webpack_require__(87);\n\t\n\tvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\texports.default = function () {\n\t  function defineProperties(target, props) {\n\t    for (var i = 0; i < props.length; i++) {\n\t      var descriptor = props[i];\n\t      descriptor.enumerable = descriptor.enumerable || false;\n\t      descriptor.configurable = true;\n\t      if (\"value\" in descriptor) descriptor.writable = true;\n\t      (0, _defineProperty2.default)(target, descriptor.key, descriptor);\n\t    }\n\t  }\n\t\n\t  return function (Constructor, protoProps, staticProps) {\n\t    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n\t    if (staticProps) defineProperties(Constructor, staticProps);\n\t    return Constructor;\n\t  };\n\t}();\n\n/***/ },\n/* 87 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(88), __esModule: true };\n\n/***/ },\n/* 88 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(89);\n\tvar $Object = __webpack_require__(17).Object;\n\tmodule.exports = function defineProperty(it, key, desc){\n\t  return $Object.defineProperty(it, key, desc);\n\t};\n\n/***/ },\n/* 89 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar $export = __webpack_require__(16);\n\t// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n\t$export($export.S + $export.F * !__webpack_require__(25), 'Object', {defineProperty: __webpack_require__(21).f});\n\n/***/ },\n/* 90 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t\tif (true) {\n\t\t\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(4), __webpack_require__(85), __webpack_require__(86), __webpack_require__(30), __webpack_require__(77), __webpack_require__(91)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\t} else if (typeof exports !== \"undefined\") {\n\t\t\tfactory(exports, require('babel-runtime/core-js/object/get-prototype-of'), require('babel-runtime/helpers/classCallCheck'), require('babel-runtime/helpers/createClass'), require('babel-runtime/helpers/possibleConstructorReturn'), require('babel-runtime/helpers/inherits'), require('./core'));\n\t\t} else {\n\t\t\tvar mod = {\n\t\t\t\texports: {}\n\t\t\t};\n\t\t\tfactory(mod.exports, global.getPrototypeOf, global.classCallCheck, global.createClass, global.possibleConstructorReturn, global.inherits, global.core);\n\t\t\tglobal.authentications = mod.exports;\n\t\t}\n\t})(this, function (exports, _getPrototypeOf, _classCallCheck2, _createClass2, _possibleConstructorReturn2, _inherits2, _core) {\n\t\t'use strict';\n\t\n\t\tObject.defineProperty(exports, \"__esModule\", {\n\t\t\tvalue: true\n\t\t});\n\t\texports.Weak = exports.Simple = exports.Delegating = undefined;\n\t\n\t\tvar _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);\n\t\n\t\tvar _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t\tvar _createClass3 = _interopRequireDefault(_createClass2);\n\t\n\t\tvar _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);\n\t\n\t\tvar _inherits3 = _interopRequireDefault(_inherits2);\n\t\n\t\tfunction _interopRequireDefault(obj) {\n\t\t\treturn obj && obj.__esModule ? obj : {\n\t\t\t\tdefault: obj\n\t\t\t};\n\t\t}\n\t\n\t\tvar Delegating = exports.Delegating = function (_Service) {\n\t\t\t(0, _inherits3.default)(Delegating, _Service);\n\t\n\t\t\tfunction Delegating() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Delegating);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Delegating.__proto__ || (0, _getPrototypeOf2.default)(Delegating)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Delegating, null, [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Delegating service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'delegating_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Delegating;\n\t\t}(_core.Service);\n\t\n\t\tvar Simple = exports.Simple = function (_Service2) {\n\t\t\t(0, _inherits3.default)(Simple, _Service2);\n\t\n\t\t\tfunction Simple() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Simple);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Simple.__proto__ || (0, _getPrototypeOf2.default)(Simple)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Simple, null, [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Simple service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'simple_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Simple;\n\t\t}(_core.Service);\n\t\n\t\tvar Weak = exports.Weak = function (_Service3) {\n\t\t\t(0, _inherits3.default)(Weak, _Service3);\n\t\n\t\t\tfunction Weak() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Weak);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Weak.__proto__ || (0, _getPrototypeOf2.default)(Weak)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Weak, [{\n\t\t\t\tkey: 'control',\n\t\n\t\t\t\t/**\n\t    * Controls a session\n\t    *\n\t    * Takes control of a weak user session, identified by the given public token.\n\t    * The public token has been previously made available by the controlled device, for example by displaying a QRCode.\n\t    * Upon control notification, the client SDK of the controlled session is expected to re-handshake.\n\t    * */\n\t\t\t\tvalue: function control(_ref) {\n\t\t\t\t\tvar fullRights = _ref.fullRights,\n\t\t\t\t\t    publicToken = _ref.publicToken;\n\t\t\t\t\treturn this.$publish('control', { fullRights: fullRights, publicToken: publicToken });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Releases a session\n\t    *\n\t    * Releases control of a weak user session, identified by the given public token.\n\t    * The weak user session must have been previously controlled by a call to 'control'.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'release',\n\t\t\t\tvalue: function release(_ref2) {\n\t\t\t\t\tvar fullRights = _ref2.fullRights,\n\t\t\t\t\t    publicToken = _ref2.publicToken;\n\t\t\t\t\treturn this.$publish('release', { fullRights: fullRights, publicToken: publicToken });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Weak service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'weak_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Weak;\n\t\t}(_core.Service);\n\t});\n\n/***/ },\n/* 91 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(85)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require(\"babel-runtime/helpers/classCallCheck\"));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.classCallCheck);\n\t    global.core = mod.exports;\n\t  }\n\t})(this, function (exports, _classCallCheck2) {\n\t  \"use strict\";\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.Service = undefined;\n\t\n\t  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  var Service = exports.Service = function Service(_ref) {\n\t    var $publish = _ref.$publish;\n\t    (0, _classCallCheck3.default)(this, Service);\n\t\n\t    this.$publish = $publish;\n\t  };\n\t});\n\n/***/ },\n/* 92 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(85), __webpack_require__(86)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require(\"babel-runtime/helpers/classCallCheck\"), require(\"babel-runtime/helpers/createClass\"));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.classCallCheck, global.createClass);\n\t    global.connectionStatus = mod.exports;\n\t  }\n\t})(this, function (exports, _classCallCheck2, _createClass2) {\n\t  \"use strict\";\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.ConnectionStatusListener = undefined;\n\t\n\t  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t  var _createClass3 = _interopRequireDefault(_createClass2);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  var ConnectionStatusListener = exports.ConnectionStatusListener = function () {\n\t    function ConnectionStatusListener() {\n\t      (0, _classCallCheck3.default)(this, ConnectionStatusListener);\n\t    }\n\t\n\t    (0, _createClass3.default)(ConnectionStatusListener, [{\n\t      key: \"onConnectionBroken\",\n\t\n\t      /**\n\t       * Callback fired when connection is broken\n\t       */\n\t      value: function onConnectionBroken() {}\n\t      /**\n\t       * Callback fired when connection is closed\n\t       */\n\t\n\t    }, {\n\t      key: \"onConnectionClosed\",\n\t      value: function onConnectionClosed() {}\n\t      /**\n\t       * Callback fired when connection is established\n\t       */\n\t\n\t    }, {\n\t      key: \"onConnectionEstablished\",\n\t      value: function onConnectionEstablished() {}\n\t      /**\n\t      * Callback fired when connection will close\n\t      */\n\t\n\t    }, {\n\t      key: \"onConnectionWillClose\",\n\t      value: function onConnectionWillClose() {}\n\t      /**\n\t       * Callback fired when an error occurs in handshake step\n\t       * @param {Object} failure\n\t       */\n\t\n\t    }, {\n\t      key: \"onFailedHandshake\",\n\t      value: function onFailedHandshake(failure) {}\n\t      /**\n\t       * Callback fired when a message is lost\n\t       */\n\t\n\t    }, {\n\t      key: \"onMessageLost\",\n\t      value: function onMessageLost() {}\n\t      /**\n\t       * Callback fired when handshake step succeed\n\t       * @param {Object} authentication\n\t       */\n\t\n\t    }, {\n\t      key: \"onSuccessfulHandshake\",\n\t      value: function onSuccessfulHandshake(authentication) {}\n\t    }]);\n\t    return ConnectionStatusListener;\n\t  }();\n\t});\n\n/***/ },\n/* 93 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(94), __webpack_require__(98)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('babel-runtime/core-js/object/assign'), require('zetapush-cometd'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.assign, global.zetapushCometd);\n\t    global.cometd = mod.exports;\n\t  }\n\t})(this, function (exports, _assign, _zetapushCometd) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.TransportLayers = exports.TransportTypes = undefined;\n\t  exports.FetchLongPollingTransport = FetchLongPollingTransport;\n\t\n\t  var _assign2 = _interopRequireDefault(_assign);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  /**\n\t   * Implements LongPollingTransport using borwser fetch() API\n\t   * @access private\n\t   * @return {FetchLongPollingTransport}\n\t   */\n\t  function FetchLongPollingTransport() {\n\t    var _super = new _zetapushCometd.LongPollingTransport();\n\t    var that = _zetapushCometd.Transport.derive(_super);\n\t\n\t    /**\n\t     * Implements transport via fetch() API\n\t     * @param {Object} packet\n\t     */\n\t    that.xhrSend = function (packet) {\n\t      fetch(packet.url, {\n\t        method: 'post',\n\t        body: packet.body,\n\t        headers: (0, _assign2.default)(packet.headers, {\n\t          'Content-Type': 'application/json;charset=UTF-8'\n\t        })\n\t      }).then(function (response) {\n\t        return response.json();\n\t      }).then(packet.onSuccess).catch(packet.onError);\n\t    };\n\t\n\t    return that;\n\t  }\n\t\n\t  /**\n\t   * CometD Transports enumeration\n\t   */\n\t  var TransportTypes = exports.TransportTypes = {\n\t    LONG_POLLING: 'long-polling',\n\t    WEBSOCKET: 'websocket'\n\t  };\n\t\n\t  /**\n\t   * CometD Transports Layers map\n\t   */\n\t  var TransportLayers = exports.TransportLayers = [{\n\t    type: TransportTypes.WEBSOCKET,\n\t    Transport: _zetapushCometd.WebSocketTransport\n\t  }, {\n\t    type: TransportTypes.LONG_POLLING,\n\t    Transport: FetchLongPollingTransport\n\t  }];\n\t});\n\n/***/ },\n/* 94 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(95), __esModule: true };\n\n/***/ },\n/* 95 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(96);\n\tmodule.exports = __webpack_require__(17).Object.assign;\n\n/***/ },\n/* 96 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 19.1.3.1 Object.assign(target, source)\n\tvar $export = __webpack_require__(16);\n\t\n\t$export($export.S + $export.F, 'Object', {assign: __webpack_require__(97)});\n\n/***/ },\n/* 97 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t// 19.1.2.1 Object.assign(target, source, ...)\n\tvar getKeys  = __webpack_require__(44)\n\t  , gOPS     = __webpack_require__(68)\n\t  , pIE      = __webpack_require__(69)\n\t  , toObject = __webpack_require__(7)\n\t  , IObject  = __webpack_require__(47)\n\t  , $assign  = Object.assign;\n\t\n\t// should work with symbols and should have deterministic property order (V8 bug)\n\tmodule.exports = !$assign || __webpack_require__(26)(function(){\n\t  var A = {}\n\t    , B = {}\n\t    , S = Symbol()\n\t    , K = 'abcdefghijklmnopqrst';\n\t  A[S] = 7;\n\t  K.split('').forEach(function(k){ B[k] = k; });\n\t  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n\t}) ? function assign(target, source){ // eslint-disable-line no-unused-vars\n\t  var T     = toObject(target)\n\t    , aLen  = arguments.length\n\t    , index = 1\n\t    , getSymbols = gOPS.f\n\t    , isEnum     = pIE.f;\n\t  while(aLen > index){\n\t    var S      = IObject(arguments[index++])\n\t      , keys   = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)\n\t      , length = keys.length\n\t      , j      = 0\n\t      , key;\n\t    while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];\n\t  } return T;\n\t} : $assign;\n\n/***/ },\n/* 98 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = {\n\t  CallbackPollingTransport: __webpack_require__(99),\n\t  CometD: __webpack_require__(103),\n\t  LongPollingTransport: __webpack_require__(105),\n\t  RequestTransport: __webpack_require__(102),\n\t  Transport: __webpack_require__(100),\n\t  TransportRegistry: __webpack_require__(104),\n\t  Utils: __webpack_require__(101),\n\t  WebSocketTransport: __webpack_require__(106)\n\t}\n\n\n/***/ },\n/* 99 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Transport = __webpack_require__(100);\n\tvar RequestTransport = __webpack_require__(102);\n\t\n\tmodule.exports = function CallbackPollingTransport() {\n\t    var _super = new RequestTransport();\n\t    var _self = Transport.derive(_super);\n\t\n\t    _self.accept = function(version, crossDomain, url) {\n\t        return true;\n\t    };\n\t\n\t    _self.jsonpSend = function(packet) {\n\t        throw 'Abstract';\n\t    };\n\t\n\t    function _failTransportFn(envelope, request, x) {\n\t        var self = this;\n\t        return function() {\n\t            self.transportFailure(envelope, request, 'error', x);\n\t        };\n\t    }\n\t\n\t    _self.transportSend = function(envelope, request) {\n\t        var self = this;\n\t\n\t        // Microsoft Internet Explorer has a 2083 URL max length\n\t        // We must ensure that we stay within that length\n\t        var start = 0;\n\t        var length = envelope.messages.length;\n\t        var lengths = [];\n\t        while (length > 0) {\n\t            // Encode the messages because all brackets, quotes, commas, colons, etc\n\t            // present in the JSON will be URL encoded, taking many more characters\n\t            var json = JSON.stringify(envelope.messages.slice(start, start + length));\n\t            var urlLength = envelope.url.length + encodeURI(json).length;\n\t\n\t            var maxLength = this.getConfiguration().maxURILength;\n\t            if (urlLength > maxLength) {\n\t                if (length === 1) {\n\t                    var x = 'Bayeux message too big (' + urlLength + ' bytes, max is ' + maxLength + ') ' +\n\t                        'for transport ' + this.getType();\n\t                    // Keep the semantic of calling response callbacks asynchronously after the request\n\t                    self.setTimeout(_failTransportFn.call(this, envelope, request, x), 0);\n\t                    return;\n\t                }\n\t\n\t                --length;\n\t                continue;\n\t            }\n\t\n\t            lengths.push(length);\n\t            start += length;\n\t            length = envelope.messages.length - start;\n\t        }\n\t\n\t        // Here we are sure that the messages can be sent within the URL limit\n\t\n\t        var envelopeToSend = envelope;\n\t        if (lengths.length > 1) {\n\t            var begin = 0;\n\t            var end = lengths[0];\n\t            this._debug('Transport', this.getType(), 'split', envelope.messages.length, 'messages into', lengths.join(' + '));\n\t            envelopeToSend = this._mixin(false, {}, envelope);\n\t            envelopeToSend.messages = envelope.messages.slice(begin, end);\n\t            envelopeToSend.onSuccess = envelope.onSuccess;\n\t            envelopeToSend.onFailure = envelope.onFailure;\n\t\n\t            for (var i = 1; i < lengths.length; ++i) {\n\t                var nextEnvelope = this._mixin(false, {}, envelope);\n\t                begin = end;\n\t                end += lengths[i];\n\t                nextEnvelope.messages = envelope.messages.slice(begin, end);\n\t                nextEnvelope.onSuccess = envelope.onSuccess;\n\t                nextEnvelope.onFailure = envelope.onFailure;\n\t                this.send(nextEnvelope, request.metaConnect);\n\t            }\n\t        }\n\t\n\t        this._debug('Transport', this.getType(), 'sending request', request.id, 'envelope', envelopeToSend);\n\t\n\t        try {\n\t            var sameStack = true;\n\t            this.jsonpSend({\n\t                transport: this,\n\t                url: envelopeToSend.url,\n\t                sync: envelopeToSend.sync,\n\t                headers: this.getConfiguration().requestHeaders,\n\t                body: JSON.stringify(envelopeToSend.messages),\n\t                onSuccess: function(responses) {\n\t                    var success = false;\n\t                    try {\n\t                        var received = self.convertToMessages(responses);\n\t                        if (received.length === 0) {\n\t                            self.transportFailure(envelopeToSend, request, {\n\t                                httpCode: 204\n\t                            });\n\t                        } else {\n\t                            success = true;\n\t                            self.transportSuccess(envelopeToSend, request, received);\n\t                        }\n\t                    } catch (x) {\n\t                        self._debug(x);\n\t                        if (!success) {\n\t                            self.transportFailure(envelopeToSend, request, {\n\t                                exception: x\n\t                            });\n\t                        }\n\t                    }\n\t                },\n\t                onError: function(reason, exception) {\n\t                    var failure = {\n\t                        reason: reason,\n\t                        exception: exception\n\t                    };\n\t                    if (sameStack) {\n\t                        // Keep the semantic of calling response callbacks asynchronously after the request\n\t                        self.setTimeout(function() {\n\t                            self.transportFailure(envelopeToSend, request, failure);\n\t                        }, 0);\n\t                    } else {\n\t                        self.transportFailure(envelopeToSend, request, failure);\n\t                    }\n\t                }\n\t            });\n\t            sameStack = false;\n\t        } catch (xx) {\n\t            // Keep the semantic of calling response callbacks asynchronously after the request\n\t            self.setTimeout(function() {\n\t                self.transportFailure(envelopeToSend, request, {\n\t                    exception: xx\n\t                });\n\t            }, 0);\n\t        }\n\t    };\n\t\n\t    return _self;\n\t};\n\n\n/***/ },\n/* 100 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Utils = __webpack_require__(101)\n\t\n\t/**\n\t * Base object with the common functionality for transports.\n\t */\n\tmodule.exports = function Transport() {\n\t    var _type;\n\t    var _cometd;\n\t    var _url;\n\t\n\t    /**\n\t     * Function invoked just after a transport has been successfully registered.\n\t     * @param type the type of transport (for example 'long-polling')\n\t     * @param cometd the cometd object this transport has been registered to\n\t     * @see #unregistered()\n\t     */\n\t    this.registered = function(type, cometd) {\n\t        _type = type;\n\t        _cometd = cometd;\n\t    };\n\t\n\t    /**\n\t     * Function invoked just after a transport has been successfully unregistered.\n\t     * @see #registered(type, cometd)\n\t     */\n\t    this.unregistered = function() {\n\t        _type = null;\n\t        _cometd = null;\n\t    };\n\t\n\t    this._debug = function() {\n\t        _cometd._debug.apply(_cometd, arguments);\n\t    };\n\t\n\t    this._mixin = function() {\n\t        return _cometd._mixin.apply(_cometd, arguments);\n\t    };\n\t\n\t    this.getConfiguration = function() {\n\t        return _cometd.getConfiguration();\n\t    };\n\t\n\t    this.getAdvice = function() {\n\t        return _cometd.getAdvice();\n\t    };\n\t\n\t    this.setTimeout = function(funktion, delay) {\n\t        return Utils.setTimeout(_cometd, funktion, delay);\n\t    };\n\t\n\t    this.clearTimeout = function(handle) {\n\t        Utils.clearTimeout(handle);\n\t    };\n\t\n\t    /**\n\t     * Converts the given response into an array of bayeux messages\n\t     * @param response the response to convert\n\t     * @return an array of bayeux messages obtained by converting the response\n\t     */\n\t    this.convertToMessages = function(response) {\n\t        if (Utils.isString(response)) {\n\t            try {\n\t                return JSON.parse(response);\n\t            } catch (x) {\n\t                this._debug('Could not convert to JSON the following string', '\"' + response + '\"');\n\t                throw x;\n\t            }\n\t        }\n\t        if (Utils.isArray(response)) {\n\t            return response;\n\t        }\n\t        if (response === undefined || response === null) {\n\t            return [];\n\t        }\n\t        if (response instanceof Object) {\n\t            return [response];\n\t        }\n\t        throw 'Conversion Error ' + response + ', typeof ' + (typeof response);\n\t    };\n\t\n\t    /**\n\t     * Returns whether this transport can work for the given version and cross domain communication case.\n\t     * @param version a string indicating the transport version\n\t     * @param crossDomain a boolean indicating whether the communication is cross domain\n\t     * @param url the URL to connect to\n\t     * @return true if this transport can work for the given version and cross domain communication case,\n\t     * false otherwise\n\t     */\n\t    this.accept = function(version, crossDomain, url) {\n\t        throw 'Abstract';\n\t    };\n\t\n\t    /**\n\t     * Returns the type of this transport.\n\t     * @see #registered(type, cometd)\n\t     */\n\t    this.getType = function() {\n\t        return _type;\n\t    };\n\t\n\t    this.getURL = function() {\n\t        return _url;\n\t    };\n\t\n\t    this.setURL = function(url) {\n\t        _url = url;\n\t    };\n\t\n\t    this.send = function(envelope, metaConnect) {\n\t        throw 'Abstract';\n\t    };\n\t\n\t    this.reset = function(init) {\n\t        this._debug('Transport', _type, 'reset', init ? 'initial' : 'retry');\n\t    };\n\t\n\t    this.abort = function() {\n\t        this._debug('Transport', _type, 'aborted');\n\t    };\n\t\n\t    this.toString = function() {\n\t        return this.getType();\n\t    };\n\t};\n\t\n\tmodule.exports.derive = function(baseObject) {\n\t    function F() {\n\t    }\n\t\n\t    F.prototype = baseObject;\n\t    return new F();\n\t};\n\n\n/***/ },\n/* 101 */\n/***/ function(module, exports) {\n\n\texports.isString = function (value) {\n\t    if (value === undefined || value === null) {\n\t        return false;\n\t    }\n\t    return typeof value === 'string' || value instanceof String;\n\t};\n\t\n\texports.isArray = function (value) {\n\t    if (value === undefined || value === null) {\n\t        return false;\n\t    }\n\t    return value instanceof Array;\n\t};\n\t\n\t/**\n\t * Returns whether the given element is contained into the given array.\n\t * @param element the element to check presence for\n\t * @param array the array to check for the element presence\n\t * @return the index of the element, if present, or a negative index if the element is not present\n\t */\n\texports.inArray = function (element, array) {\n\t    for (var i = 0; i < array.length; ++i) {\n\t        if (element === array[i]) {\n\t            return i;\n\t        }\n\t    }\n\t    return -1;\n\t};\n\t\n\texports.setTimeout = function (cometd, funktion, delay) {\n\t    return setTimeout(function() {\n\t        try {\n\t            cometd._debug('Invoking timed function', funktion);\n\t            funktion();\n\t        } catch (x) {\n\t            cometd._debug('Exception invoking timed function', funktion, x);\n\t        }\n\t    }, delay);\n\t};\n\t\n\texports.clearTimeout = function (timeoutHandle) {\n\t    clearTimeout(timeoutHandle);\n\t};\n\n\n/***/ },\n/* 102 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Transport = __webpack_require__(100)\n\tvar Utils = __webpack_require__(101)\n\t\n\t/**\n\t * Base object with the common functionality for transports based on requests.\n\t * The key responsibility is to allow at most 2 outstanding requests to the server,\n\t * to avoid that requests are sent behind a long poll.\n\t * To achieve this, we have one reserved request for the long poll, and all other\n\t * requests are serialized one after the other.\n\t */\n\tmodule.exports = function RequestTransport() {\n\t    var _super = new Transport();\n\t    var _self = Transport.derive(_super);\n\t    var _requestIds = 0;\n\t    var _metaConnectRequest = null;\n\t    var _requests = [];\n\t    var _envelopes = [];\n\t\n\t    function _coalesceEnvelopes(envelope) {\n\t        while (_envelopes.length > 0) {\n\t            var envelopeAndRequest = _envelopes[0];\n\t            var newEnvelope = envelopeAndRequest[0];\n\t            var newRequest = envelopeAndRequest[1];\n\t            if (newEnvelope.url === envelope.url &&\n\t                newEnvelope.sync === envelope.sync) {\n\t                _envelopes.shift();\n\t                envelope.messages = envelope.messages.concat(newEnvelope.messages);\n\t                this._debug('Coalesced', newEnvelope.messages.length, 'messages from request', newRequest.id);\n\t                continue;\n\t            }\n\t            break;\n\t        }\n\t    }\n\t\n\t    function _transportSend(envelope, request) {\n\t        this.transportSend(envelope, request);\n\t        request.expired = false;\n\t\n\t        if (!envelope.sync) {\n\t            var maxDelay = this.getConfiguration().maxNetworkDelay;\n\t            var delay = maxDelay;\n\t            if (request.metaConnect === true) {\n\t                delay += this.getAdvice().timeout;\n\t            }\n\t\n\t            this._debug('Transport', this.getType(), 'waiting at most', delay, 'ms for the response, maxNetworkDelay', maxDelay);\n\t\n\t            var self = this;\n\t            request.timeout = self.setTimeout(function() {\n\t                request.expired = true;\n\t                var errorMessage = 'Request ' + request.id + ' of transport ' + self.getType() + ' exceeded ' + delay + ' ms max network delay';\n\t                var failure = {\n\t                    reason: errorMessage\n\t                };\n\t                var xhr = request.xhr;\n\t                failure.httpCode = self.xhrStatus(xhr);\n\t                self.abortXHR(xhr);\n\t                self._debug(errorMessage);\n\t                self.complete(request, false, request.metaConnect);\n\t                envelope.onFailure(xhr, envelope.messages, failure);\n\t            }, delay);\n\t        }\n\t    }\n\t\n\t    function _queueSend(envelope) {\n\t        var requestId = ++_requestIds;\n\t        var request = {\n\t            id: requestId,\n\t            metaConnect: false,\n\t            envelope: envelope\n\t        };\n\t\n\t        // Consider the metaConnect requests which should always be present\n\t        if (_requests.length < this.getConfiguration().maxConnections - 1) {\n\t            _requests.push(request);\n\t            _transportSend.call(this, envelope, request);\n\t        } else {\n\t            this._debug('Transport', this.getType(), 'queueing request', requestId, 'envelope', envelope);\n\t            _envelopes.push([envelope, request]);\n\t        }\n\t    }\n\t\n\t    function _metaConnectComplete(request) {\n\t        var requestId = request.id;\n\t        this._debug('Transport', this.getType(), 'metaConnect complete, request', requestId);\n\t        if (_metaConnectRequest !== null && _metaConnectRequest.id !== requestId) {\n\t            throw 'Longpoll request mismatch, completing request ' + requestId;\n\t        }\n\t\n\t        // Reset metaConnect request\n\t        _metaConnectRequest = null;\n\t    }\n\t\n\t    function _complete(request, success) {\n\t        var index = Utils.inArray(request, _requests);\n\t        // The index can be negative if the request has been aborted\n\t        if (index >= 0) {\n\t            _requests.splice(index, 1);\n\t        }\n\t\n\t        if (_envelopes.length > 0) {\n\t            var envelopeAndRequest = _envelopes.shift();\n\t            var nextEnvelope = envelopeAndRequest[0];\n\t            var nextRequest = envelopeAndRequest[1];\n\t            this._debug('Transport dequeued request', nextRequest.id);\n\t            if (success) {\n\t                if (this.getConfiguration().autoBatch) {\n\t                    _coalesceEnvelopes.call(this, nextEnvelope);\n\t                }\n\t                _queueSend.call(this, nextEnvelope);\n\t                this._debug('Transport completed request', request.id, nextEnvelope);\n\t            } else {\n\t                // Keep the semantic of calling response callbacks asynchronously after the request\n\t                var self = this;\n\t                self.setTimeout(function() {\n\t                    self.complete(nextRequest, false, nextRequest.metaConnect);\n\t                    var failure = {\n\t                        reason: 'Previous request failed'\n\t                    };\n\t                    var xhr = nextRequest.xhr;\n\t                    failure.httpCode = self.xhrStatus(xhr);\n\t                    nextEnvelope.onFailure(xhr, nextEnvelope.messages, failure);\n\t                }, 0);\n\t            }\n\t        }\n\t    }\n\t\n\t    _self.complete = function(request, success, metaConnect) {\n\t        if (metaConnect) {\n\t            _metaConnectComplete.call(this, request);\n\t        } else {\n\t            _complete.call(this, request, success);\n\t        }\n\t    };\n\t\n\t    /**\n\t     * Performs the actual send depending on the transport type details.\n\t     * @param envelope the envelope to send\n\t     * @param request the request information\n\t     */\n\t    _self.transportSend = function(envelope, request) {\n\t        throw 'Abstract';\n\t    };\n\t\n\t    _self.transportSuccess = function(envelope, request, responses) {\n\t        if (!request.expired) {\n\t            this.clearTimeout(request.timeout);\n\t            this.complete(request, true, request.metaConnect);\n\t            if (responses && responses.length > 0) {\n\t                envelope.onSuccess(responses);\n\t            } else {\n\t                envelope.onFailure(request.xhr, envelope.messages, {\n\t                    httpCode: 204\n\t                });\n\t            }\n\t        }\n\t    };\n\t\n\t    _self.transportFailure = function(envelope, request, failure) {\n\t        if (!request.expired) {\n\t            this.clearTimeout(request.timeout);\n\t            this.complete(request, false, request.metaConnect);\n\t            envelope.onFailure(request.xhr, envelope.messages, failure);\n\t        }\n\t    };\n\t\n\t    function _metaConnectSend(envelope) {\n\t        if (_metaConnectRequest !== null) {\n\t            throw 'Concurrent metaConnect requests not allowed, request id=' + _metaConnectRequest.id + ' not yet completed';\n\t        }\n\t\n\t        var requestId = ++_requestIds;\n\t        this._debug('Transport', this.getType(), 'metaConnect send, request', requestId, 'envelope', envelope);\n\t        var request = {\n\t            id: requestId,\n\t            metaConnect: true,\n\t            envelope: envelope\n\t        };\n\t        _transportSend.call(this, envelope, request);\n\t        _metaConnectRequest = request;\n\t    }\n\t\n\t    _self.send = function(envelope, metaConnect) {\n\t        if (metaConnect) {\n\t            _metaConnectSend.call(this, envelope);\n\t        } else {\n\t            _queueSend.call(this, envelope);\n\t        }\n\t    };\n\t\n\t    _self.abort = function() {\n\t        _super.abort();\n\t        for (var i = 0; i < _requests.length; ++i) {\n\t            var request = _requests[i];\n\t            if (request) {\n\t                this._debug('Aborting request', request);\n\t                if (!this.abortXHR(request.xhr)) {\n\t                    this.transportFailure(request.envelope, request, {reason: 'abort'});\n\t                }\n\t            }\n\t        }\n\t        if (_metaConnectRequest) {\n\t            this._debug('Aborting metaConnect request', _metaConnectRequest);\n\t            if (!this.abortXHR(_metaConnectRequest.xhr)) {\n\t                this.transportFailure(_metaConnectRequest.envelope, _metaConnectRequest, {reason: 'abort'});\n\t            }\n\t        }\n\t        this.reset(true);\n\t    };\n\t\n\t    _self.reset = function(init) {\n\t        _super.reset(init);\n\t        _metaConnectRequest = null;\n\t        _requests = [];\n\t        _envelopes = [];\n\t    };\n\t\n\t    _self.abortXHR = function(xhr) {\n\t        if (xhr) {\n\t            try {\n\t                var state = xhr.readyState;\n\t                xhr.abort();\n\t                return state !== XMLHttpRequest.UNSENT;\n\t            } catch (x) {\n\t                this._debug(x);\n\t            }\n\t        }\n\t        return false;\n\t    };\n\t\n\t    _self.xhrStatus = function(xhr) {\n\t        if (xhr) {\n\t            try {\n\t                return xhr.status;\n\t            } catch (x) {\n\t                this._debug(x);\n\t            }\n\t        }\n\t        return -1;\n\t    };\n\t\n\t    return _self;\n\t};\n\n\n/***/ },\n/* 103 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar TransportRegistry = __webpack_require__(104)\n\tvar Utils = __webpack_require__(101)\n\t/**\n\t * The constructor for a CometD object, identified by an optional name.\n\t * The default name is the string 'default'.\n\t * In the rare case a page needs more than one Bayeux conversation,\n\t * a new instance can be created via:\n\t * <pre>\n\t * var bayeuxUrl2 = ...;\n\t *\n\t * // Dojo style\n\t * var cometd2 = new dojox.CometD('another_optional_name');\n\t *\n\t * // jQuery style\n\t * var cometd2 = new $.CometD('another_optional_name');\n\t *\n\t * cometd2.init({url: bayeuxUrl2});\n\t * </pre>\n\t * @param name the optional name of this cometd object\n\t */\n\tmodule.exports = function CometD(name) {\n\t    var _cometd = this;\n\t    var _name = name || 'default';\n\t    var _crossDomain = false;\n\t    var _transports = new TransportRegistry();\n\t    var _transport;\n\t    var _status = 'disconnected';\n\t    var _messageId = 0;\n\t    var _clientId = null;\n\t    var _batch = 0;\n\t    var _messageQueue = [];\n\t    var _internalBatch = false;\n\t    var _listeners = {};\n\t    var _backoff = 0;\n\t    var _scheduledSend = null;\n\t    var _extensions = [];\n\t    var _advice = {};\n\t    var _handshakeProps;\n\t    var _handshakeCallback;\n\t    var _callbacks = {};\n\t    var _remoteCalls = {};\n\t    var _reestablish = false;\n\t    var _connected = false;\n\t    var _unconnectTime = 0;\n\t    var _handshakeMessages = 0;\n\t    var _config = {\n\t        protocol: null,\n\t        stickyReconnect: true,\n\t        connectTimeout: 0,\n\t        maxConnections: 2,\n\t        backoffIncrement: 1000,\n\t        maxBackoff: 60000,\n\t        logLevel: 'info',\n\t        reverseIncomingExtensions: true,\n\t        maxNetworkDelay: 10000,\n\t        requestHeaders: {},\n\t        appendMessageTypeToURL: true,\n\t        autoBatch: false,\n\t        urls: {},\n\t        maxURILength: 2000,\n\t        advice: {\n\t            timeout: 60000,\n\t            interval: 0,\n\t            reconnect: 'retry',\n\t            maxInterval: 0\n\t        }\n\t    };\n\t\n\t    function _fieldValue(object, name) {\n\t        try {\n\t            return object[name];\n\t        } catch (x) {\n\t            return undefined;\n\t        }\n\t    }\n\t\n\t    /**\n\t     * Mixes in the given objects into the target object by copying the properties.\n\t     * @param deep if the copy must be deep\n\t     * @param target the target object\n\t     * @param objects the objects whose properties are copied into the target\n\t     */\n\t    this._mixin = function(deep, target, objects) {\n\t        var result = target || {};\n\t\n\t        // Skip first 2 parameters (deep and target), and loop over the others\n\t        for (var i = 2; i < arguments.length; ++i) {\n\t            var object = arguments[i];\n\t\n\t            if (object === undefined || object === null) {\n\t                continue;\n\t            }\n\t\n\t            for (var propName in object) {\n\t                if (object.hasOwnProperty(propName)) {\n\t                    var prop = _fieldValue(object, propName);\n\t                    var targ = _fieldValue(result, propName);\n\t\n\t                    // Avoid infinite loops\n\t                    if (prop === target) {\n\t                        continue;\n\t                    }\n\t                    // Do not mixin undefined values\n\t                    if (prop === undefined) {\n\t                        continue;\n\t                    }\n\t\n\t                    if (deep && typeof prop === 'object' && prop !== null) {\n\t                        if (prop instanceof Array) {\n\t                            result[propName] = this._mixin(deep, targ instanceof Array ? targ : [], prop);\n\t                        } else {\n\t                            var source = typeof targ === 'object' && !(targ instanceof Array) ? targ : {};\n\t                            result[propName] = this._mixin(deep, source, prop);\n\t                        }\n\t                    } else {\n\t                        result[propName] = prop;\n\t                    }\n\t                }\n\t            }\n\t        }\n\t\n\t        return result;\n\t    };\n\t\n\t    function _isString(value) {\n\t        return Utils.isString(value);\n\t    }\n\t\n\t    function _isFunction(value) {\n\t        if (value === undefined || value === null) {\n\t            return false;\n\t        }\n\t        return typeof value === 'function';\n\t    }\n\t\n\t    function _zeroPad(value, length) {\n\t        var result = '';\n\t        while (--length > 0) {\n\t            if (value >= Math.pow(10, length)) {\n\t                break;\n\t            }\n\t            result += '0';\n\t        }\n\t        result += value;\n\t        return result;\n\t    }\n\t\n\t    function _log(level, args) {\n\t        if ('undefined' !== typeof console) {\n\t            var logger = console[level];\n\t            if (_isFunction(logger)) {\n\t                var now = new Date();\n\t                [].splice.call(args, 0, 0, _zeroPad(now.getHours(), 2) + ':' + _zeroPad(now.getMinutes(), 2) + ':' +\n\t                        _zeroPad(now.getSeconds(), 2) + '.' + _zeroPad(now.getMilliseconds(), 3));\n\t                logger.apply(console, args);\n\t            }\n\t        }\n\t    }\n\t\n\t    this._warn = function() {\n\t        _log('warn', arguments);\n\t    };\n\t\n\t    this._info = function() {\n\t        if (_config.logLevel !== 'warn') {\n\t            _log('info', arguments);\n\t        }\n\t    };\n\t\n\t    this._debug = function() {\n\t        if (_config.logLevel === 'debug') {\n\t            _log('debug', arguments);\n\t        }\n\t    };\n\t\n\t    function _splitURL(url) {\n\t        // [1] = protocol://,\n\t        // [2] = host:port,\n\t        // [3] = host,\n\t        // [4] = IPv6_host,\n\t        // [5] = IPv4_host,\n\t        // [6] = :port,\n\t        // [7] = port,\n\t        // [8] = uri,\n\t        // [9] = rest (query / fragment)\n\t        return /(^https?:\\/\\/)?(((\\[[^\\]]+\\])|([^:\\/\\?#]+))(:(\\d+))?)?([^\\?#]*)(.*)?/.exec(url);\n\t    }\n\t\n\t    /**\n\t     * Returns whether the given hostAndPort is cross domain.\n\t     * The default implementation checks against window.location.host\n\t     * but this function can be overridden to make it work in non-browser\n\t     * environments.\n\t     *\n\t     * @param hostAndPort the host and port in format host:port\n\t     * @return whether the given hostAndPort is cross domain\n\t     */\n\t    this._isCrossDomain = function(hostAndPort) {\n\t        return hostAndPort && hostAndPort !== window.location.host;\n\t    };\n\t\n\t    function _configure(configuration) {\n\t        _cometd._debug('Configuring cometd object with', configuration);\n\t        // Support old style param, where only the Bayeux server URL was passed\n\t        if (_isString(configuration)) {\n\t            configuration = { url: configuration };\n\t        }\n\t        if (!configuration) {\n\t            configuration = {};\n\t        }\n\t\n\t        _config = _cometd._mixin(false, _config, configuration);\n\t\n\t        var url = _cometd.getURL();\n\t        if (!url) {\n\t            throw 'Missing required configuration parameter \\'url\\' specifying the Bayeux server URL';\n\t        }\n\t\n\t        // Check if we're cross domain.\n\t        var urlParts = _splitURL(url);\n\t        var hostAndPort = urlParts[2];\n\t        var uri = urlParts[8];\n\t        var afterURI = urlParts[9];\n\t        _crossDomain = _cometd._isCrossDomain(hostAndPort);\n\t\n\t        // Check if appending extra path is supported\n\t        if (_config.appendMessageTypeToURL) {\n\t            if (afterURI !== undefined && afterURI.length > 0) {\n\t                _cometd._info('Appending message type to URI ' + uri + afterURI + ' is not supported, disabling \\'appendMessageTypeToURL\\' configuration');\n\t                _config.appendMessageTypeToURL = false;\n\t            } else {\n\t                var uriSegments = uri.split('/');\n\t                var lastSegmentIndex = uriSegments.length - 1;\n\t                if (uri.match(/\\/$/)) {\n\t                    lastSegmentIndex -= 1;\n\t                }\n\t                if (uriSegments[lastSegmentIndex].indexOf('.') >= 0) {\n\t                    // Very likely the CometD servlet's URL pattern is mapped to an extension, such as *.cometd\n\t                    // It will be difficult to add the extra path in this case\n\t                    _cometd._info('Appending message type to URI ' + uri + ' is not supported, disabling \\'appendMessageTypeToURL\\' configuration');\n\t                    _config.appendMessageTypeToURL = false;\n\t                }\n\t            }\n\t        }\n\t    }\n\t\n\t    function _removeListener(subscription) {\n\t        if (subscription) {\n\t            var subscriptions = _listeners[subscription.channel];\n\t            if (subscriptions && subscriptions[subscription.id]) {\n\t                delete subscriptions[subscription.id];\n\t                _cometd._debug('Removed', subscription.listener ? 'listener' : 'subscription', subscription);\n\t            }\n\t        }\n\t    }\n\t\n\t    function _removeSubscription(subscription) {\n\t        if (subscription && !subscription.listener) {\n\t            _removeListener(subscription);\n\t        }\n\t    }\n\t\n\t    function _clearSubscriptions() {\n\t        for (var channel in _listeners) {\n\t            if (_listeners.hasOwnProperty(channel)) {\n\t                var subscriptions = _listeners[channel];\n\t                if (subscriptions) {\n\t                    for (var i = 0; i < subscriptions.length; ++i) {\n\t                        _removeSubscription(subscriptions[i]);\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t\n\t    function _setStatus(newStatus) {\n\t        if (_status !== newStatus) {\n\t            _cometd._debug('Status', _status, '->', newStatus);\n\t            _status = newStatus;\n\t        }\n\t    }\n\t\n\t    function _isDisconnected() {\n\t        return _status === 'disconnecting' || _status === 'disconnected';\n\t    }\n\t\n\t    function _nextMessageId() {\n\t        var result = ++_messageId;\n\t        return '' + result;\n\t    }\n\t\n\t    function _applyExtension(scope, callback, name, message, outgoing) {\n\t        try {\n\t            return callback.call(scope, message);\n\t        } catch (x) {\n\t            var handler = _cometd.onExtensionException;\n\t            if (_isFunction(handler)) {\n\t                _cometd._debug('Invoking extension exception handler', name, x);\n\t                try {\n\t                    handler.call(_cometd, x, name, outgoing, message);\n\t                } catch (xx) {\n\t                    _cometd._info('Exception during execution of extension exception handler', name, xx);\n\t                }\n\t            } else {\n\t                _cometd._info('Exception during execution of extension', name, x);\n\t            }\n\t            return message;\n\t        }\n\t    }\n\t\n\t    function _applyIncomingExtensions(message) {\n\t        for (var i = 0; i < _extensions.length; ++i) {\n\t            if (message === undefined || message === null) {\n\t                break;\n\t            }\n\t\n\t            var index = _config.reverseIncomingExtensions ? _extensions.length - 1 - i : i;\n\t            var extension = _extensions[index];\n\t            var callback = extension.extension.incoming;\n\t            if (_isFunction(callback)) {\n\t                var result = _applyExtension(extension.extension, callback, extension.name, message, false);\n\t                message = result === undefined ? message : result;\n\t            }\n\t        }\n\t        return message;\n\t    }\n\t\n\t    function _applyOutgoingExtensions(message) {\n\t        for (var i = 0; i < _extensions.length; ++i) {\n\t            if (message === undefined || message === null) {\n\t                break;\n\t            }\n\t\n\t            var extension = _extensions[i];\n\t            var callback = extension.extension.outgoing;\n\t            if (_isFunction(callback)) {\n\t                var result = _applyExtension(extension.extension, callback, extension.name, message, true);\n\t                message = result === undefined ? message : result;\n\t            }\n\t        }\n\t        return message;\n\t    }\n\t\n\t    function _notify(channel, message) {\n\t        var subscriptions = _listeners[channel];\n\t        if (subscriptions && subscriptions.length > 0) {\n\t            for (var i = 0; i < subscriptions.length; ++i) {\n\t                var subscription = subscriptions[i];\n\t                // Subscriptions may come and go, so the array may have 'holes'\n\t                if (subscription) {\n\t                    try {\n\t                        subscription.callback.call(subscription.scope, message);\n\t                    } catch (x) {\n\t                        var handler = _cometd.onListenerException;\n\t                        if (_isFunction(handler)) {\n\t                            _cometd._debug('Invoking listener exception handler', subscription, x);\n\t                            try {\n\t                                handler.call(_cometd, x, subscription, subscription.listener, message);\n\t                            } catch (xx) {\n\t                                _cometd._info('Exception during execution of listener exception handler', subscription, xx);\n\t                            }\n\t                        } else {\n\t                            _cometd._info('Exception during execution of listener', subscription, message, x);\n\t                        }\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t\n\t    function _notifyListeners(channel, message) {\n\t        // Notify direct listeners\n\t        _notify(channel, message);\n\t\n\t        // Notify the globbing listeners\n\t        var channelParts = channel.split('/');\n\t        var last = channelParts.length - 1;\n\t        for (var i = last; i > 0; --i) {\n\t            var channelPart = channelParts.slice(0, i).join('/') + '/*';\n\t            // We don't want to notify /foo/* if the channel is /foo/bar/baz,\n\t            // so we stop at the first non recursive globbing\n\t            if (i === last) {\n\t                _notify(channelPart, message);\n\t            }\n\t            // Add the recursive globber and notify\n\t            channelPart += '*';\n\t            _notify(channelPart, message);\n\t        }\n\t    }\n\t\n\t    function _cancelDelayedSend() {\n\t        if (_scheduledSend !== null) {\n\t            Utils.clearTimeout(_scheduledSend);\n\t        }\n\t        _scheduledSend = null;\n\t    }\n\t\n\t    function _delayedSend(operation, delay) {\n\t        if ('undefined' === typeof delay) {\n\t          delay = _backoff\n\t        }\n\t        _cancelDelayedSend();\n\t        var time = _advice.interval + delay;\n\t        _cometd._debug('Function scheduled in', time, 'ms, interval =', _advice.interval, 'backoff =', _backoff, operation);\n\t        _scheduledSend = Utils.setTimeout(_cometd, operation, time);\n\t    }\n\t\n\t    // Needed to break cyclic dependencies between function definitions\n\t    var _handleMessages;\n\t    var _handleFailure;\n\t\n\t    /**\n\t     * Delivers the messages to the CometD server\n\t     * @param sync whether the send is synchronous\n\t     * @param messages the array of messages to send\n\t     * @param metaConnect true if this send is on /meta/connect\n\t     * @param extraPath an extra path to append to the Bayeux server URL\n\t     */\n\t    function _send(sync, messages, metaConnect, extraPath) {\n\t        // We must be sure that the messages have a clientId.\n\t        // This is not guaranteed since the handshake may take time to return\n\t        // (and hence the clientId is not known yet) and the application\n\t        // may create other messages.\n\t        for (var i = 0; i < messages.length; ++i) {\n\t            var message = messages[i];\n\t            var messageId = message.id;\n\t\n\t            if (_clientId) {\n\t                message.clientId = _clientId;\n\t            }\n\t\n\t            message = _applyOutgoingExtensions(message);\n\t            if (message !== undefined && message !== null) {\n\t                // Extensions may have modified the message id, but we need to own it.\n\t                message.id = messageId;\n\t                messages[i] = message;\n\t            } else {\n\t                delete _callbacks[messageId];\n\t                messages.splice(i--, 1);\n\t            }\n\t        }\n\t\n\t        if (messages.length === 0) {\n\t            return;\n\t        }\n\t\n\t        var url = _cometd.getURL();\n\t        if (_config.appendMessageTypeToURL) {\n\t            // If url does not end with '/', then append it\n\t            if (!url.match(/\\/$/)) {\n\t                url = url + '/';\n\t            }\n\t            if (extraPath) {\n\t                url = url + extraPath;\n\t            }\n\t        }\n\t\n\t        var envelope = {\n\t            url: url,\n\t            sync: sync,\n\t            messages: messages,\n\t            onSuccess: function(rcvdMessages) {\n\t                try {\n\t                    _handleMessages.call(_cometd, rcvdMessages);\n\t                } catch (x) {\n\t                    _cometd._info('Exception during handling of messages', x);\n\t                }\n\t            },\n\t            onFailure: function(conduit, messages, failure) {\n\t                try {\n\t                    var transport = _cometd.getTransport();\n\t                    failure.connectionType = transport ? transport.getType() : \"unknown\";\n\t                    _handleFailure.call(_cometd, conduit, messages, failure);\n\t                } catch (x) {\n\t                    _cometd._info('Exception during handling of failure', x);\n\t                }\n\t            }\n\t        };\n\t        _cometd._debug('Send', envelope);\n\t        _transport.send(envelope, metaConnect);\n\t    }\n\t\n\t    function _queueSend(message) {\n\t        if (_batch > 0 || _internalBatch === true) {\n\t            _messageQueue.push(message);\n\t        } else {\n\t            _send(false, [message], false);\n\t        }\n\t    }\n\t\n\t    /**\n\t     * Sends a complete bayeux message.\n\t     * This method is exposed as a public so that extensions may use it\n\t     * to send bayeux message directly, for example in case of re-sending\n\t     * messages that have already been sent but that for some reason must\n\t     * be resent.\n\t     */\n\t    this.send = _queueSend;\n\t\n\t    function _resetBackoff() {\n\t        _backoff = 0;\n\t    }\n\t\n\t    function _increaseBackoff() {\n\t        if (_backoff < _config.maxBackoff) {\n\t            _backoff += _config.backoffIncrement;\n\t        }\n\t        return _backoff;\n\t    }\n\t\n\t    /**\n\t     * Starts a the batch of messages to be sent in a single request.\n\t     * @see #_endBatch(sendMessages)\n\t     */\n\t    function _startBatch() {\n\t        ++_batch;\n\t        _cometd._debug('Starting batch, depth', _batch);\n\t    }\n\t\n\t    function _flushBatch() {\n\t        var messages = _messageQueue;\n\t        _messageQueue = [];\n\t        if (messages.length > 0) {\n\t            _send(false, messages, false);\n\t        }\n\t    }\n\t\n\t    /**\n\t     * Ends the batch of messages to be sent in a single request,\n\t     * optionally sending messages present in the message queue depending\n\t     * on the given argument.\n\t     * @see #_startBatch()\n\t     */\n\t    function _endBatch() {\n\t        --_batch;\n\t        _cometd._debug('Ending batch, depth', _batch);\n\t        if (_batch < 0) {\n\t            throw 'Calls to startBatch() and endBatch() are not paired';\n\t        }\n\t\n\t        if (_batch === 0 && !_isDisconnected() && !_internalBatch) {\n\t            _flushBatch();\n\t        }\n\t    }\n\t\n\t    /**\n\t     * Sends the connect message\n\t     */\n\t    function _connect() {\n\t        if (!_isDisconnected()) {\n\t            var bayeuxMessage = {\n\t                id: _nextMessageId(),\n\t                channel: '/meta/connect',\n\t                connectionType: _transport.getType()\n\t            };\n\t\n\t            // In case of reload or temporary loss of connection\n\t            // we want the next successful connect to return immediately\n\t            // instead of being held by the server, so that connect listeners\n\t            // can be notified that the connection has been re-established\n\t            if (!_connected) {\n\t                bayeuxMessage.advice = { timeout: 0 };\n\t            }\n\t\n\t            _setStatus('connecting');\n\t            _cometd._debug('Connect sent', bayeuxMessage);\n\t            _send(false, [bayeuxMessage], true, 'connect');\n\t            _setStatus('connected');\n\t        }\n\t    }\n\t\n\t    function _delayedConnect(delay) {\n\t        _setStatus('connecting');\n\t        _delayedSend(function() {\n\t            _connect();\n\t        }, delay);\n\t    }\n\t\n\t    function _updateAdvice(newAdvice) {\n\t        if (newAdvice) {\n\t            _advice = _cometd._mixin(false, {}, _config.advice, newAdvice);\n\t            _cometd._debug('New advice', _advice);\n\t        }\n\t    }\n\t\n\t    function _disconnect(abort) {\n\t        _cancelDelayedSend();\n\t        if (abort && _transport) {\n\t            _transport.abort();\n\t        }\n\t        _clientId = null;\n\t        _setStatus('disconnected');\n\t        _batch = 0;\n\t        _resetBackoff();\n\t        _transport = null;\n\t\n\t        // Fail any existing queued message\n\t        if (_messageQueue.length > 0) {\n\t            var messages = _messageQueue;\n\t            _messageQueue = [];\n\t            _handleFailure.call(_cometd, undefined, messages, {\n\t                reason: 'Disconnected'\n\t            });\n\t        }\n\t    }\n\t\n\t    function _notifyTransportFailure(oldTransport, newTransport, failure) {\n\t        var handler = _cometd.onTransportException;\n\t        if (_isFunction(handler)) {\n\t            _cometd._debug('Invoking transport exception handler', oldTransport, newTransport, failure);\n\t            try {\n\t                handler.call(_cometd, failure, oldTransport, newTransport);\n\t            } catch (x) {\n\t                _cometd._info('Exception during execution of transport exception handler', x);\n\t            }\n\t        }\n\t    }\n\t\n\t    /**\n\t     * Sends the initial handshake message\n\t     */\n\t    function _handshake(handshakeProps, handshakeCallback) {\n\t        if (_isFunction(handshakeProps)) {\n\t            handshakeCallback = handshakeProps;\n\t            handshakeProps = undefined;\n\t        }\n\t\n\t        _clientId = null;\n\t\n\t        _clearSubscriptions();\n\t\n\t        // Reset the transports if we're not retrying the handshake\n\t        if (_isDisconnected()) {\n\t            _transports.reset(true);\n\t            _updateAdvice(_config.advice);\n\t        } else {\n\t            // We are retrying the handshake, either because another handshake failed\n\t            // and we're backing off, or because the server timed us out and asks us to\n\t            // re-handshake: in both cases, make sure that if the handshake succeeds\n\t            // the next action is a connect.\n\t            _updateAdvice(_cometd._mixin(false, _advice, {reconnect: 'retry'}));\n\t        }\n\t\n\t        _batch = 0;\n\t\n\t        // Mark the start of an internal batch.\n\t        // This is needed because handshake and connect are async.\n\t        // It may happen that the application calls init() then subscribe()\n\t        // and the subscribe message is sent before the connect message, if\n\t        // the subscribe message is not held until the connect message is sent.\n\t        // So here we start a batch to hold temporarily any message until\n\t        // the connection is fully established.\n\t        _internalBatch = true;\n\t\n\t        // Save the properties provided by the user, so that\n\t        // we can reuse them during automatic re-handshake\n\t        _handshakeProps = handshakeProps;\n\t        _handshakeCallback = handshakeCallback;\n\t\n\t        var version = '1.0';\n\t\n\t        // Figure out the transports to send to the server\n\t        var url = _cometd.getURL();\n\t        var transportTypes = _transports.findTransportTypes(version, _crossDomain, url);\n\t\n\t        var bayeuxMessage = {\n\t            id: _nextMessageId(),\n\t            version: version,\n\t            minimumVersion: version,\n\t            channel: '/meta/handshake',\n\t            supportedConnectionTypes: transportTypes,\n\t            advice: {\n\t                timeout: _advice.timeout,\n\t                interval: _advice.interval\n\t            }\n\t        };\n\t        // Do not allow the user to override important fields.\n\t        var message = _cometd._mixin(false, {}, _handshakeProps, bayeuxMessage);\n\t\n\t        // Save the callback.\n\t        _cometd._putCallback(message.id, handshakeCallback);\n\t\n\t        // Pick up the first available transport as initial transport\n\t        // since we don't know if the server supports it\n\t        if (!_transport) {\n\t            _transport = _transports.negotiateTransport(transportTypes, version, _crossDomain, url);\n\t            if (!_transport) {\n\t                var failure = 'Could not find initial transport among: ' + _transports.getTransportTypes();\n\t                _cometd._warn(failure);\n\t                throw failure;\n\t            }\n\t        }\n\t\n\t        _cometd._debug('Initial transport is', _transport.getType());\n\t\n\t        // We started a batch to hold the application messages,\n\t        // so here we must bypass it and send immediately.\n\t        _setStatus('handshaking');\n\t        _cometd._debug('Handshake sent', message);\n\t        _send(false, [message], false, 'handshake');\n\t    }\n\t\n\t    function _delayedHandshake(delay) {\n\t        _setStatus('handshaking');\n\t\n\t        // We will call _handshake() which will reset _clientId, but we want to avoid\n\t        // that between the end of this method and the call to _handshake() someone may\n\t        // call publish() (or other methods that call _queueSend()).\n\t        _internalBatch = true;\n\t\n\t        _delayedSend(function() {\n\t            _handshake(_handshakeProps, _handshakeCallback);\n\t        }, delay);\n\t    }\n\t\n\t    function _notifyCallback(callback, message) {\n\t        try {\n\t            callback.call(_cometd, message);\n\t        } catch (x) {\n\t            var handler = _cometd.onCallbackException;\n\t            if (_isFunction(handler)) {\n\t                _cometd._debug('Invoking callback exception handler', x);\n\t                try {\n\t                    handler.call(_cometd, x, message);\n\t                } catch (xx) {\n\t                    _cometd._info('Exception during execution of callback exception handler', xx);\n\t                }\n\t            } else {\n\t                _cometd._info('Exception during execution of message callback', x);\n\t            }\n\t        }\n\t    }\n\t\n\t    this._getCallback = function(messageId) {\n\t        return _callbacks[messageId];\n\t    };\n\t\n\t    this._putCallback = function(messageId, callback) {\n\t        var result = this._getCallback(messageId);\n\t        if (_isFunction(callback)) {\n\t            _callbacks[messageId] = callback;\n\t        }\n\t        return result;\n\t    };\n\t\n\t    function _handleCallback(message) {\n\t        var callback = _cometd._getCallback([message.id]);\n\t        if (_isFunction(callback)) {\n\t            delete _callbacks[message.id];\n\t            _notifyCallback(callback, message);\n\t        }\n\t    }\n\t\n\t    function _handleRemoteCall(message) {\n\t        var context = _remoteCalls[message.id];\n\t        delete _remoteCalls[message.id];\n\t        _cometd._debug('Handling remote call response for', message, 'with context', context);\n\t        if (context) {\n\t            // Clear the timeout, if present.\n\t            var timeout = context.timeout;\n\t            if (timeout) {\n\t                Utils.clearTimeout(timeout);\n\t            }\n\t\n\t            var callback = context.callback;\n\t            if (_isFunction(callback)) {\n\t                _notifyCallback(callback, message);\n\t                return true;\n\t            }\n\t        }\n\t        return false;\n\t    }\n\t\n\t    function _failHandshake(message) {\n\t        _handleCallback(message);\n\t        _notifyListeners('/meta/handshake', message);\n\t        _notifyListeners('/meta/unsuccessful', message);\n\t\n\t        // Only try again if we haven't been disconnected and\n\t        // the advice permits us to retry the handshake\n\t        var retry = !_isDisconnected() && _advice.reconnect !== 'none';\n\t        if (retry) {\n\t            _increaseBackoff();\n\t            _delayedHandshake();\n\t        } else {\n\t            _disconnect(true);\n\t        }\n\t    }\n\t\n\t    function _handshakeResponse(message) {\n\t        if (message.successful) {\n\t            // Save clientId, figure out transport, then follow the advice to connect\n\t            _clientId = message.clientId;\n\t\n\t            var url = _cometd.getURL();\n\t            var newTransport = _transports.negotiateTransport(message.supportedConnectionTypes, message.version, _crossDomain, url);\n\t            if (newTransport === null) {\n\t                var failure = 'Could not negotiate transport with server; client=[' +\n\t                    _transports.findTransportTypes(message.version, _crossDomain, url) +\n\t                    '], server=[' + message.supportedConnectionTypes + ']';\n\t                var oldTransport = _cometd.getTransport();\n\t                _notifyTransportFailure(oldTransport.getType(), null, {\n\t                    reason: failure,\n\t                    connectionType: oldTransport.getType(),\n\t                    transport: oldTransport\n\t                });\n\t                _cometd._warn(failure);\n\t                _disconnect(true);\n\t                return;\n\t            } else if (_transport !== newTransport) {\n\t                _cometd._debug('Transport', _transport.getType(), '->', newTransport.getType());\n\t                _transport = newTransport;\n\t            }\n\t\n\t            // End the internal batch and allow held messages from the application\n\t            // to go to the server (see _handshake() where we start the internal batch).\n\t            _internalBatch = false;\n\t            _flushBatch();\n\t\n\t            // Here the new transport is in place, as well as the clientId, so\n\t            // the listeners can perform a publish() if they want.\n\t            // Notify the listeners before the connect below.\n\t            message.reestablish = _reestablish;\n\t            _reestablish = true;\n\t\n\t            _handleCallback(message);\n\t            _notifyListeners('/meta/handshake', message);\n\t\n\t            var action = _isDisconnected() ? 'none' : _advice.reconnect;\n\t            switch (action) {\n\t                case 'retry':\n\t                    _resetBackoff();\n\t                    _delayedConnect();\n\t                    break;\n\t                case 'none':\n\t                    _disconnect(true);\n\t                    break;\n\t                default:\n\t                    throw 'Unrecognized advice action ' + action;\n\t            }\n\t        } else {\n\t            _failHandshake(message);\n\t        }\n\t    }\n\t\n\t    function _handshakeFailure(message) {\n\t        var version = '1.0';\n\t        var url = _cometd.getURL();\n\t        var oldTransport = _cometd.getTransport();\n\t        var transportTypes = _transports.findTransportTypes(version, _crossDomain, url);\n\t        var newTransport = _transports.negotiateTransport(transportTypes, version, _crossDomain, url);\n\t        if (!newTransport) {\n\t            _notifyTransportFailure(oldTransport.getType(), null, message.failure);\n\t            _cometd._warn('Could not negotiate transport; client=[' + transportTypes + ']');\n\t            _disconnect(true);\n\t            _failHandshake(message);\n\t        } else {\n\t            _cometd._debug('Transport', oldTransport.getType(), '->', newTransport.getType());\n\t            _notifyTransportFailure(oldTransport.getType(), newTransport.getType(), message.failure);\n\t            _failHandshake(message);\n\t            _transport = newTransport;\n\t        }\n\t    }\n\t\n\t    function _failConnect(message) {\n\t        // Notify the listeners after the status change but before the next action\n\t        _notifyListeners('/meta/connect', message);\n\t        _notifyListeners('/meta/unsuccessful', message);\n\t\n\t        // This may happen when the server crashed, the current clientId\n\t        // will be invalid, and the server will ask to handshake again\n\t        // Listeners can call disconnect(), so check the state after they run\n\t        var action = _isDisconnected() ? 'none' : _advice.reconnect;\n\t        switch (action) {\n\t            case 'retry':\n\t                _delayedConnect();\n\t                _increaseBackoff();\n\t                break;\n\t            case 'handshake':\n\t                // The current transport may be failed (e.g. network disconnection)\n\t                // Reset the transports so the new handshake picks up the right one\n\t                _transports.reset(true);\n\t                _resetBackoff();\n\t                _delayedHandshake();\n\t                break;\n\t            case 'none':\n\t                _disconnect(true);\n\t                break;\n\t            default:\n\t                throw 'Unrecognized advice action' + action;\n\t        }\n\t    }\n\t\n\t    function _connectResponse(message) {\n\t        _connected = message.successful;\n\t\n\t        if (_connected) {\n\t            _notifyListeners('/meta/connect', message);\n\t\n\t            // Normally, the advice will say \"reconnect: 'retry', interval: 0\"\n\t            // and the server will hold the request, so when a response returns\n\t            // we immediately call the server again (long polling)\n\t            // Listeners can call disconnect(), so check the state after they run\n\t            var action = _isDisconnected() ? 'none' : _advice.reconnect;\n\t            switch (action) {\n\t                case 'retry':\n\t                    _resetBackoff();\n\t                    _delayedConnect();\n\t                    break;\n\t                case 'none':\n\t                    // Wait for the /meta/disconnect to arrive.\n\t                    _disconnect(false);\n\t                    break;\n\t                default:\n\t                    throw 'Unrecognized advice action ' + action;\n\t            }\n\t        } else {\n\t            _failConnect(message);\n\t        }\n\t    }\n\t\n\t    function _connectFailure(message) {\n\t        _connected = false;\n\t        _failConnect(message);\n\t    }\n\t\n\t    function _failDisconnect(message) {\n\t        _disconnect(true);\n\t        _handleCallback(message);\n\t        _notifyListeners('/meta/disconnect', message);\n\t        _notifyListeners('/meta/unsuccessful', message);\n\t    }\n\t\n\t    function _disconnectResponse(message) {\n\t        if (message.successful) {\n\t            // Wait for the /meta/connect to arrive.\n\t            _disconnect(false);\n\t            _handleCallback(message);\n\t            _notifyListeners('/meta/disconnect', message);\n\t        } else {\n\t            _failDisconnect(message);\n\t        }\n\t    }\n\t\n\t    function _disconnectFailure(message) {\n\t        _failDisconnect(message);\n\t    }\n\t\n\t    function _failSubscribe(message) {\n\t        var subscriptions = _listeners[message.subscription];\n\t        if (subscriptions) {\n\t            for (var i = subscriptions.length - 1; i >= 0; --i) {\n\t                var subscription = subscriptions[i];\n\t                if (subscription && !subscription.listener) {\n\t                    delete subscriptions[i];\n\t                    _cometd._debug('Removed failed subscription', subscription);\n\t                    break;\n\t                }\n\t            }\n\t        }\n\t        _handleCallback(message);\n\t        _notifyListeners('/meta/subscribe', message);\n\t        _notifyListeners('/meta/unsuccessful', message);\n\t    }\n\t\n\t    function _subscribeResponse(message) {\n\t        if (message.successful) {\n\t            _handleCallback(message);\n\t            _notifyListeners('/meta/subscribe', message);\n\t        } else {\n\t            _failSubscribe(message);\n\t        }\n\t    }\n\t\n\t    function _subscribeFailure(message) {\n\t        _failSubscribe(message);\n\t    }\n\t\n\t    function _failUnsubscribe(message) {\n\t        _handleCallback(message);\n\t        _notifyListeners('/meta/unsubscribe', message);\n\t        _notifyListeners('/meta/unsuccessful', message);\n\t    }\n\t\n\t    function _unsubscribeResponse(message) {\n\t        if (message.successful) {\n\t            _handleCallback(message);\n\t            _notifyListeners('/meta/unsubscribe', message);\n\t        } else {\n\t            _failUnsubscribe(message);\n\t        }\n\t    }\n\t\n\t    function _unsubscribeFailure(message) {\n\t        _failUnsubscribe(message);\n\t    }\n\t\n\t    function _failMessage(message) {\n\t        if (!_handleRemoteCall(message)) {\n\t            _handleCallback(message);\n\t            _notifyListeners('/meta/publish', message);\n\t            _notifyListeners('/meta/unsuccessful', message);\n\t        }\n\t    }\n\t\n\t    function _messageResponse(message) {\n\t        if (message.data !== undefined) {\n\t            if (!_handleRemoteCall(message)) {\n\t                _notifyListeners(message.channel, message);\n\t                if (_handshakeMessages > 0) {\n\t                    --_handshakeMessages;\n\t                    if (_handshakeMessages === 0) {\n\t                        _cometd._debug('Processed last handshake-delivered message');\n\t                        _delayedConnect(0);\n\t                    }\n\t                }\n\t            }\n\t        } else {\n\t            if (message.successful === undefined) {\n\t                _cometd._warn('Unknown Bayeux Message', message);\n\t            } else {\n\t                if (message.successful) {\n\t                    _handleCallback(message);\n\t                    _notifyListeners('/meta/publish', message);\n\t                } else {\n\t                    _failMessage(message);\n\t                }\n\t            }\n\t        }\n\t    }\n\t\n\t    function _messageFailure(failure) {\n\t        _failMessage(failure);\n\t    }\n\t\n\t    function _receive(message) {\n\t        _unconnectTime = 0;\n\t\n\t        message = _applyIncomingExtensions(message);\n\t        if (message === undefined || message === null) {\n\t            return;\n\t        }\n\t\n\t        _updateAdvice(message.advice);\n\t\n\t        var channel = message.channel;\n\t        switch (channel) {\n\t            case '/meta/handshake':\n\t                _handshakeResponse(message);\n\t                break;\n\t            case '/meta/connect':\n\t                _connectResponse(message);\n\t                break;\n\t            case '/meta/disconnect':\n\t                _disconnectResponse(message);\n\t                break;\n\t            case '/meta/subscribe':\n\t                _subscribeResponse(message);\n\t                break;\n\t            case '/meta/unsubscribe':\n\t                _unsubscribeResponse(message);\n\t                break;\n\t            default:\n\t                _messageResponse(message);\n\t                break;\n\t        }\n\t    }\n\t\n\t    /**\n\t     * Receives a message.\n\t     * This method is exposed as a public so that extensions may inject\n\t     * messages simulating that they had been received.\n\t     */\n\t    this.receive = _receive;\n\t\n\t    _handleMessages = function(rcvdMessages) {\n\t        _cometd._debug('Received', rcvdMessages);\n\t\n\t        for (var i = 0; i < rcvdMessages.length; ++i) {\n\t            var message = rcvdMessages[i];\n\t            _receive(message);\n\t        }\n\t    };\n\t\n\t    _handleFailure = function(conduit, messages, failure) {\n\t        _cometd._debug('handleFailure', conduit, messages, failure);\n\t\n\t        failure.transport = conduit;\n\t        for (var i = 0; i < messages.length; ++i) {\n\t            var message = messages[i];\n\t            var failureMessage = {\n\t                id: message.id,\n\t                successful: false,\n\t                channel: message.channel,\n\t                failure: failure\n\t            };\n\t            failure.message = message;\n\t            switch (message.channel) {\n\t                case '/meta/handshake':\n\t                    _handshakeFailure(failureMessage);\n\t                    break;\n\t                case '/meta/connect':\n\t                    _connectFailure(failureMessage);\n\t                    break;\n\t                case '/meta/disconnect':\n\t                    _disconnectFailure(failureMessage);\n\t                    break;\n\t                case '/meta/subscribe':\n\t                    failureMessage.subscription = message.subscription;\n\t                    _subscribeFailure(failureMessage);\n\t                    break;\n\t                case '/meta/unsubscribe':\n\t                    failureMessage.subscription = message.subscription;\n\t                    _unsubscribeFailure(failureMessage);\n\t                    break;\n\t                default:\n\t                    _messageFailure(failureMessage);\n\t                    break;\n\t            }\n\t        }\n\t    };\n\t\n\t    function _hasSubscriptions(channel) {\n\t        var subscriptions = _listeners[channel];\n\t        if (subscriptions) {\n\t            for (var i = 0; i < subscriptions.length; ++i) {\n\t                if (subscriptions[i]) {\n\t                    return true;\n\t                }\n\t            }\n\t        }\n\t        return false;\n\t    }\n\t\n\t    function _resolveScopedCallback(scope, callback) {\n\t        var delegate = {\n\t            scope: scope,\n\t            method: callback\n\t        };\n\t        if (_isFunction(scope)) {\n\t            delegate.scope = undefined;\n\t            delegate.method = scope;\n\t        } else {\n\t            if (_isString(callback)) {\n\t                if (!scope) {\n\t                    throw 'Invalid scope ' + scope;\n\t                }\n\t                delegate.method = scope[callback];\n\t                if (!_isFunction(delegate.method)) {\n\t                    throw 'Invalid callback ' + callback + ' for scope ' + scope;\n\t                }\n\t            } else if (!_isFunction(callback)) {\n\t                throw 'Invalid callback ' + callback;\n\t            }\n\t        }\n\t        return delegate;\n\t    }\n\t\n\t    function _addListener(channel, scope, callback, isListener) {\n\t        // The data structure is a map<channel, subscription[]>, where each subscription\n\t        // holds the callback to be called and its scope.\n\t\n\t        var delegate = _resolveScopedCallback(scope, callback);\n\t        _cometd._debug('Adding', isListener ? 'listener' : 'subscription', 'on', channel, 'with scope', delegate.scope, 'and callback', delegate.method);\n\t\n\t        var subscription = {\n\t            channel: channel,\n\t            scope: delegate.scope,\n\t            callback: delegate.method,\n\t            listener: isListener\n\t        };\n\t\n\t        var subscriptions = _listeners[channel];\n\t        if (!subscriptions) {\n\t            subscriptions = [];\n\t            _listeners[channel] = subscriptions;\n\t        }\n\t\n\t        // Pushing onto an array appends at the end and returns the id associated with the element increased by 1.\n\t        // Note that if:\n\t        // a.push('a'); var hb=a.push('b'); delete a[hb-1]; var hc=a.push('c');\n\t        // then:\n\t        // hc==3, a.join()=='a',,'c', a.length==3\n\t        subscription.id = subscriptions.push(subscription) - 1;\n\t\n\t        _cometd._debug('Added', isListener ? 'listener' : 'subscription', subscription);\n\t\n\t        // For backward compatibility: we used to return [channel, subscription.id]\n\t        subscription[0] = channel;\n\t        subscription[1] = subscription.id;\n\t\n\t        return subscription;\n\t    }\n\t\n\t    //\n\t    // PUBLIC API\n\t    //\n\t\n\t    /**\n\t     * Registers the given transport under the given transport type.\n\t     * The optional index parameter specifies the \"priority\" at which the\n\t     * transport is registered (where 0 is the max priority).\n\t     * If a transport with the same type is already registered, this function\n\t     * does nothing and returns false.\n\t     * @param type the transport type\n\t     * @param transport the transport object\n\t     * @param index the index at which this transport is to be registered\n\t     * @return true if the transport has been registered, false otherwise\n\t     * @see #unregisterTransport(type)\n\t     */\n\t    this.registerTransport = function(type, transport, index) {\n\t        var result = _transports.add(type, transport, index);\n\t        if (result) {\n\t            this._debug('Registered transport', type);\n\t\n\t            if (_isFunction(transport.registered)) {\n\t                transport.registered(type, this);\n\t            }\n\t        }\n\t        return result;\n\t    };\n\t\n\t    /**\n\t     * Unregisters the transport with the given transport type.\n\t     * @param type the transport type to unregister\n\t     * @return the transport that has been unregistered,\n\t     * or null if no transport was previously registered under the given transport type\n\t     */\n\t    this.unregisterTransport = function(type) {\n\t        var transport = _transports.remove(type);\n\t        if (transport !== null) {\n\t            this._debug('Unregistered transport', type);\n\t\n\t            if (_isFunction(transport.unregistered)) {\n\t                transport.unregistered();\n\t            }\n\t        }\n\t        return transport;\n\t    };\n\t\n\t    this.unregisterTransports = function() {\n\t        _transports.clear();\n\t    };\n\t\n\t    /**\n\t     * @return an array of all registered transport types\n\t     */\n\t    this.getTransportTypes = function() {\n\t        return _transports.getTransportTypes();\n\t    };\n\t\n\t    this.findTransport = function(name) {\n\t        return _transports.find(name);\n\t    };\n\t\n\t    /**\n\t     * @returns the TransportRegistry object\n\t     */\n\t    this.getTransportRegistry = function() {\n\t        return _transports;\n\t    };\n\t\n\t    /**\n\t     * Configures the initial Bayeux communication with the Bayeux server.\n\t     * Configuration is passed via an object that must contain a mandatory field <code>url</code>\n\t     * of type string containing the URL of the Bayeux server.\n\t     * @param configuration the configuration object\n\t     */\n\t    this.configure = function(configuration) {\n\t        _configure.call(this, configuration);\n\t    };\n\t\n\t    /**\n\t     * Configures and establishes the Bayeux communication with the Bayeux server\n\t     * via a handshake and a subsequent connect.\n\t     * @param configuration the configuration object\n\t     * @param handshakeProps an object to be merged with the handshake message\n\t     * @see #configure(configuration)\n\t     * @see #handshake(handshakeProps)\n\t     */\n\t    this.init = function(configuration, handshakeProps) {\n\t        this.configure(configuration);\n\t        this.handshake(handshakeProps);\n\t    };\n\t\n\t    /**\n\t     * Establishes the Bayeux communication with the Bayeux server\n\t     * via a handshake and a subsequent connect.\n\t     * @param handshakeProps an object to be merged with the handshake message\n\t     * @param handshakeCallback a function to be invoked when the handshake is acknowledged\n\t     */\n\t    this.handshake = function(handshakeProps, handshakeCallback) {\n\t        _setStatus('disconnected');\n\t        _reestablish = false;\n\t        _handshake(handshakeProps, handshakeCallback);\n\t    };\n\t\n\t    /**\n\t     * Disconnects from the Bayeux server.\n\t     * It is possible to suggest to attempt a synchronous disconnect, but this feature\n\t     * may only be available in certain transports (for example, long-polling may support\n\t     * it, callback-polling certainly does not).\n\t     * @param sync whether attempt to perform a synchronous disconnect\n\t     * @param disconnectProps an object to be merged with the disconnect message\n\t     * @param disconnectCallback a function to be invoked when the disconnect is acknowledged\n\t     */\n\t    this.disconnect = function(sync, disconnectProps, disconnectCallback) {\n\t        if (_isDisconnected()) {\n\t            return;\n\t        }\n\t\n\t        if (typeof sync !== 'boolean') {\n\t            disconnectCallback = disconnectProps;\n\t            disconnectProps = sync;\n\t            sync = false;\n\t        }\n\t        if (_isFunction(disconnectProps)) {\n\t            disconnectCallback = disconnectProps;\n\t            disconnectProps = undefined;\n\t        }\n\t\n\t        var bayeuxMessage = {\n\t            id: _nextMessageId(),\n\t            channel: '/meta/disconnect'\n\t        };\n\t        // Do not allow the user to override important fields.\n\t        var message = this._mixin(false, {}, disconnectProps, bayeuxMessage);\n\t\n\t        // Save the callback.\n\t        _cometd._putCallback(message.id, disconnectCallback);\n\t\n\t        _setStatus('disconnecting');\n\t        _send(sync === true, [message], false, 'disconnect');\n\t    };\n\t\n\t    /**\n\t     * Marks the start of a batch of application messages to be sent to the server\n\t     * in a single request, obtaining a single response containing (possibly) many\n\t     * application reply messages.\n\t     * Messages are held in a queue and not sent until {@link #endBatch()} is called.\n\t     * If startBatch() is called multiple times, then an equal number of endBatch()\n\t     * calls must be made to close and send the batch of messages.\n\t     * @see #endBatch()\n\t     */\n\t    this.startBatch = function() {\n\t        _startBatch();\n\t    };\n\t\n\t    /**\n\t     * Marks the end of a batch of application messages to be sent to the server\n\t     * in a single request.\n\t     * @see #startBatch()\n\t     */\n\t    this.endBatch = function() {\n\t        _endBatch();\n\t    };\n\t\n\t    /**\n\t     * Executes the given callback in the given scope, surrounded by a {@link #startBatch()}\n\t     * and {@link #endBatch()} calls.\n\t     * @param scope the scope of the callback, may be omitted\n\t     * @param callback the callback to be executed within {@link #startBatch()} and {@link #endBatch()} calls\n\t     */\n\t    this.batch = function(scope, callback) {\n\t        var delegate = _resolveScopedCallback(scope, callback);\n\t        this.startBatch();\n\t        try {\n\t            delegate.method.call(delegate.scope);\n\t            this.endBatch();\n\t        } catch (x) {\n\t            this._info('Exception during execution of batch', x);\n\t            this.endBatch();\n\t            throw x;\n\t        }\n\t    };\n\t\n\t    /**\n\t     * Adds a listener for bayeux messages, performing the given callback in the given scope\n\t     * when a message for the given channel arrives.\n\t     * @param channel the channel the listener is interested to\n\t     * @param scope the scope of the callback, may be omitted\n\t     * @param callback the callback to call when a message is sent to the channel\n\t     * @returns the subscription handle to be passed to {@link #removeListener(object)}\n\t     * @see #removeListener(subscription)\n\t     */\n\t    this.addListener = function(channel, scope, callback) {\n\t        if (arguments.length < 2) {\n\t            throw 'Illegal arguments number: required 2, got ' + arguments.length;\n\t        }\n\t        if (!_isString(channel)) {\n\t            throw 'Illegal argument type: channel must be a string';\n\t        }\n\t\n\t        return _addListener(channel, scope, callback, true);\n\t    };\n\t\n\t    /**\n\t     * Removes the subscription obtained with a call to {@link #addListener(string, object, function)}.\n\t     * @param subscription the subscription to unsubscribe.\n\t     * @see #addListener(channel, scope, callback)\n\t     */\n\t    this.removeListener = function(subscription) {\n\t        // Beware of subscription.id == 0, which is falsy => cannot use !subscription.id\n\t        if (!subscription || !subscription.channel || !(\"id\" in subscription)) {\n\t            throw 'Invalid argument: expected subscription, not ' + subscription;\n\t        }\n\t\n\t        _removeListener(subscription);\n\t    };\n\t\n\t    /**\n\t     * Removes all listeners registered with {@link #addListener(channel, scope, callback)} or\n\t     * {@link #subscribe(channel, scope, callback)}.\n\t     */\n\t    this.clearListeners = function() {\n\t        _listeners = {};\n\t    };\n\t\n\t    /**\n\t     * Subscribes to the given channel, performing the given callback in the given scope\n\t     * when a message for the channel arrives.\n\t     * @param channel the channel to subscribe to\n\t     * @param scope the scope of the callback, may be omitted\n\t     * @param callback the callback to call when a message is sent to the channel\n\t     * @param subscribeProps an object to be merged with the subscribe message\n\t     * @param subscribeCallback a function to be invoked when the subscription is acknowledged\n\t     * @return the subscription handle to be passed to {@link #unsubscribe(object)}\n\t     */\n\t    this.subscribe = function(channel, scope, callback, subscribeProps, subscribeCallback) {\n\t        if (arguments.length < 2) {\n\t            throw 'Illegal arguments number: required 2, got ' + arguments.length;\n\t        }\n\t        if (!_isString(channel)) {\n\t            throw 'Illegal argument type: channel must be a string';\n\t        }\n\t        if (_isDisconnected()) {\n\t            throw 'Illegal state: already disconnected';\n\t        }\n\t\n\t        // Normalize arguments\n\t        if (_isFunction(scope)) {\n\t            subscribeCallback = subscribeProps;\n\t            subscribeProps = callback;\n\t            callback = scope;\n\t            scope = undefined;\n\t        }\n\t        if (_isFunction(subscribeProps)) {\n\t            subscribeCallback = subscribeProps;\n\t            subscribeProps = undefined;\n\t        }\n\t\n\t        // Only send the message to the server if this client has not yet subscribed to the channel\n\t        var send = !_hasSubscriptions(channel);\n\t\n\t        var subscription = _addListener(channel, scope, callback, false);\n\t\n\t        if (send) {\n\t            // Send the subscription message after the subscription registration to avoid\n\t            // races where the server would send a message to the subscribers, but here\n\t            // on the client the subscription has not been added yet to the data structures\n\t            var bayeuxMessage = {\n\t                id: _nextMessageId(),\n\t                channel: '/meta/subscribe',\n\t                subscription: channel\n\t            };\n\t            // Do not allow the user to override important fields.\n\t            var message = this._mixin(false, {}, subscribeProps, bayeuxMessage);\n\t\n\t            // Save the callback.\n\t            _cometd._putCallback(message.id, subscribeCallback);\n\t\n\t            _queueSend(message);\n\t        }\n\t\n\t        return subscription;\n\t    };\n\t\n\t    /**\n\t     * Unsubscribes the subscription obtained with a call to {@link #subscribe(string, object, function)}.\n\t     * @param subscription the subscription to unsubscribe.\n\t     * @param unsubscribeProps an object to be merged with the unsubscribe message\n\t     * @param unsubscribeCallback a function to be invoked when the unsubscription is acknowledged\n\t     */\n\t    this.unsubscribe = function(subscription, unsubscribeProps, unsubscribeCallback) {\n\t        if (arguments.length < 1) {\n\t            throw 'Illegal arguments number: required 1, got ' + arguments.length;\n\t        }\n\t        if (_isDisconnected()) {\n\t            throw 'Illegal state: already disconnected';\n\t        }\n\t\n\t        if (_isFunction(unsubscribeProps)) {\n\t            unsubscribeCallback = unsubscribeProps;\n\t            unsubscribeProps = undefined;\n\t        }\n\t\n\t        // Remove the local listener before sending the message\n\t        // This ensures that if the server fails, this client does not get notifications\n\t        this.removeListener(subscription);\n\t\n\t        var channel = subscription.channel;\n\t        // Only send the message to the server if this client unsubscribes the last subscription\n\t        if (!_hasSubscriptions(channel)) {\n\t            var bayeuxMessage = {\n\t                id: _nextMessageId(),\n\t                channel: '/meta/unsubscribe',\n\t                subscription: channel\n\t            };\n\t            // Do not allow the user to override important fields.\n\t            var message = this._mixin(false, {}, unsubscribeProps, bayeuxMessage);\n\t\n\t            // Save the callback.\n\t            _cometd._putCallback(message.id, unsubscribeCallback);\n\t\n\t            _queueSend(message);\n\t        }\n\t    };\n\t\n\t    this.resubscribe = function(subscription, subscribeProps) {\n\t        _removeSubscription(subscription);\n\t        if (subscription) {\n\t            return this.subscribe(subscription.channel, subscription.scope, subscription.callback, subscribeProps);\n\t        }\n\t        return undefined;\n\t    };\n\t\n\t    /**\n\t     * Removes all subscriptions added via {@link #subscribe(channel, scope, callback, subscribeProps)},\n\t     * but does not remove the listeners added via {@link addListener(channel, scope, callback)}.\n\t     */\n\t    this.clearSubscriptions = function() {\n\t        _clearSubscriptions();\n\t    };\n\t\n\t    /**\n\t     * Publishes a message on the given channel, containing the given content.\n\t     * @param channel the channel to publish the message to\n\t     * @param content the content of the message\n\t     * @param publishProps an object to be merged with the publish message\n\t     * @param publishCallback a function to be invoked when the publish is acknowledged by the server\n\t     */\n\t    this.publish = function(channel, content, publishProps, publishCallback) {\n\t        if (arguments.length < 1) {\n\t            throw 'Illegal arguments number: required 1, got ' + arguments.length;\n\t        }\n\t        if (!_isString(channel)) {\n\t            throw 'Illegal argument type: channel must be a string';\n\t        }\n\t        if (/^\\/meta\\//.test(channel)) {\n\t            throw 'Illegal argument: cannot publish to meta channels';\n\t        }\n\t        if (_isDisconnected()) {\n\t            throw 'Illegal state: already disconnected';\n\t        }\n\t\n\t        if (_isFunction(content)) {\n\t            publishCallback = content;\n\t            content = publishProps = {};\n\t        } else if (_isFunction(publishProps)) {\n\t            publishCallback = publishProps;\n\t            publishProps = {};\n\t        }\n\t\n\t        var bayeuxMessage = {\n\t            id: _nextMessageId(),\n\t            channel: channel,\n\t            data: content\n\t        };\n\t        // Do not allow the user to override important fields.\n\t        var message = this._mixin(false, {}, publishProps, bayeuxMessage);\n\t\n\t        // Save the callback.\n\t        _cometd._putCallback(message.id, publishCallback);\n\t\n\t        _queueSend(message);\n\t    };\n\t\n\t    this.remoteCall = function(target, content, timeout, callback) {\n\t        if (arguments.length < 1) {\n\t            throw 'Illegal arguments number: required 1, got ' + arguments.length;\n\t        }\n\t        if (!_isString(target)) {\n\t            throw 'Illegal argument type: target must be a string';\n\t        }\n\t        if (_isDisconnected()) {\n\t            throw 'Illegal state: already disconnected';\n\t        }\n\t\n\t        if (_isFunction(content)) {\n\t            callback = content;\n\t            content = {};\n\t            timeout = _config.maxNetworkDelay;\n\t        } else if (_isFunction(timeout)) {\n\t            callback = timeout;\n\t            timeout = _config.maxNetworkDelay;\n\t        }\n\t\n\t        if (typeof timeout !== 'number') {\n\t            throw 'Illegal argument type: timeout must be a number';\n\t        }\n\t\n\t        if (!target.match(/^\\//)) {\n\t            target = '/' + target;\n\t        }\n\t        var channel = '/service' + target;\n\t\n\t        var bayeuxMessage = {\n\t            id: _nextMessageId(),\n\t            channel: channel,\n\t            data: content\n\t        };\n\t\n\t        var context = {\n\t            callback: callback\n\t        };\n\t        if (timeout > 0) {\n\t            context.timeout = Utils.setTimeout(_cometd, function() {\n\t                _cometd._debug('Timing out remote call', bayeuxMessage, 'after', timeout, 'ms');\n\t                _failMessage({\n\t                    id: bayeuxMessage.id,\n\t                    error: '406::timeout',\n\t                    successful: false,\n\t                    failure: {\n\t                        message : bayeuxMessage,\n\t                        reason: 'Remote Call Timeout'\n\t                    }\n\t                });\n\t            }, timeout);\n\t            _cometd._debug('Scheduled remote call timeout', bayeuxMessage, 'in', timeout, 'ms');\n\t        }\n\t        _remoteCalls[bayeuxMessage.id] = context;\n\t\n\t        _queueSend(bayeuxMessage);\n\t    };\n\t\n\t    /**\n\t     * Returns a string representing the status of the bayeux communication with the Bayeux server.\n\t     */\n\t    this.getStatus = function() {\n\t        return _status;\n\t    };\n\t\n\t    /**\n\t     * Returns whether this instance has been disconnected.\n\t     */\n\t    this.isDisconnected = _isDisconnected;\n\t\n\t    /**\n\t     * Sets the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.\n\t     * Default value is 1 second, which means if there is a persistent failure the retries will happen\n\t     * after 1 second, then after 2 seconds, then after 3 seconds, etc. So for example with 15 seconds of\n\t     * elapsed time, there will be 5 retries (at 1, 3, 6, 10 and 15 seconds elapsed).\n\t     * @param period the backoff period to set\n\t     * @see #getBackoffIncrement()\n\t     */\n\t    this.setBackoffIncrement = function(period) {\n\t        _config.backoffIncrement = period;\n\t    };\n\t\n\t    /**\n\t     * Returns the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.\n\t     * @see #setBackoffIncrement(period)\n\t     */\n\t    this.getBackoffIncrement = function() {\n\t        return _config.backoffIncrement;\n\t    };\n\t\n\t    /**\n\t     * Returns the backoff period to wait before retrying an unsuccessful or failed message.\n\t     */\n\t    this.getBackoffPeriod = function() {\n\t        return _backoff;\n\t    };\n\t\n\t    /**\n\t     * Increases the backoff period up to the maximum value configured.\n\t     * @returns the backoff period after increment\n\t     * @see getBackoffIncrement\n\t     */\n\t    this.increaseBackoffPeriod = function() {\n\t        return _increaseBackoff();\n\t    };\n\t\n\t    /**\n\t     * Resets the backoff period to zero.\n\t     */\n\t    this.resetBackoffPeriod = function() {\n\t        _resetBackoff();\n\t    };\n\t\n\t    /**\n\t     * Sets the log level for console logging.\n\t     * Valid values are the strings 'error', 'warn', 'info' and 'debug', from\n\t     * less verbose to more verbose.\n\t     * @param level the log level string\n\t     */\n\t    this.setLogLevel = function(level) {\n\t        _config.logLevel = level;\n\t    };\n\t\n\t    /**\n\t     * Registers an extension whose callbacks are called for every incoming message\n\t     * (that comes from the server to this client implementation) and for every\n\t     * outgoing message (that originates from this client implementation for the\n\t     * server).\n\t     * The format of the extension object is the following:\n\t     * <pre>\n\t     * {\n\t     *     incoming: function(message) { ... },\n\t     *     outgoing: function(message) { ... }\n\t     * }\n\t     * </pre>\n\t     * Both properties are optional, but if they are present they will be called\n\t     * respectively for each incoming message and for each outgoing message.\n\t     * @param name the name of the extension\n\t     * @param extension the extension to register\n\t     * @return true if the extension was registered, false otherwise\n\t     * @see #unregisterExtension(name)\n\t     */\n\t    this.registerExtension = function(name, extension) {\n\t        if (arguments.length < 2) {\n\t            throw 'Illegal arguments number: required 2, got ' + arguments.length;\n\t        }\n\t        if (!_isString(name)) {\n\t            throw 'Illegal argument type: extension name must be a string';\n\t        }\n\t\n\t        var existing = false;\n\t        for (var i = 0; i < _extensions.length; ++i) {\n\t            var existingExtension = _extensions[i];\n\t            if (existingExtension.name === name) {\n\t                existing = true;\n\t                break;\n\t            }\n\t        }\n\t        if (!existing) {\n\t            _extensions.push({\n\t                name: name,\n\t                extension: extension\n\t            });\n\t            this._debug('Registered extension', name);\n\t\n\t            // Callback for extensions\n\t            if (_isFunction(extension.registered)) {\n\t                extension.registered(name, this);\n\t            }\n\t\n\t            return true;\n\t        } else {\n\t            this._info('Could not register extension with name', name, 'since another extension with the same name already exists');\n\t            return false;\n\t        }\n\t    };\n\t\n\t    /**\n\t     * Unregister an extension previously registered with\n\t     * {@link #registerExtension(name, extension)}.\n\t     * @param name the name of the extension to unregister.\n\t     * @return true if the extension was unregistered, false otherwise\n\t     */\n\t    this.unregisterExtension = function(name) {\n\t        if (!_isString(name)) {\n\t            throw 'Illegal argument type: extension name must be a string';\n\t        }\n\t\n\t        var unregistered = false;\n\t        for (var i = 0; i < _extensions.length; ++i) {\n\t            var extension = _extensions[i];\n\t            if (extension.name === name) {\n\t                _extensions.splice(i, 1);\n\t                unregistered = true;\n\t                this._debug('Unregistered extension', name);\n\t\n\t                // Callback for extensions\n\t                var ext = extension.extension;\n\t                if (_isFunction(ext.unregistered)) {\n\t                    ext.unregistered();\n\t                }\n\t\n\t                break;\n\t            }\n\t        }\n\t        return unregistered;\n\t    };\n\t\n\t    /**\n\t     * Find the extension registered with the given name.\n\t     * @param name the name of the extension to find\n\t     * @return the extension found or null if no extension with the given name has been registered\n\t     */\n\t    this.getExtension = function(name) {\n\t        for (var i = 0; i < _extensions.length; ++i) {\n\t            var extension = _extensions[i];\n\t            if (extension.name === name) {\n\t                return extension.extension;\n\t            }\n\t        }\n\t        return null;\n\t    };\n\t\n\t    /**\n\t     * Returns the name assigned to this CometD object, or the string 'default'\n\t     * if no name has been explicitly passed as parameter to the constructor.\n\t     */\n\t    this.getName = function() {\n\t        return _name;\n\t    };\n\t\n\t    /**\n\t     * Returns the clientId assigned by the Bayeux server during handshake.\n\t     */\n\t    this.getClientId = function() {\n\t        return _clientId;\n\t    };\n\t\n\t    /**\n\t     * Returns the URL of the Bayeux server.\n\t     */\n\t    this.getURL = function() {\n\t        if (_transport) {\n\t            var url = _transport.getURL();\n\t            if (url) {\n\t                return url;\n\t            }\n\t            url = _config.urls[_transport.getType()];\n\t            if (url) {\n\t                return url;\n\t            }\n\t        }\n\t        return _config.url;\n\t    };\n\t\n\t    this.getTransport = function() {\n\t        return _transport;\n\t    };\n\t\n\t    this.getConfiguration = function() {\n\t        return this._mixin(true, {}, _config);\n\t    };\n\t\n\t    this.getAdvice = function() {\n\t        return this._mixin(true, {}, _advice);\n\t    };\n\t};\n\n\n/***/ },\n/* 104 */\n/***/ function(module, exports) {\n\n\t/**\n\t * A registry for transports used by the CometD object.\n\t */\n\tmodule.exports = function TransportRegistry() {\n\t    var _types = [];\n\t    var _transports = {};\n\t\n\t    this.getTransportTypes = function() {\n\t        return _types.slice(0);\n\t    };\n\t\n\t    this.findTransportTypes = function(version, crossDomain, url) {\n\t        var result = [];\n\t        for (var i = 0; i < _types.length; ++i) {\n\t            var type = _types[i];\n\t            if (_transports[type].accept(version, crossDomain, url) === true) {\n\t                result.push(type);\n\t            }\n\t        }\n\t        return result;\n\t    };\n\t\n\t    this.negotiateTransport = function(types, version, crossDomain, url) {\n\t        for (var i = 0; i < _types.length; ++i) {\n\t            var type = _types[i];\n\t            for (var j = 0; j < types.length; ++j) {\n\t                if (type === types[j]) {\n\t                    var transport = _transports[type];\n\t                    if (transport.accept(version, crossDomain, url) === true) {\n\t                        return transport;\n\t                    }\n\t                }\n\t            }\n\t        }\n\t        return null;\n\t    };\n\t\n\t    this.add = function(type, transport, index) {\n\t        var existing = false;\n\t        for (var i = 0; i < _types.length; ++i) {\n\t            if (_types[i] === type) {\n\t                existing = true;\n\t                break;\n\t            }\n\t        }\n\t\n\t        if (!existing) {\n\t            if (typeof index !== 'number') {\n\t                _types.push(type);\n\t            } else {\n\t                _types.splice(index, 0, type);\n\t            }\n\t            _transports[type] = transport;\n\t        }\n\t\n\t        return !existing;\n\t    };\n\t\n\t    this.find = function(type) {\n\t        for (var i = 0; i < _types.length; ++i) {\n\t            if (_types[i] === type) {\n\t                return _transports[type];\n\t            }\n\t        }\n\t        return null;\n\t    };\n\t\n\t    this.remove = function(type) {\n\t        for (var i = 0; i < _types.length; ++i) {\n\t            if (_types[i] === type) {\n\t                _types.splice(i, 1);\n\t                var transport = _transports[type];\n\t                delete _transports[type];\n\t                return transport;\n\t            }\n\t        }\n\t        return null;\n\t    };\n\t\n\t    this.clear = function() {\n\t        _types = [];\n\t        _transports = {};\n\t    };\n\t\n\t    this.reset = function(init) {\n\t        for (var i = 0; i < _types.length; ++i) {\n\t            _transports[_types[i]].reset(init);\n\t        }\n\t    };\n\t};\n\n\n/***/ },\n/* 105 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Transport = __webpack_require__(100);\n\tvar RequestTransport = __webpack_require__(102);\n\t\n\tmodule.exports = function LongPollingTransport() {\n\t    var _super = new RequestTransport();\n\t    var _self = Transport.derive(_super);\n\t    // By default, support cross domain\n\t    var _supportsCrossDomain = true;\n\t\n\t    _self.accept = function(version, crossDomain, url) {\n\t        return _supportsCrossDomain || !crossDomain;\n\t    };\n\t\n\t    _self.xhrSend = function(packet) {\n\t        throw 'Abstract';\n\t    };\n\t\n\t    _self.transportSend = function(envelope, request) {\n\t        this._debug('Transport', this.getType(), 'sending request', request.id, 'envelope', envelope);\n\t\n\t        var self = this;\n\t        try {\n\t            var sameStack = true;\n\t            request.xhr = this.xhrSend({\n\t                transport: this,\n\t                url: envelope.url,\n\t                sync: envelope.sync,\n\t                headers: this.getConfiguration().requestHeaders,\n\t                body: JSON.stringify(envelope.messages),\n\t                onSuccess: function(response) {\n\t                    self._debug('Transport', self.getType(), 'received response', response);\n\t                    var success = false;\n\t                    try {\n\t                        var received = self.convertToMessages(response);\n\t                        if (received.length === 0) {\n\t                            _supportsCrossDomain = false;\n\t                            self.transportFailure(envelope, request, {\n\t                                httpCode: 204\n\t                            });\n\t                        } else {\n\t                            success = true;\n\t                            self.transportSuccess(envelope, request, received);\n\t                        }\n\t                    } catch (x) {\n\t                        self._debug(x);\n\t                        if (!success) {\n\t                            _supportsCrossDomain = false;\n\t                            var failure = {\n\t                                exception: x\n\t                            };\n\t                            failure.httpCode = self.xhrStatus(request.xhr);\n\t                            self.transportFailure(envelope, request, failure);\n\t                        }\n\t                    }\n\t                },\n\t                onError: function(reason, exception) {\n\t                    self._debug('Transport', self.getType(), 'received error', reason, exception);\n\t                    _supportsCrossDomain = false;\n\t                    var failure = {\n\t                        reason: reason,\n\t                        exception: exception\n\t                    };\n\t                    failure.httpCode = self.xhrStatus(request.xhr);\n\t                    if (sameStack) {\n\t                        // Keep the semantic of calling response callbacks asynchronously after the request\n\t                        self.setTimeout(function() {\n\t                            self.transportFailure(envelope, request, failure);\n\t                        }, 0);\n\t                    } else {\n\t                        self.transportFailure(envelope, request, failure);\n\t                    }\n\t                }\n\t            });\n\t            sameStack = false;\n\t        } catch (x) {\n\t            _supportsCrossDomain = false;\n\t            // Keep the semantic of calling response callbacks asynchronously after the request\n\t            self.setTimeout(function() {\n\t                self.transportFailure(envelope, request, {\n\t                    exception: x\n\t                });\n\t            }, 0);\n\t        }\n\t    };\n\t\n\t    _self.reset = function(init) {\n\t        _super.reset(init);\n\t        _supportsCrossDomain = true;\n\t    };\n\t\n\t    return _self;\n\t};\n\n\n/***/ },\n/* 106 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar Transport = __webpack_require__(100)\n\tvar Utils = __webpack_require__(101)\n\t\n\tmodule.exports = function WebSocketTransport() {\n\t    var _super = new Transport();\n\t    var _self = Transport.derive(_super);\n\t    var _cometd;\n\t    // By default WebSocket is supported\n\t    var _webSocketSupported = true;\n\t    // Whether we were able to establish a WebSocket connection\n\t    var _webSocketConnected = false;\n\t    var _stickyReconnect = true;\n\t    // The context contains the envelopes that have been sent\n\t    // and the timeouts for the messages that have been sent.\n\t    var _context = null;\n\t    var _connecting = null;\n\t    var _connected = false;\n\t    var _successCallback = null;\n\t\n\t    _self.reset = function(init) {\n\t        _super.reset(init);\n\t        _webSocketSupported = true;\n\t        if (init) {\n\t            _webSocketConnected = false;\n\t        }\n\t        _stickyReconnect = true;\n\t        _context = null;\n\t        _connecting = null;\n\t        _connected = false;\n\t    };\n\t\n\t    function _forceClose(context, event) {\n\t        if (context) {\n\t            this.webSocketClose(context, event.code, event.reason);\n\t            // Force immediate failure of pending messages to trigger reconnect.\n\t            // This is needed because the server may not reply to our close()\n\t            // and therefore the onclose function is never called.\n\t            this.onClose(context, event);\n\t        }\n\t    }\n\t\n\t    function _sameContext(context) {\n\t        return context === _connecting || context === _context;\n\t    }\n\t\n\t    function _storeEnvelope(context, envelope, metaConnect) {\n\t        var messageIds = [];\n\t        for (var i = 0; i < envelope.messages.length; ++i) {\n\t            var message = envelope.messages[i];\n\t            if (message.id) {\n\t                messageIds.push(message.id);\n\t            }\n\t        }\n\t        context.envelopes[messageIds.join(',')] = [envelope, metaConnect];\n\t        this._debug('Transport', this.getType(), 'stored envelope, envelopes', context.envelopes);\n\t    }\n\t\n\t    function _websocketConnect(context) {\n\t        // We may have multiple attempts to open a WebSocket\n\t        // connection, for example a /meta/connect request that\n\t        // may take time, along with a user-triggered publish.\n\t        // Early return if we are already connecting.\n\t        if (_connecting) {\n\t            return;\n\t        }\n\t\n\t        // Mangle the URL, changing the scheme from 'http' to 'ws'.\n\t        var url = _cometd.getURL().replace(/^http/, 'ws');\n\t        this._debug('Transport', this.getType(), 'connecting to URL', url);\n\t\n\t        try {\n\t            var protocol = _cometd.getConfiguration().protocol;\n\t            context.webSocket = protocol ? new WebSocket(url, protocol) : new WebSocket(url);\n\t            _connecting = context;\n\t        } catch (x) {\n\t            _webSocketSupported = false;\n\t            this._debug('Exception while creating WebSocket object', x);\n\t            throw x;\n\t        }\n\t\n\t        // By default use sticky reconnects.\n\t        _stickyReconnect = _cometd.getConfiguration().stickyReconnect !== false;\n\t\n\t        var self = this;\n\t        var connectTimeout = _cometd.getConfiguration().connectTimeout;\n\t        if (connectTimeout > 0) {\n\t            context.connectTimer = self.setTimeout(function() {\n\t                _cometd._debug('Transport', self.getType(), 'timed out while connecting to URL', url, ':', connectTimeout, 'ms');\n\t                // The connection was not opened, close anyway.\n\t                _forceClose.call(self, context, {code: 1000, reason: 'Connect Timeout'});\n\t            }, connectTimeout);\n\t        }\n\t\n\t        var onopen = function() {\n\t            _cometd._debug('WebSocket onopen', context);\n\t            if (context.connectTimer) {\n\t                self.clearTimeout(context.connectTimer);\n\t            }\n\t\n\t            if (_sameContext(context)) {\n\t                _connecting = null;\n\t                _context = context;\n\t                _webSocketConnected = true;\n\t                self.onOpen(context);\n\t            } else {\n\t                // We have a valid connection already, close this one.\n\t                _cometd._warn('Closing extra WebSocket connection', this, 'active connection', _context);\n\t                _forceClose.call(self, context, {code: 1000, reason: 'Extra Connection'});\n\t            }\n\t        };\n\t\n\t        // This callback is invoked when the server sends the close frame.\n\t        // The close frame for a connection may arrive *after* another\n\t        // connection has been opened, so we must make sure that actions\n\t        // are performed only if it's the same connection.\n\t        var onclose = function(event) {\n\t            event = event || {code: 1000};\n\t            _cometd._debug('WebSocket onclose', context, event, 'connecting', _connecting, 'current', _context);\n\t\n\t            if (context.connectTimer) {\n\t                self.clearTimeout(context.connectTimer);\n\t            }\n\t\n\t            self.onClose(context, event);\n\t        };\n\t\n\t        var onmessage = function(wsMessage) {\n\t            _cometd._debug('WebSocket onmessage', wsMessage, context);\n\t            self.onMessage(context, wsMessage);\n\t        };\n\t\n\t        context.webSocket.onopen = onopen;\n\t        context.webSocket.onclose = onclose;\n\t        context.webSocket.onerror = function() {\n\t            // Clients should call onclose(), but if they do not we do it here for safety.\n\t            onclose({code: 1000, reason: 'Error'});\n\t        };\n\t        context.webSocket.onmessage = onmessage;\n\t\n\t        this._debug('Transport', this.getType(), 'configured callbacks on', context);\n\t    }\n\t\n\t    function _webSocketSend(context, envelope, metaConnect) {\n\t        var json = JSON.stringify(envelope.messages);\n\t        context.webSocket.send(json);\n\t        this._debug('Transport', this.getType(), 'sent', envelope, 'metaConnect =', metaConnect);\n\t\n\t        // Manage the timeout waiting for the response.\n\t        var maxDelay = this.getConfiguration().maxNetworkDelay;\n\t        var delay = maxDelay;\n\t        if (metaConnect) {\n\t            delay += this.getAdvice().timeout;\n\t            _connected = true;\n\t        }\n\t\n\t        var self = this;\n\t        var messageIds = [];\n\t        for (var i = 0; i < envelope.messages.length; ++i) {\n\t            (function() {\n\t                var message = envelope.messages[i];\n\t                if (message.id) {\n\t                    messageIds.push(message.id);\n\t                    context.timeouts[message.id] = self.setTimeout(function() {\n\t                        _cometd._debug('Transport', self.getType(), 'timing out message', message.id, 'after', delay, 'on', context);\n\t                        _forceClose.call(self, context, {code: 1000, reason: 'Message Timeout'});\n\t                    }, delay);\n\t                }\n\t            })();\n\t        }\n\t\n\t        this._debug('Transport', this.getType(), 'waiting at most', delay, 'ms for messages', messageIds, 'maxNetworkDelay', maxDelay, ', timeouts:', context.timeouts);\n\t    }\n\t\n\t    _self._notifySuccess = function(fn, messages) {\n\t        fn.call(this, messages);\n\t    };\n\t\n\t    _self._notifyFailure = function(fn, context, messages, failure) {\n\t        fn.call(this, context, messages, failure);\n\t    };\n\t\n\t    function _send(context, envelope, metaConnect) {\n\t        try {\n\t            if (context === null) {\n\t                context = _connecting || {\n\t                        envelopes: {},\n\t                        timeouts: {}\n\t                    };\n\t                _storeEnvelope.call(this, context, envelope, metaConnect);\n\t                _websocketConnect.call(this, context);\n\t            } else {\n\t                _storeEnvelope.call(this, context, envelope, metaConnect);\n\t                _webSocketSend.call(this, context, envelope, metaConnect);\n\t            }\n\t        } catch (x) {\n\t            // Keep the semantic of calling response callbacks asynchronously after the request.\n\t            var self = this;\n\t            self.setTimeout(function() {\n\t                _forceClose.call(self, context, {\n\t                    code: 1000,\n\t                    reason: 'Exception',\n\t                    exception: x\n\t                });\n\t            }, 0);\n\t        }\n\t    }\n\t\n\t    _self.onOpen = function(context) {\n\t        var envelopes = context.envelopes;\n\t        this._debug('Transport', this.getType(), 'opened', context, 'pending messages', envelopes);\n\t        for (var key in envelopes) {\n\t            if (envelopes.hasOwnProperty(key)) {\n\t                var element = envelopes[key];\n\t                var envelope = element[0];\n\t                var metaConnect = element[1];\n\t                // Store the success callback, which is independent from the envelope,\n\t                // so that it can be used to notify arrival of messages.\n\t                _successCallback = envelope.onSuccess;\n\t                _webSocketSend.call(this, context, envelope, metaConnect);\n\t            }\n\t        }\n\t    };\n\t\n\t    _self.onMessage = function(context, wsMessage) {\n\t        this._debug('Transport', this.getType(), 'received websocket message', wsMessage, context);\n\t\n\t        var close = false;\n\t        var messages = this.convertToMessages(wsMessage.data);\n\t        var messageIds = [];\n\t        for (var i = 0; i < messages.length; ++i) {\n\t            var message = messages[i];\n\t\n\t            // Detect if the message is a response to a request we made.\n\t            // If it's a meta message, for sure it's a response; otherwise it's\n\t            // a publish message and publish responses don't have the data field.\n\t            if (/^\\/meta\\//.test(message.channel) || message.data === undefined) {\n\t                if (message.id) {\n\t                    messageIds.push(message.id);\n\t\n\t                    var timeout = context.timeouts[message.id];\n\t                    if (timeout) {\n\t                        this.clearTimeout(timeout);\n\t                        delete context.timeouts[message.id];\n\t                        this._debug('Transport', this.getType(), 'removed timeout for message', message.id, ', timeouts', context.timeouts);\n\t                    }\n\t                }\n\t            }\n\t\n\t            if ('/meta/connect' === message.channel) {\n\t                _connected = false;\n\t            }\n\t            if ('/meta/disconnect' === message.channel && !_connected) {\n\t                close = true;\n\t            }\n\t        }\n\t\n\t        // Remove the envelope corresponding to the messages.\n\t        var removed = false;\n\t        var envelopes = context.envelopes;\n\t        for (var j = 0; j < messageIds.length; ++j) {\n\t            var id = messageIds[j];\n\t            for (var key in envelopes) {\n\t                if (envelopes.hasOwnProperty(key)) {\n\t                    var ids = key.split(',');\n\t                    var index = Utils.inArray(id, ids);\n\t                    if (index >= 0) {\n\t                        removed = true;\n\t                        ids.splice(index, 1);\n\t                        var envelope = envelopes[key][0];\n\t                        var metaConnect = envelopes[key][1];\n\t                        delete envelopes[key];\n\t                        if (ids.length > 0) {\n\t                            envelopes[ids.join(',')] = [envelope, metaConnect];\n\t                        }\n\t                        break;\n\t                    }\n\t                }\n\t            }\n\t        }\n\t        if (removed) {\n\t            this._debug('Transport', this.getType(), 'removed envelope, envelopes', envelopes);\n\t        }\n\t\n\t        this._notifySuccess(_successCallback, messages);\n\t\n\t        if (close) {\n\t            this.webSocketClose(context, 1000, 'Disconnect');\n\t        }\n\t    };\n\t\n\t    _self.onClose = function(context, event) {\n\t        this._debug('Transport', this.getType(), 'closed', context, event);\n\t\n\t        if (_sameContext(context)) {\n\t            // Remember if we were able to connect.\n\t            // This close event could be due to server shutdown,\n\t            // and if it restarts we want to try websocket again.\n\t            _webSocketSupported = _stickyReconnect && _webSocketConnected;\n\t            _connecting = null;\n\t            _context = null;\n\t        }\n\t\n\t        var timeouts = context.timeouts;\n\t        context.timeouts = {};\n\t        for (var id in timeouts) {\n\t            if (timeouts.hasOwnProperty(id)) {\n\t                this.clearTimeout(timeouts[id]);\n\t            }\n\t        }\n\t\n\t        var envelopes = context.envelopes;\n\t        context.envelopes = {};\n\t        for (var key in envelopes) {\n\t            if (envelopes.hasOwnProperty(key)) {\n\t                var envelope = envelopes[key][0];\n\t                var metaConnect = envelopes[key][1];\n\t                if (metaConnect) {\n\t                    _connected = false;\n\t                }\n\t                var failure = {\n\t                    websocketCode: event.code,\n\t                    reason: event.reason\n\t                };\n\t                if (event.exception) {\n\t                    failure.exception = event.exception;\n\t                }\n\t                this._notifyFailure(envelope.onFailure, context, envelope.messages, failure);\n\t            }\n\t        }\n\t    };\n\t\n\t    _self.registered = function(type, cometd) {\n\t        _super.registered(type, cometd);\n\t        _cometd = cometd;\n\t    };\n\t\n\t    _self.accept = function(version, crossDomain, url) {\n\t        this._debug('Transport', this.getType(), 'accept, supported:', _webSocketSupported);\n\t        // Using !! to return a boolean (and not the WebSocket object).\n\t        return _webSocketSupported && !('undefined' === typeof WebSocket) && _cometd.websocketEnabled !== false;\n\t    };\n\t\n\t    _self.send = function(envelope, metaConnect) {\n\t        this._debug('Transport', this.getType(), 'sending', envelope, 'metaConnect =', metaConnect);\n\t        _send.call(this, _context, envelope, metaConnect);\n\t    };\n\t\n\t    _self.webSocketClose = function(context, code, reason) {\n\t        try {\n\t            if (context.webSocket) {\n\t                context.webSocket.close(code, reason);\n\t            }\n\t        } catch (x) {\n\t            this._debug(x);\n\t        }\n\t    };\n\t\n\t    _self.abort = function() {\n\t        _super.abort();\n\t        _forceClose.call(this, _context, {code: 1000, reason: 'Abort'});\n\t        this.reset(true);\n\t    };\n\t\n\t    return _self;\n\t};\n\n\n/***/ },\n/* 107 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(108), __webpack_require__(109), __webpack_require__(85), __webpack_require__(86), __webpack_require__(112), __webpack_require__(130), __webpack_require__(92)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('babel-runtime/helpers/defineProperty'), require('babel-runtime/core-js/object/get-own-property-names'), require('babel-runtime/helpers/classCallCheck'), require('babel-runtime/helpers/createClass'), require('./helper'), require('../utils/index'), require('../connection/connection-status'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.defineProperty, global.getOwnPropertyNames, global.classCallCheck, global.createClass, global.helper, global.index, global.connectionStatus);\n\t    global.basic = mod.exports;\n\t  }\n\t})(this, function (exports, _defineProperty2, _getOwnPropertyNames, _classCallCheck2, _createClass2, _helper, _index, _connectionStatus) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.Client = undefined;\n\t\n\t  var _defineProperty3 = _interopRequireDefault(_defineProperty2);\n\t\n\t  var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);\n\t\n\t  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t  var _createClass3 = _interopRequireDefault(_createClass2);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  var Client = exports.Client = function () {\n\t    /**\n\t     * Create a new ZetaPush Client\n\t     * @param {ClientConfig} config\n\t     */\n\t    function Client(_ref) {\n\t      var _ref$apiUrl = _ref.apiUrl,\n\t          apiUrl = _ref$apiUrl === undefined ? _index.API_URL : _ref$apiUrl,\n\t          sandboxId = _ref.sandboxId,\n\t          _ref$forceHttps = _ref.forceHttps,\n\t          forceHttps = _ref$forceHttps === undefined ? (0, _index.isHttpsProtocol)() : _ref$forceHttps,\n\t          authentication = _ref.authentication,\n\t          resource = _ref.resource,\n\t          transports = _ref.transports;\n\t      (0, _classCallCheck3.default)(this, Client);\n\t\n\t      /**\n\t       * @access private\n\t       * @type {ClientHelper}\n\t       */\n\t      this.helper = new _helper.ClientHelper({\n\t        apiUrl: apiUrl,\n\t        sandboxId: sandboxId,\n\t        forceHttps: forceHttps,\n\t        authentication: authentication,\n\t        resource: resource,\n\t        transports: transports\n\t      });\n\t    }\n\t    /**\n\t     * Add a connection listener to handle life cycle connection events\n\t     * @param {ConnectionStatusListener} listener\n\t     * @return {number} handler\n\t     */\n\t\n\t\n\t    (0, _createClass3.default)(Client, [{\n\t      key: 'addConnectionStatusListener',\n\t      value: function addConnectionStatusListener(listener) {\n\t        return this.helper.addConnectionStatusListener(listener);\n\t      }\n\t      /**\n\t       * Safely connect client to ZetaPush\n\t       */\n\t\n\t    }, {\n\t      key: 'connect',\n\t      value: function connect() {\n\t        var _this = this;\n\t\n\t        if (this.isConnected()) {\n\t          (function () {\n\t            var handler = _this.addConnectionStatusListener({\n\t              onConnectionClosed: function onConnectionClosed() {\n\t                _this.removeConnectionStatusListener(handler);\n\t                _this.helper.connect();\n\t              }\n\t            });\n\t            _this.disconnect();\n\t          })();\n\t        } else {\n\t          this.helper.connect();\n\t        }\n\t      }\n\t      /**\n\t       * Create a promise based service instance\n\t       * @param {{listener: Object, Type: class, deploymentId: string}} parameters\n\t       * @return {Object} service\n\t       * @example\n\t       * const api = client.createAsyncMacroService({\n\t       *   Type: WelcomeMacro\n\t       * })\n\t       * api.welcome({\n\t       *   message: Hello'\n\t       * }).then(({ message }) => {\n\t       *   console.log(message)\n\t       * })\n\t       */\n\t\n\t    }, {\n\t      key: 'createAsyncMacroService',\n\t      value: function createAsyncMacroService(_ref2) {\n\t        var deploymentId = _ref2.deploymentId,\n\t            listener = _ref2.listener,\n\t            Type = _ref2.Type;\n\t\n\t        return this.helper.createAsyncMacroService({ deploymentId: deploymentId, listener: listener, Type: Type });\n\t      }\n\t      /**\n\t       * Create a publish/subscribe for a service type\n\t       * @param {{listener: Object, Type: class, deploymentId: string}} parameters\n\t       * @return {Object} service\n\t       * @example\n\t       * const service = client.createService({\n\t       *   listener: {\n\t       *     list(message) {\n\t       *       console.log('Stack list callback', message)\n\t       *     },\n\t       *     push(message) {\n\t       *       console.log('Stack push callback', message)\n\t       *     }\n\t       *   },\n\t       *   Type: ZetaPush.services.Stack\n\t       * })\n\t       * service.list({\n\t       *   stack: '<STACK-ID>'\n\t       * })\n\t       * @example\n\t       * // Explicit deploymentId\n\t       * // Authentication provide optional deployment id, according to the following convention `${ServiceType.toLowerCase()_0}`\n\t       * const service = client.createService({\n\t       *   deploymentId: 'stack_0'\n\t       *   listener: {\n\t       *     list(message) {\n\t       *       console.log('Stack list callback', message)\n\t       *     },\n\t       *     push(message) {\n\t       *       console.log('Stack push callback', message)\n\t       *     }\n\t       *   },\n\t       *   Type: ZetaPush.services.Stack\n\t       * })\n\t       * service.list({\n\t       *   stack: '<STACK-ID>'\n\t       * })\n\t       */\n\t\n\t    }, {\n\t      key: 'createService',\n\t      value: function createService(_ref3) {\n\t        var deploymentId = _ref3.deploymentId,\n\t            listener = _ref3.listener,\n\t            Type = _ref3.Type;\n\t\n\t        return this.helper.createService({ deploymentId: deploymentId, listener: listener, Type: Type });\n\t      }\n\t      /**\n\t       * Disonnect client from ZetaPush\n\t       */\n\t\n\t    }, {\n\t      key: 'disconnect',\n\t      value: function disconnect() {\n\t        if (this.isConnected()) {\n\t          this.helper.disconnect();\n\t        }\n\t      }\n\t      /**\n\t       * Is client connected to ZetaPush\n\t       * @return {boolean}\n\t       */\n\t\n\t    }, {\n\t      key: 'isConnected',\n\t      value: function isConnected() {\n\t        return this.helper.isConnected();\n\t      }\n\t      /**\n\t       * Get the client sandbox id\n\t       * @return {string}\n\t       */\n\t\n\t    }, {\n\t      key: 'getSandboxId',\n\t      value: function getSandboxId() {\n\t        return this.helper.getSandboxId();\n\t      }\n\t      /**\n\t       * Get the client resource\n\t       * @return {string}\n\t       */\n\t\n\t    }, {\n\t      key: 'getResource',\n\t      value: function getResource() {\n\t        return this.helper.getResource();\n\t      }\n\t      /**\n\t       * Get the client user id\n\t       * @return {string}\n\t       */\n\t\n\t    }, {\n\t      key: 'getUserId',\n\t      value: function getUserId() {\n\t        return this.helper.getUserId();\n\t      }\n\t      /**\n\t       * Remove a connection status listener\n\t       * @param {number} handler\n\t       */\n\t\n\t    }, {\n\t      key: 'removeConnectionStatusListener',\n\t      value: function removeConnectionStatusListener(handler) {\n\t        return this.helper.removeConnectionStatusListener(handler);\n\t      }\n\t      /**\n\t       * Set a new authentication methods\n\t       * @param {function():AbstractHandshake} authentication\n\t       */\n\t\n\t    }, {\n\t      key: 'setAuthentication',\n\t      value: function setAuthentication(authentication) {\n\t        this.helper.setAuthentication(authentication);\n\t      }\n\t      /**\n\t       * Set logging level\n\t       * Valid values are the strings 'error', 'warn', 'info' and 'debug', from\n\t       * less verbose to more verbose.\n\t       * @param {string} level\n\t       */\n\t\n\t    }, {\n\t      key: 'setLogLevel',\n\t      value: function setLogLevel(level) {\n\t        this.helper.setLogLevel(level);\n\t      }\n\t      /**\n\t       * Set new client resource value\n\t       * @param {string} resource\n\t       */\n\t\n\t    }, {\n\t      key: 'setResource',\n\t      value: function setResource(resource) {\n\t        this.helper.setResource(resource);\n\t      }\n\t      /**\n\t       * Remove all subscriptions\n\t       * @param {Object} service\n\t       */\n\t\n\t    }, {\n\t      key: 'unsubscribe',\n\t      value: function unsubscribe(service) {\n\t        if (!service.$subscriptions) {\n\t          throw new TypeError('Missing $subscriptions property in service');\n\t        }\n\t        return this.helper.unsubscribe(service.$subscriptions);\n\t      }\n\t    }]);\n\t    return Client;\n\t  }();\n\t\n\t  /**\n\t   * Add shorthand connection status method\n\t   */\n\t  (0, _getOwnPropertyNames2.default)(_connectionStatus.ConnectionStatusListener.prototype).forEach(function (method) {\n\t    // Only implements unsupported methods\n\t    if (!Client.prototype.hasOwnProperty(method)) {\n\t      Client.prototype[method] = function addListener(listener) {\n\t        return this.addConnectionStatusListener((0, _defineProperty3.default)({}, method, listener));\n\t      };\n\t    }\n\t  });\n\t});\n\n/***/ },\n/* 108 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\texports.__esModule = true;\n\t\n\tvar _defineProperty = __webpack_require__(87);\n\t\n\tvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\texports.default = function (obj, key, value) {\n\t  if (key in obj) {\n\t    (0, _defineProperty2.default)(obj, key, {\n\t      value: value,\n\t      enumerable: true,\n\t      configurable: true,\n\t      writable: true\n\t    });\n\t  } else {\n\t    obj[key] = value;\n\t  }\n\t\n\t  return obj;\n\t};\n\n/***/ },\n/* 109 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(110), __esModule: true };\n\n/***/ },\n/* 110 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(111);\n\tvar $Object = __webpack_require__(17).Object;\n\tmodule.exports = function getOwnPropertyNames(it){\n\t  return $Object.getOwnPropertyNames(it);\n\t};\n\n/***/ },\n/* 111 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 19.1.2.7 Object.getOwnPropertyNames(O)\n\t__webpack_require__(15)('getOwnPropertyNames', function(){\n\t  return __webpack_require__(71).f;\n\t});\n\n/***/ },\n/* 112 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(108), __webpack_require__(113), __webpack_require__(94), __webpack_require__(85), __webpack_require__(86), __webpack_require__(135), __webpack_require__(98), __webpack_require__(93), __webpack_require__(92), __webpack_require__(129), __webpack_require__(130)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('babel-runtime/helpers/defineProperty'), require('babel-runtime/core-js/promise'), require('babel-runtime/core-js/object/assign'), require('babel-runtime/helpers/classCallCheck'), require('babel-runtime/helpers/createClass'), require('babel-runtime/core-js/object/values'), require('zetapush-cometd'), require('../connection/cometd'), require('../connection/connection-status'), require('../mapping/services'), require('../utils/index'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.defineProperty, global.promise, global.assign, global.classCallCheck, global.createClass, global.values, global.zetapushCometd, global.cometd, global.connectionStatus, global.services, global.index);\n\t    global.helper = mod.exports;\n\t  }\n\t})(this, function (exports, _defineProperty2, _promise, _assign, _classCallCheck2, _createClass2, _values, _zetapushCometd, _cometd, _connectionStatus, _services, _index) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.ClientHelper = undefined;\n\t\n\t  var _defineProperty3 = _interopRequireDefault(_defineProperty2);\n\t\n\t  var _promise2 = _interopRequireDefault(_promise);\n\t\n\t  var _assign2 = _interopRequireDefault(_assign);\n\t\n\t  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t  var _createClass3 = _interopRequireDefault(_createClass2);\n\t\n\t  var _values2 = _interopRequireDefault(_values);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  /**\n\t   * CometD Messages enumeration\n\t   * @type {Object}\n\t   */\n\t  var Message = {\n\t    RECONNECT_HANDSHAKE_VALUE: 'handshake',\n\t    RECONNECT_NONE_VALUE: 'none',\n\t    RECONNECT_RETRY_VALUE: 'retry'\n\t  };\n\t\n\t  /**\n\t   * Get all transport types\n\t   * @type {Object[]}\n\t   */\n\t  var AllTransports = (0, _values2.default)(_cometd.TransportTypes);\n\t\n\t  /**\n\t   * Delay to update server url\n\t   * @type {integer}\n\t   */\n\t  var UPDATE_SERVER_URL_DELAY = 250;\n\t\n\t  /**\n\t   * Default macro channel\n\t   * @type {string}\n\t   */\n\t  var DEFAULT_MACRO_CHANNEL = 'completed';\n\t\n\t  /**\n\t   * Provide utilities and abstraction on CometD Transport layer\n\t   * @access private\n\t   */\n\t\n\t  var ClientHelper = exports.ClientHelper = function () {\n\t    /**\n\t     * Create a new ZetaPush client helper\n\t     */\n\t    function ClientHelper(_ref) {\n\t      var _this = this;\n\t\n\t      var apiUrl = _ref.apiUrl,\n\t          sandboxId = _ref.sandboxId,\n\t          _ref$forceHttps = _ref.forceHttps,\n\t          forceHttps = _ref$forceHttps === undefined ? false : _ref$forceHttps,\n\t          authentication = _ref.authentication,\n\t          _ref$resource = _ref.resource,\n\t          resource = _ref$resource === undefined ? null : _ref$resource,\n\t          _ref$transports = _ref.transports,\n\t          transports = _ref$transports === undefined ? AllTransports : _ref$transports;\n\t      (0, _classCallCheck3.default)(this, ClientHelper);\n\t\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      this.sandboxId = sandboxId;\n\t      /**\n\t       * @access private\n\t       * @type {function():AbstractHandshake}\n\t       */\n\t      this.authentication = authentication;\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      this.resource = resource;\n\t      /**\n\t       * @access private\n\t       * @type {number}\n\t       */\n\t      this.requestId = 0;\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      this.userId = null;\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      this.uniqId = (0, _index.uuid)();\n\t      /**\n\t       * @access private\n\t       * @type {Promise}\n\t       */\n\t      this.servers = (0, _index.getServers)({ apiUrl: apiUrl, sandboxId: sandboxId, forceHttps: forceHttps });\n\t      /**\n\t       * @access private\n\t       * @type {Array<Object>}\n\t       */\n\t      this.connectionListeners = [];\n\t      /**\n\t       * @access private\n\t       * @type {boolean}\n\t       */\n\t      this.connected = false;\n\t      /**\n\t       * @access private\n\t       * @type {boolean}\n\t       */\n\t      this.wasConnected = false;\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      this.serverUrl = null;\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      this.sessionId = null;\n\t      /**\n\t       * @access private\n\t       * @type {Array<Object>}\n\t       */\n\t      this.subscribeQueue = [];\n\t      /**\n\t       * @access private\n\t       * @type {CometD}\n\t       */\n\t      this.cometd = new _zetapushCometd.CometD();\n\t\n\t      // Filter transports layers\n\t      _cometd.TransportLayers.filter(function (_ref2) {\n\t        var type = _ref2.type;\n\t\n\t        return transports.includes(type);\n\t      }).forEach(function (_ref3) {\n\t        var type = _ref3.type,\n\t            Transport = _ref3.Transport;\n\t\n\t        _this.cometd.registerTransport(type, new Transport());\n\t      });\n\t\n\t      // Handle transport exception\n\t      this.cometd.onTransportException = function (cometd, transport) {\n\t        if (_cometd.TransportTypes.LONG_POLLING === transport) {\n\t          // Try to find an other available server\n\t          // Remove the current one from the _serverList array\n\t          _this.updateServerUrl();\n\t        }\n\t      };\n\t\n\t      this.cometd.addListener('/meta/handshake', function (_ref4) {\n\t        var ext = _ref4.ext,\n\t            successful = _ref4.successful,\n\t            advice = _ref4.advice,\n\t            error = _ref4.error;\n\t\n\t        _this.cometd._debug('ClientHelper::/meta/handshake', { ext: ext, successful: successful, advice: advice, error: error });\n\t        if (successful) {\n\t          var _ext$authentication = ext.authentication,\n\t              _authentication = _ext$authentication === undefined ? null : _ext$authentication;\n\t\n\t          _this.initialized(_authentication);\n\t        } else {\n\t          _this.handshakeFailure(error);\n\t        }\n\t      });\n\t\n\t      this.cometd.addListener('/meta/handshake', function (_ref5) {\n\t        var advice = _ref5.advice,\n\t            error = _ref5.error,\n\t            ext = _ref5.ext,\n\t            successful = _ref5.successful;\n\t\n\t        _this.cometd._debug('ClientHelper::/meta/handshake', { ext: ext, successful: successful, advice: advice, error: error });\n\t        // AuthNegotiation\n\t        if (!successful) {\n\t          if (typeof advice === 'undefined') {\n\t            return;\n\t          }\n\t          if (Message.RECONNECT_NONE_VALUE === advice.reconnect) {\n\t            _this.authenticationFailed(error);\n\t          } else if (Message.RECONNECT_HANDSHAKE_VALUE === advice.reconnect) {\n\t            _this.negotiate(ext);\n\t          }\n\t        }\n\t      });\n\t\n\t      this.cometd.addListener('/meta/connect', function (_ref6) {\n\t        var advice = _ref6.advice,\n\t            channel = _ref6.channel,\n\t            successful = _ref6.successful;\n\t\n\t        _this.cometd._debug('ClientHelper::/meta/connect', { advice: advice, channel: channel, successful: successful });\n\t        // ConnectionListener\n\t        if (_this.cometd.isDisconnected()) {\n\t          _this.connected = false;\n\t          // Notify connection will close\n\t          _this.connectionWillClose();\n\t        } else {\n\t          _this.wasConnected = _this.connected;\n\t          _this.connected = successful;\n\t          if (!_this.wasConnected && _this.connected) {\n\t            _this.cometd.batch(_this, function () {\n\t              // Unqueue subscriptions\n\t              _this.subscribeQueue.forEach(function (_ref7) {\n\t                var prefix = _ref7.prefix,\n\t                    listener = _ref7.listener,\n\t                    subscriptions = _ref7.subscriptions;\n\t\n\t                _this.subscribe(prefix, listener, subscriptions);\n\t              });\n\t            });\n\t            // Notify connection is established\n\t            _this.connectionEstablished();\n\t          } else if (_this.wasConnected && !_this.connected) {\n\t            // Notify connection is broken\n\t            _this.connectionBroken();\n\t          }\n\t        }\n\t      });\n\t\n\t      this.cometd.addListener('/meta/disconnect', function (_ref8) {\n\t        var channel = _ref8.channel,\n\t            successful = _ref8.successful;\n\t\n\t        _this.cometd._debug('ClientHelper::/meta/disconnect', { channel: channel, successful: successful });\n\t        if (_this.cometd.isDisconnected()) {\n\t          _this.connected = false;\n\t          // Notify connection is closed\n\t          _this.connectionClosed();\n\t        }\n\t      });\n\t    }\n\t    /**\n\t     * Add a connection listener to handle life cycle connection events\n\t     * @param {ConnectionStatusListener} listener\n\t     * @return {number} handler\n\t     */\n\t\n\t\n\t    (0, _createClass3.default)(ClientHelper, [{\n\t      key: 'addConnectionStatusListener',\n\t      value: function addConnectionStatusListener(listener) {\n\t        this.connectionListeners.push({\n\t          enabled: true,\n\t          listener: (0, _assign2.default)(new _connectionStatus.ConnectionStatusListener(), listener)\n\t        });\n\t        return this.connectionListeners.length - 1;\n\t      }\n\t      /**\n\t       * Notify listeners when handshake step succeed\n\t       */\n\t\n\t    }, {\n\t      key: 'authenticationFailed',\n\t      value: function authenticationFailed(error) {\n\t        this.userId = null;\n\t        this.connectionListeners.filter(function (_ref9) {\n\t          var enabled = _ref9.enabled;\n\t          return enabled;\n\t        }).forEach(function (_ref10) {\n\t          var listener = _ref10.listener;\n\t\n\t          listener.onFailedHandshake(error);\n\t        });\n\t      }\n\t      /**\n\t       * Connect client using CometD Transport\n\t       */\n\t\n\t    }, {\n\t      key: 'connect',\n\t      value: function connect() {\n\t        var _this2 = this;\n\t\n\t        this.servers.then(function (servers) {\n\t          _this2.serverUrl = (0, _index.shuffle)(servers);\n\t\n\t          _this2.cometd.configure({\n\t            url: _this2.serverUrl + '/strd',\n\t            backoffIncrement: 1000,\n\t            maxBackoff: 60000,\n\t            appendMessageTypeToURL: false\n\t          });\n\t\n\t          _this2.cometd.handshake(_this2.getHandshakeFields());\n\t        });\n\t      }\n\t      /**\n\t       * Notify listeners when connection is broken\n\t       */\n\t\n\t    }, {\n\t      key: 'connectionBroken',\n\t      value: function connectionBroken() {\n\t        this.connectionListeners.filter(function (_ref11) {\n\t          var enabled = _ref11.enabled;\n\t          return enabled;\n\t        }).forEach(function (_ref12) {\n\t          var listener = _ref12.listener;\n\t\n\t          listener.onConnectionBroken();\n\t        });\n\t      }\n\t      /**\n\t       * Notify listeners when connection is closed\n\t       */\n\t\n\t    }, {\n\t      key: 'connectionClosed',\n\t      value: function connectionClosed() {\n\t        this.userId = null;\n\t        this.connectionListeners.filter(function (_ref13) {\n\t          var enabled = _ref13.enabled;\n\t          return enabled;\n\t        }).forEach(function (_ref14) {\n\t          var listener = _ref14.listener;\n\t\n\t          listener.onConnectionClosed();\n\t        });\n\t      }\n\t      /**\n\t       * Notify listeners when connection is established\n\t       */\n\t\n\t    }, {\n\t      key: 'connectionEstablished',\n\t      value: function connectionEstablished() {\n\t        this.connectionListeners.filter(function (_ref15) {\n\t          var enabled = _ref15.enabled;\n\t          return enabled;\n\t        }).forEach(function (_ref16) {\n\t          var listener = _ref16.listener;\n\t\n\t          listener.onConnectionEstablished();\n\t        });\n\t      }\n\t      /**\n\t       * Notify listeners when connection will close\n\t       */\n\t\n\t    }, {\n\t      key: 'connectionWillClose',\n\t      value: function connectionWillClose() {\n\t        this.connectionListeners.filter(function (_ref17) {\n\t          var enabled = _ref17.enabled;\n\t          return enabled;\n\t        }).forEach(function (_ref18) {\n\t          var listener = _ref18.listener;\n\t\n\t          listener.onConnectionWillClose();\n\t        });\n\t      }\n\t      /**\n\t       * Create a promise based macro service\n\t       * @param {{listener: Object, Type: class, deploymentId: string}} parameters\n\t       * @return {Object} service\n\t       */\n\t\n\t    }, {\n\t      key: 'createAsyncMacroService',\n\t      value: function createAsyncMacroService(_ref19) {\n\t        var listener = _ref19.listener,\n\t            Type = _ref19.Type,\n\t            _ref19$deploymentId = _ref19.deploymentId,\n\t            deploymentId = _ref19$deploymentId === undefined ? Type.DEFAULT_DEPLOYMENT_ID : _ref19$deploymentId;\n\t\n\t        var prefix = '/service/' + this.getSandboxId() + '/' + deploymentId;\n\t        var $publish = this.getAsyncMacroPublisher(prefix);\n\t        // Create service by publisher\n\t        return this.createServiceByPublisher({ listener: listener, prefix: prefix, Type: Type, $publish: $publish });\n\t      }\n\t      /**\n\t       * Create a publish/subscribe service\n\t       * @param {{listener: Object, Type: class, deploymentId: string}} parameters\n\t       * @return {Object} service\n\t       */\n\t\n\t    }, {\n\t      key: 'createService',\n\t      value: function createService(_ref20) {\n\t        var listener = _ref20.listener,\n\t            Type = _ref20.Type,\n\t            _ref20$deploymentId = _ref20.deploymentId,\n\t            deploymentId = _ref20$deploymentId === undefined ? Type.DEFAULT_DEPLOYMENT_ID : _ref20$deploymentId;\n\t\n\t        var isMacroType = (0, _index.isDerivedOf)(Type, _services.Macro);\n\t        var prefix = '/service/' + this.getSandboxId() + '/' + deploymentId;\n\t        var $publish = isMacroType ? this.getMacroPublisher(prefix) : this.getServicePublisher(prefix);\n\t        // Create service by publisher\n\t        return this.createServiceByPublisher({ listener: listener, prefix: prefix, Type: Type, $publish: $publish });\n\t      }\n\t      /**\n\t       * @param {{listener: Object, prefix: string, Type: class, $publish: Function}} parameters\n\t       * @return {Object} service\n\t       */\n\t\n\t    }, {\n\t      key: 'createServiceByPublisher',\n\t      value: function createServiceByPublisher(_ref21) {\n\t        var listener = _ref21.listener,\n\t            prefix = _ref21.prefix,\n\t            Type = _ref21.Type,\n\t            $publish = _ref21.$publish;\n\t\n\t        var service = new Type({ $publish: $publish });\n\t        // Store subscription in service instance\n\t        service.$subscriptions = this.subscribe(prefix, listener);\n\t        return service;\n\t      }\n\t      /**\n\t       * Disconnect CometD client\n\t       */\n\t\n\t    }, {\n\t      key: 'disconnect',\n\t      value: function disconnect() {\n\t        this.cometd.disconnect(true);\n\t      }\n\t      /**\n\t       * Get a publisher for a macro service that return a promise\n\t       * @param {string} prefix - Channel prefix\n\t       * @return {Function} publisher\n\t       */\n\t\n\t    }, {\n\t      key: 'getAsyncMacroPublisher',\n\t      value: function getAsyncMacroPublisher(prefix) {\n\t        var _this3 = this;\n\t\n\t        return function (name, parameters) {\n\t          var hardFail = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\t          var debug = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;\n\t\n\t          var channel = prefix + '/call';\n\t          var uniqRequestId = _this3.getUniqRequestId();\n\t          var subscriptions = {};\n\t          return new _promise2.default(function (resolve, reject) {\n\t            var _listener;\n\t\n\t            var handler = function handler(_ref22) {\n\t              var _ref22$data = _ref22.data,\n\t                  data = _ref22$data === undefined ? {} : _ref22$data;\n\t              var _data$result = data.result,\n\t                  result = _data$result === undefined ? {} : _data$result,\n\t                  _data$errors = data.errors,\n\t                  errors = _data$errors === undefined ? [] : _data$errors,\n\t                  requestId = data.requestId;\n\t\n\t              if (requestId === uniqRequestId) {\n\t                // Handle errors\n\t                if (errors.length > 0) {\n\t                  reject(errors);\n\t                } else {\n\t                  resolve(result);\n\t                }\n\t                _this3.unsubscribe(subscriptions);\n\t              }\n\t            };\n\t            // Create dynamic listener method\n\t            var listener = (_listener = {}, (0, _defineProperty3.default)(_listener, name, handler), (0, _defineProperty3.default)(_listener, DEFAULT_MACRO_CHANNEL, handler), _listener);\n\t            // Ad-Hoc subscription\n\t            _this3.subscribe(prefix, listener, subscriptions);\n\t            // Publish message on channel\n\t            _this3.publish(channel, {\n\t              debug: debug,\n\t              hardFail: hardFail,\n\t              name: name,\n\t              parameters: parameters,\n\t              requestId: uniqRequestId\n\t            });\n\t          });\n\t        };\n\t      }\n\t      /**\n\t       * Get client id\n\t       * @return {string} clientId\n\t       */\n\t\n\t    }, {\n\t      key: 'getClientId',\n\t      value: function getClientId() {\n\t        return this.cometd.getClientId();\n\t      }\n\t      /**\n\t       * Get CometD handshake parameters\n\t       * @return {Object}\n\t       */\n\t\n\t    }, {\n\t      key: 'getHandshakeFields',\n\t      value: function getHandshakeFields() {\n\t        var handshake = this.authentication();\n\t        return handshake.getHandshakeFields(this);\n\t      }\n\t      /**\n\t       * Get a publisher for a macro service\n\t       * @param {string} prefix - Channel prefix\n\t       * @return {Function} publisher\n\t       */\n\t\n\t    }, {\n\t      key: 'getMacroPublisher',\n\t      value: function getMacroPublisher(prefix) {\n\t        var _this4 = this;\n\t\n\t        return function (name, parameters) {\n\t          var hardFail = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\t          var debug = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;\n\t\n\t          var channel = prefix + '/call';\n\t          var requestId = _this4.getUniqRequestId();\n\t          return _this4.publish(channel, {\n\t            debug: debug,\n\t            hardFail: hardFail,\n\t            name: name,\n\t            parameters: parameters,\n\t            requestId: requestId\n\t          });\n\t        };\n\t      }\n\t      /**\n\t       * Get queued subscription index\n\t       * @return {Object} index\n\t       */\n\t\n\t    }, {\n\t      key: 'getQueuedSubscription',\n\t      value: function getQueuedSubscription() {\n\t        var subscriptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\t\n\t        var index = this.subscribeQueue.findIndex(function (element) {\n\t          return subscriptions === element.subscriptions;\n\t        });\n\t        return {\n\t          index: index,\n\t          queued: index > -1\n\t        };\n\t      }\n\t      /**\n\t       * Get resource\n\t       * @return {string}\n\t       */\n\t\n\t    }, {\n\t      key: 'getResource',\n\t      value: function getResource() {\n\t        return this.resource;\n\t      }\n\t      /**\n\t       * Get sandbox id\n\t       * @return {string}\n\t       */\n\t\n\t    }, {\n\t      key: 'getSandboxId',\n\t      value: function getSandboxId() {\n\t        return this.sandboxId;\n\t      }\n\t      /**\n\t       * Get a publisher for a service\n\t       * @param {string} prefix - Channel prefix\n\t       * @return {Function} publisher\n\t       */\n\t\n\t    }, {\n\t      key: 'getServicePublisher',\n\t      value: function getServicePublisher(prefix) {\n\t        var _this5 = this;\n\t\n\t        return function (method, parameters) {\n\t          var channel = prefix + '/' + method;\n\t          return _this5.publish(channel, parameters);\n\t        };\n\t      }\n\t      /**\n\t       * Get uniq request id\n\t       * @return {string}\n\t       */\n\t\n\t    }, {\n\t      key: 'getUniqRequestId',\n\t      value: function getUniqRequestId() {\n\t        return this.getClientId() + ':' + this.uniqId + ':' + ++this.requestId;\n\t      }\n\t      /**\n\t       * Get user id\n\t       * @return {string}\n\t       */\n\t\n\t    }, {\n\t      key: 'getUserId',\n\t      value: function getUserId() {\n\t        return this.userId;\n\t      }\n\t      /**\n\t       * Manage handshake failure case\n\t       */\n\t\n\t    }, {\n\t      key: 'handshakeFailure',\n\t      value: function handshakeFailure() {\n\t        this.userId = null;\n\t      }\n\t      /**\n\t       * Notify listeners when connection is established\n\t       */\n\t\n\t    }, {\n\t      key: 'initialized',\n\t      value: function initialized(authentication) {\n\t        if (authentication) {\n\t          this.userId = authentication.userId;\n\t        }\n\t        this.connectionListeners.filter(function (_ref23) {\n\t          var enabled = _ref23.enabled;\n\t          return enabled;\n\t        }).forEach(function (_ref24) {\n\t          var listener = _ref24.listener;\n\t\n\t          listener.onSuccessfulHandshake(authentication);\n\t        });\n\t      }\n\t      /**\n\t       * Is client connected to ZetaPush\n\t       * @return {boolean}\n\t       */\n\t\n\t    }, {\n\t      key: 'isConnected',\n\t      value: function isConnected() {\n\t        return !this.cometd.isDisconnected();\n\t      }\n\t      /**\n\t       * Notify listeners when a message is lost\n\t       */\n\t\n\t    }, {\n\t      key: 'messageLost',\n\t      value: function messageLost(channel, data) {\n\t        this.connectionListeners.filter(function (_ref25) {\n\t          var enabled = _ref25.enabled;\n\t          return enabled;\n\t        }).forEach(function (_ref26) {\n\t          var listener = _ref26.listener;\n\t\n\t          listener.onMessageLost(channel, data);\n\t        });\n\t      }\n\t      /**\n\t       * Negociate authentication\n\t       */\n\t\n\t    }, {\n\t      key: 'negotiate',\n\t      value: function negotiate(ext) {\n\t        this.cometd._debug('ClientHelper::negotiate', ext);\n\t      }\n\t      /**\n\t       * Wrap CometdD publish method\n\t       * @param {String} channel\n\t       * @param {Object} parameters\n\t       * @return {Object}\n\t       */\n\t\n\t    }, {\n\t      key: 'publish',\n\t      value: function publish(channel) {\n\t        var parameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\t\n\t        this.cometd.publish(channel, parameters);\n\t        return { channel: channel, parameters: parameters };\n\t      }\n\t      /**\n\t       * Remove a connection status listener\n\t       */\n\t\n\t    }, {\n\t      key: 'removeConnectionStatusListener',\n\t      value: function removeConnectionStatusListener(handler) {\n\t        var listener = this.connectionListeners[handler];\n\t        if (listener) {\n\t          listener.enabled = false;\n\t        }\n\t      }\n\t      /**\n\t       * Set a new authentication methods\n\t       * @param {function():AbstractHandshake} authentication\n\t       */\n\t\n\t    }, {\n\t      key: 'setAuthentication',\n\t      value: function setAuthentication(authentication) {\n\t        this.authentication = authentication;\n\t      }\n\t      /**\n\t       * Set logging level for CometD client\n\t       * Valid values are the strings 'error', 'warn', 'info' and 'debug', from\n\t       * less verbose to more verbose.\n\t       * @param {string} level\n\t       */\n\t\n\t    }, {\n\t      key: 'setLogLevel',\n\t      value: function setLogLevel(level) {\n\t        this.cometd.setLogLevel(level);\n\t      }\n\t      /**\n\t       * Subsribe all methods defined in the listener for the given prefixed channel\n\t       * @param {string} prefix - Channel prefix\n\t       * @param {Object} listener\n\t       * @param {Object} subscriptions\n\t       * @return {Object} subscriptions\n\t       */\n\t\n\t    }, {\n\t      key: 'subscribe',\n\t      value: function subscribe(prefix) {\n\t        var listener = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\t        var subscriptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\t\n\t        var _getQueuedSubscriptio = this.getQueuedSubscription(subscriptions),\n\t            queued = _getQueuedSubscriptio.queued;\n\t\n\t        if (!queued) {\n\t          // Store arguments to renew subscriptions on connection\n\t          this.subscribeQueue.push({ prefix: prefix, listener: listener, subscriptions: subscriptions });\n\t        }\n\t        // Subscribe if user is connected\n\t        if (!this.cometd.isDisconnected()) {\n\t          for (var method in listener) {\n\t            if (listener.hasOwnProperty(method)) {\n\t              var channel = prefix + '/' + method;\n\t              subscriptions[method] = this.cometd.subscribe(channel, listener[method]);\n\t            }\n\t          }\n\t        }\n\t        return subscriptions;\n\t      }\n\t      /**\n\t      * Remove current server url from the server list and shuffle for another one\n\t      */\n\t\n\t    }, {\n\t      key: 'updateServerUrl',\n\t      value: function updateServerUrl() {\n\t        var _this6 = this;\n\t\n\t        this.servers.then(function (servers) {\n\t          var index = servers.indexOf(_this6.serverUrl);\n\t          if (index > -1) {\n\t            servers.splice(index, 1);\n\t          }\n\t          if (servers.length === 0) {\n\t            // No more server available\n\t          } else {\n\t            _this6.serverUrl = (0, _index.shuffle)(servers);\n\t            _this6.cometd.configure({\n\t              url: _this6.serverUrl + '/strd'\n\t            });\n\t            window.setTimeout(function () {\n\t              _this6.cometd.handshake(_this6.getHandshakeFields());\n\t            }, UPDATE_SERVER_URL_DELAY);\n\t          }\n\t        });\n\t      }\n\t      /**\n\t       * Remove all subscriptions\n\t       * @param {Object} subscriptions\n\t       */\n\t\n\t    }, {\n\t      key: 'unsubscribe',\n\t      value: function unsubscribe() {\n\t        var subscriptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\t\n\t        // Unsubscribe\n\t        for (var method in subscriptions) {\n\t          if (subscriptions.hasOwnProperty(method)) {\n\t            var subscription = subscriptions[method];\n\t            this.cometd.unsubscribe(subscription);\n\t          }\n\t        }\n\t        // Remove subscription from queue\n\t\n\t        var _getQueuedSubscriptio2 = this.getQueuedSubscription(subscriptions),\n\t            index = _getQueuedSubscriptio2.index,\n\t            queued = _getQueuedSubscriptio2.queued;\n\t\n\t        if (queued) {\n\t          this.subscribeQueue.splice(index, 1);\n\t        }\n\t      }\n\t    }]);\n\t    return ClientHelper;\n\t  }();\n\t});\n\n/***/ },\n/* 113 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(114), __esModule: true };\n\n/***/ },\n/* 114 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(74);\n\t__webpack_require__(34);\n\t__webpack_require__(56);\n\t__webpack_require__(115);\n\tmodule.exports = __webpack_require__(17).Promise;\n\n/***/ },\n/* 115 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar LIBRARY            = __webpack_require__(38)\n\t  , global             = __webpack_require__(13)\n\t  , ctx                = __webpack_require__(18)\n\t  , classof            = __webpack_require__(116)\n\t  , $export            = __webpack_require__(16)\n\t  , isObject           = __webpack_require__(23)\n\t  , aFunction          = __webpack_require__(19)\n\t  , anInstance         = __webpack_require__(117)\n\t  , forOf              = __webpack_require__(118)\n\t  , speciesConstructor = __webpack_require__(122)\n\t  , task               = __webpack_require__(123).set\n\t  , microtask          = __webpack_require__(125)()\n\t  , PROMISE            = 'Promise'\n\t  , TypeError          = global.TypeError\n\t  , process            = global.process\n\t  , $Promise           = global[PROMISE]\n\t  , process            = global.process\n\t  , isNode             = classof(process) == 'process'\n\t  , empty              = function(){ /* empty */ }\n\t  , Internal, GenericPromiseCapability, Wrapper;\n\t\n\tvar USE_NATIVE = !!function(){\n\t  try {\n\t    // correct subclassing with @@species support\n\t    var promise     = $Promise.resolve(1)\n\t      , FakePromise = (promise.constructor = {})[__webpack_require__(55)('species')] = function(exec){ exec(empty, empty); };\n\t    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n\t    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;\n\t  } catch(e){ /* empty */ }\n\t}();\n\t\n\t// helpers\n\tvar sameConstructor = function(a, b){\n\t  // with library wrapper special case\n\t  return a === b || a === $Promise && b === Wrapper;\n\t};\n\tvar isThenable = function(it){\n\t  var then;\n\t  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;\n\t};\n\tvar newPromiseCapability = function(C){\n\t  return sameConstructor($Promise, C)\n\t    ? new PromiseCapability(C)\n\t    : new GenericPromiseCapability(C);\n\t};\n\tvar PromiseCapability = GenericPromiseCapability = function(C){\n\t  var resolve, reject;\n\t  this.promise = new C(function($$resolve, $$reject){\n\t    if(resolve !== undefined || reject !== undefined)throw TypeError('Bad Promise constructor');\n\t    resolve = $$resolve;\n\t    reject  = $$reject;\n\t  });\n\t  this.resolve = aFunction(resolve);\n\t  this.reject  = aFunction(reject);\n\t};\n\tvar perform = function(exec){\n\t  try {\n\t    exec();\n\t  } catch(e){\n\t    return {error: e};\n\t  }\n\t};\n\tvar notify = function(promise, isReject){\n\t  if(promise._n)return;\n\t  promise._n = true;\n\t  var chain = promise._c;\n\t  microtask(function(){\n\t    var value = promise._v\n\t      , ok    = promise._s == 1\n\t      , i     = 0;\n\t    var run = function(reaction){\n\t      var handler = ok ? reaction.ok : reaction.fail\n\t        , resolve = reaction.resolve\n\t        , reject  = reaction.reject\n\t        , domain  = reaction.domain\n\t        , result, then;\n\t      try {\n\t        if(handler){\n\t          if(!ok){\n\t            if(promise._h == 2)onHandleUnhandled(promise);\n\t            promise._h = 1;\n\t          }\n\t          if(handler === true)result = value;\n\t          else {\n\t            if(domain)domain.enter();\n\t            result = handler(value);\n\t            if(domain)domain.exit();\n\t          }\n\t          if(result === reaction.promise){\n\t            reject(TypeError('Promise-chain cycle'));\n\t          } else if(then = isThenable(result)){\n\t            then.call(result, resolve, reject);\n\t          } else resolve(result);\n\t        } else reject(value);\n\t      } catch(e){\n\t        reject(e);\n\t      }\n\t    };\n\t    while(chain.length > i)run(chain[i++]); // variable length - can't use forEach\n\t    promise._c = [];\n\t    promise._n = false;\n\t    if(isReject && !promise._h)onUnhandled(promise);\n\t  });\n\t};\n\tvar onUnhandled = function(promise){\n\t  task.call(global, function(){\n\t    var value = promise._v\n\t      , abrupt, handler, console;\n\t    if(isUnhandled(promise)){\n\t      abrupt = perform(function(){\n\t        if(isNode){\n\t          process.emit('unhandledRejection', value, promise);\n\t        } else if(handler = global.onunhandledrejection){\n\t          handler({promise: promise, reason: value});\n\t        } else if((console = global.console) && console.error){\n\t          console.error('Unhandled promise rejection', value);\n\t        }\n\t      });\n\t      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n\t      promise._h = isNode || isUnhandled(promise) ? 2 : 1;\n\t    } promise._a = undefined;\n\t    if(abrupt)throw abrupt.error;\n\t  });\n\t};\n\tvar isUnhandled = function(promise){\n\t  if(promise._h == 1)return false;\n\t  var chain = promise._a || promise._c\n\t    , i     = 0\n\t    , reaction;\n\t  while(chain.length > i){\n\t    reaction = chain[i++];\n\t    if(reaction.fail || !isUnhandled(reaction.promise))return false;\n\t  } return true;\n\t};\n\tvar onHandleUnhandled = function(promise){\n\t  task.call(global, function(){\n\t    var handler;\n\t    if(isNode){\n\t      process.emit('rejectionHandled', promise);\n\t    } else if(handler = global.onrejectionhandled){\n\t      handler({promise: promise, reason: promise._v});\n\t    }\n\t  });\n\t};\n\tvar $reject = function(value){\n\t  var promise = this;\n\t  if(promise._d)return;\n\t  promise._d = true;\n\t  promise = promise._w || promise; // unwrap\n\t  promise._v = value;\n\t  promise._s = 2;\n\t  if(!promise._a)promise._a = promise._c.slice();\n\t  notify(promise, true);\n\t};\n\tvar $resolve = function(value){\n\t  var promise = this\n\t    , then;\n\t  if(promise._d)return;\n\t  promise._d = true;\n\t  promise = promise._w || promise; // unwrap\n\t  try {\n\t    if(promise === value)throw TypeError(\"Promise can't be resolved itself\");\n\t    if(then = isThenable(value)){\n\t      microtask(function(){\n\t        var wrapper = {_w: promise, _d: false}; // wrap\n\t        try {\n\t          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));\n\t        } catch(e){\n\t          $reject.call(wrapper, e);\n\t        }\n\t      });\n\t    } else {\n\t      promise._v = value;\n\t      promise._s = 1;\n\t      notify(promise, false);\n\t    }\n\t  } catch(e){\n\t    $reject.call({_w: promise, _d: false}, e); // wrap\n\t  }\n\t};\n\t\n\t// constructor polyfill\n\tif(!USE_NATIVE){\n\t  // 25.4.3.1 Promise(executor)\n\t  $Promise = function Promise(executor){\n\t    anInstance(this, $Promise, PROMISE, '_h');\n\t    aFunction(executor);\n\t    Internal.call(this);\n\t    try {\n\t      executor(ctx($resolve, this, 1), ctx($reject, this, 1));\n\t    } catch(err){\n\t      $reject.call(this, err);\n\t    }\n\t  };\n\t  Internal = function Promise(executor){\n\t    this._c = [];             // <- awaiting reactions\n\t    this._a = undefined;      // <- checked in isUnhandled reactions\n\t    this._s = 0;              // <- state\n\t    this._d = false;          // <- done\n\t    this._v = undefined;      // <- value\n\t    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled\n\t    this._n = false;          // <- notify\n\t  };\n\t  Internal.prototype = __webpack_require__(126)($Promise.prototype, {\n\t    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)\n\t    then: function then(onFulfilled, onRejected){\n\t      var reaction    = newPromiseCapability(speciesConstructor(this, $Promise));\n\t      reaction.ok     = typeof onFulfilled == 'function' ? onFulfilled : true;\n\t      reaction.fail   = typeof onRejected == 'function' && onRejected;\n\t      reaction.domain = isNode ? process.domain : undefined;\n\t      this._c.push(reaction);\n\t      if(this._a)this._a.push(reaction);\n\t      if(this._s)notify(this, false);\n\t      return reaction.promise;\n\t    },\n\t    // 25.4.5.1 Promise.prototype.catch(onRejected)\n\t    'catch': function(onRejected){\n\t      return this.then(undefined, onRejected);\n\t    }\n\t  });\n\t  PromiseCapability = function(){\n\t    var promise  = new Internal;\n\t    this.promise = promise;\n\t    this.resolve = ctx($resolve, promise, 1);\n\t    this.reject  = ctx($reject, promise, 1);\n\t  };\n\t}\n\t\n\t$export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: $Promise});\n\t__webpack_require__(54)($Promise, PROMISE);\n\t__webpack_require__(127)(PROMISE);\n\tWrapper = __webpack_require__(17)[PROMISE];\n\t\n\t// statics\n\t$export($export.S + $export.F * !USE_NATIVE, PROMISE, {\n\t  // 25.4.4.5 Promise.reject(r)\n\t  reject: function reject(r){\n\t    var capability = newPromiseCapability(this)\n\t      , $$reject   = capability.reject;\n\t    $$reject(r);\n\t    return capability.promise;\n\t  }\n\t});\n\t$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {\n\t  // 25.4.4.6 Promise.resolve(x)\n\t  resolve: function resolve(x){\n\t    // instanceof instead of internal slot check because we should fix it without replacement native Promise core\n\t    if(x instanceof $Promise && sameConstructor(x.constructor, this))return x;\n\t    var capability = newPromiseCapability(this)\n\t      , $$resolve  = capability.resolve;\n\t    $$resolve(x);\n\t    return capability.promise;\n\t  }\n\t});\n\t$export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(128)(function(iter){\n\t  $Promise.all(iter)['catch'](empty);\n\t})), PROMISE, {\n\t  // 25.4.4.1 Promise.all(iterable)\n\t  all: function all(iterable){\n\t    var C          = this\n\t      , capability = newPromiseCapability(C)\n\t      , resolve    = capability.resolve\n\t      , reject     = capability.reject;\n\t    var abrupt = perform(function(){\n\t      var values    = []\n\t        , index     = 0\n\t        , remaining = 1;\n\t      forOf(iterable, false, function(promise){\n\t        var $index        = index++\n\t          , alreadyCalled = false;\n\t        values.push(undefined);\n\t        remaining++;\n\t        C.resolve(promise).then(function(value){\n\t          if(alreadyCalled)return;\n\t          alreadyCalled  = true;\n\t          values[$index] = value;\n\t          --remaining || resolve(values);\n\t        }, reject);\n\t      });\n\t      --remaining || resolve(values);\n\t    });\n\t    if(abrupt)reject(abrupt.error);\n\t    return capability.promise;\n\t  },\n\t  // 25.4.4.4 Promise.race(iterable)\n\t  race: function race(iterable){\n\t    var C          = this\n\t      , capability = newPromiseCapability(C)\n\t      , reject     = capability.reject;\n\t    var abrupt = perform(function(){\n\t      forOf(iterable, false, function(promise){\n\t        C.resolve(promise).then(capability.resolve, reject);\n\t      });\n\t    });\n\t    if(abrupt)reject(abrupt.error);\n\t    return capability.promise;\n\t  }\n\t});\n\n/***/ },\n/* 116 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// getting tag from 19.1.3.6 Object.prototype.toString()\n\tvar cof = __webpack_require__(48)\n\t  , TAG = __webpack_require__(55)('toStringTag')\n\t  // ES3 wrong here\n\t  , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\t\n\t// fallback for IE11 Script Access Denied error\n\tvar tryGet = function(it, key){\n\t  try {\n\t    return it[key];\n\t  } catch(e){ /* empty */ }\n\t};\n\t\n\tmodule.exports = function(it){\n\t  var O, T, B;\n\t  return it === undefined ? 'Undefined' : it === null ? 'Null'\n\t    // @@toStringTag case\n\t    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n\t    // builtinTag case\n\t    : ARG ? cof(O)\n\t    // ES3 arguments fallback\n\t    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n\t};\n\n/***/ },\n/* 117 */\n/***/ function(module, exports) {\n\n\tmodule.exports = function(it, Constructor, name, forbiddenField){\n\t  if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){\n\t    throw TypeError(name + ': incorrect invocation!');\n\t  } return it;\n\t};\n\n/***/ },\n/* 118 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar ctx         = __webpack_require__(18)\n\t  , call        = __webpack_require__(119)\n\t  , isArrayIter = __webpack_require__(120)\n\t  , anObject    = __webpack_require__(22)\n\t  , toLength    = __webpack_require__(50)\n\t  , getIterFn   = __webpack_require__(121)\n\t  , BREAK       = {}\n\t  , RETURN      = {};\n\tvar exports = module.exports = function(iterable, entries, fn, that, ITERATOR){\n\t  var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)\n\t    , f      = ctx(fn, that, entries ? 2 : 1)\n\t    , index  = 0\n\t    , length, step, iterator, result;\n\t  if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');\n\t  // fast case for arrays with default iterator\n\t  if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){\n\t    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);\n\t    if(result === BREAK || result === RETURN)return result;\n\t  } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){\n\t    result = call(iterator, f, step.value, entries);\n\t    if(result === BREAK || result === RETURN)return result;\n\t  }\n\t};\n\texports.BREAK  = BREAK;\n\texports.RETURN = RETURN;\n\n/***/ },\n/* 119 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// call something on iterator step with safe closing on error\n\tvar anObject = __webpack_require__(22);\n\tmodule.exports = function(iterator, fn, value, entries){\n\t  try {\n\t    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n\t  // 7.4.6 IteratorClose(iterator, completion)\n\t  } catch(e){\n\t    var ret = iterator['return'];\n\t    if(ret !== undefined)anObject(ret.call(iterator));\n\t    throw e;\n\t  }\n\t};\n\n/***/ },\n/* 120 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// check on default Array iterator\n\tvar Iterators  = __webpack_require__(40)\n\t  , ITERATOR   = __webpack_require__(55)('iterator')\n\t  , ArrayProto = Array.prototype;\n\t\n\tmodule.exports = function(it){\n\t  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n\t};\n\n/***/ },\n/* 121 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar classof   = __webpack_require__(116)\n\t  , ITERATOR  = __webpack_require__(55)('iterator')\n\t  , Iterators = __webpack_require__(40);\n\tmodule.exports = __webpack_require__(17).getIteratorMethod = function(it){\n\t  if(it != undefined)return it[ITERATOR]\n\t    || it['@@iterator']\n\t    || Iterators[classof(it)];\n\t};\n\n/***/ },\n/* 122 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 7.3.20 SpeciesConstructor(O, defaultConstructor)\n\tvar anObject  = __webpack_require__(22)\n\t  , aFunction = __webpack_require__(19)\n\t  , SPECIES   = __webpack_require__(55)('species');\n\tmodule.exports = function(O, D){\n\t  var C = anObject(O).constructor, S;\n\t  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);\n\t};\n\n/***/ },\n/* 123 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar ctx                = __webpack_require__(18)\n\t  , invoke             = __webpack_require__(124)\n\t  , html               = __webpack_require__(53)\n\t  , cel                = __webpack_require__(27)\n\t  , global             = __webpack_require__(13)\n\t  , process            = global.process\n\t  , setTask            = global.setImmediate\n\t  , clearTask          = global.clearImmediate\n\t  , MessageChannel     = global.MessageChannel\n\t  , counter            = 0\n\t  , queue              = {}\n\t  , ONREADYSTATECHANGE = 'onreadystatechange'\n\t  , defer, channel, port;\n\tvar run = function(){\n\t  var id = +this;\n\t  if(queue.hasOwnProperty(id)){\n\t    var fn = queue[id];\n\t    delete queue[id];\n\t    fn();\n\t  }\n\t};\n\tvar listener = function(event){\n\t  run.call(event.data);\n\t};\n\t// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\n\tif(!setTask || !clearTask){\n\t  setTask = function setImmediate(fn){\n\t    var args = [], i = 1;\n\t    while(arguments.length > i)args.push(arguments[i++]);\n\t    queue[++counter] = function(){\n\t      invoke(typeof fn == 'function' ? fn : Function(fn), args);\n\t    };\n\t    defer(counter);\n\t    return counter;\n\t  };\n\t  clearTask = function clearImmediate(id){\n\t    delete queue[id];\n\t  };\n\t  // Node.js 0.8-\n\t  if(__webpack_require__(48)(process) == 'process'){\n\t    defer = function(id){\n\t      process.nextTick(ctx(run, id, 1));\n\t    };\n\t  // Browsers with MessageChannel, includes WebWorkers\n\t  } else if(MessageChannel){\n\t    channel = new MessageChannel;\n\t    port    = channel.port2;\n\t    channel.port1.onmessage = listener;\n\t    defer = ctx(port.postMessage, port, 1);\n\t  // Browsers with postMessage, skip WebWorkers\n\t  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n\t  } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){\n\t    defer = function(id){\n\t      global.postMessage(id + '', '*');\n\t    };\n\t    global.addEventListener('message', listener, false);\n\t  // IE8-\n\t  } else if(ONREADYSTATECHANGE in cel('script')){\n\t    defer = function(id){\n\t      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){\n\t        html.removeChild(this);\n\t        run.call(id);\n\t      };\n\t    };\n\t  // Rest old browsers\n\t  } else {\n\t    defer = function(id){\n\t      setTimeout(ctx(run, id, 1), 0);\n\t    };\n\t  }\n\t}\n\tmodule.exports = {\n\t  set:   setTask,\n\t  clear: clearTask\n\t};\n\n/***/ },\n/* 124 */\n/***/ function(module, exports) {\n\n\t// fast apply, http://jsperf.lnkit.com/fast-apply/5\n\tmodule.exports = function(fn, args, that){\n\t  var un = that === undefined;\n\t  switch(args.length){\n\t    case 0: return un ? fn()\n\t                      : fn.call(that);\n\t    case 1: return un ? fn(args[0])\n\t                      : fn.call(that, args[0]);\n\t    case 2: return un ? fn(args[0], args[1])\n\t                      : fn.call(that, args[0], args[1]);\n\t    case 3: return un ? fn(args[0], args[1], args[2])\n\t                      : fn.call(that, args[0], args[1], args[2]);\n\t    case 4: return un ? fn(args[0], args[1], args[2], args[3])\n\t                      : fn.call(that, args[0], args[1], args[2], args[3]);\n\t  } return              fn.apply(that, args);\n\t};\n\n/***/ },\n/* 125 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar global    = __webpack_require__(13)\n\t  , macrotask = __webpack_require__(123).set\n\t  , Observer  = global.MutationObserver || global.WebKitMutationObserver\n\t  , process   = global.process\n\t  , Promise   = global.Promise\n\t  , isNode    = __webpack_require__(48)(process) == 'process';\n\t\n\tmodule.exports = function(){\n\t  var head, last, notify;\n\t\n\t  var flush = function(){\n\t    var parent, fn;\n\t    if(isNode && (parent = process.domain))parent.exit();\n\t    while(head){\n\t      fn   = head.fn;\n\t      head = head.next;\n\t      try {\n\t        fn();\n\t      } catch(e){\n\t        if(head)notify();\n\t        else last = undefined;\n\t        throw e;\n\t      }\n\t    } last = undefined;\n\t    if(parent)parent.enter();\n\t  };\n\t\n\t  // Node.js\n\t  if(isNode){\n\t    notify = function(){\n\t      process.nextTick(flush);\n\t    };\n\t  // browsers with MutationObserver\n\t  } else if(Observer){\n\t    var toggle = true\n\t      , node   = document.createTextNode('');\n\t    new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new\n\t    notify = function(){\n\t      node.data = toggle = !toggle;\n\t    };\n\t  // environments with maybe non-completely correct, but existent Promise\n\t  } else if(Promise && Promise.resolve){\n\t    var promise = Promise.resolve();\n\t    notify = function(){\n\t      promise.then(flush);\n\t    };\n\t  // for other environments - macrotask based on:\n\t  // - setImmediate\n\t  // - MessageChannel\n\t  // - window.postMessag\n\t  // - onreadystatechange\n\t  // - setTimeout\n\t  } else {\n\t    notify = function(){\n\t      // strange IE + webpack dev server bug - use .call(global)\n\t      macrotask.call(global, flush);\n\t    };\n\t  }\n\t\n\t  return function(fn){\n\t    var task = {fn: fn, next: undefined};\n\t    if(last)last.next = task;\n\t    if(!head){\n\t      head = task;\n\t      notify();\n\t    } last = task;\n\t  };\n\t};\n\n/***/ },\n/* 126 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar hide = __webpack_require__(20);\n\tmodule.exports = function(target, src, safe){\n\t  for(var key in src){\n\t    if(safe && target[key])target[key] = src[key];\n\t    else hide(target, key, src[key]);\n\t  } return target;\n\t};\n\n/***/ },\n/* 127 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar global      = __webpack_require__(13)\n\t  , core        = __webpack_require__(17)\n\t  , dP          = __webpack_require__(21)\n\t  , DESCRIPTORS = __webpack_require__(25)\n\t  , SPECIES     = __webpack_require__(55)('species');\n\t\n\tmodule.exports = function(KEY){\n\t  var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];\n\t  if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {\n\t    configurable: true,\n\t    get: function(){ return this; }\n\t  });\n\t};\n\n/***/ },\n/* 128 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar ITERATOR     = __webpack_require__(55)('iterator')\n\t  , SAFE_CLOSING = false;\n\t\n\ttry {\n\t  var riter = [7][ITERATOR]();\n\t  riter['return'] = function(){ SAFE_CLOSING = true; };\n\t  Array.from(riter, function(){ throw 2; });\n\t} catch(e){ /* empty */ }\n\t\n\tmodule.exports = function(exec, skipClosing){\n\t  if(!skipClosing && !SAFE_CLOSING)return false;\n\t  var safe = false;\n\t  try {\n\t    var arr  = [7]\n\t      , iter = arr[ITERATOR]();\n\t    iter.next = function(){ return {done: safe = true}; };\n\t    arr[ITERATOR] = function(){ return iter; };\n\t    exec(arr);\n\t  } catch(e){ /* empty */ }\n\t  return safe;\n\t};\n\n/***/ },\n/* 129 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t\tif (true) {\n\t\t\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(4), __webpack_require__(85), __webpack_require__(86), __webpack_require__(30), __webpack_require__(77), __webpack_require__(91)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\t} else if (typeof exports !== \"undefined\") {\n\t\t\tfactory(exports, require('babel-runtime/core-js/object/get-prototype-of'), require('babel-runtime/helpers/classCallCheck'), require('babel-runtime/helpers/createClass'), require('babel-runtime/helpers/possibleConstructorReturn'), require('babel-runtime/helpers/inherits'), require('./core'));\n\t\t} else {\n\t\t\tvar mod = {\n\t\t\t\texports: {}\n\t\t\t};\n\t\t\tfactory(mod.exports, global.getPrototypeOf, global.classCallCheck, global.createClass, global.possibleConstructorReturn, global.inherits, global.core);\n\t\t\tglobal.services = mod.exports;\n\t\t}\n\t})(this, function (exports, _getPrototypeOf, _classCallCheck2, _createClass2, _possibleConstructorReturn2, _inherits2, _core) {\n\t\t'use strict';\n\t\n\t\tObject.defineProperty(exports, \"__esModule\", {\n\t\t\tvalue: true\n\t\t});\n\t\texports.Userdir = exports.Zpfs_s3compat = exports.Zpfs_hdfs = exports.Zpfs_s3 = exports.Template = exports.Search = exports.Cron = exports.Sms_ovh = exports.Notif = exports.Queue = exports.Messaging = exports.Sendmail = exports.MacroDebug = exports.Macro = exports.Httpclient = exports.GroupManagement = exports.Remoting = exports.Gda = exports.Game = exports.GameEngine = exports.Echo = exports.Stack = exports.Aggreg = undefined;\n\t\n\t\tvar _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);\n\t\n\t\tvar _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t\tvar _createClass3 = _interopRequireDefault(_createClass2);\n\t\n\t\tvar _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);\n\t\n\t\tvar _inherits3 = _interopRequireDefault(_inherits2);\n\t\n\t\tfunction _interopRequireDefault(obj) {\n\t\t\treturn obj && obj.__esModule ? obj : {\n\t\t\t\tdefault: obj\n\t\t\t};\n\t\t}\n\t\n\t\tvar Aggreg = exports.Aggreg = function (_Service) {\n\t\t\t(0, _inherits3.default)(Aggreg, _Service);\n\t\n\t\t\tfunction Aggreg() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Aggreg);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Aggreg.__proto__ || (0, _getPrototypeOf2.default)(Aggreg)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Aggreg, [{\n\t\t\t\tkey: 'push',\n\t\n\t\t\t\t/**\n\t    * Pushes some data\n\t    *\n\t    * Pushes the given data.\n\t    * All the items are processed according to the defined rules.\n\t    * At least one push for a given item is needed during a time period to trigger processing and calling of the corresponding callback verb/macro.\n\t    * */\n\t\t\t\tvalue: function push(_ref) {\n\t\t\t\t\tvar items = _ref.items,\n\t\t\t\t\t    owner = _ref.owner;\n\t\t\t\t\treturn this.$publish('push', { items: items, owner: owner });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Aggreg service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'aggreg_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Aggreg;\n\t\t}(_core.Service);\n\t\n\t\tvar Stack = exports.Stack = function (_Service2) {\n\t\t\t(0, _inherits3.default)(Stack, _Service2);\n\t\n\t\t\tfunction Stack() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Stack);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Stack.__proto__ || (0, _getPrototypeOf2.default)(Stack)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Stack, [{\n\t\t\t\tkey: 'getListeners',\n\t\n\t\t\t\t/**\n\t    * Lists the listeners\n\t    *\n\t    * Returns the whole list of listeners for the given stack.\n\t    * */\n\t\t\t\tvalue: function getListeners(_ref2) {\n\t\t\t\t\tvar owner = _ref2.owner,\n\t\t\t\t\t    stack = _ref2.stack;\n\t\t\t\t\treturn this.$publish('getListeners', { owner: owner, stack: stack });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists content\n\t    *\n\t    * Returns a paginated list of contents for the given stack.\n\t    * Content is sorted according to the statically configured order.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'list',\n\t\t\t\tvalue: function list(_ref3) {\n\t\t\t\t\tvar owner = _ref3.owner,\n\t\t\t\t\t    page = _ref3.page,\n\t\t\t\t\t    stack = _ref3.stack;\n\t\t\t\t\treturn this.$publish('list', { owner: owner, page: page, stack: stack });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Empties a stack\n\t    *\n\t    * Removes all items from the given stack.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'purge',\n\t\t\t\tvalue: function purge(_ref4) {\n\t\t\t\t\tvar owner = _ref4.owner,\n\t\t\t\t\t    stack = _ref4.stack;\n\t\t\t\t\treturn this.$publish('purge', { owner: owner, stack: stack });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Pushes an item\n\t    *\n\t    * Pushes an item onto the given stack.\n\t    * The stack does not need to be created.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'push',\n\t\t\t\tvalue: function push(_ref5) {\n\t\t\t\t\tvar stack = _ref5.stack,\n\t\t\t\t\t    data = _ref5.data,\n\t\t\t\t\t    owner = _ref5.owner;\n\t\t\t\t\treturn this.$publish('push', { stack: stack, data: data, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes items\n\t    *\n\t    * Removes the item with the given guid from the given stack.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'remove',\n\t\t\t\tvalue: function remove(_ref6) {\n\t\t\t\t\tvar guids = _ref6.guids,\n\t\t\t\t\t    owner = _ref6.owner,\n\t\t\t\t\t    stack = _ref6.stack;\n\t\t\t\t\treturn this.$publish('remove', { guids: guids, owner: owner, stack: stack });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Sets the listeners\n\t    *\n\t    * Sets the listeners for the given stack.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'setListeners',\n\t\t\t\tvalue: function setListeners(_ref7) {\n\t\t\t\t\tvar listeners = _ref7.listeners,\n\t\t\t\t\t    owner = _ref7.owner,\n\t\t\t\t\t    stack = _ref7.stack;\n\t\t\t\t\treturn this.$publish('setListeners', { listeners: listeners, owner: owner, stack: stack });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Updates an item\n\t    *\n\t    * Updates an existing item of the given stack.\n\t    * The item MUST exist prior to the call.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'update',\n\t\t\t\tvalue: function update(_ref8) {\n\t\t\t\t\tvar guid = _ref8.guid,\n\t\t\t\t\t    stack = _ref8.stack,\n\t\t\t\t\t    data = _ref8.data,\n\t\t\t\t\t    owner = _ref8.owner;\n\t\t\t\t\treturn this.$publish('update', { guid: guid, stack: stack, data: data, owner: owner });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Stack service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'stack_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Stack;\n\t\t}(_core.Service);\n\t\n\t\tvar Echo = exports.Echo = function (_Service3) {\n\t\t\t(0, _inherits3.default)(Echo, _Service3);\n\t\n\t\t\tfunction Echo() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Echo);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Echo.__proto__ || (0, _getPrototypeOf2.default)(Echo)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Echo, [{\n\t\t\t\tkey: 'echo',\n\t\n\t\t\t\t/**\n\t    * Echoes an object\n\t    *\n\t    * Echoes an object: the server will echo that object on channel 'echo' for the current user.\n\t    * */\n\t\t\t\tvalue: function echo(parameter) {\n\t\t\t\t\treturn this.$publish('echo', parameter);\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Echo service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'echo_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Echo;\n\t\t}(_core.Service);\n\t\n\t\tvar GameEngine = exports.GameEngine = function (_Service4) {\n\t\t\t(0, _inherits3.default)(GameEngine, _Service4);\n\t\n\t\t\tfunction GameEngine() {\n\t\t\t\t(0, _classCallCheck3.default)(this, GameEngine);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (GameEngine.__proto__ || (0, _getPrototypeOf2.default)(GameEngine)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(GameEngine, [{\n\t\t\t\tkey: 'join_result',\n\t\n\t\t\t\t/**\n\t    * Notify the result for a join request\n\t    *\n\t    * A Game Engine notifies the STR of the result of a join request that it received on join_callback\n\t    * */\n\t\t\t\tvalue: function join_result(_ref9) {\n\t\t\t\t\tvar callerId = _ref9.callerId,\n\t\t\t\t\t    error = _ref9.error,\n\t\t\t\t\t    msgId = _ref9.msgId,\n\t\t\t\t\t    payload = _ref9.payload;\n\t\t\t\t\treturn this.$publish('join_result', { callerId: callerId, error: error, msgId: msgId, payload: payload });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Notify the result for an organization request\n\t    *\n\t    * A Game Engine notifies the STR of the result of an organization request that it received on organize_callback\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'organize_result',\n\t\t\t\tvalue: function organize_result(_ref10) {\n\t\t\t\t\tvar callerId = _ref10.callerId,\n\t\t\t\t\t    error = _ref10.error,\n\t\t\t\t\t    msgId = _ref10.msgId,\n\t\t\t\t\t    payload = _ref10.payload;\n\t\t\t\t\treturn this.$publish('organize_result', { callerId: callerId, error: error, msgId: msgId, payload: payload });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Registers a game engine\n\t    *\n\t    * A client registers itself to the STR as a Game Engine.\n\t    * The STR may, from now on, dispatch game of the given game type to said client.\n\t    * Unregistration is done automatically on logoff.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'register',\n\t\t\t\tvalue: function register(_ref11) {\n\t\t\t\t\tvar gameInfo = _ref11.gameInfo,\n\t\t\t\t\t    location = _ref11.location,\n\t\t\t\t\t    maxGames = _ref11.maxGames;\n\t\t\t\t\treturn this.$publish('register', { gameInfo: gameInfo, location: location, maxGames: maxGames });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Notify the result for a start request\n\t    *\n\t    * A Game Engine notifies the STR of the result of a start request that it received on start_callback\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'start_result',\n\t\t\t\tvalue: function start_result(_ref12) {\n\t\t\t\t\tvar gameId = _ref12.gameId;\n\t\t\t\t\treturn this.$publish('start_result', { gameId: gameId });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Notify a game event\n\t    *\n\t    * A Game Engine notifies the STR of some arbitrary game event.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'state',\n\t\t\t\tvalue: function state(_ref13) {\n\t\t\t\t\tvar data = _ref13.data,\n\t\t\t\t\t    gameId = _ref13.gameId,\n\t\t\t\t\t    status = _ref13.status;\n\t\t\t\t\treturn this.$publish('state', { data: data, gameId: gameId, status: status });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Notify the result for an unjoin request\n\t    *\n\t    * A Game Engine notifies the STR of the result of an unjoin request that it received on unjoin_callback\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'unjoin_result',\n\t\t\t\tvalue: function unjoin_result(_ref14) {\n\t\t\t\t\tvar callerId = _ref14.callerId,\n\t\t\t\t\t    error = _ref14.error,\n\t\t\t\t\t    msgId = _ref14.msgId,\n\t\t\t\t\t    payload = _ref14.payload;\n\t\t\t\t\treturn this.$publish('unjoin_result', { callerId: callerId, error: error, msgId: msgId, payload: payload });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to GameEngine service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'game_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn GameEngine;\n\t\t}(_core.Service);\n\t\n\t\tvar Game = exports.Game = function (_Service5) {\n\t\t\t(0, _inherits3.default)(Game, _Service5);\n\t\n\t\t\tfunction Game() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Game);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Game.__proto__ || (0, _getPrototypeOf2.default)(Game)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Game, [{\n\t\t\t\tkey: 'available',\n\t\n\t\t\t\t/**\n\t    * Lists game types\n\t    *\n\t    * Returns the list of game types supported by the server and the currently registered game engines.\n\t    * */\n\t\t\t\tvalue: function available() {\n\t\t\t\t\treturn this.$publish('available', {});\n\t\t\t\t}\n\t\t\t\t/**A user joins a game*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'join',\n\t\t\t\tvalue: function join(_ref15) {\n\t\t\t\t\tvar gameId = _ref15.gameId,\n\t\t\t\t\t    role = _ref15.role,\n\t\t\t\t\t    userId = _ref15.userId,\n\t\t\t\t\t    userName = _ref15.userName;\n\t\t\t\t\treturn this.$publish('join', { gameId: gameId, role: role, userId: userId, userName: userName });\n\t\t\t\t}\n\t\t\t\t/**Organizes a game*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'organize',\n\t\t\t\tvalue: function organize(_ref16) {\n\t\t\t\t\tvar type = _ref16.type,\n\t\t\t\t\t    owner = _ref16.owner,\n\t\t\t\t\t    options = _ref16.options;\n\t\t\t\t\treturn this.$publish('organize', { type: type, owner: owner, options: options });\n\t\t\t\t}\n\t\t\t\t/**Gives some command to the game engine*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'play',\n\t\t\t\tvalue: function play(_ref17) {\n\t\t\t\t\tvar data = _ref17.data,\n\t\t\t\t\t    gameId = _ref17.gameId,\n\t\t\t\t\t    userId = _ref17.userId;\n\t\t\t\t\treturn this.$publish('play', { data: data, gameId: gameId, userId: userId });\n\t\t\t\t}\n\t\t\t\t/**Starts a game*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'start',\n\t\t\t\tvalue: function start(_ref18) {\n\t\t\t\t\tvar gameId = _ref18.gameId;\n\t\t\t\t\treturn this.$publish('start', { gameId: gameId });\n\t\t\t\t}\n\t\t\t\t/**A user cancels joining a game*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'unjoin',\n\t\t\t\tvalue: function unjoin(_ref19) {\n\t\t\t\t\tvar gameId = _ref19.gameId,\n\t\t\t\t\t    role = _ref19.role,\n\t\t\t\t\t    userId = _ref19.userId,\n\t\t\t\t\t    userName = _ref19.userName;\n\t\t\t\t\treturn this.$publish('unjoin', { gameId: gameId, role: role, userId: userId, userName: userName });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Game service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'game_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Game;\n\t\t}(_core.Service);\n\t\n\t\tvar Gda = exports.Gda = function (_Service6) {\n\t\t\t(0, _inherits3.default)(Gda, _Service6);\n\t\n\t\t\tfunction Gda() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Gda);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Gda.__proto__ || (0, _getPrototypeOf2.default)(Gda)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Gda, [{\n\t\t\t\tkey: 'get',\n\t\n\t\t\t\t/**\n\t    * Asks for a data row\n\t    *\n\t    * Returns a full data row.\n\t    * */\n\t\t\t\tvalue: function get(_ref20) {\n\t\t\t\t\tvar key = _ref20.key,\n\t\t\t\t\t    owner = _ref20.owner,\n\t\t\t\t\t    table = _ref20.table;\n\t\t\t\t\treturn this.$publish('get', { key: key, owner: owner, table: table });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Asks for a data cell\n\t    *\n\t    * Returns a precise list of cells from a column in a data row.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'getCells',\n\t\t\t\tvalue: function getCells(_ref21) {\n\t\t\t\t\tvar column = _ref21.column,\n\t\t\t\t\t    key = _ref21.key,\n\t\t\t\t\t    key2 = _ref21.key2,\n\t\t\t\t\t    owner = _ref21.owner,\n\t\t\t\t\t    table = _ref21.table;\n\t\t\t\t\treturn this.$publish('getCells', { column: column, key: key, key2: key2, owner: owner, table: table });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Increments an integer value\n\t    *\n\t    * Increments a cell 64-bit signed integer value and returns the result in the data field.\n\t    * The increment is atomic : if you concurrently increment 10 times a value by 1, the final result will be the initial value plus 10. The actual individual resulting values seen by the 10 concurrent callers may vary discontinuously, with duplicates : at least one of them will see the final (+10) result.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'inc',\n\t\t\t\tvalue: function inc(_ref22) {\n\t\t\t\t\tvar table = _ref22.table,\n\t\t\t\t\t    data = _ref22.data,\n\t\t\t\t\t    key = _ref22.key,\n\t\t\t\t\t    key2 = _ref22.key2,\n\t\t\t\t\t    owner = _ref22.owner,\n\t\t\t\t\t    column = _ref22.column;\n\t\t\t\t\treturn this.$publish('inc', { table: table, data: data, key: key, key2: key2, owner: owner, column: column });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Asks for a list of rows\n\t    *\n\t    * Returns a paginated list of rows from the given table.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'list',\n\t\t\t\tvalue: function list(_ref23) {\n\t\t\t\t\tvar columns = _ref23.columns,\n\t\t\t\t\t    owner = _ref23.owner,\n\t\t\t\t\t    page = _ref23.page,\n\t\t\t\t\t    table = _ref23.table;\n\t\t\t\t\treturn this.$publish('list', { columns: columns, owner: owner, page: page, table: table });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Puts some data into a cell\n\t    *\n\t    * Creates or replaces the contents of a particular cell.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'put',\n\t\t\t\tvalue: function put(_ref24) {\n\t\t\t\t\tvar column = _ref24.column,\n\t\t\t\t\t    data = _ref24.data,\n\t\t\t\t\t    key = _ref24.key,\n\t\t\t\t\t    key2 = _ref24.key2,\n\t\t\t\t\t    owner = _ref24.owner,\n\t\t\t\t\t    table = _ref24.table;\n\t\t\t\t\treturn this.$publish('put', { column: column, data: data, key: key, key2: key2, owner: owner, table: table });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Puts several rows\n\t    *\n\t    * Creates or replaces the (maybe partial) contents of a collection of rows.\n\t    * This method only creates or replaces cells for non-null input values.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'puts',\n\t\t\t\tvalue: function puts(_ref25) {\n\t\t\t\t\tvar owner = _ref25.owner,\n\t\t\t\t\t    rows = _ref25.rows,\n\t\t\t\t\t    table = _ref25.table;\n\t\t\t\t\treturn this.$publish('puts', { owner: owner, rows: rows, table: table });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Asks for a range of rows\n\t    *\n\t    * Returns a paginated range of rows from the given table.\n\t    * A range consists of consecutive rows from the start key (inclusive) to the stop key (exclusive).\n\t    * You can specify partial keys for the start and stop fields.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'range',\n\t\t\t\tvalue: function range(_ref26) {\n\t\t\t\t\tvar columns = _ref26.columns,\n\t\t\t\t\t    owner = _ref26.owner,\n\t\t\t\t\t    page = _ref26.page,\n\t\t\t\t\t    start = _ref26.start,\n\t\t\t\t\t    stop = _ref26.stop,\n\t\t\t\t\t    table = _ref26.table;\n\t\t\t\t\treturn this.$publish('range', { columns: columns, owner: owner, page: page, start: start, stop: stop, table: table });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes one cell inside a column of a row\n\t    *\n\t    * Removes only one cell of the given column of the given row from the given table.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'removeCell',\n\t\t\t\tvalue: function removeCell(_ref27) {\n\t\t\t\t\tvar column = _ref27.column,\n\t\t\t\t\t    key = _ref27.key,\n\t\t\t\t\t    key2 = _ref27.key2,\n\t\t\t\t\t    owner = _ref27.owner,\n\t\t\t\t\t    table = _ref27.table;\n\t\t\t\t\treturn this.$publish('removeCell', { column: column, key: key, key2: key2, owner: owner, table: table });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes one full column of a row\n\t    *\n\t    * Removes all cells of the given column of the given row from the given table.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'removeColumn',\n\t\t\t\tvalue: function removeColumn(_ref28) {\n\t\t\t\t\tvar column = _ref28.column,\n\t\t\t\t\t    key = _ref28.key,\n\t\t\t\t\t    owner = _ref28.owner,\n\t\t\t\t\t    table = _ref28.table;\n\t\t\t\t\treturn this.$publish('removeColumn', { column: column, key: key, owner: owner, table: table });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes a range of rows\n\t    *\n\t    * Removes the specified columns of the given range of rows from the given table.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'removeRange',\n\t\t\t\tvalue: function removeRange(_ref29) {\n\t\t\t\t\tvar columns = _ref29.columns,\n\t\t\t\t\t    owner = _ref29.owner,\n\t\t\t\t\t    start = _ref29.start,\n\t\t\t\t\t    stop = _ref29.stop,\n\t\t\t\t\t    table = _ref29.table;\n\t\t\t\t\treturn this.$publish('removeRange', { columns: columns, owner: owner, start: start, stop: stop, table: table });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes one full row\n\t    *\n\t    * Removes all columns of the given row from the given table.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'removeRow',\n\t\t\t\tvalue: function removeRow(_ref30) {\n\t\t\t\t\tvar key = _ref30.key,\n\t\t\t\t\t    owner = _ref30.owner,\n\t\t\t\t\t    table = _ref30.table;\n\t\t\t\t\treturn this.$publish('removeRow', { key: key, owner: owner, table: table });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Gda service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'gda_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Gda;\n\t\t}(_core.Service);\n\t\n\t\tvar Remoting = function (_Service7) {\n\t\t\t(0, _inherits3.default)(Remoting, _Service7);\n\t\n\t\t\tfunction Remoting() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Remoting);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Remoting.__proto__ || (0, _getPrototypeOf2.default)(Remoting)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Remoting, [{\n\t\t\t\tkey: 'addListener',\n\t\t\t\tvalue: function addListener(_ref31) {\n\t\t\t\t\tvar cmd = _ref31.cmd,\n\t\t\t\t\t    data = _ref31.data,\n\t\t\t\t\t    from = _ref31.from,\n\t\t\t\t\t    fromResource = _ref31.fromResource,\n\t\t\t\t\t    owner = _ref31.owner,\n\t\t\t\t\t    resource = _ref31.resource;\n\t\t\t\t\treturn this.$publish('addListener', { cmd: cmd, data: data, from: from, fromResource: fromResource, owner: owner, resource: resource });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'capabilities',\n\t\t\t\tvalue: function capabilities(_ref32) {\n\t\t\t\t\tvar answeringResource = _ref32.answeringResource,\n\t\t\t\t\t    askingResource = _ref32.askingResource,\n\t\t\t\t\t    _capabilities = _ref32.capabilities;\n\t\t\t\t\treturn this.$publish('capabilities', { answeringResource: answeringResource, askingResource: askingResource, capabilities: _capabilities });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'execute',\n\t\t\t\tvalue: function execute(_ref33) {\n\t\t\t\t\tvar resource = _ref33.resource,\n\t\t\t\t\t    cmd = _ref33.cmd,\n\t\t\t\t\t    data = _ref33.data,\n\t\t\t\t\t    owner = _ref33.owner;\n\t\t\t\t\treturn this.$publish('execute', { resource: resource, cmd: cmd, data: data, owner: owner });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'getCapabilities',\n\t\t\t\tvalue: function getCapabilities() {\n\t\t\t\t\treturn this.$publish('getCapabilities', {});\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'notify',\n\t\t\t\tvalue: function notify(_ref34) {\n\t\t\t\t\tvar cmd = _ref34.cmd,\n\t\t\t\t\t    data = _ref34.data,\n\t\t\t\t\t    from = _ref34.from,\n\t\t\t\t\t    fromResource = _ref34.fromResource,\n\t\t\t\t\t    owner = _ref34.owner,\n\t\t\t\t\t    resource = _ref34.resource;\n\t\t\t\t\treturn this.$publish('notify', { cmd: cmd, data: data, from: from, fromResource: fromResource, owner: owner, resource: resource });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'ping',\n\t\t\t\tvalue: function ping(_ref35) {\n\t\t\t\t\tvar action = _ref35.action;\n\t\t\t\t\treturn this.$publish('ping', { action: action });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'pong',\n\t\t\t\tvalue: function pong(_ref36) {\n\t\t\t\t\tvar action = _ref36.action,\n\t\t\t\t\t    available = _ref36.available,\n\t\t\t\t\t    owner = _ref36.owner,\n\t\t\t\t\t    resource = _ref36.resource,\n\t\t\t\t\t    uid = _ref36.uid,\n\t\t\t\t\t    user = _ref36.user;\n\t\t\t\t\treturn this.$publish('pong', { action: action, available: available, owner: owner, resource: resource, uid: uid, user: user });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'removeListener',\n\t\t\t\tvalue: function removeListener(_ref37) {\n\t\t\t\t\tvar cmd = _ref37.cmd,\n\t\t\t\t\t    data = _ref37.data,\n\t\t\t\t\t    from = _ref37.from,\n\t\t\t\t\t    fromResource = _ref37.fromResource,\n\t\t\t\t\t    owner = _ref37.owner,\n\t\t\t\t\t    resource = _ref37.resource;\n\t\t\t\t\treturn this.$publish('removeListener', { cmd: cmd, data: data, from: from, fromResource: fromResource, owner: owner, resource: resource });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'groups_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Remoting;\n\t\t}(_core.Service);\n\t\n\t\texports.Remoting = Remoting;\n\t\n\t\tvar GroupManagement = exports.GroupManagement = function (_Service8) {\n\t\t\t(0, _inherits3.default)(GroupManagement, _Service8);\n\t\n\t\t\tfunction GroupManagement() {\n\t\t\t\t(0, _classCallCheck3.default)(this, GroupManagement);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (GroupManagement.__proto__ || (0, _getPrototypeOf2.default)(GroupManagement)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(GroupManagement, [{\n\t\t\t\tkey: 'addMe',\n\t\n\t\t\t\t/**\n\t    * Adds me to a group\n\t    *\n\t    * Adds me (the caller) to a group.\n\t    * This verb exists so that group owners may grant the right to join their groups without granting the right to add other users to those groups.\n\t    * The 'user' field is implicitly set to the current user's key.\n\t    * */\n\t\t\t\tvalue: function addMe(_ref38) {\n\t\t\t\t\tvar group = _ref38.group,\n\t\t\t\t\t    owner = _ref38.owner;\n\t\t\t\t\treturn this.$publish('addMe', { group: group, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Adds a user to a group\n\t    *\n\t    * Adds the given user to the given group.\n\t    * Addition may fail if the given group does not already exist.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'addUser',\n\t\t\t\tvalue: function addUser(_ref39) {\n\t\t\t\t\tvar user = _ref39.user,\n\t\t\t\t\t    group = _ref39.group,\n\t\t\t\t\t    owner = _ref39.owner;\n\t\t\t\t\treturn this.$publish('addUser', { user: user, group: group, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**Adds users to a group*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'addUsers',\n\t\t\t\tvalue: function addUsers(_ref40) {\n\t\t\t\t\tvar users = _ref40.users,\n\t\t\t\t\t    group = _ref40.group,\n\t\t\t\t\t    owner = _ref40.owner;\n\t\t\t\t\treturn this.$publish('addUsers', { users: users, group: group, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists my owned groups, with details\n\t    *\n\t    * Returns the whole list of groups owned by the current user, with their members\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'allGroups',\n\t\t\t\tvalue: function allGroups(_ref41) {\n\t\t\t\t\tvar owner = _ref41.owner;\n\t\t\t\t\treturn this.$publish('allGroups', { owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Creates a group\n\t    *\n\t    * Creates a group owned by the current user.\n\t    * Group creation may fail if the group already exists.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'createGroup',\n\t\t\t\tvalue: function createGroup(_ref42) {\n\t\t\t\t\tvar group = _ref42.group,\n\t\t\t\t\t    groupName = _ref42.groupName,\n\t\t\t\t\t    owner = _ref42.owner;\n\t\t\t\t\treturn this.$publish('createGroup', { group: group, groupName: groupName, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes a group\n\t    *\n\t    * Removes the given group owned by the current user or the given owner.\n\t    * Also removes all grants to that group.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'delGroup',\n\t\t\t\tvalue: function delGroup(_ref43) {\n\t\t\t\t\tvar group = _ref43.group,\n\t\t\t\t\t    owner = _ref43.owner;\n\t\t\t\t\treturn this.$publish('delGroup', { group: group, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**Removes a user from a group*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'delUser',\n\t\t\t\tvalue: function delUser(_ref44) {\n\t\t\t\t\tvar group = _ref44.group,\n\t\t\t\t\t    owner = _ref44.owner,\n\t\t\t\t\t    user = _ref44.user;\n\t\t\t\t\treturn this.$publish('delUser', { group: group, owner: owner, user: user });\n\t\t\t\t}\n\t\t\t\t/**Removes users from a group*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'delUsers',\n\t\t\t\tvalue: function delUsers(_ref45) {\n\t\t\t\t\tvar group = _ref45.group,\n\t\t\t\t\t    groupName = _ref45.groupName,\n\t\t\t\t\t    owner = _ref45.owner,\n\t\t\t\t\t    users = _ref45.users;\n\t\t\t\t\treturn this.$publish('delUsers', { group: group, groupName: groupName, owner: owner, users: users });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Tests for a group's existence\n\t    *\n\t    * Returns whether a group exists or not.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'exists',\n\t\t\t\tvalue: function exists(_ref46) {\n\t\t\t\t\tvar group = _ref46.group,\n\t\t\t\t\t    owner = _ref46.owner;\n\t\t\t\t\treturn this.$publish('exists', { group: group, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Grants a right to a group\n\t    *\n\t    * The granting API does not do any check when storing permissions.\n\t    * In particular when granting rights on a verb and resource of another API, the existence of said verb and resource is not checked.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'grant',\n\t\t\t\tvalue: function grant(_ref47) {\n\t\t\t\t\tvar action = _ref47.action,\n\t\t\t\t\t    group = _ref47.group,\n\t\t\t\t\t    owner = _ref47.owner,\n\t\t\t\t\t    resource = _ref47.resource;\n\t\t\t\t\treturn this.$publish('grant', { action: action, group: group, owner: owner, resource: resource });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists the group users\n\t    *\n\t    * Returns the whole list of users configured inside the given group.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'groupUsers',\n\t\t\t\tvalue: function groupUsers(_ref48) {\n\t\t\t\t\tvar group = _ref48.group,\n\t\t\t\t\t    owner = _ref48.owner;\n\t\t\t\t\treturn this.$publish('groupUsers', { group: group, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists my owned groups\n\t    *\n\t    * Returns the whole list of groups owned by the current user\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'groups',\n\t\t\t\tvalue: function groups(_ref49) {\n\t\t\t\t\tvar owner = _ref49.owner;\n\t\t\t\t\treturn this.$publish('groups', { owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists rights for a group\n\t    *\n\t    * This API lists explicitly configured rights.\n\t    * Effective rights include configured rights, implicit rights and inherited rights.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'listGrants',\n\t\t\t\tvalue: function listGrants(_ref50) {\n\t\t\t\t\tvar group = _ref50.group,\n\t\t\t\t\t    owner = _ref50.owner;\n\t\t\t\t\treturn this.$publish('listGrants', { group: group, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists presences for a group\n\t    *\n\t    * Returns the list of members of the given groups, along with their actual and current presence on the zetapush server.\n\t    * The current implementation does not include information about the particular devices users are connected with.\n\t    * If a user is connected twice with two different devices, two identical entries will be returned.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'listPresences',\n\t\t\t\tvalue: function listPresences(_ref51) {\n\t\t\t\t\tvar group = _ref51.group,\n\t\t\t\t\t    owner = _ref51.owner;\n\t\t\t\t\treturn this.$publish('listPresences', { group: group, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Tests membership\n\t    *\n\t    * Tests whether I (the caller) am a member of the given group.\n\t    * This verb exists so that users can determine if they are part of a group without being granted particular rights.\n\t    * The 'user' field is implicitly set to the current user's key.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'memberOf',\n\t\t\t\tvalue: function memberOf(_ref52) {\n\t\t\t\t\tvar hardFail = _ref52.hardFail,\n\t\t\t\t\t    group = _ref52.group,\n\t\t\t\t\t    owner = _ref52.owner;\n\t\t\t\t\treturn this.$publish('memberOf', { hardFail: hardFail, group: group, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Grants rights to a group\n\t    *\n\t    * Grant several rights at once.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'mgrant',\n\t\t\t\tvalue: function mgrant(_ref53) {\n\t\t\t\t\tvar actions = _ref53.actions,\n\t\t\t\t\t    group = _ref53.group,\n\t\t\t\t\t    owner = _ref53.owner,\n\t\t\t\t\t    resource = _ref53.resource;\n\t\t\t\t\treturn this.$publish('mgrant', { actions: actions, group: group, owner: owner, resource: resource });\n\t\t\t\t}\n\t\t\t\t/**Revokes rights for a group*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'mrevoke',\n\t\t\t\tvalue: function mrevoke(_ref54) {\n\t\t\t\t\tvar actions = _ref54.actions,\n\t\t\t\t\t    group = _ref54.group,\n\t\t\t\t\t    owner = _ref54.owner,\n\t\t\t\t\t    resource = _ref54.resource;\n\t\t\t\t\treturn this.$publish('mrevoke', { actions: actions, group: group, owner: owner, resource: resource });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists the groups I am part of\n\t    *\n\t    * Returns the whole list of groups the current user is part of.\n\t    * Groups may be owned by anyone, including the current user.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'myGroups',\n\t\t\t\tvalue: function myGroups(_ref55) {\n\t\t\t\t\tvar owner = _ref55.owner;\n\t\t\t\t\treturn this.$publish('myGroups', { owner: owner });\n\t\t\t\t}\n\t\t\t\t/**Revokes a right for a group*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'revoke',\n\t\t\t\tvalue: function revoke(_ref56) {\n\t\t\t\t\tvar action = _ref56.action,\n\t\t\t\t\t    group = _ref56.group,\n\t\t\t\t\t    owner = _ref56.owner,\n\t\t\t\t\t    resource = _ref56.resource;\n\t\t\t\t\treturn this.$publish('revoke', { action: action, group: group, owner: owner, resource: resource });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to GroupManagement service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'groups_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn GroupManagement;\n\t\t}(_core.Service);\n\t\n\t\tvar Httpclient = exports.Httpclient = function (_Service9) {\n\t\t\t(0, _inherits3.default)(Httpclient, _Service9);\n\t\n\t\t\tfunction Httpclient() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Httpclient);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Httpclient.__proto__ || (0, _getPrototypeOf2.default)(Httpclient)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Httpclient, [{\n\t\t\t\tkey: 'call',\n\t\n\t\t\t\t/**\n\t    * Makes a predefined request\n\t    *\n\t    * Lookups a predefined request by name, and executes it.\n\t    * */\n\t\t\t\tvalue: function call(_ref57) {\n\t\t\t\t\tvar name = _ref57.name,\n\t\t\t\t\t    requestId = _ref57.requestId;\n\t\t\t\t\treturn this.$publish('call', { name: name, requestId: requestId });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Httpclient service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'httpclient_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Httpclient;\n\t\t}(_core.Service);\n\t\n\t\tvar Macro = exports.Macro = function (_Service10) {\n\t\t\t(0, _inherits3.default)(Macro, _Service10);\n\t\n\t\t\tfunction Macro() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Macro);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Macro.__proto__ || (0, _getPrototypeOf2.default)(Macro)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Macro, [{\n\t\t\t\tkey: 'call',\n\t\n\t\t\t\t/**\n\t    * Plays a previously recorded macro\n\t    *\n\t    * DO NOT use this verb from inside an enclosing macro when you need the result in order to proceed with the enclosing macro.\n\t    * You can override the default notification channel when defining the macro.\n\t    * */\n\t\t\t\tvalue: function call(_ref58) {\n\t\t\t\t\tvar debug = _ref58.debug,\n\t\t\t\t\t    hardFail = _ref58.hardFail,\n\t\t\t\t\t    name = _ref58.name,\n\t\t\t\t\t    parameters = _ref58.parameters;\n\t\t\t\t\treturn this.$publish('call', { debug: debug, hardFail: hardFail, name: name, parameters: parameters });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Macro service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'macro_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Macro;\n\t\t}(_core.Service);\n\t\n\t\tvar MacroDebug = function (_Service11) {\n\t\t\t(0, _inherits3.default)(MacroDebug, _Service11);\n\t\n\t\t\tfunction MacroDebug() {\n\t\t\t\t(0, _classCallCheck3.default)(this, MacroDebug);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (MacroDebug.__proto__ || (0, _getPrototypeOf2.default)(MacroDebug)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(MacroDebug, [{\n\t\t\t\tkey: 'breakpoint',\n\t\t\t\tvalue: function breakpoint(_ref59) {\n\t\t\t\t\tvar _breakpoint = _ref59.breakpoint,\n\t\t\t\t\t    enabled = _ref59.enabled,\n\t\t\t\t\t    token = _ref59.token;\n\t\t\t\t\treturn this.$publish('breakpoint', { breakpoint: _breakpoint, enabled: enabled, token: token });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'info',\n\t\t\t\tvalue: function info(_ref60) {\n\t\t\t\t\tvar exp = _ref60.exp,\n\t\t\t\t\t    frame = _ref60.frame,\n\t\t\t\t\t    token = _ref60.token;\n\t\t\t\t\treturn this.$publish('info', { exp: exp, frame: frame, token: token });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'livedebug',\n\t\t\t\tvalue: function livedebug(_ref61) {\n\t\t\t\t\tvar breakpoints = _ref61.breakpoints,\n\t\t\t\t\t    debug = _ref61.debug,\n\t\t\t\t\t    hardFail = _ref61.hardFail,\n\t\t\t\t\t    name = _ref61.name,\n\t\t\t\t\t    parameters = _ref61.parameters,\n\t\t\t\t\t    token = _ref61.token;\n\t\t\t\t\treturn this.$publish('livedebug', { breakpoints: breakpoints, debug: debug, hardFail: hardFail, name: name, parameters: parameters, token: token });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'resume',\n\t\t\t\tvalue: function resume(_ref62) {\n\t\t\t\t\tvar token = _ref62.token,\n\t\t\t\t\t    type = _ref62.type;\n\t\t\t\t\treturn this.$publish('resume', { token: token, type: type });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'variable',\n\t\t\t\tvalue: function variable(_ref63) {\n\t\t\t\t\tvar data = _ref63.data,\n\t\t\t\t\t    frame = _ref63.frame,\n\t\t\t\t\t    name = _ref63.name,\n\t\t\t\t\t    token = _ref63.token;\n\t\t\t\t\treturn this.$publish('variable', { data: data, frame: frame, name: name, token: token });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'macro_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn MacroDebug;\n\t\t}(_core.Service);\n\t\n\t\texports.MacroDebug = MacroDebug;\n\t\n\t\tvar Sendmail = exports.Sendmail = function (_Service12) {\n\t\t\t(0, _inherits3.default)(Sendmail, _Service12);\n\t\n\t\t\tfunction Sendmail() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Sendmail);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Sendmail.__proto__ || (0, _getPrototypeOf2.default)(Sendmail)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Sendmail, null, [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Sendmail service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'sendmail_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Sendmail;\n\t\t}(_core.Service);\n\t\n\t\tvar Messaging = exports.Messaging = function (_Service13) {\n\t\t\t(0, _inherits3.default)(Messaging, _Service13);\n\t\n\t\t\tfunction Messaging() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Messaging);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Messaging.__proto__ || (0, _getPrototypeOf2.default)(Messaging)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Messaging, [{\n\t\t\t\tkey: 'send',\n\t\n\t\t\t\t/**\n\t    * Sends a message to a target\n\t    *\n\t    * Sends the given message to the specified target on the given (optional) channel.\n\t    * The administratively given default channel name is used when none is provided in the message itself.\n\t    * */\n\t\t\t\tvalue: function send(_ref64) {\n\t\t\t\t\tvar target = _ref64.target,\n\t\t\t\t\t    channel = _ref64.channel,\n\t\t\t\t\t    data = _ref64.data;\n\t\t\t\t\treturn this.$publish('send', { target: target, channel: channel, data: data });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Messaging service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'messaging_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Messaging;\n\t\t}(_core.Service);\n\t\n\t\tvar Queue = exports.Queue = function (_Service14) {\n\t\t\t(0, _inherits3.default)(Queue, _Service14);\n\t\n\t\t\tfunction Queue() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Queue);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Queue.__proto__ || (0, _getPrototypeOf2.default)(Queue)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Queue, [{\n\t\t\t\tkey: 'call',\n\t\n\t\t\t\t/**\n\t    * Submits a task\n\t    *\n\t    * Producer API.\n\t    * A task producer submits the given task to the server.\n\t    * The server will find a tasker with processing capacity and dispatch the task.\n\t    * The task result will be returned to the caller.\n\t    * When called from inside a macro, the comsumer generated result is available for further use.\n\t    * */\n\t\t\t\tvalue: function call(_ref65) {\n\t\t\t\t\tvar description = _ref65.description,\n\t\t\t\t\t    originBusinessId = _ref65.originBusinessId,\n\t\t\t\t\t    originDeploymentId = _ref65.originDeploymentId,\n\t\t\t\t\t    data = _ref65.data,\n\t\t\t\t\t    owner = _ref65.owner;\n\t\t\t\t\treturn this.$publish('call', { description: description, originBusinessId: originBusinessId, originDeploymentId: originDeploymentId, data: data, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Notifies completion of a task\n\t    *\n\t    * Consumer API.\n\t    * The tasker notifies completion of the given task to the server.\n\t    * The tasker can optionally include a result or an error code.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'done',\n\t\t\t\tvalue: function done(_ref66) {\n\t\t\t\t\tvar result = _ref66.result,\n\t\t\t\t\t    success = _ref66.success,\n\t\t\t\t\t    taskId = _ref66.taskId;\n\t\t\t\t\treturn this.$publish('done', { result: result, success: success, taskId: taskId });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Registers a consumer\n\t    *\n\t    * Consumer API.\n\t    * Registers the current user resource as an available task consumer.\n\t    * Tasks will be then dispatched to that consumer.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'register',\n\t\t\t\tvalue: function register(_ref67) {\n\t\t\t\t\tvar capacity = _ref67.capacity;\n\t\t\t\t\treturn this.$publish('register', { capacity: capacity });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Submits a task\n\t    *\n\t    * Producer API.\n\t    * A task producer submits the given task to the server.\n\t    * The server will find a tasker with processing capacity and dispatch the task.\n\t    * The task result will be ignored : the producer will not receive any notification of any kind, even in case of errors (including capacity exceeded errors).\n\t    * This verb will return immediately : you can use this API to asynchronously submit a task.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'submit',\n\t\t\t\tvalue: function submit(_ref68) {\n\t\t\t\t\tvar description = _ref68.description,\n\t\t\t\t\t    originBusinessId = _ref68.originBusinessId,\n\t\t\t\t\t    originDeploymentId = _ref68.originDeploymentId,\n\t\t\t\t\t    data = _ref68.data,\n\t\t\t\t\t    owner = _ref68.owner;\n\t\t\t\t\treturn this.$publish('submit', { description: description, originBusinessId: originBusinessId, originDeploymentId: originDeploymentId, data: data, owner: owner });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Unregisters a consumer\n\t    *\n\t    * Consumer API.\n\t    * Unregisters the current user resource as an available task consumer.\n\t    * All non finished tasks are returned to the server.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'unregister',\n\t\t\t\tvalue: function unregister() {\n\t\t\t\t\treturn this.$publish('unregister', {});\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Queue service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'queue_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Queue;\n\t\t}(_core.Service);\n\t\n\t\tvar Notif = exports.Notif = function (_Service15) {\n\t\t\t(0, _inherits3.default)(Notif, _Service15);\n\t\n\t\t\tfunction Notif() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Notif);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Notif.__proto__ || (0, _getPrototypeOf2.default)(Notif)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Notif, null, [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Notif service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'notif_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Notif;\n\t\t}(_core.Service);\n\t\n\t\tvar Sms_ovh = exports.Sms_ovh = function (_Service16) {\n\t\t\t(0, _inherits3.default)(Sms_ovh, _Service16);\n\t\n\t\t\tfunction Sms_ovh() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Sms_ovh);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Sms_ovh.__proto__ || (0, _getPrototypeOf2.default)(Sms_ovh)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Sms_ovh, null, [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Sms_ovh service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'sms_ovh_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Sms_ovh;\n\t\t}(_core.Service);\n\t\n\t\tvar Cron = exports.Cron = function (_Service17) {\n\t\t\t(0, _inherits3.default)(Cron, _Service17);\n\t\n\t\t\tfunction Cron() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Cron);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Cron.__proto__ || (0, _getPrototypeOf2.default)(Cron)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Cron, [{\n\t\t\t\tkey: 'list',\n\t\n\t\t\t\t/**\n\t    * List the configured tasks\n\t    *\n\t    * Returns a paginated list of the asking user's tasks.\n\t    * */\n\t\t\t\tvalue: function list(_ref69) {\n\t\t\t\t\tvar owner = _ref69.owner,\n\t\t\t\t\t    page = _ref69.page,\n\t\t\t\t\t    start = _ref69.start,\n\t\t\t\t\t    stop = _ref69.stop;\n\t\t\t\t\treturn this.$publish('list', { owner: owner, page: page, start: start, stop: stop });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes a scheduled task\n\t    *\n\t    * Removes a previously scheduled task.\n\t    * Does absolutely nothing if asked to remove a non-existent task.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'unschedule',\n\t\t\t\tvalue: function unschedule(_ref70) {\n\t\t\t\t\tvar cronName = _ref70.cronName,\n\t\t\t\t\t    owner = _ref70.owner;\n\t\t\t\t\treturn this.$publish('unschedule', { cronName: cronName, owner: owner });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Cron service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'cron_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Cron;\n\t\t}(_core.Service);\n\t\n\t\tvar Search = function (_Service18) {\n\t\t\t(0, _inherits3.default)(Search, _Service18);\n\t\n\t\t\tfunction Search() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Search);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Search.__proto__ || (0, _getPrototypeOf2.default)(Search)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Search, [{\n\t\t\t\tkey: 'delete',\n\t\t\t\tvalue: function _delete(_ref71) {\n\t\t\t\t\tvar id = _ref71.id,\n\t\t\t\t\t    index = _ref71.index,\n\t\t\t\t\t    type = _ref71.type;\n\t\t\t\t\treturn this.$publish('delete', { id: id, index: index, type: type });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'get',\n\t\t\t\tvalue: function get(_ref72) {\n\t\t\t\t\tvar id = _ref72.id,\n\t\t\t\t\t    index = _ref72.index,\n\t\t\t\t\t    type = _ref72.type;\n\t\t\t\t\treturn this.$publish('get', { id: id, index: index, type: type });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'index',\n\t\t\t\tvalue: function index(_ref73) {\n\t\t\t\t\tvar data = _ref73.data,\n\t\t\t\t\t    id = _ref73.id,\n\t\t\t\t\t    _index = _ref73.index,\n\t\t\t\t\t    type = _ref73.type;\n\t\t\t\t\treturn this.$publish('index', { data: data, id: id, index: _index, type: type });\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\tkey: 'search',\n\t\t\t\tvalue: function search(_ref74) {\n\t\t\t\t\tvar indices = _ref74.indices,\n\t\t\t\t\t    page = _ref74.page,\n\t\t\t\t\t    query = _ref74.query,\n\t\t\t\t\t    sort = _ref74.sort,\n\t\t\t\t\t    types = _ref74.types;\n\t\t\t\t\treturn this.$publish('search', { indices: indices, page: page, query: query, sort: sort, types: types });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'search_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Search;\n\t\t}(_core.Service);\n\t\n\t\texports.Search = Search;\n\t\n\t\tvar Template = exports.Template = function (_Service19) {\n\t\t\t(0, _inherits3.default)(Template, _Service19);\n\t\n\t\t\tfunction Template() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Template);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Template.__proto__ || (0, _getPrototypeOf2.default)(Template)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Template, [{\n\t\t\t\tkey: 'evaluate',\n\t\n\t\t\t\t/**\n\t    * Evaluates a template\n\t    *\n\t    * Evaluates the given template and returns the result as a string.\n\t    * Templates are parsed the first time they are evaluated. Evaluation may fail early due to a parsing error.\n\t    * */\n\t\t\t\tvalue: function evaluate(_ref75) {\n\t\t\t\t\tvar data = _ref75.data,\n\t\t\t\t\t    languageTag = _ref75.languageTag,\n\t\t\t\t\t    name = _ref75.name,\n\t\t\t\t\t    requestId = _ref75.requestId;\n\t\t\t\t\treturn this.$publish('evaluate', { data: data, languageTag: languageTag, name: name, requestId: requestId });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Template service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'template_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Template;\n\t\t}(_core.Service);\n\t\n\t\tvar Zpfs_s3 = exports.Zpfs_s3 = function (_Service20) {\n\t\t\t(0, _inherits3.default)(Zpfs_s3, _Service20);\n\t\n\t\t\tfunction Zpfs_s3() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Zpfs_s3);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Zpfs_s3.__proto__ || (0, _getPrototypeOf2.default)(Zpfs_s3)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Zpfs_s3, [{\n\t\t\t\tkey: 'cp',\n\t\n\t\t\t\t/**\n\t    * Copies a file\n\t    *\n\t    * Copies a file or folder (recursively) to a new location.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\t\t\tvalue: function cp(_ref76) {\n\t\t\t\t\tvar oldPath = _ref76.oldPath,\n\t\t\t\t\t    owner = _ref76.owner,\n\t\t\t\t\t    path = _ref76.path;\n\t\t\t\t\treturn this.$publish('cp', { oldPath: oldPath, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Returns disk usage\n\t    *\n\t    * Returns an recursively aggregated number of used bytes, starting at the given path.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'du',\n\t\t\t\tvalue: function du(_ref77) {\n\t\t\t\t\tvar owner = _ref77.owner,\n\t\t\t\t\t    path = _ref77.path;\n\t\t\t\t\treturn this.$publish('du', { owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Links a file\n\t    *\n\t    * Links a file or folder to another location.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'link',\n\t\t\t\tvalue: function link(_ref78) {\n\t\t\t\t\tvar oldPath = _ref78.oldPath,\n\t\t\t\t\t    owner = _ref78.owner,\n\t\t\t\t\t    path = _ref78.path;\n\t\t\t\t\treturn this.$publish('link', { oldPath: oldPath, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists a folder content\n\t    *\n\t    * Returns a paginated list of the folder's content.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'ls',\n\t\t\t\tvalue: function ls(_ref79) {\n\t\t\t\t\tvar folder = _ref79.folder,\n\t\t\t\t\t    owner = _ref79.owner,\n\t\t\t\t\t    page = _ref79.page;\n\t\t\t\t\treturn this.$publish('ls', { folder: folder, owner: owner, page: page });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Creates a folder\n\t    *\n\t    * Creates a new folder.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'mkdir',\n\t\t\t\tvalue: function mkdir(_ref80) {\n\t\t\t\t\tvar folder = _ref80.folder,\n\t\t\t\t\t    owner = _ref80.owner,\n\t\t\t\t\t    parents = _ref80.parents;\n\t\t\t\t\treturn this.$publish('mkdir', { folder: folder, owner: owner, parents: parents });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Moves a file\n\t    *\n\t    * Moves a file or folder (recursively) to a new location.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'mv',\n\t\t\t\tvalue: function mv(_ref81) {\n\t\t\t\t\tvar oldPath = _ref81.oldPath,\n\t\t\t\t\t    owner = _ref81.owner,\n\t\t\t\t\t    path = _ref81.path;\n\t\t\t\t\treturn this.$publish('mv', { oldPath: oldPath, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Notifies of upload completion\n\t    *\n\t    * The client application calls this verb to notify that it's done uploading to the cloud.\n\t    * Calling that verb MAY trigger additional events such as thumbnail/metadata creation.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'newFile',\n\t\t\t\tvalue: function newFile(_ref82) {\n\t\t\t\t\tvar guid = _ref82.guid,\n\t\t\t\t\t    metadata = _ref82.metadata,\n\t\t\t\t\t    owner = _ref82.owner,\n\t\t\t\t\t    tags = _ref82.tags;\n\t\t\t\t\treturn this.$publish('newFile', { guid: guid, metadata: metadata, owner: owner, tags: tags });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Requests an upload URL\n\t    *\n\t    * Requests an HTTP upload URL.\n\t    * The URL contains temporary credentials (typically valid for a few minutes) and is meant for immediate use.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'newUploadUrl',\n\t\t\t\tvalue: function newUploadUrl(_ref83) {\n\t\t\t\t\tvar contentType = _ref83.contentType,\n\t\t\t\t\t    owner = _ref83.owner,\n\t\t\t\t\t    path = _ref83.path;\n\t\t\t\t\treturn this.$publish('newUploadUrl', { contentType: contentType, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes a file\n\t    *\n\t    * Removes a file or folder (recursively).\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'rm',\n\t\t\t\tvalue: function rm(_ref84) {\n\t\t\t\t\tvar owner = _ref84.owner,\n\t\t\t\t\t    path = _ref84.path;\n\t\t\t\t\treturn this.$publish('rm', { owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Returns information about a file\n\t    *\n\t    * Returns information about a single file.\n\t    * The entry field will be null if the path does not exist\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'stat',\n\t\t\t\tvalue: function stat(_ref85) {\n\t\t\t\t\tvar owner = _ref85.owner,\n\t\t\t\t\t    path = _ref85.path;\n\t\t\t\t\treturn this.$publish('stat', { owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**Updates a file's metadata*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'updateMeta',\n\t\t\t\tvalue: function updateMeta(_ref86) {\n\t\t\t\t\tvar metadata = _ref86.metadata,\n\t\t\t\t\t    metadataFiles = _ref86.metadataFiles,\n\t\t\t\t\t    owner = _ref86.owner,\n\t\t\t\t\t    path = _ref86.path;\n\t\t\t\t\treturn this.$publish('updateMeta', { metadata: metadata, metadataFiles: metadataFiles, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Zpfs_s3 service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'zpfs_s3_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Zpfs_s3;\n\t\t}(_core.Service);\n\t\n\t\tvar Zpfs_hdfs = exports.Zpfs_hdfs = function (_Service21) {\n\t\t\t(0, _inherits3.default)(Zpfs_hdfs, _Service21);\n\t\n\t\t\tfunction Zpfs_hdfs() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Zpfs_hdfs);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Zpfs_hdfs.__proto__ || (0, _getPrototypeOf2.default)(Zpfs_hdfs)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Zpfs_hdfs, [{\n\t\t\t\tkey: 'cp',\n\t\n\t\t\t\t/**\n\t    * Copies a file\n\t    *\n\t    * Copies a file or folder (recursively) to a new location.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\t\t\tvalue: function cp(_ref87) {\n\t\t\t\t\tvar oldPath = _ref87.oldPath,\n\t\t\t\t\t    owner = _ref87.owner,\n\t\t\t\t\t    path = _ref87.path;\n\t\t\t\t\treturn this.$publish('cp', { oldPath: oldPath, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Returns disk usage\n\t    *\n\t    * Returns an recursively aggregated number of used bytes, starting at the given path.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'du',\n\t\t\t\tvalue: function du(_ref88) {\n\t\t\t\t\tvar owner = _ref88.owner,\n\t\t\t\t\t    path = _ref88.path;\n\t\t\t\t\treturn this.$publish('du', { owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Links a file\n\t    *\n\t    * Links a file or folder to another location.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'link',\n\t\t\t\tvalue: function link(_ref89) {\n\t\t\t\t\tvar oldPath = _ref89.oldPath,\n\t\t\t\t\t    owner = _ref89.owner,\n\t\t\t\t\t    path = _ref89.path;\n\t\t\t\t\treturn this.$publish('link', { oldPath: oldPath, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists a folder content\n\t    *\n\t    * Returns a paginated list of the folder's content.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'ls',\n\t\t\t\tvalue: function ls(_ref90) {\n\t\t\t\t\tvar folder = _ref90.folder,\n\t\t\t\t\t    owner = _ref90.owner,\n\t\t\t\t\t    page = _ref90.page;\n\t\t\t\t\treturn this.$publish('ls', { folder: folder, owner: owner, page: page });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Creates a folder\n\t    *\n\t    * Creates a new folder.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'mkdir',\n\t\t\t\tvalue: function mkdir(_ref91) {\n\t\t\t\t\tvar folder = _ref91.folder,\n\t\t\t\t\t    owner = _ref91.owner,\n\t\t\t\t\t    parents = _ref91.parents;\n\t\t\t\t\treturn this.$publish('mkdir', { folder: folder, owner: owner, parents: parents });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Moves a file\n\t    *\n\t    * Moves a file or folder (recursively) to a new location.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'mv',\n\t\t\t\tvalue: function mv(_ref92) {\n\t\t\t\t\tvar oldPath = _ref92.oldPath,\n\t\t\t\t\t    owner = _ref92.owner,\n\t\t\t\t\t    path = _ref92.path;\n\t\t\t\t\treturn this.$publish('mv', { oldPath: oldPath, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Notifies of upload completion\n\t    *\n\t    * The client application calls this verb to notify that it's done uploading to the cloud.\n\t    * Calling that verb MAY trigger additional events such as thumbnail/metadata creation.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'newFile',\n\t\t\t\tvalue: function newFile(_ref93) {\n\t\t\t\t\tvar guid = _ref93.guid,\n\t\t\t\t\t    metadata = _ref93.metadata,\n\t\t\t\t\t    owner = _ref93.owner,\n\t\t\t\t\t    tags = _ref93.tags;\n\t\t\t\t\treturn this.$publish('newFile', { guid: guid, metadata: metadata, owner: owner, tags: tags });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Requests an upload URL\n\t    *\n\t    * Requests an HTTP upload URL.\n\t    * The URL contains temporary credentials (typically valid for a few minutes) and is meant for immediate use.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'newUploadUrl',\n\t\t\t\tvalue: function newUploadUrl(_ref94) {\n\t\t\t\t\tvar contentType = _ref94.contentType,\n\t\t\t\t\t    owner = _ref94.owner,\n\t\t\t\t\t    path = _ref94.path;\n\t\t\t\t\treturn this.$publish('newUploadUrl', { contentType: contentType, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes a file\n\t    *\n\t    * Removes a file or folder (recursively).\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'rm',\n\t\t\t\tvalue: function rm(_ref95) {\n\t\t\t\t\tvar owner = _ref95.owner,\n\t\t\t\t\t    path = _ref95.path;\n\t\t\t\t\treturn this.$publish('rm', { owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Returns information about a file\n\t    *\n\t    * Returns information about a single file.\n\t    * The entry field will be null if the path does not exist\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'stat',\n\t\t\t\tvalue: function stat(_ref96) {\n\t\t\t\t\tvar owner = _ref96.owner,\n\t\t\t\t\t    path = _ref96.path;\n\t\t\t\t\treturn this.$publish('stat', { owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**Updates a file's metadata*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'updateMeta',\n\t\t\t\tvalue: function updateMeta(_ref97) {\n\t\t\t\t\tvar metadata = _ref97.metadata,\n\t\t\t\t\t    metadataFiles = _ref97.metadataFiles,\n\t\t\t\t\t    owner = _ref97.owner,\n\t\t\t\t\t    path = _ref97.path;\n\t\t\t\t\treturn this.$publish('updateMeta', { metadata: metadata, metadataFiles: metadataFiles, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Zpfs_hdfs service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'zpfs_hdfs_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Zpfs_hdfs;\n\t\t}(_core.Service);\n\t\n\t\tvar Zpfs_s3compat = exports.Zpfs_s3compat = function (_Service22) {\n\t\t\t(0, _inherits3.default)(Zpfs_s3compat, _Service22);\n\t\n\t\t\tfunction Zpfs_s3compat() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Zpfs_s3compat);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Zpfs_s3compat.__proto__ || (0, _getPrototypeOf2.default)(Zpfs_s3compat)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Zpfs_s3compat, [{\n\t\t\t\tkey: 'cp',\n\t\n\t\t\t\t/**\n\t    * Copies a file\n\t    *\n\t    * Copies a file or folder (recursively) to a new location.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\t\t\tvalue: function cp(_ref98) {\n\t\t\t\t\tvar oldPath = _ref98.oldPath,\n\t\t\t\t\t    owner = _ref98.owner,\n\t\t\t\t\t    path = _ref98.path;\n\t\t\t\t\treturn this.$publish('cp', { oldPath: oldPath, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Returns disk usage\n\t    *\n\t    * Returns an recursively aggregated number of used bytes, starting at the given path.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'du',\n\t\t\t\tvalue: function du(_ref99) {\n\t\t\t\t\tvar owner = _ref99.owner,\n\t\t\t\t\t    path = _ref99.path;\n\t\t\t\t\treturn this.$publish('du', { owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Links a file\n\t    *\n\t    * Links a file or folder to another location.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'link',\n\t\t\t\tvalue: function link(_ref100) {\n\t\t\t\t\tvar oldPath = _ref100.oldPath,\n\t\t\t\t\t    owner = _ref100.owner,\n\t\t\t\t\t    path = _ref100.path;\n\t\t\t\t\treturn this.$publish('link', { oldPath: oldPath, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Lists a folder content\n\t    *\n\t    * Returns a paginated list of the folder's content.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'ls',\n\t\t\t\tvalue: function ls(_ref101) {\n\t\t\t\t\tvar folder = _ref101.folder,\n\t\t\t\t\t    owner = _ref101.owner,\n\t\t\t\t\t    page = _ref101.page;\n\t\t\t\t\treturn this.$publish('ls', { folder: folder, owner: owner, page: page });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Creates a folder\n\t    *\n\t    * Creates a new folder.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'mkdir',\n\t\t\t\tvalue: function mkdir(_ref102) {\n\t\t\t\t\tvar folder = _ref102.folder,\n\t\t\t\t\t    owner = _ref102.owner,\n\t\t\t\t\t    parents = _ref102.parents;\n\t\t\t\t\treturn this.$publish('mkdir', { folder: folder, owner: owner, parents: parents });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Moves a file\n\t    *\n\t    * Moves a file or folder (recursively) to a new location.\n\t    * May fail if the target location is not empty.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'mv',\n\t\t\t\tvalue: function mv(_ref103) {\n\t\t\t\t\tvar oldPath = _ref103.oldPath,\n\t\t\t\t\t    owner = _ref103.owner,\n\t\t\t\t\t    path = _ref103.path;\n\t\t\t\t\treturn this.$publish('mv', { oldPath: oldPath, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Notifies of upload completion\n\t    *\n\t    * The client application calls this verb to notify that it's done uploading to the cloud.\n\t    * Calling that verb MAY trigger additional events such as thumbnail/metadata creation.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'newFile',\n\t\t\t\tvalue: function newFile(_ref104) {\n\t\t\t\t\tvar guid = _ref104.guid,\n\t\t\t\t\t    metadata = _ref104.metadata,\n\t\t\t\t\t    owner = _ref104.owner,\n\t\t\t\t\t    tags = _ref104.tags;\n\t\t\t\t\treturn this.$publish('newFile', { guid: guid, metadata: metadata, owner: owner, tags: tags });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Requests an upload URL\n\t    *\n\t    * Requests an HTTP upload URL.\n\t    * The URL contains temporary credentials (typically valid for a few minutes) and is meant for immediate use.\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'newUploadUrl',\n\t\t\t\tvalue: function newUploadUrl(_ref105) {\n\t\t\t\t\tvar contentType = _ref105.contentType,\n\t\t\t\t\t    owner = _ref105.owner,\n\t\t\t\t\t    path = _ref105.path;\n\t\t\t\t\treturn this.$publish('newUploadUrl', { contentType: contentType, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Removes a file\n\t    *\n\t    * Removes a file or folder (recursively).\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'rm',\n\t\t\t\tvalue: function rm(_ref106) {\n\t\t\t\t\tvar owner = _ref106.owner,\n\t\t\t\t\t    path = _ref106.path;\n\t\t\t\t\treturn this.$publish('rm', { owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**\n\t    * Returns information about a file\n\t    *\n\t    * Returns information about a single file.\n\t    * The entry field will be null if the path does not exist\n\t    * */\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'stat',\n\t\t\t\tvalue: function stat(_ref107) {\n\t\t\t\t\tvar owner = _ref107.owner,\n\t\t\t\t\t    path = _ref107.path;\n\t\t\t\t\treturn this.$publish('stat', { owner: owner, path: path });\n\t\t\t\t}\n\t\t\t\t/**Updates a file's metadata*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'updateMeta',\n\t\t\t\tvalue: function updateMeta(_ref108) {\n\t\t\t\t\tvar metadata = _ref108.metadata,\n\t\t\t\t\t    metadataFiles = _ref108.metadataFiles,\n\t\t\t\t\t    owner = _ref108.owner,\n\t\t\t\t\t    path = _ref108.path;\n\t\t\t\t\treturn this.$publish('updateMeta', { metadata: metadata, metadataFiles: metadataFiles, owner: owner, path: path });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Zpfs_s3compat service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'zpfs_s3compat_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Zpfs_s3compat;\n\t\t}(_core.Service);\n\t\n\t\tvar Userdir = exports.Userdir = function (_Service23) {\n\t\t\t(0, _inherits3.default)(Userdir, _Service23);\n\t\n\t\t\tfunction Userdir() {\n\t\t\t\t(0, _classCallCheck3.default)(this, Userdir);\n\t\t\t\treturn (0, _possibleConstructorReturn3.default)(this, (Userdir.__proto__ || (0, _getPrototypeOf2.default)(Userdir)).apply(this, arguments));\n\t\t\t}\n\t\n\t\t\t(0, _createClass3.default)(Userdir, [{\n\t\t\t\tkey: 'search',\n\t\n\t\t\t\t/**Searches for users matching the request*/\n\t\t\t\tvalue: function search(_ref109) {\n\t\t\t\t\tvar page = _ref109.page,\n\t\t\t\t\t    query = _ref109.query,\n\t\t\t\t\t    requestId = _ref109.requestId;\n\t\t\t\t\treturn this.$publish('search', { page: page, query: query, requestId: requestId });\n\t\t\t\t}\n\t\t\t\t/**Requests public data for the specified users*/\n\t\n\t\t\t}, {\n\t\t\t\tkey: 'userInfo',\n\t\t\t\tvalue: function userInfo(_ref110) {\n\t\t\t\t\tvar userKeys = _ref110.userKeys;\n\t\t\t\t\treturn this.$publish('userInfo', { userKeys: userKeys });\n\t\t\t\t}\n\t\t\t}], [{\n\t\t\t\tkey: 'DEFAULT_DEPLOYMENT_ID',\n\t\n\t\t\t\t/**\n\t    * Get default deployment id associated to Userdir service\n\t    * @return {string}\n\t    */\n\t\t\t\tget: function get() {\n\t\t\t\t\treturn 'userdir_0';\n\t\t\t\t}\n\t\t\t}]);\n\t\t\treturn Userdir;\n\t\t}(_core.Service);\n\t});\n\n/***/ },\n/* 130 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(131), __webpack_require__(4)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('babel-runtime/core-js/array/from'), require('babel-runtime/core-js/object/get-prototype-of'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.from, global.getPrototypeOf);\n\t    global.index = mod.exports;\n\t  }\n\t})(this, function (exports, _from, _getPrototypeOf) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.uuid = exports.isDerivedOf = exports.isHttpsProtocol = exports.getServers = exports.getSecureUrl = exports.shuffle = exports.API_URL = undefined;\n\t\n\t  var _from2 = _interopRequireDefault(_from);\n\t\n\t  var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  /**\n\t   * Match unsecure pattern web\n\t   * @type {RegExp}\n\t   */\n\t  var HTTP_PATTERN = /^http:\\/\\/|^\\/\\//;\n\t\n\t  /**\n\t   * Https protocol\n\t   * @type {string}\n\t   */\n\t  var HTTPS_PROTOCOL = 'https:';\n\t\n\t  /**\n\t   * Alpha numeric dictionary\n\t   */\n\t  var DICTIONARY = 'abcdefghijklmnopqrstuvwxyz0123456789';\n\t\n\t  /**\n\t  * Default ZetaPush API URL\n\t  * @access private\n\t  */\n\t  var API_URL = exports.API_URL = 'https://api.zpush.io/';\n\t\n\t  /**\n\t   * @access private\n\t   * @param {Array<Object>} list\n\t   * @return {Object}\n\t   */\n\t  var shuffle = exports.shuffle = function shuffle(list) {\n\t    var index = Math.floor(Math.random() * list.length);\n\t    return list[index];\n\t  };\n\t\n\t  /**\n\t   * @access private\n\t   * @param {string} url\n\t   * @param {boolean} forceHttps\n\t   * @return {string}\n\t   */\n\t  var getSecureUrl = exports.getSecureUrl = function getSecureUrl(url, forceHttps) {\n\t    return forceHttps ? url.replace(HTTP_PATTERN, 'https://') : url;\n\t  };\n\t\n\t  /**\n\t   * @access private\n\t   * @param {{apiUrl: string, sandboxId: string, forceHttps: boolean}} parameters\n\t   * @return {Promise}\n\t   */\n\t  var getServers = exports.getServers = function getServers(_ref) {\n\t    var apiUrl = _ref.apiUrl,\n\t        sandboxId = _ref.sandboxId,\n\t        forceHttps = _ref.forceHttps;\n\t\n\t    var secureApiUrl = getSecureUrl(apiUrl, forceHttps);\n\t    var url = '' + secureApiUrl + sandboxId;\n\t    return fetch(url).then(function (response) {\n\t      return response.json();\n\t    }).then(function (_ref2) {\n\t      var servers = _ref2.servers;\n\t\n\t      // TODO: Replace by a server side implementation when available\n\t      return servers.map(function (server) {\n\t        return getSecureUrl(server, forceHttps);\n\t      });\n\t    });\n\t  };\n\t\n\t  /**\n\t   * @access private\n\t   * @return {boolean}\n\t   */\n\t  var isHttpsProtocol = exports.isHttpsProtocol = function isHttpsProtocol() {\n\t    return location.protocol === HTTPS_PROTOCOL;\n\t  };\n\t\n\t  /**\n\t   * @access private\n\t   * @param Class Derived\n\t   * @param Class Parent\n\t   * @return {boolean}\n\t   */\n\t  var isDerivedOf = exports.isDerivedOf = function isDerivedOf(Derived, Parent) {\n\t    var prototype = (0, _getPrototypeOf2.default)(Derived);\n\t    var is = false;\n\t    while (!(is || prototype === null)) {\n\t      is = prototype === Parent;\n\t      prototype = (0, _getPrototypeOf2.default)(prototype);\n\t    }\n\t    return is;\n\t  };\n\t\n\t  /**\n\t   * Get random id\n\t   * @return {string}\n\t   */\n\t  var uuid = exports.uuid = function uuid() {\n\t    var entropy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 7;\n\t    var dictionary = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DICTIONARY;\n\t    return (0, _from2.default)(Array(entropy)).reduce(function (previous) {\n\t      var next = dictionary.charAt(Math.floor(Math.random() * dictionary.length));\n\t      return '' + previous + next;\n\t    }, '');\n\t  };\n\t});\n\n/***/ },\n/* 131 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(132), __esModule: true };\n\n/***/ },\n/* 132 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(34);\n\t__webpack_require__(133);\n\tmodule.exports = __webpack_require__(17).Array.from;\n\n/***/ },\n/* 133 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar ctx            = __webpack_require__(18)\n\t  , $export        = __webpack_require__(16)\n\t  , toObject       = __webpack_require__(7)\n\t  , call           = __webpack_require__(119)\n\t  , isArrayIter    = __webpack_require__(120)\n\t  , toLength       = __webpack_require__(50)\n\t  , createProperty = __webpack_require__(134)\n\t  , getIterFn      = __webpack_require__(121);\n\t\n\t$export($export.S + $export.F * !__webpack_require__(128)(function(iter){ Array.from(iter); }), 'Array', {\n\t  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n\t  from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){\n\t    var O       = toObject(arrayLike)\n\t      , C       = typeof this == 'function' ? this : Array\n\t      , aLen    = arguments.length\n\t      , mapfn   = aLen > 1 ? arguments[1] : undefined\n\t      , mapping = mapfn !== undefined\n\t      , index   = 0\n\t      , iterFn  = getIterFn(O)\n\t      , length, result, step, iterator;\n\t    if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n\t    // if object isn't iterable or it's array with default iterator - use simple case\n\t    if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){\n\t      for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){\n\t        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n\t      }\n\t    } else {\n\t      length = toLength(O.length);\n\t      for(result = new C(length); length > index; index++){\n\t        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n\t      }\n\t    }\n\t    result.length = index;\n\t    return result;\n\t  }\n\t});\n\n\n/***/ },\n/* 134 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\tvar $defineProperty = __webpack_require__(21)\n\t  , createDesc      = __webpack_require__(29);\n\t\n\tmodule.exports = function(object, index, value){\n\t  if(index in object)$defineProperty.f(object, index, createDesc(0, value));\n\t  else object[index] = value;\n\t};\n\n/***/ },\n/* 135 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(136), __esModule: true };\n\n/***/ },\n/* 136 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(137);\n\tmodule.exports = __webpack_require__(17).Object.values;\n\n/***/ },\n/* 137 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// https://github.com/tc39/proposal-object-values-entries\n\tvar $export = __webpack_require__(16)\n\t  , $values = __webpack_require__(138)(false);\n\t\n\t$export($export.S, 'Object', {\n\t  values: function values(it){\n\t    return $values(it);\n\t  }\n\t});\n\n/***/ },\n/* 138 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar getKeys   = __webpack_require__(44)\n\t  , toIObject = __webpack_require__(46)\n\t  , isEnum    = __webpack_require__(69).f;\n\tmodule.exports = function(isEntries){\n\t  return function(it){\n\t    var O      = toIObject(it)\n\t      , keys   = getKeys(O)\n\t      , length = keys.length\n\t      , i      = 0\n\t      , result = []\n\t      , key;\n\t    while(length > i)if(isEnum.call(O, key = keys[i++])){\n\t      result.push(isEntries ? [key, O[key]] : O[key]);\n\t    } return result;\n\t  };\n\t};\n\n/***/ },\n/* 139 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(4), __webpack_require__(85), __webpack_require__(86), __webpack_require__(30), __webpack_require__(77), __webpack_require__(140), __webpack_require__(107), __webpack_require__(3), __webpack_require__(144)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('babel-runtime/core-js/object/get-prototype-of'), require('babel-runtime/helpers/classCallCheck'), require('babel-runtime/helpers/createClass'), require('babel-runtime/helpers/possibleConstructorReturn'), require('babel-runtime/helpers/inherits'), require('babel-runtime/helpers/get'), require('./basic'), require('../authentication/handshake'), require('../utils/session-persistence'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.getPrototypeOf, global.classCallCheck, global.createClass, global.possibleConstructorReturn, global.inherits, global.get, global.basic, global.handshake, global.sessionPersistence);\n\t    global.smart = mod.exports;\n\t  }\n\t})(this, function (exports, _getPrototypeOf, _classCallCheck2, _createClass2, _possibleConstructorReturn2, _inherits2, _get2, _basic, _handshake, _sessionPersistence) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.SmartClient = undefined;\n\t\n\t  var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);\n\t\n\t  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t  var _createClass3 = _interopRequireDefault(_createClass2);\n\t\n\t  var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);\n\t\n\t  var _inherits3 = _interopRequireDefault(_inherits2);\n\t\n\t  var _get3 = _interopRequireDefault(_get2);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  var SmartClient = exports.SmartClient = function (_Client) {\n\t    (0, _inherits3.default)(SmartClient, _Client);\n\t\n\t    /**\n\t     * Create a new ZetaPush SmartClient\n\t     * @param {SmartClientConfig} config\n\t     */\n\t    function SmartClient(_ref) {\n\t      var apiUrl = _ref.apiUrl,\n\t          sandboxId = _ref.sandboxId,\n\t          forceHttps = _ref.forceHttps,\n\t          resource = _ref.resource,\n\t          transports = _ref.transports;\n\t      (0, _classCallCheck3.default)(this, SmartClient);\n\t\n\t      var persistence = new _sessionPersistence.SessionPersistenceStrategy({ sandboxId: sandboxId });\n\t\n\t      /**\n\t       * @return {AbstractHandshakeManager}\n\t       */\n\t      var authentication = function authentication() {\n\t        var session = persistence.get();\n\t        var token = session.token;\n\t\n\t\n\t        if (_this.hasCredentials()) {\n\t          var _this$getCredentials = _this.getCredentials(),\n\t              login = _this$getCredentials.login,\n\t              password = _this$getCredentials.password;\n\t\n\t          _this.setCredentials({});\n\t          return _handshake.Authentication.simple({\n\t            login: login,\n\t            password: password\n\t          });\n\t        } else {\n\t          if (_this.isStronglyAuthenticated(session)) {\n\t            return _handshake.Authentication.simple({\n\t              login: token,\n\t              password: null\n\t            });\n\t          } else {\n\t            return _handshake.Authentication.weak({\n\t              token: token\n\t            });\n\t          }\n\t        }\n\t      };\n\t      // Initialize base client\n\t\n\t      /**\n\t       * @access protected\n\t       * @type {SessionPersistenceStrategy}\n\t       */\n\t      var _this = (0, _possibleConstructorReturn3.default)(this, (SmartClient.__proto__ || (0, _getPrototypeOf2.default)(SmartClient)).call(this, {\n\t        apiUrl: apiUrl, sandboxId: sandboxId, authentication: authentication, forceHttps: forceHttps, resource: resource, transports: transports\n\t      }));\n\t\n\t      _this.persistence = persistence;\n\t      /**\n\t       * @access protected\n\t       * @type {Object}\n\t       */\n\t      _this.credentials = {};\n\t      /**\n\t       * Handle connection lifecycle events\n\t       * @access protected\n\t       * @type {Object}\n\t       */\n\t      _this.lifeCycleConnectionHandler = _this.addConnectionStatusListener({\n\t        onConnectionClosed: function onConnectionClosed() {\n\t          persistence.set({});\n\t        },\n\t        onSuccessfulHandshake: function onSuccessfulHandshake(session) {\n\t          if (session.token) {\n\t            persistence.set(session);\n\t          }\n\t        }\n\t      });\n\t      // Properly disconnect client to avoir ghost connections\n\t      window.addEventListener('beforeunload', function () {\n\t        _this.removeConnectionStatusListener(_this.lifeCycleConnectionHandler);\n\t        (0, _get3.default)(SmartClient.prototype.__proto__ || (0, _getPrototypeOf2.default)(SmartClient.prototype), 'disconnect', _this).call(_this);\n\t      });\n\t      return _this;\n\t    }\n\t    /**\n\t     * Disconnect client from ZetaPush backend\n\t     */\n\t\n\t\n\t    (0, _createClass3.default)(SmartClient, [{\n\t      key: 'disconnect',\n\t      value: function disconnect() {\n\t        (0, _get3.default)(SmartClient.prototype.__proto__ || (0, _getPrototypeOf2.default)(SmartClient.prototype), 'disconnect', this).call(this);\n\t      }\n\t      /**\n\t       * @return {Object}\n\t       */\n\t\n\t    }, {\n\t      key: 'getCredentials',\n\t      value: function getCredentials() {\n\t        return this.credentials;\n\t      }\n\t      /**\n\t       * @return {Object}\n\t       */\n\t\n\t    }, {\n\t      key: 'getSession',\n\t      value: function getSession() {\n\t        return this.persistence.get();\n\t      }\n\t      /**\n\t       * @return {boolean}\n\t       */\n\t\n\t    }, {\n\t      key: 'hasCredentials',\n\t      value: function hasCredentials() {\n\t        var _getCredentials = this.getCredentials(),\n\t            login = _getCredentials.login,\n\t            password = _getCredentials.password;\n\t\n\t        return login && password;\n\t      }\n\t      /**\n\t       * @return {boolean}\n\t       */\n\t\n\t    }, {\n\t      key: 'isStronglyAuthenticated',\n\t      value: function isStronglyAuthenticated() {\n\t        var session = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.persistence.get();\n\t\n\t        return !this.isWeaklyAuthenticated(session) && typeof session.token === 'string';\n\t      }\n\t      /**\n\t       * @return {boolean}\n\t       */\n\t\n\t    }, {\n\t      key: 'isWeaklyAuthenticated',\n\t      value: function isWeaklyAuthenticated() {\n\t        var session = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.persistence.get();\n\t\n\t        return typeof session.publicToken === 'string';\n\t      }\n\t      /**\n\t       * @param {{login: string, password: string}} parameters\n\t       */\n\t\n\t    }, {\n\t      key: 'setCredentials',\n\t      value: function setCredentials(_ref2) {\n\t        var login = _ref2.login,\n\t            password = _ref2.password;\n\t\n\t        this.credentials = { login: login, password: password };\n\t      }\n\t    }]);\n\t    return SmartClient;\n\t  }(_basic.Client);\n\t});\n\n/***/ },\n/* 140 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t\"use strict\";\n\t\n\texports.__esModule = true;\n\t\n\tvar _getPrototypeOf = __webpack_require__(4);\n\t\n\tvar _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);\n\t\n\tvar _getOwnPropertyDescriptor = __webpack_require__(141);\n\t\n\tvar _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\texports.default = function get(object, property, receiver) {\n\t  if (object === null) object = Function.prototype;\n\t  var desc = (0, _getOwnPropertyDescriptor2.default)(object, property);\n\t\n\t  if (desc === undefined) {\n\t    var parent = (0, _getPrototypeOf2.default)(object);\n\t\n\t    if (parent === null) {\n\t      return undefined;\n\t    } else {\n\t      return get(parent, property, receiver);\n\t    }\n\t  } else if (\"value\" in desc) {\n\t    return desc.value;\n\t  } else {\n\t    var getter = desc.get;\n\t\n\t    if (getter === undefined) {\n\t      return undefined;\n\t    }\n\t\n\t    return getter.call(receiver);\n\t  }\n\t};\n\n/***/ },\n/* 141 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(142), __esModule: true };\n\n/***/ },\n/* 142 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(143);\n\tvar $Object = __webpack_require__(17).Object;\n\tmodule.exports = function getOwnPropertyDescriptor(it, key){\n\t  return $Object.getOwnPropertyDescriptor(it, key);\n\t};\n\n/***/ },\n/* 143 */\n/***/ function(module, exports, __webpack_require__) {\n\n\t// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n\tvar toIObject                 = __webpack_require__(46)\n\t  , $getOwnPropertyDescriptor = __webpack_require__(73).f;\n\t\n\t__webpack_require__(15)('getOwnPropertyDescriptor', function(){\n\t  return function getOwnPropertyDescriptor(it, key){\n\t    return $getOwnPropertyDescriptor(toIObject(it), key);\n\t  };\n\t});\n\n/***/ },\n/* 144 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(145), __webpack_require__(85), __webpack_require__(86)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('babel-runtime/core-js/json/stringify'), require('babel-runtime/helpers/classCallCheck'), require('babel-runtime/helpers/createClass'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.stringify, global.classCallCheck, global.createClass);\n\t    global.sessionPersistence = mod.exports;\n\t  }\n\t})(this, function (exports, _stringify, _classCallCheck2, _createClass2) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.SessionPersistenceStrategy = exports.ZETAPUSH_SESSION_KEY = undefined;\n\t\n\t  var _stringify2 = _interopRequireDefault(_stringify);\n\t\n\t  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t  var _createClass3 = _interopRequireDefault(_createClass2);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  /**\n\t   * @type {string}\n\t   */\n\t  var ZETAPUSH_SESSION_KEY = exports.ZETAPUSH_SESSION_KEY = 'zetapush.token';\n\t\n\t  /**\n\t   * Provide abstraction for token persistence\n\t   * @access protected\n\t   */\n\t\n\t  var SessionPersistenceStrategy = exports.SessionPersistenceStrategy = function () {\n\t    /**\n\t     * @param {{sandboxId: string, storage: DOMStorage}} parameters\n\t     */\n\t    function SessionPersistenceStrategy() {\n\t      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n\t          sandboxId = _ref.sandboxId,\n\t          _ref$storage = _ref.storage,\n\t          storage = _ref$storage === undefined ? window.localStorage : _ref$storage;\n\t\n\t      (0, _classCallCheck3.default)(this, SessionPersistenceStrategy);\n\t\n\t      /**\n\t       * @access private\n\t       * @type {string}\n\t       */\n\t      this.key = ZETAPUSH_SESSION_KEY + '.' + sandboxId;\n\t      /**\n\t       * @access private\n\t       * @type {DOMStorage}\n\t       */\n\t      this.storage = storage;\n\t    }\n\t    /**\n\t     * @return {string} session The stored session\n\t     */\n\t\n\t\n\t    (0, _createClass3.default)(SessionPersistenceStrategy, [{\n\t      key: 'get',\n\t      value: function get() {\n\t        var key = this.key,\n\t            storage = this.storage;\n\t\n\t        var json = storage.getItem(key) || '{}';\n\t        var session = JSON.parse(json);\n\t        return session;\n\t      }\n\t      /**\n\t       * @param {Object} session The session to store\n\t       */\n\t\n\t    }, {\n\t      key: 'set',\n\t      value: function set() {\n\t        var session = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\t        var key = this.key,\n\t            storage = this.storage;\n\t\n\t        var json = (0, _stringify2.default)(session);\n\t        return storage.setItem(key, json);\n\t      }\n\t    }]);\n\t    return SessionPersistenceStrategy;\n\t  }();\n\t});\n\n/***/ },\n/* 145 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tmodule.exports = { \"default\": __webpack_require__(146), __esModule: true };\n\n/***/ },\n/* 146 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar core  = __webpack_require__(17)\n\t  , $JSON = core.JSON || (core.JSON = {stringify: JSON.stringify});\n\tmodule.exports = function stringify(it){ // eslint-disable-line no-unused-vars\n\t  return $JSON.stringify.apply($JSON, arguments);\n\t};\n\n/***/ },\n/* 147 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(4), __webpack_require__(85), __webpack_require__(86), __webpack_require__(30), __webpack_require__(77), __webpack_require__(107), __webpack_require__(3), __webpack_require__(144)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('babel-runtime/core-js/object/get-prototype-of'), require('babel-runtime/helpers/classCallCheck'), require('babel-runtime/helpers/createClass'), require('babel-runtime/helpers/possibleConstructorReturn'), require('babel-runtime/helpers/inherits'), require('./basic'), require('../authentication/handshake'), require('../utils/session-persistence'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.getPrototypeOf, global.classCallCheck, global.createClass, global.possibleConstructorReturn, global.inherits, global.basic, global.handshake, global.sessionPersistence);\n\t    global.weak = mod.exports;\n\t  }\n\t})(this, function (exports, _getPrototypeOf, _classCallCheck2, _createClass2, _possibleConstructorReturn2, _inherits2, _basic, _handshake, _sessionPersistence) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.WeakClient = undefined;\n\t\n\t  var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);\n\t\n\t  var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);\n\t\n\t  var _createClass3 = _interopRequireDefault(_createClass2);\n\t\n\t  var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);\n\t\n\t  var _inherits3 = _interopRequireDefault(_inherits2);\n\t\n\t  function _interopRequireDefault(obj) {\n\t    return obj && obj.__esModule ? obj : {\n\t      default: obj\n\t    };\n\t  }\n\t\n\t  var WeakClient = exports.WeakClient = function (_Client) {\n\t    (0, _inherits3.default)(WeakClient, _Client);\n\t\n\t    /**\n\t     * Create a new ZetaPush WeakClient\n\t     * @param {WeakClientConfig} config\n\t     */\n\t    function WeakClient(_ref) {\n\t      var apiUrl = _ref.apiUrl,\n\t          sandboxId = _ref.sandboxId,\n\t          deploymentId = _ref.deploymentId,\n\t          forceHttps = _ref.forceHttps,\n\t          resource = _ref.resource,\n\t          transports = _ref.transports;\n\t      (0, _classCallCheck3.default)(this, WeakClient);\n\t\n\t      var authentication = function authentication() {\n\t        var token = _this.getToken();\n\t        var handshake = _handshake.Authentication.weak({\n\t          deploymentId: deploymentId,\n\t          token: token\n\t        });\n\t        return handshake;\n\t      };\n\t      /**\n\t       * Call Client constructor with specific parameters\n\t       */\n\t\n\t      // Handle successful handshake\n\t      var _this = (0, _possibleConstructorReturn3.default)(this, (WeakClient.__proto__ || (0, _getPrototypeOf2.default)(WeakClient)).call(this, { apiUrl: apiUrl, sandboxId: sandboxId, forceHttps: forceHttps, authentication: authentication, resource: resource, transports: transports }));\n\t\n\t      var onSuccessfulHandshake = function onSuccessfulHandshake(_ref2) {\n\t        var publicToken = _ref2.publicToken,\n\t            userId = _ref2.userId,\n\t            token = _ref2.token;\n\t\n\t        if (token) {\n\t          _this.strategy.set({ publicToken: publicToken, userId: userId, token: token });\n\t        }\n\t      };\n\t      _this.addConnectionStatusListener({ onSuccessfulHandshake: onSuccessfulHandshake });\n\t      /**\n\t       * @access private\n\t       * @type {SessionPersistenceStrategy}\n\t       */\n\t      _this.strategy = new _sessionPersistence.SessionPersistenceStrategy();\n\t      return _this;\n\t    }\n\t    /**\n\t     * @return {string} The stored token\n\t     */\n\t\n\t\n\t    (0, _createClass3.default)(WeakClient, [{\n\t      key: 'getToken',\n\t      value: function getToken() {\n\t        var _strategy$get = this.strategy.get(),\n\t            token = _strategy$get.token;\n\t\n\t        return token;\n\t      }\n\t    }]);\n\t    return WeakClient;\n\t  }(_basic.Client);\n\t});\n\n/***/ },\n/* 148 */\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (global, factory) {\n\t  if (true) {\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(90), __webpack_require__(129)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t  } else if (typeof exports !== \"undefined\") {\n\t    factory(exports, require('./authentications'), require('./services'));\n\t  } else {\n\t    var mod = {\n\t      exports: {}\n\t    };\n\t    factory(mod.exports, global.authentications, global.services);\n\t    global.index = mod.exports;\n\t  }\n\t})(this, function (exports, _authentications, _services) {\n\t  'use strict';\n\t\n\t  Object.defineProperty(exports, \"__esModule\", {\n\t    value: true\n\t  });\n\t  exports.services = exports.authentications = undefined;\n\t\n\t  var authentications = _interopRequireWildcard(_authentications);\n\t\n\t  var services = _interopRequireWildcard(_services);\n\t\n\t  function _interopRequireWildcard(obj) {\n\t    if (obj && obj.__esModule) {\n\t      return obj;\n\t    } else {\n\t      var newObj = {};\n\t\n\t      if (obj != null) {\n\t        for (var key in obj) {\n\t          if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];\n\t        }\n\t      }\n\t\n\t      newObj.default = obj;\n\t      return newObj;\n\t    }\n\t  }\n\t\n\t  exports.authentications = authentications;\n\t  exports.services = services;\n\t});\n\n/***/ }\n/******/ ])\n});\n;\n\n\n// WEBPACK FOOTER //\n// zetapush.min.js"," \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\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\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.loaded = 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// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 4e1c3ddbe1098a00e90a","(function(self) {\n  'use strict';\n\n  if (self.fetch) {\n    return\n  }\n\n  var support = {\n    searchParams: 'URLSearchParams' in self,\n    iterable: 'Symbol' in self && 'iterator' in Symbol,\n    blob: 'FileReader' in self && 'Blob' in self && (function() {\n      try {\n        new Blob()\n        return true\n      } catch(e) {\n        return false\n      }\n    })(),\n    formData: 'FormData' in self,\n    arrayBuffer: 'ArrayBuffer' in self\n  }\n\n  function normalizeName(name) {\n    if (typeof name !== 'string') {\n      name = String(name)\n    }\n    if (/[^a-z0-9\\-#$%&'*+.\\^_`|~]/i.test(name)) {\n      throw new TypeError('Invalid character in header field name')\n    }\n    return name.toLowerCase()\n  }\n\n  function normalizeValue(value) {\n    if (typeof value !== 'string') {\n      value = String(value)\n    }\n    return value\n  }\n\n  // Build a destructive iterator for the value list\n  function iteratorFor(items) {\n    var iterator = {\n      next: function() {\n        var value = items.shift()\n        return {done: value === undefined, value: value}\n      }\n    }\n\n    if (support.iterable) {\n      iterator[Symbol.iterator] = function() {\n        return iterator\n      }\n    }\n\n    return iterator\n  }\n\n  function Headers(headers) {\n    this.map = {}\n\n    if (headers instanceof Headers) {\n      headers.forEach(function(value, name) {\n        this.append(name, value)\n      }, this)\n\n    } else if (headers) {\n      Object.getOwnPropertyNames(headers).forEach(function(name) {\n        this.append(name, headers[name])\n      }, this)\n    }\n  }\n\n  Headers.prototype.append = function(name, value) {\n    name = normalizeName(name)\n    value = normalizeValue(value)\n    var list = this.map[name]\n    if (!list) {\n      list = []\n      this.map[name] = list\n    }\n    list.push(value)\n  }\n\n  Headers.prototype['delete'] = function(name) {\n    delete this.map[normalizeName(name)]\n  }\n\n  Headers.prototype.get = function(name) {\n    var values = this.map[normalizeName(name)]\n    return values ? values[0] : null\n  }\n\n  Headers.prototype.getAll = function(name) {\n    return this.map[normalizeName(name)] || []\n  }\n\n  Headers.prototype.has = function(name) {\n    return this.map.hasOwnProperty(normalizeName(name))\n  }\n\n  Headers.prototype.set = function(name, value) {\n    this.map[normalizeName(name)] = [normalizeValue(value)]\n  }\n\n  Headers.prototype.forEach = function(callback, thisArg) {\n    Object.getOwnPropertyNames(this.map).forEach(function(name) {\n      this.map[name].forEach(function(value) {\n        callback.call(thisArg, value, name, this)\n      }, this)\n    }, this)\n  }\n\n  Headers.prototype.keys = function() {\n    var items = []\n    this.forEach(function(value, name) { items.push(name) })\n    return iteratorFor(items)\n  }\n\n  Headers.prototype.values = function() {\n    var items = []\n    this.forEach(function(value) { items.push(value) })\n    return iteratorFor(items)\n  }\n\n  Headers.prototype.entries = function() {\n    var items = []\n    this.forEach(function(value, name) { items.push([name, value]) })\n    return iteratorFor(items)\n  }\n\n  if (support.iterable) {\n    Headers.prototype[Symbol.iterator] = Headers.prototype.entries\n  }\n\n  function consumed(body) {\n    if (body.bodyUsed) {\n      return Promise.reject(new TypeError('Already read'))\n    }\n    body.bodyUsed = true\n  }\n\n  function fileReaderReady(reader) {\n    return new Promise(function(resolve, reject) {\n      reader.onload = function() {\n        resolve(reader.result)\n      }\n      reader.onerror = function() {\n        reject(reader.error)\n      }\n    })\n  }\n\n  function readBlobAsArrayBuffer(blob) {\n    var reader = new FileReader()\n    reader.readAsArrayBuffer(blob)\n    return fileReaderReady(reader)\n  }\n\n  function readBlobAsText(blob) {\n    var reader = new FileReader()\n    reader.readAsText(blob)\n    return fileReaderReady(reader)\n  }\n\n  function Body() {\n    this.bodyUsed = false\n\n    this._initBody = function(body) {\n      this._bodyInit = body\n      if (typeof body === 'string') {\n        this._bodyText = body\n      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n        this._bodyBlob = body\n      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n        this._bodyFormData = body\n      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n        this._bodyText = body.toString()\n      } else if (!body) {\n        this._bodyText = ''\n      } else if (support.arrayBuffer && ArrayBuffer.prototype.isPrototypeOf(body)) {\n        // Only support ArrayBuffers for POST method.\n        // Receiving ArrayBuffers happens via Blobs, instead.\n      } else {\n        throw new Error('unsupported BodyInit type')\n      }\n\n      if (!this.headers.get('content-type')) {\n        if (typeof body === 'string') {\n          this.headers.set('content-type', 'text/plain;charset=UTF-8')\n        } else if (this._bodyBlob && this._bodyBlob.type) {\n          this.headers.set('content-type', this._bodyBlob.type)\n        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')\n        }\n      }\n    }\n\n    if (support.blob) {\n      this.blob = function() {\n        var rejected = consumed(this)\n        if (rejected) {\n          return rejected\n        }\n\n        if (this._bodyBlob) {\n          return Promise.resolve(this._bodyBlob)\n        } else if (this._bodyFormData) {\n          throw new Error('could not read FormData body as blob')\n        } else {\n          return Promise.resolve(new Blob([this._bodyText]))\n        }\n      }\n\n      this.arrayBuffer = function() {\n        return this.blob().then(readBlobAsArrayBuffer)\n      }\n\n      this.text = function() {\n        var rejected = consumed(this)\n        if (rejected) {\n          return rejected\n        }\n\n        if (this._bodyBlob) {\n          return readBlobAsText(this._bodyBlob)\n        } else if (this._bodyFormData) {\n          throw new Error('could not read FormData body as text')\n        } else {\n          return Promise.resolve(this._bodyText)\n        }\n      }\n    } else {\n      this.text = function() {\n        var rejected = consumed(this)\n        return rejected ? rejected : Promise.resolve(this._bodyText)\n      }\n    }\n\n    if (support.formData) {\n      this.formData = function() {\n        return this.text().then(decode)\n      }\n    }\n\n    this.json = function() {\n      return this.text().then(JSON.parse)\n    }\n\n    return this\n  }\n\n  // HTTP methods whose capitalization should be normalized\n  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']\n\n  function normalizeMethod(method) {\n    var upcased = method.toUpperCase()\n    return (methods.indexOf(upcased) > -1) ? upcased : method\n  }\n\n  function Request(input, options) {\n    options = options || {}\n    var body = options.body\n    if (Request.prototype.isPrototypeOf(input)) {\n      if (input.bodyUsed) {\n        throw new TypeError('Already read')\n      }\n      this.url = input.url\n      this.credentials = input.credentials\n      if (!options.headers) {\n        this.headers = new Headers(input.headers)\n      }\n      this.method = input.method\n      this.mode = input.mode\n      if (!body) {\n        body = input._bodyInit\n        input.bodyUsed = true\n      }\n    } else {\n      this.url = input\n    }\n\n    this.credentials = options.credentials || this.credentials || 'omit'\n    if (options.headers || !this.headers) {\n      this.headers = new Headers(options.headers)\n    }\n    this.method = normalizeMethod(options.method || this.method || 'GET')\n    this.mode = options.mode || this.mode || null\n    this.referrer = null\n\n    if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n      throw new TypeError('Body not allowed for GET or HEAD requests')\n    }\n    this._initBody(body)\n  }\n\n  Request.prototype.clone = function() {\n    return new Request(this)\n  }\n\n  function decode(body) {\n    var form = new FormData()\n    body.trim().split('&').forEach(function(bytes) {\n      if (bytes) {\n        var split = bytes.split('=')\n        var name = split.shift().replace(/\\+/g, ' ')\n        var value = split.join('=').replace(/\\+/g, ' ')\n        form.append(decodeURIComponent(name), decodeURIComponent(value))\n      }\n    })\n    return form\n  }\n\n  function headers(xhr) {\n    var head = new Headers()\n    var pairs = (xhr.getAllResponseHeaders() || '').trim().split('\\n')\n    pairs.forEach(function(header) {\n      var split = header.trim().split(':')\n      var key = split.shift().trim()\n      var value = split.join(':').trim()\n      head.append(key, value)\n    })\n    return head\n  }\n\n  Body.call(Request.prototype)\n\n  function Response(bodyInit, options) {\n    if (!options) {\n      options = {}\n    }\n\n    this.type = 'default'\n    this.status = options.status\n    this.ok = this.status >= 200 && this.status < 300\n    this.statusText = options.statusText\n    this.headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers)\n    this.url = options.url || ''\n    this._initBody(bodyInit)\n  }\n\n  Body.call(Response.prototype)\n\n  Response.prototype.clone = function() {\n    return new Response(this._bodyInit, {\n      status: this.status,\n      statusText: this.statusText,\n      headers: new Headers(this.headers),\n      url: this.url\n    })\n  }\n\n  Response.error = function() {\n    var response = new Response(null, {status: 0, statusText: ''})\n    response.type = 'error'\n    return response\n  }\n\n  var redirectStatuses = [301, 302, 303, 307, 308]\n\n  Response.redirect = function(url, status) {\n    if (redirectStatuses.indexOf(status) === -1) {\n      throw new RangeError('Invalid status code')\n    }\n\n    return new Response(null, {status: status, headers: {location: url}})\n  }\n\n  self.Headers = Headers\n  self.Request = Request\n  self.Response = Response\n\n  self.fetch = function(input, init) {\n    return new Promise(function(resolve, reject) {\n      var request\n      if (Request.prototype.isPrototypeOf(input) && !init) {\n        request = input\n      } else {\n        request = new Request(input, init)\n      }\n\n      var xhr = new XMLHttpRequest()\n\n      function responseURL() {\n        if ('responseURL' in xhr) {\n          return xhr.responseURL\n        }\n\n        // Avoid security warnings on getResponseHeader when not allowed by CORS\n        if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {\n          return xhr.getResponseHeader('X-Request-URL')\n        }\n\n        return\n      }\n\n      xhr.onload = function() {\n        var options = {\n          status: xhr.status,\n          statusText: xhr.statusText,\n          headers: headers(xhr),\n          url: responseURL()\n        }\n        var body = 'response' in xhr ? xhr.response : xhr.responseText\n        resolve(new Response(body, options))\n      }\n\n      xhr.onerror = function() {\n        reject(new TypeError('Network request failed'))\n      }\n\n      xhr.ontimeout = function() {\n        reject(new TypeError('Network request failed'))\n      }\n\n      xhr.open(request.method, request.url, true)\n\n      if (request.credentials === 'include') {\n        xhr.withCredentials = true\n      }\n\n      if ('responseType' in xhr && support.blob) {\n        xhr.responseType = 'blob'\n      }\n\n      request.headers.forEach(function(value, name) {\n        xhr.setRequestHeader(name, value)\n      })\n\n      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)\n    })\n  }\n  self.fetch.polyfill = true\n})(typeof self !== 'undefined' ? self : this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/whatwg-fetch/fetch.js\n// module id = 1\n// module chunks = 0","export { Authentication } from './authentication/handshake'\nexport { ConnectionStatusListener } from './connection/connection-status'\nexport { TransportTypes } from './connection/cometd'\n\nexport { Client } from './client/basic'\nexport { SmartClient } from './client/smart'\nexport { WeakClient } from './client/weak'\n\nexport { services } from './mapping'\n\n/**\n * SDK Version\n * @type {string}\n */\nexport const VERSION = '3.1.0-alpha.2'\n\n\n\n// WEBPACK FOOTER //\n// ./lib/index.js","import { Delegating, Simple, Weak } from '../mapping/authentications'\n\n/**\n * ZetaPush deployables names\n */\nconst DeployableNames = {\n  AUTH_SIMPLE: 'simple',\n  AUTH_WEAK: 'weak',\n  AUTH_DELEGATING: 'delegating'\n}\n\n/**\n * Provide abstraction over CometD handshake data structure\n * @access protected\n */\nclass AbstractHandshake {\n  /**\n   * Create a new handshake manager\n   * @param {{authType: string, sandboxId: string, deploymentId: string}} parameters\n   */\n  constructor({ authType, sandboxId, deploymentId }) {\n    /**\n     * @access protected\n     * @type {string}\n     */\n    this.authType = authType\n    /**\n     * @access protected\n     * @type {string}\n     */\n    this.sandboxId = sandboxId\n    /**\n     * @access protected\n     * @type {string}\n     */\n    this.deploymentId = deploymentId\n  }\n  /**\n   * @param {ClientHelper} client\n   * @return {Object}\n   */\n  getHandshakeFields(client) {\n    const authentication = {\n      data: this.authData,\n      type: `${client.getSandboxId()}.${this.deploymentId}.${this.authType}`,\n      version: this.authVersion\n    }\n    if (client.getResource()) {\n      authentication.resource = client.getResource()\n    }\n    return {\n      ext: {\n        authentication\n      }\n    }\n  }\n  /**\n   * Get auth version\n   * @return {string}\n   */\n  get authVersion() {\n    return 'none'\n  }\n\n}\n\n/**\n * Provide abstraction over CometD token base handshake data structure\n * @access protected\n * @extends {AbstractHandshake}\n */\nclass TokenHandshake extends AbstractHandshake {\n  /**\n   * @param {{authType: string, deploymentId: string, token: string}} parameters\n   */\n  constructor({ authType, deploymentId, token }) {\n    super({ deploymentId, authType })\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.token = token\n  }\n  /**\n   * @return {token: string}\n   */\n  get authData() {\n    const { token } = this\n    return {\n      token\n    }\n  }\n\n}\n\n/**\n * Provide abstraction over CometD credentials based handshake data structure\n * @access protected\n * @extends {AbstractHandshake}\n */\nclass CredentialsHandshake extends AbstractHandshake {\n\n  /**\n   * @param {{authType: string, deploymentId: string, login: string, password: string}} parameters\n   */\n  constructor({ authType, deploymentId, login, password }) {\n    super({ authType, deploymentId })\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.login = login\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.password = password\n  }\n  /**\n   * Get auth data\n   * @return {login: string, password: string}\n   */\n  get authData() {\n    const { login, password } = this\n    return {\n      login, password\n    }\n  }\n\n}\n\n/**\n * Factory to create handshake\n * @access public\n */\nexport class Authentication {\n  /**\n   * @param {{deploymentId: string, login: string, password: string}} parameters\n   * @return {CredentialsHandshake}\n   * @example\n   * // Explicit deploymentId\n   * // Authentication provide optional deployment id, according to the following convention `${ServiceType.toLowerCase()_0}`\n   * Authentication.delegating({\n   *   deploymentId: '<YOUR-SIMPLE-AUTHENTICATION-DEPLOYMENT-ID>',\n   *   login: <USER-LOGIN>,\n   *   password: '<USER-PASSWORD>'\n   * })\n   */\n  static simple({ deploymentId = Simple.DEFAULT_DEPLOYMENT_ID, login, password }) {\n    return Authentication.create({\n      authType: DeployableNames.AUTH_SIMPLE,\n      deploymentId,\n      login,\n      password\n    })\n  }\n  /**\n   * @param {{deploymentId: string, token: string}} parameters\n   * @return {TokenHandshake}\n   * @example\n   * // Explicit deploymentId\n   * // Authentication provide optional deployment id, according to the following convention `${ServiceType.toLowerCase()_0}`\n   * Authentication.delegating({\n   *   deploymentId: '<YOUR-WEAK-AUTHENTICATION-DEPLOYMENT-ID>',\n   *   token: null\n   * })\n   */\n  static weak({ deploymentId = Weak.DEFAULT_DEPLOYMENT_ID, token }) {\n    return Authentication.create({\n      authType: DeployableNames.AUTH_WEAK,\n      deploymentId,\n      login: token,\n      password: null\n    })\n  }\n  /**\n   * @param {{deploymentId: string, token: string}} parameters\n   * @return {TokenHandshake}\n   * @example\n   * // Explicit deploymentId\n   * // Authentication provide optional deployment id, according to the following convention `${ServiceType.toLowerCase()_0}`\n   * Authentication.delegating({\n   *   deploymentId: '<YOUR-DELEGATING-AUTHENTICATION-DEPLOYMENT-ID>',\n   *   token: null\n   * })\n   */\n  static delegating({ deploymentId = Delegating.DEFAULT_DEPLOYMENT_ID, token }) {\n    return Authentication.create({\n      authType: DeployableNames.AUTH_DELEGATING,\n      deploymentId,\n      login: token,\n      password: null\n    })\n  }\n  /**\n   * @param {{authType: string, deploymentId: string, login: string, password: string}} parameters\n   * @return {TokenHandshake|CredentialsHandshake}\n   */\n  static create({ authType, deploymentId, login, password }) {\n    if (password === null) {\n      return new TokenHandshake({ authType, deploymentId, token: login })\n    }\n    return new CredentialsHandshake({ authType, deploymentId, login, password })\n  }\n\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/authentication/handshake.js","module.exports = { \"default\": require(\"core-js/library/fn/object/get-prototype-of\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/get-prototype-of.js\n// module id = 4\n// module chunks = 0","require('../../modules/es6.object.get-prototype-of');\nmodule.exports = require('../../modules/_core').Object.getPrototypeOf;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/get-prototype-of.js\n// module id = 5\n// module chunks = 0","// 19.1.2.9 Object.getPrototypeOf(O)\nvar toObject        = require('./_to-object')\n  , $getPrototypeOf = require('./_object-gpo');\n\nrequire('./_object-sap')('getPrototypeOf', function(){\n  return function getPrototypeOf(it){\n    return $getPrototypeOf(toObject(it));\n  };\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.object.get-prototype-of.js\n// module id = 6\n// module chunks = 0","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function(it){\n  return Object(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-object.js\n// module id = 7\n// module chunks = 0","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_defined.js\n// module id = 8\n// module chunks = 0","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has         = require('./_has')\n  , toObject    = require('./_to-object')\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\n  , ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function(O){\n  O = toObject(O);\n  if(has(O, IE_PROTO))return O[IE_PROTO];\n  if(typeof O.constructor == 'function' && O instanceof O.constructor){\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectProto : null;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gpo.js\n// module id = 9\n// module chunks = 0","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n  return hasOwnProperty.call(it, key);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_has.js\n// module id = 10\n// module chunks = 0","var shared = require('./_shared')('keys')\n  , uid    = require('./_uid');\nmodule.exports = function(key){\n  return shared[key] || (shared[key] = uid(key));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_shared-key.js\n// module id = 11\n// module chunks = 0","var global = require('./_global')\n  , SHARED = '__core-js_shared__'\n  , store  = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n  return store[key] || (store[key] = {});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_shared.js\n// module id = 12\n// module chunks = 0","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_global.js\n// module id = 13\n// module chunks = 0","var id = 0\n  , px = Math.random();\nmodule.exports = function(key){\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_uid.js\n// module id = 14\n// module chunks = 0","// most Object methods by ES6 should accept primitives\nvar $export = require('./_export')\n  , core    = require('./_core')\n  , fails   = require('./_fails');\nmodule.exports = function(KEY, exec){\n  var fn  = (core.Object || {})[KEY] || Object[KEY]\n    , exp = {};\n  exp[KEY] = exec(fn);\n  $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-sap.js\n// module id = 15\n// module chunks = 0","var global    = require('./_global')\n  , core      = require('./_core')\n  , ctx       = require('./_ctx')\n  , hide      = require('./_hide')\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE]\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(a, b, c){\n        if(this instanceof C){\n          switch(arguments.length){\n            case 0: return new C;\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if(IS_PROTO){\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_export.js\n// module id = 16\n// module chunks = 0","var core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_core.js\n// module id = 17\n// module chunks = 0","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_ctx.js\n// module id = 18\n// module chunks = 0","module.exports = function(it){\n  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_a-function.js\n// module id = 19\n// module chunks = 0","var dP         = require('./_object-dp')\n  , createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function(object, key, value){\n  return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n  object[key] = value;\n  return object;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_hide.js\n// module id = 20\n// module chunks = 0","var anObject       = require('./_an-object')\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n  , toPrimitive    = require('./_to-primitive')\n  , dP             = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if(IE8_DOM_DEFINE)try {\n    return dP(O, P, Attributes);\n  } catch(e){ /* empty */ }\n  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n  if('value' in Attributes)O[P] = Attributes.value;\n  return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-dp.js\n// module id = 21\n// module chunks = 0","var isObject = require('./_is-object');\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_an-object.js\n// module id = 22\n// module chunks = 0","module.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-object.js\n// module id = 23\n// module chunks = 0","module.exports = !require('./_descriptors') && !require('./_fails')(function(){\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_ie8-dom-define.js\n// module id = 24\n// module chunks = 0","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_descriptors.js\n// module id = 25\n// module chunks = 0","module.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_fails.js\n// module id = 26\n// module chunks = 0","var isObject = require('./_is-object')\n  , document = require('./_global').document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_dom-create.js\n// module id = 27\n// module chunks = 0","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n  if(!isObject(it))return it;\n  var fn, val;\n  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-primitive.js\n// module id = 28\n// module chunks = 0","module.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_property-desc.js\n// module id = 29\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nvar _typeof2 = require(\"../helpers/typeof\");\n\nvar _typeof3 = _interopRequireDefault(_typeof2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && ((typeof call === \"undefined\" ? \"undefined\" : (0, _typeof3.default)(call)) === \"object\" || typeof call === \"function\") ? call : self;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/possibleConstructorReturn.js\n// module id = 30\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nvar _iterator = require(\"../core-js/symbol/iterator\");\n\nvar _iterator2 = _interopRequireDefault(_iterator);\n\nvar _symbol = require(\"../core-js/symbol\");\n\nvar _symbol2 = _interopRequireDefault(_symbol);\n\nvar _typeof = typeof _symbol2.default === \"function\" && typeof _iterator2.default === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default ? \"symbol\" : typeof obj; };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = typeof _symbol2.default === \"function\" && _typeof(_iterator2.default) === \"symbol\" ? function (obj) {\n  return typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n} : function (obj) {\n  return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default ? \"symbol\" : typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/typeof.js\n// module id = 31\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/symbol/iterator\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/symbol/iterator.js\n// module id = 32\n// module chunks = 0","require('../../modules/es6.string.iterator');\nrequire('../../modules/web.dom.iterable');\nmodule.exports = require('../../modules/_wks-ext').f('iterator');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/symbol/iterator.js\n// module id = 33\n// module chunks = 0","'use strict';\nvar $at  = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function(iterated){\n  this._t = String(iterated); // target\n  this._i = 0;                // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , index = this._i\n    , point;\n  if(index >= O.length)return {value: undefined, done: true};\n  point = $at(O, index);\n  this._i += point.length;\n  return {value: point, done: false};\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.string.iterator.js\n// module id = 34\n// module chunks = 0","var toInteger = require('./_to-integer')\n  , defined   = require('./_defined');\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n  return function(that, pos){\n    var s = String(defined(that))\n      , i = toInteger(pos)\n      , l = s.length\n      , a, b;\n    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_string-at.js\n// module id = 35\n// module chunks = 0","// 7.1.4 ToInteger\nvar ceil  = Math.ceil\n  , floor = Math.floor;\nmodule.exports = function(it){\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-integer.js\n// module id = 36\n// module chunks = 0","'use strict';\nvar LIBRARY        = require('./_library')\n  , $export        = require('./_export')\n  , redefine       = require('./_redefine')\n  , hide           = require('./_hide')\n  , has            = require('./_has')\n  , Iterators      = require('./_iterators')\n  , $iterCreate    = require('./_iter-create')\n  , setToStringTag = require('./_set-to-string-tag')\n  , getPrototypeOf = require('./_object-gpo')\n  , ITERATOR       = require('./_wks')('iterator')\n  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n  , FF_ITERATOR    = '@@iterator'\n  , KEYS           = 'keys'\n  , VALUES         = 'values';\n\nvar returnThis = function(){ return this; };\n\nmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function(kind){\n    if(!BUGGY && kind in proto)return proto[kind];\n    switch(kind){\n      case KEYS: return function keys(){ return new Constructor(this, kind); };\n      case VALUES: return function values(){ return new Constructor(this, kind); };\n    } return function entries(){ return new Constructor(this, kind); };\n  };\n  var TAG        = NAME + ' Iterator'\n    , DEF_VALUES = DEFAULT == VALUES\n    , VALUES_BUG = false\n    , proto      = Base.prototype\n    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n    , $default   = $native || getMethod(DEFAULT)\n    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n    , methods, key, IteratorPrototype;\n  // Fix native\n  if($anyNative){\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n    if(IteratorPrototype !== Object.prototype){\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if(DEF_VALUES && $native && $native.name !== VALUES){\n    VALUES_BUG = true;\n    $default = function values(){ return $native.call(this); };\n  }\n  // Define iterator\n  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG]  = returnThis;\n  if(DEFAULT){\n    methods = {\n      values:  DEF_VALUES ? $default : getMethod(VALUES),\n      keys:    IS_SET     ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if(FORCED)for(key in methods){\n      if(!(key in proto))redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-define.js\n// module id = 37\n// module chunks = 0","module.exports = true;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_library.js\n// module id = 38\n// module chunks = 0","module.exports = require('./_hide');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_redefine.js\n// module id = 39\n// module chunks = 0","module.exports = {};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iterators.js\n// module id = 40\n// module chunks = 0","'use strict';\nvar create         = require('./_object-create')\n  , descriptor     = require('./_property-desc')\n  , setToStringTag = require('./_set-to-string-tag')\n  , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });\n\nmodule.exports = function(Constructor, NAME, next){\n  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n  setToStringTag(Constructor, NAME + ' Iterator');\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-create.js\n// module id = 41\n// module chunks = 0","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject    = require('./_an-object')\n  , dPs         = require('./_object-dps')\n  , enumBugKeys = require('./_enum-bug-keys')\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\n  , Empty       = function(){ /* empty */ }\n  , PROTOTYPE   = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function(){\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = require('./_dom-create')('iframe')\n    , i      = enumBugKeys.length\n    , lt     = '<'\n    , gt     = '>'\n    , iframeDocument;\n  iframe.style.display = 'none';\n  require('./_html').appendChild(iframe);\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n  // createDict = iframe.contentWindow.Object;\n  // html.removeChild(iframe);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n  iframeDocument.close();\n  createDict = iframeDocument.F;\n  while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\n  return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties){\n  var result;\n  if(O !== null){\n    Empty[PROTOTYPE] = anObject(O);\n    result = new Empty;\n    Empty[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = createDict();\n  return Properties === undefined ? result : dPs(result, Properties);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-create.js\n// module id = 42\n// module chunks = 0","var dP       = require('./_object-dp')\n  , anObject = require('./_an-object')\n  , getKeys  = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){\n  anObject(O);\n  var keys   = getKeys(Properties)\n    , length = keys.length\n    , i = 0\n    , P;\n  while(length > i)dP.f(O, P = keys[i++], Properties[P]);\n  return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-dps.js\n// module id = 43\n// module chunks = 0","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys       = require('./_object-keys-internal')\n  , enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O){\n  return $keys(O, enumBugKeys);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-keys.js\n// module id = 44\n// module chunks = 0","var has          = require('./_has')\n  , toIObject    = require('./_to-iobject')\n  , arrayIndexOf = require('./_array-includes')(false)\n  , IE_PROTO     = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function(object, names){\n  var O      = toIObject(object)\n    , i      = 0\n    , result = []\n    , key;\n  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while(names.length > i)if(has(O, key = names[i++])){\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-keys-internal.js\n// module id = 45\n// module chunks = 0","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject')\n  , defined = require('./_defined');\nmodule.exports = function(it){\n  return IObject(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-iobject.js\n// module id = 46\n// module chunks = 0","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iobject.js\n// module id = 47\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = function(it){\n  return toString.call(it).slice(8, -1);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_cof.js\n// module id = 48\n// module chunks = 0","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject')\n  , toLength  = require('./_to-length')\n  , toIndex   = require('./_to-index');\nmodule.exports = function(IS_INCLUDES){\n  return function($this, el, fromIndex){\n    var O      = toIObject($this)\n      , length = toLength(O.length)\n      , index  = toIndex(fromIndex, length)\n      , value;\n    // Array#includes uses SameValueZero equality algorithm\n    if(IS_INCLUDES && el != el)while(length > index){\n      value = O[index++];\n      if(value != value)return true;\n    // Array#toIndex ignores holes, Array#includes - not\n    } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n      if(O[index] === el)return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_array-includes.js\n// module id = 49\n// module chunks = 0","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer')\n  , min       = Math.min;\nmodule.exports = function(it){\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-length.js\n// module id = 50\n// module chunks = 0","var toInteger = require('./_to-integer')\n  , max       = Math.max\n  , min       = Math.min;\nmodule.exports = function(index, length){\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_to-index.js\n// module id = 51\n// module chunks = 0","// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_enum-bug-keys.js\n// module id = 52\n// module chunks = 0","module.exports = require('./_global').document && document.documentElement;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_html.js\n// module id = 53\n// module chunks = 0","var def = require('./_object-dp').f\n  , has = require('./_has')\n  , TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_set-to-string-tag.js\n// module id = 54\n// module chunks = 0","var store      = require('./_shared')('wks')\n  , uid        = require('./_uid')\n  , Symbol     = require('./_global').Symbol\n  , USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function(name){\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_wks.js\n// module id = 55\n// module chunks = 0","require('./es6.array.iterator');\nvar global        = require('./_global')\n  , hide          = require('./_hide')\n  , Iterators     = require('./_iterators')\n  , TO_STRING_TAG = require('./_wks')('toStringTag');\n\nfor(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){\n  var NAME       = collections[i]\n    , Collection = global[NAME]\n    , proto      = Collection && Collection.prototype;\n  if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);\n  Iterators[NAME] = Iterators.Array;\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/web.dom.iterable.js\n// module id = 56\n// module chunks = 0","'use strict';\nvar addToUnscopables = require('./_add-to-unscopables')\n  , step             = require('./_iter-step')\n  , Iterators        = require('./_iterators')\n  , toIObject        = require('./_to-iobject');\n\n// 22.1.3.4 Array.prototype.entries()\n// 22.1.3.13 Array.prototype.keys()\n// 22.1.3.29 Array.prototype.values()\n// 22.1.3.30 Array.prototype[@@iterator]()\nmodule.exports = require('./_iter-define')(Array, 'Array', function(iterated, kind){\n  this._t = toIObject(iterated); // target\n  this._i = 0;                   // next index\n  this._k = kind;                // kind\n// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , kind  = this._k\n    , index = this._i++;\n  if(!O || index >= O.length){\n    this._t = undefined;\n    return step(1);\n  }\n  if(kind == 'keys'  )return step(0, index);\n  if(kind == 'values')return step(0, O[index]);\n  return step(0, [index, O[index]]);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\nIterators.Arguments = Iterators.Array;\n\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.array.iterator.js\n// module id = 57\n// module chunks = 0","module.exports = function(){ /* empty */ };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_add-to-unscopables.js\n// module id = 58\n// module chunks = 0","module.exports = function(done, value){\n  return {value: value, done: !!done};\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-step.js\n// module id = 59\n// module chunks = 0","exports.f = require('./_wks');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_wks-ext.js\n// module id = 60\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/symbol\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/symbol.js\n// module id = 61\n// module chunks = 0","require('../../modules/es6.symbol');\nrequire('../../modules/es6.object.to-string');\nrequire('../../modules/es7.symbol.async-iterator');\nrequire('../../modules/es7.symbol.observable');\nmodule.exports = require('../../modules/_core').Symbol;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/symbol/index.js\n// module id = 62\n// module chunks = 0","'use strict';\n// ECMAScript 6 symbols shim\nvar global         = require('./_global')\n  , has            = require('./_has')\n  , DESCRIPTORS    = require('./_descriptors')\n  , $export        = require('./_export')\n  , redefine       = require('./_redefine')\n  , META           = require('./_meta').KEY\n  , $fails         = require('./_fails')\n  , shared         = require('./_shared')\n  , setToStringTag = require('./_set-to-string-tag')\n  , uid            = require('./_uid')\n  , wks            = require('./_wks')\n  , wksExt         = require('./_wks-ext')\n  , wksDefine      = require('./_wks-define')\n  , keyOf          = require('./_keyof')\n  , enumKeys       = require('./_enum-keys')\n  , isArray        = require('./_is-array')\n  , anObject       = require('./_an-object')\n  , toIObject      = require('./_to-iobject')\n  , toPrimitive    = require('./_to-primitive')\n  , createDesc     = require('./_property-desc')\n  , _create        = require('./_object-create')\n  , gOPNExt        = require('./_object-gopn-ext')\n  , $GOPD          = require('./_object-gopd')\n  , $DP            = require('./_object-dp')\n  , $keys          = require('./_object-keys')\n  , gOPD           = $GOPD.f\n  , dP             = $DP.f\n  , gOPN           = gOPNExt.f\n  , $Symbol        = global.Symbol\n  , $JSON          = global.JSON\n  , _stringify     = $JSON && $JSON.stringify\n  , PROTOTYPE      = 'prototype'\n  , HIDDEN         = wks('_hidden')\n  , TO_PRIMITIVE   = wks('toPrimitive')\n  , isEnum         = {}.propertyIsEnumerable\n  , SymbolRegistry = shared('symbol-registry')\n  , AllSymbols     = shared('symbols')\n  , OPSymbols      = shared('op-symbols')\n  , ObjectProto    = Object[PROTOTYPE]\n  , USE_NATIVE     = typeof $Symbol == 'function'\n  , QObject        = global.QObject;\n// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\nvar setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDesc = DESCRIPTORS && $fails(function(){\n  return _create(dP({}, 'a', {\n    get: function(){ return dP(this, 'a', {value: 7}).a; }\n  })).a != 7;\n}) ? function(it, key, D){\n  var protoDesc = gOPD(ObjectProto, key);\n  if(protoDesc)delete ObjectProto[key];\n  dP(it, key, D);\n  if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc);\n} : dP;\n\nvar wrap = function(tag){\n  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);\n  sym._k = tag;\n  return sym;\n};\n\nvar isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){\n  return typeof it == 'symbol';\n} : function(it){\n  return it instanceof $Symbol;\n};\n\nvar $defineProperty = function defineProperty(it, key, D){\n  if(it === ObjectProto)$defineProperty(OPSymbols, key, D);\n  anObject(it);\n  key = toPrimitive(key, true);\n  anObject(D);\n  if(has(AllSymbols, key)){\n    if(!D.enumerable){\n      if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {}));\n      it[HIDDEN][key] = true;\n    } else {\n      if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;\n      D = _create(D, {enumerable: createDesc(0, false)});\n    } return setSymbolDesc(it, key, D);\n  } return dP(it, key, D);\n};\nvar $defineProperties = function defineProperties(it, P){\n  anObject(it);\n  var keys = enumKeys(P = toIObject(P))\n    , i    = 0\n    , l = keys.length\n    , key;\n  while(l > i)$defineProperty(it, key = keys[i++], P[key]);\n  return it;\n};\nvar $create = function create(it, P){\n  return P === undefined ? _create(it) : $defineProperties(_create(it), P);\n};\nvar $propertyIsEnumerable = function propertyIsEnumerable(key){\n  var E = isEnum.call(this, key = toPrimitive(key, true));\n  if(this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return false;\n  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;\n};\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){\n  it  = toIObject(it);\n  key = toPrimitive(key, true);\n  if(it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return;\n  var D = gOPD(it, key);\n  if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;\n  return D;\n};\nvar $getOwnPropertyNames = function getOwnPropertyNames(it){\n  var names  = gOPN(toIObject(it))\n    , result = []\n    , i      = 0\n    , key;\n  while(names.length > i){\n    if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key);\n  } return result;\n};\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(it){\n  var IS_OP  = it === ObjectProto\n    , names  = gOPN(IS_OP ? OPSymbols : toIObject(it))\n    , result = []\n    , i      = 0\n    , key;\n  while(names.length > i){\n    if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]);\n  } return result;\n};\n\n// 19.4.1.1 Symbol([description])\nif(!USE_NATIVE){\n  $Symbol = function Symbol(){\n    if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!');\n    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);\n    var $set = function(value){\n      if(this === ObjectProto)$set.call(OPSymbols, value);\n      if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;\n      setSymbolDesc(this, tag, createDesc(1, value));\n    };\n    if(DESCRIPTORS && setter)setSymbolDesc(ObjectProto, tag, {configurable: true, set: $set});\n    return wrap(tag);\n  };\n  redefine($Symbol[PROTOTYPE], 'toString', function toString(){\n    return this._k;\n  });\n\n  $GOPD.f = $getOwnPropertyDescriptor;\n  $DP.f   = $defineProperty;\n  require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;\n  require('./_object-pie').f  = $propertyIsEnumerable;\n  require('./_object-gops').f = $getOwnPropertySymbols;\n\n  if(DESCRIPTORS && !require('./_library')){\n    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);\n  }\n\n  wksExt.f = function(name){\n    return wrap(wks(name));\n  }\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol});\n\nfor(var symbols = (\n  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14\n  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'\n).split(','), i = 0; symbols.length > i; )wks(symbols[i++]);\n\nfor(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]);\n\n$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {\n  // 19.4.2.1 Symbol.for(key)\n  'for': function(key){\n    return has(SymbolRegistry, key += '')\n      ? SymbolRegistry[key]\n      : SymbolRegistry[key] = $Symbol(key);\n  },\n  // 19.4.2.5 Symbol.keyFor(sym)\n  keyFor: function keyFor(key){\n    if(isSymbol(key))return keyOf(SymbolRegistry, key);\n    throw TypeError(key + ' is not a symbol!');\n  },\n  useSetter: function(){ setter = true; },\n  useSimple: function(){ setter = false; }\n});\n\n$export($export.S + $export.F * !USE_NATIVE, 'Object', {\n  // 19.1.2.2 Object.create(O [, Properties])\n  create: $create,\n  // 19.1.2.4 Object.defineProperty(O, P, Attributes)\n  defineProperty: $defineProperty,\n  // 19.1.2.3 Object.defineProperties(O, Properties)\n  defineProperties: $defineProperties,\n  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,\n  // 19.1.2.7 Object.getOwnPropertyNames(O)\n  getOwnPropertyNames: $getOwnPropertyNames,\n  // 19.1.2.8 Object.getOwnPropertySymbols(O)\n  getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// 24.3.2 JSON.stringify(value [, replacer [, space]])\n$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){\n  var S = $Symbol();\n  // MS Edge converts symbol values to JSON as {}\n  // WebKit converts symbol values to JSON as null\n  // V8 throws on boxed symbols\n  return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';\n})), 'JSON', {\n  stringify: function stringify(it){\n    if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined\n    var args = [it]\n      , i    = 1\n      , replacer, $replacer;\n    while(arguments.length > i)args.push(arguments[i++]);\n    replacer = args[1];\n    if(typeof replacer == 'function')$replacer = replacer;\n    if($replacer || !isArray(replacer))replacer = function(key, value){\n      if($replacer)value = $replacer.call(this, key, value);\n      if(!isSymbol(value))return value;\n    };\n    args[1] = replacer;\n    return _stringify.apply($JSON, args);\n  }\n});\n\n// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)\n$Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);\n// 19.4.3.5 Symbol.prototype[@@toStringTag]\nsetToStringTag($Symbol, 'Symbol');\n// 20.2.1.9 Math[@@toStringTag]\nsetToStringTag(Math, 'Math', true);\n// 24.3.3 JSON[@@toStringTag]\nsetToStringTag(global.JSON, 'JSON', true);\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.symbol.js\n// module id = 63\n// module chunks = 0","var META     = require('./_uid')('meta')\n  , isObject = require('./_is-object')\n  , has      = require('./_has')\n  , setDesc  = require('./_object-dp').f\n  , id       = 0;\nvar isExtensible = Object.isExtensible || function(){\n  return true;\n};\nvar FREEZE = !require('./_fails')(function(){\n  return isExtensible(Object.preventExtensions({}));\n});\nvar setMeta = function(it){\n  setDesc(it, META, {value: {\n    i: 'O' + ++id, // object ID\n    w: {}          // weak collections IDs\n  }});\n};\nvar fastKey = function(it, create){\n  // return primitive with prefix\n  if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if(!has(it, META)){\n    // can't set metadata to uncaught frozen object\n    if(!isExtensible(it))return 'F';\n    // not necessary to add metadata\n    if(!create)return 'E';\n    // add missing metadata\n    setMeta(it);\n  // return object ID\n  } return it[META].i;\n};\nvar getWeak = function(it, create){\n  if(!has(it, META)){\n    // can't set metadata to uncaught frozen object\n    if(!isExtensible(it))return true;\n    // not necessary to add metadata\n    if(!create)return false;\n    // add missing metadata\n    setMeta(it);\n  // return hash weak collections IDs\n  } return it[META].w;\n};\n// add metadata on freeze-family methods calling\nvar onFreeze = function(it){\n  if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it);\n  return it;\n};\nvar meta = module.exports = {\n  KEY:      META,\n  NEED:     false,\n  fastKey:  fastKey,\n  getWeak:  getWeak,\n  onFreeze: onFreeze\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_meta.js\n// module id = 64\n// module chunks = 0","var global         = require('./_global')\n  , core           = require('./_core')\n  , LIBRARY        = require('./_library')\n  , wksExt         = require('./_wks-ext')\n  , defineProperty = require('./_object-dp').f;\nmodule.exports = function(name){\n  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});\n  if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_wks-define.js\n// module id = 65\n// module chunks = 0","var getKeys   = require('./_object-keys')\n  , toIObject = require('./_to-iobject');\nmodule.exports = function(object, el){\n  var O      = toIObject(object)\n    , keys   = getKeys(O)\n    , length = keys.length\n    , index  = 0\n    , key;\n  while(length > index)if(O[key = keys[index++]] === el)return key;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_keyof.js\n// module id = 66\n// module chunks = 0","// all enumerable object keys, includes symbols\nvar getKeys = require('./_object-keys')\n  , gOPS    = require('./_object-gops')\n  , pIE     = require('./_object-pie');\nmodule.exports = function(it){\n  var result     = getKeys(it)\n    , getSymbols = gOPS.f;\n  if(getSymbols){\n    var symbols = getSymbols(it)\n      , isEnum  = pIE.f\n      , i       = 0\n      , key;\n    while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key);\n  } return result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_enum-keys.js\n// module id = 67\n// module chunks = 0","exports.f = Object.getOwnPropertySymbols;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gops.js\n// module id = 68\n// module chunks = 0","exports.f = {}.propertyIsEnumerable;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-pie.js\n// module id = 69\n// module chunks = 0","// 7.2.2 IsArray(argument)\nvar cof = require('./_cof');\nmodule.exports = Array.isArray || function isArray(arg){\n  return cof(arg) == 'Array';\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-array.js\n// module id = 70\n// module chunks = 0","// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nvar toIObject = require('./_to-iobject')\n  , gOPN      = require('./_object-gopn').f\n  , toString  = {}.toString;\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function(it){\n  try {\n    return gOPN(it);\n  } catch(e){\n    return windowNames.slice();\n  }\n};\n\nmodule.exports.f = function getOwnPropertyNames(it){\n  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gopn-ext.js\n// module id = 71\n// module chunks = 0","// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)\nvar $keys      = require('./_object-keys-internal')\n  , hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');\n\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){\n  return $keys(O, hiddenKeys);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gopn.js\n// module id = 72\n// module chunks = 0","var pIE            = require('./_object-pie')\n  , createDesc     = require('./_property-desc')\n  , toIObject      = require('./_to-iobject')\n  , toPrimitive    = require('./_to-primitive')\n  , has            = require('./_has')\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n  , gOPD           = Object.getOwnPropertyDescriptor;\n\nexports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P){\n  O = toIObject(O);\n  P = toPrimitive(P, true);\n  if(IE8_DOM_DEFINE)try {\n    return gOPD(O, P);\n  } catch(e){ /* empty */ }\n  if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-gopd.js\n// module id = 73\n// module chunks = 0","require('./_wks-define')('asyncIterator');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es7.symbol.async-iterator.js\n// module id = 75\n// module chunks = 0","require('./_wks-define')('observable');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es7.symbol.observable.js\n// module id = 76\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nvar _setPrototypeOf = require(\"../core-js/object/set-prototype-of\");\n\nvar _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);\n\nvar _create = require(\"../core-js/object/create\");\n\nvar _create2 = _interopRequireDefault(_create);\n\nvar _typeof2 = require(\"../helpers/typeof\");\n\nvar _typeof3 = _interopRequireDefault(_typeof2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + (typeof superClass === \"undefined\" ? \"undefined\" : (0, _typeof3.default)(superClass)));\n  }\n\n  subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) _setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/inherits.js\n// module id = 77\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/object/set-prototype-of\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/set-prototype-of.js\n// module id = 78\n// module chunks = 0","require('../../modules/es6.object.set-prototype-of');\nmodule.exports = require('../../modules/_core').Object.setPrototypeOf;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/set-prototype-of.js\n// module id = 79\n// module chunks = 0","// 19.1.3.19 Object.setPrototypeOf(O, proto)\nvar $export = require('./_export');\n$export($export.S, 'Object', {setPrototypeOf: require('./_set-proto').set});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.object.set-prototype-of.js\n// module id = 80\n// module chunks = 0","// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nvar isObject = require('./_is-object')\n  , anObject = require('./_an-object');\nvar check = function(O, proto){\n  anObject(O);\n  if(!isObject(proto) && proto !== null)throw TypeError(proto + \": can't set as prototype!\");\n};\nmodule.exports = {\n  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line\n    function(test, buggy, set){\n      try {\n        set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2);\n        set(test, []);\n        buggy = !(test instanceof Array);\n      } catch(e){ buggy = true; }\n      return function setPrototypeOf(O, proto){\n        check(O, proto);\n        if(buggy)O.__proto__ = proto;\n        else set(O, proto);\n        return O;\n      };\n    }({}, false) : undefined),\n  check: check\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_set-proto.js\n// module id = 81\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/object/create\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/create.js\n// module id = 82\n// module chunks = 0","require('../../modules/es6.object.create');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function create(P, D){\n  return $Object.create(P, D);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/create.js\n// module id = 83\n// module chunks = 0","var $export = require('./_export')\n// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\n$export($export.S, 'Object', {create: require('./_object-create')});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.object.create.js\n// module id = 84\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nexports.default = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/classCallCheck.js\n// module id = 85\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      (0, _defineProperty2.default)(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/createClass.js\n// module id = 86\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/object/define-property\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/define-property.js\n// module id = 87\n// module chunks = 0","require('../../modules/es6.object.define-property');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function defineProperty(it, key, desc){\n  return $Object.defineProperty(it, key, desc);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/define-property.js\n// module id = 88\n// module chunks = 0","var $export = require('./_export');\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', {defineProperty: require('./_object-dp').f});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.object.define-property.js\n// module id = 89\n// module chunks = 0","import { Service } from './core'\n/**\n * Delegating authentication\n *\n * This authentication delegates authentication to an external auth provider\n * <br>When a zetapush client handshakes with a delegated authentication, the 'token' field given by the client is sent to the configured remote server as part of the URL\n * <br>The response must be in JSON format\n *  Each key of the response will be considered a user information field name\n *\n * */\n/**\n * End-user API for the delegating authentication\n *\n * Provisionning verbs.\n * @access public\n * */\nexport class Delegating extends Service {\n\t/**\n\t * Get default deployment id associated to Delegating service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'delegating_0'\n\t}\n}\n/**\n * Local authentication\n *\n * Zetapush local authentication\n *  The configurer can choose the primary key and mandatory user fields for account creation\n *  The field 'zetapushKey' is generated by the server and MUST not be used : it contains the unique key of the user inside a sandbox (it can be obtained from inside a macro with the <b>__userKey</b> pseudo-constant)\n * */\n/**\n * End-user API for the simple local authentication\n *\n * These API verbs allow end-users to manage their account.\n * @access public\n * */\nexport class Simple extends Service {\n\t/**\n\t * Get default deployment id associated to Simple service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'simple_0'\n\t}\n}\n/**\n * Weak authentication\n *\n * The weak authentication allows for anonymous authentication of devices\n *  Such devices can display a qrcode to allow regular users to take control of them\n * */\n/**\n * User API for weak devices control\n *\n * User API for control and release of weakly authenticated user sessions.\n * @access public\n * */\nexport class Weak extends Service {\n\t/**\n\t * Get default deployment id associated to Weak service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'weak_0'\n\t}\n\t/**\n\t * Controls a session\n\t *\n\t * Takes control of a weak user session, identified by the given public token.\n\t * The public token has been previously made available by the controlled device, for example by displaying a QRCode.\n\t * Upon control notification, the client SDK of the controlled session is expected to re-handshake.\n\t * */\n\tcontrol({fullRights,publicToken}) { return this.$publish('control', {fullRights,publicToken})}\n\t/**\n\t * Releases a session\n\t *\n\t * Releases control of a weak user session, identified by the given public token.\n\t * The weak user session must have been previously controlled by a call to 'control'.\n\t * */\n\trelease({fullRights,publicToken}) { return this.$publish('release', {fullRights,publicToken})}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/mapping/authentications.js","/**\n * @access protected\n */\nexport class Service {\n  constructor({ $publish }) {\n    this.$publish = $publish\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/mapping/core.js","/**\n * Define life cycle connection methods\n * @access public\n */\nexport class ConnectionStatusListener {\n  /**\n   * Callback fired when connection is broken\n   */\n  onConnectionBroken() {}\n  /**\n   * Callback fired when connection is closed\n   */\n  onConnectionClosed() {}\n  /**\n   * Callback fired when connection is established\n   */\n  onConnectionEstablished() {}\n  /**\n  * Callback fired when connection will close\n  */\n  onConnectionWillClose() {}\n  /**\n   * Callback fired when an error occurs in handshake step\n   * @param {Object} failure\n   */\n  onFailedHandshake(failure) {}\n  /**\n   * Callback fired when a message is lost\n   */\n  onMessageLost() {}\n  /**\n   * Callback fired when handshake step succeed\n   * @param {Object} authentication\n   */\n  onSuccessfulHandshake(authentication) {}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/connection/connection-status.js","import { Transport, LongPollingTransport, WebSocketTransport } from 'zetapush-cometd'\n\n/**\n * Implements LongPollingTransport using borwser fetch() API\n * @access private\n * @return {FetchLongPollingTransport}\n */\nexport function FetchLongPollingTransport() {\n  const _super = new LongPollingTransport()\n  const that = Transport.derive(_super)\n\n  /**\n   * Implements transport via fetch() API\n   * @param {Object} packet\n   */\n  that.xhrSend = function (packet) {\n    fetch(packet.url, {\n      method: 'post',\n      body: packet.body,\n      headers: Object.assign(packet.headers, {\n        'Content-Type': 'application/json;charset=UTF-8'\n      })\n    })\n    .then((response) => {\n      return response.json()\n    })\n    .then(packet.onSuccess)\n    .catch(packet.onError)\n  }\n\n  return that\n}\n\n/**\n * CometD Transports enumeration\n */\nexport const TransportTypes = {\n  LONG_POLLING: 'long-polling',\n  WEBSOCKET: 'websocket'\n}\n\n/**\n * CometD Transports Layers map\n */\nexport const TransportLayers = [{\n  type: TransportTypes.WEBSOCKET,\n  Transport: WebSocketTransport\n}, {\n  type: TransportTypes.LONG_POLLING,\n  Transport: FetchLongPollingTransport\n}]\n\n\n\n// WEBPACK FOOTER //\n// ./lib/connection/cometd.js","module.exports = { \"default\": require(\"core-js/library/fn/object/assign\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/assign.js\n// module id = 94\n// module chunks = 0","require('../../modules/es6.object.assign');\nmodule.exports = require('../../modules/_core').Object.assign;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/assign.js\n// module id = 95\n// module chunks = 0","// 19.1.3.1 Object.assign(target, source)\nvar $export = require('./_export');\n\n$export($export.S + $export.F, 'Object', {assign: require('./_object-assign')});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.object.assign.js\n// module id = 96\n// module chunks = 0","'use strict';\n// 19.1.2.1 Object.assign(target, source, ...)\nvar getKeys  = require('./_object-keys')\n  , gOPS     = require('./_object-gops')\n  , pIE      = require('./_object-pie')\n  , toObject = require('./_to-object')\n  , IObject  = require('./_iobject')\n  , $assign  = Object.assign;\n\n// should work with symbols and should have deterministic property order (V8 bug)\nmodule.exports = !$assign || require('./_fails')(function(){\n  var A = {}\n    , B = {}\n    , S = Symbol()\n    , K = 'abcdefghijklmnopqrst';\n  A[S] = 7;\n  K.split('').forEach(function(k){ B[k] = k; });\n  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n}) ? function assign(target, source){ // eslint-disable-line no-unused-vars\n  var T     = toObject(target)\n    , aLen  = arguments.length\n    , index = 1\n    , getSymbols = gOPS.f\n    , isEnum     = pIE.f;\n  while(aLen > index){\n    var S      = IObject(arguments[index++])\n      , keys   = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)\n      , length = keys.length\n      , j      = 0\n      , key;\n    while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];\n  } return T;\n} : $assign;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-assign.js\n// module id = 97\n// module chunks = 0","module.exports = {\n  CallbackPollingTransport: require('./lib/CallbackPollingTransport'),\n  CometD: require('./lib/CometD'),\n  LongPollingTransport: require('./lib/LongPollingTransport'),\n  RequestTransport: require('./lib/RequestTransport'),\n  Transport: require('./lib/Transport'),\n  TransportRegistry: require('./lib/TransportRegistry'),\n  Utils: require('./lib/Utils'),\n  WebSocketTransport: require('./lib/WebSocketTransport')\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zetapush-cometd/index.js\n// module id = 98\n// module chunks = 0","var Transport = require('./Transport');\nvar RequestTransport = require('./RequestTransport');\n\nmodule.exports = function CallbackPollingTransport() {\n    var _super = new RequestTransport();\n    var _self = Transport.derive(_super);\n\n    _self.accept = function(version, crossDomain, url) {\n        return true;\n    };\n\n    _self.jsonpSend = function(packet) {\n        throw 'Abstract';\n    };\n\n    function _failTransportFn(envelope, request, x) {\n        var self = this;\n        return function() {\n            self.transportFailure(envelope, request, 'error', x);\n        };\n    }\n\n    _self.transportSend = function(envelope, request) {\n        var self = this;\n\n        // Microsoft Internet Explorer has a 2083 URL max length\n        // We must ensure that we stay within that length\n        var start = 0;\n        var length = envelope.messages.length;\n        var lengths = [];\n        while (length > 0) {\n            // Encode the messages because all brackets, quotes, commas, colons, etc\n            // present in the JSON will be URL encoded, taking many more characters\n            var json = JSON.stringify(envelope.messages.slice(start, start + length));\n            var urlLength = envelope.url.length + encodeURI(json).length;\n\n            var maxLength = this.getConfiguration().maxURILength;\n            if (urlLength > maxLength) {\n                if (length === 1) {\n                    var x = 'Bayeux message too big (' + urlLength + ' bytes, max is ' + maxLength + ') ' +\n                        'for transport ' + this.getType();\n                    // Keep the semantic of calling response callbacks asynchronously after the request\n                    self.setTimeout(_failTransportFn.call(this, envelope, request, x), 0);\n                    return;\n                }\n\n                --length;\n                continue;\n            }\n\n            lengths.push(length);\n            start += length;\n            length = envelope.messages.length - start;\n        }\n\n        // Here we are sure that the messages can be sent within the URL limit\n\n        var envelopeToSend = envelope;\n        if (lengths.length > 1) {\n            var begin = 0;\n            var end = lengths[0];\n            this._debug('Transport', this.getType(), 'split', envelope.messages.length, 'messages into', lengths.join(' + '));\n            envelopeToSend = this._mixin(false, {}, envelope);\n            envelopeToSend.messages = envelope.messages.slice(begin, end);\n            envelopeToSend.onSuccess = envelope.onSuccess;\n            envelopeToSend.onFailure = envelope.onFailure;\n\n            for (var i = 1; i < lengths.length; ++i) {\n                var nextEnvelope = this._mixin(false, {}, envelope);\n                begin = end;\n                end += lengths[i];\n                nextEnvelope.messages = envelope.messages.slice(begin, end);\n                nextEnvelope.onSuccess = envelope.onSuccess;\n                nextEnvelope.onFailure = envelope.onFailure;\n                this.send(nextEnvelope, request.metaConnect);\n            }\n        }\n\n        this._debug('Transport', this.getType(), 'sending request', request.id, 'envelope', envelopeToSend);\n\n        try {\n            var sameStack = true;\n            this.jsonpSend({\n                transport: this,\n                url: envelopeToSend.url,\n                sync: envelopeToSend.sync,\n                headers: this.getConfiguration().requestHeaders,\n                body: JSON.stringify(envelopeToSend.messages),\n                onSuccess: function(responses) {\n                    var success = false;\n                    try {\n                        var received = self.convertToMessages(responses);\n                        if (received.length === 0) {\n                            self.transportFailure(envelopeToSend, request, {\n                                httpCode: 204\n                            });\n                        } else {\n                            success = true;\n                            self.transportSuccess(envelopeToSend, request, received);\n                        }\n                    } catch (x) {\n                        self._debug(x);\n                        if (!success) {\n                            self.transportFailure(envelopeToSend, request, {\n                                exception: x\n                            });\n                        }\n                    }\n                },\n                onError: function(reason, exception) {\n                    var failure = {\n                        reason: reason,\n                        exception: exception\n                    };\n                    if (sameStack) {\n                        // Keep the semantic of calling response callbacks asynchronously after the request\n                        self.setTimeout(function() {\n                            self.transportFailure(envelopeToSend, request, failure);\n                        }, 0);\n                    } else {\n                        self.transportFailure(envelopeToSend, request, failure);\n                    }\n                }\n            });\n            sameStack = false;\n        } catch (xx) {\n            // Keep the semantic of calling response callbacks asynchronously after the request\n            self.setTimeout(function() {\n                self.transportFailure(envelopeToSend, request, {\n                    exception: xx\n                });\n            }, 0);\n        }\n    };\n\n    return _self;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zetapush-cometd/lib/CallbackPollingTransport.js\n// module id = 99\n// module chunks = 0","var Utils = require('./Utils')\n\n/**\n * Base object with the common functionality for transports.\n */\nmodule.exports = function Transport() {\n    var _type;\n    var _cometd;\n    var _url;\n\n    /**\n     * Function invoked just after a transport has been successfully registered.\n     * @param type the type of transport (for example 'long-polling')\n     * @param cometd the cometd object this transport has been registered to\n     * @see #unregistered()\n     */\n    this.registered = function(type, cometd) {\n        _type = type;\n        _cometd = cometd;\n    };\n\n    /**\n     * Function invoked just after a transport has been successfully unregistered.\n     * @see #registered(type, cometd)\n     */\n    this.unregistered = function() {\n        _type = null;\n        _cometd = null;\n    };\n\n    this._debug = function() {\n        _cometd._debug.apply(_cometd, arguments);\n    };\n\n    this._mixin = function() {\n        return _cometd._mixin.apply(_cometd, arguments);\n    };\n\n    this.getConfiguration = function() {\n        return _cometd.getConfiguration();\n    };\n\n    this.getAdvice = function() {\n        return _cometd.getAdvice();\n    };\n\n    this.setTimeout = function(funktion, delay) {\n        return Utils.setTimeout(_cometd, funktion, delay);\n    };\n\n    this.clearTimeout = function(handle) {\n        Utils.clearTimeout(handle);\n    };\n\n    /**\n     * Converts the given response into an array of bayeux messages\n     * @param response the response to convert\n     * @return an array of bayeux messages obtained by converting the response\n     */\n    this.convertToMessages = function(response) {\n        if (Utils.isString(response)) {\n            try {\n                return JSON.parse(response);\n            } catch (x) {\n                this._debug('Could not convert to JSON the following string', '\"' + response + '\"');\n                throw x;\n            }\n        }\n        if (Utils.isArray(response)) {\n            return response;\n        }\n        if (response === undefined || response === null) {\n            return [];\n        }\n        if (response instanceof Object) {\n            return [response];\n        }\n        throw 'Conversion Error ' + response + ', typeof ' + (typeof response);\n    };\n\n    /**\n     * Returns whether this transport can work for the given version and cross domain communication case.\n     * @param version a string indicating the transport version\n     * @param crossDomain a boolean indicating whether the communication is cross domain\n     * @param url the URL to connect to\n     * @return true if this transport can work for the given version and cross domain communication case,\n     * false otherwise\n     */\n    this.accept = function(version, crossDomain, url) {\n        throw 'Abstract';\n    };\n\n    /**\n     * Returns the type of this transport.\n     * @see #registered(type, cometd)\n     */\n    this.getType = function() {\n        return _type;\n    };\n\n    this.getURL = function() {\n        return _url;\n    };\n\n    this.setURL = function(url) {\n        _url = url;\n    };\n\n    this.send = function(envelope, metaConnect) {\n        throw 'Abstract';\n    };\n\n    this.reset = function(init) {\n        this._debug('Transport', _type, 'reset', init ? 'initial' : 'retry');\n    };\n\n    this.abort = function() {\n        this._debug('Transport', _type, 'aborted');\n    };\n\n    this.toString = function() {\n        return this.getType();\n    };\n};\n\nmodule.exports.derive = function(baseObject) {\n    function F() {\n    }\n\n    F.prototype = baseObject;\n    return new F();\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zetapush-cometd/lib/Transport.js\n// module id = 100\n// module chunks = 0","exports.isString = function (value) {\n    if (value === undefined || value === null) {\n        return false;\n    }\n    return typeof value === 'string' || value instanceof String;\n};\n\nexports.isArray = function (value) {\n    if (value === undefined || value === null) {\n        return false;\n    }\n    return value instanceof Array;\n};\n\n/**\n * Returns whether the given element is contained into the given array.\n * @param element the element to check presence for\n * @param array the array to check for the element presence\n * @return the index of the element, if present, or a negative index if the element is not present\n */\nexports.inArray = function (element, array) {\n    for (var i = 0; i < array.length; ++i) {\n        if (element === array[i]) {\n            return i;\n        }\n    }\n    return -1;\n};\n\nexports.setTimeout = function (cometd, funktion, delay) {\n    return setTimeout(function() {\n        try {\n            cometd._debug('Invoking timed function', funktion);\n            funktion();\n        } catch (x) {\n            cometd._debug('Exception invoking timed function', funktion, x);\n        }\n    }, delay);\n};\n\nexports.clearTimeout = function (timeoutHandle) {\n    clearTimeout(timeoutHandle);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zetapush-cometd/lib/Utils.js\n// module id = 101\n// module chunks = 0","var Transport = require('./Transport')\nvar Utils = require('./Utils')\n\n/**\n * Base object with the common functionality for transports based on requests.\n * The key responsibility is to allow at most 2 outstanding requests to the server,\n * to avoid that requests are sent behind a long poll.\n * To achieve this, we have one reserved request for the long poll, and all other\n * requests are serialized one after the other.\n */\nmodule.exports = function RequestTransport() {\n    var _super = new Transport();\n    var _self = Transport.derive(_super);\n    var _requestIds = 0;\n    var _metaConnectRequest = null;\n    var _requests = [];\n    var _envelopes = [];\n\n    function _coalesceEnvelopes(envelope) {\n        while (_envelopes.length > 0) {\n            var envelopeAndRequest = _envelopes[0];\n            var newEnvelope = envelopeAndRequest[0];\n            var newRequest = envelopeAndRequest[1];\n            if (newEnvelope.url === envelope.url &&\n                newEnvelope.sync === envelope.sync) {\n                _envelopes.shift();\n                envelope.messages = envelope.messages.concat(newEnvelope.messages);\n                this._debug('Coalesced', newEnvelope.messages.length, 'messages from request', newRequest.id);\n                continue;\n            }\n            break;\n        }\n    }\n\n    function _transportSend(envelope, request) {\n        this.transportSend(envelope, request);\n        request.expired = false;\n\n        if (!envelope.sync) {\n            var maxDelay = this.getConfiguration().maxNetworkDelay;\n            var delay = maxDelay;\n            if (request.metaConnect === true) {\n                delay += this.getAdvice().timeout;\n            }\n\n            this._debug('Transport', this.getType(), 'waiting at most', delay, 'ms for the response, maxNetworkDelay', maxDelay);\n\n            var self = this;\n            request.timeout = self.setTimeout(function() {\n                request.expired = true;\n                var errorMessage = 'Request ' + request.id + ' of transport ' + self.getType() + ' exceeded ' + delay + ' ms max network delay';\n                var failure = {\n                    reason: errorMessage\n                };\n                var xhr = request.xhr;\n                failure.httpCode = self.xhrStatus(xhr);\n                self.abortXHR(xhr);\n                self._debug(errorMessage);\n                self.complete(request, false, request.metaConnect);\n                envelope.onFailure(xhr, envelope.messages, failure);\n            }, delay);\n        }\n    }\n\n    function _queueSend(envelope) {\n        var requestId = ++_requestIds;\n        var request = {\n            id: requestId,\n            metaConnect: false,\n            envelope: envelope\n        };\n\n        // Consider the metaConnect requests which should always be present\n        if (_requests.length < this.getConfiguration().maxConnections - 1) {\n            _requests.push(request);\n            _transportSend.call(this, envelope, request);\n        } else {\n            this._debug('Transport', this.getType(), 'queueing request', requestId, 'envelope', envelope);\n            _envelopes.push([envelope, request]);\n        }\n    }\n\n    function _metaConnectComplete(request) {\n        var requestId = request.id;\n        this._debug('Transport', this.getType(), 'metaConnect complete, request', requestId);\n        if (_metaConnectRequest !== null && _metaConnectRequest.id !== requestId) {\n            throw 'Longpoll request mismatch, completing request ' + requestId;\n        }\n\n        // Reset metaConnect request\n        _metaConnectRequest = null;\n    }\n\n    function _complete(request, success) {\n        var index = Utils.inArray(request, _requests);\n        // The index can be negative if the request has been aborted\n        if (index >= 0) {\n            _requests.splice(index, 1);\n        }\n\n        if (_envelopes.length > 0) {\n            var envelopeAndRequest = _envelopes.shift();\n            var nextEnvelope = envelopeAndRequest[0];\n            var nextRequest = envelopeAndRequest[1];\n            this._debug('Transport dequeued request', nextRequest.id);\n            if (success) {\n                if (this.getConfiguration().autoBatch) {\n                    _coalesceEnvelopes.call(this, nextEnvelope);\n                }\n                _queueSend.call(this, nextEnvelope);\n                this._debug('Transport completed request', request.id, nextEnvelope);\n            } else {\n                // Keep the semantic of calling response callbacks asynchronously after the request\n                var self = this;\n                self.setTimeout(function() {\n                    self.complete(nextRequest, false, nextRequest.metaConnect);\n                    var failure = {\n                        reason: 'Previous request failed'\n                    };\n                    var xhr = nextRequest.xhr;\n                    failure.httpCode = self.xhrStatus(xhr);\n                    nextEnvelope.onFailure(xhr, nextEnvelope.messages, failure);\n                }, 0);\n            }\n        }\n    }\n\n    _self.complete = function(request, success, metaConnect) {\n        if (metaConnect) {\n            _metaConnectComplete.call(this, request);\n        } else {\n            _complete.call(this, request, success);\n        }\n    };\n\n    /**\n     * Performs the actual send depending on the transport type details.\n     * @param envelope the envelope to send\n     * @param request the request information\n     */\n    _self.transportSend = function(envelope, request) {\n        throw 'Abstract';\n    };\n\n    _self.transportSuccess = function(envelope, request, responses) {\n        if (!request.expired) {\n            this.clearTimeout(request.timeout);\n            this.complete(request, true, request.metaConnect);\n            if (responses && responses.length > 0) {\n                envelope.onSuccess(responses);\n            } else {\n                envelope.onFailure(request.xhr, envelope.messages, {\n                    httpCode: 204\n                });\n            }\n        }\n    };\n\n    _self.transportFailure = function(envelope, request, failure) {\n        if (!request.expired) {\n            this.clearTimeout(request.timeout);\n            this.complete(request, false, request.metaConnect);\n            envelope.onFailure(request.xhr, envelope.messages, failure);\n        }\n    };\n\n    function _metaConnectSend(envelope) {\n        if (_metaConnectRequest !== null) {\n            throw 'Concurrent metaConnect requests not allowed, request id=' + _metaConnectRequest.id + ' not yet completed';\n        }\n\n        var requestId = ++_requestIds;\n        this._debug('Transport', this.getType(), 'metaConnect send, request', requestId, 'envelope', envelope);\n        var request = {\n            id: requestId,\n            metaConnect: true,\n            envelope: envelope\n        };\n        _transportSend.call(this, envelope, request);\n        _metaConnectRequest = request;\n    }\n\n    _self.send = function(envelope, metaConnect) {\n        if (metaConnect) {\n            _metaConnectSend.call(this, envelope);\n        } else {\n            _queueSend.call(this, envelope);\n        }\n    };\n\n    _self.abort = function() {\n        _super.abort();\n        for (var i = 0; i < _requests.length; ++i) {\n            var request = _requests[i];\n            if (request) {\n                this._debug('Aborting request', request);\n                if (!this.abortXHR(request.xhr)) {\n                    this.transportFailure(request.envelope, request, {reason: 'abort'});\n                }\n            }\n        }\n        if (_metaConnectRequest) {\n            this._debug('Aborting metaConnect request', _metaConnectRequest);\n            if (!this.abortXHR(_metaConnectRequest.xhr)) {\n                this.transportFailure(_metaConnectRequest.envelope, _metaConnectRequest, {reason: 'abort'});\n            }\n        }\n        this.reset(true);\n    };\n\n    _self.reset = function(init) {\n        _super.reset(init);\n        _metaConnectRequest = null;\n        _requests = [];\n        _envelopes = [];\n    };\n\n    _self.abortXHR = function(xhr) {\n        if (xhr) {\n            try {\n                var state = xhr.readyState;\n                xhr.abort();\n                return state !== XMLHttpRequest.UNSENT;\n            } catch (x) {\n                this._debug(x);\n            }\n        }\n        return false;\n    };\n\n    _self.xhrStatus = function(xhr) {\n        if (xhr) {\n            try {\n                return xhr.status;\n            } catch (x) {\n                this._debug(x);\n            }\n        }\n        return -1;\n    };\n\n    return _self;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zetapush-cometd/lib/RequestTransport.js\n// module id = 102\n// module chunks = 0","var TransportRegistry = require('./TransportRegistry')\nvar Utils = require('./Utils')\n/**\n * The constructor for a CometD object, identified by an optional name.\n * The default name is the string 'default'.\n * In the rare case a page needs more than one Bayeux conversation,\n * a new instance can be created via:\n * <pre>\n * var bayeuxUrl2 = ...;\n *\n * // Dojo style\n * var cometd2 = new dojox.CometD('another_optional_name');\n *\n * // jQuery style\n * var cometd2 = new $.CometD('another_optional_name');\n *\n * cometd2.init({url: bayeuxUrl2});\n * </pre>\n * @param name the optional name of this cometd object\n */\nmodule.exports = function CometD(name) {\n    var _cometd = this;\n    var _name = name || 'default';\n    var _crossDomain = false;\n    var _transports = new TransportRegistry();\n    var _transport;\n    var _status = 'disconnected';\n    var _messageId = 0;\n    var _clientId = null;\n    var _batch = 0;\n    var _messageQueue = [];\n    var _internalBatch = false;\n    var _listeners = {};\n    var _backoff = 0;\n    var _scheduledSend = null;\n    var _extensions = [];\n    var _advice = {};\n    var _handshakeProps;\n    var _handshakeCallback;\n    var _callbacks = {};\n    var _remoteCalls = {};\n    var _reestablish = false;\n    var _connected = false;\n    var _unconnectTime = 0;\n    var _handshakeMessages = 0;\n    var _config = {\n        protocol: null,\n        stickyReconnect: true,\n        connectTimeout: 0,\n        maxConnections: 2,\n        backoffIncrement: 1000,\n        maxBackoff: 60000,\n        logLevel: 'info',\n        reverseIncomingExtensions: true,\n        maxNetworkDelay: 10000,\n        requestHeaders: {},\n        appendMessageTypeToURL: true,\n        autoBatch: false,\n        urls: {},\n        maxURILength: 2000,\n        advice: {\n            timeout: 60000,\n            interval: 0,\n            reconnect: 'retry',\n            maxInterval: 0\n        }\n    };\n\n    function _fieldValue(object, name) {\n        try {\n            return object[name];\n        } catch (x) {\n            return undefined;\n        }\n    }\n\n    /**\n     * Mixes in the given objects into the target object by copying the properties.\n     * @param deep if the copy must be deep\n     * @param target the target object\n     * @param objects the objects whose properties are copied into the target\n     */\n    this._mixin = function(deep, target, objects) {\n        var result = target || {};\n\n        // Skip first 2 parameters (deep and target), and loop over the others\n        for (var i = 2; i < arguments.length; ++i) {\n            var object = arguments[i];\n\n            if (object === undefined || object === null) {\n                continue;\n            }\n\n            for (var propName in object) {\n                if (object.hasOwnProperty(propName)) {\n                    var prop = _fieldValue(object, propName);\n                    var targ = _fieldValue(result, propName);\n\n                    // Avoid infinite loops\n                    if (prop === target) {\n                        continue;\n                    }\n                    // Do not mixin undefined values\n                    if (prop === undefined) {\n                        continue;\n                    }\n\n                    if (deep && typeof prop === 'object' && prop !== null) {\n                        if (prop instanceof Array) {\n                            result[propName] = this._mixin(deep, targ instanceof Array ? targ : [], prop);\n                        } else {\n                            var source = typeof targ === 'object' && !(targ instanceof Array) ? targ : {};\n                            result[propName] = this._mixin(deep, source, prop);\n                        }\n                    } else {\n                        result[propName] = prop;\n                    }\n                }\n            }\n        }\n\n        return result;\n    };\n\n    function _isString(value) {\n        return Utils.isString(value);\n    }\n\n    function _isFunction(value) {\n        if (value === undefined || value === null) {\n            return false;\n        }\n        return typeof value === 'function';\n    }\n\n    function _zeroPad(value, length) {\n        var result = '';\n        while (--length > 0) {\n            if (value >= Math.pow(10, length)) {\n                break;\n            }\n            result += '0';\n        }\n        result += value;\n        return result;\n    }\n\n    function _log(level, args) {\n        if ('undefined' !== typeof console) {\n            var logger = console[level];\n            if (_isFunction(logger)) {\n                var now = new Date();\n                [].splice.call(args, 0, 0, _zeroPad(now.getHours(), 2) + ':' + _zeroPad(now.getMinutes(), 2) + ':' +\n                        _zeroPad(now.getSeconds(), 2) + '.' + _zeroPad(now.getMilliseconds(), 3));\n                logger.apply(console, args);\n            }\n        }\n    }\n\n    this._warn = function() {\n        _log('warn', arguments);\n    };\n\n    this._info = function() {\n        if (_config.logLevel !== 'warn') {\n            _log('info', arguments);\n        }\n    };\n\n    this._debug = function() {\n        if (_config.logLevel === 'debug') {\n            _log('debug', arguments);\n        }\n    };\n\n    function _splitURL(url) {\n        // [1] = protocol://,\n        // [2] = host:port,\n        // [3] = host,\n        // [4] = IPv6_host,\n        // [5] = IPv4_host,\n        // [6] = :port,\n        // [7] = port,\n        // [8] = uri,\n        // [9] = rest (query / fragment)\n        return /(^https?:\\/\\/)?(((\\[[^\\]]+\\])|([^:\\/\\?#]+))(:(\\d+))?)?([^\\?#]*)(.*)?/.exec(url);\n    }\n\n    /**\n     * Returns whether the given hostAndPort is cross domain.\n     * The default implementation checks against window.location.host\n     * but this function can be overridden to make it work in non-browser\n     * environments.\n     *\n     * @param hostAndPort the host and port in format host:port\n     * @return whether the given hostAndPort is cross domain\n     */\n    this._isCrossDomain = function(hostAndPort) {\n        return hostAndPort && hostAndPort !== window.location.host;\n    };\n\n    function _configure(configuration) {\n        _cometd._debug('Configuring cometd object with', configuration);\n        // Support old style param, where only the Bayeux server URL was passed\n        if (_isString(configuration)) {\n            configuration = { url: configuration };\n        }\n        if (!configuration) {\n            configuration = {};\n        }\n\n        _config = _cometd._mixin(false, _config, configuration);\n\n        var url = _cometd.getURL();\n        if (!url) {\n            throw 'Missing required configuration parameter \\'url\\' specifying the Bayeux server URL';\n        }\n\n        // Check if we're cross domain.\n        var urlParts = _splitURL(url);\n        var hostAndPort = urlParts[2];\n        var uri = urlParts[8];\n        var afterURI = urlParts[9];\n        _crossDomain = _cometd._isCrossDomain(hostAndPort);\n\n        // Check if appending extra path is supported\n        if (_config.appendMessageTypeToURL) {\n            if (afterURI !== undefined && afterURI.length > 0) {\n                _cometd._info('Appending message type to URI ' + uri + afterURI + ' is not supported, disabling \\'appendMessageTypeToURL\\' configuration');\n                _config.appendMessageTypeToURL = false;\n            } else {\n                var uriSegments = uri.split('/');\n                var lastSegmentIndex = uriSegments.length - 1;\n                if (uri.match(/\\/$/)) {\n                    lastSegmentIndex -= 1;\n                }\n                if (uriSegments[lastSegmentIndex].indexOf('.') >= 0) {\n                    // Very likely the CometD servlet's URL pattern is mapped to an extension, such as *.cometd\n                    // It will be difficult to add the extra path in this case\n                    _cometd._info('Appending message type to URI ' + uri + ' is not supported, disabling \\'appendMessageTypeToURL\\' configuration');\n                    _config.appendMessageTypeToURL = false;\n                }\n            }\n        }\n    }\n\n    function _removeListener(subscription) {\n        if (subscription) {\n            var subscriptions = _listeners[subscription.channel];\n            if (subscriptions && subscriptions[subscription.id]) {\n                delete subscriptions[subscription.id];\n                _cometd._debug('Removed', subscription.listener ? 'listener' : 'subscription', subscription);\n            }\n        }\n    }\n\n    function _removeSubscription(subscription) {\n        if (subscription && !subscription.listener) {\n            _removeListener(subscription);\n        }\n    }\n\n    function _clearSubscriptions() {\n        for (var channel in _listeners) {\n            if (_listeners.hasOwnProperty(channel)) {\n                var subscriptions = _listeners[channel];\n                if (subscriptions) {\n                    for (var i = 0; i < subscriptions.length; ++i) {\n                        _removeSubscription(subscriptions[i]);\n                    }\n                }\n            }\n        }\n    }\n\n    function _setStatus(newStatus) {\n        if (_status !== newStatus) {\n            _cometd._debug('Status', _status, '->', newStatus);\n            _status = newStatus;\n        }\n    }\n\n    function _isDisconnected() {\n        return _status === 'disconnecting' || _status === 'disconnected';\n    }\n\n    function _nextMessageId() {\n        var result = ++_messageId;\n        return '' + result;\n    }\n\n    function _applyExtension(scope, callback, name, message, outgoing) {\n        try {\n            return callback.call(scope, message);\n        } catch (x) {\n            var handler = _cometd.onExtensionException;\n            if (_isFunction(handler)) {\n                _cometd._debug('Invoking extension exception handler', name, x);\n                try {\n                    handler.call(_cometd, x, name, outgoing, message);\n                } catch (xx) {\n                    _cometd._info('Exception during execution of extension exception handler', name, xx);\n                }\n            } else {\n                _cometd._info('Exception during execution of extension', name, x);\n            }\n            return message;\n        }\n    }\n\n    function _applyIncomingExtensions(message) {\n        for (var i = 0; i < _extensions.length; ++i) {\n            if (message === undefined || message === null) {\n                break;\n            }\n\n            var index = _config.reverseIncomingExtensions ? _extensions.length - 1 - i : i;\n            var extension = _extensions[index];\n            var callback = extension.extension.incoming;\n            if (_isFunction(callback)) {\n                var result = _applyExtension(extension.extension, callback, extension.name, message, false);\n                message = result === undefined ? message : result;\n            }\n        }\n        return message;\n    }\n\n    function _applyOutgoingExtensions(message) {\n        for (var i = 0; i < _extensions.length; ++i) {\n            if (message === undefined || message === null) {\n                break;\n            }\n\n            var extension = _extensions[i];\n            var callback = extension.extension.outgoing;\n            if (_isFunction(callback)) {\n                var result = _applyExtension(extension.extension, callback, extension.name, message, true);\n                message = result === undefined ? message : result;\n            }\n        }\n        return message;\n    }\n\n    function _notify(channel, message) {\n        var subscriptions = _listeners[channel];\n        if (subscriptions && subscriptions.length > 0) {\n            for (var i = 0; i < subscriptions.length; ++i) {\n                var subscription = subscriptions[i];\n                // Subscriptions may come and go, so the array may have 'holes'\n                if (subscription) {\n                    try {\n                        subscription.callback.call(subscription.scope, message);\n                    } catch (x) {\n                        var handler = _cometd.onListenerException;\n                        if (_isFunction(handler)) {\n                            _cometd._debug('Invoking listener exception handler', subscription, x);\n                            try {\n                                handler.call(_cometd, x, subscription, subscription.listener, message);\n                            } catch (xx) {\n                                _cometd._info('Exception during execution of listener exception handler', subscription, xx);\n                            }\n                        } else {\n                            _cometd._info('Exception during execution of listener', subscription, message, x);\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    function _notifyListeners(channel, message) {\n        // Notify direct listeners\n        _notify(channel, message);\n\n        // Notify the globbing listeners\n        var channelParts = channel.split('/');\n        var last = channelParts.length - 1;\n        for (var i = last; i > 0; --i) {\n            var channelPart = channelParts.slice(0, i).join('/') + '/*';\n            // We don't want to notify /foo/* if the channel is /foo/bar/baz,\n            // so we stop at the first non recursive globbing\n            if (i === last) {\n                _notify(channelPart, message);\n            }\n            // Add the recursive globber and notify\n            channelPart += '*';\n            _notify(channelPart, message);\n        }\n    }\n\n    function _cancelDelayedSend() {\n        if (_scheduledSend !== null) {\n            Utils.clearTimeout(_scheduledSend);\n        }\n        _scheduledSend = null;\n    }\n\n    function _delayedSend(operation, delay) {\n        if ('undefined' === typeof delay) {\n          delay = _backoff\n        }\n        _cancelDelayedSend();\n        var time = _advice.interval + delay;\n        _cometd._debug('Function scheduled in', time, 'ms, interval =', _advice.interval, 'backoff =', _backoff, operation);\n        _scheduledSend = Utils.setTimeout(_cometd, operation, time);\n    }\n\n    // Needed to break cyclic dependencies between function definitions\n    var _handleMessages;\n    var _handleFailure;\n\n    /**\n     * Delivers the messages to the CometD server\n     * @param sync whether the send is synchronous\n     * @param messages the array of messages to send\n     * @param metaConnect true if this send is on /meta/connect\n     * @param extraPath an extra path to append to the Bayeux server URL\n     */\n    function _send(sync, messages, metaConnect, extraPath) {\n        // We must be sure that the messages have a clientId.\n        // This is not guaranteed since the handshake may take time to return\n        // (and hence the clientId is not known yet) and the application\n        // may create other messages.\n        for (var i = 0; i < messages.length; ++i) {\n            var message = messages[i];\n            var messageId = message.id;\n\n            if (_clientId) {\n                message.clientId = _clientId;\n            }\n\n            message = _applyOutgoingExtensions(message);\n            if (message !== undefined && message !== null) {\n                // Extensions may have modified the message id, but we need to own it.\n                message.id = messageId;\n                messages[i] = message;\n            } else {\n                delete _callbacks[messageId];\n                messages.splice(i--, 1);\n            }\n        }\n\n        if (messages.length === 0) {\n            return;\n        }\n\n        var url = _cometd.getURL();\n        if (_config.appendMessageTypeToURL) {\n            // If url does not end with '/', then append it\n            if (!url.match(/\\/$/)) {\n                url = url + '/';\n            }\n            if (extraPath) {\n                url = url + extraPath;\n            }\n        }\n\n        var envelope = {\n            url: url,\n            sync: sync,\n            messages: messages,\n            onSuccess: function(rcvdMessages) {\n                try {\n                    _handleMessages.call(_cometd, rcvdMessages);\n                } catch (x) {\n                    _cometd._info('Exception during handling of messages', x);\n                }\n            },\n            onFailure: function(conduit, messages, failure) {\n                try {\n                    var transport = _cometd.getTransport();\n                    failure.connectionType = transport ? transport.getType() : \"unknown\";\n                    _handleFailure.call(_cometd, conduit, messages, failure);\n                } catch (x) {\n                    _cometd._info('Exception during handling of failure', x);\n                }\n            }\n        };\n        _cometd._debug('Send', envelope);\n        _transport.send(envelope, metaConnect);\n    }\n\n    function _queueSend(message) {\n        if (_batch > 0 || _internalBatch === true) {\n            _messageQueue.push(message);\n        } else {\n            _send(false, [message], false);\n        }\n    }\n\n    /**\n     * Sends a complete bayeux message.\n     * This method is exposed as a public so that extensions may use it\n     * to send bayeux message directly, for example in case of re-sending\n     * messages that have already been sent but that for some reason must\n     * be resent.\n     */\n    this.send = _queueSend;\n\n    function _resetBackoff() {\n        _backoff = 0;\n    }\n\n    function _increaseBackoff() {\n        if (_backoff < _config.maxBackoff) {\n            _backoff += _config.backoffIncrement;\n        }\n        return _backoff;\n    }\n\n    /**\n     * Starts a the batch of messages to be sent in a single request.\n     * @see #_endBatch(sendMessages)\n     */\n    function _startBatch() {\n        ++_batch;\n        _cometd._debug('Starting batch, depth', _batch);\n    }\n\n    function _flushBatch() {\n        var messages = _messageQueue;\n        _messageQueue = [];\n        if (messages.length > 0) {\n            _send(false, messages, false);\n        }\n    }\n\n    /**\n     * Ends the batch of messages to be sent in a single request,\n     * optionally sending messages present in the message queue depending\n     * on the given argument.\n     * @see #_startBatch()\n     */\n    function _endBatch() {\n        --_batch;\n        _cometd._debug('Ending batch, depth', _batch);\n        if (_batch < 0) {\n            throw 'Calls to startBatch() and endBatch() are not paired';\n        }\n\n        if (_batch === 0 && !_isDisconnected() && !_internalBatch) {\n            _flushBatch();\n        }\n    }\n\n    /**\n     * Sends the connect message\n     */\n    function _connect() {\n        if (!_isDisconnected()) {\n            var bayeuxMessage = {\n                id: _nextMessageId(),\n                channel: '/meta/connect',\n                connectionType: _transport.getType()\n            };\n\n            // In case of reload or temporary loss of connection\n            // we want the next successful connect to return immediately\n            // instead of being held by the server, so that connect listeners\n            // can be notified that the connection has been re-established\n            if (!_connected) {\n                bayeuxMessage.advice = { timeout: 0 };\n            }\n\n            _setStatus('connecting');\n            _cometd._debug('Connect sent', bayeuxMessage);\n            _send(false, [bayeuxMessage], true, 'connect');\n            _setStatus('connected');\n        }\n    }\n\n    function _delayedConnect(delay) {\n        _setStatus('connecting');\n        _delayedSend(function() {\n            _connect();\n        }, delay);\n    }\n\n    function _updateAdvice(newAdvice) {\n        if (newAdvice) {\n            _advice = _cometd._mixin(false, {}, _config.advice, newAdvice);\n            _cometd._debug('New advice', _advice);\n        }\n    }\n\n    function _disconnect(abort) {\n        _cancelDelayedSend();\n        if (abort && _transport) {\n            _transport.abort();\n        }\n        _clientId = null;\n        _setStatus('disconnected');\n        _batch = 0;\n        _resetBackoff();\n        _transport = null;\n\n        // Fail any existing queued message\n        if (_messageQueue.length > 0) {\n            var messages = _messageQueue;\n            _messageQueue = [];\n            _handleFailure.call(_cometd, undefined, messages, {\n                reason: 'Disconnected'\n            });\n        }\n    }\n\n    function _notifyTransportFailure(oldTransport, newTransport, failure) {\n        var handler = _cometd.onTransportException;\n        if (_isFunction(handler)) {\n            _cometd._debug('Invoking transport exception handler', oldTransport, newTransport, failure);\n            try {\n                handler.call(_cometd, failure, oldTransport, newTransport);\n            } catch (x) {\n                _cometd._info('Exception during execution of transport exception handler', x);\n            }\n        }\n    }\n\n    /**\n     * Sends the initial handshake message\n     */\n    function _handshake(handshakeProps, handshakeCallback) {\n        if (_isFunction(handshakeProps)) {\n            handshakeCallback = handshakeProps;\n            handshakeProps = undefined;\n        }\n\n        _clientId = null;\n\n        _clearSubscriptions();\n\n        // Reset the transports if we're not retrying the handshake\n        if (_isDisconnected()) {\n            _transports.reset(true);\n            _updateAdvice(_config.advice);\n        } else {\n            // We are retrying the handshake, either because another handshake failed\n            // and we're backing off, or because the server timed us out and asks us to\n            // re-handshake: in both cases, make sure that if the handshake succeeds\n            // the next action is a connect.\n            _updateAdvice(_cometd._mixin(false, _advice, {reconnect: 'retry'}));\n        }\n\n        _batch = 0;\n\n        // Mark the start of an internal batch.\n        // This is needed because handshake and connect are async.\n        // It may happen that the application calls init() then subscribe()\n        // and the subscribe message is sent before the connect message, if\n        // the subscribe message is not held until the connect message is sent.\n        // So here we start a batch to hold temporarily any message until\n        // the connection is fully established.\n        _internalBatch = true;\n\n        // Save the properties provided by the user, so that\n        // we can reuse them during automatic re-handshake\n        _handshakeProps = handshakeProps;\n        _handshakeCallback = handshakeCallback;\n\n        var version = '1.0';\n\n        // Figure out the transports to send to the server\n        var url = _cometd.getURL();\n        var transportTypes = _transports.findTransportTypes(version, _crossDomain, url);\n\n        var bayeuxMessage = {\n            id: _nextMessageId(),\n            version: version,\n            minimumVersion: version,\n            channel: '/meta/handshake',\n            supportedConnectionTypes: transportTypes,\n            advice: {\n                timeout: _advice.timeout,\n                interval: _advice.interval\n            }\n        };\n        // Do not allow the user to override important fields.\n        var message = _cometd._mixin(false, {}, _handshakeProps, bayeuxMessage);\n\n        // Save the callback.\n        _cometd._putCallback(message.id, handshakeCallback);\n\n        // Pick up the first available transport as initial transport\n        // since we don't know if the server supports it\n        if (!_transport) {\n            _transport = _transports.negotiateTransport(transportTypes, version, _crossDomain, url);\n            if (!_transport) {\n                var failure = 'Could not find initial transport among: ' + _transports.getTransportTypes();\n                _cometd._warn(failure);\n                throw failure;\n            }\n        }\n\n        _cometd._debug('Initial transport is', _transport.getType());\n\n        // We started a batch to hold the application messages,\n        // so here we must bypass it and send immediately.\n        _setStatus('handshaking');\n        _cometd._debug('Handshake sent', message);\n        _send(false, [message], false, 'handshake');\n    }\n\n    function _delayedHandshake(delay) {\n        _setStatus('handshaking');\n\n        // We will call _handshake() which will reset _clientId, but we want to avoid\n        // that between the end of this method and the call to _handshake() someone may\n        // call publish() (or other methods that call _queueSend()).\n        _internalBatch = true;\n\n        _delayedSend(function() {\n            _handshake(_handshakeProps, _handshakeCallback);\n        }, delay);\n    }\n\n    function _notifyCallback(callback, message) {\n        try {\n            callback.call(_cometd, message);\n        } catch (x) {\n            var handler = _cometd.onCallbackException;\n            if (_isFunction(handler)) {\n                _cometd._debug('Invoking callback exception handler', x);\n                try {\n                    handler.call(_cometd, x, message);\n                } catch (xx) {\n                    _cometd._info('Exception during execution of callback exception handler', xx);\n                }\n            } else {\n                _cometd._info('Exception during execution of message callback', x);\n            }\n        }\n    }\n\n    this._getCallback = function(messageId) {\n        return _callbacks[messageId];\n    };\n\n    this._putCallback = function(messageId, callback) {\n        var result = this._getCallback(messageId);\n        if (_isFunction(callback)) {\n            _callbacks[messageId] = callback;\n        }\n        return result;\n    };\n\n    function _handleCallback(message) {\n        var callback = _cometd._getCallback([message.id]);\n        if (_isFunction(callback)) {\n            delete _callbacks[message.id];\n            _notifyCallback(callback, message);\n        }\n    }\n\n    function _handleRemoteCall(message) {\n        var context = _remoteCalls[message.id];\n        delete _remoteCalls[message.id];\n        _cometd._debug('Handling remote call response for', message, 'with context', context);\n        if (context) {\n            // Clear the timeout, if present.\n            var timeout = context.timeout;\n            if (timeout) {\n                Utils.clearTimeout(timeout);\n            }\n\n            var callback = context.callback;\n            if (_isFunction(callback)) {\n                _notifyCallback(callback, message);\n                return true;\n            }\n        }\n        return false;\n    }\n\n    function _failHandshake(message) {\n        _handleCallback(message);\n        _notifyListeners('/meta/handshake', message);\n        _notifyListeners('/meta/unsuccessful', message);\n\n        // Only try again if we haven't been disconnected and\n        // the advice permits us to retry the handshake\n        var retry = !_isDisconnected() && _advice.reconnect !== 'none';\n        if (retry) {\n            _increaseBackoff();\n            _delayedHandshake();\n        } else {\n            _disconnect(true);\n        }\n    }\n\n    function _handshakeResponse(message) {\n        if (message.successful) {\n            // Save clientId, figure out transport, then follow the advice to connect\n            _clientId = message.clientId;\n\n            var url = _cometd.getURL();\n            var newTransport = _transports.negotiateTransport(message.supportedConnectionTypes, message.version, _crossDomain, url);\n            if (newTransport === null) {\n                var failure = 'Could not negotiate transport with server; client=[' +\n                    _transports.findTransportTypes(message.version, _crossDomain, url) +\n                    '], server=[' + message.supportedConnectionTypes + ']';\n                var oldTransport = _cometd.getTransport();\n                _notifyTransportFailure(oldTransport.getType(), null, {\n                    reason: failure,\n                    connectionType: oldTransport.getType(),\n                    transport: oldTransport\n                });\n                _cometd._warn(failure);\n                _disconnect(true);\n                return;\n            } else if (_transport !== newTransport) {\n                _cometd._debug('Transport', _transport.getType(), '->', newTransport.getType());\n                _transport = newTransport;\n            }\n\n            // End the internal batch and allow held messages from the application\n            // to go to the server (see _handshake() where we start the internal batch).\n            _internalBatch = false;\n            _flushBatch();\n\n            // Here the new transport is in place, as well as the clientId, so\n            // the listeners can perform a publish() if they want.\n            // Notify the listeners before the connect below.\n            message.reestablish = _reestablish;\n            _reestablish = true;\n\n            _handleCallback(message);\n            _notifyListeners('/meta/handshake', message);\n\n            var action = _isDisconnected() ? 'none' : _advice.reconnect;\n            switch (action) {\n                case 'retry':\n                    _resetBackoff();\n                    _delayedConnect();\n                    break;\n                case 'none':\n                    _disconnect(true);\n                    break;\n                default:\n                    throw 'Unrecognized advice action ' + action;\n            }\n        } else {\n            _failHandshake(message);\n        }\n    }\n\n    function _handshakeFailure(message) {\n        var version = '1.0';\n        var url = _cometd.getURL();\n        var oldTransport = _cometd.getTransport();\n        var transportTypes = _transports.findTransportTypes(version, _crossDomain, url);\n        var newTransport = _transports.negotiateTransport(transportTypes, version, _crossDomain, url);\n        if (!newTransport) {\n            _notifyTransportFailure(oldTransport.getType(), null, message.failure);\n            _cometd._warn('Could not negotiate transport; client=[' + transportTypes + ']');\n            _disconnect(true);\n            _failHandshake(message);\n        } else {\n            _cometd._debug('Transport', oldTransport.getType(), '->', newTransport.getType());\n            _notifyTransportFailure(oldTransport.getType(), newTransport.getType(), message.failure);\n            _failHandshake(message);\n            _transport = newTransport;\n        }\n    }\n\n    function _failConnect(message) {\n        // Notify the listeners after the status change but before the next action\n        _notifyListeners('/meta/connect', message);\n        _notifyListeners('/meta/unsuccessful', message);\n\n        // This may happen when the server crashed, the current clientId\n        // will be invalid, and the server will ask to handshake again\n        // Listeners can call disconnect(), so check the state after they run\n        var action = _isDisconnected() ? 'none' : _advice.reconnect;\n        switch (action) {\n            case 'retry':\n                _delayedConnect();\n                _increaseBackoff();\n                break;\n            case 'handshake':\n                // The current transport may be failed (e.g. network disconnection)\n                // Reset the transports so the new handshake picks up the right one\n                _transports.reset(true);\n                _resetBackoff();\n                _delayedHandshake();\n                break;\n            case 'none':\n                _disconnect(true);\n                break;\n            default:\n                throw 'Unrecognized advice action' + action;\n        }\n    }\n\n    function _connectResponse(message) {\n        _connected = message.successful;\n\n        if (_connected) {\n            _notifyListeners('/meta/connect', message);\n\n            // Normally, the advice will say \"reconnect: 'retry', interval: 0\"\n            // and the server will hold the request, so when a response returns\n            // we immediately call the server again (long polling)\n            // Listeners can call disconnect(), so check the state after they run\n            var action = _isDisconnected() ? 'none' : _advice.reconnect;\n            switch (action) {\n                case 'retry':\n                    _resetBackoff();\n                    _delayedConnect();\n                    break;\n                case 'none':\n                    // Wait for the /meta/disconnect to arrive.\n                    _disconnect(false);\n                    break;\n                default:\n                    throw 'Unrecognized advice action ' + action;\n            }\n        } else {\n            _failConnect(message);\n        }\n    }\n\n    function _connectFailure(message) {\n        _connected = false;\n        _failConnect(message);\n    }\n\n    function _failDisconnect(message) {\n        _disconnect(true);\n        _handleCallback(message);\n        _notifyListeners('/meta/disconnect', message);\n        _notifyListeners('/meta/unsuccessful', message);\n    }\n\n    function _disconnectResponse(message) {\n        if (message.successful) {\n            // Wait for the /meta/connect to arrive.\n            _disconnect(false);\n            _handleCallback(message);\n            _notifyListeners('/meta/disconnect', message);\n        } else {\n            _failDisconnect(message);\n        }\n    }\n\n    function _disconnectFailure(message) {\n        _failDisconnect(message);\n    }\n\n    function _failSubscribe(message) {\n        var subscriptions = _listeners[message.subscription];\n        if (subscriptions) {\n            for (var i = subscriptions.length - 1; i >= 0; --i) {\n                var subscription = subscriptions[i];\n                if (subscription && !subscription.listener) {\n                    delete subscriptions[i];\n                    _cometd._debug('Removed failed subscription', subscription);\n                    break;\n                }\n            }\n        }\n        _handleCallback(message);\n        _notifyListeners('/meta/subscribe', message);\n        _notifyListeners('/meta/unsuccessful', message);\n    }\n\n    function _subscribeResponse(message) {\n        if (message.successful) {\n            _handleCallback(message);\n            _notifyListeners('/meta/subscribe', message);\n        } else {\n            _failSubscribe(message);\n        }\n    }\n\n    function _subscribeFailure(message) {\n        _failSubscribe(message);\n    }\n\n    function _failUnsubscribe(message) {\n        _handleCallback(message);\n        _notifyListeners('/meta/unsubscribe', message);\n        _notifyListeners('/meta/unsuccessful', message);\n    }\n\n    function _unsubscribeResponse(message) {\n        if (message.successful) {\n            _handleCallback(message);\n            _notifyListeners('/meta/unsubscribe', message);\n        } else {\n            _failUnsubscribe(message);\n        }\n    }\n\n    function _unsubscribeFailure(message) {\n        _failUnsubscribe(message);\n    }\n\n    function _failMessage(message) {\n        if (!_handleRemoteCall(message)) {\n            _handleCallback(message);\n            _notifyListeners('/meta/publish', message);\n            _notifyListeners('/meta/unsuccessful', message);\n        }\n    }\n\n    function _messageResponse(message) {\n        if (message.data !== undefined) {\n            if (!_handleRemoteCall(message)) {\n                _notifyListeners(message.channel, message);\n                if (_handshakeMessages > 0) {\n                    --_handshakeMessages;\n                    if (_handshakeMessages === 0) {\n                        _cometd._debug('Processed last handshake-delivered message');\n                        _delayedConnect(0);\n                    }\n                }\n            }\n        } else {\n            if (message.successful === undefined) {\n                _cometd._warn('Unknown Bayeux Message', message);\n            } else {\n                if (message.successful) {\n                    _handleCallback(message);\n                    _notifyListeners('/meta/publish', message);\n                } else {\n                    _failMessage(message);\n                }\n            }\n        }\n    }\n\n    function _messageFailure(failure) {\n        _failMessage(failure);\n    }\n\n    function _receive(message) {\n        _unconnectTime = 0;\n\n        message = _applyIncomingExtensions(message);\n        if (message === undefined || message === null) {\n            return;\n        }\n\n        _updateAdvice(message.advice);\n\n        var channel = message.channel;\n        switch (channel) {\n            case '/meta/handshake':\n                _handshakeResponse(message);\n                break;\n            case '/meta/connect':\n                _connectResponse(message);\n                break;\n            case '/meta/disconnect':\n                _disconnectResponse(message);\n                break;\n            case '/meta/subscribe':\n                _subscribeResponse(message);\n                break;\n            case '/meta/unsubscribe':\n                _unsubscribeResponse(message);\n                break;\n            default:\n                _messageResponse(message);\n                break;\n        }\n    }\n\n    /**\n     * Receives a message.\n     * This method is exposed as a public so that extensions may inject\n     * messages simulating that they had been received.\n     */\n    this.receive = _receive;\n\n    _handleMessages = function(rcvdMessages) {\n        _cometd._debug('Received', rcvdMessages);\n\n        for (var i = 0; i < rcvdMessages.length; ++i) {\n            var message = rcvdMessages[i];\n            _receive(message);\n        }\n    };\n\n    _handleFailure = function(conduit, messages, failure) {\n        _cometd._debug('handleFailure', conduit, messages, failure);\n\n        failure.transport = conduit;\n        for (var i = 0; i < messages.length; ++i) {\n            var message = messages[i];\n            var failureMessage = {\n                id: message.id,\n                successful: false,\n                channel: message.channel,\n                failure: failure\n            };\n            failure.message = message;\n            switch (message.channel) {\n                case '/meta/handshake':\n                    _handshakeFailure(failureMessage);\n                    break;\n                case '/meta/connect':\n                    _connectFailure(failureMessage);\n                    break;\n                case '/meta/disconnect':\n                    _disconnectFailure(failureMessage);\n                    break;\n                case '/meta/subscribe':\n                    failureMessage.subscription = message.subscription;\n                    _subscribeFailure(failureMessage);\n                    break;\n                case '/meta/unsubscribe':\n                    failureMessage.subscription = message.subscription;\n                    _unsubscribeFailure(failureMessage);\n                    break;\n                default:\n                    _messageFailure(failureMessage);\n                    break;\n            }\n        }\n    };\n\n    function _hasSubscriptions(channel) {\n        var subscriptions = _listeners[channel];\n        if (subscriptions) {\n            for (var i = 0; i < subscriptions.length; ++i) {\n                if (subscriptions[i]) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n\n    function _resolveScopedCallback(scope, callback) {\n        var delegate = {\n            scope: scope,\n            method: callback\n        };\n        if (_isFunction(scope)) {\n            delegate.scope = undefined;\n            delegate.method = scope;\n        } else {\n            if (_isString(callback)) {\n                if (!scope) {\n                    throw 'Invalid scope ' + scope;\n                }\n                delegate.method = scope[callback];\n                if (!_isFunction(delegate.method)) {\n                    throw 'Invalid callback ' + callback + ' for scope ' + scope;\n                }\n            } else if (!_isFunction(callback)) {\n                throw 'Invalid callback ' + callback;\n            }\n        }\n        return delegate;\n    }\n\n    function _addListener(channel, scope, callback, isListener) {\n        // The data structure is a map<channel, subscription[]>, where each subscription\n        // holds the callback to be called and its scope.\n\n        var delegate = _resolveScopedCallback(scope, callback);\n        _cometd._debug('Adding', isListener ? 'listener' : 'subscription', 'on', channel, 'with scope', delegate.scope, 'and callback', delegate.method);\n\n        var subscription = {\n            channel: channel,\n            scope: delegate.scope,\n            callback: delegate.method,\n            listener: isListener\n        };\n\n        var subscriptions = _listeners[channel];\n        if (!subscriptions) {\n            subscriptions = [];\n            _listeners[channel] = subscriptions;\n        }\n\n        // Pushing onto an array appends at the end and returns the id associated with the element increased by 1.\n        // Note that if:\n        // a.push('a'); var hb=a.push('b'); delete a[hb-1]; var hc=a.push('c');\n        // then:\n        // hc==3, a.join()=='a',,'c', a.length==3\n        subscription.id = subscriptions.push(subscription) - 1;\n\n        _cometd._debug('Added', isListener ? 'listener' : 'subscription', subscription);\n\n        // For backward compatibility: we used to return [channel, subscription.id]\n        subscription[0] = channel;\n        subscription[1] = subscription.id;\n\n        return subscription;\n    }\n\n    //\n    // PUBLIC API\n    //\n\n    /**\n     * Registers the given transport under the given transport type.\n     * The optional index parameter specifies the \"priority\" at which the\n     * transport is registered (where 0 is the max priority).\n     * If a transport with the same type is already registered, this function\n     * does nothing and returns false.\n     * @param type the transport type\n     * @param transport the transport object\n     * @param index the index at which this transport is to be registered\n     * @return true if the transport has been registered, false otherwise\n     * @see #unregisterTransport(type)\n     */\n    this.registerTransport = function(type, transport, index) {\n        var result = _transports.add(type, transport, index);\n        if (result) {\n            this._debug('Registered transport', type);\n\n            if (_isFunction(transport.registered)) {\n                transport.registered(type, this);\n            }\n        }\n        return result;\n    };\n\n    /**\n     * Unregisters the transport with the given transport type.\n     * @param type the transport type to unregister\n     * @return the transport that has been unregistered,\n     * or null if no transport was previously registered under the given transport type\n     */\n    this.unregisterTransport = function(type) {\n        var transport = _transports.remove(type);\n        if (transport !== null) {\n            this._debug('Unregistered transport', type);\n\n            if (_isFunction(transport.unregistered)) {\n                transport.unregistered();\n            }\n        }\n        return transport;\n    };\n\n    this.unregisterTransports = function() {\n        _transports.clear();\n    };\n\n    /**\n     * @return an array of all registered transport types\n     */\n    this.getTransportTypes = function() {\n        return _transports.getTransportTypes();\n    };\n\n    this.findTransport = function(name) {\n        return _transports.find(name);\n    };\n\n    /**\n     * @returns the TransportRegistry object\n     */\n    this.getTransportRegistry = function() {\n        return _transports;\n    };\n\n    /**\n     * Configures the initial Bayeux communication with the Bayeux server.\n     * Configuration is passed via an object that must contain a mandatory field <code>url</code>\n     * of type string containing the URL of the Bayeux server.\n     * @param configuration the configuration object\n     */\n    this.configure = function(configuration) {\n        _configure.call(this, configuration);\n    };\n\n    /**\n     * Configures and establishes the Bayeux communication with the Bayeux server\n     * via a handshake and a subsequent connect.\n     * @param configuration the configuration object\n     * @param handshakeProps an object to be merged with the handshake message\n     * @see #configure(configuration)\n     * @see #handshake(handshakeProps)\n     */\n    this.init = function(configuration, handshakeProps) {\n        this.configure(configuration);\n        this.handshake(handshakeProps);\n    };\n\n    /**\n     * Establishes the Bayeux communication with the Bayeux server\n     * via a handshake and a subsequent connect.\n     * @param handshakeProps an object to be merged with the handshake message\n     * @param handshakeCallback a function to be invoked when the handshake is acknowledged\n     */\n    this.handshake = function(handshakeProps, handshakeCallback) {\n        _setStatus('disconnected');\n        _reestablish = false;\n        _handshake(handshakeProps, handshakeCallback);\n    };\n\n    /**\n     * Disconnects from the Bayeux server.\n     * It is possible to suggest to attempt a synchronous disconnect, but this feature\n     * may only be available in certain transports (for example, long-polling may support\n     * it, callback-polling certainly does not).\n     * @param sync whether attempt to perform a synchronous disconnect\n     * @param disconnectProps an object to be merged with the disconnect message\n     * @param disconnectCallback a function to be invoked when the disconnect is acknowledged\n     */\n    this.disconnect = function(sync, disconnectProps, disconnectCallback) {\n        if (_isDisconnected()) {\n            return;\n        }\n\n        if (typeof sync !== 'boolean') {\n            disconnectCallback = disconnectProps;\n            disconnectProps = sync;\n            sync = false;\n        }\n        if (_isFunction(disconnectProps)) {\n            disconnectCallback = disconnectProps;\n            disconnectProps = undefined;\n        }\n\n        var bayeuxMessage = {\n            id: _nextMessageId(),\n            channel: '/meta/disconnect'\n        };\n        // Do not allow the user to override important fields.\n        var message = this._mixin(false, {}, disconnectProps, bayeuxMessage);\n\n        // Save the callback.\n        _cometd._putCallback(message.id, disconnectCallback);\n\n        _setStatus('disconnecting');\n        _send(sync === true, [message], false, 'disconnect');\n    };\n\n    /**\n     * Marks the start of a batch of application messages to be sent to the server\n     * in a single request, obtaining a single response containing (possibly) many\n     * application reply messages.\n     * Messages are held in a queue and not sent until {@link #endBatch()} is called.\n     * If startBatch() is called multiple times, then an equal number of endBatch()\n     * calls must be made to close and send the batch of messages.\n     * @see #endBatch()\n     */\n    this.startBatch = function() {\n        _startBatch();\n    };\n\n    /**\n     * Marks the end of a batch of application messages to be sent to the server\n     * in a single request.\n     * @see #startBatch()\n     */\n    this.endBatch = function() {\n        _endBatch();\n    };\n\n    /**\n     * Executes the given callback in the given scope, surrounded by a {@link #startBatch()}\n     * and {@link #endBatch()} calls.\n     * @param scope the scope of the callback, may be omitted\n     * @param callback the callback to be executed within {@link #startBatch()} and {@link #endBatch()} calls\n     */\n    this.batch = function(scope, callback) {\n        var delegate = _resolveScopedCallback(scope, callback);\n        this.startBatch();\n        try {\n            delegate.method.call(delegate.scope);\n            this.endBatch();\n        } catch (x) {\n            this._info('Exception during execution of batch', x);\n            this.endBatch();\n            throw x;\n        }\n    };\n\n    /**\n     * Adds a listener for bayeux messages, performing the given callback in the given scope\n     * when a message for the given channel arrives.\n     * @param channel the channel the listener is interested to\n     * @param scope the scope of the callback, may be omitted\n     * @param callback the callback to call when a message is sent to the channel\n     * @returns the subscription handle to be passed to {@link #removeListener(object)}\n     * @see #removeListener(subscription)\n     */\n    this.addListener = function(channel, scope, callback) {\n        if (arguments.length < 2) {\n            throw 'Illegal arguments number: required 2, got ' + arguments.length;\n        }\n        if (!_isString(channel)) {\n            throw 'Illegal argument type: channel must be a string';\n        }\n\n        return _addListener(channel, scope, callback, true);\n    };\n\n    /**\n     * Removes the subscription obtained with a call to {@link #addListener(string, object, function)}.\n     * @param subscription the subscription to unsubscribe.\n     * @see #addListener(channel, scope, callback)\n     */\n    this.removeListener = function(subscription) {\n        // Beware of subscription.id == 0, which is falsy => cannot use !subscription.id\n        if (!subscription || !subscription.channel || !(\"id\" in subscription)) {\n            throw 'Invalid argument: expected subscription, not ' + subscription;\n        }\n\n        _removeListener(subscription);\n    };\n\n    /**\n     * Removes all listeners registered with {@link #addListener(channel, scope, callback)} or\n     * {@link #subscribe(channel, scope, callback)}.\n     */\n    this.clearListeners = function() {\n        _listeners = {};\n    };\n\n    /**\n     * Subscribes to the given channel, performing the given callback in the given scope\n     * when a message for the channel arrives.\n     * @param channel the channel to subscribe to\n     * @param scope the scope of the callback, may be omitted\n     * @param callback the callback to call when a message is sent to the channel\n     * @param subscribeProps an object to be merged with the subscribe message\n     * @param subscribeCallback a function to be invoked when the subscription is acknowledged\n     * @return the subscription handle to be passed to {@link #unsubscribe(object)}\n     */\n    this.subscribe = function(channel, scope, callback, subscribeProps, subscribeCallback) {\n        if (arguments.length < 2) {\n            throw 'Illegal arguments number: required 2, got ' + arguments.length;\n        }\n        if (!_isString(channel)) {\n            throw 'Illegal argument type: channel must be a string';\n        }\n        if (_isDisconnected()) {\n            throw 'Illegal state: already disconnected';\n        }\n\n        // Normalize arguments\n        if (_isFunction(scope)) {\n            subscribeCallback = subscribeProps;\n            subscribeProps = callback;\n            callback = scope;\n            scope = undefined;\n        }\n        if (_isFunction(subscribeProps)) {\n            subscribeCallback = subscribeProps;\n            subscribeProps = undefined;\n        }\n\n        // Only send the message to the server if this client has not yet subscribed to the channel\n        var send = !_hasSubscriptions(channel);\n\n        var subscription = _addListener(channel, scope, callback, false);\n\n        if (send) {\n            // Send the subscription message after the subscription registration to avoid\n            // races where the server would send a message to the subscribers, but here\n            // on the client the subscription has not been added yet to the data structures\n            var bayeuxMessage = {\n                id: _nextMessageId(),\n                channel: '/meta/subscribe',\n                subscription: channel\n            };\n            // Do not allow the user to override important fields.\n            var message = this._mixin(false, {}, subscribeProps, bayeuxMessage);\n\n            // Save the callback.\n            _cometd._putCallback(message.id, subscribeCallback);\n\n            _queueSend(message);\n        }\n\n        return subscription;\n    };\n\n    /**\n     * Unsubscribes the subscription obtained with a call to {@link #subscribe(string, object, function)}.\n     * @param subscription the subscription to unsubscribe.\n     * @param unsubscribeProps an object to be merged with the unsubscribe message\n     * @param unsubscribeCallback a function to be invoked when the unsubscription is acknowledged\n     */\n    this.unsubscribe = function(subscription, unsubscribeProps, unsubscribeCallback) {\n        if (arguments.length < 1) {\n            throw 'Illegal arguments number: required 1, got ' + arguments.length;\n        }\n        if (_isDisconnected()) {\n            throw 'Illegal state: already disconnected';\n        }\n\n        if (_isFunction(unsubscribeProps)) {\n            unsubscribeCallback = unsubscribeProps;\n            unsubscribeProps = undefined;\n        }\n\n        // Remove the local listener before sending the message\n        // This ensures that if the server fails, this client does not get notifications\n        this.removeListener(subscription);\n\n        var channel = subscription.channel;\n        // Only send the message to the server if this client unsubscribes the last subscription\n        if (!_hasSubscriptions(channel)) {\n            var bayeuxMessage = {\n                id: _nextMessageId(),\n                channel: '/meta/unsubscribe',\n                subscription: channel\n            };\n            // Do not allow the user to override important fields.\n            var message = this._mixin(false, {}, unsubscribeProps, bayeuxMessage);\n\n            // Save the callback.\n            _cometd._putCallback(message.id, unsubscribeCallback);\n\n            _queueSend(message);\n        }\n    };\n\n    this.resubscribe = function(subscription, subscribeProps) {\n        _removeSubscription(subscription);\n        if (subscription) {\n            return this.subscribe(subscription.channel, subscription.scope, subscription.callback, subscribeProps);\n        }\n        return undefined;\n    };\n\n    /**\n     * Removes all subscriptions added via {@link #subscribe(channel, scope, callback, subscribeProps)},\n     * but does not remove the listeners added via {@link addListener(channel, scope, callback)}.\n     */\n    this.clearSubscriptions = function() {\n        _clearSubscriptions();\n    };\n\n    /**\n     * Publishes a message on the given channel, containing the given content.\n     * @param channel the channel to publish the message to\n     * @param content the content of the message\n     * @param publishProps an object to be merged with the publish message\n     * @param publishCallback a function to be invoked when the publish is acknowledged by the server\n     */\n    this.publish = function(channel, content, publishProps, publishCallback) {\n        if (arguments.length < 1) {\n            throw 'Illegal arguments number: required 1, got ' + arguments.length;\n        }\n        if (!_isString(channel)) {\n            throw 'Illegal argument type: channel must be a string';\n        }\n        if (/^\\/meta\\//.test(channel)) {\n            throw 'Illegal argument: cannot publish to meta channels';\n        }\n        if (_isDisconnected()) {\n            throw 'Illegal state: already disconnected';\n        }\n\n        if (_isFunction(content)) {\n            publishCallback = content;\n            content = publishProps = {};\n        } else if (_isFunction(publishProps)) {\n            publishCallback = publishProps;\n            publishProps = {};\n        }\n\n        var bayeuxMessage = {\n            id: _nextMessageId(),\n            channel: channel,\n            data: content\n        };\n        // Do not allow the user to override important fields.\n        var message = this._mixin(false, {}, publishProps, bayeuxMessage);\n\n        // Save the callback.\n        _cometd._putCallback(message.id, publishCallback);\n\n        _queueSend(message);\n    };\n\n    this.remoteCall = function(target, content, timeout, callback) {\n        if (arguments.length < 1) {\n            throw 'Illegal arguments number: required 1, got ' + arguments.length;\n        }\n        if (!_isString(target)) {\n            throw 'Illegal argument type: target must be a string';\n        }\n        if (_isDisconnected()) {\n            throw 'Illegal state: already disconnected';\n        }\n\n        if (_isFunction(content)) {\n            callback = content;\n            content = {};\n            timeout = _config.maxNetworkDelay;\n        } else if (_isFunction(timeout)) {\n            callback = timeout;\n            timeout = _config.maxNetworkDelay;\n        }\n\n        if (typeof timeout !== 'number') {\n            throw 'Illegal argument type: timeout must be a number';\n        }\n\n        if (!target.match(/^\\//)) {\n            target = '/' + target;\n        }\n        var channel = '/service' + target;\n\n        var bayeuxMessage = {\n            id: _nextMessageId(),\n            channel: channel,\n            data: content\n        };\n\n        var context = {\n            callback: callback\n        };\n        if (timeout > 0) {\n            context.timeout = Utils.setTimeout(_cometd, function() {\n                _cometd._debug('Timing out remote call', bayeuxMessage, 'after', timeout, 'ms');\n                _failMessage({\n                    id: bayeuxMessage.id,\n                    error: '406::timeout',\n                    successful: false,\n                    failure: {\n                        message : bayeuxMessage,\n                        reason: 'Remote Call Timeout'\n                    }\n                });\n            }, timeout);\n            _cometd._debug('Scheduled remote call timeout', bayeuxMessage, 'in', timeout, 'ms');\n        }\n        _remoteCalls[bayeuxMessage.id] = context;\n\n        _queueSend(bayeuxMessage);\n    };\n\n    /**\n     * Returns a string representing the status of the bayeux communication with the Bayeux server.\n     */\n    this.getStatus = function() {\n        return _status;\n    };\n\n    /**\n     * Returns whether this instance has been disconnected.\n     */\n    this.isDisconnected = _isDisconnected;\n\n    /**\n     * Sets the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.\n     * Default value is 1 second, which means if there is a persistent failure the retries will happen\n     * after 1 second, then after 2 seconds, then after 3 seconds, etc. So for example with 15 seconds of\n     * elapsed time, there will be 5 retries (at 1, 3, 6, 10 and 15 seconds elapsed).\n     * @param period the backoff period to set\n     * @see #getBackoffIncrement()\n     */\n    this.setBackoffIncrement = function(period) {\n        _config.backoffIncrement = period;\n    };\n\n    /**\n     * Returns the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.\n     * @see #setBackoffIncrement(period)\n     */\n    this.getBackoffIncrement = function() {\n        return _config.backoffIncrement;\n    };\n\n    /**\n     * Returns the backoff period to wait before retrying an unsuccessful or failed message.\n     */\n    this.getBackoffPeriod = function() {\n        return _backoff;\n    };\n\n    /**\n     * Increases the backoff period up to the maximum value configured.\n     * @returns the backoff period after increment\n     * @see getBackoffIncrement\n     */\n    this.increaseBackoffPeriod = function() {\n        return _increaseBackoff();\n    };\n\n    /**\n     * Resets the backoff period to zero.\n     */\n    this.resetBackoffPeriod = function() {\n        _resetBackoff();\n    };\n\n    /**\n     * Sets the log level for console logging.\n     * Valid values are the strings 'error', 'warn', 'info' and 'debug', from\n     * less verbose to more verbose.\n     * @param level the log level string\n     */\n    this.setLogLevel = function(level) {\n        _config.logLevel = level;\n    };\n\n    /**\n     * Registers an extension whose callbacks are called for every incoming message\n     * (that comes from the server to this client implementation) and for every\n     * outgoing message (that originates from this client implementation for the\n     * server).\n     * The format of the extension object is the following:\n     * <pre>\n     * {\n     *     incoming: function(message) { ... },\n     *     outgoing: function(message) { ... }\n     * }\n     * </pre>\n     * Both properties are optional, but if they are present they will be called\n     * respectively for each incoming message and for each outgoing message.\n     * @param name the name of the extension\n     * @param extension the extension to register\n     * @return true if the extension was registered, false otherwise\n     * @see #unregisterExtension(name)\n     */\n    this.registerExtension = function(name, extension) {\n        if (arguments.length < 2) {\n            throw 'Illegal arguments number: required 2, got ' + arguments.length;\n        }\n        if (!_isString(name)) {\n            throw 'Illegal argument type: extension name must be a string';\n        }\n\n        var existing = false;\n        for (var i = 0; i < _extensions.length; ++i) {\n            var existingExtension = _extensions[i];\n            if (existingExtension.name === name) {\n                existing = true;\n                break;\n            }\n        }\n        if (!existing) {\n            _extensions.push({\n                name: name,\n                extension: extension\n            });\n            this._debug('Registered extension', name);\n\n            // Callback for extensions\n            if (_isFunction(extension.registered)) {\n                extension.registered(name, this);\n            }\n\n            return true;\n        } else {\n            this._info('Could not register extension with name', name, 'since another extension with the same name already exists');\n            return false;\n        }\n    };\n\n    /**\n     * Unregister an extension previously registered with\n     * {@link #registerExtension(name, extension)}.\n     * @param name the name of the extension to unregister.\n     * @return true if the extension was unregistered, false otherwise\n     */\n    this.unregisterExtension = function(name) {\n        if (!_isString(name)) {\n            throw 'Illegal argument type: extension name must be a string';\n        }\n\n        var unregistered = false;\n        for (var i = 0; i < _extensions.length; ++i) {\n            var extension = _extensions[i];\n            if (extension.name === name) {\n                _extensions.splice(i, 1);\n                unregistered = true;\n                this._debug('Unregistered extension', name);\n\n                // Callback for extensions\n                var ext = extension.extension;\n                if (_isFunction(ext.unregistered)) {\n                    ext.unregistered();\n                }\n\n                break;\n            }\n        }\n        return unregistered;\n    };\n\n    /**\n     * Find the extension registered with the given name.\n     * @param name the name of the extension to find\n     * @return the extension found or null if no extension with the given name has been registered\n     */\n    this.getExtension = function(name) {\n        for (var i = 0; i < _extensions.length; ++i) {\n            var extension = _extensions[i];\n            if (extension.name === name) {\n                return extension.extension;\n            }\n        }\n        return null;\n    };\n\n    /**\n     * Returns the name assigned to this CometD object, or the string 'default'\n     * if no name has been explicitly passed as parameter to the constructor.\n     */\n    this.getName = function() {\n        return _name;\n    };\n\n    /**\n     * Returns the clientId assigned by the Bayeux server during handshake.\n     */\n    this.getClientId = function() {\n        return _clientId;\n    };\n\n    /**\n     * Returns the URL of the Bayeux server.\n     */\n    this.getURL = function() {\n        if (_transport) {\n            var url = _transport.getURL();\n            if (url) {\n                return url;\n            }\n            url = _config.urls[_transport.getType()];\n            if (url) {\n                return url;\n            }\n        }\n        return _config.url;\n    };\n\n    this.getTransport = function() {\n        return _transport;\n    };\n\n    this.getConfiguration = function() {\n        return this._mixin(true, {}, _config);\n    };\n\n    this.getAdvice = function() {\n        return this._mixin(true, {}, _advice);\n    };\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zetapush-cometd/lib/CometD.js\n// module id = 103\n// module chunks = 0","/**\n * A registry for transports used by the CometD object.\n */\nmodule.exports = function TransportRegistry() {\n    var _types = [];\n    var _transports = {};\n\n    this.getTransportTypes = function() {\n        return _types.slice(0);\n    };\n\n    this.findTransportTypes = function(version, crossDomain, url) {\n        var result = [];\n        for (var i = 0; i < _types.length; ++i) {\n            var type = _types[i];\n            if (_transports[type].accept(version, crossDomain, url) === true) {\n                result.push(type);\n            }\n        }\n        return result;\n    };\n\n    this.negotiateTransport = function(types, version, crossDomain, url) {\n        for (var i = 0; i < _types.length; ++i) {\n            var type = _types[i];\n            for (var j = 0; j < types.length; ++j) {\n                if (type === types[j]) {\n                    var transport = _transports[type];\n                    if (transport.accept(version, crossDomain, url) === true) {\n                        return transport;\n                    }\n                }\n            }\n        }\n        return null;\n    };\n\n    this.add = function(type, transport, index) {\n        var existing = false;\n        for (var i = 0; i < _types.length; ++i) {\n            if (_types[i] === type) {\n                existing = true;\n                break;\n            }\n        }\n\n        if (!existing) {\n            if (typeof index !== 'number') {\n                _types.push(type);\n            } else {\n                _types.splice(index, 0, type);\n            }\n            _transports[type] = transport;\n        }\n\n        return !existing;\n    };\n\n    this.find = function(type) {\n        for (var i = 0; i < _types.length; ++i) {\n            if (_types[i] === type) {\n                return _transports[type];\n            }\n        }\n        return null;\n    };\n\n    this.remove = function(type) {\n        for (var i = 0; i < _types.length; ++i) {\n            if (_types[i] === type) {\n                _types.splice(i, 1);\n                var transport = _transports[type];\n                delete _transports[type];\n                return transport;\n            }\n        }\n        return null;\n    };\n\n    this.clear = function() {\n        _types = [];\n        _transports = {};\n    };\n\n    this.reset = function(init) {\n        for (var i = 0; i < _types.length; ++i) {\n            _transports[_types[i]].reset(init);\n        }\n    };\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zetapush-cometd/lib/TransportRegistry.js\n// module id = 104\n// module chunks = 0","var Transport = require('./Transport');\nvar RequestTransport = require('./RequestTransport');\n\nmodule.exports = function LongPollingTransport() {\n    var _super = new RequestTransport();\n    var _self = Transport.derive(_super);\n    // By default, support cross domain\n    var _supportsCrossDomain = true;\n\n    _self.accept = function(version, crossDomain, url) {\n        return _supportsCrossDomain || !crossDomain;\n    };\n\n    _self.xhrSend = function(packet) {\n        throw 'Abstract';\n    };\n\n    _self.transportSend = function(envelope, request) {\n        this._debug('Transport', this.getType(), 'sending request', request.id, 'envelope', envelope);\n\n        var self = this;\n        try {\n            var sameStack = true;\n            request.xhr = this.xhrSend({\n                transport: this,\n                url: envelope.url,\n                sync: envelope.sync,\n                headers: this.getConfiguration().requestHeaders,\n                body: JSON.stringify(envelope.messages),\n                onSuccess: function(response) {\n                    self._debug('Transport', self.getType(), 'received response', response);\n                    var success = false;\n                    try {\n                        var received = self.convertToMessages(response);\n                        if (received.length === 0) {\n                            _supportsCrossDomain = false;\n                            self.transportFailure(envelope, request, {\n                                httpCode: 204\n                            });\n                        } else {\n                            success = true;\n                            self.transportSuccess(envelope, request, received);\n                        }\n                    } catch (x) {\n                        self._debug(x);\n                        if (!success) {\n                            _supportsCrossDomain = false;\n                            var failure = {\n                                exception: x\n                            };\n                            failure.httpCode = self.xhrStatus(request.xhr);\n                            self.transportFailure(envelope, request, failure);\n                        }\n                    }\n                },\n                onError: function(reason, exception) {\n                    self._debug('Transport', self.getType(), 'received error', reason, exception);\n                    _supportsCrossDomain = false;\n                    var failure = {\n                        reason: reason,\n                        exception: exception\n                    };\n                    failure.httpCode = self.xhrStatus(request.xhr);\n                    if (sameStack) {\n                        // Keep the semantic of calling response callbacks asynchronously after the request\n                        self.setTimeout(function() {\n                            self.transportFailure(envelope, request, failure);\n                        }, 0);\n                    } else {\n                        self.transportFailure(envelope, request, failure);\n                    }\n                }\n            });\n            sameStack = false;\n        } catch (x) {\n            _supportsCrossDomain = false;\n            // Keep the semantic of calling response callbacks asynchronously after the request\n            self.setTimeout(function() {\n                self.transportFailure(envelope, request, {\n                    exception: x\n                });\n            }, 0);\n        }\n    };\n\n    _self.reset = function(init) {\n        _super.reset(init);\n        _supportsCrossDomain = true;\n    };\n\n    return _self;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zetapush-cometd/lib/LongPollingTransport.js\n// module id = 105\n// module chunks = 0","var Transport = require('./Transport')\nvar Utils = require('./Utils')\n\nmodule.exports = function WebSocketTransport() {\n    var _super = new Transport();\n    var _self = Transport.derive(_super);\n    var _cometd;\n    // By default WebSocket is supported\n    var _webSocketSupported = true;\n    // Whether we were able to establish a WebSocket connection\n    var _webSocketConnected = false;\n    var _stickyReconnect = true;\n    // The context contains the envelopes that have been sent\n    // and the timeouts for the messages that have been sent.\n    var _context = null;\n    var _connecting = null;\n    var _connected = false;\n    var _successCallback = null;\n\n    _self.reset = function(init) {\n        _super.reset(init);\n        _webSocketSupported = true;\n        if (init) {\n            _webSocketConnected = false;\n        }\n        _stickyReconnect = true;\n        _context = null;\n        _connecting = null;\n        _connected = false;\n    };\n\n    function _forceClose(context, event) {\n        if (context) {\n            this.webSocketClose(context, event.code, event.reason);\n            // Force immediate failure of pending messages to trigger reconnect.\n            // This is needed because the server may not reply to our close()\n            // and therefore the onclose function is never called.\n            this.onClose(context, event);\n        }\n    }\n\n    function _sameContext(context) {\n        return context === _connecting || context === _context;\n    }\n\n    function _storeEnvelope(context, envelope, metaConnect) {\n        var messageIds = [];\n        for (var i = 0; i < envelope.messages.length; ++i) {\n            var message = envelope.messages[i];\n            if (message.id) {\n                messageIds.push(message.id);\n            }\n        }\n        context.envelopes[messageIds.join(',')] = [envelope, metaConnect];\n        this._debug('Transport', this.getType(), 'stored envelope, envelopes', context.envelopes);\n    }\n\n    function _websocketConnect(context) {\n        // We may have multiple attempts to open a WebSocket\n        // connection, for example a /meta/connect request that\n        // may take time, along with a user-triggered publish.\n        // Early return if we are already connecting.\n        if (_connecting) {\n            return;\n        }\n\n        // Mangle the URL, changing the scheme from 'http' to 'ws'.\n        var url = _cometd.getURL().replace(/^http/, 'ws');\n        this._debug('Transport', this.getType(), 'connecting to URL', url);\n\n        try {\n            var protocol = _cometd.getConfiguration().protocol;\n            context.webSocket = protocol ? new WebSocket(url, protocol) : new WebSocket(url);\n            _connecting = context;\n        } catch (x) {\n            _webSocketSupported = false;\n            this._debug('Exception while creating WebSocket object', x);\n            throw x;\n        }\n\n        // By default use sticky reconnects.\n        _stickyReconnect = _cometd.getConfiguration().stickyReconnect !== false;\n\n        var self = this;\n        var connectTimeout = _cometd.getConfiguration().connectTimeout;\n        if (connectTimeout > 0) {\n            context.connectTimer = self.setTimeout(function() {\n                _cometd._debug('Transport', self.getType(), 'timed out while connecting to URL', url, ':', connectTimeout, 'ms');\n                // The connection was not opened, close anyway.\n                _forceClose.call(self, context, {code: 1000, reason: 'Connect Timeout'});\n            }, connectTimeout);\n        }\n\n        var onopen = function() {\n            _cometd._debug('WebSocket onopen', context);\n            if (context.connectTimer) {\n                self.clearTimeout(context.connectTimer);\n            }\n\n            if (_sameContext(context)) {\n                _connecting = null;\n                _context = context;\n                _webSocketConnected = true;\n                self.onOpen(context);\n            } else {\n                // We have a valid connection already, close this one.\n                _cometd._warn('Closing extra WebSocket connection', this, 'active connection', _context);\n                _forceClose.call(self, context, {code: 1000, reason: 'Extra Connection'});\n            }\n        };\n\n        // This callback is invoked when the server sends the close frame.\n        // The close frame for a connection may arrive *after* another\n        // connection has been opened, so we must make sure that actions\n        // are performed only if it's the same connection.\n        var onclose = function(event) {\n            event = event || {code: 1000};\n            _cometd._debug('WebSocket onclose', context, event, 'connecting', _connecting, 'current', _context);\n\n            if (context.connectTimer) {\n                self.clearTimeout(context.connectTimer);\n            }\n\n            self.onClose(context, event);\n        };\n\n        var onmessage = function(wsMessage) {\n            _cometd._debug('WebSocket onmessage', wsMessage, context);\n            self.onMessage(context, wsMessage);\n        };\n\n        context.webSocket.onopen = onopen;\n        context.webSocket.onclose = onclose;\n        context.webSocket.onerror = function() {\n            // Clients should call onclose(), but if they do not we do it here for safety.\n            onclose({code: 1000, reason: 'Error'});\n        };\n        context.webSocket.onmessage = onmessage;\n\n        this._debug('Transport', this.getType(), 'configured callbacks on', context);\n    }\n\n    function _webSocketSend(context, envelope, metaConnect) {\n        var json = JSON.stringify(envelope.messages);\n        context.webSocket.send(json);\n        this._debug('Transport', this.getType(), 'sent', envelope, 'metaConnect =', metaConnect);\n\n        // Manage the timeout waiting for the response.\n        var maxDelay = this.getConfiguration().maxNetworkDelay;\n        var delay = maxDelay;\n        if (metaConnect) {\n            delay += this.getAdvice().timeout;\n            _connected = true;\n        }\n\n        var self = this;\n        var messageIds = [];\n        for (var i = 0; i < envelope.messages.length; ++i) {\n            (function() {\n                var message = envelope.messages[i];\n                if (message.id) {\n                    messageIds.push(message.id);\n                    context.timeouts[message.id] = self.setTimeout(function() {\n                        _cometd._debug('Transport', self.getType(), 'timing out message', message.id, 'after', delay, 'on', context);\n                        _forceClose.call(self, context, {code: 1000, reason: 'Message Timeout'});\n                    }, delay);\n                }\n            })();\n        }\n\n        this._debug('Transport', this.getType(), 'waiting at most', delay, 'ms for messages', messageIds, 'maxNetworkDelay', maxDelay, ', timeouts:', context.timeouts);\n    }\n\n    _self._notifySuccess = function(fn, messages) {\n        fn.call(this, messages);\n    };\n\n    _self._notifyFailure = function(fn, context, messages, failure) {\n        fn.call(this, context, messages, failure);\n    };\n\n    function _send(context, envelope, metaConnect) {\n        try {\n            if (context === null) {\n                context = _connecting || {\n                        envelopes: {},\n                        timeouts: {}\n                    };\n                _storeEnvelope.call(this, context, envelope, metaConnect);\n                _websocketConnect.call(this, context);\n            } else {\n                _storeEnvelope.call(this, context, envelope, metaConnect);\n                _webSocketSend.call(this, context, envelope, metaConnect);\n            }\n        } catch (x) {\n            // Keep the semantic of calling response callbacks asynchronously after the request.\n            var self = this;\n            self.setTimeout(function() {\n                _forceClose.call(self, context, {\n                    code: 1000,\n                    reason: 'Exception',\n                    exception: x\n                });\n            }, 0);\n        }\n    }\n\n    _self.onOpen = function(context) {\n        var envelopes = context.envelopes;\n        this._debug('Transport', this.getType(), 'opened', context, 'pending messages', envelopes);\n        for (var key in envelopes) {\n            if (envelopes.hasOwnProperty(key)) {\n                var element = envelopes[key];\n                var envelope = element[0];\n                var metaConnect = element[1];\n                // Store the success callback, which is independent from the envelope,\n                // so that it can be used to notify arrival of messages.\n                _successCallback = envelope.onSuccess;\n                _webSocketSend.call(this, context, envelope, metaConnect);\n            }\n        }\n    };\n\n    _self.onMessage = function(context, wsMessage) {\n        this._debug('Transport', this.getType(), 'received websocket message', wsMessage, context);\n\n        var close = false;\n        var messages = this.convertToMessages(wsMessage.data);\n        var messageIds = [];\n        for (var i = 0; i < messages.length; ++i) {\n            var message = messages[i];\n\n            // Detect if the message is a response to a request we made.\n            // If it's a meta message, for sure it's a response; otherwise it's\n            // a publish message and publish responses don't have the data field.\n            if (/^\\/meta\\//.test(message.channel) || message.data === undefined) {\n                if (message.id) {\n                    messageIds.push(message.id);\n\n                    var timeout = context.timeouts[message.id];\n                    if (timeout) {\n                        this.clearTimeout(timeout);\n                        delete context.timeouts[message.id];\n                        this._debug('Transport', this.getType(), 'removed timeout for message', message.id, ', timeouts', context.timeouts);\n                    }\n                }\n            }\n\n            if ('/meta/connect' === message.channel) {\n                _connected = false;\n            }\n            if ('/meta/disconnect' === message.channel && !_connected) {\n                close = true;\n            }\n        }\n\n        // Remove the envelope corresponding to the messages.\n        var removed = false;\n        var envelopes = context.envelopes;\n        for (var j = 0; j < messageIds.length; ++j) {\n            var id = messageIds[j];\n            for (var key in envelopes) {\n                if (envelopes.hasOwnProperty(key)) {\n                    var ids = key.split(',');\n                    var index = Utils.inArray(id, ids);\n                    if (index >= 0) {\n                        removed = true;\n                        ids.splice(index, 1);\n                        var envelope = envelopes[key][0];\n                        var metaConnect = envelopes[key][1];\n                        delete envelopes[key];\n                        if (ids.length > 0) {\n                            envelopes[ids.join(',')] = [envelope, metaConnect];\n                        }\n                        break;\n                    }\n                }\n            }\n        }\n        if (removed) {\n            this._debug('Transport', this.getType(), 'removed envelope, envelopes', envelopes);\n        }\n\n        this._notifySuccess(_successCallback, messages);\n\n        if (close) {\n            this.webSocketClose(context, 1000, 'Disconnect');\n        }\n    };\n\n    _self.onClose = function(context, event) {\n        this._debug('Transport', this.getType(), 'closed', context, event);\n\n        if (_sameContext(context)) {\n            // Remember if we were able to connect.\n            // This close event could be due to server shutdown,\n            // and if it restarts we want to try websocket again.\n            _webSocketSupported = _stickyReconnect && _webSocketConnected;\n            _connecting = null;\n            _context = null;\n        }\n\n        var timeouts = context.timeouts;\n        context.timeouts = {};\n        for (var id in timeouts) {\n            if (timeouts.hasOwnProperty(id)) {\n                this.clearTimeout(timeouts[id]);\n            }\n        }\n\n        var envelopes = context.envelopes;\n        context.envelopes = {};\n        for (var key in envelopes) {\n            if (envelopes.hasOwnProperty(key)) {\n                var envelope = envelopes[key][0];\n                var metaConnect = envelopes[key][1];\n                if (metaConnect) {\n                    _connected = false;\n                }\n                var failure = {\n                    websocketCode: event.code,\n                    reason: event.reason\n                };\n                if (event.exception) {\n                    failure.exception = event.exception;\n                }\n                this._notifyFailure(envelope.onFailure, context, envelope.messages, failure);\n            }\n        }\n    };\n\n    _self.registered = function(type, cometd) {\n        _super.registered(type, cometd);\n        _cometd = cometd;\n    };\n\n    _self.accept = function(version, crossDomain, url) {\n        this._debug('Transport', this.getType(), 'accept, supported:', _webSocketSupported);\n        // Using !! to return a boolean (and not the WebSocket object).\n        return _webSocketSupported && !('undefined' === typeof WebSocket) && _cometd.websocketEnabled !== false;\n    };\n\n    _self.send = function(envelope, metaConnect) {\n        this._debug('Transport', this.getType(), 'sending', envelope, 'metaConnect =', metaConnect);\n        _send.call(this, _context, envelope, metaConnect);\n    };\n\n    _self.webSocketClose = function(context, code, reason) {\n        try {\n            if (context.webSocket) {\n                context.webSocket.close(code, reason);\n            }\n        } catch (x) {\n            this._debug(x);\n        }\n    };\n\n    _self.abort = function() {\n        _super.abort();\n        _forceClose.call(this, _context, {code: 1000, reason: 'Abort'});\n        this.reset(true);\n    };\n\n    return _self;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/zetapush-cometd/lib/WebSocketTransport.js\n// module id = 106\n// module chunks = 0","import { ClientHelper } from './helper'\nimport { API_URL, isHttpsProtocol } from '../utils/index'\nimport { ConnectionStatusListener } from '../connection/connection-status'\n\n/**\n * Client config object.\n * @typedef {Object} ClientConfig\n * @property {string} apiUrl - Api Url\n * @property {string} sandboxId - Sandbox id\n * @property {boolean} forceHttps - Force end to end HTTPS connection\n * @property {function():AbstractHandshake} authentication - Return authentication properties\n * @property {string} resource - Client resource id\n * @property {Array} transports - Client transports list\n */\n\n/**\n * ZetaPush Client to connect\n * @access public\n * @example\n * // Securized client with token based connection\n * const client = new ZetaPush.Client({\n *   sandboxId: '<YOUR-SANDBOX-ID>',\n *   authentication() {\n *     return ZetaPush.Authentication.weak({\n *       token: null\n  *    })\n *   }\n * })\n * @example\n * // Client with authentication based connection\n * const client = new ZetaPush.Client({\n *   sandboxId: '<YOUR-SANDBOX-ID>',\n *   authentication() {\n *     return ZetaPush.Authentication.simple({\n *       login: '<USER-LOGIN>',\n *       password: '<USER-PASSWORD>'\n  *    })\n *   }\n * })\n * @example\n * // Explicit deploymentId\n * const clientSimple = new ZetaPush.Client({\n *   sandboxId: '<YOUR-SANDBOX-ID>',\n *   authentication() {\n *     return ZetaPush.Authentication.simple({\n *       deploymentId: '<YOUR-SIMPLE-AUTHENTICATION-DEPLOYMENT-ID>',\n *       login: '<USER-LOGIN>',\n *       password: '<USER-PASSWORD>'\n *    })\n *   }\n * })\n * const clientWeak = new ZetaPush.Client({\n *   sandboxId: '<YOUR-SANDBOX-ID>',\n *   authentication() {\n *     return ZetaPush.Authentication.weak({\n *       deploymentId: '<YOUR-WEAK-AUTHENTICATION-DEPLOYMENT-ID>',\n *       token: '<SESSION-TOKEN>'\n *    })\n *   }\n * })\n */\nexport class Client {\n  /**\n   * Create a new ZetaPush Client\n   * @param {ClientConfig} config\n   */\n  constructor({ apiUrl = API_URL, sandboxId, forceHttps = isHttpsProtocol(), authentication, resource, transports }) {\n    /**\n     * @access private\n     * @type {ClientHelper}\n     */\n    this.helper = new ClientHelper({\n      apiUrl,\n      sandboxId,\n      forceHttps,\n      authentication,\n      resource,\n      transports\n    })\n  }\n  /**\n   * Add a connection listener to handle life cycle connection events\n   * @param {ConnectionStatusListener} listener\n   * @return {number} handler\n   */\n  addConnectionStatusListener(listener) {\n    return this.helper.addConnectionStatusListener(listener)\n  }\n  /**\n   * Safely connect client to ZetaPush\n   */\n  connect() {\n    if (this.isConnected()) {\n      const handler = this.addConnectionStatusListener({\n        onConnectionClosed: () => {\n          this.removeConnectionStatusListener(handler)\n          this.helper.connect()\n        }\n      })\n      this.disconnect()\n    } else {\n      this.helper.connect()\n    }\n  }\n  /**\n   * Create a promise based service instance\n   * @param {{listener: Object, Type: class, deploymentId: string}} parameters\n   * @return {Object} service\n   * @example\n   * const api = client.createAsyncMacroService({\n   *   Type: WelcomeMacro\n   * })\n   * api.welcome({\n   *   message: Hello'\n   * }).then(({ message }) => {\n   *   console.log(message)\n   * })\n   */\n  createAsyncMacroService({ deploymentId, listener, Type }) {\n    return this.helper.createAsyncMacroService({ deploymentId, listener, Type })\n  }\n  /**\n   * Create a publish/subscribe for a service type\n   * @param {{listener: Object, Type: class, deploymentId: string}} parameters\n   * @return {Object} service\n   * @example\n   * const service = client.createService({\n   *   listener: {\n   *     list(message) {\n   *       console.log('Stack list callback', message)\n   *     },\n   *     push(message) {\n   *       console.log('Stack push callback', message)\n   *     }\n   *   },\n   *   Type: ZetaPush.services.Stack\n   * })\n   * service.list({\n   *   stack: '<STACK-ID>'\n   * })\n   * @example\n   * // Explicit deploymentId\n   * // Authentication provide optional deployment id, according to the following convention `${ServiceType.toLowerCase()_0}`\n   * const service = client.createService({\n   *   deploymentId: 'stack_0'\n   *   listener: {\n   *     list(message) {\n   *       console.log('Stack list callback', message)\n   *     },\n   *     push(message) {\n   *       console.log('Stack push callback', message)\n   *     }\n   *   },\n   *   Type: ZetaPush.services.Stack\n   * })\n   * service.list({\n   *   stack: '<STACK-ID>'\n   * })\n   */\n  createService({ deploymentId, listener, Type }) {\n    return this.helper.createService({ deploymentId, listener, Type })\n  }\n  /**\n   * Disonnect client from ZetaPush\n   */\n  disconnect() {\n    if (this.isConnected()) {\n      this.helper.disconnect()\n    }\n  }\n  /**\n   * Is client connected to ZetaPush\n   * @return {boolean}\n   */\n  isConnected() {\n    return this.helper.isConnected()\n  }\n  /**\n   * Get the client sandbox id\n   * @return {string}\n   */\n  getSandboxId() {\n    return this.helper.getSandboxId()\n  }\n  /**\n   * Get the client resource\n   * @return {string}\n   */\n  getResource() {\n    return this.helper.getResource()\n  }\n  /**\n   * Get the client user id\n   * @return {string}\n   */\n  getUserId() {\n    return this.helper.getUserId()\n  }\n  /**\n   * Remove a connection status listener\n   * @param {number} handler\n   */\n  removeConnectionStatusListener(handler) {\n    return this.helper.removeConnectionStatusListener(handler)\n  }\n  /**\n   * Set a new authentication methods\n   * @param {function():AbstractHandshake} authentication\n   */\n  setAuthentication(authentication) {\n    this.helper.setAuthentication(authentication)\n  }\n  /**\n   * Set logging level\n   * Valid values are the strings 'error', 'warn', 'info' and 'debug', from\n   * less verbose to more verbose.\n   * @param {string} level\n   */\n  setLogLevel(level) {\n    this.helper.setLogLevel(level)\n  }\n  /**\n   * Set new client resource value\n   * @param {string} resource\n   */\n  setResource(resource) {\n    this.helper.setResource(resource)\n  }\n  /**\n   * Remove all subscriptions\n   * @param {Object} service\n   */\n  unsubscribe(service) {\n    if (!service.$subscriptions) {\n      throw new TypeError('Missing $subscriptions property in service')\n    }\n    return this.helper.unsubscribe(service.$subscriptions)\n  }\n}\n\n/**\n * Add shorthand connection status method\n */\nObject.getOwnPropertyNames(ConnectionStatusListener.prototype).forEach((method) => {\n  // Only implements unsupported methods\n  if (!Client.prototype.hasOwnProperty(method)) {\n    Client.prototype[method] = function addListener(listener) {\n      return this.addConnectionStatusListener({\n        [method]: listener\n      })\n    }\n  }\n})\n\n\n\n// WEBPACK FOOTER //\n// ./lib/client/basic.js","\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (obj, key, value) {\n  if (key in obj) {\n    (0, _defineProperty2.default)(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/defineProperty.js\n// module id = 108\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/object/get-own-property-names\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/get-own-property-names.js\n// module id = 109\n// module chunks = 0","require('../../modules/es6.object.get-own-property-names');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function getOwnPropertyNames(it){\n  return $Object.getOwnPropertyNames(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/get-own-property-names.js\n// module id = 110\n// module chunks = 0","// 19.1.2.7 Object.getOwnPropertyNames(O)\nrequire('./_object-sap')('getOwnPropertyNames', function(){\n  return require('./_object-gopn-ext').f;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.object.get-own-property-names.js\n// module id = 111\n// module chunks = 0","import { CometD } from 'zetapush-cometd'\nimport { TransportTypes, TransportLayers } from '../connection/cometd'\nimport { ConnectionStatusListener } from '../connection/connection-status'\nimport { Macro } from '../mapping/services'\nimport { getServers, isDerivedOf, shuffle, uuid } from '../utils/index'\n\n/**\n * CometD Messages enumeration\n * @type {Object}\n */\nconst Message = {\n  RECONNECT_HANDSHAKE_VALUE: 'handshake',\n  RECONNECT_NONE_VALUE: 'none',\n  RECONNECT_RETRY_VALUE: 'retry'\n}\n\n/**\n * Get all transport types\n * @type {Object[]}\n */\nconst AllTransports = Object.values(TransportTypes)\n\n/**\n * Delay to update server url\n * @type {integer}\n */\nconst UPDATE_SERVER_URL_DELAY = 250\n\n/**\n * Default macro channel\n * @type {string}\n */\nconst DEFAULT_MACRO_CHANNEL = 'completed'\n\n/**\n * Provide utilities and abstraction on CometD Transport layer\n * @access private\n */\nexport class ClientHelper {\n  /**\n   * Create a new ZetaPush client helper\n   */\n  constructor({ apiUrl, sandboxId, forceHttps = false, authentication, resource = null, transports = AllTransports }) {\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.sandboxId = sandboxId\n    /**\n     * @access private\n     * @type {function():AbstractHandshake}\n     */\n    this.authentication = authentication\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.resource = resource\n    /**\n     * @access private\n     * @type {number}\n     */\n    this.requestId = 0\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.userId = null\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.uniqId = uuid()\n    /**\n     * @access private\n     * @type {Promise}\n     */\n    this.servers = getServers({ apiUrl, sandboxId, forceHttps })\n    /**\n     * @access private\n     * @type {Array<Object>}\n     */\n    this.connectionListeners = []\n    /**\n     * @access private\n     * @type {boolean}\n     */\n    this.connected = false\n    /**\n     * @access private\n     * @type {boolean}\n     */\n    this.wasConnected = false\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.serverUrl = null\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.sessionId = null\n    /**\n     * @access private\n     * @type {Array<Object>}\n     */\n    this.subscribeQueue = []\n    /**\n     * @access private\n     * @type {CometD}\n     */\n    this.cometd = new CometD()\n\n    // Filter transports layers\n    TransportLayers.filter(({ type }) => {\n      return transports.includes(type)\n    }).forEach(({ type, Transport }) => {\n      this.cometd.registerTransport(type, new Transport())\n    })\n\n    // Handle transport exception\n    this.cometd.onTransportException = (cometd, transport) => {\n      if (TransportTypes.LONG_POLLING === transport) {\n        // Try to find an other available server\n        // Remove the current one from the _serverList array\n        this.updateServerUrl()\n      }\n    }\n\n    this.cometd.addListener('/meta/handshake', ({ ext, successful, advice, error }) => {\n      this.cometd._debug('ClientHelper::/meta/handshake', { ext, successful, advice, error })\n      if (successful) {\n        const { authentication = null } = ext\n        this.initialized(authentication)\n      } else {\n        this.handshakeFailure(error)\n      }\n    })\n\n    this.cometd.addListener('/meta/handshake', ({ advice, error, ext, successful }) => {\n      this.cometd._debug('ClientHelper::/meta/handshake', { ext, successful, advice, error })\n      // AuthNegotiation\n      if (!successful) {\n        if (typeof advice === 'undefined') {\n          return\n        }\n        if (Message.RECONNECT_NONE_VALUE === advice.reconnect) {\n          this.authenticationFailed(error)\n        } else if (Message.RECONNECT_HANDSHAKE_VALUE === advice.reconnect) {\n          this.negotiate(ext)\n        }\n      }\n    })\n\n    this.cometd.addListener('/meta/connect', ({ advice, channel, successful }) => {\n      this.cometd._debug('ClientHelper::/meta/connect', { advice, channel, successful })\n      // ConnectionListener\n      if (this.cometd.isDisconnected()) {\n        this.connected = false\n        // Notify connection will close\n        this.connectionWillClose()\n      } else {\n        this.wasConnected = this.connected\n        this.connected = successful\n        if (!this.wasConnected && this.connected) {\n          this.cometd.batch(this, () => {\n            // Unqueue subscriptions\n            this.subscribeQueue.forEach(({ prefix, listener, subscriptions }) => {\n              this.subscribe(prefix, listener, subscriptions)\n            })\n          })\n          // Notify connection is established\n          this.connectionEstablished()\n        } else if (this.wasConnected && !this.connected) {\n          // Notify connection is broken\n          this.connectionBroken()\n        }\n      }\n    })\n\n    this.cometd.addListener('/meta/disconnect', ({ channel, successful }) => {\n      this.cometd._debug('ClientHelper::/meta/disconnect', { channel, successful })\n      if (this.cometd.isDisconnected()) {\n        this.connected = false\n        // Notify connection is closed\n        this.connectionClosed()\n      }\n    })\n  }\n  /**\n   * Add a connection listener to handle life cycle connection events\n   * @param {ConnectionStatusListener} listener\n   * @return {number} handler\n   */\n  addConnectionStatusListener(listener) {\n    this.connectionListeners.push({\n      enabled: true,\n      listener: Object.assign(new ConnectionStatusListener(), listener)\n    })\n    return this.connectionListeners.length - 1\n  }\n  /**\n   * Notify listeners when handshake step succeed\n   */\n  authenticationFailed(error) {\n    this.userId = null\n    this.connectionListeners\n      .filter(({ enabled }) => enabled)\n      .forEach(({ listener }) => {\n        listener.onFailedHandshake(error)\n      })\n  }\n  /**\n   * Connect client using CometD Transport\n   */\n  connect() {\n    this.servers.then((servers) => {\n      this.serverUrl = shuffle(servers)\n\n      this.cometd.configure({\n        url: `${this.serverUrl}/strd`,\n        backoffIncrement: 1000,\n        maxBackoff: 60000,\n        appendMessageTypeToURL: false\n      })\n\n      this.cometd.handshake(this.getHandshakeFields())\n    })\n  }\n  /**\n   * Notify listeners when connection is broken\n   */\n  connectionBroken() {\n    this.connectionListeners\n      .filter(({ enabled }) => enabled)\n      .forEach(({ listener }) => {\n        listener.onConnectionBroken()\n      })\n  }\n  /**\n   * Notify listeners when connection is closed\n   */\n  connectionClosed() {\n    this.userId = null\n    this.connectionListeners\n      .filter(({ enabled }) => enabled)\n      .forEach(({ listener }) => {\n        listener.onConnectionClosed()\n      })\n  }\n  /**\n   * Notify listeners when connection is established\n   */\n  connectionEstablished() {\n    this.connectionListeners\n      .filter(({ enabled }) => enabled)\n      .forEach(({ listener }) => {\n        listener.onConnectionEstablished()\n      })\n  }\n  /**\n   * Notify listeners when connection will close\n   */\n  connectionWillClose() {\n    this.connectionListeners\n      .filter(({ enabled }) => enabled)\n      .forEach(({ listener }) => {\n        listener.onConnectionWillClose()\n      })\n  }\n  /**\n   * Create a promise based macro service\n   * @param {{listener: Object, Type: class, deploymentId: string}} parameters\n   * @return {Object} service\n   */\n  createAsyncMacroService({ listener, Type, deploymentId = Type.DEFAULT_DEPLOYMENT_ID }) {\n    const prefix = `/service/${this.getSandboxId()}/${deploymentId}`\n    const $publish = this.getAsyncMacroPublisher(prefix)\n    // Create service by publisher\n    return this.createServiceByPublisher({ listener, prefix, Type, $publish })\n  }\n  /**\n   * Create a publish/subscribe service\n   * @param {{listener: Object, Type: class, deploymentId: string}} parameters\n   * @return {Object} service\n   */\n  createService({ listener, Type, deploymentId = Type.DEFAULT_DEPLOYMENT_ID }) {\n    const isMacroType = isDerivedOf(Type, Macro)\n    const prefix = `/service/${this.getSandboxId()}/${deploymentId}`\n    const $publish = isMacroType ? this.getMacroPublisher(prefix) : this.getServicePublisher(prefix)\n    // Create service by publisher\n    return this.createServiceByPublisher({ listener, prefix, Type, $publish })\n  }\n  /**\n   * @param {{listener: Object, prefix: string, Type: class, $publish: Function}} parameters\n   * @return {Object} service\n   */\n  createServiceByPublisher({ listener, prefix, Type, $publish }) {\n    const service = new Type({ $publish })\n    // Store subscription in service instance\n    service.$subscriptions = this.subscribe(prefix, listener)\n    return service\n  }\n  /**\n   * Disconnect CometD client\n   */\n  disconnect() {\n    this.cometd.disconnect(true)\n  }\n  /**\n   * Get a publisher for a macro service that return a promise\n   * @param {string} prefix - Channel prefix\n   * @return {Function} publisher\n   */\n  getAsyncMacroPublisher(prefix) {\n    return (name, parameters, hardFail = false, debug = 1) => {\n      const channel = `${prefix}/call`\n      const uniqRequestId = this.getUniqRequestId()\n      const subscriptions = {}\n      return new Promise((resolve, reject) => {\n        const handler = ({ data = {} }) => {\n          const { result = {}, errors = [], requestId } = data\n          if (requestId === uniqRequestId) {\n            // Handle errors\n            if (errors.length > 0) {\n              reject(errors)\n            } else {\n              resolve(result)\n            }\n            this.unsubscribe(subscriptions)\n          }\n        }\n        // Create dynamic listener method\n        const listener = {\n          [name]: handler,\n          [DEFAULT_MACRO_CHANNEL]: handler\n        }\n        // Ad-Hoc subscription\n        this.subscribe(prefix, listener, subscriptions)\n        // Publish message on channel\n        this.publish(channel, {\n          debug,\n          hardFail,\n          name,\n          parameters,\n          requestId: uniqRequestId\n        })\n      })\n    }\n  }\n  /**\n   * Get client id\n   * @return {string} clientId\n   */\n  getClientId() {\n    return this.cometd.getClientId()\n  }\n  /**\n   * Get CometD handshake parameters\n   * @return {Object}\n   */\n  getHandshakeFields() {\n    const handshake = this.authentication()\n    return handshake.getHandshakeFields(this)\n  }\n  /**\n   * Get a publisher for a macro service\n   * @param {string} prefix - Channel prefix\n   * @return {Function} publisher\n   */\n  getMacroPublisher(prefix) {\n    return (name, parameters, hardFail = false, debug = 1) => {\n      const channel = `${prefix}/call`\n      const requestId = this.getUniqRequestId()\n      return this.publish(channel, {\n        debug,\n        hardFail,\n        name,\n        parameters,\n        requestId\n      })\n    }\n  }\n  /**\n   * Get queued subscription index\n   * @return {Object} index\n   */\n  getQueuedSubscription(subscriptions = {}) {\n    const index = this.subscribeQueue.findIndex((element) => subscriptions === element.subscriptions)\n    return {\n      index,\n      queued: index > -1\n    }\n  }\n  /**\n   * Get resource\n   * @return {string}\n   */\n  getResource() {\n    return this.resource\n  }\n  /**\n   * Get sandbox id\n   * @return {string}\n   */\n  getSandboxId() {\n    return this.sandboxId\n  }\n  /**\n   * Get a publisher for a service\n   * @param {string} prefix - Channel prefix\n   * @return {Function} publisher\n   */\n  getServicePublisher(prefix) {\n    return (method, parameters) => {\n      const channel = `${prefix}/${method}`\n      return this.publish(channel, parameters)\n    }\n  }\n  /**\n   * Get uniq request id\n   * @return {string}\n   */\n  getUniqRequestId() {\n    return `${this.getClientId()}:${this.uniqId}:${++this.requestId}`\n  }\n  /**\n   * Get user id\n   * @return {string}\n   */\n  getUserId() {\n    return this.userId\n  }\n  /**\n   * Manage handshake failure case\n   */\n  handshakeFailure() {\n    this.userId = null\n  }\n  /**\n   * Notify listeners when connection is established\n   */\n  initialized(authentication) {\n    if (authentication) {\n      this.userId = authentication.userId\n    }\n    this.connectionListeners\n      .filter(({ enabled }) => enabled)\n      .forEach(({ listener }) => {\n        listener.onSuccessfulHandshake(authentication)\n      })\n  }\n  /**\n   * Is client connected to ZetaPush\n   * @return {boolean}\n   */\n  isConnected() {\n    return !this.cometd.isDisconnected()\n  }\n  /**\n   * Notify listeners when a message is lost\n   */\n  messageLost(channel, data) {\n    this.connectionListeners\n      .filter(({ enabled }) => enabled)\n      .forEach(({ listener }) => {\n        listener.onMessageLost(channel, data)\n      })\n  }\n  /**\n   * Negociate authentication\n   */\n  negotiate(ext) {\n    this.cometd._debug('ClientHelper::negotiate', ext)\n  }\n  /**\n   * Wrap CometdD publish method\n   * @param {String} channel\n   * @param {Object} parameters\n   * @return {Object}\n   */\n  publish(channel, parameters = {}) {\n    this.cometd.publish(channel, parameters)\n    return { channel, parameters }\n  }\n  /**\n   * Remove a connection status listener\n   */\n  removeConnectionStatusListener(handler) {\n    const listener = this.connectionListeners[handler]\n    if (listener) {\n      listener.enabled = false\n    }\n  }\n  /**\n   * Set a new authentication methods\n   * @param {function():AbstractHandshake} authentication\n   */\n  setAuthentication(authentication) {\n    this.authentication = authentication\n  }\n  /**\n   * Set logging level for CometD client\n   * Valid values are the strings 'error', 'warn', 'info' and 'debug', from\n   * less verbose to more verbose.\n   * @param {string} level\n   */\n  setLogLevel(level) {\n    this.cometd.setLogLevel(level)\n  }\n  /**\n   * Subsribe all methods defined in the listener for the given prefixed channel\n   * @param {string} prefix - Channel prefix\n   * @param {Object} listener\n   * @param {Object} subscriptions\n   * @return {Object} subscriptions\n   */\n  subscribe(prefix, listener = {}, subscriptions = {}) {\n    const { queued } = this.getQueuedSubscription(subscriptions)\n    if (!queued) {\n      // Store arguments to renew subscriptions on connection\n      this.subscribeQueue.push({ prefix, listener, subscriptions })\n    }\n    // Subscribe if user is connected\n    if (!this.cometd.isDisconnected()) {\n      for (let method in listener) {\n        if (listener.hasOwnProperty(method)) {\n          const channel = `${prefix}/${method}`\n          subscriptions[method] = this.cometd.subscribe(channel, listener[method])\n        }\n      }\n    }\n    return subscriptions\n  }\n  /**\n  * Remove current server url from the server list and shuffle for another one\n  */\n  updateServerUrl() {\n    this.servers.then((servers) => {\n      const index = servers.indexOf(this.serverUrl)\n      if (index > -1) {\n        servers.splice(index, 1)\n      }\n      if (servers.length === 0) {\n        // No more server available\n      } else {\n        this.serverUrl = shuffle(servers)\n        this.cometd.configure({\n          url: `${this.serverUrl}/strd`\n        })\n        window.setTimeout(() => {\n          this.cometd.handshake(this.getHandshakeFields())\n        }, UPDATE_SERVER_URL_DELAY)\n      }\n    })\n  }\n  /**\n   * Remove all subscriptions\n   * @param {Object} subscriptions\n   */\n  unsubscribe(subscriptions = {}) {\n    // Unsubscribe\n    for (let method in subscriptions) {\n      if (subscriptions.hasOwnProperty(method)) {\n        const subscription = subscriptions[method]\n        this.cometd.unsubscribe(subscription)\n      }\n    }\n    // Remove subscription from queue\n    const { index, queued } = this.getQueuedSubscription(subscriptions)\n    if (queued) {\n      this.subscribeQueue.splice(index, 1)\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/client/helper.js","module.exports = { \"default\": require(\"core-js/library/fn/promise\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/promise.js\n// module id = 113\n// module chunks = 0","require('../modules/es6.object.to-string');\nrequire('../modules/es6.string.iterator');\nrequire('../modules/web.dom.iterable');\nrequire('../modules/es6.promise');\nmodule.exports = require('../modules/_core').Promise;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/promise.js\n// module id = 114\n// module chunks = 0","'use strict';\nvar LIBRARY            = require('./_library')\n  , global             = require('./_global')\n  , ctx                = require('./_ctx')\n  , classof            = require('./_classof')\n  , $export            = require('./_export')\n  , isObject           = require('./_is-object')\n  , aFunction          = require('./_a-function')\n  , anInstance         = require('./_an-instance')\n  , forOf              = require('./_for-of')\n  , speciesConstructor = require('./_species-constructor')\n  , task               = require('./_task').set\n  , microtask          = require('./_microtask')()\n  , PROMISE            = 'Promise'\n  , TypeError          = global.TypeError\n  , process            = global.process\n  , $Promise           = global[PROMISE]\n  , process            = global.process\n  , isNode             = classof(process) == 'process'\n  , empty              = function(){ /* empty */ }\n  , Internal, GenericPromiseCapability, Wrapper;\n\nvar USE_NATIVE = !!function(){\n  try {\n    // correct subclassing with @@species support\n    var promise     = $Promise.resolve(1)\n      , FakePromise = (promise.constructor = {})[require('./_wks')('species')] = function(exec){ exec(empty, empty); };\n    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;\n  } catch(e){ /* empty */ }\n}();\n\n// helpers\nvar sameConstructor = function(a, b){\n  // with library wrapper special case\n  return a === b || a === $Promise && b === Wrapper;\n};\nvar isThenable = function(it){\n  var then;\n  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;\n};\nvar newPromiseCapability = function(C){\n  return sameConstructor($Promise, C)\n    ? new PromiseCapability(C)\n    : new GenericPromiseCapability(C);\n};\nvar PromiseCapability = GenericPromiseCapability = function(C){\n  var resolve, reject;\n  this.promise = new C(function($$resolve, $$reject){\n    if(resolve !== undefined || reject !== undefined)throw TypeError('Bad Promise constructor');\n    resolve = $$resolve;\n    reject  = $$reject;\n  });\n  this.resolve = aFunction(resolve);\n  this.reject  = aFunction(reject);\n};\nvar perform = function(exec){\n  try {\n    exec();\n  } catch(e){\n    return {error: e};\n  }\n};\nvar notify = function(promise, isReject){\n  if(promise._n)return;\n  promise._n = true;\n  var chain = promise._c;\n  microtask(function(){\n    var value = promise._v\n      , ok    = promise._s == 1\n      , i     = 0;\n    var run = function(reaction){\n      var handler = ok ? reaction.ok : reaction.fail\n        , resolve = reaction.resolve\n        , reject  = reaction.reject\n        , domain  = reaction.domain\n        , result, then;\n      try {\n        if(handler){\n          if(!ok){\n            if(promise._h == 2)onHandleUnhandled(promise);\n            promise._h = 1;\n          }\n          if(handler === true)result = value;\n          else {\n            if(domain)domain.enter();\n            result = handler(value);\n            if(domain)domain.exit();\n          }\n          if(result === reaction.promise){\n            reject(TypeError('Promise-chain cycle'));\n          } else if(then = isThenable(result)){\n            then.call(result, resolve, reject);\n          } else resolve(result);\n        } else reject(value);\n      } catch(e){\n        reject(e);\n      }\n    };\n    while(chain.length > i)run(chain[i++]); // variable length - can't use forEach\n    promise._c = [];\n    promise._n = false;\n    if(isReject && !promise._h)onUnhandled(promise);\n  });\n};\nvar onUnhandled = function(promise){\n  task.call(global, function(){\n    var value = promise._v\n      , abrupt, handler, console;\n    if(isUnhandled(promise)){\n      abrupt = perform(function(){\n        if(isNode){\n          process.emit('unhandledRejection', value, promise);\n        } else if(handler = global.onunhandledrejection){\n          handler({promise: promise, reason: value});\n        } else if((console = global.console) && console.error){\n          console.error('Unhandled promise rejection', value);\n        }\n      });\n      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n      promise._h = isNode || isUnhandled(promise) ? 2 : 1;\n    } promise._a = undefined;\n    if(abrupt)throw abrupt.error;\n  });\n};\nvar isUnhandled = function(promise){\n  if(promise._h == 1)return false;\n  var chain = promise._a || promise._c\n    , i     = 0\n    , reaction;\n  while(chain.length > i){\n    reaction = chain[i++];\n    if(reaction.fail || !isUnhandled(reaction.promise))return false;\n  } return true;\n};\nvar onHandleUnhandled = function(promise){\n  task.call(global, function(){\n    var handler;\n    if(isNode){\n      process.emit('rejectionHandled', promise);\n    } else if(handler = global.onrejectionhandled){\n      handler({promise: promise, reason: promise._v});\n    }\n  });\n};\nvar $reject = function(value){\n  var promise = this;\n  if(promise._d)return;\n  promise._d = true;\n  promise = promise._w || promise; // unwrap\n  promise._v = value;\n  promise._s = 2;\n  if(!promise._a)promise._a = promise._c.slice();\n  notify(promise, true);\n};\nvar $resolve = function(value){\n  var promise = this\n    , then;\n  if(promise._d)return;\n  promise._d = true;\n  promise = promise._w || promise; // unwrap\n  try {\n    if(promise === value)throw TypeError(\"Promise can't be resolved itself\");\n    if(then = isThenable(value)){\n      microtask(function(){\n        var wrapper = {_w: promise, _d: false}; // wrap\n        try {\n          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));\n        } catch(e){\n          $reject.call(wrapper, e);\n        }\n      });\n    } else {\n      promise._v = value;\n      promise._s = 1;\n      notify(promise, false);\n    }\n  } catch(e){\n    $reject.call({_w: promise, _d: false}, e); // wrap\n  }\n};\n\n// constructor polyfill\nif(!USE_NATIVE){\n  // 25.4.3.1 Promise(executor)\n  $Promise = function Promise(executor){\n    anInstance(this, $Promise, PROMISE, '_h');\n    aFunction(executor);\n    Internal.call(this);\n    try {\n      executor(ctx($resolve, this, 1), ctx($reject, this, 1));\n    } catch(err){\n      $reject.call(this, err);\n    }\n  };\n  Internal = function Promise(executor){\n    this._c = [];             // <- awaiting reactions\n    this._a = undefined;      // <- checked in isUnhandled reactions\n    this._s = 0;              // <- state\n    this._d = false;          // <- done\n    this._v = undefined;      // <- value\n    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled\n    this._n = false;          // <- notify\n  };\n  Internal.prototype = require('./_redefine-all')($Promise.prototype, {\n    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)\n    then: function then(onFulfilled, onRejected){\n      var reaction    = newPromiseCapability(speciesConstructor(this, $Promise));\n      reaction.ok     = typeof onFulfilled == 'function' ? onFulfilled : true;\n      reaction.fail   = typeof onRejected == 'function' && onRejected;\n      reaction.domain = isNode ? process.domain : undefined;\n      this._c.push(reaction);\n      if(this._a)this._a.push(reaction);\n      if(this._s)notify(this, false);\n      return reaction.promise;\n    },\n    // 25.4.5.1 Promise.prototype.catch(onRejected)\n    'catch': function(onRejected){\n      return this.then(undefined, onRejected);\n    }\n  });\n  PromiseCapability = function(){\n    var promise  = new Internal;\n    this.promise = promise;\n    this.resolve = ctx($resolve, promise, 1);\n    this.reject  = ctx($reject, promise, 1);\n  };\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: $Promise});\nrequire('./_set-to-string-tag')($Promise, PROMISE);\nrequire('./_set-species')(PROMISE);\nWrapper = require('./_core')[PROMISE];\n\n// statics\n$export($export.S + $export.F * !USE_NATIVE, PROMISE, {\n  // 25.4.4.5 Promise.reject(r)\n  reject: function reject(r){\n    var capability = newPromiseCapability(this)\n      , $$reject   = capability.reject;\n    $$reject(r);\n    return capability.promise;\n  }\n});\n$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {\n  // 25.4.4.6 Promise.resolve(x)\n  resolve: function resolve(x){\n    // instanceof instead of internal slot check because we should fix it without replacement native Promise core\n    if(x instanceof $Promise && sameConstructor(x.constructor, this))return x;\n    var capability = newPromiseCapability(this)\n      , $$resolve  = capability.resolve;\n    $$resolve(x);\n    return capability.promise;\n  }\n});\n$export($export.S + $export.F * !(USE_NATIVE && require('./_iter-detect')(function(iter){\n  $Promise.all(iter)['catch'](empty);\n})), PROMISE, {\n  // 25.4.4.1 Promise.all(iterable)\n  all: function all(iterable){\n    var C          = this\n      , capability = newPromiseCapability(C)\n      , resolve    = capability.resolve\n      , reject     = capability.reject;\n    var abrupt = perform(function(){\n      var values    = []\n        , index     = 0\n        , remaining = 1;\n      forOf(iterable, false, function(promise){\n        var $index        = index++\n          , alreadyCalled = false;\n        values.push(undefined);\n        remaining++;\n        C.resolve(promise).then(function(value){\n          if(alreadyCalled)return;\n          alreadyCalled  = true;\n          values[$index] = value;\n          --remaining || resolve(values);\n        }, reject);\n      });\n      --remaining || resolve(values);\n    });\n    if(abrupt)reject(abrupt.error);\n    return capability.promise;\n  },\n  // 25.4.4.4 Promise.race(iterable)\n  race: function race(iterable){\n    var C          = this\n      , capability = newPromiseCapability(C)\n      , reject     = capability.reject;\n    var abrupt = perform(function(){\n      forOf(iterable, false, function(promise){\n        C.resolve(promise).then(capability.resolve, reject);\n      });\n    });\n    if(abrupt)reject(abrupt.error);\n    return capability.promise;\n  }\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.promise.js\n// module id = 115\n// module chunks = 0","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof')\n  , TAG = require('./_wks')('toStringTag')\n  // ES3 wrong here\n  , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function(it, key){\n  try {\n    return it[key];\n  } catch(e){ /* empty */ }\n};\n\nmodule.exports = function(it){\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_classof.js\n// module id = 116\n// module chunks = 0","module.exports = function(it, Constructor, name, forbiddenField){\n  if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){\n    throw TypeError(name + ': incorrect invocation!');\n  } return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_an-instance.js\n// module id = 117\n// module chunks = 0","var ctx         = require('./_ctx')\n  , call        = require('./_iter-call')\n  , isArrayIter = require('./_is-array-iter')\n  , anObject    = require('./_an-object')\n  , toLength    = require('./_to-length')\n  , getIterFn   = require('./core.get-iterator-method')\n  , BREAK       = {}\n  , RETURN      = {};\nvar exports = module.exports = function(iterable, entries, fn, that, ITERATOR){\n  var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)\n    , f      = ctx(fn, that, entries ? 2 : 1)\n    , index  = 0\n    , length, step, iterator, result;\n  if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');\n  // fast case for arrays with default iterator\n  if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){\n    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);\n    if(result === BREAK || result === RETURN)return result;\n  } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){\n    result = call(iterator, f, step.value, entries);\n    if(result === BREAK || result === RETURN)return result;\n  }\n};\nexports.BREAK  = BREAK;\nexports.RETURN = RETURN;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_for-of.js\n// module id = 118\n// module chunks = 0","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function(iterator, fn, value, entries){\n  try {\n    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch(e){\n    var ret = iterator['return'];\n    if(ret !== undefined)anObject(ret.call(iterator));\n    throw e;\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-call.js\n// module id = 119\n// module chunks = 0","// check on default Array iterator\nvar Iterators  = require('./_iterators')\n  , ITERATOR   = require('./_wks')('iterator')\n  , ArrayProto = Array.prototype;\n\nmodule.exports = function(it){\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_is-array-iter.js\n// module id = 120\n// module chunks = 0","var classof   = require('./_classof')\n  , ITERATOR  = require('./_wks')('iterator')\n  , Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function(it){\n  if(it != undefined)return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/core.get-iterator-method.js\n// module id = 121\n// module chunks = 0","// 7.3.20 SpeciesConstructor(O, defaultConstructor)\nvar anObject  = require('./_an-object')\n  , aFunction = require('./_a-function')\n  , SPECIES   = require('./_wks')('species');\nmodule.exports = function(O, D){\n  var C = anObject(O).constructor, S;\n  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_species-constructor.js\n// module id = 122\n// module chunks = 0","var ctx                = require('./_ctx')\n  , invoke             = require('./_invoke')\n  , html               = require('./_html')\n  , cel                = require('./_dom-create')\n  , global             = require('./_global')\n  , process            = global.process\n  , setTask            = global.setImmediate\n  , clearTask          = global.clearImmediate\n  , MessageChannel     = global.MessageChannel\n  , counter            = 0\n  , queue              = {}\n  , ONREADYSTATECHANGE = 'onreadystatechange'\n  , defer, channel, port;\nvar run = function(){\n  var id = +this;\n  if(queue.hasOwnProperty(id)){\n    var fn = queue[id];\n    delete queue[id];\n    fn();\n  }\n};\nvar listener = function(event){\n  run.call(event.data);\n};\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif(!setTask || !clearTask){\n  setTask = function setImmediate(fn){\n    var args = [], i = 1;\n    while(arguments.length > i)args.push(arguments[i++]);\n    queue[++counter] = function(){\n      invoke(typeof fn == 'function' ? fn : Function(fn), args);\n    };\n    defer(counter);\n    return counter;\n  };\n  clearTask = function clearImmediate(id){\n    delete queue[id];\n  };\n  // Node.js 0.8-\n  if(require('./_cof')(process) == 'process'){\n    defer = function(id){\n      process.nextTick(ctx(run, id, 1));\n    };\n  // Browsers with MessageChannel, includes WebWorkers\n  } else if(MessageChannel){\n    channel = new MessageChannel;\n    port    = channel.port2;\n    channel.port1.onmessage = listener;\n    defer = ctx(port.postMessage, port, 1);\n  // Browsers with postMessage, skip WebWorkers\n  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n  } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){\n    defer = function(id){\n      global.postMessage(id + '', '*');\n    };\n    global.addEventListener('message', listener, false);\n  // IE8-\n  } else if(ONREADYSTATECHANGE in cel('script')){\n    defer = function(id){\n      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){\n        html.removeChild(this);\n        run.call(id);\n      };\n    };\n  // Rest old browsers\n  } else {\n    defer = function(id){\n      setTimeout(ctx(run, id, 1), 0);\n    };\n  }\n}\nmodule.exports = {\n  set:   setTask,\n  clear: clearTask\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_task.js\n// module id = 123\n// module chunks = 0","// fast apply, http://jsperf.lnkit.com/fast-apply/5\nmodule.exports = function(fn, args, that){\n  var un = that === undefined;\n  switch(args.length){\n    case 0: return un ? fn()\n                      : fn.call(that);\n    case 1: return un ? fn(args[0])\n                      : fn.call(that, args[0]);\n    case 2: return un ? fn(args[0], args[1])\n                      : fn.call(that, args[0], args[1]);\n    case 3: return un ? fn(args[0], args[1], args[2])\n                      : fn.call(that, args[0], args[1], args[2]);\n    case 4: return un ? fn(args[0], args[1], args[2], args[3])\n                      : fn.call(that, args[0], args[1], args[2], args[3]);\n  } return              fn.apply(that, args);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_invoke.js\n// module id = 124\n// module chunks = 0","var global    = require('./_global')\n  , macrotask = require('./_task').set\n  , Observer  = global.MutationObserver || global.WebKitMutationObserver\n  , process   = global.process\n  , Promise   = global.Promise\n  , isNode    = require('./_cof')(process) == 'process';\n\nmodule.exports = function(){\n  var head, last, notify;\n\n  var flush = function(){\n    var parent, fn;\n    if(isNode && (parent = process.domain))parent.exit();\n    while(head){\n      fn   = head.fn;\n      head = head.next;\n      try {\n        fn();\n      } catch(e){\n        if(head)notify();\n        else last = undefined;\n        throw e;\n      }\n    } last = undefined;\n    if(parent)parent.enter();\n  };\n\n  // Node.js\n  if(isNode){\n    notify = function(){\n      process.nextTick(flush);\n    };\n  // browsers with MutationObserver\n  } else if(Observer){\n    var toggle = true\n      , node   = document.createTextNode('');\n    new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new\n    notify = function(){\n      node.data = toggle = !toggle;\n    };\n  // environments with maybe non-completely correct, but existent Promise\n  } else if(Promise && Promise.resolve){\n    var promise = Promise.resolve();\n    notify = function(){\n      promise.then(flush);\n    };\n  // for other environments - macrotask based on:\n  // - setImmediate\n  // - MessageChannel\n  // - window.postMessag\n  // - onreadystatechange\n  // - setTimeout\n  } else {\n    notify = function(){\n      // strange IE + webpack dev server bug - use .call(global)\n      macrotask.call(global, flush);\n    };\n  }\n\n  return function(fn){\n    var task = {fn: fn, next: undefined};\n    if(last)last.next = task;\n    if(!head){\n      head = task;\n      notify();\n    } last = task;\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_microtask.js\n// module id = 125\n// module chunks = 0","var hide = require('./_hide');\nmodule.exports = function(target, src, safe){\n  for(var key in src){\n    if(safe && target[key])target[key] = src[key];\n    else hide(target, key, src[key]);\n  } return target;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_redefine-all.js\n// module id = 126\n// module chunks = 0","'use strict';\nvar global      = require('./_global')\n  , core        = require('./_core')\n  , dP          = require('./_object-dp')\n  , DESCRIPTORS = require('./_descriptors')\n  , SPECIES     = require('./_wks')('species');\n\nmodule.exports = function(KEY){\n  var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];\n  if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {\n    configurable: true,\n    get: function(){ return this; }\n  });\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_set-species.js\n// module id = 127\n// module chunks = 0","var ITERATOR     = require('./_wks')('iterator')\n  , SAFE_CLOSING = false;\n\ntry {\n  var riter = [7][ITERATOR]();\n  riter['return'] = function(){ SAFE_CLOSING = true; };\n  Array.from(riter, function(){ throw 2; });\n} catch(e){ /* empty */ }\n\nmodule.exports = function(exec, skipClosing){\n  if(!skipClosing && !SAFE_CLOSING)return false;\n  var safe = false;\n  try {\n    var arr  = [7]\n      , iter = arr[ITERATOR]();\n    iter.next = function(){ return {done: safe = true}; };\n    arr[ITERATOR] = function(){ return iter; };\n    exec(arr);\n  } catch(e){ /* empty */ }\n  return safe;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_iter-detect.js\n// module id = 128\n// module chunks = 0","import { Service } from './core'\n/**\n * Data aggregation\n *\n * Provides data aggregation over time and across different items\n *  User devices push items data on developer-defined categories\n *  This service automatically aggregates the data\n * Raw data is not available for reading, only the generated aggregation result\n *\n * */\n/**\n * User API for item aggregation\n *\n * Users can push data and be notified of aggregated data.\n * This service does not allow you to read the data. To achieve that kind of behavior, you could configure a callback to store the data.\n * @access public\n * */\nexport class Aggreg extends Service {\n\t/**\n\t * Get default deployment id associated to Aggreg service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'aggreg_0'\n\t}\n\t/**\n\t * Pushes some data\n\t *\n\t * Pushes the given data.\n\t * All the items are processed according to the defined rules.\n\t * At least one push for a given item is needed during a time period to trigger processing and calling of the corresponding callback verb/macro.\n\t * */\n\tpush({items,owner}) { return this.$publish('push', {items,owner})}\n}\n/**\n * Data stacks\n *\n * Stacks are a per-user named persistent queue of data\n *  An administrator creates a stack service\n *  End-users can push data on an arbitrary number of their own arbitrary named stacks\n * */\n/**\n * Data stack user API\n *\n * Data is stored on a per user basis. However, notifications can be sent to a configurable set of listeners.\n * Stack names are arbitrary and do not need to be explicitly initialized.\n * @access public\n * */\nexport class Stack extends Service {\n\t/**\n\t * Get default deployment id associated to Stack service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'stack_0'\n\t}\n\t/**\n\t * Lists the listeners\n\t *\n\t * Returns the whole list of listeners for the given stack.\n\t * */\n\tgetListeners({owner,stack}) { return this.$publish('getListeners', {owner,stack})}\n\t/**\n\t * Lists content\n\t *\n\t * Returns a paginated list of contents for the given stack.\n\t * Content is sorted according to the statically configured order.\n\t * */\n\tlist({owner,page,stack}) { return this.$publish('list', {owner,page,stack})}\n\t/**\n\t * Empties a stack\n\t *\n\t * Removes all items from the given stack.\n\t * */\n\tpurge({owner,stack}) { return this.$publish('purge', {owner,stack})}\n\t/**\n\t * Pushes an item\n\t *\n\t * Pushes an item onto the given stack.\n\t * The stack does not need to be created.\n\t * */\n\tpush({stack,data,owner}) { return this.$publish('push', {stack,data,owner})}\n\t/**\n\t * Removes items\n\t *\n\t * Removes the item with the given guid from the given stack.\n\t * */\n\tremove({guids,owner,stack}) { return this.$publish('remove', {guids,owner,stack})}\n\t/**\n\t * Sets the listeners\n\t *\n\t * Sets the listeners for the given stack.\n\t * */\n\tsetListeners({listeners,owner,stack}) { return this.$publish('setListeners', {listeners,owner,stack})}\n\t/**\n\t * Updates an item\n\t *\n\t * Updates an existing item of the given stack.\n\t * The item MUST exist prior to the call.\n\t * */\n\tupdate({guid,stack,data,owner}) { return this.$publish('update', {guid,stack,data,owner})}\n}\n/**\n * Echo\n *\n * Echo\n * */\n/**\n * Echo service\n *\n * Simple echo service, for development purposes.\n * @access public\n * */\nexport class Echo extends Service {\n\t/**\n\t * Get default deployment id associated to Echo service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'echo_0'\n\t}\n\t/**\n\t * Echoes an object\n\t *\n\t * Echoes an object: the server will echo that object on channel 'echo' for the current user.\n\t * */\n\techo(parameter) { return this.$publish('echo', parameter)}\n}\n/**\n * Game engine\n *\n * Abstract Game Engine\n *  Concrete game engines are remote cometd clients or internal macros\n * */\n/**\n * Game Engine API\n *\n * The Game Engine API is for game engine clients, not end-users.\n * @access public\n * */\nexport class GameEngine extends Service {\n\t/**\n\t * Get default deployment id associated to GameEngine service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'game_0'\n\t}\n\t/**\n\t * Notify the result for a join request\n\t *\n\t * A Game Engine notifies the STR of the result of a join request that it received on join_callback\n\t * */\n\tjoin_result({callerId,error,msgId,payload}) { return this.$publish('join_result', {callerId,error,msgId,payload})}\n\t/**\n\t * Notify the result for an organization request\n\t *\n\t * A Game Engine notifies the STR of the result of an organization request that it received on organize_callback\n\t * */\n\torganize_result({callerId,error,msgId,payload}) { return this.$publish('organize_result', {callerId,error,msgId,payload})}\n\t/**\n\t * Registers a game engine\n\t *\n\t * A client registers itself to the STR as a Game Engine.\n\t * The STR may, from now on, dispatch game of the given game type to said client.\n\t * Unregistration is done automatically on logoff.\n\t * */\n\tregister({gameInfo,location,maxGames}) { return this.$publish('register', {gameInfo,location,maxGames})}\n\t/**\n\t * Notify the result for a start request\n\t *\n\t * A Game Engine notifies the STR of the result of a start request that it received on start_callback\n\t * */\n\tstart_result({gameId}) { return this.$publish('start_result', {gameId})}\n\t/**\n\t * Notify a game event\n\t *\n\t * A Game Engine notifies the STR of some arbitrary game event.\n\t * */\n\tstate({data,gameId,status}) { return this.$publish('state', {data,gameId,status})}\n\t/**\n\t * Notify the result for an unjoin request\n\t *\n\t * A Game Engine notifies the STR of the result of an unjoin request that it received on unjoin_callback\n\t * */\n\tunjoin_result({callerId,error,msgId,payload}) { return this.$publish('unjoin_result', {callerId,error,msgId,payload})}\n}\n/**\n * User API for games\n *\n * Users can list, start, join games, and play.\n * @access public\n * */\nexport class Game extends Service {\n\t/**\n\t * Get default deployment id associated to Game service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'game_0'\n\t}\n\t/**\n\t * Lists game types\n\t *\n\t * Returns the list of game types supported by the server and the currently registered game engines.\n\t * */\n\tavailable() { return this.$publish('available', {})}\n\t/**A user joins a game*/\n\tjoin({gameId,role,userId,userName}) { return this.$publish('join', {gameId,role,userId,userName})}\n\t/**Organizes a game*/\n\torganize({type,owner,options}) { return this.$publish('organize', {type,owner,options})}\n\t/**Gives some command to the game engine*/\n\tplay({data,gameId,userId}) { return this.$publish('play', {data,gameId,userId})}\n\t/**Starts a game*/\n\tstart({gameId}) { return this.$publish('start', {gameId})}\n\t/**A user cancels joining a game*/\n\tunjoin({gameId,role,userId,userName}) { return this.$publish('unjoin', {gameId,role,userId,userName})}\n}\n/**\n * Generic Data Access\n *\n * Generic Data Access Service : NoSQL storage\n * */\n/**\n * GDA User API\n *\n * User API for Generic Data Access.\n * Data is stored on a per-user basis.\n * Users can put, get, list their data.\n * @access public\n * */\nexport class Gda extends Service {\n\t/**\n\t * Get default deployment id associated to Gda service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'gda_0'\n\t}\n\t/**\n\t * Asks for a data row\n\t *\n\t * Returns a full data row.\n\t * */\n\tget({key,owner,table}) { return this.$publish('get', {key,owner,table})}\n\t/**\n\t * Asks for a data cell\n\t *\n\t * Returns a precise list of cells from a column in a data row.\n\t * */\n\tgetCells({column,key,key2,owner,table}) { return this.$publish('getCells', {column,key,key2,owner,table})}\n\t/**\n\t * Increments an integer value\n\t *\n\t * Increments a cell 64-bit signed integer value and returns the result in the data field.\n\t * The increment is atomic : if you concurrently increment 10 times a value by 1, the final result will be the initial value plus 10. The actual individual resulting values seen by the 10 concurrent callers may vary discontinuously, with duplicates : at least one of them will see the final (+10) result.\n\t * */\n\tinc({table,data,key,key2,owner,column}) { return this.$publish('inc', {table,data,key,key2,owner,column})}\n\t/**\n\t * Asks for a list of rows\n\t *\n\t * Returns a paginated list of rows from the given table.\n\t * */\n\tlist({columns,owner,page,table}) { return this.$publish('list', {columns,owner,page,table})}\n\t/**\n\t * Puts some data into a cell\n\t *\n\t * Creates or replaces the contents of a particular cell.\n\t * */\n\tput({column,data,key,key2,owner,table}) { return this.$publish('put', {column,data,key,key2,owner,table})}\n\t/**\n\t * Puts several rows\n\t *\n\t * Creates or replaces the (maybe partial) contents of a collection of rows.\n\t * This method only creates or replaces cells for non-null input values.\n\t * */\n\tputs({owner,rows,table}) { return this.$publish('puts', {owner,rows,table})}\n\t/**\n\t * Asks for a range of rows\n\t *\n\t * Returns a paginated range of rows from the given table.\n\t * A range consists of consecutive rows from the start key (inclusive) to the stop key (exclusive).\n\t * You can specify partial keys for the start and stop fields.\n\t * */\n\trange({columns,owner,page,start,stop,table}) { return this.$publish('range', {columns,owner,page,start,stop,table})}\n\t/**\n\t * Removes one cell inside a column of a row\n\t *\n\t * Removes only one cell of the given column of the given row from the given table.\n\t * */\n\tremoveCell({column,key,key2,owner,table}) { return this.$publish('removeCell', {column,key,key2,owner,table})}\n\t/**\n\t * Removes one full column of a row\n\t *\n\t * Removes all cells of the given column of the given row from the given table.\n\t * */\n\tremoveColumn({column,key,owner,table}) { return this.$publish('removeColumn', {column,key,owner,table})}\n\t/**\n\t * Removes a range of rows\n\t *\n\t * Removes the specified columns of the given range of rows from the given table.\n\t * */\n\tremoveRange({columns,owner,start,stop,table}) { return this.$publish('removeRange', {columns,owner,start,stop,table})}\n\t/**\n\t * Removes one full row\n\t *\n\t * Removes all columns of the given row from the given table.\n\t * */\n\tremoveRow({key,owner,table}) { return this.$publish('removeRow', {key,owner,table})}\n}\n/**\n * Groups Management\n *\n * Groups management for users, grants on resources, remote commands on devices\n *  This is where you can configure rights for any resource\n *\n * */\n/**\n * User API for remote control\n *\n * @access public\n * */\nexport class Remoting extends Service {\n\t/**\n\t * Get default deployment id associated to Remoting service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'groups_0'\n\t}\n\t/**\n\t * Adds a listener\n\t *\n\t * A user requests notifications from a device owned by anyone who granted him the right authorizations.\n\t * Whenever the device calls 'notify', notifications will be sent to the caller of this verb.\n\t * */\n\taddListener({cmd,data,from,fromResource,owner,resource}) { return this.$publish('addListener', {cmd,data,from,fromResource,owner,resource})}\n\t/**Response to 'getCapabilities'*/\n\tcapabilities({answeringResource,askingResource,capabilities}) { return this.$publish('capabilities', {answeringResource,askingResource,capabilities})}\n\t/**\n\t * Executes a command\n\t *\n\t * A user executes a command on a device owned by anyone who granted him the right authorizations.\n\t * The command is issued on channel 'command'\n\t * */\n\texecute({resource,cmd,data,owner}) { return this.$publish('execute', {resource,cmd,data,owner})}\n\t/**\n\t * Requests capabilities\n\t *\n\t * A user requests all his devices for the whole list of their capabilities.\n\t * Devices are expected to answer on channel 'capabilities'\n\t * */\n\tgetCapabilities() { return this.$publish('getCapabilities', {})}\n\t/**\n\t * Notifies of some event\n\t *\n\t * A device notifies the registered users/devices on this channel.\n\t * The server forwards the notification to said users.\n\t * */\n\tnotify({cmd,data,from,fromResource,owner,resource}) { return this.$publish('notify', {cmd,data,from,fromResource,owner,resource})}\n\t/**\n\t * Pings devices\n\t *\n\t * A user requests all devices (of all owners) on which he has authorizations to respond on channel 'pong'\n\t * */\n\tping({action}) { return this.$publish('ping', {action})}\n\t/**Response to ping*/\n\tpong({action,available,owner,resource,uid,user}) { return this.$publish('pong', {action,available,owner,resource,uid,user})}\n\t/**\n\t * Removes a listener\n\t *\n\t * A user stops requesting notifications from a device owned by anyone who granted him the right authorizations\n\t * */\n\tremoveListener({cmd,data,from,fromResource,owner,resource}) { return this.$publish('removeListener', {cmd,data,from,fromResource,owner,resource})}\n}\n/**\n * User API for groups and rights.\n *\n * Groups are stored per user.\n * This means that two users can own a group with the same identifier. A couple (owner, group) is needed to uniquely identify a group inside a group management service.\n * The triplet (deploymentId, owner, group) is actually needed to fully qualify a group outside of the scope of this service.\n * @access public\n * */\nexport class GroupManagement extends Service {\n\t/**\n\t * Get default deployment id associated to GroupManagement service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'groups_0'\n\t}\n\t/**\n\t * Adds me to a group\n\t *\n\t * Adds me (the caller) to a group.\n\t * This verb exists so that group owners may grant the right to join their groups without granting the right to add other users to those groups.\n\t * The 'user' field is implicitly set to the current user's key.\n\t * */\n\taddMe({group,owner}) { return this.$publish('addMe', {group,owner})}\n\t/**\n\t * Adds a user to a group\n\t *\n\t * Adds the given user to the given group.\n\t * Addition may fail if the given group does not already exist.\n\t * */\n\taddUser({user,group,owner}) { return this.$publish('addUser', {user,group,owner})}\n\t/**Adds users to a group*/\n\taddUsers({users,group,owner}) { return this.$publish('addUsers', {users,group,owner})}\n\t/**\n\t * Lists my owned groups, with details\n\t *\n\t * Returns the whole list of groups owned by the current user, with their members\n\t * */\n\tallGroups({owner}) { return this.$publish('allGroups', {owner})}\n\t/**\n\t * Creates a group\n\t *\n\t * Creates a group owned by the current user.\n\t * Group creation may fail if the group already exists.\n\t * */\n\tcreateGroup({group,groupName,owner}) { return this.$publish('createGroup', {group,groupName,owner})}\n\t/**\n\t * Removes a group\n\t *\n\t * Removes the given group owned by the current user or the given owner.\n\t * Also removes all grants to that group.\n\t * */\n\tdelGroup({group,owner}) { return this.$publish('delGroup', {group,owner})}\n\t/**Removes a user from a group*/\n\tdelUser({group,owner,user}) { return this.$publish('delUser', {group,owner,user})}\n\t/**Removes users from a group*/\n\tdelUsers({group,groupName,owner,users}) { return this.$publish('delUsers', {group,groupName,owner,users})}\n\t/**\n\t * Tests for a group's existence\n\t *\n\t * Returns whether a group exists or not.\n\t * */\n\texists({group,owner}) { return this.$publish('exists', {group,owner})}\n\t/**\n\t * Grants a right to a group\n\t *\n\t * The granting API does not do any check when storing permissions.\n\t * In particular when granting rights on a verb and resource of another API, the existence of said verb and resource is not checked.\n\t * */\n\tgrant({action,group,owner,resource}) { return this.$publish('grant', {action,group,owner,resource})}\n\t/**\n\t * Lists the group users\n\t *\n\t * Returns the whole list of users configured inside the given group.\n\t * */\n\tgroupUsers({group,owner}) { return this.$publish('groupUsers', {group,owner})}\n\t/**\n\t * Lists my owned groups\n\t *\n\t * Returns the whole list of groups owned by the current user\n\t * */\n\tgroups({owner}) { return this.$publish('groups', {owner})}\n\t/**\n\t * Lists rights for a group\n\t *\n\t * This API lists explicitly configured rights.\n\t * Effective rights include configured rights, implicit rights and inherited rights.\n\t * */\n\tlistGrants({group,owner}) { return this.$publish('listGrants', {group,owner})}\n\t/**\n\t * Lists presences for a group\n\t *\n\t * Returns the list of members of the given groups, along with their actual and current presence on the zetapush server.\n\t * The current implementation does not include information about the particular devices users are connected with.\n\t * If a user is connected twice with two different devices, two identical entries will be returned.\n\t * */\n\tlistPresences({group,owner}) { return this.$publish('listPresences', {group,owner})}\n\t/**\n\t * Tests membership\n\t *\n\t * Tests whether I (the caller) am a member of the given group.\n\t * This verb exists so that users can determine if they are part of a group without being granted particular rights.\n\t * The 'user' field is implicitly set to the current user's key.\n\t * */\n\tmemberOf({hardFail,group,owner}) { return this.$publish('memberOf', {hardFail,group,owner})}\n\t/**\n\t * Grants rights to a group\n\t *\n\t * Grant several rights at once.\n\t * */\n\tmgrant({actions,group,owner,resource}) { return this.$publish('mgrant', {actions,group,owner,resource})}\n\t/**Revokes rights for a group*/\n\tmrevoke({actions,group,owner,resource}) { return this.$publish('mrevoke', {actions,group,owner,resource})}\n\t/**\n\t * Lists the groups I am part of\n\t *\n\t * Returns the whole list of groups the current user is part of.\n\t * Groups may be owned by anyone, including the current user.\n\t * */\n\tmyGroups({owner}) { return this.$publish('myGroups', {owner})}\n\t/**Revokes a right for a group*/\n\trevoke({action,group,owner,resource}) { return this.$publish('revoke', {action,group,owner,resource})}\n}\n/**\n * HTTP client\n *\n * Web-service client\n *  An admin records URL templates that can be called by users\n *  Calls are not configurable by end-users\n *  However an admin may leverage the macro service to achieve URL, headers and body configurability\n * */\n/**\n * User API for http requests\n *\n * @access public\n * */\nexport class Httpclient extends Service {\n\t/**\n\t * Get default deployment id associated to Httpclient service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'httpclient_0'\n\t}\n\t/**\n\t * Makes a predefined request\n\t *\n\t * Lookups a predefined request by name, and executes it.\n\t * */\n\tcall({name,requestId}) { return this.$publish('call', {name,requestId})}\n}\n/**\n * Macros\n *\n * Macro-command service\n *  An admin defines macro-commands that can sequentially call any number of other api verbs, loop on collections of data, make decisions, etc\n *\n *\n *  End-users play them, with contextual parameters\n * */\n/**\n * User API for macro execution\n *\n * Simple errors are reported as usual.\n * However, the macro execution verbs treat most errors in a particular way : instead of reporting errors on the usual 'error' channel, errors are put in the returned 'MacroCompletion' result.\n * This behavior can be tuned on a per-call basis with the hardFail parameter.\n * Note that some particular errors will always behave as if hardFail were true, because they are related to programming errors, or prevent processing from ending gracefully : STACK_OVERFLOW, NO_SUCH_FUNCTION, RAM_EXCEEDED, CYCLES_EXCEEDED, TIME_EXCEEDED, QUOTA_EXCEEDED, RATE_EXCEEDED, BAD_COMPARATOR_VALUE\n * @access public\n * */\nexport class Macro extends Service {\n\t/**\n\t * Get default deployment id associated to Macro service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'macro_0'\n\t}\n\t/**\n\t * Plays a previously recorded macro\n\t *\n\t * DO NOT use this verb from inside an enclosing macro when you need the result in order to proceed with the enclosing macro.\n\t * You can override the default notification channel when defining the macro.\n\t * */\n\tcall({debug,hardFail,name,parameters}) { return this.$publish('call', {debug,hardFail,name,parameters})}\n}\n/**\n * User API for macro debugging\n *\n * Debugger API for macro.\n * These API verbs are not intended for use by most developers.\n * @access public\n * */\nexport class MacroDebug extends Service {\n\t/**\n\t * Get default deployment id associated to MacroDebug service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'macro_0'\n\t}\n\t/**Enables or disables a breakpoint*/\n\tbreakpoint({breakpoint,enabled,token}) { return this.$publish('breakpoint', {breakpoint,enabled,token})}\n\t/**Requests some information*/\n\tinfo({exp,frame,token}) { return this.$publish('info', {exp,frame,token})}\n\t/**\n\t * Debugs a previously recorded macro\n\t *\n\t * The given breakpoints will be honored, causing a suspension of the execution, resumable via 'resume'.\n\t * Only one debug session can be active at any given time.\n\t * */\n\tlivedebug({breakpoints,debug,hardFail,name,parameters,token}) { return this.$publish('livedebug', {breakpoints,debug,hardFail,name,parameters,token})}\n\t/**Resumes a paused macro*/\n\tresume({token,type}) { return this.$publish('resume', {token,type})}\n\t/**Sets a variable value*/\n\tvariable({data,frame,name,token}) { return this.$publish('variable', {data,frame,name,token})}\n}\n/**\n * Mail sender\n *\n * Sends email through SMTP\n * */\n/**\n * Mail service user API\n *\n * This service is statically configured with an outgoing SMTP server.\n * Users call the API here to actually send emails.\n * @access public\n * */\nexport class Sendmail extends Service {\n\t/**\n\t * Get default deployment id associated to Sendmail service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'sendmail_0'\n\t}\n}\n/**\n * Messaging service\n *\n * Messaging service\n * */\n/**\n * Messaging service\n *\n * Simple and flexible user-to-user or user-to-group messaging service.\n * @access public\n * */\nexport class Messaging extends Service {\n\t/**\n\t * Get default deployment id associated to Messaging service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'messaging_0'\n\t}\n\t/**\n\t * Sends a message to a target\n\t *\n\t * Sends the given message to the specified target on the given (optional) channel.\n\t * The administratively given default channel name is used when none is provided in the message itself.\n\t * */\n\tsend({target,channel,data}) { return this.$publish('send', {target,channel,data})}\n}\n/**\n * Producer consumer\n *\n * Producer consumer service\n *  Users can submit tasks and other users consume them\n * */\n/**\n * Producer / consumer real-time API\n *\n * Task producers submits their tasks.\n * The server dispatches the tasks.\n * Consumers process them and report completion back to the server.\n * Tasks are global to the service (i.e. NOT per user).\n * @access public\n * */\nexport class Queue extends Service {\n\t/**\n\t * Get default deployment id associated to Queue service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'queue_0'\n\t}\n\t/**\n\t * Submits a task\n\t *\n\t * Producer API.\n\t * A task producer submits the given task to the server.\n\t * The server will find a tasker with processing capacity and dispatch the task.\n\t * The task result will be returned to the caller.\n\t * When called from inside a macro, the comsumer generated result is available for further use.\n\t * */\n\tcall({description,originBusinessId,originDeploymentId,data,owner}) { return this.$publish('call', {description,originBusinessId,originDeploymentId,data,owner})}\n\t/**\n\t * Notifies completion of a task\n\t *\n\t * Consumer API.\n\t * The tasker notifies completion of the given task to the server.\n\t * The tasker can optionally include a result or an error code.\n\t * */\n\tdone({result,success,taskId}) { return this.$publish('done', {result,success,taskId})}\n\t/**\n\t * Registers a consumer\n\t *\n\t * Consumer API.\n\t * Registers the current user resource as an available task consumer.\n\t * Tasks will be then dispatched to that consumer.\n\t * */\n\tregister({capacity}) { return this.$publish('register', {capacity})}\n\t/**\n\t * Submits a task\n\t *\n\t * Producer API.\n\t * A task producer submits the given task to the server.\n\t * The server will find a tasker with processing capacity and dispatch the task.\n\t * The task result will be ignored : the producer will not receive any notification of any kind, even in case of errors (including capacity exceeded errors).\n\t * This verb will return immediately : you can use this API to asynchronously submit a task.\n\t * */\n\tsubmit({description,originBusinessId,originDeploymentId,data,owner}) { return this.$publish('submit', {description,originBusinessId,originDeploymentId,data,owner})}\n\t/**\n\t * Unregisters a consumer\n\t *\n\t * Consumer API.\n\t * Unregisters the current user resource as an available task consumer.\n\t * All non finished tasks are returned to the server.\n\t * */\n\tunregister() { return this.$publish('unregister', {})}\n}\n/**\n * Push Notifications\n *\n * Native Push Notifications for Android, iOS\n *\n *\n *\n * */\n/**\n * Notification User API\n *\n * User API for notifications.\n * For notifications to work properly, it is imperative that the resource name of a device remain constant over time.\n * @access public\n * */\nexport class Notif extends Service {\n\t/**\n\t * Get default deployment id associated to Notif service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'notif_0'\n\t}\n}\n/**\n * SMS via OVH\n *\n * SMS sender, to send text messages to mobile phones\n * This SMS sending service uses the OVH API\n *\n * */\n/**\n * SMS service\n *\n * User API for SMS.\n * @access public\n * */\nexport class Sms_ovh extends Service {\n\t/**\n\t * Get default deployment id associated to Sms_ovh service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'sms_ovh_0'\n\t}\n}\n/**\n * Scheduler\n *\n * Scheduler service\n *  End-users can schedule one-time or repetitive tasks using a classical cron syntax (with the year field) or a timestamp (milliseconds from the epoch)\n * */\n/**\n * User API for the Scheduler\n *\n * User endpoints for scheduling : users can schedule, list and delete tasks.\n * Tasks are stored on a per-user basis: a task will run with the priviledges of the user who stored it.\n * Tasks are run on the server and thus can call api verbs marked as server-only.\n * @access public\n * */\nexport class Cron extends Service {\n\t/**\n\t * Get default deployment id associated to Cron service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'cron_0'\n\t}\n\t/**\n\t * List the configured tasks\n\t *\n\t * Returns a paginated list of the asking user's tasks.\n\t * */\n\tlist({owner,page,start,stop}) { return this.$publish('list', {owner,page,start,stop})}\n\t/**\n\t * Removes a scheduled task\n\t *\n\t * Removes a previously scheduled task.\n\t * Does absolutely nothing if asked to remove a non-existent task.\n\t * */\n\tunschedule({cronName,owner}) { return this.$publish('unschedule', {cronName,owner})}\n}\n/**\n * Search engine\n *\n * ElasticSearch engine, to index and search data\n *  An admin creates indices\n *  Users index and search documents\n *\n * */\n/**\n * ElasticSearch Service\n *\n * This API is a very thin wrapper around ElasticSearch's API.\n * @access public\n * */\nexport class Search extends Service {\n\t/**\n\t * Get default deployment id associated to Search service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'search_0'\n\t}\n\t/**\n\t * Deletes data\n\t *\n\t * Deletes a document from the elasticsearch engine by id.\n\t * */\n\tdelete({id,index,type}) { return this.$publish('delete', {id,index,type})}\n\t/**\n\t * Gets data\n\t *\n\t * Retrieves a document from the elasticsearch engine by id.\n\t * */\n\tget({id,index,type}) { return this.$publish('get', {id,index,type})}\n\t/**\n\t * Indexes data\n\t *\n\t * Inserts or updates a document into the elasticsearch engine.\n\t * */\n\tindex({data,id,index,type}) { return this.$publish('index', {data,id,index,type})}\n\t/**Searches for data*/\n\tsearch({indices,page,query,sort,types}) { return this.$publish('search', {indices,page,query,sort,types})}\n}\n/**\n * Template engine\n *\n * Template engine to produce documents from parameterized templates\n * <br>An admin creates templates\n * <br> Users produce documents\n * <br>The implementation uses the <a href='http://freemarker\n * org/'>freemarker</a> engine\n *\n * */\n/**\n * User API for templates\n *\n * Users use this API to evaluate pre-configured templates.\n * @access public\n * */\nexport class Template extends Service {\n\t/**\n\t * Get default deployment id associated to Template service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'template_0'\n\t}\n\t/**\n\t * Evaluates a template\n\t *\n\t * Evaluates the given template and returns the result as a string.\n\t * Templates are parsed the first time they are evaluated. Evaluation may fail early due to a parsing error.\n\t * */\n\tevaluate({data,languageTag,name,requestId}) { return this.$publish('evaluate', {data,languageTag,name,requestId})}\n}\n/**\n * Upload: S3\n *\n * Upload service with S3 storage\n * */\n/**\n * User API for file management\n *\n * User API for virtual file management and http file upload\n * This API contains all the verbs needed to browse, upload and remove files.\n * Files are stored on a per-user basis: each user has his or her own whole virtual filesystem.\n * Uploading a file is a 3-step process : request an upload URL, upload via HTTP, notify this service of completion.\n * @access public\n * */\nexport class Zpfs_s3 extends Service {\n\t/**\n\t * Get default deployment id associated to Zpfs_s3 service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'zpfs_s3_0'\n\t}\n\t/**\n\t * Copies a file\n\t *\n\t * Copies a file or folder (recursively) to a new location.\n\t * May fail if the target location is not empty.\n\t * */\n\tcp({oldPath,owner,path}) { return this.$publish('cp', {oldPath,owner,path})}\n\t/**\n\t * Returns disk usage\n\t *\n\t * Returns an recursively aggregated number of used bytes, starting at the given path.\n\t * */\n\tdu({owner,path}) { return this.$publish('du', {owner,path})}\n\t/**\n\t * Links a file\n\t *\n\t * Links a file or folder to another location.\n\t * May fail if the target location is not empty.\n\t * */\n\tlink({oldPath,owner,path}) { return this.$publish('link', {oldPath,owner,path})}\n\t/**\n\t * Lists a folder content\n\t *\n\t * Returns a paginated list of the folder's content.\n\t * */\n\tls({folder,owner,page}) { return this.$publish('ls', {folder,owner,page})}\n\t/**\n\t * Creates a folder\n\t *\n\t * Creates a new folder.\n\t * May fail if the target location is not empty.\n\t * */\n\tmkdir({folder,owner,parents}) { return this.$publish('mkdir', {folder,owner,parents})}\n\t/**\n\t * Moves a file\n\t *\n\t * Moves a file or folder (recursively) to a new location.\n\t * May fail if the target location is not empty.\n\t * */\n\tmv({oldPath,owner,path}) { return this.$publish('mv', {oldPath,owner,path})}\n\t/**\n\t * Notifies of upload completion\n\t *\n\t * The client application calls this verb to notify that it's done uploading to the cloud.\n\t * Calling that verb MAY trigger additional events such as thumbnail/metadata creation.\n\t * */\n\tnewFile({guid,metadata,owner,tags}) { return this.$publish('newFile', {guid,metadata,owner,tags})}\n\t/**\n\t * Requests an upload URL\n\t *\n\t * Requests an HTTP upload URL.\n\t * The URL contains temporary credentials (typically valid for a few minutes) and is meant for immediate use.\n\t * */\n\tnewUploadUrl({contentType,owner,path}) { return this.$publish('newUploadUrl', {contentType,owner,path})}\n\t/**\n\t * Removes a file\n\t *\n\t * Removes a file or folder (recursively).\n\t * */\n\trm({owner,path}) { return this.$publish('rm', {owner,path})}\n\t/**\n\t * Returns information about a file\n\t *\n\t * Returns information about a single file.\n\t * The entry field will be null if the path does not exist\n\t * */\n\tstat({owner,path}) { return this.$publish('stat', {owner,path})}\n\t/**Updates a file's metadata*/\n\tupdateMeta({metadata,metadataFiles,owner,path}) { return this.$publish('updateMeta', {metadata,metadataFiles,owner,path})}\n}\n/**\n * Upload: local\n *\n * Upload service with local HDFS storage\n * */\n/**\n * User API for file management\n *\n * User API for virtual file management and http file upload\n * This API contains all the verbs needed to browse, upload and remove files.\n * Files are stored on a per-user basis: each user has his or her own whole virtual filesystem.\n * Uploading a file is a 3-step process : request an upload URL, upload via HTTP, notify this service of completion.\n * @access public\n * */\nexport class Zpfs_hdfs extends Service {\n\t/**\n\t * Get default deployment id associated to Zpfs_hdfs service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'zpfs_hdfs_0'\n\t}\n\t/**\n\t * Copies a file\n\t *\n\t * Copies a file or folder (recursively) to a new location.\n\t * May fail if the target location is not empty.\n\t * */\n\tcp({oldPath,owner,path}) { return this.$publish('cp', {oldPath,owner,path})}\n\t/**\n\t * Returns disk usage\n\t *\n\t * Returns an recursively aggregated number of used bytes, starting at the given path.\n\t * */\n\tdu({owner,path}) { return this.$publish('du', {owner,path})}\n\t/**\n\t * Links a file\n\t *\n\t * Links a file or folder to another location.\n\t * May fail if the target location is not empty.\n\t * */\n\tlink({oldPath,owner,path}) { return this.$publish('link', {oldPath,owner,path})}\n\t/**\n\t * Lists a folder content\n\t *\n\t * Returns a paginated list of the folder's content.\n\t * */\n\tls({folder,owner,page}) { return this.$publish('ls', {folder,owner,page})}\n\t/**\n\t * Creates a folder\n\t *\n\t * Creates a new folder.\n\t * May fail if the target location is not empty.\n\t * */\n\tmkdir({folder,owner,parents}) { return this.$publish('mkdir', {folder,owner,parents})}\n\t/**\n\t * Moves a file\n\t *\n\t * Moves a file or folder (recursively) to a new location.\n\t * May fail if the target location is not empty.\n\t * */\n\tmv({oldPath,owner,path}) { return this.$publish('mv', {oldPath,owner,path})}\n\t/**\n\t * Notifies of upload completion\n\t *\n\t * The client application calls this verb to notify that it's done uploading to the cloud.\n\t * Calling that verb MAY trigger additional events such as thumbnail/metadata creation.\n\t * */\n\tnewFile({guid,metadata,owner,tags}) { return this.$publish('newFile', {guid,metadata,owner,tags})}\n\t/**\n\t * Requests an upload URL\n\t *\n\t * Requests an HTTP upload URL.\n\t * The URL contains temporary credentials (typically valid for a few minutes) and is meant for immediate use.\n\t * */\n\tnewUploadUrl({contentType,owner,path}) { return this.$publish('newUploadUrl', {contentType,owner,path})}\n\t/**\n\t * Removes a file\n\t *\n\t * Removes a file or folder (recursively).\n\t * */\n\trm({owner,path}) { return this.$publish('rm', {owner,path})}\n\t/**\n\t * Returns information about a file\n\t *\n\t * Returns information about a single file.\n\t * The entry field will be null if the path does not exist\n\t * */\n\tstat({owner,path}) { return this.$publish('stat', {owner,path})}\n\t/**Updates a file's metadata*/\n\tupdateMeta({metadata,metadataFiles,owner,path}) { return this.$publish('updateMeta', {metadata,metadataFiles,owner,path})}\n}\n/**\n * Upload: pseudo-S3\n *\n * Upload service with pseudo-S3compatible storage\n * */\n/**\n * User API for file management\n *\n * User API for virtual file management and http file upload\n * This API contains all the verbs needed to browse, upload and remove files.\n * Files are stored on a per-user basis: each user has his or her own whole virtual filesystem.\n * Uploading a file is a 3-step process : request an upload URL, upload via HTTP, notify this service of completion.\n * @access public\n * */\nexport class Zpfs_s3compat extends Service {\n\t/**\n\t * Get default deployment id associated to Zpfs_s3compat service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'zpfs_s3compat_0'\n\t}\n\t/**\n\t * Copies a file\n\t *\n\t * Copies a file or folder (recursively) to a new location.\n\t * May fail if the target location is not empty.\n\t * */\n\tcp({oldPath,owner,path}) { return this.$publish('cp', {oldPath,owner,path})}\n\t/**\n\t * Returns disk usage\n\t *\n\t * Returns an recursively aggregated number of used bytes, starting at the given path.\n\t * */\n\tdu({owner,path}) { return this.$publish('du', {owner,path})}\n\t/**\n\t * Links a file\n\t *\n\t * Links a file or folder to another location.\n\t * May fail if the target location is not empty.\n\t * */\n\tlink({oldPath,owner,path}) { return this.$publish('link', {oldPath,owner,path})}\n\t/**\n\t * Lists a folder content\n\t *\n\t * Returns a paginated list of the folder's content.\n\t * */\n\tls({folder,owner,page}) { return this.$publish('ls', {folder,owner,page})}\n\t/**\n\t * Creates a folder\n\t *\n\t * Creates a new folder.\n\t * May fail if the target location is not empty.\n\t * */\n\tmkdir({folder,owner,parents}) { return this.$publish('mkdir', {folder,owner,parents})}\n\t/**\n\t * Moves a file\n\t *\n\t * Moves a file or folder (recursively) to a new location.\n\t * May fail if the target location is not empty.\n\t * */\n\tmv({oldPath,owner,path}) { return this.$publish('mv', {oldPath,owner,path})}\n\t/**\n\t * Notifies of upload completion\n\t *\n\t * The client application calls this verb to notify that it's done uploading to the cloud.\n\t * Calling that verb MAY trigger additional events such as thumbnail/metadata creation.\n\t * */\n\tnewFile({guid,metadata,owner,tags}) { return this.$publish('newFile', {guid,metadata,owner,tags})}\n\t/**\n\t * Requests an upload URL\n\t *\n\t * Requests an HTTP upload URL.\n\t * The URL contains temporary credentials (typically valid for a few minutes) and is meant for immediate use.\n\t * */\n\tnewUploadUrl({contentType,owner,path}) { return this.$publish('newUploadUrl', {contentType,owner,path})}\n\t/**\n\t * Removes a file\n\t *\n\t * Removes a file or folder (recursively).\n\t * */\n\trm({owner,path}) { return this.$publish('rm', {owner,path})}\n\t/**\n\t * Returns information about a file\n\t *\n\t * Returns information about a single file.\n\t * The entry field will be null if the path does not exist\n\t * */\n\tstat({owner,path}) { return this.$publish('stat', {owner,path})}\n\t/**Updates a file's metadata*/\n\tupdateMeta({metadata,metadataFiles,owner,path}) { return this.$publish('updateMeta', {metadata,metadataFiles,owner,path})}\n}\n/**\n * User directory service\n *\n * User directory service\n * */\n/**\n * User API for user information\n *\n * @access public\n * */\nexport class Userdir extends Service {\n\t/**\n\t * Get default deployment id associated to Userdir service\n\t * @return {string}\n\t */\n\tstatic get DEFAULT_DEPLOYMENT_ID() {\n\t\treturn 'userdir_0'\n\t}\n\t/**Searches for users matching the request*/\n\tsearch({page,query,requestId}) { return this.$publish('search', {page,query,requestId})}\n\t/**Requests public data for the specified users*/\n\tuserInfo({userKeys}) { return this.$publish('userInfo', {userKeys})}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/mapping/services.js","/**\n * Match unsecure pattern web\n * @type {RegExp}\n */\nconst HTTP_PATTERN = /^http:\\/\\/|^\\/\\//\n\n/**\n * Https protocol\n * @type {string}\n */\nconst HTTPS_PROTOCOL = 'https:'\n\n/**\n * Alpha numeric dictionary\n */\nconst DICTIONARY = 'abcdefghijklmnopqrstuvwxyz0123456789'\n\n/**\n* Default ZetaPush API URL\n* @access private\n*/\nexport const API_URL = 'https://api.zpush.io/'\n\n/**\n * @access private\n * @param {Array<Object>} list\n * @return {Object}\n */\nexport const shuffle = (list) => {\n  const index = Math.floor(Math.random() * list.length)\n  return list[index]\n}\n\n/**\n * @access private\n * @param {string} url\n * @param {boolean} forceHttps\n * @return {string}\n */\nexport const getSecureUrl = (url, forceHttps) => {\n  return forceHttps ? url.replace(HTTP_PATTERN, 'https://') : url\n}\n\n/**\n * @access private\n * @param {{apiUrl: string, sandboxId: string, forceHttps: boolean}} parameters\n * @return {Promise}\n */\nexport const getServers = ({ apiUrl, sandboxId, forceHttps }) => {\n  const secureApiUrl = getSecureUrl(apiUrl, forceHttps)\n  const url = `${secureApiUrl}${sandboxId}`\n  return fetch(url)\n    .then((response) => {\n      return response.json()\n    })\n    .then(({ servers }) => {\n      // TODO: Replace by a server side implementation when available\n      return servers.map((server) => {\n        return getSecureUrl(server, forceHttps)\n      })\n    })\n}\n\n/**\n * @access private\n * @return {boolean}\n */\nexport const isHttpsProtocol = () => {\n  return location.protocol === HTTPS_PROTOCOL\n}\n\n/**\n * @access private\n * @param Class Derived\n * @param Class Parent\n * @return {boolean}\n */\nexport const isDerivedOf = (Derived, Parent) => {\n  let prototype = Object.getPrototypeOf(Derived)\n  let is = false\n  while (!(is || prototype === null)) {\n    is = prototype === Parent\n    prototype = Object.getPrototypeOf(prototype)\n  }\n  return is\n}\n\n/**\n * Get random id\n * @return {string}\n */\nexport const uuid = (entropy = 7, dictionary = DICTIONARY) => Array.from(Array(entropy)).reduce((previous) => {\n  const next = dictionary.charAt(Math.floor(Math.random() * dictionary.length))\n  return `${previous}${next}`\n}, '')\n\n\n\n// WEBPACK FOOTER //\n// ./lib/utils/index.js","module.exports = { \"default\": require(\"core-js/library/fn/array/from\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/array/from.js\n// module id = 131\n// module chunks = 0","require('../../modules/es6.string.iterator');\nrequire('../../modules/es6.array.from');\nmodule.exports = require('../../modules/_core').Array.from;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/array/from.js\n// module id = 132\n// module chunks = 0","'use strict';\nvar ctx            = require('./_ctx')\n  , $export        = require('./_export')\n  , toObject       = require('./_to-object')\n  , call           = require('./_iter-call')\n  , isArrayIter    = require('./_is-array-iter')\n  , toLength       = require('./_to-length')\n  , createProperty = require('./_create-property')\n  , getIterFn      = require('./core.get-iterator-method');\n\n$export($export.S + $export.F * !require('./_iter-detect')(function(iter){ Array.from(iter); }), 'Array', {\n  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n  from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){\n    var O       = toObject(arrayLike)\n      , C       = typeof this == 'function' ? this : Array\n      , aLen    = arguments.length\n      , mapfn   = aLen > 1 ? arguments[1] : undefined\n      , mapping = mapfn !== undefined\n      , index   = 0\n      , iterFn  = getIterFn(O)\n      , length, result, step, iterator;\n    if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n    // if object isn't iterable or it's array with default iterator - use simple case\n    if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){\n      for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){\n        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n      }\n    } else {\n      length = toLength(O.length);\n      for(result = new C(length); length > index; index++){\n        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n      }\n    }\n    result.length = index;\n    return result;\n  }\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.array.from.js\n// module id = 133\n// module chunks = 0","'use strict';\nvar $defineProperty = require('./_object-dp')\n  , createDesc      = require('./_property-desc');\n\nmodule.exports = function(object, index, value){\n  if(index in object)$defineProperty.f(object, index, createDesc(0, value));\n  else object[index] = value;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_create-property.js\n// module id = 134\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/object/values\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/values.js\n// module id = 135\n// module chunks = 0","require('../../modules/es7.object.values');\nmodule.exports = require('../../modules/_core').Object.values;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/values.js\n// module id = 136\n// module chunks = 0","// https://github.com/tc39/proposal-object-values-entries\nvar $export = require('./_export')\n  , $values = require('./_object-to-array')(false);\n\n$export($export.S, 'Object', {\n  values: function values(it){\n    return $values(it);\n  }\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es7.object.values.js\n// module id = 137\n// module chunks = 0","var getKeys   = require('./_object-keys')\n  , toIObject = require('./_to-iobject')\n  , isEnum    = require('./_object-pie').f;\nmodule.exports = function(isEntries){\n  return function(it){\n    var O      = toIObject(it)\n      , keys   = getKeys(O)\n      , length = keys.length\n      , i      = 0\n      , result = []\n      , key;\n    while(length > i)if(isEnum.call(O, key = keys[i++])){\n      result.push(isEntries ? [key, O[key]] : O[key]);\n    } return result;\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/_object-to-array.js\n// module id = 138\n// module chunks = 0","import { Client } from './basic'\nimport { Authentication } from '../authentication/handshake'\nimport { SessionPersistenceStrategy } from '../utils/session-persistence'\n\n/**\n * SmartClient config object.\n * @typedef {Object} SmartClientConfig\n * @property {string} apiUrl - Api Url\n * @property {string} sandboxId - Sandbox id\n * @property {boolean} forceHttps - Force end to end HTTPS connection\n * @property {string} resource - Client resource id\n * @property {Array} transports - Client transports list\n */\n\n/**\n * @access public\n * @extends {Client}\n * @example\n * // Create a new WeakClient\n * const client = new ZetaPush.SmartClient({\n *   sandboxId: '<YOUR-SANDBOX-ID>'\n * })\n */\nexport class SmartClient extends Client {\n  /**\n   * Create a new ZetaPush SmartClient\n   * @param {SmartClientConfig} config\n   */\n  constructor({ apiUrl, sandboxId, forceHttps, resource, transports }) {\n    const persistence = new SessionPersistenceStrategy({ sandboxId })\n\n    /**\n     * @return {AbstractHandshakeManager}\n     */\n    const authentication = () => {\n      const session = persistence.get()\n      const { token } = session\n\n      if (this.hasCredentials()) {\n        const { login, password } = this.getCredentials()\n        this.setCredentials({})\n        return Authentication.simple({\n          login,\n          password\n        })\n      } else {\n        if (this.isStronglyAuthenticated(session)) {\n          return Authentication.simple({\n            login: token,\n            password: null\n          })\n        } else {\n          return Authentication.weak({\n            token\n          })\n        }\n      }\n    }\n    // Initialize base client\n    super({\n      apiUrl, sandboxId, authentication, forceHttps, resource, transports\n    })\n    /**\n     * @access protected\n     * @type {SessionPersistenceStrategy}\n     */\n    this.persistence = persistence\n    /**\n     * @access protected\n     * @type {Object}\n     */\n    this.credentials = {}\n    /**\n     * Handle connection lifecycle events\n     * @access protected\n     * @type {Object}\n     */\n    this.lifeCycleConnectionHandler = this.addConnectionStatusListener({\n      onConnectionClosed() {\n        persistence.set({})\n      },\n      onSuccessfulHandshake(session) {\n        if (session.token) {\n          persistence.set(session)\n        }\n      }\n    })\n    // Properly disconnect client to avoir ghost connections\n    window.addEventListener('beforeunload', () => {\n      this.removeConnectionStatusListener(this.lifeCycleConnectionHandler)\n      super.disconnect()\n    })\n  }\n  /**\n   * Disconnect client from ZetaPush backend\n   */\n  disconnect() {\n    super.disconnect()\n  }\n  /**\n   * @return {Object}\n   */\n  getCredentials() {\n    return this.credentials\n  }\n  /**\n   * @return {Object}\n   */\n  getSession() {\n    return this.persistence.get()\n  }\n  /**\n   * @return {boolean}\n   */\n  hasCredentials() {\n    const { login, password } = this.getCredentials()\n    return login && password\n  }\n  /**\n   * @return {boolean}\n   */\n  isStronglyAuthenticated(session = this.persistence.get()) {\n    return !this.isWeaklyAuthenticated(session) && typeof session.token === 'string'\n  }\n  /**\n   * @return {boolean}\n   */\n  isWeaklyAuthenticated(session = this.persistence.get()) {\n    return typeof session.publicToken === 'string'\n  }\n  /**\n   * @param {{login: string, password: string}} parameters\n   */\n  setCredentials({ login, password }) {\n    this.credentials = { login, password }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/client/smart.js","\"use strict\";\n\nexports.__esModule = true;\n\nvar _getPrototypeOf = require(\"../core-js/object/get-prototype-of\");\n\nvar _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);\n\nvar _getOwnPropertyDescriptor = require(\"../core-js/object/get-own-property-descriptor\");\n\nvar _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function get(object, property, receiver) {\n  if (object === null) object = Function.prototype;\n  var desc = (0, _getOwnPropertyDescriptor2.default)(object, property);\n\n  if (desc === undefined) {\n    var parent = (0, _getPrototypeOf2.default)(object);\n\n    if (parent === null) {\n      return undefined;\n    } else {\n      return get(parent, property, receiver);\n    }\n  } else if (\"value\" in desc) {\n    return desc.value;\n  } else {\n    var getter = desc.get;\n\n    if (getter === undefined) {\n      return undefined;\n    }\n\n    return getter.call(receiver);\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/get.js\n// module id = 140\n// module chunks = 0","module.exports = { \"default\": require(\"core-js/library/fn/object/get-own-property-descriptor\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/get-own-property-descriptor.js\n// module id = 141\n// module chunks = 0","require('../../modules/es6.object.get-own-property-descriptor');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function getOwnPropertyDescriptor(it, key){\n  return $Object.getOwnPropertyDescriptor(it, key);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/object/get-own-property-descriptor.js\n// module id = 142\n// module chunks = 0","// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\nvar toIObject                 = require('./_to-iobject')\n  , $getOwnPropertyDescriptor = require('./_object-gopd').f;\n\nrequire('./_object-sap')('getOwnPropertyDescriptor', function(){\n  return function getOwnPropertyDescriptor(it, key){\n    return $getOwnPropertyDescriptor(toIObject(it), key);\n  };\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/modules/es6.object.get-own-property-descriptor.js\n// module id = 143\n// module chunks = 0","/**\n * @type {string}\n */\nexport const ZETAPUSH_SESSION_KEY = 'zetapush.token'\n\n/**\n * Provide abstraction for token persistence\n * @access protected\n */\nexport class SessionPersistenceStrategy {\n  /**\n   * @param {{sandboxId: string, storage: DOMStorage}} parameters\n   */\n  constructor({ sandboxId, storage = window.localStorage } = {}) {\n    /**\n     * @access private\n     * @type {string}\n     */\n    this.key = `${ZETAPUSH_SESSION_KEY}.${sandboxId}`\n    /**\n     * @access private\n     * @type {DOMStorage}\n     */\n    this.storage = storage\n  }\n  /**\n   * @return {string} session The stored session\n   */\n  get() {\n    const { key, storage } = this\n    const json = storage.getItem(key) || '{}'\n    const session = JSON.parse(json)\n    return session\n  }\n  /**\n   * @param {Object} session The session to store\n   */\n  set(session = {}) {\n    const { key, storage } = this\n    const json = JSON.stringify(session)\n    return storage.setItem(key, json)\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/utils/session-persistence.js","module.exports = { \"default\": require(\"core-js/library/fn/json/stringify\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/json/stringify.js\n// module id = 145\n// module chunks = 0","var core  = require('../../modules/_core')\n  , $JSON = core.JSON || (core.JSON = {stringify: JSON.stringify});\nmodule.exports = function stringify(it){ // eslint-disable-line no-unused-vars\n  return $JSON.stringify.apply($JSON, arguments);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/core-js/library/fn/json/stringify.js\n// module id = 146\n// module chunks = 0","import { Client } from './basic'\nimport { Authentication } from '../authentication/handshake'\nimport { SessionPersistenceStrategy } from '../utils/session-persistence'\n\n/**\n * WeakClient config object.\n * @typedef {Object} WeakClientConfig\n * @property {string} apiUrl - Api Url\n * @property {string} deploymentId - Authentication deployment id, default value is 'weak_0'\n * @property {string} sandboxId - Sandbox id\n * @property {boolean} forceHttps - Force end to end HTTPS connection\n * @property {string} resource - Client resource id\n * @property {Array} transports - Client transports list\n */\n\n/**\n * @access public\n * @extends {Client}\n * @example\n * // Create a new WeakClient\n * const client = new ZetaPush.WeakClient({\n *   sandboxId: '<YOUR-SANDBOX-ID>'\n * })\n * @example\n * // Explicit deploymentId\n * // WeakClient provide optional deployment id, according to the following convention `${ServiceType.toLowerCase()_0}`\n * // deploymentId default value is weak_0\n * const client = new ZetaPush.WeakClient({\n *   deploymentId: 'weak_0',\n *   sandboxId: '<YOUR-SANDBOX-ID>'\n * })\n */\nexport class WeakClient extends Client {\n  /**\n   * Create a new ZetaPush WeakClient\n   * @param {WeakClientConfig} config\n   */\n  constructor({ apiUrl, sandboxId, deploymentId, forceHttps, resource, transports }) {\n    const authentication = () => {\n      const token = this.getToken()\n      const handshake = Authentication.weak({\n        deploymentId,\n        token\n      })\n      return handshake\n    }\n    /**\n     * Call Client constructor with specific parameters\n     */\n    super({ apiUrl, sandboxId, forceHttps, authentication, resource, transports })\n    // Handle successful handshake\n    const onSuccessfulHandshake = ({ publicToken, userId, token }) => {\n      if (token) {\n        this.strategy.set({ publicToken, userId, token })\n      }\n    }\n    this.addConnectionStatusListener({ onSuccessfulHandshake })\n    /**\n     * @access private\n     * @type {SessionPersistenceStrategy}\n     */\n    this.strategy = new SessionPersistenceStrategy()\n  }\n  /**\n   * @return {string} The stored token\n   */\n  getToken() {\n    const { token } = this.strategy.get()\n    return token\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./lib/client/weak.js","import * as authentications from './authentications'\nimport * as services from './services'\n\nexport { authentications, services }\n\n\n\n// WEBPACK FOOTER //\n// ./lib/mapping/index.js"],"sourceRoot":""}