https://wxuas.com/lib/@microsoft/signalr/dist/browser/signalr.js

1(function webpackUniversalModuleDefinition(root, factory) {
2	if(typeof exports === 'object' && typeof module === 'object')
3		module.exports = factory();
4	else if(typeof define === 'function' && define.amd)
5		define([], factory);
6	else if(typeof exports === 'object')
7		exports["signalR"] = factory();
8	else
9		root["signalR"] = factory();
10})(window, function() {
11return /******/ (function(modules) { // webpackBootstrap
12/******/ 	// The module cache
13/******/ 	var installedModules = {};
14/******/
15/******/ 	// The require function
16/******/ 	function __webpack_require__(moduleId) {
17/******/
18/******/ 		// Check if module is in cache
19/******/ 		if(installedModules[moduleId]) {
20/******/ 			return installedModules[moduleId].exports;
21/******/ 		}
22/******/ 		// Create a new module (and put it into the cache)
23/******/ 		var module = installedModules[moduleId] = {
24/******/ 			i: moduleId,
25/******/ 			l: false,
26/******/ 			exports: {}
27/******/ 		};
28/******/
29/******/ 		// Execute the module function
30/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
31/******/
32/******/ 		// Flag the module as loaded
33/******/ 		module.l = true;
34/******/
35/******/ 		// Return the exports of the module
36/******/ 		return module.exports;
37/******/ 	}
38/******/
39/******/
40/******/ 	// expose the modules object (__webpack_modules__)
41/******/ 	__webpack_require__.m = modules;
42/******/
43/******/ 	// expose the module cache
44/******/ 	__webpack_require__.c = installedModules;
45/******/
46/******/ 	// define getter function for harmony exports
47/******/ 	__webpack_require__.d = function(exports, name, getter) {
48/******/ 		if(!__webpack_require__.o(exports, name)) {
49/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
50/******/ 		}
51/******/ 	};
52/******/
53/******/ 	// define __esModule on exports
54/******/ 	__webpack_require__.r = function(exports) {
55/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
56/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
57/******/ 		}
58/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
59/******/ 	};
60/******/
61/******/ 	// create a fake namespace object
62/******/ 	// mode & 1: value is a module id, require it
63/******/ 	// mode & 2: merge all properties of value into the ns
64/******/ 	// mode & 4: return value when already ns object
65/******/ 	// mode & 8|1: behave like require
66/******/ 	__webpack_require__.t = function(value, mode) {
67/******/ 		if(mode & 1) value = __webpack_require__(value);
68/******/ 		if(mode & 8) return value;
69/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
70/******/ 		var ns = Object.create(null);
71/******/ 		__webpack_require__.r(ns);
72/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
73/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
74/******/ 		return ns;
75/******/ 	};
76/******/
77/******/ 	// getDefaultExport function for compatibility with non-harmony modules
78/******/ 	__webpack_require__.n = function(module) {
79/******/ 		var getter = module && module.__esModule ?
80/******/ 			function getDefault() { return module['default']; } :
81/******/ 			function getModuleExports() { return module; };
82/******/ 		__webpack_require__.d(getter, 'a', getter);
83/******/ 		return getter;
84/******/ 	};
85/******/
86/******/ 	// Object.prototype.hasOwnProperty.call
87/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
88/******/
89/******/ 	// __webpack_public_path__
90/******/ 	__webpack_require__.p = "";
91/******/
92/******/
93/******/ 	// Load entry module and return exports
94/******/ 	return __webpack_require__(__webpack_require__.s = 0);
95/******/ })
96/************************************************************************/
97/******/ ([
98/* 0 */
99/***/ (function(module, __webpack_exports__, __webpack_require__) {
100
101"use strict";
102__webpack_require__.r(__webpack_exports__);
103/* harmony import */ var es6_promise_dist_es6_promise_auto_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
104/* harmony import */ var es6_promise_dist_es6_promise_auto_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(es6_promise_dist_es6_promise_auto_js__WEBPACK_IMPORTED_MODULE_0__);
105/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3);
106/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "VERSION", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["VERSION"]; });
107
108/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "AbortError", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["AbortError"]; });
109
110/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpError", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["HttpError"]; });
111
112/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimeoutError", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["TimeoutError"]; });
113
114/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpClient", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["HttpClient"]; });
115
116/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpResponse", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["HttpResponse"]; });
117
118/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "DefaultHttpClient", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["DefaultHttpClient"]; });
119
120/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HubConnection", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["HubConnection"]; });
121
122/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HubConnectionState", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["HubConnectionState"]; });
123
124/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HubConnectionBuilder", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["HubConnectionBuilder"]; });
125
126/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "MessageType", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["MessageType"]; });
127
128/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "LogLevel", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["LogLevel"]; });
129
130/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpTransportType", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["HttpTransportType"]; });
131
132/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TransferFormat", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["TransferFormat"]; });
133
134/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "NullLogger", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["NullLogger"]; });
135
136/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "JsonHubProtocol", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["JsonHubProtocol"]; });
137
138/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Subject", function() { return _index__WEBPACK_IMPORTED_MODULE_1__["Subject"]; });
139
140// Copyright (c) .NET Foundation. All rights reserved.
141// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
142// This is where we add any polyfills we'll need for the browser. It is the entry module for browser-specific builds.
143
144// Copy from Array.prototype into Uint8Array to polyfill on IE. It's OK because the implementations of indexOf and slice use properties
145// that exist on Uint8Array with the same name, and JavaScript is magic.
146// We make them 'writable' because the Buffer polyfill messes with it as well.
147if (!Uint8Array.prototype.indexOf) {
148    Object.defineProperty(Uint8Array.prototype, "indexOf", {
149        value: Array.prototype.indexOf,
150        writable: true,
151    });

157,
158        writable: true,
159    });
160}
161if (!Uint8Array.prototype.forEach) {
162    Object.defineProperty(Uint8Array.prototype, "forEach", {
163        value: Array.prototype.forEach,
164        writable: true,
165    });
166}
167
168
169
170/***/ }),
171/* 1 */
172/***/ (function(module, exports, __webpack_require__) {
173
174/* WEBPACK VAR INJECTION */(function(global) {var require;/*!
175 * @overview es6-promise - a tiny implementation of Promises/A+.
176 * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
177 * @license   Licensed under MIT license
178 *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
179 * @version   v4.2.2+97478eb6
180 */
181
182(function (global, factory) {
183	 true ? module.exports = factory() :
184	undefined;
185}(this, (function () { 'use strict';
186
187function objectOrFunction(x) {
188  var type = typeof x;
189  return x !== null && (type === 'object' || type === 'function');
190}
191
192function isFunction(x) {
193  return typeof x === 'function';
194}
195
196
197
198var _isArray = void 0;
199if (Array.isArray) {
200  _isArray = Array.isArray;
201} else {
202  _isArray = function (x) {
203    return Object.prototype.toString.call(x) === '[object Array]';
204  };
205}
206
207var isArray = _isArray;
208
209var len = 0;
210var vertxNext = void 0;
211var customSchedulerFn = void 0;
212
213var asap = function asap(callback, arg) {
214  queue[len] = callback;
215  queue[len + 1] = arg;
216  len += 2;
217  if (len === 2) {
218    // If len is 2, that means that we need to schedule an async flush.
219    // If additional callbacks are queued before the queue is flushed, they
220    // will be processed by this flush that we are scheduling.
221    if (customSchedulerFn) {
222      customSchedulerFn(flush);
223    } else {
224      scheduleFlush();
225    }
226  }
227};
228
229function setScheduler(scheduleFn) {
230  customSchedulerFn = scheduleFn;
231}
232
233function setAsap(asapFn) {
234  asap = asapFn;
235}
236
237var browserWindow = typeof window !== 'undefined' ? window : undefined;
238var browserGlobal = browserWindow || {};
239var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
240var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
241
242// test for web worker but not in IE10
243var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
244
245// node
246function useNextTick() {
247  // node version 0.10.x displays a deprecation warning when nextTick is used recursively
248  // see https://github.com/cujojs/when/issues/410 for details
249  return function () {
250    return process.nextTick(flush);
251  };
252}
253
254// vertx
255function useVertxTimer() {
256  if (typeof vertxNext !== 'undefined') {
257    return function () {
258      vertxNext(flush);
259    };
260  }
261
262  return useSetTimeout();
263}
264
265function useMutationObserver() {
266  var iterations = 0;
267  var observer = new BrowserMutationObserver(flush);
268  var node = document.createTextNode('');
269  observer.observe(node, { characterData: true });
270
271  return function () {
272    node.data = iterations = ++iterations % 2;
273  };
274}
275
276// web worker
277function useMessageChannel() {
278  var channel = new MessageChannel();
279  channel.port1.onmessage = flush;
280  return function () {
281    return channel.port2.postMessage(0);
282  };
283}
284
285function useSetTimeout() {
286  // Store setTimeout reference so es6-promise will be unaffected by
287  // other code modifying setTimeout (like sinon.useFakeTimers())
288  var globalSetTimeout = setTimeout;
289  return function () {
290    return globalSetTimeout(flush, 1);
291  };
292}
293
294var queue = new Array(1000);
295function flush() {
296  for (var i = 0; i < len; i += 2) {
297    var callback = queue[i];
298    var arg = queue[i + 1];
299
300    callback(arg);
301
302    queue[i] = undefined;
303    queue[i + 1] = undefined;
304  }
305
306  len = 0;
307}
308
309function attemptVertx() {
310  try {
311    var r = require;
312    var vertx = __webpack_require__(!(function webpackMissingModule() { var e = new Error("Cannot find module 'vertx'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()));
313    vertxNext = vertx.runOnLoop || vertx.runOnContext;
314    return useVertxTimer();
315  } catch (e) {
316    return useSetTimeout();
317  }
318}
319
320var scheduleFlush = void 0;
321// Decide what async method to use to triggering processing of queued callbacks:
322if (isNode) {
323  scheduleFlush = useNextTick();
324} else if (BrowserMutationObserver) {
325  scheduleFlush = useMutationObserver();
326} else if (isWorker) {
327  scheduleFlush = useMessageChannel();
328} else if (browserWindow === undefined && "function" === 'function') {
329  scheduleFlush = attemptVertx();
330} else {
331  scheduleFlush = useSetTimeout();
332}
333
334function then(onFulfillment, onRejection) {
335  var parent = this;
336
337  var child = new this.constructor(noop);
338
339  if (child[PROMISE_ID] === undefined) {
340    makePromise(child);
341  }
342
343  var _state = parent._state;
344
345
346  if (_state) {
347    var callback = arguments[_state - 1];
348    asap(function () {
349      return invokeCallback(_state, child, callback, parent._result);
350    });
351  } else {
352    subscribe(parent, child, onFulfillment, onRejection);
353  }
354
355  return child;
356}
357
358/**
359  `Promise.resolve` returns a promise that will become resolved with the
360  passed `value`. It is shorthand for the following:
361
362  ```javascript
363  let promise = new Promise(function(resolve, reject){
364    resolve(1);
365  });
366
367  promise.then(function(value){
368    // value === 1
369  });
370  ```
371
372  Instead of writing the above, your code now simply becomes the following:
373
374  ```javascript
375  let promise = Promise.resolve(1);
376
377  promise.then(function(value){
378    // value === 1
379  });
380  ```
381
382  @method resolve
383  @static
384  @param {Any} value value that the returned promise will be resolved with
385  Useful for tooling.
386  @return {Promise} a promise that will become fulfilled with the given
387  `value`
388*/
389function resolve$1(object) {
390  /*jshint validthis:true */
391  var Constructor = this;
392
393  if (object && typeof object === 'object' && object.constructor === Constructor) {
394    return object;
395  }
396
397  var promise = new Constructor(noop);
398  resolve(promise, object);
399  return promise;
400}
401
402var PROMISE_ID = Math.random().toString(36).substring(16);
403
404function noop() {}
405
406var PENDING = void 0;
407var FULFILLED = 1;
408var REJECTED = 2;
409
410var GET_THEN_ERROR = new ErrorObject();
411
412function selfFulfillment() {
413  return new TypeError("You cannot resolve a promise with itself");
414}
415
416function cannotReturnOwn() {
417  return new TypeError('A promises callback cannot return that same promise.');
418}
419
420function getThen(promise) {
421  try {
422    return promise.then;
423  } catch (error) {
424    GET_THEN_ERROR.error = error;
425    return GET_THEN_ERROR;
426  }
427}
428
429function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
430  try {
431    then$$1.call(value, fulfillmentHandler, rejectionHandler);
432  } catch (e) {
433    return e;
434  }
435}
436
437function handleForeignThenable(promise, thenable, then$$1) {
438  asap(function (promise) {
439    var sealed = false;
440    var error = tryThen(then$$1, thenable, function (value) {
441      if (sealed) {
442        return;
443      }
444      sealed = true;
445      if (thenable !== value) {
446        resolve(promise, value);
447      } else {
448        fulfill(promise, value);
449      }
450    }, function (reason) {
451      if (sealed) {
452        return;
453      }
454      sealed = true;
455
456      reject(promise, reason);
457    }, 'Settle: ' + (promise._label || ' unknown promise'));
458
459    if (!sealed && error) {
460      sealed = true;
461      reject(promise, error);
462    }
463  }, promise);
464}
465
466function handleOwnThenable(promise, thenable) {
467  if (thenable._state === FULFILLED) {
468    fulfill(promise, thenable._result);
469  } else if (thenable._state === REJECTED) {
470    reject(promise, thenable._result);
471  } else {
472    subscribe(thenable, undefined, function (value) {
473      return resolve(promise, value);
474    }, function (reason) {
475      return reject(promise, reason);
476    });
477  }
478}
479
480function handleMaybeThenable(promise, maybeThenable, then$$1) {
481  if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
482    handleOwnThenable(promise, maybeThenable);
483  } else {
484    if (then$$1 === GET_THEN_ERROR) {
485      reject(promise, GET_THEN_ERROR.error);
486      GET_THEN_ERROR.error = null;
487    } else if (then$$1 === undefined) {
488      fulfill(promise, maybeThenable);
489    } else if (isFunction(then$$1)) {
490      handleForeignThenable(promise, maybeThenable, then$$1);
491    } else {
492      fulfill(promise, maybeThenable);
493    }
494  }
495}
496
497function resolve(promise, value) {
498  if (promise === value) {
499    reject(promise, selfFulfillment());
500  } else if (objectOrFunction(value)) {
501    handleMaybeThenable(promise, value, getThen(value));
502  } else {
503    fulfill(promise, value);
504  }
505}
506
507function publishRejection(promise) {
508  if (promise._onerror) {
509    promise._onerror(promise._result);
510  }
511
512  publish(promise);
513}
514
515function fulfill(promise, value) {
516  if (promise._state !== PENDING) {
517    return;
518  }
519
520  promise._result = value;
521  promise._state = FULFILLED;
522
523  if (promise._subscribers.length !== 0) {
524    asap(publish, promise);
525  }
526}
527
528function reject(promise, reason) {
529  if (promise._state !== PENDING) {
530    return;
531  }
532  promise._state = REJECTED;
533  promise._result = reason;
534
535  asap(publishRejection, promise);
536}
537
538function subscribe(parent, child, onFulfillment, onRejection) {
539  var _subscribers = parent._subscribers;
540  var length = _subscribers.length;
541
542
543  parent._onerror = null;
544
545  _subscribers[length] = child;
546  _subscribers[length + FULFILLED] = onFulfillment;
547  _subscribers[length + REJECTED] = onRejection;
548
549  if (length === 0 && parent._state) {
550    asap(publish, parent);
551  }
552}
553
554function publish(promise) {
555  var subscribers = promise._subscribers;
556  var settled = promise._state;
557
558  if (subscribers.length === 0) {
559    return;
560  }
561
562  var child = void 0,
563      callback = void 0,
564      detail = promise._result;
565
566  for (var i = 0; i < subscribers.length; i += 3) {
567    child = subscribers[i];
568    callback = subscribers[i + settled];
569
570    if (child) {
571      invokeCallback(settled, child, callback, detail);
572    } else {
573      callback(detail);
574    }
575  }
576
577  promise._subscribers.length = 0;
578}
579
580function ErrorObject() {
581  this.error = null;
582}
583
584var TRY_CATCH_ERROR = new ErrorObject();
585
586function tryCatch(callback, detail) {
587  try {
588    return callback(detail);
589  } catch (e) {
590    TRY_CATCH_ERROR.error = e;
591    return TRY_CATCH_ERROR;
592  }
593}
594
595function invokeCallback(settled, promise, callback, detail) {
596  var hasCallback = isFunction(callback),
597      value = void 0,
598      error = void 0,
599      succeeded = void 0,
600      failed = void 0;
601
602  if (hasCallback) {
603    value = tryCatch(callback, detail);
604
605    if (value === TRY_CATCH_ERROR) {
606      failed = true;
607      error = value.error;
608      value.error = null;
609    } else {
610      succeeded = true;
611    }
612
613    if (promise === value) {
614      reject(promise, cannotReturnOwn());
615      return;
616    }
617  } else {
618    value = detail;
619    succeeded = true;
620  }
621
622  if (promise._state !== PENDING) {
623    // noop
624  } else if (hasCallback && succeeded) {
625    resolve(promise, value);
626  } else if (failed) {
627    reject(promise, error);
628  } else if (settled === FULFILLED) {
629    fulfill(promise, value);
630  } else if (settled === REJECTED) {
631    reject(promise, value);
632  }
633}
634
635function initializePromise(promise, resolver) {
636  try {
637    resolver(function resolvePromise(value) {
638      resolve(promise, value);
639    }, function rejectPromise(reason) {
640      reject(promise, reason);
641    });
642  } catch (e) {
643    reject(promise, e);
644  }
645}
646
647var id = 0;
648function nextId() {
649  return id++;
650}
651
652function makePromise(promise) {
653  promise[PROMISE_ID] = id++;
654  promise._state = undefined;
655  promise._result = undefined;
656  promise._subscribers = [];
657}
658
659function validationError() {
660  return new Error('Array Methods must be provided an Array');
661}
662
663function validationError() {
664  return new Error('Array Methods must be provided an Array');
665}
666
667var Enumerator = function () {
668  function Enumerator(Constructor, input) {
669    this._instanceConstructor = Constructor;
670    this.promise = new Constructor(noop);
671
672    if (!this.promise[PROMISE_ID]) {
673      makePromise(this.promise);
674    }
675
676    if (isArray(input)) {
677      this.length = input.length;
678      this._remaining = input.length;
679
680      this._result = new Array(this.length);
681
682      if (this.length === 0) {
683        fulfill(this.promise, this._result);
684      } else {
685        this.length = this.length || 0;
686        this._enumerate(input);
687        if (this._remaining === 0) {
688          fulfill(this.promise, this._result);
689        }
690      }
691    } else {
692      reject(this.promise, validationError());
693    }
694  }
695
696  Enumerator.prototype._enumerate = function _enumerate(input) {
697    for (var i = 0; this._state === PENDING && i < input.length; i++) {
698      this._eachEntry(input[i], i);
699    }
700  };
701
702  Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
703    var c = this._instanceConstructor;
704    var resolve$$1 = c.resolve;
705
706
707    if (resolve$$1 === resolve$1) {
708      var _then = getThen(entry);
709
710      if (_then === then && entry._state !== PENDING) {
711        this._settledAt(entry._state, i, entry._result);
712      } else if (typeof _then !== 'function') {
713        this._remaining--;
714        this._result[i] = entry;
715      } else if (c === Promise$2) {
716        var promise = new c(noop);
717        handleMaybeThenable(promise, entry, _then);
718        this._willSettleAt(promise, i);
719      } else {

720        this._willSettleAt(new c(function (resolve$$1) {
721          return resolve$$1(entry);
722        }), i);
723      }
724    } else {
725      this._willSettleAt(resolve$$1(entry), i);
726    }
727  };
728
729  Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
730    var promise = this.promise;
731
732
733    if (promise._state === PENDING) {
734      this._remaining--;
735
736      if (state === REJECTED) {
737        reject(promise, value);
738      } else {
739        this._result[i] = value;
740      }
741    }
742
743    if (this._remaining === 0) {
744      fulfill(promise, this._result);
745    }
746  };
747
748  Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
749    var enumerator = this;
750
751    subscribe(promise, undefined, function (value) {
752      return enumerator._settledAt(FULFILLED, i, value);
753    }, function (reason) {
754      return enumerator._settledAt(REJECTED, i, reason);
755    });
756  };
757
758  return Enumerator;
759}();
760
761/**
762  `Promise.all` accepts an array of promises, and returns a new promise which
763  is fulfilled with an array of fulfillment values for the passed promises, or
764  rejected with the reason of the first passed promise to be rejected. It casts all
765  elements of the passed iterable to promises as it runs this algorithm.
766
767  Example:
768
769  ```javascript
770  let promise1 = resolve(1);
771  let promise2 = resolve(2);
772  let promise3 = resolve(3);
773  let promises = [ promise1, promise2, promise3 ];
774
775  Promise.all(promises).then(function(array){
776    // The array here would be [ 1, 2, 3 ];
777  });
778  ```
779
780  If any of the `promises` given to `all` are rejected, the first promise
781  that is rejected will be given as an argument to the returned promises's
782  rejection handler. For example:
783
784  Example:
785
786  ```javascript
787  let promise1 = resolve(1);
788  let promise2 = reject(new Error("2"));
789  let promise3 = reject(new Error("3"));
790  let promises = [ promise1, promise2, promise3 ];
791
792  Promise.all(promises).then(function(array){
793    // Code here never runs because there are rejected promises!
794  }, function(error) {
795    // error.message === "2"
796  });
797  ```
798
799  @method all
800  @static
801  @param {Array} entries array of promises
802  @param {String} label optional string for labeling the promise.
803  Useful for tooling.
804  @return {Promise} promise that is fulfilled when all `promises` have been
805  fulfilled, or rejected if any of them become rejected.
806  @static
807*/
808function all(entries) {
809  return new Enumerator(this, entries).promise;
810}
811
812/**
813  `Promise.race` returns a new promise which is settled in the same way as the
814  first passed promise to settle.
815
816  Example:
817
818  ```javascript
819  let promise1 = new Promise(function(resolve, reject){
820    setTimeout(function(){
821      resolve('promise 1');
822    }, 200);
823  });
824
825  let promise2 = new Promise(function(resolve, reject){
826    setTimeout(function(){
827      resolve('promise 2');
828    }, 100);
829  });
830
831  Promise.race([promise1, promise2]).then(function(result){
832    // result === 'promise 2' because it was resolved before promise1
833    // was resolved.
834  });
835  ```
836
837  `Promise.race` is deterministic in that only the state of the first
838  settled promise matters. For example, even if other promises given to the
839  `promises` array argument are resolved, but the first settled promise has
840  become rejected before the other promises became fulfilled, the returned
841  promise will become rejected:
842
843  ```javascript
844  let promise1 = new Promise(function(resolve, reject){
845    setTimeout(function(){
846      resolve('promise 1');
847    }, 200);
848  });
849
850  let promise2 = new Promise(function(resolve, reject){
851    setTimeout(function(){
852      reject(new Error('promise 2'));
853    }, 100);
854  });
855
856  Promise.race([promise1, promise2]).then(function(result){
857    // Code here never runs
858  }, function(reason){
859    // reason.message === 'promise 2' because promise 2 became rejected before
860    // promise 1 became fulfilled
861  });
862  ```
863
864  An example real-world use case is implementing timeouts:
865
866  ```javascript
867  Promise.race([ajax('foo.json'), timeout(5000)])
868  ```
869
870  @method race
871  @static
872  @param {Array} promises array of promises to observe
873  Useful for tooling.
874  @return {Promise} a promise which settles in the same way as the first passed
875  promise to settle.
876*/
877function race(entries) {
878  /*jshint validthis:true */
879  var Constructor = this;
880
881  if (!isArray(entries)) {
882    return new Constructor(function (_, reject) {
883      return reject(new TypeError('You must pass an array to race.'));
884    });
885  } else {
886    return new Constructor(function (resolve, reject) {
887      var length = entries.length;
888      for (var i = 0; i < length; i++) {
889        Constructor.resolve(entries[i]).then(resolve, reject);
890      }
891    });
892  }
893}
894
895/**
896  `Promise.reject` returns a promise rejected with the passed `reason`.
897  It is shorthand for the following:
898
899  ```javascript
900  let promise = new Promise(function(resolve, reject){
901    reject(new Error('WHOOPS'));
902  });
903
904  promise.then(function(value){
905    // Code here doesn't run because the promise is rejected!
906  }, function(reason){
907    // reason.message === 'WHOOPS'
908  });
909  ```
910
911  Instead of writing the above, your code now simply becomes the following:
912
913  ```javascript
914  let promise = Promise.reject(new Error('WHOOPS'));
915
916  promise.then(function(value){
917    // Code here doesn't run because the promise is rejected!
918  }, function(reason){
919    // reason.message === 'WHOOPS'
920  });
921  ```
922
923  @method reject
924  @static
925  @param {Any} reason value that the returned promise will be rejected with.
926  Useful for tooling.
927  @return {Promise} a promise rejected with the given `reason`.
928*/
929function reject$1(reason) {
930  /*jshint validthis:true */
931  var Constructor = this;
932  var promise = new Constructor(noop);
933  reject(promise, reason);
934  return promise;
935}
936
937function needsResolver() {
938  throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
939}
940
941function needsNew() {
942  throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object c

942onstructor cannot be called as a function.");
943}
944
945/**
946  Promise objects represent the eventual result of an asynchronous operation. The
947  primary way of interacting with a promise is through its `then` method, which
948  registers callbacks to receive either a promise's eventual value or the reason
949  why the promise cannot be fulfilled.
950
951  Terminology
952  -----------
953
954  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
955  - `thenable` is an object or function that defines a `then` method.
956  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
957  - `exception` is a value that is thrown using the throw statement.
958  - `reason` is a value that indicates why a promise was rejected.
959  - `settled` the final resting state of a promise, fulfilled or rejected.
960
961  A promise can be in one of three states: pending, fulfilled, or rejected.
962
963  Promises that are fulfilled have a fulfillment value and are in the fulfilled
964  state.  Promises that are rejected have a rejection reason and are in the
965  rejected state.  A fulfillment value is never a thenable.
966
967  Promises can also be said to *resolve* a value.  If this value is also a
968  promise, then the original promise's settled state will match the value's
969  settled state.  So a promise that *resolves* a promise that rejects will
970  itself reject, and a promise that *resolves* a promise that fulfills will
971  itself fulfill.
972
973
974  Basic Usage:
975  ------------
976
977  ```js
978  let promise = new Promise(function(resolve, reject) {
979    // on success
980    resolve(value);
981
982    // on failure
983    reject(reason);
984  });
985
986  promise.then(function(value) {
987    // on fulfillment
988  }, function(reason) {
989    // on rejection
990  });
991  ```
992
993  Advanced Usage:
994  ---------------
995
996  Promises shine when abstracting away asynchronous interactions such as
997  `XMLHttpRequest`s.
998
999  ```js
1000  function getJSON(url) {
1001    return new Promise(function(resolve, reject){
1002      let xhr = new XMLHttpRequest();
1003
1004      xhr.open('GET', url);
1005      xhr.onreadystatechange = handler;
1006      xhr.responseType = 'json';
1007      xhr.setRequestHeader('Accept', 'application/json');
1008      xhr.send();
1009
1010      function handler() {
1011        if (this.readyState === this.DONE) {
1012          if (this.status === 200) {
1013            resolve(this.response);
1014          } else {
1015            reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
1016          }
1017        }
1018      };
1019    });
1020  }
1021
1022  getJSON('/posts.json').then(function(json) {
1023    // on fulfillment
1024  }, function(reason) {
1025    // on rejection
1026  });
1027  ```
1028
1029  Unlike callbacks, promises are great composable primitives.
1030
1031  ```js
1032  Promise.all([
1033    getJSON('/posts'),
1034    getJSON('/comments')
1035  ]).then(function(values){
1036    values[0] // => postsJSON
1037    values[1] // => commentsJSON
1038
1039    return values;
1040  });
1041  ```
1042
1043  @class Promise
1044  @param {Function} resolver
1045  Useful for tooling.
1046  @constructor
1047*/
1048
1049var Promise$2 = function () {
1050  function Promise(resolver) {
1051    this[PROMISE_ID] = nextId();
1052    this._result = this._state = undefined;
1053    this._subscribers = [];
1054
1055    if (noop !== resolver) {
1056      typeof resolver !== 'function' && needsResolver();
1057      this instanceof Promise ? initializePromise(this, resolver) : needsNew();
1058    }
1059  }
1060
1061  /**
1062  The primary way of interacting with a promise is through its `then` method,
1063  which registers callbacks to receive either a promise's eventual value or the
1064  reason why the promise cannot be fulfilled.
1065   ```js
1066  findUser().then(function(user){
1067    // user is available
1068  }, function(reason){
1069    // user is unavailable, and you are given the reason why
1070  });
1071  ```
1072   Chaining
1073  --------
1074   The return value of `then` is itself a promise.  This second, 'downstream'
1075  promise is resolved with the return value of the first promise's fulfillment
1076  or rejection handler, or rejected if the handler throws an exception.
1077   ```js
1078  findUser().then(function (user) {
1079    return user.name;
1080  }, function (reason) {
1081    return 'default name';
1082  }).then(function (userName) {
1083    // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
1084    // will be `'default name'`
1085  });
1086   findUser().then(function (user) {
1087    throw new Error('Found user, but still unhappy');
1088  }, function (reason) {
1089    throw new Error('`findUser` rejected and we're unhappy');
1090  }).then(function (value) {
1091    // never reached
1092  }, function (reason) {
1093    // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
1094    // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
1095  });
1096  ```
1097  If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
1098   ```js
1099  findUser().then(function (user) {
1100    throw new PedagogicalException('Upstream error');
1101  }).then(function (value) {
1102    // never reached
1103  }).then(function (value) {
1104    // never reached
1105  }, function (reason) {
1106    // The `PedgagocialException` is propagated all the way down to here
1107  });
1108  ```
1109   Assimilation
1110  ------------
1111   Sometimes the value you want to propagate to a downstream promise can only be
1112  retrieved asynchronously. This can be achieved by returning a promise in the
1113  fulfillment or rejection handler. The downstream promise will then be pending
1114  until the returned promise is settled. This is called *assimilation*.
1115   ```js
1116  findUser().then(function (user) {
1117    return findCommentsByAuthor(user);
1118  }).then(function (comments) {
1119    // The user's comments are now available
1120  });
1121  ```
1122   If the assimliated promise rejects, then the downstream promise will also reject.
1123   ```js
1124  findUser().then(function (user) {
1125    return findCommentsByAuthor(user);
1126  }).then(function (comments) {
1127    // If `findCommentsByAuthor` fulfills, we'll have the value here
1128  }, function (reason) {
1129    // If `findCommentsByAuthor` rejects, we'll have the reason here
1130  });
1131  ```

1132   Simple Example
1133  --------------
1134   Synchronous Example
1135   ```javascript
1136  let result;
1137   try {
1138    result = findResult();
1139    // success
1140  } catch(reason) {
1141    // failure
1142  }
1143  ```
1144   Errback Example
1145   ```js
1146  findResult(function(result, err){
1147    if (err) {
1148      // failure
1149    } else {
1150      // success
1151    }
1152  });
1153  ```
1154   Promise Example;
1155   ```javascript
1156  findResult().then(function(result){
1157    // success
1158  }, function(reason){
1159    // failure
1160  });
1161  ```
1162   Advanced Example
1163  --------------
1164   Synchronous Example
1165   ```javascript
1166  let author, books;
1167   try {
1168    author = findAuthor();
1169    books  = findBooksByAuthor(author);
1170    // success
1171  } catch(reason) {
1172    // failure
1173  }
1174  ```
1175   Errback Example
1176   ```js
1177   function foundBooks(books) {
1178   }
1179   function failure(reason) {
1180   }
1181   findAuthor(function(author, err){
1182    if (err) {
1183      failure(err);
1184      // failure
1185    } else {
1186      try {
1187        findBoooksByAuthor(author, function(books, err) {
1188          if (err) {
1189            failure(err);
1190          } else {
1191            try {
1192              foundBooks(books);
1193            } catch(reason) {
1194              failure(reason);
1195            }
1196          }
1197        });
1198      } catch(error) {
1199        failure(err);
1200      }
1201      // success
1202    }
1203  });
1204  ```
1205   Promise Example;
1206   ```javascript
1207  findAuthor().
1208    then(findBooksByAuthor).
1209    then(function(books){
1210      // found books
1211  }).catch(function(reason){
1212    // something went wrong
1213  });
1214  ```
1215   @method then
1216  @param {Function} onFulfilled
1217  @param {Function} onRejected
1218  Useful for tooling.
1219  @return {Promise}
1220  */
1221
1222  /**
1223  `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
1224  as the catch block of a try/catch statement.
1225  ```js
1226  function findAuthor(){
1227  throw new Error('couldn't find that author');
1228  }
1229  // synchronous
1230  try {
1231  findAuthor();
1232  } catch(reason) {
1233  // something went wrong
1234  }
1235  // async with promises
1236  findAuthor().catch(function(reason){
1237  // something went wrong
1238  });
1239  ```
1240  @method catch
1241  @param {Function} onRejection
1242  Useful for tooling.
1243  @return {Promise}
1244  */
1245
1246
1247  Promise.prototype.catch = function _catch(onRejection) {
1248    return this.then(null, onRejection);
1249  };
1250
1251  /**
1252    `finally` will be invoked regardless of the promise's fate just as native
1253    try/catch/finally behaves
1254  
1255    Synchronous example:
1256  
1257    ```js
1258    findAuthor() {
1259      if (Math.random() > 0.5) {
1260        throw new Error();
1261      }
1262      return new Author();
1263    }
1264  
1265    try {
1266      return findAuthor(); // succeed or fail
1267    } catch(error) {
1268      return findOtherAuther();
1269    } finally {
1270      // always runs
1271      // doesn't affect the return value
1272    }
1273    ```
1274  
1275    Asynchronous example:
1276  
1277    ```js
1278    findAuthor().catch(function(reason){
1279      return findOtherAuther();
1280    }).finally(function(){
1281      // author was either found, or not
1282    });
1283    ```
1284  
1285    @method finally
1286    @param {Function} callback
1287    @return {Promise}
1288  */
1289
1290
1291  Promise.prototype.finally = function _finally(callback) {
1292    var promise = this;
1293    var constructor = promise.constructor;
1294
1295    return promise.then(function (value) {
1296      return constructor.resolve(callback()).then(function () {
1297        return value;
1298      });
1299    }, function (reason) {
1300      return constructor.resolve(callback()).then(function () {
1301        throw reason;
1302      });
1303    });
1304  };
1305
1306  return Promise;
1307}();
1308
1309Promise$2.prototype.then = then;
1310Promise$2.all = all;
1311Promise$2.race = race;
1312Promise$2.resolve = resolve$1;
1313Promise$2.reject = reject$1;
1314Promise$2._setScheduler = setScheduler;
1315Promise$2._setAsap = setAsap;
1316Promise$2._asap = asap;
1317
1318/*global self*/
1319function polyfill() {
1320    var local = void 0;
1321
1322    if (typeof global !== 'undefined') {
1323        local = global;
1324    } else if (typeof self !== 'undefined') {
1325        local = self;
1326    } else {
1327        try {
1328            local = Function('return this')();
1329        } catch (e) {
1330            throw new Error('polyfill failed because global object is unavailable in this environment');
1331        }
1332    }
1333
1334    var P = local.Promise;
1335
1336    if (P) {
1337        var promiseToString = null;
1338        try {
1339            promiseToString = Object.prototype.toString.call(P.resolve());
1340        } catch (e) {
1341            // silently ignored
1342        }
1343
1344        if (promiseToString === '[object Promise]' && !P.cast) {
1345            return;
1346        }
1347    }
1348
1349    local.Promise = Promise$2;
1350}
1351
1352// Strange compat..
1353Promise$2.polyfill = polyfill;
1354Promise$2.Promise = Promise$2;
1355
1356Promise$2.polyfill();
1357
1358return Promise$2;
1359
1360})));
1361
1362
1363
1364//# sourceMappingURL=es6-promise.auto.map
1365
1366/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(2)))
1367
1368/***/ }),
1369/* 2 */
1370/***/ (function(module, exports) {
1371
1372var g;
1373
1374// This works in non-strict mode
1375g = (function() {
1376	return this;
1377})();
1378
1379try {
1380	// This works if eval is allowed (see CSP)
1381	g = g || new Function("return this")();
1382} catch (e) {
1383	// This works if the window reference is available
1384	if (typeof window === "object") g = window;
1385}
1386
1387// g can still be undefined, but nothing to do about it...
1388// We return undefined, instead of nothing here, so it's
1389// easier to handle this case. if(!global) { ...}
1390
1391module.exports = g;
1392
1393
1394/***/ }),
1395/* 3 */
1396/***/ (function(module, __webpack_exports__, __webpack_require__) {
1397
1398"use strict";
1399__webpack_require__.r(__webpack_exports__);
1400/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "VERSION", function() { return VERSION; });
1401/* harmony import */ var _Errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
1402/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "

1402AbortError", function() { return _Errors__WEBPACK_IMPORTED_MODULE_0__["AbortError"]; });
1403
1404/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpError", function() { return _Errors__WEBPACK_IMPORTED_MODULE_0__["HttpError"]; });
1405
1406/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TimeoutError", function() { return _Errors__WEBPACK_IMPORTED_MODULE_0__["TimeoutError"]; });
1407
1408/* harmony import */ var _HttpClient__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
1409/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpClient", function() { return _HttpClient__WEBPACK_IMPORTED_MODULE_1__["HttpClient"]; });
1410
1411/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpResponse", function() { return _HttpClient__WEBPACK_IMPORTED_MODULE_1__["HttpResponse"]; });
1412
1413/* harmony import */ var _DefaultHttpClient__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6);
1414/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "DefaultHttpClient", function() { return _DefaultHttpClient__WEBPACK_IMPORTED_MODULE_2__["DefaultHttpClient"]; });
1415
1416/* harmony import */ var _HubConnection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
1417/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HubConnection", function() { return _HubConnection__WEBPACK_IMPORTED_MODULE_3__["HubConnection"]; });
1418
1419/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HubConnectionState", function() { return _HubConnection__WEBPACK_IMPORTED_MODULE_3__["HubConnectionState"]; });
1420
1421/* harmony import */ var _HubConnectionBuilder__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(17);
1422/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HubConnectionBuilder", function() { return _HubConnectionBuilder__WEBPACK_IMPORTED_MODULE_4__["HubConnectionBuilder"]; });
1423
1424/* harmony import */ var _IHubProtocol__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(15);
1425/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "MessageType", function() { return _IHubProtocol__WEBPACK_IMPORTED_MODULE_5__["MessageType"]; });
1426
1427/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(9);
1428/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "LogLevel", function() { return _ILogger__WEBPACK_IMPORTED_MODULE_6__["LogLevel"]; });
1429
1430/* harmony import */ var _ITransport__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(20);
1431/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "HttpTransportType", function() { return _ITransport__WEBPACK_IMPORTED_MODULE_7__["HttpTransportType"]; });
1432
1433/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "TransferFormat", function() { return _ITransport__WEBPACK_IMPORTED_MODULE_7__["TransferFormat"]; });
1434
1435/* harmony import */ var _Loggers__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(14);
1436/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "NullLogger", function() { return _Loggers__WEBPACK_IMPORTED_MODULE_8__["NullLogger"]; });
1437
1438/* harmony import */ var _JsonHubProtocol__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(25);
1439/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "JsonHubProtocol", function() { return _JsonHubProtocol__WEBPACK_IMPORTED_MODULE_9__["JsonHubProtocol"]; });
1440
1441/* harmony import */ var _Subject__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(16);
1442/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Subject", function() { return _Subject__WEBPACK_IMPORTED_MODULE_10__["Subject"]; });
1443
1444// Copyright (c) .NET Foundation. All rights reserved.
1445// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
1446// Version token that will be replaced by the prepack command
1447/** The version of the SignalR client. */
1448var VERSION = "3.1.4";
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462/***/ }),
1463/* 4 */
1464/***/ (function(module, __webpack_exports__, __webpack_require__) {
1465
1466"use strict";
1467__webpack_require__.r(__webpack_exports__);
1468/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HttpError", function() { return HttpError; });
1469/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TimeoutError", function() { return TimeoutError; });
1470/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "AbortError", function() { return AbortError; });
1471// Copyright (c) .NET Foundation. All rights reserved.
1472// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
1473var __extends = (undefined && undefined.__extends) || (function () {
1474    var extendStatics = Object.setPrototypeOf ||
1475        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
1476        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
1477    return function (d, b) {
1478        extendStatics(d, b);
1479        function __() { this.constructor = d; }
1480        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
1481    };
1482})();
1483/** Error thrown when an HTTP request fails. */
1484var HttpError = /** @class */ (function (_super) {
1485    __extends(HttpError, _super);
1486    /** Constructs a new instance of {@link @microsoft/signalr.HttpError}.
1487     *
1488     * @param {string} errorMessage A descriptive error message.
1489     * @param {number} statusCode The HTTP status code represented by this error.
1490     */
1491    function HttpError(errorMessage, statusCode) {
1492        var _newTarget = this.constructor;
1493        var _this = this;
1494        var trueProto = _newTarget.prototype;
1495        _this = _super.call(this, errorMessage) || this;
1496        _this.statusCode = statusCode;
1497        // Workaround issue in Typescript compiler
1498        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
1499        _this.__proto__ = trueProto;
1500        return _this;
1501    }
1502    return HttpError;
1503}(Error));
1504
1505/** Error thrown when a timeout elapses. */
1506var TimeoutError = /** @class */ (function (_super) {
1507    __extends(TimeoutError, _super);
1508    /** Constructs a new instance of {@link @microsoft/signalr.TimeoutError}.
1509     *
1510     * @param {string} errorMessage A descriptive error message.
1511     */
1512    function TimeoutError(errorMessage) {
1513        var _newTarget = this.constructor;
1514        if (errorMessage === void 0) { errorMessage = "A timeout occurred."; }
1515        var _this = this;
1516        var trueProto = _newTarget.prototype;
1517        _this = _super.call(this, errorMessage) || this;
1518        // Workaround issue in Typescript compiler
1519        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
1520        _this.__proto__ = trueProto;
1521        return _this;
1522    }
1523    return TimeoutError;
1524}(Error));
1525
1526/** Error thrown when an action is aborted. */
1527var AbortError = /** @class */ (function (_super) {
1528    __extends(AbortError, _super);
1529    /** Constructs a new instance of {@link AbortError}.
1530     *
1531     * @param {string} errorMessage A descriptive error message.
1532     */
1533    function AbortError(errorMessage) {
1534        var _newTarget = this.constructor;
1535        if (errorMessage === void 0) { errorMessage = "An abort occurred."; }
1536        var _this = this;
1537        var trueProto = _newTarget.prototype;
1538        _this = _super.call(this, errorMessage) || this;
1539        // Workaround issue in Typescript compiler
1540        // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
1541        _this.__proto__ = trueProto;
1542        return _this;
1543    }
1544    return AbortError;
1545}(Error));
1546
1547
1548
1549/***/ }),
1550/* 5 */
1551/***/ (function(module, __webpack_exports__, __webpack_require__) {
1552
1553"use strict";
1554__webpack_require__.r(__webpack_exports__);
1555/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HttpResponse", function() { return HttpResponse; });
1556/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HttpClient", function() { return HttpClient; });
1557// Copyright (c) .NET Foundation. All rights reserved.
1558// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
1559var __assign = (undefined && undefined.__assign) || Object.assign || function(t) {
1560    for (var s, i = 1, n = arguments.length; i < n; i++) {
1561        s = arguments[i];
1562        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
1563            t[p] = s[p];
1564    }
1565    return t;
1566};
1567/** Represents an HTTP response. */
1568var HttpResponse = /** @class */ (function () {
1569    function HttpResponse(statusCode, statusText, content) {
1570        this.statusCode = statusCode;
1571        this.statusText = statusText;
1572        this.content = content;
1573    }
1574    return HttpResponse;
1575}());
1576
1577/** Abstraction over an HTTP client.
1578 *
1579 * This class provides an abstraction over an HTTP client so that a different implementation can be provided on different platforms.
1580 */
1581var HttpClient = /** @class */ (function () {
1582    function HttpClient() {
1583    }
1584    HttpClient.prototype.get = function (url, options) {
1585        return this.send(__assign({}, options, { method: "GET", url: url }));
1586    };
1587    HttpClient.prototype.post = function (url, options) {
1588        return this.send(__assign({}, options, { method: "POST", url: url }));
1589    };
1590    HttpClient.prototype.delete = function (url, options) {
1591        return this.send(__assign({}, options, { method: "DELETE", url: url }));
1592    };
1593    /** Gets all cookies that apply to the specified URL.
1594     *
1595     * @param url The URL that the cookies are valid for.
1596     * @returns {string} A string containing all the key-value cookie pairs for the specified URL.
1597     */
1598    // @ts-ignore
1599    HttpClient.prototype.getCookieString = function (url) {
1600        return "";
1601    };
1602    return HttpClient;
1603}());
1604
1605
1606
1607/***/ }),
1608/* 6 */
1609/***/ (function(module, __webpack_exports__, __webpack_require__) {
1610
1611"use strict";
1612__webpack_require__.r(__webpack_exports__);
1613/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DefaultHttpClient", function() { return DefaultHttpClient; });
1614/* harmony import */ var _Errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
1615/* harmony import */ var _HttpClient__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
1616/* harmony import */ var _NodeHttpClient__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7);
1617/* harmony import */ var _XhrHttpClient__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8);
1618// Copyright (c) .NET Foundation. All rights reserved.
1619// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
1620var __extends = (undefined && undefined.__extends) || (function () {
1621    var extendStatics = Object.setPrototypeOf ||
1622        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
1623        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
1624    return function (d, b) {
1625        extendStatics(d, b);
1626        function __() { this.constructor = d; }
1627        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
1628    };
1629})();
1630
1631
1632
1633
1634/** Default implementation of {@link @microsoft/signalr.HttpClient}. */
1635var DefaultHttpClient = /** @class */ (function (_super) {
1636    __extends(DefaultHttpClient, _super);
1637    /** Creates a new instance of the {@link @microsoft/signalr.DefaultHttpClient}, using the provided {@link @microsoft/signalr.ILogger} to log messages. */
1638    function DefaultHttpClient(logger) {
1639        var _this = _super.call(this) || this;
1640        if (typeof XMLHttpRequest !== "undefined") {
1641            _this.httpClient = new _XhrHttpClient__WEBPACK_IMPORTED_MODULE_3__["XhrHttpClient"](logger);
1642        }
1643        else {
1644            _this.httpClient = new _NodeHttpClient__WEBPACK_IMPORTED_MODULE_2__["NodeHttpClient"](logger);
1645        }
1646        return _this;
1647    }
1648    /** @inheritDoc */
1649    DefaultHttpClient.prototype.send = function (request) {
1650        // Check that abort was not signaled before calling send
1651        if (request.abortSignal && request.abortSignal.aborted) {
1652            return Promise.reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["AbortError"]());
1653        }
1654        if (!request.method) {
1655            return Promise.reject(new Error("No method defined."));

1748        }
1749        if (!request.url) {
1750            return Promise.reject(new Error("No url defined."));
1751        }
1752        return new Promise(function (resolve, reject) {
1753            var xhr = new XMLHttpRequest();
1754            xhr.open(request.method, request.url, true);
1755            xhr.withCredentials = true;
1756            xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
1757            // Explicitly setting the Content-Type header for React Native on Android platform.
1758            xhr.setRequestHeader("Content-Type", "text/plain;charset=UTF-8");
1759            var headers = request.headers;
1760            if (headers) {
1761                Object.keys(headers)
1762                    .forEach(function (header) {
1763                    xhr.setRequestHeader(header, headers[header]);
1764                });
1765            }
1766            if (request.responseType) {
1767                xhr.responseType = request.responseType;
1768            }
1769            if (request.abortSignal) {
1770                request.abortSignal.onabort = function () {
1771                    xhr.abort();
1772                    reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["AbortError"]());
1773                };
1774            }
1775            if (request.timeout) {
1776                xhr.timeout = request.timeout;
1777            }
1778            xhr.onload = function () {
1779                if (request.abortSignal) {
1780                    request.abortSignal.onabort = null;
1781                }
1782                if (xhr.status >= 200 && xhr.status < 300) {
1783                    resolve(new _HttpClient__WEBPACK_IMPORTED_MODULE_1__["HttpResponse"](xhr.status, xhr.statusText, xhr.response || xhr.responseText));
1784                }
1785                else {
1786                    reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["HttpError"](xhr.statusText, xhr.status));
1787                }
1788            };
1789            xhr.onerror = function () {
1790                _this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Warning, "Error from HTTP request. " + xhr.status + ": " + xhr.statusText + ".");
1791                reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["HttpError"](xhr.statusText, xhr.status));
1792            };
1793            xhr.ontimeout = function () {
1794                _this.logger.log(_ILogger__WEBPACK_IMPORTED_MODULE_2__["LogLevel"].Warning, "Timeout from HTTP request.");
1795                reject(new _Errors__WEBPACK_IMPORTED_MODULE_0__["TimeoutError"]());
1796            };
1797            xhr.send(request.content || "");
1798        });
1799    };
1800    return XhrHttpClient;
1801}(_HttpClient__WEBPACK_IMPORTED_MODULE_1__["HttpClient"]));
1802
1803
1804
1805/***/ }),
1806/* 9 */
1807/***/ (function(module, __webpack_exports__, __webpack_require__) {
1808
1809"use strict";
1810__webpack_require__.r(__webpack_exports__);
1811/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LogLevel", function() { return LogLevel; });
1812// Copyright (c) .NET Foundation. All rights reserved.
1813// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
1814// These values are designed to match the ASP.NET Log Levels since that's the pattern we're emulating here.
1815/** Indicates the severity of a log message.
1816 *
1817 * Log Levels are ordered in increasing severity. So `Debug` is more severe than `Trace`, etc.
1818 */
1819var LogLevel;
1820(function (LogLevel) {
1821    /** Log level for very low severity diagnostic messages. */
1822    LogLevel[LogLevel["Trace"] = 0] = "Trace";
1823    /** Log level for low severity diagnostic messages. */
1824    LogLevel[LogLevel["Debug"] = 1] = "Debug";
1825    /** Log level for informational diagnostic messages. */
1826    LogLevel[LogLevel["Information"] = 2] = "Information";
1827    /** Log level for diagnostic messages that indicate a non-fatal problem. */
1828    LogLevel[LogLevel["Warning"] = 3] = "Warning";
1829    /** Log level for diagnostic messages that indicate a failure in the current operation. */
1830    LogLevel[LogLevel["Error"] = 4] = "Error";
1831    /** Log level for diagnostic messages that indicate a failure that will terminate the entire application. */
1832    LogLevel[LogLevel["Critical"] = 5] = "Critical";
1833    /** The highest possible log level. Used when configuring logging to indicate that no log messages should be emitted. */
1834    LogLevel[LogLevel["None"] = 6] = "None";
1835})(LogLevel || (LogLevel = {}));
1836
1837
1838/***/ }),
1839/* 10 */
1840/***/ (function(module, __webpack_exports__, __webpack_require__) {
1841
1842"use strict";
1843__webpack_require__.r(__webpack_exports__);
1844/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HubConnectionState", function() { return HubConnectionState; });
1845/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HubConnection", function() { return HubConnection; });
1846/* harmony import */ var _HandshakeProtocol__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11);
1847/* harmony import */ var _IHubProtocol__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15);
1848/* harmony import */ var _ILogger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
1849/* harmony import */ var _Subject__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(16);
1850/* harmony import */ var _Utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(13);
1851// Copyright (c) .NET Foundation. All rights reserved.
1852// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
1853var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
1854    return new (P || (P = Promise))(function (resolve, reject) {
1855        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
1856        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
1857        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
1858        step((generator = generator.apply(thisArg, _arguments || [])).next());
1859    });

2490ould already be resolved without the continuation having run yet.
2491        this.stopDuringStartError = this.stopDuringStartError || error || new Error("The underlying connection was closed before the hub handshake could complete.");
2492        // If the handshake is in progress, start will be waiting for the handshake promise, so we complete it.
2493        // If it has already completed, this should just noop.
2494        if (this.handshakeResolver) {
2495            this.handshakeResolver();
2496        }
2497        this.cancelCallbacksWithError(error || new Error("Invocation canceled due to the underlying connection being closed."));
2498        this.cleanupTimeout();
2499        this.cleanupPingTimer();
2500        if (this.connectionState === HubConnectionState.Disconnecting) {
2501            this.completeClose(error);
2502        }
2503        else if (this.connectionState === HubConnectionState.Connected && this.reconnectPolicy) {
2504            // tslint:disable-next-line:no-floating-promises
2505            this.reconnect(error);
2506        }
2507        else if (this.connectionState === HubConnectionState.Connected) {
2508            this.completeClose(error);
2509        }
2510        // If none of the above if conditions were true were called the HubConnection must be in either:
2511        // 1. The Connecting state in which case the handshakeResolver will c