@urql/core/dist/urql-core.mjs

function p(a, b) {
  void 0 === b && (b = []);
  if (Array.isArray(a)) {
    a.forEach((function c(a) {
      p(a, b);
    }));
  } else if ("object" == typeof a && null !== a) {
    for (var d in a) {
      "__typename" === d && "string" == typeof a[d] ? b.push(a[d]) : p(a[d], b);
    }
  }
  return b;
}

function q(a, b, c) {
  return c.indexOf(a) === b;
}

function r(a) {
  return a.kind === Kind.FIELD && "__typename" === a.name.value;
}

function t(a) {
  if (a.selectionSet && !a.selectionSet.selections.some(r)) {
    return _extends({}, a, {
      selectionSet: _extends({}, a.selectionSet, {
        selections: a.selectionSet.selections.concat([ {
          kind: Kind.FIELD,
          name: {
            kind: Kind.NAME,
            value: "__typename"
          }
        } ])
      })
    });
  }
}

function u(a) {
  var b = visit(a, {
    Field: t,
    InlineFragment: t
  });
  b.__key = a.__key;
  return b;
}

function v(a) {
  return a && "object" == typeof a ? Object.keys(a).reduce((function(b, c) {
    var d = a[c];
    "__typename" === c ? Object.defineProperty(b, "__typename", {
      enumerable: !1,
      value: d
    }) : Array.isArray(d) ? b[c] = d.map(v) : b[c] = d && "object" == typeof d && "__typename" in d ? v(d) : d;
    return b;
  }), {}) : a;
}

function w(a) {
  a.toPromise = function() {
    return toPromise(take(1)(a));
  };
  return a;
}

function z(a, b, c) {
  c || (c = b.context);
  return {
    key: b.key,
    query: b.query,
    variables: b.variables,
    kind: a,
    context: c,
    get operationName() {
      if ("production" !== process.env.NODE_ENV) {
        var a = y_operationName, b = a.key;
        a = a.message;
        x[b] || (console.warn("[WARNING: Deprecated] " + a), x[b] = !0);
      }
      return this.kind;
    }
  };
}

function A(a, b) {
  return z(a.kind, a, _extends({}, a.context, {
    meta: _extends({}, a.context.meta, b)
  }));
}

function B() {}

function C(a) {
  return "subscription" !== (a = a.kind) && "query" !== a;
}

function D(a) {
  return a.path || a.extensions ? {
    message: a.message,
    path: a.path,
    extensions: a.extensions
  } : a.message;
}

function E(a) {
  return "mutation" !== (a = a.kind) && "query" !== a;
}

function F(a) {
  var b = z(a.kind, a);
  b.query = u(a.query);
  return b;
}

function G(a) {
  return "query" !== a.kind || "cache-only" !== a.context.requestPolicy;
}

function H(a) {
  return A(a, {
    cacheOutcome: "miss"
  });
}

function I(a) {
  return E(a);
}

function J(a) {
  function b(a) {
    var c = a.context.requestPolicy;
    return "query" === a.kind && "network-only" !== c && ("cache-only" === c || f.has(a.key));
  }
  function c(a) {
    var b = f.get(a.key);
    "production" !== process.env.NODE_ENV && k(_extends({}, {
      operation: a
    }, b ? {
      type: "cacheHit",
      message: "The result was successfully retried from the cache"
    } : {
      type: "cacheMiss",
      message: "The result could not be retrieved from the cache"
    }));
    b = _extends({}, b, {
      operation: A(a, {
        cacheOutcome: b ? "hit" : "miss"
      })
    });
    "cache-and-network" === a.context.requestPolicy && (b.stale = !0, K(l, a));
    return b;
  }
  function d(a) {
    return !E(a) && b(a);
  }
  function e(a) {
    a.operation && "mutation" === a.operation.kind ? g(a) : a.operation && "query" === a.operation.kind && m(a);
  }
  function h(a) {
    return !E(a) && !b(a);
  }
  var g, m, n = a.forward, l = a.client, k = a.dispatchDebug, f = new Map;
  a = Object.create(null);
  g = function L(a, b, c, d) {
    function e(b) {
      if (a.has(b)) {
        var d = a.get(b).operation;
        a.delete(b);
        K(c, d);
      }
    }
    return function(a) {
      function c(a) {
        l.add(a);
      }
      var l = new Set, k = a.operation.context.additionalTypenames;
      k = p(a.data).filter(q).concat(k || []);
      "production" !== process.env.NODE_ENV && d({
        type: "cacheInvalidation",
        message: "The following typenames have been invalidated: " + k,
        operation: a.operation,
        data: {
          typenames: k,
          response: a
        },
        source: "cacheExchange"
      });
      k.forEach((function(a) {
        (a = b[a] || (b[a] = new Set)).forEach(c);
        a.clear();
      }));
      l.forEach(e);
    };
  }(f, a, l, k), m = function M(a, b) {
    return function(c) {
      var d = c.operation, e = c.data, h = d.context.additionalTypenames;
      null != e && (a.set(d.key, {
        operation: d,
        data: e,
        error: c.error
      }), p(c.data).filter(q).concat(h || []).forEach((function(a) {
        (b[a] || (b[a] = new Set)).add(d.key);
      })));
    };
  }(f, a);
  return function(a) {
    var b = share(a);
    a = map(c)(filter(d)(b));
    b = tap(e)(n(filter(G)(map(H)(merge([ map(F)(filter(h)(b)), filter(I)(b) ])))));
    return merge([ a, b ]);
  };
}

function K(a, b) {
  return a.reexecuteOperation(z(b.kind, b, _extends({}, b.context, {
    requestPolicy: "network-only"
  })));
}

function N(a) {
  return console.log("[Exchange debug]: Completed operation: ", a);
}

function O(a) {
  return console.log("[Exchange debug]: Incoming operation: ", a);
}

function P(a) {
  function b(a) {
    h.delete(a.operation.key);
  }
  function c(a) {
    var b = a.key, c = a.kind;
    if ("teardown" === c) {
      return h.delete(b), !0;
    }
    if ("query" !== c && "subscription" !== c) {
      return !0;
    }
    c = h.has(b);
    h.add(b);
    c && "production" !== process.env.NODE_ENV && e({
      type: "dedup",
      message: "An operation has been deduped.",
      operation: a,
      source: "dedupExchange"
    });
    return !c;
  }
  var d = a.forward, e = a.dispatchDebug, h = new Set;
  return function(a) {
    a = filter(c)(a);
    return tap(b)(d(a));
  };
}

function Q(a) {
  return "query" === a.kind || "mutation" === a.kind;
}

function R(a) {
  return "query" !== a.kind && "mutation" !== a.kind;
}

function S(a) {
  var b = a.forward, c = a.dispatchDebug;
  return function(a) {
    var h, d = share(a);
    a = mergeMap((function(a) {
      var b = a.key, e = filter((function(a) {
        return "teardown" === a.kind && a.key === b;
      }))(d), f = makeFetchBody(a), g = makeFetchURL(a, f), m = makeFetchOptions(a, f);
      "production" !== process.env.NODE_ENV && c({
        type: "fetchRequest",
        message: "A fetch request is being executed.",
        operation: a,
        data: {
          url: g,
          fetchOptions: m
        },
        source: "fetchExchange"
      });
      return onPush((function(b) {
        var d = b.data ? void 0 : b.error;
        "production" !== process.env.NODE_ENV && c({
          type: d ? "fetchError" : "fetchSuccess",
          message: "A " + (d ? "failed" : "successful") + " fetch response has been returned.",
          operation: a,
          data: {
            url: g,
            fetchOptions: m,
            value: d || b
          },
          source: "fetchExchange"
        });
      }))(takeUntil(e)(makeFetchSource(a, g, m)));
    }))(filter(Q)(d));
    h = b(filter(R)(d));
    return merge([ a, h ]);
  };
}

function T() {
  return !1;
}

function U(a) {
  function b(a) {
    if ("teardown" !== a.kind && "production" !== process.env.NODE_ENV) {
      var b = 'No exchange has handled operations of kind "' + a.kind + "\". Check whether you've added an exchange responsible for these operations.";
      "production" !== process.env.NODE_ENV && c({
        type: "fallbackCatch",
        message: b,
        operation: a,
        source: "fallbackExchange"
      });
      console.warn(b);
    }
  }
  var c = a.dispatchDebug;
  return function(a) {
    return filter(T)(tap(b)(a));
  };
}

function W(a) {
  return function(b) {
    var c = b.client, d = b.dispatchDebug;
    return a.reduceRight((function(a, b) {
      return b({
        client: c,
        forward: a,
        dispatchDebug: function(a) {
          "production" !== process.env.NODE_ENV && d(_extends({}, {
            timestamp: Date.now(),
            source: b.name
          }, a));
        }
      });
    }), b.forward);
  };
}

function Y(a) {
  var d, e, h, n, l, c = this;
  this.activeOperations = Object.create(null);
  this.queue = [];
  this.createOperationContext = function(a) {
    a || (a = {});
    return _extends({}, {
      url: c.url,
      fetchOptions: c.fetchOptions,
      fetch: c.fetch,
      preferGetMethod: c.preferGetMethod
    }, a, {
      suspense: a.suspense || !1 !== a.suspense && c.suspense,
      requestPolicy: a.requestPolicy || c.requestPolicy
    });
  };
  this.createRequestOperation = function(a, b, d) {
    return z(a, b, c.createOperationContext(d));
  };
  this.executeQuery = function(a, b) {
    a = c.createRequestOperation("query", a, b);
    return c.executeRequestOperation(a);
  };
  this.executeSubscription = function(a, b) {
    a = c.createRequestOperation("subscription", a, b);
    return c.executeRequestOperation(a);
  };
  this.executeMutation = function(a, b) {
    a = c.createRequestOperation("mutation", a, b);
    return c.executeRequestOperation(a);
  };
  if ("production" !== process.env.NODE_ENV && !a.url) {
    throw Error("You are creating an urql-client without a url.");
  }
  d = B;
  if ("production" !== process.env.NODE_ENV) {
    e = (d = makeSubject()).next, h = d.source;
    this.subscribeToDebugTarget = function b(a) {
      return subscribe(a)(h);
    };
    d = e;
  }
  this.url = a.url;
  this.fetchOptions = a.fetchOptions;
  this.fetch = a.fetch;
  this.suspense = !!a.suspense;
  this.requestPolicy = a.requestPolicy || "cache-first";
  this.preferGetMethod = !!a.preferGetMethod;
  this.maskTypename = !!a.maskTypename;
  e = makeSubject();
  n = e.next;
  this.operations$ = e.source;
  l = !1;
  this.dispatchOperation = function(a) {
    l = !0;
    for (a && n(a); a = c.queue.shift(); ) {
      n(a);
    }
    l = !1;
  };
  this.reexecuteOperation = function(a) {
    if ("mutation" === a.kind || 0 < (c.activeOperations[a.key] || 0)) {
      c.queue.push(a), l || Promise.resolve().then(c.dispatchOperation);
    }
  };
  a = W(void 0 !== a.exchanges ? a.exchanges : X);
  this.results$ = share(a({
    client: this,
    dispatchDebug: d,
    forward: U({
      dispatchDebug: d
    })
  })(this.operations$));
  publish(this.results$);
}

function Z(a) {
  a.data = v(a.data);
  return a;
}

function createClient(a) {
  return new Y(a);
}

function debugExchange(a) {
  var d = a.forward;
  return "production" === process.env.NODE_ENV ? function b(a) {
    return d(a);
  } : function c(a) {
    return tap(N)(d(tap(O)(a)));
  };
}

function errorExchange(a) {
  function b(a) {
    var b = a.error;
    a = a.operation;
    b && c(b, a);
  }
  var c = a.onError;
  return function(a) {
    var c = a.forward;
    return function(a) {
      return tap(b)(c(a));
    };
  };
}

function ssrExchange(a) {
  function b(b) {
    var c = b.client, m = b.forward;
    return function(b) {
      var e = a && "boolean" == typeof a.isClient ? !!a.isClient : !c.suspense, g = share(b);
      b = m(filter(h)(g));
      g = map(n)(filter(l)(g));
      e ? g = tap(d)(g) : b = tap(k)(b);
      return merge([ b, g ]);
    };
  }
  function c(a) {
    return !C(a) && void 0 !== f[a.key];
  }
  function d(a) {
    g.push(a.operation.key);
    1 === g.length && Promise.resolve().then(e);
  }
  function e() {
    for (var a; a = g.shift(); ) {
      delete f[a];
    }
  }
  function h(a) {
    return !c(a);
  }
  function n(a) {
    var b = f[a.key], c = b.error;
    return {
      operation: a,
      data: (b = b.data) ? JSON.parse(b) : void 0,
      extensions: void 0,
      error: c ? new CombinedError({
        networkError: c.networkError ? Error(c.networkError) : void 0,
        graphQLErrors: c.graphQLErrors && c.graphQLErrors.length ? c.graphQLErrors : void 0
      }) : void 0
    };
  }
  function l(a) {
    return c(a);
  }
  function k(a) {
    var c, b = a.operation;
    if (!C(b)) {
      c = a.error;
      a = {
        data: JSON.stringify(a.data),
        error: void 0
      };
      c && (a.error = {
        graphQLErrors: c.graphQLErrors.map(D),
        networkError: c.networkError ? "" + c.networkError : void 0
      });
      f[b.key] = a;
    }
  }
  var f = {}, g = [];
  b.restoreData = function(a) {
    return _extends(f, a);
  };
  b.extractData = function() {
    return _extends({}, f);
  };
  a && a.initialState && b.restoreData(a.initialState);
  return b;
}

function subscriptionExchange(a) {
  function b(a) {
    return "subscription" === (a = a.kind) || !!d && ("query" === a || "mutation" === a);
  }
  var c = a.forwardSubscription, d = a.enableAllOperations;
  return function(a) {
    function d(a) {
      var b = c({
        key: a.key.toString(36),
        query: print(a.query),
        variables: a.variables,
        context: _extends({}, a.context)
      });
      return make((function(c) {
        function d(b) {
          return f(makeResult(a, b));
        }
        function e(b) {
          return f(makeErrorResult(a, b));
        }
        function g() {
          k || (k = !0, "subscription" === a.kind && l.reexecuteOperation(z("teardown", a, a.context)), 
          h());
        }
        var m, f = c.next, h = c.complete, k = !1;
        Promise.resolve().then((function() {
          k || (m = b.subscribe({
            next: d,
            error: e,
            complete: g
          }));
        }));
        return function() {
          k = !0;
          m && m.unsubscribe();
        };
      }));
    }
    function e(a) {
      return !f(a);
    }
    var l = a.client, k = a.forward, f = b;
    return function(a) {
      var c, b = share(a);
      a = mergeMap((function(a) {
        var c = a.key, e = filter((function(a) {
          return "teardown" === a.kind && a.key === c;
        }))(b);
        return takeUntil(e)(d(a));
      }))(filter(f)(b));
      c = k(filter(e)(b));
      return merge([ a, c ]);
    };
  };
}

var x, y_operationName, V, X;

import { visit } from "graphql/language/visitor.mjs";

import { Kind } from "graphql/language/kinds.mjs";

import { print } from "graphql/language/printer.mjs";

import { toPromise, take, share, filter, map, tap, merge, mergeMap, takeUntil, make, onPush, makeSubject, publish, onStart, onEnd, switchMap, fromValue, interval, subscribe } from "wonka";

import { _ as _extends, C as CombinedError, m as makeResult, a as makeErrorResult, b as makeFetchBody, c as makeFetchURL, d as makeFetchOptions, e as makeFetchSource, f as createRequest } from "./231258ed.mjs";

export { C as CombinedError, f as createRequest, a as makeErrorResult, m as makeResult, s as stringifyVariables } from "./231258ed.mjs";

x = {}, y_operationName = {
  key: "Operation.operationName",
  message: 'The "Operation.operationName" property has been deprecated and will be removed in a future release of urql. Use "Operation.kind" instead.'
};

V = U({
  dispatchDebug: B
});

X = [ P, J, S ];

Y.prototype.onOperationStart = function(a) {
  var b = a.key;
  this.activeOperations[b] = (this.activeOperations[b] || 0) + 1;
  this.dispatchOperation(a);
};

Y.prototype.onOperationEnd = function(a) {
  var b = a.key, c = this.activeOperations[b] || 0;
  if (0 >= (this.activeOperations[b] = 0 >= c ? 0 : c - 1)) {
    for (b = this.queue.length - 1; 0 <= b; b--) {
      this.queue[b].key === a.key && this.queue.splice(b, 1);
    }
    this.dispatchOperation(z("teardown", a, a.context));
  }
};

Y.prototype.executeRequestOperation = function(a) {
  var h, n, d = this, e = filter((function(b) {
    return b.operation.key === a.key;
  }))(this.results$);
  this.maskTypename && (e = map(Z)(e));
  if ("mutation" === a.kind) {
    return take(1)(onStart((function b() {
      return d.dispatchOperation(a);
    }))(e));
  }
  h = filter((function(b) {
    return "teardown" === b.kind && b.key === a.key;
  }))(this.operations$), n = onEnd((function() {
    d.onOperationEnd(a);
  }))(onStart((function() {
    d.onOperationStart(a);
  }))(takeUntil(h)(e)));
  return "query" === a.kind && a.context.pollInterval ? switchMap((function c() {
    return n;
  }))(merge([ fromValue(0), interval(a.context.pollInterval) ])) : n;
};

Y.prototype.query = function(a, b, c) {
  c && "boolean" == typeof c.suspense || (c = _extends({}, c, {
    suspense: !1
  }));
  return w(this.executeQuery(createRequest(a, b), c));
};

Y.prototype.readQuery = function(a, b, c) {
  var d = null;
  subscribe((function(a) {
    d = a;
  }))(this.executeQuery(createRequest(a, b), c)).unsubscribe();
  return d;
};

Y.prototype.subscription = function(a, b, c) {
  return this.executeSubscription(createRequest(a, b), c);
};

Y.prototype.mutation = function(a, b, c) {
  return w(this.executeMutation(createRequest(a, b), c));
};

export { Y as Client, J as cacheExchange, W as composeExchanges, createClient, debugExchange, P as dedupExchange, X as defaultExchanges, errorExchange, V as fallbackExchangeIO, S as fetchExchange, u as formatDocument, z as makeOperation, v as maskTypename, ssrExchange, subscriptionExchange };
//# sourceMappingURL=urql-core.mjs.map