@hypercerts-org/marketplace-sdk 0.3.7 → 0.3.9

package/dist/index.esm.js

@@ -4,8 +4,6 @@ import { MerkleTree } from 'merkletreejs';
 import { keccak256 as keccak256$1 } from 'js-sha3';
 import { createClient } from '@supabase/supabase-js';
 import { CONSTANTS, parseClaimOrFractionId } from '@hypercerts-org/sdk';
-import { Client, cacheExchange, fetchExchange } from '@urql/core';
-import { graphql } from 'gql.tada';
 
 var abiIERC721 = [
 	{
@@ -4804,17 +4802,2488 @@ const contractName = "LooksRareProtocol";
  */
 const version = 2;
 
-const urqlClient = new Client({
+var e$2 = {
+  NAME: "Name",
+  DOCUMENT: "Document",
+  OPERATION_DEFINITION: "OperationDefinition",
+  VARIABLE_DEFINITION: "VariableDefinition",
+  SELECTION_SET: "SelectionSet",
+  FIELD: "Field",
+  ARGUMENT: "Argument",
+  FRAGMENT_SPREAD: "FragmentSpread",
+  INLINE_FRAGMENT: "InlineFragment",
+  FRAGMENT_DEFINITION: "FragmentDefinition",
+  VARIABLE: "Variable",
+  INT: "IntValue",
+  FLOAT: "FloatValue",
+  STRING: "StringValue",
+  BOOLEAN: "BooleanValue",
+  NULL: "NullValue",
+  ENUM: "EnumValue",
+  LIST: "ListValue",
+  OBJECT: "ObjectValue",
+  OBJECT_FIELD: "ObjectField",
+  DIRECTIVE: "Directive",
+  NAMED_TYPE: "NamedType",
+  LIST_TYPE: "ListType",
+  NON_NULL_TYPE: "NonNullType"
+};
+
+class GraphQLError extends Error {
+  constructor(e, r, i, n, a, t, l) {
+    super(e);
+    this.name = "GraphQLError";
+    this.message = e;
+    if (a) {
+      this.path = a;
+    }
+    if (r) {
+      this.nodes = Array.isArray(r) ? r : [ r ];
+    }
+    if (i) {
+      this.source = i;
+    }
+    if (n) {
+      this.positions = n;
+    }
+    if (t) {
+      this.originalError = t;
+    }
+    var o = l;
+    if (!o && t) {
+      var u = t.extensions;
+      if (u && "object" == typeof u) {
+        o = u;
+      }
+    }
+    this.extensions = o || {};
+  }
+  toJSON() {
+    return {
+      ...this,
+      message: this.message
+    };
+  }
+  toString() {
+    return this.message;
+  }
+  get [Symbol.toStringTag]() {
+    return "GraphQLError";
+  }
+}
+
+var i$1;
+
+var n;
+
+function error(e) {
+  return new GraphQLError(`Syntax Error: Unexpected token at ${n} in ${e}`);
+}
+
+function advance(e) {
+  e.lastIndex = n;
+  if (e.test(i$1)) {
+    return i$1.slice(n, n = e.lastIndex);
+  }
+}
+
+var a = / +(?=[^\s])/y;
+
+function blockString(e) {
+  var r = e.split("\n");
+  var i = "";
+  var n = 0;
+  var t = 0;
+  var l = r.length - 1;
+  for (var o = 0; o < r.length; o++) {
+    a.lastIndex = 0;
+    if (a.test(r[o])) {
+      if (o && (!n || a.lastIndex < n)) {
+        n = a.lastIndex;
+      }
+      t = t || o;
+      l = o;
+    }
+  }
+  for (var u = t; u <= l; u++) {
+    if (u !== t) {
+      i += "\n";
+    }
+    i += r[u].slice(n).replace(/\\"""/g, '"""');
+  }
+  return i;
+}
+
+function ignored() {
+  for (var e = 0 | i$1.charCodeAt(n++); 9 === e || 10 === e || 13 === e || 32 === e || 35 === e || 44 === e || 65279 === e; e = 0 | i$1.charCodeAt(n++)) {
+    if (35 === e) {
+      while (10 !== (e = i$1.charCodeAt(n++)) && 13 !== e) {}
+    }
+  }
+  n--;
+}
+
+var t = /[_A-Za-z]\w*/y;
+
+var l$1 = new RegExp("(?:(null|true|false)|\\$(" + t.source + ')|(-?\\d+)((?:\\.\\d+)?[eE][+-]?\\d+|\\.\\d+)?|("""(?:"""|(?:[\\s\\S]*?[^\\\\])"""))|("(?:"|[^\\r\\n]*?[^\\\\]"))|(' + t.source + "))", "y");
+
+var o = function(e) {
+  e[e.Const = 1] = "Const";
+  e[e.Var = 2] = "Var";
+  e[e.Int = 3] = "Int";
+  e[e.Float = 4] = "Float";
+  e[e.BlockString = 5] = "BlockString";
+  e[e.String = 6] = "String";
+  e[e.Enum = 7] = "Enum";
+  return e;
+}(o || {});
+
+var u$1 = /\\/g;
+
+function value(e) {
+  var r;
+  var a;
+  l$1.lastIndex = n;
+  if (91 === i$1.charCodeAt(n)) {
+    n++;
+    ignored();
+    var d = [];
+    while (93 !== i$1.charCodeAt(n)) {
+      d.push(value(e));
+    }
+    n++;
+    ignored();
+    return {
+      kind: "ListValue",
+      values: d
+    };
+  } else if (123 === i$1.charCodeAt(n)) {
+    n++;
+    ignored();
+    var v = [];
+    while (125 !== i$1.charCodeAt(n)) {
+      if (null == (r = advance(t))) {
+        throw error("ObjectField");
+      }
+      ignored();
+      if (58 !== i$1.charCodeAt(n++)) {
+        throw error("ObjectField");
+      }
+      ignored();
+      v.push({
+        kind: "ObjectField",
+        name: {
+          kind: "Name",
+          value: r
+        },
+        value: value(e)
+      });
+    }
+    n++;
+    ignored();
+    return {
+      kind: "ObjectValue",
+      fields: v
+    };
+  } else if (null != (a = l$1.exec(i$1))) {
+    n = l$1.lastIndex;
+    ignored();
+    if (null != (r = a[o.Const])) {
+      return "null" === r ? {
+        kind: "NullValue"
+      } : {
+        kind: "BooleanValue",
+        value: "true" === r
+      };
+    } else if (null != (r = a[o.Var])) {
+      if (e) {
+        throw error("Variable");
+      } else {
+        return {
+          kind: "Variable",
+          name: {
+            kind: "Name",
+            value: r
+          }
+        };
+      }
+    } else if (null != (r = a[o.Int])) {
+      var s;
+      if (null != (s = a[o.Float])) {
+        return {
+          kind: "FloatValue",
+          value: r + s
+        };
+      } else {
+        return {
+          kind: "IntValue",
+          value: r
+        };
+      }
+    } else if (null != (r = a[o.BlockString])) {
+      return {
+        kind: "StringValue",
+        value: blockString(r.slice(3, -3)),
+        block: !0
+      };
+    } else if (null != (r = a[o.String])) {
+      return {
+        kind: "StringValue",
+        value: u$1.test(r) ? JSON.parse(r) : r.slice(1, -1),
+        block: !1
+      };
+    } else if (null != (r = a[o.Enum])) {
+      return {
+        kind: "EnumValue",
+        value: r
+      };
+    }
+  }
+  throw error("Value");
+}
+
+function arguments_(e) {
+  if (40 === i$1.charCodeAt(n)) {
+    var r = [];
+    n++;
+    ignored();
+    var a;
+    do {
+      if (null == (a = advance(t))) {
+        throw error("Argument");
+      }
+      ignored();
+      if (58 !== i$1.charCodeAt(n++)) {
+        throw error("Argument");
+      }
+      ignored();
+      r.push({
+        kind: "Argument",
+        name: {
+          kind: "Name",
+          value: a
+        },
+        value: value(e)
+      });
+    } while (41 !== i$1.charCodeAt(n));
+    n++;
+    ignored();
+    return r;
+  }
+}
+
+function directives(e) {
+  if (64 === i$1.charCodeAt(n)) {
+    var r = [];
+    var a;
+    do {
+      n++;
+      if (null == (a = advance(t))) {
+        throw error("Directive");
+      }
+      ignored();
+      r.push({
+        kind: "Directive",
+        name: {
+          kind: "Name",
+          value: a
+        },
+        arguments: arguments_(e)
+      });
+    } while (64 === i$1.charCodeAt(n));
+    return r;
+  }
+}
+
+function type() {
+  var e;
+  var r = 0;
+  while (91 === i$1.charCodeAt(n)) {
+    r++;
+    n++;
+    ignored();
+  }
+  if (null == (e = advance(t))) {
+    throw error("NamedType");
+  }
+  ignored();
+  var a = {
+    kind: "NamedType",
+    name: {
+      kind: "Name",
+      value: e
+    }
+  };
+  do {
+    if (33 === i$1.charCodeAt(n)) {
+      n++;
+      ignored();
+      a = {
+        kind: "NonNullType",
+        type: a
+      };
+    }
+    if (r) {
+      if (93 !== i$1.charCodeAt(n++)) {
+        throw error("NamedType");
+      }
+      ignored();
+      a = {
+        kind: "ListType",
+        type: a
+      };
+    }
+  } while (r--);
+  return a;
+}
+
+var d$1 = new RegExp("(?:(\\.{3})|(" + t.source + "))", "y");
+
+var v$1 = function(e) {
+  e[e.Spread = 1] = "Spread";
+  e[e.Name = 2] = "Name";
+  return e;
+}(v$1 || {});
+
+function selectionSet() {
+  var e = [];
+  var r;
+  var a;
+  do {
+    d$1.lastIndex = n;
+    if (null != (a = d$1.exec(i$1))) {
+      n = d$1.lastIndex;
+      if (null != a[v$1.Spread]) {
+        ignored();
+        var l = advance(t);
+        if (null != l && "on" !== l) {
+          ignored();
+          e.push({
+            kind: "FragmentSpread",
+            name: {
+              kind: "Name",
+              value: l
+            },
+            directives: directives(!1)
+          });
+        } else {
+          ignored();
+          if ("on" === l) {
+            if (null == (l = advance(t))) {
+              throw error("NamedType");
+            }
+            ignored();
+          }
+          var o = directives(!1);
+          if (123 !== i$1.charCodeAt(n++)) {
+            throw error("InlineFragment");
+          }
+          ignored();
+          e.push({
+            kind: "InlineFragment",
+            typeCondition: l ? {
+              kind: "NamedType",
+              name: {
+                kind: "Name",
+                value: l
+              }
+            } : void 0,
+            directives: o,
+            selectionSet: selectionSet()
+          });
+        }
+      } else if (null != (r = a[v$1.Name])) {
+        var u = void 0;
+        ignored();
+        if (58 === i$1.charCodeAt(n)) {
+          n++;
+          ignored();
+          u = r;
+          if (null == (r = advance(t))) {
+            throw error("Field");
+          }
+          ignored();
+        }
+        var s = arguments_(!1);
+        ignored();
+        var c = directives(!1);
+        var f = void 0;
+        if (123 === i$1.charCodeAt(n)) {
+          n++;
+          ignored();
+          f = selectionSet();
+        }
+        e.push({
+          kind: "Field",
+          alias: u ? {
+            kind: "Name",
+            value: u
+          } : void 0,
+          name: {
+            kind: "Name",
+            value: r
+          },
+          arguments: s,
+          directives: c,
+          selectionSet: f
+        });
+      }
+    } else {
+      throw error("SelectionSet");
+    }
+  } while (125 !== i$1.charCodeAt(n));
+  n++;
+  ignored();
+  return {
+    kind: "SelectionSet",
+    selections: e
+  };
+}
+
+function fragmentDefinition() {
+  var e;
+  var r;
+  if (null == (e = advance(t))) {
+    throw error("FragmentDefinition");
+  }
+  ignored();
+  if ("on" !== advance(t)) {
+    throw error("FragmentDefinition");
+  }
+  ignored();
+  if (null == (r = advance(t))) {
+    throw error("FragmentDefinition");
+  }
+  ignored();
+  var a = directives(!1);
+  if (123 !== i$1.charCodeAt(n++)) {
+    throw error("FragmentDefinition");
+  }
+  ignored();
+  return {
+    kind: "FragmentDefinition",
+    name: {
+      kind: "Name",
+      value: e
+    },
+    typeCondition: {
+      kind: "NamedType",
+      name: {
+        kind: "Name",
+        value: r
+      }
+    },
+    directives: a,
+    selectionSet: selectionSet()
+  };
+}
+
+var s = /(?:query|mutation|subscription|fragment)/y;
+
+function operationDefinition(e) {
+  var r;
+  var a;
+  var l;
+  if (e) {
+    ignored();
+    r = advance(t);
+    a = function variableDefinitions() {
+      ignored();
+      if (40 === i$1.charCodeAt(n)) {
+        var e = [];
+        n++;
+        ignored();
+        var r;
+        do {
+          if (36 !== i$1.charCodeAt(n++)) {
+            throw error("Variable");
+          }
+          if (null == (r = advance(t))) {
+            throw error("Variable");
+          }
+          ignored();
+          if (58 !== i$1.charCodeAt(n++)) {
+            throw error("VariableDefinition");
+          }
+          ignored();
+          var a = type();
+          var l = void 0;
+          if (61 === i$1.charCodeAt(n)) {
+            n++;
+            ignored();
+            l = value(!0);
+          }
+          ignored();
+          e.push({
+            kind: "VariableDefinition",
+            variable: {
+              kind: "Variable",
+              name: {
+                kind: "Name",
+                value: r
+              }
+            },
+            type: a,
+            defaultValue: l,
+            directives: directives(!0)
+          });
+        } while (41 !== i$1.charCodeAt(n));
+        n++;
+        ignored();
+        return e;
+      }
+    }();
+    l = directives(!1);
+  }
+  if (123 === i$1.charCodeAt(n)) {
+    n++;
+    ignored();
+    return {
+      kind: "OperationDefinition",
+      operation: e || "query",
+      name: r ? {
+        kind: "Name",
+        value: r
+      } : void 0,
+      variableDefinitions: a,
+      directives: l,
+      selectionSet: selectionSet()
+    };
+  }
+}
+
+function parse(e, r) {
+  i$1 = "string" == typeof e.body ? e.body : e;
+  n = 0;
+  return function document() {
+    var e;
+    var r;
+    ignored();
+    var a = [];
+    do {
+      if ("fragment" === (e = advance(s))) {
+        ignored();
+        a.push(fragmentDefinition());
+      } else if (null != (r = operationDefinition(e))) {
+        a.push(r);
+      } else {
+        throw error("Document");
+      }
+    } while (n < i$1.length);
+    return {
+      kind: "Document",
+      definitions: a
+    };
+  }();
+}
+
+function mapJoin(e, r, i) {
+  var n = "";
+  for (var a = 0; a < e.length; a++) {
+    if (a) {
+      n += r;
+    }
+    n += i(e[a]);
+  }
+  return n;
+}
+
+function printString(e) {
+  return JSON.stringify(e);
+}
+
+function printBlockString(e) {
+  return '"""\n' + e.replace(/"""/g, '\\"""') + '\n"""';
+}
+
+var f$1 = "\n";
+
+var m$1 = {
+  OperationDefinition(e) {
+    var r = e.operation;
+    if (e.name) {
+      r += " " + e.name.value;
+    }
+    if (e.variableDefinitions && e.variableDefinitions.length) {
+      if (!e.name) {
+        r += " ";
+      }
+      r += "(" + mapJoin(e.variableDefinitions, ", ", m$1.VariableDefinition) + ")";
+    }
+    if (e.directives && e.directives.length) {
+      r += " " + mapJoin(e.directives, " ", m$1.Directive);
+    }
+    return "query" !== r ? r + " " + m$1.SelectionSet(e.selectionSet) : m$1.SelectionSet(e.selectionSet);
+  },
+  VariableDefinition(e) {
+    var r = m$1.Variable(e.variable) + ": " + _print(e.type);
+    if (e.defaultValue) {
+      r += " = " + _print(e.defaultValue);
+    }
+    if (e.directives && e.directives.length) {
+      r += " " + mapJoin(e.directives, " ", m$1.Directive);
+    }
+    return r;
+  },
+  Field(e) {
+    var r = e.alias ? e.alias.value + ": " + e.name.value : e.name.value;
+    if (e.arguments && e.arguments.length) {
+      var i = mapJoin(e.arguments, ", ", m$1.Argument);
+      if (r.length + i.length + 2 > 80) {
+        r += "(" + (f$1 += "  ") + mapJoin(e.arguments, f$1, m$1.Argument) + (f$1 = f$1.slice(0, -2)) + ")";
+      } else {
+        r += "(" + i + ")";
+      }
+    }
+    if (e.directives && e.directives.length) {
+      r += " " + mapJoin(e.directives, " ", m$1.Directive);
+    }
+    if (e.selectionSet) {
+      r += " " + m$1.SelectionSet(e.selectionSet);
+    }
+    return r;
+  },
+  StringValue(e) {
+    if (e.block) {
+      return printBlockString(e.value).replace(/\n/g, f$1);
+    } else {
+      return printString(e.value);
+    }
+  },
+  BooleanValue: e => "" + e.value,
+  NullValue: e => "null",
+  IntValue: e => e.value,
+  FloatValue: e => e.value,
+  EnumValue: e => e.value,
+  Name: e => e.value,
+  Variable: e => "$" + e.name.value,
+  ListValue: e => "[" + mapJoin(e.values, ", ", _print) + "]",
+  ObjectValue: e => "{" + mapJoin(e.fields, ", ", m$1.ObjectField) + "}",
+  ObjectField: e => e.name.value + ": " + _print(e.value),
+  Document(e) {
+    if (!e.definitions || !e.definitions.length) {
+      return "";
+    }
+    return mapJoin(e.definitions, "\n\n", _print);
+  },
+  SelectionSet: e => "{" + (f$1 += "  ") + mapJoin(e.selections, f$1, _print) + (f$1 = f$1.slice(0, -2)) + "}",
+  Argument: e => e.name.value + ": " + _print(e.value),
+  FragmentSpread(e) {
+    var r = "..." + e.name.value;
+    if (e.directives && e.directives.length) {
+      r += " " + mapJoin(e.directives, " ", m$1.Directive);
+    }
+    return r;
+  },
+  InlineFragment(e) {
+    var r = "...";
+    if (e.typeCondition) {
+      r += " on " + e.typeCondition.name.value;
+    }
+    if (e.directives && e.directives.length) {
+      r += " " + mapJoin(e.directives, " ", m$1.Directive);
+    }
+    return r += " " + m$1.SelectionSet(e.selectionSet);
+  },
+  FragmentDefinition(e) {
+    var r = "fragment " + e.name.value;
+    r += " on " + e.typeCondition.name.value;
+    if (e.directives && e.directives.length) {
+      r += " " + mapJoin(e.directives, " ", m$1.Directive);
+    }
+    return r + " " + m$1.SelectionSet(e.selectionSet);
+  },
+  Directive(e) {
+    var r = "@" + e.name.value;
+    if (e.arguments && e.arguments.length) {
+      r += "(" + mapJoin(e.arguments, ", ", m$1.Argument) + ")";
+    }
+    return r;
+  },
+  NamedType: e => e.name.value,
+  ListType: e => "[" + _print(e.type) + "]",
+  NonNullType: e => _print(e.type) + "!"
+};
+
+var _print = e => m$1[e.kind](e);
+
+function print(e) {
+  f$1 = "\n";
+  return m$1[e.kind] ? m$1[e.kind](e) : "";
+}
+
+var teardownPlaceholder = () => {};
+
+var e$1 = teardownPlaceholder;
+
+function start(e) {
+  return {
+    tag: 0,
+    0: e
+  };
+}
+
+function push(e) {
+  return {
+    tag: 1,
+    0: e
+  };
+}
+
+var asyncIteratorSymbol = () => "function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator";
+
+var identity = e => e;
+
+function filter(r) {
+  return t => i => {
+    var a = e$1;
+    t((e => {
+      if (0 === e) {
+        i(0);
+      } else if (0 === e.tag) {
+        a = e[0];
+        i(e);
+      } else if (!r(e[0])) {
+        a(0);
+      } else {
+        i(e);
+      }
+    }));
+  };
+}
+
+function map(e) {
+  return r => t => r((r => {
+    if (0 === r || 0 === r.tag) {
+      t(r);
+    } else {
+      t(push(e(r[0])));
+    }
+  }));
+}
+
+function mergeMap(r) {
+  return t => i => {
+    var a = [];
+    var f = e$1;
+    var n = !1;
+    var s = !1;
+    t((t => {
+      if (s) ; else if (0 === t) {
+        s = !0;
+        if (!a.length) {
+          i(0);
+        }
+      } else if (0 === t.tag) {
+        f = t[0];
+      } else {
+        n = !1;
+        !function applyInnerSource(r) {
+          var t = e$1;
+          r((e => {
+            if (0 === e) {
+              if (a.length) {
+                var r = a.indexOf(t);
+                if (r > -1) {
+                  (a = a.slice()).splice(r, 1);
+                }
+                if (!a.length) {
+                  if (s) {
+                    i(0);
+                  } else if (!n) {
+                    n = !0;
+                    f(0);
+                  }
+                }
+              }
+            } else if (0 === e.tag) {
+              a.push(t = e[0]);
+              t(0);
+            } else if (a.length) {
+              i(e);
+              t(0);
+            }
+          }));
+        }(r(t[0]));
+        if (!n) {
+          n = !0;
+          f(0);
+        }
+      }
+    }));
+    i(start((e => {
+      if (1 === e) {
+        if (!s) {
+          s = !0;
+          f(1);
+        }
+        for (var r = 0, t = a, i = a.length; r < i; r++) {
+          t[r](1);
+        }
+        a.length = 0;
+      } else {
+        if (!s && !n) {
+          n = !0;
+          f(0);
+        } else {
+          n = !1;
+        }
+        for (var l = 0, u = a, o = a.length; l < o; l++) {
+          u[l](0);
+        }
+      }
+    })));
+  };
+}
+
+function mergeAll(e) {
+  return mergeMap(identity)(e);
+}
+
+function merge(e) {
+  return mergeAll(r(e));
+}
+
+function onEnd(e) {
+  return r => t => {
+    var i = !1;
+    r((r => {
+      if (i) ; else if (0 === r) {
+        i = !0;
+        t(0);
+        e();
+      } else if (0 === r.tag) {
+        var a = r[0];
+        t(start((r => {
+          if (1 === r) {
+            i = !0;
+            a(1);
+            e();
+          } else {
+            a(r);
+          }
+        })));
+      } else {
+        t(r);
+      }
+    }));
+  };
+}
+
+function onPush(e) {
+  return r => t => {
+    var i = !1;
+    r((r => {
+      if (i) ; else if (0 === r) {
+        i = !0;
+        t(0);
+      } else if (0 === r.tag) {
+        var a = r[0];
+        t(start((e => {
+          if (1 === e) {
+            i = !0;
+          }
+          a(e);
+        })));
+      } else {
+        e(r[0]);
+        t(r);
+      }
+    }));
+  };
+}
+
+function onStart(e) {
+  return r => t => r((r => {
+    if (0 === r) {
+      t(0);
+    } else if (0 === r.tag) {
+      t(r);
+      e();
+    } else {
+      t(r);
+    }
+  }));
+}
+
+function share(r) {
+  var t = [];
+  var i = e$1;
+  var a = !1;
+  return e => {
+    t.push(e);
+    if (1 === t.length) {
+      r((e => {
+        if (0 === e) {
+          for (var r = 0, f = t, n = t.length; r < n; r++) {
+            f[r](0);
+          }
+          t.length = 0;
+        } else if (0 === e.tag) {
+          i = e[0];
+        } else {
+          a = !1;
+          for (var s = 0, l = t, u = t.length; s < u; s++) {
+            l[s](e);
+          }
+        }
+      }));
+    }
+    e(start((r => {
+      if (1 === r) {
+        var f = t.indexOf(e);
+        if (f > -1) {
+          (t = t.slice()).splice(f, 1);
+        }
+        if (!t.length) {
+          i(1);
+        }
+      } else if (!a) {
+        a = !0;
+        i(0);
+      }
+    })));
+  };
+}
+
+function switchMap(r) {
+  return t => i => {
+    var a = e$1;
+    var f = e$1;
+    var n = !1;
+    var s = !1;
+    var l = !1;
+    var u = !1;
+    t((t => {
+      if (u) ; else if (0 === t) {
+        u = !0;
+        if (!l) {
+          i(0);
+        }
+      } else if (0 === t.tag) {
+        a = t[0];
+      } else {
+        if (l) {
+          f(1);
+          f = e$1;
+        }
+        if (!n) {
+          n = !0;
+          a(0);
+        } else {
+          n = !1;
+        }
+        !function applyInnerSource(e) {
+          l = !0;
+          e((e => {
+            if (!l) ; else if (0 === e) {
+              l = !1;
+              if (u) {
+                i(0);
+              } else if (!n) {
+                n = !0;
+                a(0);
+              }
+            } else if (0 === e.tag) {
+              s = !1;
+              (f = e[0])(0);
+            } else {
+              i(e);
+              if (!s) {
+                f(0);
+              } else {
+                s = !1;
+              }
+            }
+          }));
+        }(r(t[0]));
+      }
+    }));
+    i(start((e => {
+      if (1 === e) {
+        if (!u) {
+          u = !0;
+          a(1);
+        }
+        if (l) {
+          l = !1;
+          f(1);
+        }
+      } else {
+        if (!u && !n) {
+          n = !0;
+          a(0);
+        }
+        if (l && !s) {
+          s = !0;
+          f(0);
+        }
+      }
+    })));
+  };
+}
+
+function take(r) {
+  return t => i => {
+    var a = e$1;
+    var f = !1;
+    var n = 0;
+    t((e => {
+      if (f) ; else if (0 === e) {
+        f = !0;
+        i(0);
+      } else if (0 === e.tag) {
+        if (r <= 0) {
+          f = !0;
+          i(0);
+          e[0](1);
+        } else {
+          a = e[0];
+        }
+      } else if (n++ < r) {
+        i(e);
+        if (!f && n >= r) {
+          f = !0;
+          i(0);
+          a(1);
+        }
+      } else {
+        i(e);
+      }
+    }));
+    i(start((e => {
+      if (1 === e && !f) {
+        f = !0;
+        a(1);
+      } else if (0 === e && !f && n < r) {
+        a(0);
+      }
+    })));
+  };
+}
+
+function takeUntil(r) {
+  return t => i => {
+    var a = e$1;
+    var f = e$1;
+    var n = !1;
+    t((e => {
+      if (n) ; else if (0 === e) {
+        n = !0;
+        f(1);
+        i(0);
+      } else if (0 === e.tag) {
+        a = e[0];
+        r((e => {
+          if (0 === e) ; else if (0 === e.tag) {
+            (f = e[0])(0);
+          } else {
+            n = !0;
+            f(1);
+            a(1);
+            i(0);
+          }
+        }));
+      } else {
+        i(e);
+      }
+    }));
+    i(start((e => {
+      if (1 === e && !n) {
+        n = !0;
+        a(1);
+        f(1);
+      } else if (!n) {
+        a(0);
+      }
+    })));
+  };
+}
+
+function takeWhile(r, t) {
+  return i => a => {
+    var f = e$1;
+    var n = !1;
+    i((e => {
+      if (n) ; else if (0 === e) {
+        n = !0;
+        a(0);
+      } else if (0 === e.tag) {
+        f = e[0];
+        a(e);
+      } else if (!r(e[0])) {
+        n = !0;
+        if (t) {
+          a(e);
+        }
+        a(0);
+        f(1);
+      } else {
+        a(e);
+      }
+    }));
+  };
+}
+
+function lazy(e) {
+  return r => e()(r);
+}
+
+function fromAsyncIterable(e) {
+  return r => {
+    var t = e[asyncIteratorSymbol()] && e[asyncIteratorSymbol()]() || e;
+    var i = !1;
+    var a = !1;
+    var f = !1;
+    var n;
+    r(start((async e => {
+      if (1 === e) {
+        i = !0;
+        if (t.return) {
+          t.return();
+        }
+      } else if (a) {
+        f = !0;
+      } else {
+        for (f = a = !0; f && !i; ) {
+          if ((n = await t.next()).done) {
+            i = !0;
+            if (t.return) {
+              await t.return();
+            }
+            r(0);
+          } else {
+            try {
+              f = !1;
+              r(push(n.value));
+            } catch (e) {
+              if (t.throw) {
+                if (i = !!(await t.throw(e)).done) {
+                  r(0);
+                }
+              } else {
+                throw e;
+              }
+            }
+          }
+        }
+        a = !1;
+      }
+    })));
+  };
+}
+
+function fromIterable(e) {
+  if (e[Symbol.asyncIterator]) {
+    return fromAsyncIterable(e);
+  }
+  return r => {
+    var t = e[Symbol.iterator]();
+    var i = !1;
+    var a = !1;
+    var f = !1;
+    var n;
+    r(start((e => {
+      if (1 === e) {
+        i = !0;
+        if (t.return) {
+          t.return();
+        }
+      } else if (a) {
+        f = !0;
+      } else {
+        for (f = a = !0; f && !i; ) {
+          if ((n = t.next()).done) {
+            i = !0;
+            if (t.return) {
+              t.return();
+            }
+            r(0);
+          } else {
+            try {
+              f = !1;
+              r(push(n.value));
+            } catch (e) {
+              if (t.throw) {
+                if (i = !!t.throw(e).done) {
+                  r(0);
+                }
+              } else {
+                throw e;
+              }
+            }
+          }
+        }
+        a = !1;
+      }
+    })));
+  };
+}
+
+var r = fromIterable;
+
+function fromValue(e) {
+  return r => {
+    var t = !1;
+    r(start((i => {
+      if (1 === i) {
+        t = !0;
+      } else if (!t) {
+        t = !0;
+        r(push(e));
+        r(0);
+      }
+    })));
+  };
+}
+
+function make(e) {
+  return r => {
+    var t = !1;
+    var i = e({
+      next(e) {
+        if (!t) {
+          r(push(e));
+        }
+      },
+      complete() {
+        if (!t) {
+          t = !0;
+          r(0);
+        }
+      }
+    });
+    r(start((e => {
+      if (1 === e && !t) {
+        t = !0;
+        i();
+      }
+    })));
+  };
+}
+
+function makeSubject() {
+  var e;
+  var r;
+  return {
+    source: share(make((t => {
+      e = t.next;
+      r = t.complete;
+      return teardownPlaceholder;
+    }))),
+    next(r) {
+      if (e) {
+        e(r);
+      }
+    },
+    complete() {
+      if (r) {
+        r();
+      }
+    }
+  };
+}
+
+function subscribe(r) {
+  return t => {
+    var i = e$1;
+    var a = !1;
+    t((e => {
+      if (0 === e) {
+        a = !0;
+      } else if (0 === e.tag) {
+        (i = e[0])(0);
+      } else if (!a) {
+        r(e[0]);
+        i(0);
+      }
+    }));
+    return {
+      unsubscribe() {
+        if (!a) {
+          a = !0;
+          i(1);
+        }
+      }
+    };
+  };
+}
+
+function publish(e) {
+  subscribe((e => {}))(e);
+}
+
+function toPromise(r) {
+  return new Promise((t => {
+    var i = e$1;
+    var a;
+    r((e => {
+      if (0 === e) {
+        Promise.resolve(a).then(t);
+      } else if (0 === e.tag) {
+        (i = e[0])(0);
+      } else {
+        a = e[0];
+        i(0);
+      }
+    }));
+  }));
+}
+
+var rehydrateGraphQlError = r => {
+  if (r && r.message && (r.extensions || "GraphQLError" === r.name)) {
+    return r;
+  } else if ("object" == typeof r && r.message) {
+    return new GraphQLError(r.message, r.nodes, r.source, r.positions, r.path, r, r.extensions || {});
+  } else {
+    return new GraphQLError(r);
+  }
+};
+
+class CombinedError extends Error {
+  constructor(e) {
+    var r = (e.graphQLErrors || []).map(rehydrateGraphQlError);
+    var t = ((e, r) => {
+      var t = "";
+      if (e) {
+        return `[Network] ${e.message}`;
+      }
+      if (r) {
+        for (var a of r) {
+          if (t) {
+            t += "\n";
+          }
+          t += `[GraphQL] ${a.message}`;
+        }
+      }
+      return t;
+    })(e.networkError, r);
+    super(t);
+    this.name = "CombinedError";
+    this.message = t;
+    this.graphQLErrors = r;
+    this.networkError = e.networkError;
+    this.response = e.response;
+  }
+  toString() {
+    return this.message;
+  }
+}
+
+var phash = (e, r) => {
+  var t = 0 | (r || 5381);
+  for (var a = 0, o = 0 | e.length; a < o; a++) {
+    t = (t << 5) + t + e.charCodeAt(a);
+  }
+  return t;
+};
+
+var i = new Set;
+
+var f = new WeakMap;
+
+var stringify = (e, r) => {
+  if (null === e || i.has(e)) {
+    return "null";
+  } else if ("object" != typeof e) {
+    return JSON.stringify(e) || "";
+  } else if (e.toJSON) {
+    return stringify(e.toJSON(), r);
+  } else if (Array.isArray(e)) {
+    var t = "[";
+    for (var a of e) {
+      if (t.length > 1) {
+        t += ",";
+      }
+      t += stringify(a, r) || "null";
+    }
+    return t += "]";
+  } else if (!r && (l !== NoopConstructor && e instanceof l || c !== NoopConstructor && e instanceof c)) {
+    return "null";
+  }
+  var o = Object.keys(e).sort();
+  if (!o.length && e.constructor && Object.getPrototypeOf(e).constructor !== Object.prototype.constructor) {
+    var n = f.get(e) || Math.random().toString(36).slice(2);
+    f.set(e, n);
+    return stringify({
+      __key: n
+    }, r);
+  }
+  i.add(e);
+  var s = "{";
+  for (var d of o) {
+    var v = stringify(e[d], r);
+    if (v) {
+      if (s.length > 1) {
+        s += ",";
+      }
+      s += stringify(d, r) + ":" + v;
+    }
+  }
+  i.delete(e);
+  return s += "}";
+};
+
+var extract = (e, r, t) => {
+  if (null == t || "object" != typeof t || t.toJSON || i.has(t)) ; else if (Array.isArray(t)) {
+    for (var a = 0, o = t.length; a < o; a++) {
+      extract(e, `${r}.${a}`, t[a]);
+    }
+  } else if (t instanceof l || t instanceof c) {
+    e.set(r, t);
+  } else {
+    i.add(t);
+    for (var n of Object.keys(t)) {
+      extract(e, `${r}.${n}`, t[n]);
+    }
+  }
+};
+
+var stringifyVariables = (e, r) => {
+  i.clear();
+  return stringify(e, r || !1);
+};
+
+class NoopConstructor {}
+
+var l = "undefined" != typeof File ? File : NoopConstructor;
+
+var c = "undefined" != typeof Blob ? Blob : NoopConstructor;
+
+var d = /("{3}[\s\S]*"{3}|"(?:\\.|[^"])*")/g;
+
+var v = /(?:#[^\n\r]+)?(?:[\r\n]+|$)/g;
+
+var replaceOutsideStrings = (e, r) => r % 2 == 0 ? e.replace(v, "\n") : e;
+
+var sanitizeDocument = e => e.split(d).map(replaceOutsideStrings).join("").trim();
+
+var p = new Map;
+
+var u = new Map;
+
+var stringifyDocument = e => {
+  var t;
+  if ("string" == typeof e) {
+    t = sanitizeDocument(e);
+  } else if (e.loc && u.get(e.__key) === e) {
+    t = e.loc.source.body;
+  } else {
+    t = p.get(e) || sanitizeDocument(print(e));
+    p.set(e, t);
+  }
+  if ("string" != typeof e && !e.loc) {
+    e.loc = {
+      start: 0,
+      end: t.length,
+      source: {
+        body: t,
+        name: "gql",
+        locationOffset: {
+          line: 1,
+          column: 1
+        }
+      }
+    };
+  }
+  return t;
+};
+
+var hashDocument = e => {
+  var r;
+  if (e.documentId) {
+    r = phash(e.documentId);
+  } else {
+    r = phash(stringifyDocument(e));
+    if (e.definitions) {
+      var t = getOperationName(e);
+      if (t) {
+        r = phash(`\n# ${t}`, r);
+      }
+    }
+  }
+  return r;
+};
+
+var keyDocument = e => {
+  var r;
+  var a;
+  if ("string" == typeof e) {
+    r = hashDocument(e);
+    a = u.get(r) || parse(e);
+  } else {
+    r = e.__key || hashDocument(e);
+    a = u.get(r) || e;
+  }
+  if (!a.loc) {
+    stringifyDocument(a);
+  }
+  a.__key = r;
+  u.set(r, a);
+  return a;
+};
+
+var createRequest = (e, r, t) => {
+  var a = r || {};
+  var o = keyDocument(e);
+  var n = stringifyVariables(a, !0);
+  var s = o.__key;
+  if ("{}" !== n) {
+    s = phash(n, s);
+  }
+  return {
+    key: s,
+    query: o,
+    variables: a,
+    extensions: t
+  };
+};
+
+var getOperationName = e => {
+  for (var r of e.definitions) {
+    if (r.kind === e$2.OPERATION_DEFINITION) {
+      return r.name ? r.name.value : void 0;
+    }
+  }
+};
+
+var getOperationType = e => {
+  for (var r of e.definitions) {
+    if (r.kind === e$2.OPERATION_DEFINITION) {
+      return r.operation;
+    }
+  }
+};
+
+var makeResult = (e, r, t) => {
+  if (!("data" in r || "errors" in r && Array.isArray(r.errors))) {
+    throw new Error("No Content");
+  }
+  var a = "subscription" === e.kind;
+  return {
+    operation: e,
+    data: r.data,
+    error: Array.isArray(r.errors) ? new CombinedError({
+      graphQLErrors: r.errors,
+      response: t
+    }) : void 0,
+    extensions: r.extensions ? {
+      ...r.extensions
+    } : void 0,
+    hasNext: null == r.hasNext ? a : r.hasNext,
+    stale: !1
+  };
+};
+
+var deepMerge = (e, r) => {
+  if ("object" == typeof e && null != e) {
+    if (!e.constructor || e.constructor === Object || Array.isArray(e)) {
+      e = Array.isArray(e) ? [ ...e ] : {
+        ...e
+      };
+      for (var t of Object.keys(r)) {
+        e[t] = deepMerge(e[t], r[t]);
+      }
+      return e;
+    }
+  }
+  return r;
+};
+
+var mergeResultPatch = (e, r, t, a) => {
+  var o = e.error ? e.error.graphQLErrors : [];
+  var n = !!e.extensions || !!(r.payload || r).extensions;
+  var s = {
+    ...e.extensions,
+    ...(r.payload || r).extensions
+  };
+  var i = r.incremental;
+  if ("path" in r) {
+    i = [ r ];
+  }
+  var f = {
+    data: e.data
+  };
+  if (i) {
+    var _loop = function(e) {
+      if (Array.isArray(e.errors)) {
+        o.push(...e.errors);
+      }
+      if (e.extensions) {
+        Object.assign(s, e.extensions);
+        n = !0;
+      }
+      var r = "data";
+      var t = f;
+      var i = [];
+      if (e.path) {
+        i = e.path;
+      } else if (a) {
+        var l = a.find((r => r.id === e.id));
+        if (e.subPath) {
+          i = [ ...l.path, ...e.subPath ];
+        } else {
+          i = l.path;
+        }
+      }
+      for (var c = 0, d = i.length; c < d; r = i[c++]) {
+        t = t[r] = Array.isArray(t[r]) ? [ ...t[r] ] : {
+          ...t[r]
+        };
+      }
+      if (e.items) {
+        var v = +r >= 0 ? r : 0;
+        for (var p = 0, u = e.items.length; p < u; p++) {
+          t[v + p] = deepMerge(t[v + p], e.items[p]);
+        }
+      } else if (void 0 !== e.data) {
+        t[r] = deepMerge(t[r], e.data);
+      }
+    };
+    for (var l of i) {
+      _loop(l);
+    }
+  } else {
+    f.data = (r.payload || r).data || e.data;
+    o = r.errors || r.payload && r.payload.errors || o;
+  }
+  return {
+    operation: e.operation,
+    data: f.data,
+    error: o.length ? new CombinedError({
+      graphQLErrors: o,
+      response: t
+    }) : void 0,
+    extensions: n ? s : void 0,
+    hasNext: null != r.hasNext ? r.hasNext : e.hasNext,
+    stale: !1
+  };
+};
+
+var makeErrorResult = (e, r, t) => ({
+  operation: e,
+  data: void 0,
+  error: new CombinedError({
+    networkError: r,
+    response: t
+  }),
+  extensions: void 0,
+  hasNext: !1,
+  stale: !1
+});
+
+function makeFetchBody(e) {
+  var r = {
+    query: void 0,
+    documentId: void 0,
+    operationName: getOperationName(e.query),
+    variables: e.variables || void 0,
+    extensions: e.extensions
+  };
+  if ("documentId" in e.query && e.query.documentId && (!e.query.definitions || !e.query.definitions.length)) {
+    r.documentId = e.query.documentId;
+  } else if (!e.extensions || !e.extensions.persistedQuery || e.extensions.persistedQuery.miss) {
+    r.query = stringifyDocument(e.query);
+  }
+  return r;
+}
+
+var makeFetchURL = (e, r) => {
+  var t = "query" === e.kind && e.context.preferGetMethod;
+  if (!t || !r) {
+    return e.context.url;
+  }
+  var a = splitOutSearchParams(e.context.url);
+  for (var o in r) {
+    var n = r[o];
+    if (n) {
+      a[1].set(o, "object" == typeof n ? stringifyVariables(n) : n);
+    }
+  }
+  var s = a.join("?");
+  if (s.length > 2047 && "force" !== t) {
+    e.context.preferGetMethod = !1;
+    return e.context.url;
+  }
+  return s;
+};
+
+var splitOutSearchParams = e => {
+  var r = e.indexOf("?");
+  return r > -1 ? [ e.slice(0, r), new URLSearchParams(e.slice(r + 1)) ] : [ e, new URLSearchParams ];
+};
+
+var serializeBody = (e, r) => {
+  if (r && !("query" === e.kind && !!e.context.preferGetMethod)) {
+    var t = stringifyVariables(r);
+    var a = (e => {
+      var r = new Map;
+      if (l !== NoopConstructor || c !== NoopConstructor) {
+        i.clear();
+        extract(r, "variables", e);
+      }
+      return r;
+    })(r.variables);
+    if (a.size) {
+      var o = new FormData;
+      o.append("operations", t);
+      o.append("map", stringifyVariables({
+        ...[ ...a.keys() ].map((e => [ e ]))
+      }));
+      var n = 0;
+      for (var s of a.values()) {
+        o.append("" + n++, s);
+      }
+      return o;
+    }
+    return t;
+  }
+};
+
+var makeFetchOptions = (e, r) => {
+  var t = {
+    accept: "subscription" === e.kind ? "text/event-stream, multipart/mixed" : "application/graphql-response+json, application/graphql+json, application/json, text/event-stream, multipart/mixed"
+  };
+  var a = ("function" == typeof e.context.fetchOptions ? e.context.fetchOptions() : e.context.fetchOptions) || {};
+  if (a.headers) {
+    if ((e => "has" in e && !Object.keys(e).length)(a.headers)) {
+      a.headers.forEach(((e, r) => {
+        t[r] = e;
+      }));
+    } else if (Array.isArray(a.headers)) {
+      a.headers.forEach(((e, r) => {
+        if (Array.isArray(e)) {
+          if (t[e[0]]) {
+            t[e[0]] = `${t[e[0]]},${e[1]}`;
+          } else {
+            t[e[0]] = e[1];
+          }
+        } else {
+          t[r] = e;
+        }
+      }));
+    } else {
+      for (var o in a.headers) {
+        t[o.toLowerCase()] = a.headers[o];
+      }
+    }
+  }
+  var n = serializeBody(e, r);
+  if ("string" == typeof n && !t["content-type"]) {
+    t["content-type"] = "application/json";
+  }
+  return {
+    ...a,
+    method: n ? "POST" : "GET",
+    body: n,
+    headers: t
+  };
+};
+
+var y = "undefined" != typeof TextDecoder ? new TextDecoder : null;
+
+var h = /boundary="?([^=";]+)"?/i;
+
+var m = /data: ?([^\n]+)/;
+
+var toString = e => "Buffer" === e.constructor.name ? e.toString() : y.decode(e);
+
+async function* streamBody(e) {
+  if (e.body[Symbol.asyncIterator]) {
+    for await (var r of e.body) {
+      yield toString(r);
+    }
+  } else {
+    var t = e.body.getReader();
+    var a;
+    try {
+      while (!(a = await t.read()).done) {
+        yield toString(a.value);
+      }
+    } finally {
+      t.cancel();
+    }
+  }
+}
+
+async function* split(e, r) {
+  var t = "";
+  var a;
+  for await (var o of e) {
+    t += o;
+    while ((a = t.indexOf(r)) > -1) {
+      yield t.slice(0, a);
+      t = t.slice(a + r.length);
+    }
+  }
+}
+
+async function* fetchOperation(e, r, t) {
+  var a = !0;
+  var o = null;
+  var n;
+  try {
+    yield await Promise.resolve();
+    var s = (n = await (e.context.fetch || fetch)(r, t)).headers.get("Content-Type") || "";
+    var i;
+    if (/multipart\/mixed/i.test(s)) {
+      i = async function* parseMultipartMixed(e, r) {
+        var t = e.match(h);
+        var a = "--" + (t ? t[1] : "-");
+        var o = !0;
+        var n;
+        for await (var s of split(streamBody(r), "\r\n" + a)) {
+          if (o) {
+            o = !1;
+            var i = s.indexOf(a);
+            if (i > -1) {
+              s = s.slice(i + a.length);
+            } else {
+              continue;
+            }
+          }
+          try {
+            yield n = JSON.parse(s.slice(s.indexOf("\r\n\r\n") + 4));
+          } catch (e) {
+            if (!n) {
+              throw e;
+            }
+          }
+          if (n && !1 === n.hasNext) {
+            break;
+          }
+        }
+        if (n && !1 !== n.hasNext) {
+          yield {
+            hasNext: !1
+          };
+        }
+      }(s, n);
+    } else if (/text\/event-stream/i.test(s)) {
+      i = async function* parseEventStream(e) {
+        var r;
+        for await (var t of split(streamBody(e), "\n\n")) {
+          var a = t.match(m);
+          if (a) {
+            var o = a[1];
+            try {
+              yield r = JSON.parse(o);
+            } catch (e) {
+              if (!r) {
+                throw e;
+              }
+            }
+            if (r && !1 === r.hasNext) {
+              break;
+            }
+          }
+        }
+        if (r && !1 !== r.hasNext) {
+          yield {
+            hasNext: !1
+          };
+        }
+      }(n);
+    } else if (!/text\//i.test(s)) {
+      i = async function* parseJSON(e) {
+        yield JSON.parse(await e.text());
+      }(n);
+    } else {
+      i = async function* parseMaybeJSON(e) {
+        var r = await e.text();
+        try {
+          var t = JSON.parse(r);
+          if ("production" !== process.env.NODE_ENV) {
+            console.warn('Found response with content-type "text/plain" but it had a valid "application/json" response.');
+          }
+          yield t;
+        } catch (e) {
+          throw new Error(r);
+        }
+      }(n);
+    }
+    var f;
+    for await (var l of i) {
+      if (l.pending && !o) {
+        f = l.pending;
+      } else if (l.pending) {
+        f = [ ...f, ...l.pending ];
+      }
+      o = o ? mergeResultPatch(o, l, n, f) : makeResult(e, l, n);
+      a = !1;
+      yield o;
+      a = !0;
+    }
+    if (!o) {
+      yield o = makeResult(e, {}, n);
+    }
+  } catch (r) {
+    if (!a) {
+      throw r;
+    }
+    yield makeErrorResult(e, n && (n.status < 200 || n.status >= 300) && n.statusText ? new Error(n.statusText) : r, n);
+  }
+}
+
+function makeFetchSource(e, r, t) {
+  var a;
+  if ("undefined" != typeof AbortController) {
+    t.signal = (a = new AbortController).signal;
+  }
+  return onEnd((() => {
+    if (a) {
+      a.abort();
+    }
+  }))(filter((e => !!e))(fromAsyncIterable(fetchOperation(e, r, t))));
+}
+
+var collectTypes = (e, r) => {
+  if (Array.isArray(e)) {
+    for (var t of e) {
+      collectTypes(t, r);
+    }
+  } else if ("object" == typeof e && null !== e) {
+    for (var n in e) {
+      if ("__typename" === n && "string" == typeof e[n]) {
+        r.add(e[n]);
+      } else {
+        collectTypes(e[n], r);
+      }
+    }
+  }
+  return r;
+};
+
+var formatNode = r => {
+  if ("definitions" in r) {
+    var t = [];
+    for (var n of r.definitions) {
+      var a = formatNode(n);
+      t.push(a);
+    }
+    return {
+      ...r,
+      definitions: t
+    };
+  }
+  if ("directives" in r && r.directives && r.directives.length) {
+    var o = [];
+    var i = {};
+    for (var s of r.directives) {
+      var c = s.name.value;
+      if ("_" !== c[0]) {
+        o.push(s);
+      } else {
+        c = c.slice(1);
+      }
+      i[c] = s;
+    }
+    r = {
+      ...r,
+      directives: o,
+      _directives: i
+    };
+  }
+  if ("selectionSet" in r) {
+    var u = [];
+    var p = r.kind === e$2.OPERATION_DEFINITION;
+    if (r.selectionSet) {
+      for (var d of r.selectionSet.selections || []) {
+        p = p || d.kind === e$2.FIELD && "__typename" === d.name.value && !d.alias;
+        var v = formatNode(d);
+        u.push(v);
+      }
+      if (!p) {
+        u.push({
+          kind: e$2.FIELD,
+          name: {
+            kind: e$2.NAME,
+            value: "__typename"
+          },
+          _generated: !0
+        });
+      }
+      return {
+        ...r,
+        selectionSet: {
+          ...r.selectionSet,
+          selections: u
+        }
+      };
+    }
+  }
+  return r;
+};
+
+var I = new Map;
+
+var formatDocument = e => {
+  var t = keyDocument(e);
+  var n = I.get(t.__key);
+  if (!n) {
+    I.set(t.__key, n = formatNode(t));
+    Object.defineProperty(n, "__key", {
+      value: t.__key,
+      enumerable: !1
+    });
+  }
+  return n;
+};
+
+function withPromise(e) {
+  var source$ = r => e(r);
+  source$.toPromise = () => toPromise(take(1)(filter((e => !e.stale && !e.hasNext))(source$)));
+  source$.then = (e, r) => source$.toPromise().then(e, r);
+  source$.subscribe = e => subscribe(e)(source$);
+  return source$;
+}
+
+function makeOperation(e, r, t) {
+  return {
+    ...r,
+    kind: e,
+    context: r.context ? {
+      ...r.context,
+      ...t
+    } : t || r.context
+  };
+}
+
+var addMetadata = (e, r) => makeOperation(e.kind, e, {
+  meta: {
+    ...e.context.meta,
+    ...r
+  }
+});
+
+var noop = () => {};
+
+var shouldSkip = ({kind: e}) => "mutation" !== e && "query" !== e;
+
+var mapTypeNames = e => {
+  var r = formatDocument(e.query);
+  if (r !== e.query) {
+    var t = makeOperation(e.kind, e);
+    t.query = r;
+    return t;
+  } else {
+    return e;
+  }
+};
+
+var cacheExchange = ({forward: e, client: r, dispatchDebug: t}) => {
+  var a = new Map;
+  var o = new Map;
+  var isOperationCached = e => "query" === e.kind && "network-only" !== e.context.requestPolicy && ("cache-only" === e.context.requestPolicy || a.has(e.key));
+  return i => {
+    var s = map((e => {
+      var o = a.get(e.key);
+      "production" !== process.env.NODE_ENV && t({
+        operation: e,
+        ...o ? {
+          type: "cacheHit",
+          message: "The result was successfully retried from the cache"
+        } : {
+          type: "cacheMiss",
+          message: "The result could not be retrieved from the cache"
+        },
+        source: "cacheExchange"
+      });
+      var i = o || makeResult(e, {
+        data: null
+      });
+      i = {
+        ...i,
+        operation: "production" !== process.env.NODE_ENV ? addMetadata(e, {
+          cacheOutcome: o ? "hit" : "miss"
+        }) : e
+      };
+      if ("cache-and-network" === e.context.requestPolicy) {
+        i.stale = !0;
+        reexecuteOperation(r, e);
+      }
+      return i;
+    }))(filter((e => !shouldSkip(e) && isOperationCached(e)))(i));
+    var c = onPush((e => {
+      var {operation: n} = e;
+      if (!n) {
+        return;
+      }
+      var i = n.context.additionalTypenames || [];
+      if ("subscription" !== e.operation.kind) {
+        i = (e => [ ...collectTypes(e, new Set) ])(e.data).concat(i);
+      }
+      if ("mutation" === e.operation.kind || "subscription" === e.operation.kind) {
+        var s = new Set;
+        "production" !== process.env.NODE_ENV && t({
+          type: "cacheInvalidation",
+          message: `The following typenames have been invalidated: ${i}`,
+          operation: n,
+          data: {
+            typenames: i,
+            response: e
+          },
+          source: "cacheExchange"
+        });
+        for (var c = 0; c < i.length; c++) {
+          var u = i[c];
+          var p = o.get(u);
+          if (!p) {
+            o.set(u, p = new Set);
+          }
+          for (var d of p.values()) {
+            s.add(d);
+          }
+          p.clear();
+        }
+        for (var v of s.values()) {
+          if (a.has(v)) {
+            n = a.get(v).operation;
+            a.delete(v);
+            reexecuteOperation(r, n);
+          }
+        }
+      } else if ("query" === n.kind && e.data) {
+        a.set(n.key, e);
+        for (var l = 0; l < i.length; l++) {
+          var f = i[l];
+          var h = o.get(f);
+          if (!h) {
+            o.set(f, h = new Set);
+          }
+          h.add(n.key);
+        }
+      }
+    }))(e(filter((e => "query" !== e.kind || "cache-only" !== e.context.requestPolicy))(map((e => "production" !== process.env.NODE_ENV ? addMetadata(e, {
+      cacheOutcome: "miss"
+    }) : e))(merge([ map(mapTypeNames)(filter((e => !shouldSkip(e) && !isOperationCached(e)))(i)), filter((e => shouldSkip(e)))(i) ])))));
+    return merge([ s, c ]);
+  };
+};
+
+var reexecuteOperation = (e, r) => e.reexecuteOperation(makeOperation(r.kind, r, {
+  requestPolicy: "network-only"
+}));
+
+var fetchExchange = ({forward: e, dispatchDebug: r}) => t => {
+  var n = mergeMap((e => {
+    var n = makeFetchBody(e);
+    var a = makeFetchURL(e, n);
+    var i = makeFetchOptions(e, n);
+    "production" !== process.env.NODE_ENV && r({
+      type: "fetchRequest",
+      message: "A fetch request is being executed.",
+      operation: e,
+      data: {
+        url: a,
+        fetchOptions: i
+      },
+      source: "fetchExchange"
+    });
+    var s = takeUntil(filter((r => "teardown" === r.kind && r.key === e.key))(t))(makeFetchSource(e, a, i));
+    if ("production" !== process.env.NODE_ENV) {
+      return onPush((t => {
+        var n = !t.data ? t.error : void 0;
+        "production" !== process.env.NODE_ENV && r({
+          type: n ? "fetchError" : "fetchSuccess",
+          message: `A ${n ? "failed" : "successful"} fetch response has been returned.`,
+          operation: e,
+          data: {
+            url: a,
+            fetchOptions: i,
+            value: n || t
+          },
+          source: "fetchExchange"
+        });
+      }))(s);
+    }
+    return s;
+  }))(filter((e => "teardown" !== e.kind && ("subscription" !== e.kind || !!e.context.fetchSubscriptions)))(t));
+  var a = e(filter((e => "teardown" === e.kind || "subscription" === e.kind && !e.context.fetchSubscriptions))(t));
+  return merge([ n, a ]);
+};
+
+var composeExchanges = e => ({client: r, forward: t, dispatchDebug: n}) => e.reduceRight(((e, t) => {
+  var a = !1;
+  return t({
+    client: r,
+    forward(r) {
+      if ("production" !== process.env.NODE_ENV) {
+        if (a) {
+          throw new Error("forward() must only be called once in each Exchange.");
+        }
+        a = !0;
+      }
+      return share(e(share(r)));
+    },
+    dispatchDebug(e) {
+      "production" !== process.env.NODE_ENV && n({
+        timestamp: Date.now(),
+        source: t.name,
+        ...e
+      });
+    }
+  });
+}), t);
+
+var fallbackExchange = ({dispatchDebug: e}) => r => {
+  if ("production" !== process.env.NODE_ENV) {
+    r = onPush((r => {
+      if ("teardown" !== r.kind && "production" !== process.env.NODE_ENV) {
+        var t = `No exchange has handled operations of kind "${r.kind}". Check whether you've added an exchange responsible for these operations.`;
+        "production" !== process.env.NODE_ENV && e({
+          type: "fallbackCatch",
+          message: t,
+          operation: r,
+          source: "fallbackExchange"
+        });
+        console.warn(t);
+      }
+    }))(r);
+  }
+  return filter((e => !1))(r);
+};
+
+var C = function Client(e) {
+  if ("production" !== process.env.NODE_ENV && !e.url) {
+    throw new Error("You are creating an urql-client without a url.");
+  }
+  var r = 0;
+  var t = new Map;
+  var n = new Map;
+  var a = new Set;
+  var o = [];
+  var i = {
+    url: e.url,
+    fetchSubscriptions: e.fetchSubscriptions,
+    fetchOptions: e.fetchOptions,
+    fetch: e.fetch,
+    preferGetMethod: e.preferGetMethod,
+    requestPolicy: e.requestPolicy || "cache-first"
+  };
+  var s = makeSubject();
+  function nextOperation(e) {
+    if ("mutation" === e.kind || "teardown" === e.kind || !a.has(e.key)) {
+      if ("teardown" === e.kind) {
+        a.delete(e.key);
+      } else if ("mutation" !== e.kind) {
+        a.add(e.key);
+      }
+      s.next(e);
+    }
+  }
+  var c = !1;
+  function dispatchOperation(e) {
+    if (e) {
+      nextOperation(e);
+    }
+    if (!c) {
+      c = !0;
+      while (c && (e = o.shift())) {
+        nextOperation(e);
+      }
+      c = !1;
+    }
+  }
+  var makeResultSource = e => {
+    var r = takeUntil(filter((r => "teardown" === r.kind && r.key === e.key))(s.source))(filter((r => r.operation.kind === e.kind && r.operation.key === e.key && (!r.operation.context._instance || r.operation.context._instance === e.context._instance)))(O));
+    if ("query" !== e.kind) {
+      r = takeWhile((e => !!e.hasNext), !0)(r);
+    } else {
+      r = switchMap((r => {
+        var t = fromValue(r);
+        return r.stale || r.hasNext ? t : merge([ t, map((() => {
+          r.stale = !0;
+          return r;
+        }))(take(1)(filter((r => r.key === e.key))(s.source))) ]);
+      }))(r);
+    }
+    if ("mutation" !== e.kind) {
+      r = onEnd((() => {
+        a.delete(e.key);
+        t.delete(e.key);
+        n.delete(e.key);
+        c = !1;
+        for (var r = o.length - 1; r >= 0; r--) {
+          if (o[r].key === e.key) {
+            o.splice(r, 1);
+          }
+        }
+        nextOperation(makeOperation("teardown", e, e.context));
+      }))(onPush((r => {
+        if (r.stale) {
+          if (!r.hasNext) {
+            a.delete(e.key);
+          } else {
+            for (var n of o) {
+              if (n.key === r.operation.key) {
+                a.delete(n.key);
+                break;
+              }
+            }
+          }
+        } else if (!r.hasNext) {
+          a.delete(e.key);
+        }
+        t.set(e.key, r);
+      }))(r));
+    } else {
+      r = onStart((() => {
+        nextOperation(e);
+      }))(r);
+    }
+    return share(r);
+  };
+  var u = this instanceof Client ? this : Object.create(Client.prototype);
+  var p = Object.assign(u, {
+    suspense: !!e.suspense,
+    operations$: s.source,
+    reexecuteOperation(e) {
+      if ("teardown" === e.kind) {
+        dispatchOperation(e);
+      } else if ("mutation" === e.kind) {
+        o.push(e);
+        Promise.resolve().then(dispatchOperation);
+      } else if (n.has(e.key)) {
+        var r = !1;
+        for (var t = 0; t < o.length; t++) {
+          if (o[t].key === e.key) {
+            o[t] = e;
+            r = !0;
+          }
+        }
+        if (!(r || a.has(e.key) && "network-only" !== e.context.requestPolicy)) {
+          o.push(e);
+          Promise.resolve().then(dispatchOperation);
+        } else {
+          a.delete(e.key);
+          Promise.resolve().then(dispatchOperation);
+        }
+      }
+    },
+    createRequestOperation(e, t, n) {
+      if (!n) {
+        n = {};
+      }
+      var a;
+      if ("production" !== process.env.NODE_ENV && "teardown" !== e && (a = getOperationType(t.query)) !== e) {
+        throw new Error(`Expected operation of type "${e}" but found "${a}"`);
+      }
+      return makeOperation(e, t, {
+        _instance: "mutation" === e ? r = r + 1 | 0 : void 0,
+        ...i,
+        ...n,
+        requestPolicy: n.requestPolicy || i.requestPolicy,
+        suspense: n.suspense || !1 !== n.suspense && p.suspense
+      });
+    },
+    executeRequestOperation(e) {
+      if ("mutation" === e.kind) {
+        return withPromise(makeResultSource(e));
+      }
+      return withPromise(lazy((() => {
+        var r = n.get(e.key);
+        if (!r) {
+          n.set(e.key, r = makeResultSource(e));
+        }
+        r = onStart((() => {
+          dispatchOperation(e);
+        }))(r);
+        var a = t.get(e.key);
+        if ("query" === e.kind && a && (a.stale || a.hasNext)) {
+          return switchMap(fromValue)(merge([ r, filter((r => r === t.get(e.key)))(fromValue(a)) ]));
+        } else {
+          return r;
+        }
+      })));
+    },
+    executeQuery(e, r) {
+      var t = p.createRequestOperation("query", e, r);
+      return p.executeRequestOperation(t);
+    },
+    executeSubscription(e, r) {
+      var t = p.createRequestOperation("subscription", e, r);
+      return p.executeRequestOperation(t);
+    },
+    executeMutation(e, r) {
+      var t = p.createRequestOperation("mutation", e, r);
+      return p.executeRequestOperation(t);
+    },
+    readQuery(e, r, t) {
+      var n = null;
+      subscribe((e => {
+        n = e;
+      }))(p.query(e, r, t)).unsubscribe();
+      return n;
+    },
+    query: (e, r, t) => p.executeQuery(createRequest(e, r), t),
+    subscription: (e, r, t) => p.executeSubscription(createRequest(e, r), t),
+    mutation: (e, r, t) => p.executeMutation(createRequest(e, r), t)
+  });
+  var d = noop;
+  if ("production" !== process.env.NODE_ENV) {
+    var {next: f, source: x} = makeSubject();
+    p.subscribeToDebugTarget = e => subscribe(e)(x);
+    d = f;
+  }
+  var g = composeExchanges(e.exchanges);
+  var O = share(g({
+    client: p,
+    dispatchDebug: d,
+    forward: fallbackExchange({
+      dispatchDebug: d
+    })
+  })(s.source));
+  publish(O);
+  return p;
+};
+
+function initGraphQLTada() {
+  function graphql(e, i) {
+    var a = parse(e).definitions;
+    var t = new Set;
+    for (var s of i || []) {
+      for (var d of s.definitions) {
+        if (d.kind === e$2.FRAGMENT_DEFINITION && !t.has(d)) {
+          a.push(d);
+          t.add(d);
+        }
+      }
+    }
+    if (a[0].kind === e$2.FRAGMENT_DEFINITION && a[0].directives) {
+      a[0].directives = a[0].directives.filter((n => "_unmask" !== n.name.value));
+    }
+    return {
+      kind: e$2.DOCUMENT,
+      definitions: a
+    };
+  }
+  graphql.scalar = function scalar(n, r) {
+    return r;
+  };
+  graphql.persisted = function persisted(r, e) {
+    return {
+      kind: e$2.DOCUMENT,
+      definitions: e ? e.definitions : [],
+      documentId: r
+    };
+  };
+  return graphql;
+}
+
+var e = initGraphQLTada();
+
+const urqlClient = new C({
     url: CONSTANTS.ENDPOINTS["test"],
     exchanges: [cacheExchange, fetchExchange],
 });
-const fractionsByIdQuery = graphql(`
+const fractionsByIdQuery = e(`
   query fractionsById($fraction_id: String!) {
     fractions(where: { hypercert_id: { eq: $fraction_id } }) {
       data {
         creation_block_timestamp
         fraction_id
-        last_block_update_timestamp
+        last_update_block_timestamp 
         owner_address
         units
       }