andoncloud-widget-preview 1.0.3 → 1.1.1

package/dist/index.js

@@ -8,6 +8,8 @@ var react = require('@emotion/react');
 var reactDom = require('react-dom');
 var require$$0 = require('react-is');
 var iconsMaterial = require('@mui/icons-material');
+var dragIcon_svg = require('../node_modules/andoncloud-dashboard-toolkit/dist/assets/drag-icon.svg');
+var require$$1 = require('../node_modules/andoncloud-dashboard-toolkit/dist/assets/resize-icon.svg');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -18,6 +20,8 @@ var react__default = /*#__PURE__*/_interopDefaultLegacy(react);
 var reactDom__default = /*#__PURE__*/_interopDefaultLegacy(reactDom);
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 var iconsMaterial__default = /*#__PURE__*/_interopDefaultLegacy(iconsMaterial);
+var dragIcon_svg__default = /*#__PURE__*/_interopDefaultLegacy(dragIcon_svg);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 
 function _typeof(obj) {
   "@babel/helpers - typeof";
@@ -69,6 +73,36 @@ function _createClass(Constructor, protoProps, staticProps) {
   return Constructor;
 }
 
+var matchHtmlEntity = /&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34|nbsp|#160|copy|#169|reg|#174|hellip|#8230);/g;
+var htmlEntities = {
+  '&': '&',
+  '&': '&',
+  '&lt;': '<',
+  '&#60;': '<',
+  '&gt;': '>',
+  '&#62;': '>',
+  '&apos;': "'",
+  '&#39;': "'",
+  '&quot;': '"',
+  '&#34;': '"',
+  '&nbsp;': ' ',
+  '&#160;': ' ',
+  '&copy;': '©',
+  '&#169;': '©',
+  '&reg;': '®',
+  '&#174;': '®',
+  '&hellip;': '…',
+  '&#8230;': '…'
+};
+
+var unescapeHtmlEntity = function unescapeHtmlEntity(m) {
+  return htmlEntities[m];
+};
+
+var unescape = function unescape(text) {
+  return text.replace(matchHtmlEntity, unescapeHtmlEntity);
+};
+
 function ownKeys$7(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread$7(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$7(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$7(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
@@ -79,9 +113,10 @@ var defaultOptions = {
   transSupportBasicHtmlNodes: true,
   transWrapTextNodes: '',
   transKeepBasicHtmlNodesFor: ['br', 'strong', 'i', 'p'],
-  useSuspense: true
+  useSuspense: true,
+  unescape: unescape
 };
-React__default["default"].createContext();
+React.createContext();
 function setDefaults() {
   var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   defaultOptions = _objectSpread$7(_objectSpread$7({}, defaultOptions), options);
@@ -1129,7 +1164,7 @@ var Translator = function (_EventEmitter) {
             } else {
               var pluralSuffix;
               if (needsPluralHandling) pluralSuffix = _this4.pluralResolver.getSuffix(code, options.count, options);
-              var zeroSuffix = '_zero';
+              var zeroSuffix = "".concat(_this4.options.pluralSeparator, "zero");
 
               if (needsPluralHandling) {
                 finalKeys.push(key + pluralSuffix);
@@ -2065,6 +2100,8 @@ var Connector = function (_EventEmitter) {
     _this.waitingReads = [];
     _this.maxParallelReads = options.maxParallelReads || 10;
     _this.readingCalls = 0;
+    _this.maxRetries = options.maxRetries >= 0 ? options.maxRetries : 5;
+    _this.retryTimeout = options.retryTimeout >= 1 ? options.retryTimeout : 350;
     _this.state = {};
     _this.queue = [];
 
@@ -2171,7 +2208,7 @@ var Connector = function (_EventEmitter) {
       var _this3 = this;
 
       var tried = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-      var wait = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 350;
+      var wait = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : this.retryTimeout;
       var callback = arguments.length > 5 ? arguments[5] : undefined;
       if (!lng.length) return callback(null, {});
 
@@ -2189,13 +2226,6 @@ var Connector = function (_EventEmitter) {
 
       this.readingCalls++;
       return this.backend[fcName](lng, ns, function (err, data) {
-        if (err && data && tried < 5) {
-          setTimeout(function () {
-            _this3.read.call(_this3, lng, ns, fcName, tried + 1, wait * 2, callback);
-          }, wait);
-          return;
-        }
-
         _this3.readingCalls--;
 
         if (_this3.waitingReads.length > 0) {
@@ -2204,6 +2234,13 @@ var Connector = function (_EventEmitter) {
           _this3.read(next.lng, next.ns, next.fcName, next.tried, next.wait, next.callback);
         }
 
+        if (err && data && tried < _this3.maxRetries) {
+          setTimeout(function () {
+            _this3.read.call(_this3, lng, ns, fcName, tried + 1, wait * 2, callback);
+          }, wait);
+          return;
+        }
+
         callback(err, data);
       });
     }
@@ -2439,7 +2476,7 @@ var I18n = function (_EventEmitter) {
         options = {};
       }
 
-      if (!options.defaultNS && options.ns) {
+      if (!options.defaultNS && options.defaultNS !== false && options.ns) {
         if (typeof options.ns === 'string') {
           options.defaultNS = options.ns;
         } else if (options.ns.indexOf('translation') < 0) {
@@ -2795,8 +2832,9 @@ var I18n = function (_EventEmitter) {
         options.lng = options.lng || fixedT.lng;
         options.lngs = options.lngs || fixedT.lngs;
         options.ns = options.ns || fixedT.ns;
+        options.keyPrefix = options.keyPrefix || keyPrefix || fixedT.keyPrefix;
         var keySeparator = _this5.options.keySeparator || '.';
-        var resultKey = keyPrefix ? "".concat(keyPrefix).concat(keySeparator).concat(key) : key;
+        var resultKey = options.keyPrefix ? "".concat(options.keyPrefix).concat(keySeparator).concat(key) : key;
         return _this5.t(resultKey, options);
       };
 
@@ -3012,16 +3050,18 @@ function createCommonjsModule(fn) {
 	return fn(module, module.exports), module.exports;
 }
 
-var dist = createCommonjsModule(function (module, exports) {
+var dist_1 = createCommonjsModule(function (module, exports) {
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
 
 var React__default$1 = _interopDefault(React__default["default"]);
 
 
+
 var reactIs = _interopDefault(require$$0__default["default"]);
 
 
+var resizeIcon = _interopDefault(require$$1__default["default"]);
 
 function _extends() {
   _extends = Object.assign || function (target) {
@@ -3041,6 +3081,21 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
 function _taggedTemplateLiteralLoose(strings, raw) {
   if (!raw) {
     raw = strings.slice(0);
@@ -3050,8 +3105,69 @@ function _taggedTemplateLiteralLoose(strings, raw) {
   return strings;
 }
 
+var styles = {
+  buttons: {
+    paddingTop: function paddingTop(theme) {
+      return theme.spacing(2);
+    }
+  },
+  cancelButton: {
+    marginRight: '10px'
+  },
+  popper: {
+    '.MuiTooltip-tooltip': {
+      padding: '20px',
+      fontSize: '14px',
+      color: 'rgba(0, 0, 0, 0.75)',
+      borderRadius: '8px',
+      backgroundColor: 'white'
+    },
+    '.MuiTooltip-arrow': {
+      color: 'white'
+    }
+  }
+};
+
+var _excluded = ["children", "confirmMessage", "confirmButtonText", "cancelButtonText", "onCancel", "onConfirm"];
+
+var ConfirmTooltip = function ConfirmTooltip(_ref) {
+  var children = _ref.children,
+      confirmMessage = _ref.confirmMessage,
+      confirmButtonText = _ref.confirmButtonText,
+      cancelButtonText = _ref.cancelButtonText,
+      onCancel = _ref.onCancel,
+      onConfirm = _ref.onConfirm,
+      props = _objectWithoutPropertiesLoose(_ref, _excluded);
+
+  return React__default$1.createElement(material__default["default"].Tooltip, Object.assign({}, props, {
+    placement: "bottom-end",
+    title: React__default$1.createElement(material__default["default"].Box, null, React__default$1.createElement(material__default["default"].Typography, null, confirmMessage), React__default$1.createElement(material__default["default"].Stack, {
+      direction: "row",
+      justifyContent: "flex-end",
+      sx: styles.buttons
+    }, React__default$1.createElement(material__default["default"].Button, {
+      color: "secondary",
+      onClick: function onClick(e) {
+        e.stopPropagation();
+        onCancel();
+      },
+      sx: styles.cancelButton
+    }, cancelButtonText), React__default$1.createElement(material__default["default"].Button, {
+      color: "error",
+      onClick: function onClick(e) {
+        e.stopPropagation();
+        onConfirm();
+      }
+    }, confirmButtonText))),
+    PopperProps: {
+      sx: styles.popper
+    },
+    arrow: true
+  }), children);
+};
+
 function _extends$1() {
-  _extends$1 = Object.assign || function (target) {
+  _extends$1 = Object.assign ? Object.assign.bind() : function (target) {
     for (var i = 1; i < arguments.length; i++) {
       var source = arguments[i];
 
@@ -3064,7 +3180,6 @@ function _extends$1() {
 
     return target;
   };
-
   return _extends$1.apply(this, arguments);
 }
 
@@ -3080,7 +3195,7 @@ function _taggedTemplateLiteral(strings, raw) {
   }));
 }
 
-function _objectWithoutPropertiesLoose(source, excluded) {
+function _objectWithoutPropertiesLoose$1(source, excluded) {
   if (source == null) return {};
   var target = {};
   var sourceKeys = Object.keys(source);
@@ -3097,7 +3212,7 @@ function _objectWithoutPropertiesLoose(source, excluded) {
 
 function _objectWithoutProperties(source, excluded) {
   if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var target = _objectWithoutPropertiesLoose$1(source, excluded);
   var key, i;
 
   if (Object.getOwnPropertySymbols) {
@@ -3211,11 +3326,10 @@ function _createClass(Constructor, protoProps, staticProps) {
 }
 
 function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
     o.__proto__ = p;
     return o;
   };
-
   return _setPrototypeOf(o, p);
 }
 
@@ -4474,7 +4588,7 @@ var GroupHeading = function GroupHeading(props) {
   }, innerProps));
 };
 
-var _excluded = ["innerRef", "isDisabled", "isHidden", "inputClassName"];
+var _excluded$4 = ["innerRef", "isDisabled", "isHidden", "inputClassName"];
 var inputCSS = function inputCSS(_ref) {
   var isDisabled = _ref.isDisabled,
       value = _ref.value,
@@ -4534,7 +4648,7 @@ var Input = function Input(props) {
       isDisabled = _cleanCommonProps.isDisabled,
       isHidden = _cleanCommonProps.isHidden,
       inputClassName = _cleanCommonProps.inputClassName,
-      innerProps = _objectWithoutProperties(_cleanCommonProps, _excluded);
+      innerProps = _objectWithoutProperties(_cleanCommonProps, _excluded$4);
 
   return react__default["default"].jsx("div", {
     className: cx({
@@ -4806,7 +4920,7 @@ var defaultComponents = function defaultComponents(props) {
   return _objectSpread2(_objectSpread2({}, components), props.components);
 };
 
-var _excluded$4 = ["defaultInputValue", "defaultMenuIsOpen", "defaultValue", "inputValue", "menuIsOpen", "onChange", "onInputChange", "onMenuClose", "onMenuOpen", "value"];
+var _excluded$5 = ["defaultInputValue", "defaultMenuIsOpen", "defaultValue", "inputValue", "menuIsOpen", "onChange", "onInputChange", "onMenuClose", "onMenuOpen", "value"];
 function useStateManager(_ref) {
   var _ref$defaultInputValu = _ref.defaultInputValue,
       defaultInputValue = _ref$defaultInputValu === void 0 ? '' : _ref$defaultInputValu,
@@ -4821,7 +4935,7 @@ function useStateManager(_ref) {
       propsOnMenuClose = _ref.onMenuClose,
       propsOnMenuOpen = _ref.onMenuOpen,
       propsValue = _ref.value,
-      restSelectProps = _objectWithoutProperties(_ref, _excluded$4);
+      restSelectProps = _objectWithoutProperties(_ref, _excluded$5);
 
   var _useState = React__default["default"].useState(propsInputValue !== undefined ? propsInputValue : defaultInputValue),
       _useState2 = _slicedToArray(_useState, 2),
@@ -5490,10 +5604,10 @@ var createFilter = function createFilter(config) {
   };
 };
 
-var _excluded$5 = ["innerRef"];
+var _excluded$6 = ["innerRef"];
 function DummyInput(_ref) {
   var innerRef = _ref.innerRef,
-      props = _objectWithoutProperties(_ref, _excluded$5);
+      props = _objectWithoutProperties(_ref, _excluded$6);
 
   // Remove animation props not meant for HTML elements
   var filteredProps = removeProps(props, 'onExited', 'in', 'enter', 'exit', 'appear');
@@ -6768,7 +6882,7 @@ var Select = /*#__PURE__*/function (_Component) {
       }
 
       if (isFocused && isDisabled && !prevProps.isDisabled) {
-        // ensure select state gets blurred in case Select is programatically disabled while focused
+        // ensure select state gets blurred in case Select is programmatically disabled while focused
         // eslint-disable-next-line react/no-did-update-set-state
         this.setState({
           isFocused: false
@@ -7675,6 +7789,10 @@ function createCommonjsModule(fn, module) {
 	return module = { exports: {} }, fn(module, module.exports), module.exports;
 }
 
+function getCjsExportFromNamespace (n) {
+	return n && n['default'] || n;
+}
+
 function commonjsRequire () {
 	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
 }
@@ -7774,7 +7892,7 @@ function _slicedToArray(arr, i) {
 module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
 });
 
-unwrapExports(slicedToArray);
+var _slicedToArray$1 = unwrapExports(slicedToArray);
 
 var objectWithoutPropertiesLoose = createCommonjsModule(function (module) {
 function _objectWithoutPropertiesLoose(source, excluded) {
@@ -7915,7 +8033,7 @@ function _defineProperty(obj, key, value) {
 module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
 });
 
-unwrapExports(defineProperty);
+var _defineProperty$2 = unwrapExports(defineProperty);
 
 var StateManagedSelect = /*#__PURE__*/React__default["default"].forwardRef(function (props, ref) {
   var baseSelectProps = useStateManager(props);
@@ -7962,7 +8080,7 @@ function _possibleConstructorReturn$1(self, call) {
 }
 
 function _getPrototypeOf$1(o) {
-  _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+  _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
     return o.__proto__ || Object.getPrototypeOf(o);
   };
   return _getPrototypeOf$1(o);
@@ -10542,24 +10660,481 @@ var SortableSelect = function SortableSelect(_ref) {
   });
 };
 
-var WidgetSettingsButton = function WidgetSettingsButton(_ref) {
-  var onClick = _ref.onClick;
-  return React__default$1.createElement(material__default["default"].Box, {
-    sx: {
-      position: 'absolute',
-      top: 0,
-      left: 0,
-      borderBottomRightRadius: 15,
-      background: 'rgba(0,0,0,0.15)',
-      zIndex: 1000
-    }
-  }, React__default$1.createElement(material__default["default"].IconButton, {
-    color: "primary",
-    onClick: onClick
-  }, React__default$1.createElement(iconsMaterial__default["default"].Settings, null)));
+var classCallCheck = createCommonjsModule(function (module) {
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _classCallCheck$1 = unwrapExports(classCallCheck);
+
+var createClass = createCommonjsModule(function (module) {
+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;
+}
+
+module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
+});
+
+var _createClass$1 = unwrapExports(createClass);
+
+var matchHtmlEntity = /&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34|nbsp|#160|copy|#169|reg|#174|hellip|#8230);/g;
+var htmlEntities = {
+  '&amp;': '&',
+  '&#38;': '&',
+  '&lt;': '<',
+  '&#60;': '<',
+  '&gt;': '>',
+  '&#62;': '>',
+  '&apos;': "'",
+  '&#39;': "'",
+  '&quot;': '"',
+  '&#34;': '"',
+  '&nbsp;': ' ',
+  '&#160;': ' ',
+  '&copy;': '©',
+  '&#169;': '©',
+  '&reg;': '®',
+  '&#174;': '®',
+  '&hellip;': '…',
+  '&#8230;': '…'
+};
+
+var unescapeHtmlEntity = function unescapeHtmlEntity(m) {
+  return htmlEntities[m];
 };
 
-/*! *****************************************************************************
+var unescape = function unescape(text) {
+  return text.replace(matchHtmlEntity, unescapeHtmlEntity);
+};
+
+var defaultOptions = {
+  bindI18n: 'languageChanged',
+  bindI18nStore: '',
+  transEmptyNodeValue: '',
+  transSupportBasicHtmlNodes: true,
+  transWrapTextNodes: '',
+  transKeepBasicHtmlNodesFor: ['br', 'strong', 'i', 'p'],
+  useSuspense: true,
+  unescape: unescape
+};
+var i18nInstance;
+var I18nContext = React__default["default"].createContext();
+function getDefaults() {
+  return defaultOptions;
+}
+var ReportNamespaces = function () {
+  function ReportNamespaces() {
+    _classCallCheck$1(this, ReportNamespaces);
+
+    this.usedNamespaces = {};
+  }
+
+  _createClass$1(ReportNamespaces, [{
+    key: "addUsedNamespaces",
+    value: function addUsedNamespaces(namespaces) {
+      var _this = this;
+
+      namespaces.forEach(function (ns) {
+        if (!_this.usedNamespaces[ns]) _this.usedNamespaces[ns] = true;
+      });
+    }
+  }, {
+    key: "getUsedNamespaces",
+    value: function getUsedNamespaces() {
+      return Object.keys(this.usedNamespaces);
+    }
+  }]);
+
+  return ReportNamespaces;
+}();
+function getI18n() {
+  return i18nInstance;
+}
+
+function warn() {
+  if (console && console.warn) {
+    var _console;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    if (typeof args[0] === 'string') args[0] = "react-i18next:: ".concat(args[0]);
+
+    (_console = console).warn.apply(_console, args);
+  }
+}
+var alreadyWarned = {};
+function warnOnce() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+
+  if (typeof args[0] === 'string' && alreadyWarned[args[0]]) return;
+  if (typeof args[0] === 'string') alreadyWarned[args[0]] = new Date();
+  warn.apply(void 0, args);
+}
+function loadNamespaces(i18n, ns, cb) {
+  i18n.loadNamespaces(ns, function () {
+    if (i18n.isInitialized) {
+      cb();
+    } else {
+      var initialized = function initialized() {
+        setTimeout(function () {
+          i18n.off('initialized', initialized);
+        }, 0);
+        cb();
+      };
+
+      i18n.on('initialized', initialized);
+    }
+  });
+}
+
+function oldI18nextHasLoadedNamespace(ns, i18n) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var lng = i18n.languages[0];
+  var fallbackLng = i18n.options ? i18n.options.fallbackLng : false;
+  var lastLng = i18n.languages[i18n.languages.length - 1];
+  if (lng.toLowerCase() === 'cimode') return true;
+
+  var loadNotPending = function loadNotPending(l, n) {
+    var loadState = i18n.services.backendConnector.state["".concat(l, "|").concat(n)];
+    return loadState === -1 || loadState === 2;
+  };
+
+  if (options.bindI18n && options.bindI18n.indexOf('languageChanging') > -1 && i18n.services.backendConnector.backend && i18n.isLanguageChangingTo && !loadNotPending(i18n.isLanguageChangingTo, ns)) return false;
+  if (i18n.hasResourceBundle(lng, ns)) return true;
+  if (!i18n.services.backendConnector.backend || i18n.options.resources && !i18n.options.partialBundledLanguages) return true;
+  if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns))) return true;
+  return false;
+}
+
+function hasLoadedNamespace(ns, i18n) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+  if (!i18n.languages || !i18n.languages.length) {
+    warnOnce('i18n.languages were undefined or empty', i18n.languages);
+    return true;
+  }
+
+  var isNewerI18next = i18n.options.ignoreJSONStructure !== undefined;
+
+  if (!isNewerI18next) {
+    return oldI18nextHasLoadedNamespace(ns, i18n, options);
+  }
+
+  return i18n.hasLoadedNamespace(ns, {
+    precheck: function precheck(i18nInstance, loadNotPending) {
+      if (options.bindI18n && options.bindI18n.indexOf('languageChanging') > -1 && i18nInstance.services.backendConnector.backend && i18nInstance.isLanguageChangingTo && !loadNotPending(i18nInstance.isLanguageChangingTo, ns)) return false;
+    }
+  });
+}
+
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var usePrevious = function usePrevious(value, ignore) {
+  var ref = React__default["default"].useRef();
+  React__default["default"].useEffect(function () {
+    ref.current = ignore ? ref.current : value;
+  }, [value, ignore]);
+  return ref.current;
+};
+
+function useTranslation(ns) {
+  var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var i18nFromProps = props.i18n;
+
+  var _ref = React__default["default"].useContext(I18nContext) || {},
+      i18nFromContext = _ref.i18n,
+      defaultNSFromContext = _ref.defaultNS;
+
+  var i18n = i18nFromProps || i18nFromContext || getI18n();
+  if (i18n && !i18n.reportNamespaces) i18n.reportNamespaces = new ReportNamespaces();
+
+  if (!i18n) {
+    warnOnce('You will need to pass in an i18next instance by using initReactI18next');
+
+    var notReadyT = function notReadyT(k) {
+      return Array.isArray(k) ? k[k.length - 1] : k;
+    };
+
+    var retNotReady = [notReadyT, {}, false];
+    retNotReady.t = notReadyT;
+    retNotReady.i18n = {};
+    retNotReady.ready = false;
+    return retNotReady;
+  }
+
+  if (i18n.options.react && i18n.options.react.wait !== undefined) warnOnce('It seems you are still using the old wait option, you may migrate to the new useSuspense behaviour.');
+
+  var i18nOptions = _objectSpread$1(_objectSpread$1(_objectSpread$1({}, getDefaults()), i18n.options.react), props);
+
+  var useSuspense = i18nOptions.useSuspense,
+      keyPrefix = i18nOptions.keyPrefix;
+  var namespaces = ns || defaultNSFromContext || i18n.options && i18n.options.defaultNS;
+  namespaces = typeof namespaces === 'string' ? [namespaces] : namespaces || ['translation'];
+  if (i18n.reportNamespaces.addUsedNamespaces) i18n.reportNamespaces.addUsedNamespaces(namespaces);
+  var ready = (i18n.isInitialized || i18n.initializedStoreOnce) && namespaces.every(function (n) {
+    return hasLoadedNamespace(n, i18n, i18nOptions);
+  });
+
+  function getT() {
+    return i18n.getFixedT(null, i18nOptions.nsMode === 'fallback' ? namespaces : namespaces[0], keyPrefix);
+  }
+
+  var _useState = React__default["default"].useState(getT),
+      _useState2 = _slicedToArray$1(_useState, 2),
+      t = _useState2[0],
+      setT = _useState2[1];
+
+  var joinedNS = namespaces.join();
+  var previousJoinedNS = usePrevious(joinedNS);
+  var isMounted = React__default["default"].useRef(true);
+  React__default["default"].useEffect(function () {
+    var bindI18n = i18nOptions.bindI18n,
+        bindI18nStore = i18nOptions.bindI18nStore;
+    isMounted.current = true;
+
+    if (!ready && !useSuspense) {
+      loadNamespaces(i18n, namespaces, function () {
+        if (isMounted.current) setT(getT);
+      });
+    }
+
+    if (ready && previousJoinedNS && previousJoinedNS !== joinedNS && isMounted.current) {
+      setT(getT);
+    }
+
+    function boundReset() {
+      if (isMounted.current) setT(getT);
+    }
+
+    if (bindI18n && i18n) i18n.on(bindI18n, boundReset);
+    if (bindI18nStore && i18n) i18n.store.on(bindI18nStore, boundReset);
+    return function () {
+      isMounted.current = false;
+      if (bindI18n && i18n) bindI18n.split(' ').forEach(function (e) {
+        return i18n.off(e, boundReset);
+      });
+      if (bindI18nStore && i18n) bindI18nStore.split(' ').forEach(function (e) {
+        return i18n.store.off(e, boundReset);
+      });
+    };
+  }, [i18n, joinedNS]);
+  var isInitial = React__default["default"].useRef(true);
+  React__default["default"].useEffect(function () {
+    if (isMounted.current && !isInitial.current) {
+      setT(getT);
+    }
+
+    isInitial.current = false;
+  }, [i18n, keyPrefix]);
+  var ret = [t, i18n, ready];
+  ret.t = t;
+  ret.i18n = i18n;
+  ret.ready = ready;
+  if (ready) return ret;
+  if (!ready && !useSuspense) return ret;
+  throw new Promise(function (resolve) {
+    loadNamespaces(i18n, namespaces, function () {
+      resolve();
+    });
+  });
+}
+
+var styles$1 = {
+  root: {
+    boxShadow: 'none',
+    '& .react-resizable-handle': {
+      width: '24px',
+      height: '24px',
+      borderRadius: '4px',
+      background: function background(theme) {
+        return theme.palette.primary.main + " url(" + resizeIcon + ")";
+      },
+      backgroundRepeat: 'no-repeat',
+      backgroundSize: '50%',
+      backgroundPosition: '50%',
+      '&:hover': {
+        backgroundColor: function backgroundColor(theme) {
+          return theme.palette.primary.dark;
+        }
+      }
+    },
+    '& .react-resizable-handle:after': {
+      display: 'none'
+    }
+  },
+  header: {
+    height: '40px'
+  },
+  dragIcon: {
+    width: '30px',
+    height: '30px',
+    marginLeft: function marginLeft(theme) {
+      return "-" + theme.spacing(1);
+    },
+    padding: '8px',
+    borderRadius: '4px',
+    background: function background(theme) {
+      return theme.palette.primary.main;
+    },
+    '&:hover': {
+      cursor: 'move',
+      background: function background(theme) {
+        return theme.palette.primary.dark;
+      }
+    }
+  },
+  actionButtons: {
+    height: '30px',
+    marginTop: '-7px'
+  },
+  settingsButton: {
+    color: 'rgba(255, 255, 255, 0.45)',
+    borderRadius: '4px',
+    borderTopRightRadius: 0,
+    borderBottomRightRadius: 0
+  },
+  deleteButton: {
+    color: 'rgba(255, 255, 255, 0.45)',
+    marginLeft: '1px',
+    borderRadius: '4px',
+    borderTopLeftRadius: 0,
+    borderBottomLeftRadius: 0
+  },
+  content: {
+    height: 'calc(100% - 40px)',
+    padding: 0,
+    background: 'transparent',
+    border: '1px solid rgba(255, 255, 255, 0.2)',
+    borderTop: 'none',
+    borderRadius: '4px',
+    boxShadow: '0px 4px 8px rgba(0, 0, 0, 0.25)'
+  }
+};
+
+var _excluded$7 = ["children", "title", "Widget", "id", "url", "token", "lang", "data", "settings", "openSettingsModal", "onSettingsModalOpened", "onSettingsModalClosed", "onDelete", "editMode"];
+var WidgetCard = React__default$1.forwardRef(function (_ref, ref) {
+  var children = _ref.children,
+      title = _ref.title,
+      Widget = _ref.Widget,
+      id = _ref.id,
+      url = _ref.url,
+      token = _ref.token,
+      lang = _ref.lang,
+      data = _ref.data,
+      settings = _ref.settings,
+      openSettingsModal = _ref.openSettingsModal,
+      onSettingsModalOpened = _ref.onSettingsModalOpened,
+      onSettingsModalClosed = _ref.onSettingsModalClosed,
+      onDelete = _ref.onDelete,
+      editMode = _ref.editMode,
+      cardProps = _objectWithoutPropertiesLoose(_ref, _excluded$7);
+
+  var _useState = React__default["default"].useState(false),
+      removeTooltipOpened = _useState[0],
+      setRemoveTooltipOpened = _useState[1];
+
+  var _useTranslation = useTranslation(),
+      t = _useTranslation.t;
+
+  var handleOpenSettingsModal = function handleOpenSettingsModal() {
+    if (onSettingsModalOpened) onSettingsModalOpened();
+  };
+
+  var handleDelete = function handleDelete() {
+    if (onDelete) onDelete();
+    setRemoveTooltipOpened(false);
+  };
+
+  var renderDragHandle = function renderDragHandle() {
+    return React__default$1.createElement(material__default["default"].SvgIcon, {
+      component: dragIcon_svg__default["default"].ReactComponent,
+      className: "draggable-handle",
+      sx: styles$1.dragIcon,
+      inheritViewBox: true
+    });
+  };
+
+  var renderActionButtons = function renderActionButtons() {
+    return React__default$1.createElement(material__default["default"].Stack, {
+      direction: "row",
+      sx: styles$1.actionButtons
+    }, React__default$1.createElement(material__default["default"].Button, {
+      color: "secondary",
+      sx: styles$1.settingsButton,
+      onClick: handleOpenSettingsModal
+    }, React__default$1.createElement(iconsMaterial__default["default"].Settings, null)), React__default$1.createElement(ConfirmTooltip, {
+      open: removeTooltipOpened,
+      confirmMessage: t('Are you sure you want to delete this widget?'),
+      confirmButtonText: t('Delete'),
+      cancelButtonText: t('Cancel'),
+      onCancel: function onCancel() {
+        return setRemoveTooltipOpened(false);
+      },
+      onConfirm: handleDelete
+    }, React__default$1.createElement(material__default["default"].Button, {
+      color: "secondary",
+      sx: styles$1.deleteButton,
+      onClick: function onClick(e) {
+        e.stopPropagation();
+        setRemoveTooltipOpened(true);
+      }
+    }, React__default$1.createElement(iconsMaterial__default["default"].Delete, null))));
+  };
+
+  return React__default$1.createElement(material__default["default"].Card, Object.assign({
+    ref: ref,
+    sx: styles$1.root
+  }, cardProps), React__default$1.createElement(material__default["default"].CardHeader, {
+    avatar: editMode && renderDragHandle(),
+    title: title,
+    titleTypographyProps: {
+      variant: 'subtitle1'
+    },
+    action: editMode && renderActionButtons(),
+    sx: styles$1.header
+  }), React__default$1.createElement(material__default["default"].CardContent, {
+    sx: styles$1.content
+  }, React__default$1.createElement(Widget, {
+    id: id,
+    url: url,
+    token: token,
+    lang: lang,
+    data: data,
+    settings: settings,
+    openSettingsModal: openSettingsModal,
+    onSettingsModalOpened: onSettingsModalOpened,
+    onSettingsModalClosed: onSettingsModalClosed,
+    editMode: editMode
+  })), editMode && children);
+});
+
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -10691,17 +11266,17 @@ function leftPad(len, str) {
 
 function _typeof$2(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$2 = function _typeof(obj) { return typeof obj; }; } else { _typeof$2 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$2(obj); }
 
-function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$2(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(Object(source), true).forEach(function (key) { _defineProperty$3(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-function _defineProperty$2(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 _defineProperty$3(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 _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 function _defineProperties$1(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$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }
+function _createClass$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; }
 
 function _inherits$1(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 } }); if (superClass) _setPrototypeOf$1(subClass, superClass); }
 
@@ -10780,7 +11355,7 @@ var GraphQLError = /*#__PURE__*/function (_Error) {
 
     var _this;
 
-    _classCallCheck$1(this, GraphQLError);
+    _classCallCheck$2(this, GraphQLError);
 
     _this = _super.call(this, message);
     _this.name = 'GraphQLError';
@@ -10815,7 +11390,7 @@ var GraphQLError = /*#__PURE__*/function (_Error) {
     var originalExtensions = originalError === null || originalError === void 0 ? void 0 : originalError.extensions;
 
     if (extensions == null && isObjectLike(originalExtensions)) {
-      _this.extensions = _objectSpread$1({}, originalExtensions);
+      _this.extensions = _objectSpread$2({}, originalExtensions);
     } else {
       _this.extensions = extensions !== null && extensions !== void 0 ? extensions : {};
     } // By being enumerable, JSON.stringify will include bellow properties in the resulting output.
@@ -10875,7 +11450,7 @@ var GraphQLError = /*#__PURE__*/function (_Error) {
     return _this;
   }
 
-  _createClass$1(GraphQLError, [{
+  _createClass$2(GraphQLError, [{
     key: "toString",
     value: function toString() {
       return printError(this);
@@ -11125,6 +11700,13 @@ var Token = /*#__PURE__*/function () {
 }(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
 
 defineInspect(Token);
+/**
+ * @internal
+ */
+
+function isNode(maybeNode) {
+  return maybeNode != null && typeof maybeNode.kind === 'string';
+}
 /**
  * The list of all possible AST node types.
  */
@@ -11327,7 +11909,7 @@ function instanceOf(value, constructor) {
 
 function _defineProperties$2(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$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; }
+function _createClass$3(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; }
 
 /**
  * A representation of source input to GraphQL. The `name` and `locationOffset` parameters are
@@ -11352,7 +11934,7 @@ var Source = /*#__PURE__*/function () {
   } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet
 
 
-  _createClass$2(Source, [{
+  _createClass$3(Source, [{
     key: SYMBOL_TO_STRING_TAG,
     get: function get() {
       return 'Source';
@@ -11496,6 +12078,36 @@ function getBlockStringIndentation(value) {
 
   return (_commonIndent = commonIndent) !== null && _commonIndent !== void 0 ? _commonIndent : 0;
 }
+/**
+ * Print a block string in the indented block form by adding a leading and
+ * trailing blank line. However, if a block string starts with whitespace and is
+ * a single-line, adding a leading blank line would strip that whitespace.
+ *
+ * @internal
+ */
+
+function printBlockString(value) {
+  var indentation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var preferMultipleLines = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var isSingleLine = value.indexOf('\n') === -1;
+  var hasLeadingSpace = value[0] === ' ' || value[0] === '\t';
+  var hasTrailingQuote = value[value.length - 1] === '"';
+  var hasTrailingSlash = value[value.length - 1] === '\\';
+  var printAsMultipleLines = !isSingleLine || hasTrailingQuote || hasTrailingSlash || preferMultipleLines;
+  var result = ''; // Format a multi-line block quote to account for leading space.
+
+  if (printAsMultipleLines && !(isSingleLine && hasLeadingSpace)) {
+    result += '\n' + indentation;
+  }
+
+  result += indentation ? value.replace(/\n/g, '\n' + indentation) : value;
+
+  if (printAsMultipleLines) {
+    result += '\n';
+  }
+
+  return '"""' + result.replace(/"""/g, '\\"""') + '"""';
+}
 
 /**
  * Given a Source object, creates a Lexer for that source.
@@ -12183,8 +12795,44 @@ function parse(source, options) {
   return parser.parseDocument();
 }
 /**
- * This class is exported only to assist people in implementing their own parsers
- * without duplicating too much code and should be used only as last resort for cases
+ * Given a string containing a GraphQL value (ex. `[42]`), parse the AST for
+ * that value.
+ * Throws GraphQLError if a syntax error is encountered.
+ *
+ * This is useful within tools that operate upon GraphQL Values directly and
+ * in isolation of complete GraphQL documents.
+ *
+ * Consider providing the results to the utility function: valueFromAST().
+ */
+
+function parseValue(source, options) {
+  var parser = new Parser(source, options);
+  parser.expectToken(TokenKind.SOF);
+  var value = parser.parseValueLiteral(false);
+  parser.expectToken(TokenKind.EOF);
+  return value;
+}
+/**
+ * Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for
+ * that type.
+ * Throws GraphQLError if a syntax error is encountered.
+ *
+ * This is useful within tools that operate upon GraphQL Types directly and
+ * in isolation of complete GraphQL documents.
+ *
+ * Consider providing the results to the utility function: typeFromAST().
+ */
+
+function parseType(source, options) {
+  var parser = new Parser(source, options);
+  parser.expectToken(TokenKind.SOF);
+  var type = parser.parseTypeReference();
+  parser.expectToken(TokenKind.EOF);
+  return type;
+}
+/**
+ * This class is exported only to assist people in implementing their own parsers
+ * without duplicating too much code and should be used only as last resort for cases
  * such as experimental syntax or if certain features could not be contributed upstream.
  *
  * It is still part of the internal API and is versioned, so any changes to it are never
@@ -13675,6 +14323,659 @@ function getTokenKindDesc(kind) {
   return isPunctuatorTokenKind(kind) ? "\"".concat(kind, "\"") : kind;
 }
 
+var parser = {
+  __proto__: null,
+  parse: parse,
+  parseValue: parseValue,
+  parseType: parseType,
+  Parser: Parser
+};
+
+/**
+ * A visitor is provided to visit, it contains the collection of
+ * relevant functions to be called during the visitor's traversal.
+ */
+
+var QueryDocumentKeys = {
+  Name: [],
+  Document: ['definitions'],
+  OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],
+  VariableDefinition: ['variable', 'type', 'defaultValue', 'directives'],
+  Variable: ['name'],
+  SelectionSet: ['selections'],
+  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],
+  Argument: ['name', 'value'],
+  FragmentSpread: ['name', 'directives'],
+  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],
+  FragmentDefinition: ['name', // Note: fragment variable definitions are experimental and may be changed
+  // or removed in the future.
+  'variableDefinitions', 'typeCondition', 'directives', 'selectionSet'],
+  IntValue: [],
+  FloatValue: [],
+  StringValue: [],
+  BooleanValue: [],
+  NullValue: [],
+  EnumValue: [],
+  ListValue: ['values'],
+  ObjectValue: ['fields'],
+  ObjectField: ['name', 'value'],
+  Directive: ['name', 'arguments'],
+  NamedType: ['name'],
+  ListType: ['type'],
+  NonNullType: ['type'],
+  SchemaDefinition: ['description', 'directives', 'operationTypes'],
+  OperationTypeDefinition: ['type'],
+  ScalarTypeDefinition: ['description', 'name', 'directives'],
+  ObjectTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],
+  FieldDefinition: ['description', 'name', 'arguments', 'type', 'directives'],
+  InputValueDefinition: ['description', 'name', 'type', 'defaultValue', 'directives'],
+  InterfaceTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],
+  UnionTypeDefinition: ['description', 'name', 'directives', 'types'],
+  EnumTypeDefinition: ['description', 'name', 'directives', 'values'],
+  EnumValueDefinition: ['description', 'name', 'directives'],
+  InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],
+  DirectiveDefinition: ['description', 'name', 'arguments', 'locations'],
+  SchemaExtension: ['directives', 'operationTypes'],
+  ScalarTypeExtension: ['name', 'directives'],
+  ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
+  InterfaceTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
+  UnionTypeExtension: ['name', 'directives', 'types'],
+  EnumTypeExtension: ['name', 'directives', 'values'],
+  InputObjectTypeExtension: ['name', 'directives', 'fields']
+};
+var BREAK = Object.freeze({});
+/**
+ * visit() will walk through an AST using a depth-first traversal, calling
+ * the visitor's enter function at each node in the traversal, and calling the
+ * leave function after visiting that node and all of its child nodes.
+ *
+ * By returning different values from the enter and leave functions, the
+ * behavior of the visitor can be altered, including skipping over a sub-tree of
+ * the AST (by returning false), editing the AST by returning a value or null
+ * to remove the value, or to stop the whole traversal by returning BREAK.
+ *
+ * When using visit() to edit an AST, the original AST will not be modified, and
+ * a new version of the AST with the changes applied will be returned from the
+ * visit function.
+ *
+ *     const editedAST = visit(ast, {
+ *       enter(node, key, parent, path, ancestors) {
+ *         // @return
+ *         //   undefined: no action
+ *         //   false: skip visiting this node
+ *         //   visitor.BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       },
+ *       leave(node, key, parent, path, ancestors) {
+ *         // @return
+ *         //   undefined: no action
+ *         //   false: no action
+ *         //   visitor.BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       }
+ *     });
+ *
+ * Alternatively to providing enter() and leave() functions, a visitor can
+ * instead provide functions named the same as the kinds of AST nodes, or
+ * enter/leave visitors at a named key, leading to four permutations of the
+ * visitor API:
+ *
+ * 1) Named visitors triggered when entering a node of a specific kind.
+ *
+ *     visit(ast, {
+ *       Kind(node) {
+ *         // enter the "Kind" node
+ *       }
+ *     })
+ *
+ * 2) Named visitors that trigger upon entering and leaving a node of
+ *    a specific kind.
+ *
+ *     visit(ast, {
+ *       Kind: {
+ *         enter(node) {
+ *           // enter the "Kind" node
+ *         }
+ *         leave(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ *
+ * 3) Generic visitors that trigger upon entering and leaving any node.
+ *
+ *     visit(ast, {
+ *       enter(node) {
+ *         // enter any node
+ *       },
+ *       leave(node) {
+ *         // leave any node
+ *       }
+ *     })
+ *
+ * 4) Parallel visitors for entering and leaving nodes of a specific kind.
+ *
+ *     visit(ast, {
+ *       enter: {
+ *         Kind(node) {
+ *           // enter the "Kind" node
+ *         }
+ *       },
+ *       leave: {
+ *         Kind(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ */
+
+function visit(root, visitor) {
+  var visitorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : QueryDocumentKeys;
+
+  /* eslint-disable no-undef-init */
+  var stack = undefined;
+  var inArray = Array.isArray(root);
+  var keys = [root];
+  var index = -1;
+  var edits = [];
+  var node = undefined;
+  var key = undefined;
+  var parent = undefined;
+  var path = [];
+  var ancestors = [];
+  var newRoot = root;
+  /* eslint-enable no-undef-init */
+
+  do {
+    index++;
+    var isLeaving = index === keys.length;
+    var isEdited = isLeaving && edits.length !== 0;
+
+    if (isLeaving) {
+      key = ancestors.length === 0 ? undefined : path[path.length - 1];
+      node = parent;
+      parent = ancestors.pop();
+
+      if (isEdited) {
+        if (inArray) {
+          node = node.slice();
+        } else {
+          var clone = {};
+
+          for (var _i2 = 0, _Object$keys2 = Object.keys(node); _i2 < _Object$keys2.length; _i2++) {
+            var k = _Object$keys2[_i2];
+            clone[k] = node[k];
+          }
+
+          node = clone;
+        }
+
+        var editOffset = 0;
+
+        for (var ii = 0; ii < edits.length; ii++) {
+          var editKey = edits[ii][0];
+          var editValue = edits[ii][1];
+
+          if (inArray) {
+            editKey -= editOffset;
+          }
+
+          if (inArray && editValue === null) {
+            node.splice(editKey, 1);
+            editOffset++;
+          } else {
+            node[editKey] = editValue;
+          }
+        }
+      }
+
+      index = stack.index;
+      keys = stack.keys;
+      edits = stack.edits;
+      inArray = stack.inArray;
+      stack = stack.prev;
+    } else {
+      key = parent ? inArray ? index : keys[index] : undefined;
+      node = parent ? parent[key] : newRoot;
+
+      if (node === null || node === undefined) {
+        continue;
+      }
+
+      if (parent) {
+        path.push(key);
+      }
+    }
+
+    var result = void 0;
+
+    if (!Array.isArray(node)) {
+      if (!isNode(node)) {
+        throw new Error("Invalid AST Node: ".concat(inspect(node), "."));
+      }
+
+      var visitFn = getVisitFn(visitor, node.kind, isLeaving);
+
+      if (visitFn) {
+        result = visitFn.call(visitor, node, key, parent, path, ancestors);
+
+        if (result === BREAK) {
+          break;
+        }
+
+        if (result === false) {
+          if (!isLeaving) {
+            path.pop();
+            continue;
+          }
+        } else if (result !== undefined) {
+          edits.push([key, result]);
+
+          if (!isLeaving) {
+            if (isNode(result)) {
+              node = result;
+            } else {
+              path.pop();
+              continue;
+            }
+          }
+        }
+      }
+    }
+
+    if (result === undefined && isEdited) {
+      edits.push([key, node]);
+    }
+
+    if (isLeaving) {
+      path.pop();
+    } else {
+      var _visitorKeys$node$kin;
+
+      stack = {
+        inArray: inArray,
+        index: index,
+        keys: keys,
+        edits: edits,
+        prev: stack
+      };
+      inArray = Array.isArray(node);
+      keys = inArray ? node : (_visitorKeys$node$kin = visitorKeys[node.kind]) !== null && _visitorKeys$node$kin !== void 0 ? _visitorKeys$node$kin : [];
+      index = -1;
+      edits = [];
+
+      if (parent) {
+        ancestors.push(parent);
+      }
+
+      parent = node;
+    }
+  } while (stack !== undefined);
+
+  if (edits.length !== 0) {
+    newRoot = edits[edits.length - 1][1];
+  }
+
+  return newRoot;
+}
+/**
+ * Given a visitor instance, if it is leaving or not, and a node kind, return
+ * the function the visitor runtime should call.
+ */
+
+function getVisitFn(visitor, kind, isLeaving) {
+  var kindVisitor = visitor[kind];
+
+  if (kindVisitor) {
+    if (!isLeaving && typeof kindVisitor === 'function') {
+      // { Kind() {} }
+      return kindVisitor;
+    }
+
+    var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;
+
+    if (typeof kindSpecificVisitor === 'function') {
+      // { Kind: { enter() {}, leave() {} } }
+      return kindSpecificVisitor;
+    }
+  } else {
+    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;
+
+    if (specificVisitor) {
+      if (typeof specificVisitor === 'function') {
+        // { enter() {}, leave() {} }
+        return specificVisitor;
+      }
+
+      var specificKindVisitor = specificVisitor[kind];
+
+      if (typeof specificKindVisitor === 'function') {
+        // { enter: { Kind() {} }, leave: { Kind() {} } }
+        return specificKindVisitor;
+      }
+    }
+  }
+}
+
+/**
+ * Converts an AST into a string, using one set of reasonable
+ * formatting rules.
+ */
+
+function print(ast) {
+  return visit(ast, {
+    leave: printDocASTReducer
+  });
+}
+var MAX_LINE_LENGTH = 80; // TODO: provide better type coverage in future
+
+var printDocASTReducer = {
+  Name: function Name(node) {
+    return node.value;
+  },
+  Variable: function Variable(node) {
+    return '$' + node.name;
+  },
+  // Document
+  Document: function Document(node) {
+    return join(node.definitions, '\n\n') + '\n';
+  },
+  OperationDefinition: function OperationDefinition(node) {
+    var op = node.operation;
+    var name = node.name;
+    var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
+    var directives = join(node.directives, ' ');
+    var selectionSet = node.selectionSet; // Anonymous queries with no directives or variable definitions can use
+    // the query short form.
+
+    return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');
+  },
+  VariableDefinition: function VariableDefinition(_ref) {
+    var variable = _ref.variable,
+        type = _ref.type,
+        defaultValue = _ref.defaultValue,
+        directives = _ref.directives;
+    return variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' '));
+  },
+  SelectionSet: function SelectionSet(_ref2) {
+    var selections = _ref2.selections;
+    return block(selections);
+  },
+  Field: function Field(_ref3) {
+    var alias = _ref3.alias,
+        name = _ref3.name,
+        args = _ref3.arguments,
+        directives = _ref3.directives,
+        selectionSet = _ref3.selectionSet;
+    var prefix = wrap('', alias, ': ') + name;
+    var argsLine = prefix + wrap('(', join(args, ', '), ')');
+
+    if (argsLine.length > MAX_LINE_LENGTH) {
+      argsLine = prefix + wrap('(\n', indent(join(args, '\n')), '\n)');
+    }
+
+    return join([argsLine, join(directives, ' '), selectionSet], ' ');
+  },
+  Argument: function Argument(_ref4) {
+    var name = _ref4.name,
+        value = _ref4.value;
+    return name + ': ' + value;
+  },
+  // Fragments
+  FragmentSpread: function FragmentSpread(_ref5) {
+    var name = _ref5.name,
+        directives = _ref5.directives;
+    return '...' + name + wrap(' ', join(directives, ' '));
+  },
+  InlineFragment: function InlineFragment(_ref6) {
+    var typeCondition = _ref6.typeCondition,
+        directives = _ref6.directives,
+        selectionSet = _ref6.selectionSet;
+    return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');
+  },
+  FragmentDefinition: function FragmentDefinition(_ref7) {
+    var name = _ref7.name,
+        typeCondition = _ref7.typeCondition,
+        variableDefinitions = _ref7.variableDefinitions,
+        directives = _ref7.directives,
+        selectionSet = _ref7.selectionSet;
+    return (// Note: fragment variable definitions are experimental and may be changed
+      // or removed in the future.
+      "fragment ".concat(name).concat(wrap('(', join(variableDefinitions, ', '), ')'), " ") + "on ".concat(typeCondition, " ").concat(wrap('', join(directives, ' '), ' ')) + selectionSet
+    );
+  },
+  // Value
+  IntValue: function IntValue(_ref8) {
+    var value = _ref8.value;
+    return value;
+  },
+  FloatValue: function FloatValue(_ref9) {
+    var value = _ref9.value;
+    return value;
+  },
+  StringValue: function StringValue(_ref10, key) {
+    var value = _ref10.value,
+        isBlockString = _ref10.block;
+    return isBlockString ? printBlockString(value, key === 'description' ? '' : '  ') : JSON.stringify(value);
+  },
+  BooleanValue: function BooleanValue(_ref11) {
+    var value = _ref11.value;
+    return value ? 'true' : 'false';
+  },
+  NullValue: function NullValue() {
+    return 'null';
+  },
+  EnumValue: function EnumValue(_ref12) {
+    var value = _ref12.value;
+    return value;
+  },
+  ListValue: function ListValue(_ref13) {
+    var values = _ref13.values;
+    return '[' + join(values, ', ') + ']';
+  },
+  ObjectValue: function ObjectValue(_ref14) {
+    var fields = _ref14.fields;
+    return '{' + join(fields, ', ') + '}';
+  },
+  ObjectField: function ObjectField(_ref15) {
+    var name = _ref15.name,
+        value = _ref15.value;
+    return name + ': ' + value;
+  },
+  // Directive
+  Directive: function Directive(_ref16) {
+    var name = _ref16.name,
+        args = _ref16.arguments;
+    return '@' + name + wrap('(', join(args, ', '), ')');
+  },
+  // Type
+  NamedType: function NamedType(_ref17) {
+    var name = _ref17.name;
+    return name;
+  },
+  ListType: function ListType(_ref18) {
+    var type = _ref18.type;
+    return '[' + type + ']';
+  },
+  NonNullType: function NonNullType(_ref19) {
+    var type = _ref19.type;
+    return type + '!';
+  },
+  // Type System Definitions
+  SchemaDefinition: addDescription(function (_ref20) {
+    var directives = _ref20.directives,
+        operationTypes = _ref20.operationTypes;
+    return join(['schema', join(directives, ' '), block(operationTypes)], ' ');
+  }),
+  OperationTypeDefinition: function OperationTypeDefinition(_ref21) {
+    var operation = _ref21.operation,
+        type = _ref21.type;
+    return operation + ': ' + type;
+  },
+  ScalarTypeDefinition: addDescription(function (_ref22) {
+    var name = _ref22.name,
+        directives = _ref22.directives;
+    return join(['scalar', name, join(directives, ' ')], ' ');
+  }),
+  ObjectTypeDefinition: addDescription(function (_ref23) {
+    var name = _ref23.name,
+        interfaces = _ref23.interfaces,
+        directives = _ref23.directives,
+        fields = _ref23.fields;
+    return join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
+  }),
+  FieldDefinition: addDescription(function (_ref24) {
+    var name = _ref24.name,
+        args = _ref24.arguments,
+        type = _ref24.type,
+        directives = _ref24.directives;
+    return name + (hasMultilineItems(args) ? wrap('(\n', indent(join(args, '\n')), '\n)') : wrap('(', join(args, ', '), ')')) + ': ' + type + wrap(' ', join(directives, ' '));
+  }),
+  InputValueDefinition: addDescription(function (_ref25) {
+    var name = _ref25.name,
+        type = _ref25.type,
+        defaultValue = _ref25.defaultValue,
+        directives = _ref25.directives;
+    return join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ');
+  }),
+  InterfaceTypeDefinition: addDescription(function (_ref26) {
+    var name = _ref26.name,
+        interfaces = _ref26.interfaces,
+        directives = _ref26.directives,
+        fields = _ref26.fields;
+    return join(['interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
+  }),
+  UnionTypeDefinition: addDescription(function (_ref27) {
+    var name = _ref27.name,
+        directives = _ref27.directives,
+        types = _ref27.types;
+    return join(['union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');
+  }),
+  EnumTypeDefinition: addDescription(function (_ref28) {
+    var name = _ref28.name,
+        directives = _ref28.directives,
+        values = _ref28.values;
+    return join(['enum', name, join(directives, ' '), block(values)], ' ');
+  }),
+  EnumValueDefinition: addDescription(function (_ref29) {
+    var name = _ref29.name,
+        directives = _ref29.directives;
+    return join([name, join(directives, ' ')], ' ');
+  }),
+  InputObjectTypeDefinition: addDescription(function (_ref30) {
+    var name = _ref30.name,
+        directives = _ref30.directives,
+        fields = _ref30.fields;
+    return join(['input', name, join(directives, ' '), block(fields)], ' ');
+  }),
+  DirectiveDefinition: addDescription(function (_ref31) {
+    var name = _ref31.name,
+        args = _ref31.arguments,
+        repeatable = _ref31.repeatable,
+        locations = _ref31.locations;
+    return 'directive @' + name + (hasMultilineItems(args) ? wrap('(\n', indent(join(args, '\n')), '\n)') : wrap('(', join(args, ', '), ')')) + (repeatable ? ' repeatable' : '') + ' on ' + join(locations, ' | ');
+  }),
+  SchemaExtension: function SchemaExtension(_ref32) {
+    var directives = _ref32.directives,
+        operationTypes = _ref32.operationTypes;
+    return join(['extend schema', join(directives, ' '), block(operationTypes)], ' ');
+  },
+  ScalarTypeExtension: function ScalarTypeExtension(_ref33) {
+    var name = _ref33.name,
+        directives = _ref33.directives;
+    return join(['extend scalar', name, join(directives, ' ')], ' ');
+  },
+  ObjectTypeExtension: function ObjectTypeExtension(_ref34) {
+    var name = _ref34.name,
+        interfaces = _ref34.interfaces,
+        directives = _ref34.directives,
+        fields = _ref34.fields;
+    return join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
+  },
+  InterfaceTypeExtension: function InterfaceTypeExtension(_ref35) {
+    var name = _ref35.name,
+        interfaces = _ref35.interfaces,
+        directives = _ref35.directives,
+        fields = _ref35.fields;
+    return join(['extend interface', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');
+  },
+  UnionTypeExtension: function UnionTypeExtension(_ref36) {
+    var name = _ref36.name,
+        directives = _ref36.directives,
+        types = _ref36.types;
+    return join(['extend union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');
+  },
+  EnumTypeExtension: function EnumTypeExtension(_ref37) {
+    var name = _ref37.name,
+        directives = _ref37.directives,
+        values = _ref37.values;
+    return join(['extend enum', name, join(directives, ' '), block(values)], ' ');
+  },
+  InputObjectTypeExtension: function InputObjectTypeExtension(_ref38) {
+    var name = _ref38.name,
+        directives = _ref38.directives,
+        fields = _ref38.fields;
+    return join(['extend input', name, join(directives, ' '), block(fields)], ' ');
+  }
+};
+
+function addDescription(cb) {
+  return function (node) {
+    return join([node.description, cb(node)], '\n');
+  };
+}
+/**
+ * Given maybeArray, print an empty string if it is null or empty, otherwise
+ * print all items together separated by separator if provided
+ */
+
+
+function join(maybeArray) {
+  var _maybeArray$filter$jo;
+
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter(function (x) {
+    return x;
+  }).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : '';
+}
+/**
+ * Given array, print each item on its own line, wrapped in an
+ * indented "{ }" block.
+ */
+
+
+function block(array) {
+  return wrap('{\n', indent(join(array, '\n')), '\n}');
+}
+/**
+ * If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.
+ */
+
+
+function wrap(start, maybeString) {
+  var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  return maybeString != null && maybeString !== '' ? start + maybeString + end : '';
+}
+
+function indent(str) {
+  return wrap('  ', str.replace(/\n/g, '\n  '));
+}
+
+function isMultiline(str) {
+  return str.indexOf('\n') !== -1;
+}
+
+function hasMultilineItems(maybeArray) {
+  return maybeArray != null && maybeArray.some(isMultiline);
+}
+
+var printer = {
+  __proto__: null,
+  print: print
+};
+
 var docCache = new Map();
 var fragmentSourceMap = new Map();
 var printFragmentWarnings = true;
@@ -15868,147 +17169,1766 @@ var Observable = /*@__PURE__*/ (function () {
         }
         return pipeFromArray(operations)(this);
     };
-    Observable.prototype.toPromise = function (promiseCtor) {
+    Observable.prototype.toPromise = function (promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+            var value;
+            _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });
+        });
+    };
+    Observable.create = function (subscribe) {
+        return new Observable(subscribe);
+    };
+    return Observable;
+}());
+function getPromiseCtor(promiseCtor) {
+    if (!promiseCtor) {
+        promiseCtor =  Promise;
+    }
+    if (!promiseCtor) {
+        throw new Error('no Promise impl found');
+    }
+    return promiseCtor;
+}
+
+var ActionCableClient = /*#__PURE__*/function () {
+  function ActionCableClient(url) {
+    var _this = this;
+
+    this.cable = null;
+    this.subscriptions = new Map();
+
+    this.addSubscription = function (id, subscription) {
+      _this.subscriptions.set(id, subscription);
+    };
+
+    this.wsURL = url;
+  }
+
+  var _proto = ActionCableClient.prototype;
+
+  _proto.connect = function connect(token, lang) {
+    this.cable = action_cable.createConsumer(this.wsURL + "?token=" + token + "&lang=" + lang);
+  };
+
+  _proto.request = function request(_request) {
+    var cable = this.cable,
+        subscriptions = this.subscriptions,
+        addSubscription = this.addSubscription;
+    var subscription;
+    return new Observable(function (observer) {
+      if (cable) {
+        var _request$variables;
+
+        var subscriptionId = ((_request$variables = _request.variables) === null || _request$variables === void 0 ? void 0 : _request$variables.id) || 'company';
+
+        if (!subscriptions.has(subscriptionId)) {
+          subscription = cable.subscriptions.create({
+            channel: 'GraphqlChannel',
+            channelId: Math.round(Date.now() + Math.random() * 100000).toString(16)
+          }, {
+            connected: function connected() {
+              this.perform('execute', _request);
+            },
+            received: function received(payload) {
+              if (!payload.more) {
+                if (observer.complete) {
+                  observer.complete();
+                }
+              } else if (payload.result.errors) {
+                if (observer.error) {
+                  observer.error(payload.result.errors[0]);
+                }
+              } else if (payload.result.data) {
+                if (observer.next) {
+                  if (!lodash_isempty(payload.result.data)) {
+                    observer.next(payload.result);
+                  }
+                }
+              }
+            }
+          });
+          addSubscription(subscriptionId, subscription);
+        }
+      }
+    });
+  };
+
+  _proto.hasSubscription = function hasSubscription(id) {
+    return this.subscriptions.has(id);
+  };
+
+  return ActionCableClient;
+}();
+
+var GraphqlWsClient = /*#__PURE__*/function () {
+  function GraphqlWsClient(url, token, lang) {
+    this.actionCableClient = null;
+    this.actionCableClient = new ActionCableClient(url);
+    this.actionCableClient.connect(token, lang);
+  }
+
+  var _proto = GraphqlWsClient.prototype;
+
+  _proto.subscribe = function subscribe(query, variables, onData, onError) {
+    if (onError === void 0) {
+      onError = function onError(error) {
+        throw error;
+      };
+    }
+
+    var getFirstValue = function getFirstValue(data) {
+      var keys = Object.keys(data);
+      if (keys.length !== 1) throw new Error("Expected exactly one response key, got: " + keys.join(', '));
+      return data[keys[0]];
+    };
+
+    if (!this.actionCableClient) throw new Error('No WS client available');
+    var subscription = this.actionCableClient.request({
+      query: query,
+      variables: variables
+    }).subscribe({
+      next: function next(_ref) {
+        var data = _ref.data,
+            errors = _ref.errors;
+
+        if (errors) {
+          return onError(new Error(JSON.stringify(errors)));
+        }
+
+        if (data && onData) onData(getFirstValue(data));
+      }
+    });
+    return function () {
+      return subscription.unsubscribe();
+    };
+  };
+
+  return GraphqlWsClient;
+}();
+
+var getGqlWsClient = function getGqlWsClient(url, token, lang) {
+  return new GraphqlWsClient(url, token, lang);
+};
+
+var browserPonyfill = createCommonjsModule(function (module, exports) {
+var global = typeof self !== 'undefined' ? self : commonjsGlobal$1;
+var __self__ = (function () {
+function F() {
+this.fetch = false;
+this.DOMException = global.DOMException;
+}
+F.prototype = global;
+return new F();
+})();
+(function(self) {
+
+((function (exports) {
+
+  var support = {
+    searchParams: 'URLSearchParams' in self,
+    iterable: 'Symbol' in self && 'iterator' in Symbol,
+    blob:
+      'FileReader' in self &&
+      'Blob' in self &&
+      (function() {
+        try {
+          new Blob();
+          return true
+        } catch (e) {
+          return false
+        }
+      })(),
+    formData: 'FormData' in self,
+    arrayBuffer: 'ArrayBuffer' in self
+  };
+
+  function isDataView(obj) {
+    return obj && DataView.prototype.isPrototypeOf(obj)
+  }
+
+  if (support.arrayBuffer) {
+    var viewClasses = [
+      '[object Int8Array]',
+      '[object Uint8Array]',
+      '[object Uint8ClampedArray]',
+      '[object Int16Array]',
+      '[object Uint16Array]',
+      '[object Int32Array]',
+      '[object Uint32Array]',
+      '[object Float32Array]',
+      '[object Float64Array]'
+    ];
+
+    var isArrayBufferView =
+      ArrayBuffer.isView ||
+      function(obj) {
+        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+      };
+  }
+
+  function normalizeName(name) {
+    if (typeof name !== 'string') {
+      name = String(name);
+    }
+    if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
+      throw new TypeError('Invalid character in header field name')
+    }
+    return name.toLowerCase()
+  }
+
+  function normalizeValue(value) {
+    if (typeof value !== 'string') {
+      value = String(value);
+    }
+    return value
+  }
+
+  // Build a destructive iterator for the value list
+  function iteratorFor(items) {
+    var iterator = {
+      next: function() {
+        var value = items.shift();
+        return {done: value === undefined, value: value}
+      }
+    };
+
+    if (support.iterable) {
+      iterator[Symbol.iterator] = function() {
+        return iterator
+      };
+    }
+
+    return iterator
+  }
+
+  function Headers(headers) {
+    this.map = {};
+
+    if (headers instanceof Headers) {
+      headers.forEach(function(value, name) {
+        this.append(name, value);
+      }, this);
+    } else if (Array.isArray(headers)) {
+      headers.forEach(function(header) {
+        this.append(header[0], header[1]);
+      }, this);
+    } else if (headers) {
+      Object.getOwnPropertyNames(headers).forEach(function(name) {
+        this.append(name, headers[name]);
+      }, this);
+    }
+  }
+
+  Headers.prototype.append = function(name, value) {
+    name = normalizeName(name);
+    value = normalizeValue(value);
+    var oldValue = this.map[name];
+    this.map[name] = oldValue ? oldValue + ', ' + value : value;
+  };
+
+  Headers.prototype['delete'] = function(name) {
+    delete this.map[normalizeName(name)];
+  };
+
+  Headers.prototype.get = function(name) {
+    name = normalizeName(name);
+    return this.has(name) ? this.map[name] : null
+  };
+
+  Headers.prototype.has = function(name) {
+    return this.map.hasOwnProperty(normalizeName(name))
+  };
+
+  Headers.prototype.set = function(name, value) {
+    this.map[normalizeName(name)] = normalizeValue(value);
+  };
+
+  Headers.prototype.forEach = function(callback, thisArg) {
+    for (var name in this.map) {
+      if (this.map.hasOwnProperty(name)) {
+        callback.call(thisArg, this.map[name], name, this);
+      }
+    }
+  };
+
+  Headers.prototype.keys = function() {
+    var items = [];
+    this.forEach(function(value, name) {
+      items.push(name);
+    });
+    return iteratorFor(items)
+  };
+
+  Headers.prototype.values = function() {
+    var items = [];
+    this.forEach(function(value) {
+      items.push(value);
+    });
+    return iteratorFor(items)
+  };
+
+  Headers.prototype.entries = function() {
+    var items = [];
+    this.forEach(function(value, name) {
+      items.push([name, value]);
+    });
+    return iteratorFor(items)
+  };
+
+  if (support.iterable) {
+    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+  }
+
+  function consumed(body) {
+    if (body.bodyUsed) {
+      return Promise.reject(new TypeError('Already read'))
+    }
+    body.bodyUsed = true;
+  }
+
+  function fileReaderReady(reader) {
+    return new Promise(function(resolve, reject) {
+      reader.onload = function() {
+        resolve(reader.result);
+      };
+      reader.onerror = function() {
+        reject(reader.error);
+      };
+    })
+  }
+
+  function readBlobAsArrayBuffer(blob) {
+    var reader = new FileReader();
+    var promise = fileReaderReady(reader);
+    reader.readAsArrayBuffer(blob);
+    return promise
+  }
+
+  function readBlobAsText(blob) {
+    var reader = new FileReader();
+    var promise = fileReaderReady(reader);
+    reader.readAsText(blob);
+    return promise
+  }
+
+  function readArrayBufferAsText(buf) {
+    var view = new Uint8Array(buf);
+    var chars = new Array(view.length);
+
+    for (var i = 0; i < view.length; i++) {
+      chars[i] = String.fromCharCode(view[i]);
+    }
+    return chars.join('')
+  }
+
+  function bufferClone(buf) {
+    if (buf.slice) {
+      return buf.slice(0)
+    } else {
+      var view = new Uint8Array(buf.byteLength);
+      view.set(new Uint8Array(buf));
+      return view.buffer
+    }
+  }
+
+  function Body() {
+    this.bodyUsed = false;
+
+    this._initBody = function(body) {
+      this._bodyInit = body;
+      if (!body) {
+        this._bodyText = '';
+      } else if (typeof body === 'string') {
+        this._bodyText = body;
+      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+        this._bodyBlob = body;
+      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+        this._bodyFormData = body;
+      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+        this._bodyText = body.toString();
+      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+        this._bodyArrayBuffer = bufferClone(body.buffer);
+        // IE 10-11 can't handle a DataView body.
+        this._bodyInit = new Blob([this._bodyArrayBuffer]);
+      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+        this._bodyArrayBuffer = bufferClone(body);
+      } else {
+        this._bodyText = body = Object.prototype.toString.call(body);
+      }
+
+      if (!this.headers.get('content-type')) {
+        if (typeof body === 'string') {
+          this.headers.set('content-type', 'text/plain;charset=UTF-8');
+        } else if (this._bodyBlob && this._bodyBlob.type) {
+          this.headers.set('content-type', this._bodyBlob.type);
+        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        }
+      }
+    };
+
+    if (support.blob) {
+      this.blob = function() {
+        var rejected = consumed(this);
+        if (rejected) {
+          return rejected
+        }
+
+        if (this._bodyBlob) {
+          return Promise.resolve(this._bodyBlob)
+        } else if (this._bodyArrayBuffer) {
+          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+        } else if (this._bodyFormData) {
+          throw new Error('could not read FormData body as blob')
+        } else {
+          return Promise.resolve(new Blob([this._bodyText]))
+        }
+      };
+
+      this.arrayBuffer = function() {
+        if (this._bodyArrayBuffer) {
+          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
+        } else {
+          return this.blob().then(readBlobAsArrayBuffer)
+        }
+      };
+    }
+
+    this.text = function() {
+      var rejected = consumed(this);
+      if (rejected) {
+        return rejected
+      }
+
+      if (this._bodyBlob) {
+        return readBlobAsText(this._bodyBlob)
+      } else if (this._bodyArrayBuffer) {
+        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+      } else if (this._bodyFormData) {
+        throw new Error('could not read FormData body as text')
+      } else {
+        return Promise.resolve(this._bodyText)
+      }
+    };
+
+    if (support.formData) {
+      this.formData = function() {
+        return this.text().then(decode)
+      };
+    }
+
+    this.json = function() {
+      return this.text().then(JSON.parse)
+    };
+
+    return this
+  }
+
+  // HTTP methods whose capitalization should be normalized
+  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+
+  function normalizeMethod(method) {
+    var upcased = method.toUpperCase();
+    return methods.indexOf(upcased) > -1 ? upcased : method
+  }
+
+  function Request(input, options) {
+    options = options || {};
+    var body = options.body;
+
+    if (input instanceof Request) {
+      if (input.bodyUsed) {
+        throw new TypeError('Already read')
+      }
+      this.url = input.url;
+      this.credentials = input.credentials;
+      if (!options.headers) {
+        this.headers = new Headers(input.headers);
+      }
+      this.method = input.method;
+      this.mode = input.mode;
+      this.signal = input.signal;
+      if (!body && input._bodyInit != null) {
+        body = input._bodyInit;
+        input.bodyUsed = true;
+      }
+    } else {
+      this.url = String(input);
+    }
+
+    this.credentials = options.credentials || this.credentials || 'same-origin';
+    if (options.headers || !this.headers) {
+      this.headers = new Headers(options.headers);
+    }
+    this.method = normalizeMethod(options.method || this.method || 'GET');
+    this.mode = options.mode || this.mode || null;
+    this.signal = options.signal || this.signal;
+    this.referrer = null;
+
+    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+      throw new TypeError('Body not allowed for GET or HEAD requests')
+    }
+    this._initBody(body);
+  }
+
+  Request.prototype.clone = function() {
+    return new Request(this, {body: this._bodyInit})
+  };
+
+  function decode(body) {
+    var form = new FormData();
+    body
+      .trim()
+      .split('&')
+      .forEach(function(bytes) {
+        if (bytes) {
+          var split = bytes.split('=');
+          var name = split.shift().replace(/\+/g, ' ');
+          var value = split.join('=').replace(/\+/g, ' ');
+          form.append(decodeURIComponent(name), decodeURIComponent(value));
+        }
+      });
+    return form
+  }
+
+  function parseHeaders(rawHeaders) {
+    var headers = new Headers();
+    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+    // https://tools.ietf.org/html/rfc7230#section-3.2
+    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+    preProcessedHeaders.split(/\r?\n/).forEach(function(line) {
+      var parts = line.split(':');
+      var key = parts.shift().trim();
+      if (key) {
+        var value = parts.join(':').trim();
+        headers.append(key, value);
+      }
+    });
+    return headers
+  }
+
+  Body.call(Request.prototype);
+
+  function Response(bodyInit, options) {
+    if (!options) {
+      options = {};
+    }
+
+    this.type = 'default';
+    this.status = options.status === undefined ? 200 : options.status;
+    this.ok = this.status >= 200 && this.status < 300;
+    this.statusText = 'statusText' in options ? options.statusText : 'OK';
+    this.headers = new Headers(options.headers);
+    this.url = options.url || '';
+    this._initBody(bodyInit);
+  }
+
+  Body.call(Response.prototype);
+
+  Response.prototype.clone = function() {
+    return new Response(this._bodyInit, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: new Headers(this.headers),
+      url: this.url
+    })
+  };
+
+  Response.error = function() {
+    var response = new Response(null, {status: 0, statusText: ''});
+    response.type = 'error';
+    return response
+  };
+
+  var redirectStatuses = [301, 302, 303, 307, 308];
+
+  Response.redirect = function(url, status) {
+    if (redirectStatuses.indexOf(status) === -1) {
+      throw new RangeError('Invalid status code')
+    }
+
+    return new Response(null, {status: status, headers: {location: url}})
+  };
+
+  exports.DOMException = self.DOMException;
+  try {
+    new exports.DOMException();
+  } catch (err) {
+    exports.DOMException = function(message, name) {
+      this.message = message;
+      this.name = name;
+      var error = Error(message);
+      this.stack = error.stack;
+    };
+    exports.DOMException.prototype = Object.create(Error.prototype);
+    exports.DOMException.prototype.constructor = exports.DOMException;
+  }
+
+  function fetch(input, init) {
+    return new Promise(function(resolve, reject) {
+      var request = new Request(input, init);
+
+      if (request.signal && request.signal.aborted) {
+        return reject(new exports.DOMException('Aborted', 'AbortError'))
+      }
+
+      var xhr = new XMLHttpRequest();
+
+      function abortXhr() {
+        xhr.abort();
+      }
+
+      xhr.onload = function() {
+        var options = {
+          status: xhr.status,
+          statusText: xhr.statusText,
+          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+        };
+        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+        var body = 'response' in xhr ? xhr.response : xhr.responseText;
+        resolve(new Response(body, options));
+      };
+
+      xhr.onerror = function() {
+        reject(new TypeError('Network request failed'));
+      };
+
+      xhr.ontimeout = function() {
+        reject(new TypeError('Network request failed'));
+      };
+
+      xhr.onabort = function() {
+        reject(new exports.DOMException('Aborted', 'AbortError'));
+      };
+
+      xhr.open(request.method, request.url, true);
+
+      if (request.credentials === 'include') {
+        xhr.withCredentials = true;
+      } else if (request.credentials === 'omit') {
+        xhr.withCredentials = false;
+      }
+
+      if ('responseType' in xhr && support.blob) {
+        xhr.responseType = 'blob';
+      }
+
+      request.headers.forEach(function(value, name) {
+        xhr.setRequestHeader(name, value);
+      });
+
+      if (request.signal) {
+        request.signal.addEventListener('abort', abortXhr);
+
+        xhr.onreadystatechange = function() {
+          // DONE (success or failure)
+          if (xhr.readyState === 4) {
+            request.signal.removeEventListener('abort', abortXhr);
+          }
+        };
+      }
+
+      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+    })
+  }
+
+  fetch.polyfill = true;
+
+  if (!self.fetch) {
+    self.fetch = fetch;
+    self.Headers = Headers;
+    self.Request = Request;
+    self.Response = Response;
+  }
+
+  exports.Headers = Headers;
+  exports.Request = Request;
+  exports.Response = Response;
+  exports.fetch = fetch;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+  return exports;
+
+}))({});
+})(__self__);
+__self__.fetch.ponyfill = true;
+// Remove "polyfill" property added by whatwg-fetch
+delete __self__.fetch.polyfill;
+// Choose between native implementation (global) or custom implementation (__self__)
+// var ctx = global.fetch ? global : __self__;
+var ctx = __self__; // this line disable service worker support temporarily
+exports = ctx.fetch; // To enable: import fetch from 'cross-fetch'
+exports.default = ctx.fetch; // For TypeScript consumers without esModuleInterop.
+exports.fetch = ctx.fetch; // To enable: import {fetch} from 'cross-fetch'
+exports.Headers = ctx.Headers;
+exports.Request = ctx.Request;
+exports.Response = ctx.Response;
+module.exports = exports;
+});
+
+unwrapExports(browserPonyfill);
+
+var ReactNativeFile = function ReactNativeFile(_ref) {
+  var uri = _ref.uri,
+    name = _ref.name,
+    type = _ref.type;
+  this.uri = uri;
+  this.name = name;
+  this.type = type;
+};
+
+var isExtractableFile = function isExtractableFile(value) {
+  return (
+    (typeof File !== 'undefined' && value instanceof File) ||
+    (typeof Blob !== 'undefined' && value instanceof Blob) ||
+    value instanceof ReactNativeFile
+  );
+};
+
+var extractFiles = function extractFiles(value, path, isExtractableFile$1) {
+  if (path === void 0) {
+    path = '';
+  }
+
+  if (isExtractableFile$1 === void 0) {
+    isExtractableFile$1 = isExtractableFile;
+  }
+
+  var clone;
+  var files = new Map();
+
+  function addFile(paths, file) {
+    var storedPaths = files.get(file);
+    if (storedPaths) storedPaths.push.apply(storedPaths, paths);
+    else files.set(file, paths);
+  }
+
+  if (isExtractableFile$1(value)) {
+    clone = null;
+    addFile([path], value);
+  } else {
+    var prefix = path ? path + '.' : '';
+    if (typeof FileList !== 'undefined' && value instanceof FileList)
+      clone = Array.prototype.map.call(value, function (file, i) {
+        addFile(['' + prefix + i], file);
+        return null;
+      });
+    else if (Array.isArray(value))
+      clone = value.map(function (child, i) {
+        var result = extractFiles(child, '' + prefix + i, isExtractableFile$1);
+        result.files.forEach(addFile);
+        return result.clone;
+      });
+    else if (value && value.constructor === Object) {
+      clone = {};
+
+      for (var i in value) {
+        var result = extractFiles(value[i], '' + prefix + i, isExtractableFile$1);
+        result.files.forEach(addFile);
+        clone[i] = result.clone;
+      }
+    } else clone = value;
+  }
+
+  return {
+    clone: clone,
+    files: files,
+  };
+};
+
+
+
+var _public = {
+  __proto__: null,
+  ReactNativeFile: ReactNativeFile,
+  extractFiles: extractFiles,
+  isExtractableFile: isExtractableFile
+};
+
+/* eslint-env browser */
+var browser$1 = typeof self == 'object' ? self.FormData : window.FormData;
+
+var defaultJsonSerializer = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultJsonSerializer = void 0;
+exports.defaultJsonSerializer = {
+    parse: JSON.parse,
+    stringify: JSON.stringify
+};
+
+});
+
+unwrapExports(defaultJsonSerializer);
+
+var extract_files_1 = getCjsExportFromNamespace(_public);
+
+var createRequestBody_1 = createCommonjsModule(function (module, exports) {
+var __importDefault = (commonjsGlobal$1 && commonjsGlobal$1.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+
+var form_data_1 = __importDefault(browser$1);
+
+/**
+ * Duck type if NodeJS stream
+ * https://github.com/sindresorhus/is-stream/blob/3750505b0727f6df54324784fe369365ef78841e/index.js#L3
+ */
+var isExtractableFileEnhanced = function (value) {
+    return extract_files_1.isExtractableFile(value) ||
+        (value !== null && typeof value === 'object' && typeof value.pipe === 'function');
+};
+/**
+ * Returns Multipart Form if body contains files
+ * (https://github.com/jaydenseric/graphql-multipart-request-spec)
+ * Otherwise returns JSON
+ */
+function createRequestBody(query, variables, operationName, jsonSerializer) {
+    if (jsonSerializer === void 0) { jsonSerializer = defaultJsonSerializer.defaultJsonSerializer; }
+    var _a = extract_files_1.extractFiles({ query: query, variables: variables, operationName: operationName }, '', isExtractableFileEnhanced), clone = _a.clone, files = _a.files;
+    if (files.size === 0) {
+        if (!Array.isArray(query)) {
+            return jsonSerializer.stringify(clone);
+        }
+        if (typeof variables !== 'undefined' && !Array.isArray(variables)) {
+            throw new Error('Cannot create request body with given variable type, array expected');
+        }
+        // Batch support
+        var payload = query.reduce(function (accu, currentQuery, index) {
+            accu.push({ query: currentQuery, variables: variables ? variables[index] : undefined });
+            return accu;
+        }, []);
+        return jsonSerializer.stringify(payload);
+    }
+    var Form = typeof FormData === 'undefined' ? form_data_1.default : FormData;
+    var form = new Form();
+    form.append('operations', jsonSerializer.stringify(clone));
+    var map = {};
+    var i = 0;
+    files.forEach(function (paths) {
+        map[++i] = paths;
+    });
+    form.append('map', jsonSerializer.stringify(map));
+    i = 0;
+    files.forEach(function (paths, file) {
+        form.append("" + ++i, file);
+    });
+    return form;
+}
+exports.default = createRequestBody;
+
+});
+
+unwrapExports(createRequestBody_1);
+
+var parseArgs = createCommonjsModule(function (module, exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBatchRequestsExtendedArgs = exports.parseRawRequestExtendedArgs = exports.parseRequestExtendedArgs = exports.parseBatchRequestArgs = exports.parseRawRequestArgs = exports.parseRequestArgs = void 0;
+function parseRequestArgs(documentOrOptions, variables, requestHeaders) {
+    return documentOrOptions.document
+        ? documentOrOptions
+        : {
+            document: documentOrOptions,
+            variables: variables,
+            requestHeaders: requestHeaders,
+            signal: undefined,
+        };
+}
+exports.parseRequestArgs = parseRequestArgs;
+function parseRawRequestArgs(queryOrOptions, variables, requestHeaders) {
+    return queryOrOptions.query
+        ? queryOrOptions
+        : {
+            query: queryOrOptions,
+            variables: variables,
+            requestHeaders: requestHeaders,
+            signal: undefined,
+        };
+}
+exports.parseRawRequestArgs = parseRawRequestArgs;
+function parseBatchRequestArgs(documentsOrOptions, requestHeaders) {
+    return documentsOrOptions.documents
+        ? documentsOrOptions
+        : {
+            documents: documentsOrOptions,
+            requestHeaders: requestHeaders,
+            signal: undefined,
+        };
+}
+exports.parseBatchRequestArgs = parseBatchRequestArgs;
+function parseRequestExtendedArgs(urlOrOptions, document, variables, requestHeaders) {
+    return urlOrOptions.document
+        ? urlOrOptions
+        : {
+            url: urlOrOptions,
+            document: document,
+            variables: variables,
+            requestHeaders: requestHeaders,
+            signal: undefined,
+        };
+}
+exports.parseRequestExtendedArgs = parseRequestExtendedArgs;
+function parseRawRequestExtendedArgs(urlOrOptions, query, variables, requestHeaders) {
+    return urlOrOptions.query
+        ? urlOrOptions
+        : {
+            url: urlOrOptions,
+            query: query,
+            variables: variables,
+            requestHeaders: requestHeaders,
+            signal: undefined,
+        };
+}
+exports.parseRawRequestExtendedArgs = parseRawRequestExtendedArgs;
+function parseBatchRequestsExtendedArgs(urlOrOptions, documents, requestHeaders) {
+    return urlOrOptions.documents
+        ? urlOrOptions
+        : {
+            url: urlOrOptions,
+            documents: documents,
+            requestHeaders: requestHeaders,
+            signal: undefined,
+        };
+}
+exports.parseBatchRequestsExtendedArgs = parseBatchRequestsExtendedArgs;
+
+});
+
+unwrapExports(parseArgs);
+
+var types = createCommonjsModule(function (module, exports) {
+var __extends = (commonjsGlobal$1 && commonjsGlobal$1.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientError = void 0;
+var ClientError = /** @class */ (function (_super) {
+    __extends(ClientError, _super);
+    function ClientError(response, request) {
+        var _this = this;
+        var message = ClientError.extractMessage(response) + ": " + JSON.stringify({
+            response: response,
+            request: request,
+        });
+        _this = _super.call(this, message) || this;
+        Object.setPrototypeOf(_this, ClientError.prototype);
+        _this.response = response;
+        _this.request = request;
+        // this is needed as Safari doesn't support .captureStackTrace
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(_this, ClientError);
+        }
+        return _this;
+    }
+    ClientError.extractMessage = function (response) {
+        try {
+            return response.errors[0].message;
+        }
+        catch (e) {
+            return "GraphQL Error (Code: " + response.status + ")";
+        }
+    };
+    return ClientError;
+}(Error));
+exports.ClientError = ClientError;
+
+});
+
+unwrapExports(types);
+
+var graphqlWs = createCommonjsModule(function (module, exports) {
+var __assign = (commonjsGlobal$1 && commonjsGlobal$1.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (commonjsGlobal$1 && commonjsGlobal$1.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (commonjsGlobal$1 && commonjsGlobal$1.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLWebSocketClient = void 0;
+
+
+var CONNECTION_INIT = 'connection_init';
+var CONNECTION_ACK = 'connection_ack';
+var PING = 'ping';
+var PONG = 'pong';
+var SUBSCRIBE = 'subscribe';
+var NEXT = 'next';
+var ERROR = 'error';
+var COMPLETE = 'complete';
+var GraphQLWebSocketMessage = /** @class */ (function () {
+    function GraphQLWebSocketMessage(type, payload, id) {
+        this._type = type;
+        this._payload = payload;
+        this._id = id;
+    }
+    Object.defineProperty(GraphQLWebSocketMessage.prototype, "type", {
+        get: function () { return this._type; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphQLWebSocketMessage.prototype, "id", {
+        get: function () { return this._id; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphQLWebSocketMessage.prototype, "payload", {
+        get: function () { return this._payload; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphQLWebSocketMessage.prototype, "text", {
+        get: function () {
+            var result = { type: this.type };
+            if (this.id != null && this.id != undefined)
+                result.id = this.id;
+            if (this.payload != null && this.payload != undefined)
+                result.payload = this.payload;
+            return JSON.stringify(result);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GraphQLWebSocketMessage.parse = function (data, f) {
+        var _a = JSON.parse(data), type = _a.type, payload = _a.payload, id = _a.id;
+        return new GraphQLWebSocketMessage(type, f(payload), id);
+    };
+    return GraphQLWebSocketMessage;
+}());
+var GraphQLWebSocketClient = /** @class */ (function () {
+    function GraphQLWebSocketClient(socket, _a) {
+        var _this = this;
+        var onInit = _a.onInit, onAcknowledged = _a.onAcknowledged, onPing = _a.onPing, onPong = _a.onPong;
+        this.socketState = { acknowledged: false, lastRequestId: 0, subscriptions: {} };
+        this.socket = socket;
+        socket.onopen = function (e) { return __awaiter(_this, void 0, void 0, function () {
+            var _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        this.socketState.acknowledged = false;
+                        this.socketState.subscriptions = {};
+                        _b = (_a = socket).send;
+                        _c = ConnectionInit;
+                        if (!onInit) return [3 /*break*/, 2];
+                        return [4 /*yield*/, onInit()];
+                    case 1:
+                        _d = _e.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _d = null;
+                        _e.label = 3;
+                    case 3:
+                        _b.apply(_a, [_c.apply(void 0, [_d]).text]);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        socket.onclose = function (e) {
+            _this.socketState.acknowledged = false;
+            _this.socketState.subscriptions = {};
+        };
+        socket.onerror = function (e) {
+            console.error(e);
+        };
+        socket.onmessage = function (e) {
+            try {
+                var message = parseMessage(e.data);
+                switch (message.type) {
+                    case CONNECTION_ACK: {
+                        if (_this.socketState.acknowledged) {
+                            console.warn("Duplicate CONNECTION_ACK message ignored");
+                        }
+                        else {
+                            _this.socketState.acknowledged = true;
+                            if (onAcknowledged)
+                                onAcknowledged(message.payload);
+                        }
+                        return;
+                    }
+                    case PING: {
+                        if (onPing)
+                            onPing(message.payload).then(function (r) { return socket.send(Pong(r).text); });
+                        else
+                            socket.send(Pong(null).text);
+                        return;
+                    }
+                    case PONG: {
+                        if (onPong)
+                            onPong(message.payload);
+                        return;
+                    }
+                }
+                if (!_this.socketState.acknowledged) {
+                    // Web-socket connection not acknowledged
+                    return;
+                }
+                if (message.id === undefined || message.id === null || !_this.socketState.subscriptions[message.id]) {
+                    // No subscription identifer or subscription indentifier is not found
+                    return;
+                }
+                var _a = _this.socketState.subscriptions[message.id], query = _a.query, variables = _a.variables, subscriber = _a.subscriber;
+                switch (message.type) {
+                    case NEXT: {
+                        if (!message.payload.errors && message.payload.data) {
+                            subscriber.next && subscriber.next(message.payload.data);
+                        }
+                        if (message.payload.errors) {
+                            subscriber.error && subscriber.error(new types.ClientError(__assign(__assign({}, message.payload), { status: 200 }), { query: query, variables: variables }));
+                        }
+                        else {
+                        }
+                        return;
+                    }
+                    case ERROR: {
+                        subscriber.error && subscriber.error(new types.ClientError({ errors: message.payload, status: 200 }, { query: query, variables: variables }));
+                        return;
+                    }
+                    case COMPLETE: {
+                        subscriber.complete && subscriber.complete();
+                        delete _this.socketState.subscriptions[message.id];
+                        return;
+                    }
+                }
+            }
+            catch (e) {
+                // Unexpected errors while handling graphql-ws message
+                console.error(e);
+                socket.close(1006);
+            }
+            socket.close(4400, "Unknown graphql-ws message.");
+        };
+    }
+    GraphQLWebSocketClient.prototype.makeSubscribe = function (query, operationName, variables, subscriber) {
+        var _this = this;
+        var subscriptionId = (this.socketState.lastRequestId++).toString();
+        this.socketState.subscriptions[subscriptionId] = { query: query, variables: variables, subscriber: subscriber };
+        this.socket.send(Subscribe(subscriptionId, { query: query, operationName: operationName, variables: variables }).text);
+        return function () {
+            _this.socket.send(Complete(subscriptionId).text);
+            delete _this.socketState.subscriptions[subscriptionId];
+        };
+    };
+    GraphQLWebSocketClient.prototype.rawRequest = function (query, variables) {
         var _this = this;
-        promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor(function (resolve, reject) {
-            var value;
-            _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });
+        return new Promise(function (resolve, reject) {
+            var result;
+            _this.rawSubscribe(query, {
+                next: function (data, extensions) { return (result = { data: data, extensions: extensions }); },
+                error: reject,
+                complete: function () { return resolve(result); },
+            }, variables);
         });
     };
-    Observable.create = function (subscribe) {
-        return new Observable(subscribe);
+    GraphQLWebSocketClient.prototype.request = function (document, variables) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var result;
+            _this.subscribe(document, {
+                next: function (data) { return (result = data); },
+                error: reject,
+                complete: function () { return resolve(result); },
+            }, variables);
+        });
     };
-    return Observable;
+    GraphQLWebSocketClient.prototype.subscribe = function (document, subscriber, variables) {
+        var _a = dist.resolveRequestDocument(document), query = _a.query, operationName = _a.operationName;
+        return this.makeSubscribe(query, operationName, variables, subscriber);
+    };
+    GraphQLWebSocketClient.prototype.rawSubscribe = function (query, subscriber, variables) {
+        return this.makeSubscribe(query, undefined, variables, subscriber);
+    };
+    GraphQLWebSocketClient.prototype.ping = function (payload) {
+        this.socket.send(Ping(payload).text);
+    };
+    GraphQLWebSocketClient.prototype.close = function () {
+        this.socket.close(1000);
+    };
+    GraphQLWebSocketClient.PROTOCOL = "graphql-transport-ws";
+    return GraphQLWebSocketClient;
 }());
-function getPromiseCtor(promiseCtor) {
-    if (!promiseCtor) {
-        promiseCtor =  Promise;
-    }
-    if (!promiseCtor) {
-        throw new Error('no Promise impl found');
-    }
-    return promiseCtor;
+exports.GraphQLWebSocketClient = GraphQLWebSocketClient;
+// Helper functions
+function parseMessage(data, f) {
+    if (f === void 0) { f = function (a) { return a; }; }
+    var m = GraphQLWebSocketMessage.parse(data, f);
+    return m;
+}
+function ConnectionInit(payload) {
+    return new GraphQLWebSocketMessage(CONNECTION_INIT, payload);
+}
+function Ping(payload) {
+    return new GraphQLWebSocketMessage(PING, payload, undefined);
+}
+function Pong(payload) {
+    return new GraphQLWebSocketMessage(PONG, payload, undefined);
+}
+function Subscribe(id, payload) {
+    return new GraphQLWebSocketMessage(SUBSCRIBE, payload, id);
+}
+function Complete(id) {
+    return new GraphQLWebSocketMessage(COMPLETE, undefined, id);
 }
 
-var ActionCableClient = /*#__PURE__*/function () {
-  function ActionCableClient(url) {
-    var _this = this;
+});
 
-    this.cable = null;
-    this.subscriptions = new Map();
+unwrapExports(graphqlWs);
 
-    this.addSubscription = function (id, subscription) {
-      _this.subscriptions.set(id, subscription);
-    };
+var parser_1 = getCjsExportFromNamespace(parser);
 
-    this.wsURL = url;
-  }
+var printer_1 = getCjsExportFromNamespace(printer);
 
-  var _proto = ActionCableClient.prototype;
+var dist = createCommonjsModule(function (module, exports) {
+var __assign = (commonjsGlobal$1 && commonjsGlobal$1.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (commonjsGlobal$1 && commonjsGlobal$1.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (commonjsGlobal$1 && commonjsGlobal$1.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (commonjsGlobal$1 && commonjsGlobal$1.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (commonjsGlobal$1 && commonjsGlobal$1.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (commonjsGlobal$1 && commonjsGlobal$1.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (commonjsGlobal$1 && commonjsGlobal$1.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (commonjsGlobal$1 && commonjsGlobal$1.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLWebSocketClient = exports.gql = exports.resolveRequestDocument = exports.batchRequests = exports.request = exports.rawRequest = exports.GraphQLClient = exports.ClientError = void 0;
+var cross_fetch_1 = __importStar(browserPonyfill), CrossFetch = cross_fetch_1;
 
-  _proto.connect = function connect(token, lang) {
-    this.cable = action_cable.createConsumer(this.wsURL + "?token=" + token + "&lang=" + lang);
-  };
 
-  _proto.request = function request(_request) {
-    var cable = this.cable,
-        subscriptions = this.subscriptions,
-        addSubscription = this.addSubscription;
-    var subscription;
-    return new Observable(function (observer) {
-      if (cable) {
-        var _request$variables;
+var createRequestBody_1$1 = __importDefault(createRequestBody_1);
 
-        var subscriptionId = ((_request$variables = _request.variables) === null || _request$variables === void 0 ? void 0 : _request$variables.id) || 'company';
 
-        if (!subscriptions.has(subscriptionId)) {
-          subscription = cable.subscriptions.create({
-            channel: 'GraphqlChannel',
-            channelId: Math.round(Date.now() + Math.random() * 100000).toString(16)
-          }, {
-            connected: function connected() {
-              this.perform('execute', _request);
-            },
-            received: function received(payload) {
-              if (!payload.more) {
-                if (observer.complete) {
-                  observer.complete();
+
+Object.defineProperty(exports, "ClientError", { enumerable: true, get: function () { return types.ClientError; } });
+/**
+ * Convert the given headers configuration into a plain object.
+ */
+var resolveHeaders = function (headers) {
+    var oHeaders = {};
+    if (headers) {
+        if ((typeof Headers !== 'undefined' && headers instanceof Headers) ||
+            headers instanceof CrossFetch.Headers) {
+            oHeaders = HeadersInstanceToPlainObject(headers);
+        }
+        else if (Array.isArray(headers)) {
+            headers.forEach(function (_a) {
+                var name = _a[0], value = _a[1];
+                oHeaders[name] = value;
+            });
+        }
+        else {
+            oHeaders = headers;
+        }
+    }
+    return oHeaders;
+};
+/**
+ * Clean a GraphQL document to send it via a GET query
+ *
+ * @param {string} str GraphQL query
+ * @returns {string} Cleaned query
+ */
+var queryCleanner = function (str) { return str.replace(/([\s,]|#[^\n\r]+)+/g, ' ').trim(); };
+/**
+ * Create query string for GraphQL request
+ *
+ * @param {object} param0 -
+ *
+ * @param {string|string[]} param0.query the GraphQL document or array of document if it's a batch request
+ * @param {string|undefined} param0.operationName the GraphQL operation name
+ * @param {any|any[]} param0.variables the GraphQL variables to use
+ */
+var buildGetQueryParams = function (_a) {
+    var query = _a.query, variables = _a.variables, operationName = _a.operationName, jsonSerializer = _a.jsonSerializer;
+    if (!Array.isArray(query)) {
+        var search = ["query=" + encodeURIComponent(queryCleanner(query))];
+        if (variables) {
+            search.push("variables=" + encodeURIComponent(jsonSerializer.stringify(variables)));
+        }
+        if (operationName) {
+            search.push("operationName=" + encodeURIComponent(operationName));
+        }
+        return search.join('&');
+    }
+    if (typeof variables !== 'undefined' && !Array.isArray(variables)) {
+        throw new Error('Cannot create query with given variable type, array expected');
+    }
+    // Batch support
+    var payload = query.reduce(function (accu, currentQuery, index) {
+        accu.push({
+            query: queryCleanner(currentQuery),
+            variables: variables ? jsonSerializer.stringify(variables[index]) : undefined,
+        });
+        return accu;
+    }, []);
+    return "query=" + encodeURIComponent(jsonSerializer.stringify(payload));
+};
+/**
+ * Fetch data using POST method
+ */
+var post = function (_a) {
+    var url = _a.url, query = _a.query, variables = _a.variables, operationName = _a.operationName, headers = _a.headers, fetch = _a.fetch, fetchOptions = _a.fetchOptions;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var body;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    body = createRequestBody_1$1.default(query, variables, operationName, fetchOptions.jsonSerializer);
+                    return [4 /*yield*/, fetch(url, __assign({ method: 'POST', headers: __assign(__assign({}, (typeof body === 'string' ? { 'Content-Type': 'application/json' } : {})), headers), body: body }, fetchOptions))];
+                case 1: return [2 /*return*/, _b.sent()];
+            }
+        });
+    });
+};
+/**
+ * Fetch data using GET method
+ */
+var get = function (_a) {
+    var url = _a.url, query = _a.query, variables = _a.variables, operationName = _a.operationName, headers = _a.headers, fetch = _a.fetch, fetchOptions = _a.fetchOptions;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var queryParams;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    queryParams = buildGetQueryParams({
+                        query: query,
+                        variables: variables,
+                        operationName: operationName,
+                        jsonSerializer: fetchOptions.jsonSerializer
+                    });
+                    return [4 /*yield*/, fetch(url + "?" + queryParams, __assign({ method: 'GET', headers: headers }, fetchOptions))];
+                case 1: return [2 /*return*/, _b.sent()];
+            }
+        });
+    });
+};
+/**
+ * GraphQL Client.
+ */
+var GraphQLClient = /** @class */ (function () {
+    function GraphQLClient(url, options) {
+        this.url = url;
+        this.options = options || {};
+    }
+    GraphQLClient.prototype.rawRequest = function (queryOrOptions, variables, requestHeaders) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rawRequestOptions, _a, headers, _b, fetch, _c, method, fetchOptions, url, operationName;
+            return __generator(this, function (_d) {
+                rawRequestOptions = parseArgs.parseRawRequestArgs(queryOrOptions, variables, requestHeaders);
+                _a = this.options, headers = _a.headers, _b = _a.fetch, fetch = _b === void 0 ? cross_fetch_1.default : _b, _c = _a.method, method = _c === void 0 ? 'POST' : _c, fetchOptions = __rest(_a, ["headers", "fetch", "method"]);
+                url = this.url;
+                if (rawRequestOptions.signal !== undefined) {
+                    fetchOptions.signal = rawRequestOptions.signal;
                 }
-              } else if (payload.result.errors) {
-                if (observer.error) {
-                  observer.error(payload.result.errors[0]);
+                operationName = resolveRequestDocument(rawRequestOptions.query).operationName;
+                return [2 /*return*/, makeRequest({
+                        url: url,
+                        query: rawRequestOptions.query,
+                        variables: rawRequestOptions.variables,
+                        headers: __assign(__assign({}, resolveHeaders(callOrIdentity(headers))), resolveHeaders(rawRequestOptions.requestHeaders)),
+                        operationName: operationName,
+                        fetch: fetch,
+                        method: method,
+                        fetchOptions: fetchOptions,
+                    })];
+            });
+        });
+    };
+    GraphQLClient.prototype.request = function (documentOrOptions, variables, requestHeaders) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, _a, headers, _b, fetch, _c, method, fetchOptions, url, _d, query, operationName, data;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        requestOptions = parseArgs.parseRequestArgs(documentOrOptions, variables, requestHeaders);
+                        _a = this.options, headers = _a.headers, _b = _a.fetch, fetch = _b === void 0 ? cross_fetch_1.default : _b, _c = _a.method, method = _c === void 0 ? 'POST' : _c, fetchOptions = __rest(_a, ["headers", "fetch", "method"]);
+                        url = this.url;
+                        if (requestOptions.signal !== undefined) {
+                            fetchOptions.signal = requestOptions.signal;
+                        }
+                        _d = resolveRequestDocument(requestOptions.document), query = _d.query, operationName = _d.operationName;
+                        return [4 /*yield*/, makeRequest({
+                                url: url,
+                                query: query,
+                                variables: requestOptions.variables,
+                                headers: __assign(__assign({}, resolveHeaders(callOrIdentity(headers))), resolveHeaders(requestOptions.requestHeaders)),
+                                operationName: operationName,
+                                fetch: fetch,
+                                method: method,
+                                fetchOptions: fetchOptions,
+                            })];
+                    case 1:
+                        data = (_e.sent()).data;
+                        return [2 /*return*/, data];
                 }
-              } else if (payload.result.data) {
-                if (observer.next) {
-                  if (!lodash_isempty(payload.result.data)) {
-                    observer.next(payload.result);
-                  }
+            });
+        });
+    };
+    GraphQLClient.prototype.batchRequests = function (documentsOrOptions, requestHeaders) {
+        return __awaiter(this, void 0, void 0, function () {
+            var batchRequestOptions, _a, headers, _b, fetch, _c, method, fetchOptions, url, queries, variables, data;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        batchRequestOptions = parseArgs.parseBatchRequestArgs(documentsOrOptions, requestHeaders);
+                        _a = this.options, headers = _a.headers, _b = _a.fetch, fetch = _b === void 0 ? cross_fetch_1.default : _b, _c = _a.method, method = _c === void 0 ? 'POST' : _c, fetchOptions = __rest(_a, ["headers", "fetch", "method"]);
+                        url = this.url;
+                        if (batchRequestOptions.signal !== undefined) {
+                            fetchOptions.signal = batchRequestOptions.signal;
+                        }
+                        queries = batchRequestOptions.documents.map(function (_a) {
+                            var document = _a.document;
+                            return resolveRequestDocument(document).query;
+                        });
+                        variables = batchRequestOptions.documents.map(function (_a) {
+                            var variables = _a.variables;
+                            return variables;
+                        });
+                        return [4 /*yield*/, makeRequest({
+                                url: url,
+                                query: queries,
+                                variables: variables,
+                                headers: __assign(__assign({}, resolveHeaders(callOrIdentity(headers))), resolveHeaders(batchRequestOptions.requestHeaders)),
+                                operationName: undefined,
+                                fetch: fetch,
+                                method: method,
+                                fetchOptions: fetchOptions,
+                            })];
+                    case 1:
+                        data = (_d.sent()).data;
+                        return [2 /*return*/, data];
                 }
-              }
-            }
-          });
-          addSubscription(subscriptionId, subscription);
+            });
+        });
+    };
+    GraphQLClient.prototype.setHeaders = function (headers) {
+        this.options.headers = headers;
+        return this;
+    };
+    /**
+     * Attach a header to the client. All subsequent requests will have this header.
+     */
+    GraphQLClient.prototype.setHeader = function (key, value) {
+        var _a;
+        var headers = this.options.headers;
+        if (headers) {
+            // todo what if headers is in nested array form... ?
+            //@ts-ignore
+            headers[key] = value;
         }
-      }
+        else {
+            this.options.headers = (_a = {}, _a[key] = value, _a);
+        }
+        return this;
+    };
+    /**
+     * Change the client endpoint. All subsequent requests will send to this endpoint.
+     */
+    GraphQLClient.prototype.setEndpoint = function (value) {
+        this.url = value;
+        return this;
+    };
+    return GraphQLClient;
+}());
+exports.GraphQLClient = GraphQLClient;
+function makeRequest(_a) {
+    var url = _a.url, query = _a.query, variables = _a.variables, headers = _a.headers, operationName = _a.operationName, fetch = _a.fetch, _b = _a.method, method = _b === void 0 ? 'POST' : _b, fetchOptions = _a.fetchOptions;
+    return __awaiter(this, void 0, void 0, function () {
+        var fetcher, isBathchingQuery, response, result, successfullyReceivedData, successfullyPassedErrorPolicy, headers_1, status_1, rest, data, errorResult;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    fetcher = method.toUpperCase() === 'POST' ? post : get;
+                    isBathchingQuery = Array.isArray(query);
+                    return [4 /*yield*/, fetcher({
+                            url: url,
+                            query: query,
+                            variables: variables,
+                            operationName: operationName,
+                            headers: headers,
+                            fetch: fetch,
+                            fetchOptions: fetchOptions,
+                        })];
+                case 1:
+                    response = _c.sent();
+                    return [4 /*yield*/, getResult(response, fetchOptions.jsonSerializer)];
+                case 2:
+                    result = _c.sent();
+                    successfullyReceivedData = isBathchingQuery && Array.isArray(result) ? !result.some(function (_a) {
+                        var data = _a.data;
+                        return !data;
+                    }) : !!result.data;
+                    successfullyPassedErrorPolicy = !result.errors || fetchOptions.errorPolicy === 'all' || fetchOptions.errorPolicy === 'ignore';
+                    if (response.ok && successfullyPassedErrorPolicy && successfullyReceivedData) {
+                        headers_1 = response.headers, status_1 = response.status;
+                        rest = __rest(result, ["errors"]);
+                        data = fetchOptions.errorPolicy === 'ignore' ? rest : result;
+                        return [2 /*return*/, __assign(__assign({}, (isBathchingQuery ? { data: data } : data)), { headers: headers_1, status: status_1 })];
+                    }
+                    else {
+                        errorResult = typeof result === 'string' ? { error: result } : result;
+                        throw new types.ClientError(__assign(__assign({}, errorResult), { status: response.status, headers: response.headers }), { query: query, variables: variables });
+                    }
+            }
+        });
     });
-  };
-
-  _proto.hasSubscription = function hasSubscription(id) {
-    return this.subscriptions.has(id);
-  };
-
-  return ActionCableClient;
-}();
-
-var GraphqlWsClient = /*#__PURE__*/function () {
-  function GraphqlWsClient(url, token, lang) {
-    this.actionCableClient = null;
-    this.actionCableClient = new ActionCableClient(url);
-    this.actionCableClient.connect(token, lang);
-  }
-
-  var _proto = GraphqlWsClient.prototype;
-
-  _proto.subscribe = function subscribe(query, variables, onData, onError) {
-    if (onError === void 0) {
-      onError = function onError(error) {
-        throw error;
-      };
+}
+function rawRequest(urlOrOptions, query, variables, requestHeaders) {
+    return __awaiter(this, void 0, void 0, function () {
+        var requestOptions, client;
+        return __generator(this, function (_a) {
+            requestOptions = parseArgs.parseRawRequestExtendedArgs(urlOrOptions, query, variables, requestHeaders);
+            client = new GraphQLClient(requestOptions.url);
+            return [2 /*return*/, client.rawRequest(__assign({}, requestOptions))];
+        });
+    });
+}
+exports.rawRequest = rawRequest;
+function request(urlOrOptions, document, variables, requestHeaders) {
+    return __awaiter(this, void 0, void 0, function () {
+        var requestOptions, client;
+        return __generator(this, function (_a) {
+            requestOptions = parseArgs.parseRequestExtendedArgs(urlOrOptions, document, variables, requestHeaders);
+            client = new GraphQLClient(requestOptions.url);
+            return [2 /*return*/, client.request(__assign({}, requestOptions))];
+        });
+    });
+}
+exports.request = request;
+function batchRequests(urlOrOptions, documents, requestHeaders) {
+    return __awaiter(this, void 0, void 0, function () {
+        var requestOptions, client;
+        return __generator(this, function (_a) {
+            requestOptions = parseArgs.parseBatchRequestsExtendedArgs(urlOrOptions, documents, requestHeaders);
+            client = new GraphQLClient(requestOptions.url);
+            return [2 /*return*/, client.batchRequests(__assign({}, requestOptions))];
+        });
+    });
+}
+exports.batchRequests = batchRequests;
+exports.default = request;
+/**
+ * todo
+ */
+function getResult(response, jsonSerializer) {
+    if (jsonSerializer === void 0) { jsonSerializer = defaultJsonSerializer.defaultJsonSerializer; }
+    return __awaiter(this, void 0, void 0, function () {
+        var contentType, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    response.headers.forEach(function (value, key) {
+                        if (key.toLowerCase() === 'content-type') {
+                            contentType = value;
+                        }
+                    });
+                    if (!(contentType && contentType.toLowerCase().startsWith('application/json'))) return [3 /*break*/, 2];
+                    _b = (_a = jsonSerializer).parse;
+                    return [4 /*yield*/, response.text()];
+                case 1: return [2 /*return*/, _b.apply(_a, [_c.sent()])];
+                case 2: return [2 /*return*/, response.text()];
+            }
+        });
+    });
+}
+/**
+ * helpers
+ */
+function extractOperationName(document) {
+    var _a;
+    var operationName = undefined;
+    var operationDefinitions = document.definitions.filter(function (definition) { return definition.kind === 'OperationDefinition'; });
+    if (operationDefinitions.length === 1) {
+        operationName = (_a = operationDefinitions[0].name) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    return operationName;
+}
+function resolveRequestDocument(document) {
+    if (typeof document === 'string') {
+        var operationName_1 = undefined;
+        try {
+            var parsedDocument = parser_1.parse(document);
+            operationName_1 = extractOperationName(parsedDocument);
+        }
+        catch (err) {
+            // Failed parsing the document, the operationName will be undefined
+        }
+        return { query: document, operationName: operationName_1 };
     }
+    var operationName = extractOperationName(document);
+    return { query: printer_1.print(document), operationName: operationName };
+}
+exports.resolveRequestDocument = resolveRequestDocument;
+function callOrIdentity(value) {
+    return typeof value === 'function' ? value() : value;
+}
+/**
+ * Convenience passthrough template tag to get the benefits of tooling for the gql template tag. This does not actually parse the input into a GraphQL DocumentNode like graphql-tag package does. It just returns the string with any variables given interpolated. Can save you a bit of performance and having to install another package.
+ *
+ * @example
+ *
+ * import { gql } from 'graphql-request'
+ *
+ * await request('https://foo.bar/graphql', gql`...`)
+ *
+ * @remarks
+ *
+ * Several tools in the Node GraphQL ecosystem are hardcoded to specially treat any template tag named "gql". For example see this prettier issue: https://github.com/prettier/prettier/issues/4360. Using this template tag has no runtime effect beyond variable interpolation.
+ */
+function gql(chunks) {
+    var variables = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        variables[_i - 1] = arguments[_i];
+    }
+    return chunks.reduce(function (accumulator, chunk, index) { return "" + accumulator + chunk + (index in variables ? variables[index] : ''); }, '');
+}
+exports.gql = gql;
+/**
+ * Convert Headers instance into regular object
+ */
+function HeadersInstanceToPlainObject(headers) {
+    var o = {};
+    headers.forEach(function (v, k) {
+        o[k] = v;
+    });
+    return o;
+}
 
-    var getFirstValue = function getFirstValue(data) {
-      var keys = Object.keys(data);
-      if (keys.length !== 1) throw new Error("Expected exactly one response key, got: " + keys.join(', '));
-      return data[keys[0]];
-    };
-
-    if (!this.actionCableClient) throw new Error('No WS client available');
-    var subscription = this.actionCableClient.request({
-      query: query,
-      variables: variables
-    }).subscribe({
-      next: function next(_ref) {
-        var data = _ref.data,
-            errors = _ref.errors;
-
-        if (errors) {
-          return onError(new Error(JSON.stringify(errors)));
-        }
+Object.defineProperty(exports, "GraphQLWebSocketClient", { enumerable: true, get: function () { return graphqlWs.GraphQLWebSocketClient; } });
 
-        if (data && onData) onData(getFirstValue(data));
-      }
-    });
-    return function () {
-      return subscription.unsubscribe();
-    };
-  };
+});
 
-  return GraphqlWsClient;
-}();
+unwrapExports(dist);
+var dist_7 = dist.GraphQLClient;
 
-var getGqlWsClient = function getGqlWsClient(url, token, lang) {
-  return new GraphqlWsClient(url, token, lang);
+var getGraphqlSdk = function getGraphqlSdk(url, token) {
+  var graphqlClient = new dist_7(url);
+  graphqlClient.setHeader('Authorization', "Bearer " + token);
+  return getSdk(graphqlClient);
 };
 
 var moment = createCommonjsModule(function (module, exports) {
@@ -18459,7 +21379,7 @@ var moment = createCommonjsModule(function (module, exports) {
     function preprocessRFC2822(s) {
         // Remove comments and folding whitespace and replace multiple-spaces with a single space
         return s
-            .replace(/\([^)]*\)|[\n\t]/g, ' ')
+            .replace(/\([^()]*\)|[\n\t]/g, ' ')
             .replace(/(\s\s+)/g, ' ')
             .replace(/^\s\s*/, '')
             .replace(/\s\s*$/, '');
@@ -21640,7 +24560,7 @@ var moment = createCommonjsModule(function (module, exports) {
 
     //! moment.js
 
-    hooks.version = '2.29.3';
+    hooks.version = '2.29.4';
 
     setHookCallback(createLocal);
 
@@ -21743,6 +24663,7 @@ var getRecentShift = function getRecentShift(date, shifts) {
 };
 
 exports.CompanyConfigDocument = CompanyConfigDocument;
+exports.ConfirmTooltip = ConfirmTooltip;
 exports.CounterDirectoriesDocument = CounterDirectoriesDocument;
 exports.CountersDocument = CountersDocument;
 exports.CreateDashboardDocument = CreateDashboardDocument;
@@ -21778,12 +24699,13 @@ exports.UpdateOrderExecutionDocument = UpdateOrderExecutionDocument;
 exports.UpdateWidgetDocument = UpdateWidgetDocument;
 exports.UsersDocument = UsersDocument;
 exports.UsersPresencesDocument = UsersPresencesDocument;
+exports.WidgetCard = WidgetCard;
 exports.WidgetDocument = WidgetDocument;
-exports.WidgetSettingsButton = WidgetSettingsButton;
 exports.WorkplaceEventDocument = WorkplaceEventDocument;
 exports.WorkplacesDocument = WorkplacesDocument;
 exports.getCurrentShift = getCurrentShift;
 exports.getGqlWsClient = getGqlWsClient;
+exports.getGraphqlSdk = getGraphqlSdk;
 exports.getRecentShift = getRecentShift;
 exports.getSdk = getSdk;
 exports.normalizeShifts = normalizeShifts;
@@ -23014,6 +25936,7 @@ var GRAPHQL_API_URL = process.env.REACT_APP_WIDGET_GRAPHQL_API_URL;
 var Dashboard = function Dashboard(_ref) {
   var lang = _ref.lang,
       widgetName = _ref.widgetName,
+      widgetDisplayName = _ref.widgetDisplayName,
       widgetWidth = _ref.widgetWidth,
       widgetHeight = _ref.widgetHeight,
       Widget = _ref.Widget,
@@ -23033,18 +25956,14 @@ var Dashboard = function Dashboard(_ref) {
       i: widgetId,
       x: 0,
       y: 0,
-      w: widgetWidth || 2,
-      h: widgetHeight || 3
-    }]
-  }, (authResponse == null ? void 0 : authResponse.accessToken) && React__default["default"].createElement(material.Box, {
-    key: widgetId
-  }, React__default["default"].createElement(dist.WidgetSettingsButton, {
-    onClick: function onClick() {
-      return setSettingsModalOpened(function (current) {
-        return !current;
-      });
-    }
-  }), React__default["default"].createElement(Widget, {
+      w: widgetWidth || 3,
+      h: widgetHeight || 4
+    }],
+    draggableHandle: ".draggable-handle"
+  }, (authResponse == null ? void 0 : authResponse.accessToken) && React__default["default"].createElement(dist_1.WidgetCard, {
+    key: widgetId,
+    Widget: Widget,
+    title: widgetDisplayName(lang),
     id: widgetId,
     url: GRAPHQL_API_URL,
     token: authResponse.accessToken,
@@ -23057,7 +25976,7 @@ var Dashboard = function Dashboard(_ref) {
       return setSettingsModalOpened(false);
     },
     editMode: editMode
-  })));
+  }));
 };
 
 var routes = function routes(isLoggedIn, _ref) {
@@ -23136,12 +26055,9 @@ var WidgetPreview = function WidgetPreview(_ref) {
     clientId: 'sample-app-client-id',
     grantType: 'password'
   };
-  var containerStyles = {
-    height: '100vh'
-  };
   var headerProps = {
     position: 'static',
-    leadingText: widgetDisplayName,
+    leadingText: widgetDisplayName(lang),
     menuProps: {
       items: menuItems,
       buttonColor: 'white'
@@ -23151,8 +26067,7 @@ var WidgetPreview = function WidgetPreview(_ref) {
     baseUrl: OAUTH2_BASE_URL,
     authProps: authProps
   }, React__default["default"].createElement(andoncloudSdk.Container, {
-    headerProps: headerProps,
-    styles: containerStyles
+    headerProps: headerProps
   }, React__default["default"].createElement(Routing, {
     lang: lang,
     widgetName: widgetName,