@equinor/echo-framework 0.7.3 → 0.7.6

package/dist/node_modules/@microsoft/signalr/dist/esm/Errors.js

@@ -0,0 +1,287 @@
+'use strict';
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+}); // Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+/** Error thrown when an HTTP request fails. */
+
+var HttpError = /*#__PURE__*/function (_Error) {
+  _inherits(HttpError, _Error);
+
+  var _super = _createSuper(HttpError);
+
+  /** Constructs a new instance of {@link @microsoft/signalr.HttpError}.
+   *
+   * @param {string} errorMessage A descriptive error message.
+   * @param {number} statusCode The HTTP status code represented by this error.
+   */
+  function HttpError(errorMessage, statusCode) {
+    var _this;
+
+    _classCallCheck(this, HttpError);
+
+    var trueProto = (this instanceof HttpError ? this.constructor : void 0).prototype;
+    _this = _super.call(this, "".concat(errorMessage, ": Status code '").concat(statusCode, "'"));
+    _this.statusCode = statusCode; // Workaround issue in Typescript compiler
+    // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+
+    _this.__proto__ = trueProto;
+    return _this;
+  }
+
+  return _createClass(HttpError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/** Error thrown when a timeout elapses. */
+
+
+var TimeoutError = /*#__PURE__*/function (_Error2) {
+  _inherits(TimeoutError, _Error2);
+
+  var _super2 = _createSuper(TimeoutError);
+
+  /** Constructs a new instance of {@link @microsoft/signalr.TimeoutError}.
+   *
+   * @param {string} errorMessage A descriptive error message.
+   */
+  function TimeoutError() {
+    var _this2;
+
+    var errorMessage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "A timeout occurred.";
+
+    _classCallCheck(this, TimeoutError);
+
+    var trueProto = (this instanceof TimeoutError ? this.constructor : void 0).prototype;
+    _this2 = _super2.call(this, errorMessage); // Workaround issue in Typescript compiler
+    // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+
+    _this2.__proto__ = trueProto;
+    return _this2;
+  }
+
+  return _createClass(TimeoutError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/** Error thrown when an action is aborted. */
+
+
+var AbortError = /*#__PURE__*/function (_Error3) {
+  _inherits(AbortError, _Error3);
+
+  var _super3 = _createSuper(AbortError);
+
+  /** Constructs a new instance of {@link AbortError}.
+   *
+   * @param {string} errorMessage A descriptive error message.
+   */
+  function AbortError() {
+    var _this3;
+
+    var errorMessage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "An abort occurred.";
+
+    _classCallCheck(this, AbortError);
+
+    var trueProto = (this instanceof AbortError ? this.constructor : void 0).prototype;
+    _this3 = _super3.call(this, errorMessage); // Workaround issue in Typescript compiler
+    // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+
+    _this3.__proto__ = trueProto;
+    return _this3;
+  }
+
+  return _createClass(AbortError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/** Error thrown when the selected transport is unsupported by the browser. */
+
+/** @private */
+
+
+var UnsupportedTransportError = /*#__PURE__*/function (_Error4) {
+  _inherits(UnsupportedTransportError, _Error4);
+
+  var _super4 = _createSuper(UnsupportedTransportError);
+
+  /** Constructs a new instance of {@link @microsoft/signalr.UnsupportedTransportError}.
+   *
+   * @param {string} message A descriptive error message.
+   * @param {HttpTransportType} transport The {@link @microsoft/signalr.HttpTransportType} this error occured on.
+   */
+  function UnsupportedTransportError(message, transport) {
+    var _this4;
+
+    _classCallCheck(this, UnsupportedTransportError);
+
+    var trueProto = (this instanceof UnsupportedTransportError ? this.constructor : void 0).prototype;
+    _this4 = _super4.call(this, message);
+    _this4.transport = transport;
+    _this4.errorType = 'UnsupportedTransportError'; // Workaround issue in Typescript compiler
+    // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+
+    _this4.__proto__ = trueProto;
+    return _this4;
+  }
+
+  return _createClass(UnsupportedTransportError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/** Error thrown when the selected transport is disabled by the browser. */
+
+/** @private */
+
+
+var DisabledTransportError = /*#__PURE__*/function (_Error5) {
+  _inherits(DisabledTransportError, _Error5);
+
+  var _super5 = _createSuper(DisabledTransportError);
+
+  /** Constructs a new instance of {@link @microsoft/signalr.DisabledTransportError}.
+   *
+   * @param {string} message A descriptive error message.
+   * @param {HttpTransportType} transport The {@link @microsoft/signalr.HttpTransportType} this error occured on.
+   */
+  function DisabledTransportError(message, transport) {
+    var _this5;
+
+    _classCallCheck(this, DisabledTransportError);
+
+    var trueProto = (this instanceof DisabledTransportError ? this.constructor : void 0).prototype;
+    _this5 = _super5.call(this, message);
+    _this5.transport = transport;
+    _this5.errorType = 'DisabledTransportError'; // Workaround issue in Typescript compiler
+    // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+
+    _this5.__proto__ = trueProto;
+    return _this5;
+  }
+
+  return _createClass(DisabledTransportError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/** Error thrown when the selected transport cannot be started. */
+
+/** @private */
+
+
+var FailedToStartTransportError = /*#__PURE__*/function (_Error6) {
+  _inherits(FailedToStartTransportError, _Error6);
+
+  var _super6 = _createSuper(FailedToStartTransportError);
+
+  /** Constructs a new instance of {@link @microsoft/signalr.FailedToStartTransportError}.
+   *
+   * @param {string} message A descriptive error message.
+   * @param {HttpTransportType} transport The {@link @microsoft/signalr.HttpTransportType} this error occured on.
+   */
+  function FailedToStartTransportError(message, transport) {
+    var _this6;
+
+    _classCallCheck(this, FailedToStartTransportError);
+
+    var trueProto = (this instanceof FailedToStartTransportError ? this.constructor : void 0).prototype;
+    _this6 = _super6.call(this, message);
+    _this6.transport = transport;
+    _this6.errorType = 'FailedToStartTransportError'; // Workaround issue in Typescript compiler
+    // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+
+    _this6.__proto__ = trueProto;
+    return _this6;
+  }
+
+  return _createClass(FailedToStartTransportError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/** Error thrown when the negotiation with the server failed to complete. */
+
+/** @private */
+
+
+var FailedToNegotiateWithServerError = /*#__PURE__*/function (_Error7) {
+  _inherits(FailedToNegotiateWithServerError, _Error7);
+
+  var _super7 = _createSuper(FailedToNegotiateWithServerError);
+
+  /** Constructs a new instance of {@link @microsoft/signalr.FailedToNegotiateWithServerError}.
+   *
+   * @param {string} message A descriptive error message.
+   */
+  function FailedToNegotiateWithServerError(message) {
+    var _this7;
+
+    _classCallCheck(this, FailedToNegotiateWithServerError);
+
+    var trueProto = (this instanceof FailedToNegotiateWithServerError ? this.constructor : void 0).prototype;
+    _this7 = _super7.call(this, message);
+    _this7.errorType = 'FailedToNegotiateWithServerError'; // Workaround issue in Typescript compiler
+    // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+
+    _this7.__proto__ = trueProto;
+    return _this7;
+  }
+
+  return _createClass(FailedToNegotiateWithServerError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/** Error thrown when multiple errors have occured. */
+
+/** @private */
+
+
+var AggregateErrors = /*#__PURE__*/function (_Error8) {
+  _inherits(AggregateErrors, _Error8);
+
+  var _super8 = _createSuper(AggregateErrors);
+
+  /** Constructs a new instance of {@link @microsoft/signalr.AggregateErrors}.
+   *
+   * @param {string} message A descriptive error message.
+   * @param {Error[]} innerErrors The collection of errors this error is aggregating.
+   */
+  function AggregateErrors(message, innerErrors) {
+    var _this8;
+
+    _classCallCheck(this, AggregateErrors);
+
+    var trueProto = (this instanceof AggregateErrors ? this.constructor : void 0).prototype;
+    _this8 = _super8.call(this, message);
+    _this8.innerErrors = innerErrors; // Workaround issue in Typescript compiler
+    // https://github.com/Microsoft/TypeScript/issues/13965#issuecomment-278570200
+
+    _this8.__proto__ = trueProto;
+    return _this8;
+  }
+
+  return _createClass(AggregateErrors);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+exports.AbortError = AbortError;
+exports.AggregateErrors = AggregateErrors;
+exports.DisabledTransportError = DisabledTransportError;
+exports.FailedToNegotiateWithServerError = FailedToNegotiateWithServerError;
+exports.FailedToStartTransportError = FailedToStartTransportError;
+exports.HttpError = HttpError;
+exports.TimeoutError = TimeoutError;
+exports.UnsupportedTransportError = UnsupportedTransportError;

package/dist/node_modules/@microsoft/signalr/dist/esm/FetchHttpClient.js

@@ -0,0 +1,281 @@
+'use strict';
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+
+var Errors = require('./Errors.js');
+
+var HttpClient = require('./HttpClient.js');
+
+var ILogger = require('./ILogger.js');
+
+var Utils = require('./Utils.js'); // Licensed to the .NET Foundation under one or more agreements.
+
+
+var FetchHttpClient = /*#__PURE__*/function (_HttpClient$HttpClien) {
+  _inherits(FetchHttpClient, _HttpClient$HttpClien);
+
+  var _super = _createSuper(FetchHttpClient);
+
+  function FetchHttpClient(logger) {
+    var _this;
+
+    _classCallCheck(this, FetchHttpClient);
+
+    _this = _super.call(this);
+    _this._logger = logger;
+
+    if (typeof fetch === "undefined") {
+      // In order to ignore the dynamic require in webpack builds we need to do this magic
+      // @ts-ignore: TS doesn't know about these names
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require; // Cookies aren't automatically handled in Node so we need to add a CookieJar to preserve cookies across requests
+
+      _this._jar = new (requireFunc("tough-cookie").CookieJar)();
+      _this._fetchType = requireFunc("node-fetch"); // node-fetch doesn't have a nice API for getting and setting cookies
+      // fetch-cookie will wrap a fetch implementation with a default CookieJar or a provided one
+
+      _this._fetchType = requireFunc("fetch-cookie")(_this._fetchType, _this._jar);
+    } else {
+      _this._fetchType = fetch.bind(Utils.getGlobalThis());
+    }
+
+    if (typeof AbortController === "undefined") {
+      // In order to ignore the dynamic require in webpack builds we need to do this magic
+      // @ts-ignore: TS doesn't know about these names
+      var _requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require; // Node needs EventListener methods on AbortController which our custom polyfill doesn't provide
+
+
+      _this._abortControllerType = _requireFunc("abort-controller");
+    } else {
+      _this._abortControllerType = AbortController;
+    }
+
+    return _this;
+  }
+  /** @inheritDoc */
+
+
+  _createClass(FetchHttpClient, [{
+    key: "send",
+    value: function () {
+      var _send = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(request) {
+        var _this2 = this;
+
+        var abortController, error, timeoutId, msTimeout, response, errorMessage, content, payload;
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!(request.abortSignal && request.abortSignal.aborted)) {
+                  _context.next = 2;
+                  break;
+                }
+
+                throw new Errors.AbortError();
+
+              case 2:
+                if (request.method) {
+                  _context.next = 4;
+                  break;
+                }
+
+                throw new Error("No method defined.");
+
+              case 4:
+                if (request.url) {
+                  _context.next = 6;
+                  break;
+                }
+
+                throw new Error("No url defined.");
+
+              case 6:
+                abortController = new this._abortControllerType();
+
+                // Hook our abortSignal into the abort controller
+                if (request.abortSignal) {
+                  request.abortSignal.onabort = function () {
+                    abortController.abort();
+                    error = new Errors.AbortError();
+                  };
+                } // If a timeout has been passed in, setup a timeout to call abort
+                // Type needs to be any to fit window.setTimeout and NodeJS.setTimeout
+
+
+                timeoutId = null;
+
+                if (request.timeout) {
+                  msTimeout = request.timeout;
+                  timeoutId = setTimeout(function () {
+                    abortController.abort();
+
+                    _this2._logger.log(ILogger.LogLevel.Warning, "Timeout from HTTP request.");
+
+                    error = new Errors.TimeoutError();
+                  }, msTimeout);
+                }
+
+                _context.prev = 10;
+                _context.next = 13;
+                return this._fetchType(request.url, {
+                  body: request.content,
+                  cache: "no-cache",
+                  credentials: request.withCredentials === true ? "include" : "same-origin",
+                  headers: _objectSpread({
+                    "Content-Type": "text/plain;charset=UTF-8",
+                    "X-Requested-With": "XMLHttpRequest"
+                  }, request.headers),
+                  method: request.method,
+                  mode: "cors",
+                  redirect: "follow",
+                  signal: abortController.signal
+                });
+
+              case 13:
+                response = _context.sent;
+                _context.next = 22;
+                break;
+
+              case 16:
+                _context.prev = 16;
+                _context.t0 = _context["catch"](10);
+
+                if (!error) {
+                  _context.next = 20;
+                  break;
+                }
+
+                throw error;
+
+              case 20:
+                this._logger.log(ILogger.LogLevel.Warning, "Error from HTTP request. ".concat(_context.t0, "."));
+
+                throw _context.t0;
+
+              case 22:
+                _context.prev = 22;
+
+                if (timeoutId) {
+                  clearTimeout(timeoutId);
+                }
+
+                if (request.abortSignal) {
+                  request.abortSignal.onabort = null;
+                }
+
+                return _context.finish(22);
+
+              case 26:
+                if (response.ok) {
+                  _context.next = 31;
+                  break;
+                }
+
+                _context.next = 29;
+                return deserializeContent(response, "text");
+
+              case 29:
+                errorMessage = _context.sent;
+                throw new Errors.HttpError(errorMessage || response.statusText, response.status);
+
+              case 31:
+                content = deserializeContent(response, request.responseType);
+                _context.next = 34;
+                return content;
+
+              case 34:
+                payload = _context.sent;
+                return _context.abrupt("return", new HttpClient.HttpResponse(response.status, response.statusText, payload));
+
+              case 36:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[10, 16, 22, 26]]);
+      }));
+
+      function send(_x) {
+        return _send.apply(this, arguments);
+      }
+
+      return send;
+    }()
+  }, {
+    key: "getCookieString",
+    value: function getCookieString(url) {
+      var cookies = "";
+
+      if (Utils.Platform.isNode && this._jar) {
+        // @ts-ignore: unused variable
+        this._jar.getCookies(url, function (e, c) {
+          return cookies = c.join("; ");
+        });
+      }
+
+      return cookies;
+    }
+  }]);
+
+  return FetchHttpClient;
+}(HttpClient.HttpClient);
+
+function deserializeContent(response, responseType) {
+  var content;
+
+  switch (responseType) {
+    case "arraybuffer":
+      content = response.arrayBuffer();
+      break;
+
+    case "text":
+      content = response.text();
+      break;
+
+    case "blob":
+    case "document":
+    case "json":
+      throw new Error("".concat(responseType, " is not supported."));
+
+    default:
+      content = response.text();
+      break;
+  }
+
+  return content;
+}
+
+exports.FetchHttpClient = FetchHttpClient;

package/dist/node_modules/@microsoft/signalr/dist/esm/HandshakeProtocol.js

@@ -0,0 +1,86 @@
+'use strict';
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+
+var TextMessageFormat = require('./TextMessageFormat.js');
+
+var Utils = require('./Utils.js'); // Licensed to the .NET Foundation under one or more agreements.
+
+/** @private */
+
+
+var HandshakeProtocol = /*#__PURE__*/function () {
+  function HandshakeProtocol() {
+    _classCallCheck(this, HandshakeProtocol);
+  }
+
+  _createClass(HandshakeProtocol, [{
+    key: "writeHandshakeRequest",
+    value: // Handshake request is always JSON
+    function writeHandshakeRequest(handshakeRequest) {
+      return TextMessageFormat.TextMessageFormat.write(JSON.stringify(handshakeRequest));
+    }
+  }, {
+    key: "parseHandshakeResponse",
+    value: function parseHandshakeResponse(data) {
+      var messageData;
+      var remainingData;
+
+      if (Utils.isArrayBuffer(data)) {
+        // Format is binary but still need to read JSON text from handshake response
+        var binaryData = new Uint8Array(data);
+        var separatorIndex = binaryData.indexOf(TextMessageFormat.TextMessageFormat.RecordSeparatorCode);
+
+        if (separatorIndex === -1) {
+          throw new Error("Message is incomplete.");
+        } // content before separator is handshake response
+        // optional content after is additional messages
+
+
+        var responseLength = separatorIndex + 1;
+        messageData = String.fromCharCode.apply(null, Array.prototype.slice.call(binaryData.slice(0, responseLength)));
+        remainingData = binaryData.byteLength > responseLength ? binaryData.slice(responseLength).buffer : null;
+      } else {
+        var textData = data;
+
+        var _separatorIndex = textData.indexOf(TextMessageFormat.TextMessageFormat.RecordSeparator);
+
+        if (_separatorIndex === -1) {
+          throw new Error("Message is incomplete.");
+        } // content before separator is handshake response
+        // optional content after is additional messages
+
+
+        var _responseLength = _separatorIndex + 1;
+
+        messageData = textData.substring(0, _responseLength);
+        remainingData = textData.length > _responseLength ? textData.substring(_responseLength) : null;
+      } // At this point we should have just the single handshake message
+
+
+      var messages = TextMessageFormat.TextMessageFormat.parse(messageData);
+      var response = JSON.parse(messages[0]);
+
+      if (response.type) {
+        throw new Error("Expected a handshake response from the server.");
+      }
+
+      var responseMessage = response; // multiple messages could have arrived with handshake
+      // return additional data to be parsed as usual, or null if all parsed
+
+      return [remainingData, responseMessage];
+    }
+  }]);
+
+  return HandshakeProtocol;
+}();
+
+exports.HandshakeProtocol = HandshakeProtocol;

package/dist/node_modules/@microsoft/signalr/dist/esm/HeaderNames.js

@@ -0,0 +1,20 @@
+'use strict';
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+}); // Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+var HeaderNames = /*#__PURE__*/_createClass(function HeaderNames() {
+  _classCallCheck(this, HeaderNames);
+});
+
+HeaderNames.Authorization = "Authorization";
+HeaderNames.Cookie = "Cookie";
+exports.HeaderNames = HeaderNames;