andoncloud-widget-preview 1.0.3 → 1.0.4

package/dist/index.js

@@ -3012,7 +3012,7 @@ 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; }
 
 
@@ -7675,6 +7675,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');
 }
@@ -11125,6 +11129,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.
  */
@@ -11496,6 +11507,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.
@@ -12182,6 +12223,42 @@ function parse(source, options) {
   var parser = new Parser(source, options);
   return parser.parseDocument();
 }
+/**
+ * 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
@@ -13675,6 +13752,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;
@@ -16011,6 +16741,1338 @@ 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 parser_1 = getCjsExportFromNamespace(parser);
+
+var printer_1 = getCjsExportFromNamespace(printer);
+
+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.gql = exports.batchRequests = exports.request = exports.rawRequest = exports.GraphQLClient = exports.ClientError = void 0;
+var cross_fetch_1 = __importStar(browserPonyfill), CrossFetch = cross_fetch_1;
+
+
+var createRequestBody_1$1 = __importDefault(createRequestBody_1);
+
+
+
+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;
+                }
+                operationName = resolveRequestDocument(rawRequestOptions.query).operationName;
+                return [2 /*return*/, makeRequest({
+                        url: url,
+                        query: rawRequestOptions.query,
+                        variables: rawRequestOptions.variables,
+                        headers: __assign(__assign({}, resolveHeaders(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(headers)), resolveHeaders(requestOptions.requestHeaders)),
+                                operationName: operationName,
+                                fetch: fetch,
+                                method: method,
+                                fetchOptions: fetchOptions,
+                            })];
+                    case 1:
+                        data = (_e.sent()).data;
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    };
+    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(headers)), resolveHeaders(batchRequestOptions.requestHeaders)),
+                                operationName: undefined,
+                                fetch: fetch,
+                                method: method,
+                                fetchOptions: fetchOptions,
+                            })];
+                    case 1:
+                        data = (_d.sent()).data;
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    };
+    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, headers_1, status_1, 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;
+                    if (response.ok && !result.errors && successfullyReceivedData) {
+                        headers_1 = response.headers, status_1 = response.status;
+                        return [2 /*return*/, __assign(__assign({}, (isBathchingQuery ? { data: result } : result)), { 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 });
+                    }
+            }
+        });
+    });
+}
+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 };
+}
+/**
+ * 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;
+}
+
+});
+
+unwrapExports(dist);
+var dist_5 = dist.GraphQLClient;
+
+var getGraphqlSdk = function getGraphqlSdk(url, token) {
+  var graphqlClient = new dist_5(url);
+  graphqlClient.setHeader('Authorization', "Bearer " + token);
+  return getSdk(graphqlClient);
+};
+
 var moment = createCommonjsModule(function (module, exports) {
 (function (global, factory) {
      module.exports = factory() ;
@@ -21784,6 +23846,7 @@ exports.WorkplaceEventDocument = WorkplaceEventDocument;
 exports.WorkplacesDocument = WorkplacesDocument;
 exports.getCurrentShift = getCurrentShift;
 exports.getGqlWsClient = getGqlWsClient;
+exports.getGraphqlSdk = getGraphqlSdk;
 exports.getRecentShift = getRecentShift;
 exports.getSdk = getSdk;
 exports.normalizeShifts = normalizeShifts;
@@ -23038,7 +25101,7 @@ var Dashboard = function Dashboard(_ref) {
     }]
   }, (authResponse == null ? void 0 : authResponse.accessToken) && React__default["default"].createElement(material.Box, {
     key: widgetId
-  }, React__default["default"].createElement(dist.WidgetSettingsButton, {
+  }, React__default["default"].createElement(dist_1.WidgetSettingsButton, {
     onClick: function onClick() {
       return setSettingsModalOpened(function (current) {
         return !current;
@@ -23141,7 +25204,7 @@ var WidgetPreview = function WidgetPreview(_ref) {
   };
   var headerProps = {
     position: 'static',
-    leadingText: widgetDisplayName,
+    leadingText: widgetDisplayName(lang),
     menuProps: {
       items: menuItems,
       buttonColor: 'white'