@sanity/client 3.3.0 → 4.0.0-alpha.esm.3

package/dist/browser/sanityClient.js

@@ -0,0 +1,2243 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+
+// node_modules/nano-pubsub/index.js
+var require_nano_pubsub = __commonJS({
+  "node_modules/nano-pubsub/index.js"(exports, module) {
+    module.exports = function Pubsub() {
+      var subscribers = [];
+      return {
+        subscribe,
+        publish
+      };
+      function subscribe(subscriber) {
+        subscribers.push(subscriber);
+        return function unsubscribe() {
+          var idx = subscribers.indexOf(subscriber);
+          if (idx > -1) {
+            subscribers.splice(idx, 1);
+          }
+        };
+      }
+      function publish() {
+        for (var i = 0; i < subscribers.length; i++) {
+          subscribers[i].apply(null, arguments);
+        }
+      }
+    };
+  }
+});
+
+// node_modules/get-it/lib/util/middlewareReducer.js
+var require_middlewareReducer = __commonJS({
+  "node_modules/get-it/lib/util/middlewareReducer.js"(exports, module) {
+    "use strict";
+    module.exports = function(middleware3) {
+      var applyMiddleware = function applyMiddleware2(hook, defaultValue) {
+        var bailEarly = hook === "onError";
+        var value = defaultValue;
+        for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+          args[_key - 2] = arguments[_key];
+        }
+        for (var i = 0; i < middleware3[hook].length; i++) {
+          var handler = middleware3[hook][i];
+          value = handler.apply(void 0, [value].concat(args));
+          if (bailEarly && !value) {
+            break;
+          }
+        }
+        return value;
+      };
+      return applyMiddleware;
+    };
+  }
+});
+
+// node_modules/object-assign/index.js
+var require_object_assign = __commonJS({
+  "node_modules/object-assign/index.js"(exports, module) {
+    "use strict";
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+    function toObject(val) {
+      if (val === null || val === void 0) {
+        throw new TypeError("Object.assign cannot be called with null or undefined");
+      }
+      return Object(val);
+    }
+    function shouldUseNative() {
+      try {
+        if (!Object.assign) {
+          return false;
+        }
+        var test1 = new String("abc");
+        test1[5] = "de";
+        if (Object.getOwnPropertyNames(test1)[0] === "5") {
+          return false;
+        }
+        var test2 = {};
+        for (var i = 0; i < 10; i++) {
+          test2["_" + String.fromCharCode(i)] = i;
+        }
+        var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
+          return test2[n];
+        });
+        if (order2.join("") !== "0123456789") {
+          return false;
+        }
+        var test3 = {};
+        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+          test3[letter] = letter;
+        });
+        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+          return false;
+        }
+        return true;
+      } catch (err) {
+        return false;
+      }
+    }
+    module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+      var from;
+      var to = toObject(target);
+      var symbols;
+      for (var s = 1; s < arguments.length; s++) {
+        from = Object(arguments[s]);
+        for (var key in from) {
+          if (hasOwnProperty.call(from, key)) {
+            to[key] = from[key];
+          }
+        }
+        if (getOwnPropertySymbols) {
+          symbols = getOwnPropertySymbols(from);
+          for (var i = 0; i < symbols.length; i++) {
+            if (propIsEnumerable.call(from, symbols[i])) {
+              to[symbols[i]] = from[symbols[i]];
+            }
+          }
+        }
+      }
+      return to;
+    };
+  }
+});
+
+// node_modules/requires-port/index.js
+var require_requires_port = __commonJS({
+  "node_modules/requires-port/index.js"(exports, module) {
+    "use strict";
+    module.exports = function required(port, protocol) {
+      protocol = protocol.split(":")[0];
+      port = +port;
+      if (!port)
+        return false;
+      switch (protocol) {
+        case "http":
+        case "ws":
+          return port !== 80;
+        case "https":
+        case "wss":
+          return port !== 443;
+        case "ftp":
+          return port !== 21;
+        case "gopher":
+          return port !== 70;
+        case "file":
+          return false;
+      }
+      return port !== 0;
+    };
+  }
+});
+
+// node_modules/querystringify/index.js
+var require_querystringify = __commonJS({
+  "node_modules/querystringify/index.js"(exports) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var undef;
+    function decode(input) {
+      try {
+        return decodeURIComponent(input.replace(/\+/g, " "));
+      } catch (e) {
+        return null;
+      }
+    }
+    function encode(input) {
+      try {
+        return encodeURIComponent(input);
+      } catch (e) {
+        return null;
+      }
+    }
+    function querystring(query) {
+      var parser = /([^=?#&]+)=?([^&]*)/g, result = {}, part;
+      while (part = parser.exec(query)) {
+        var key = decode(part[1]), value = decode(part[2]);
+        if (key === null || value === null || key in result)
+          continue;
+        result[key] = value;
+      }
+      return result;
+    }
+    function querystringify(obj, prefix) {
+      prefix = prefix || "";
+      var pairs = [], value, key;
+      if (typeof prefix !== "string")
+        prefix = "?";
+      for (key in obj) {
+        if (has.call(obj, key)) {
+          value = obj[key];
+          if (!value && (value === null || value === undef || isNaN(value))) {
+            value = "";
+          }
+          key = encode(key);
+          value = encode(value);
+          if (key === null || value === null)
+            continue;
+          pairs.push(key + "=" + value);
+        }
+      }
+      return pairs.length ? prefix + pairs.join("&") : "";
+    }
+    exports.stringify = querystringify;
+    exports.parse = querystring;
+  }
+});
+
+// node_modules/url-parse/index.js
+var require_url_parse = __commonJS({
+  "node_modules/url-parse/index.js"(exports, module) {
+    "use strict";
+    var required = require_requires_port();
+    var qs = require_querystringify();
+    var controlOrWhitespace = /^[\x00-\x20\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/;
+    var CRHTLF = /[\n\r\t]/g;
+    var slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//;
+    var port = /:\d+$/;
+    var protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\\/]+)?([\S\s]*)/i;
+    var windowsDriveLetter = /^[a-zA-Z]:/;
+    function trimLeft(str) {
+      return (str ? str : "").toString().replace(controlOrWhitespace, "");
+    }
+    var rules = [
+      ["#", "hash"],
+      ["?", "query"],
+      function sanitize(address, url) {
+        return isSpecial(url.protocol) ? address.replace(/\\/g, "/") : address;
+      },
+      ["/", "pathname"],
+      ["@", "auth", 1],
+      [NaN, "host", void 0, 1, 1],
+      [/:(\d*)$/, "port", void 0, 1],
+      [NaN, "hostname", void 0, 1, 1]
+    ];
+    var ignore = { hash: 1, query: 1 };
+    function lolcation(loc) {
+      var globalVar;
+      if (typeof window !== "undefined")
+        globalVar = window;
+      else if (typeof global !== "undefined")
+        globalVar = global;
+      else if (typeof self !== "undefined")
+        globalVar = self;
+      else
+        globalVar = {};
+      var location = globalVar.location || {};
+      loc = loc || location;
+      var finaldestination = {}, type = typeof loc, key;
+      if (loc.protocol === "blob:") {
+        finaldestination = new Url(unescape(loc.pathname), {});
+      } else if (type === "string") {
+        finaldestination = new Url(loc, {});
+        for (key in ignore)
+          delete finaldestination[key];
+      } else if (type === "object") {
+        for (key in loc) {
+          if (key in ignore)
+            continue;
+          finaldestination[key] = loc[key];
+        }
+        if (finaldestination.slashes === void 0) {
+          finaldestination.slashes = slashes.test(loc.href);
+        }
+      }
+      return finaldestination;
+    }
+    function isSpecial(scheme) {
+      return scheme === "file:" || scheme === "ftp:" || scheme === "http:" || scheme === "https:" || scheme === "ws:" || scheme === "wss:";
+    }
+    function extractProtocol(address, location) {
+      address = trimLeft(address);
+      address = address.replace(CRHTLF, "");
+      location = location || {};
+      var match = protocolre.exec(address);
+      var protocol = match[1] ? match[1].toLowerCase() : "";
+      var forwardSlashes = !!match[2];
+      var otherSlashes = !!match[3];
+      var slashesCount = 0;
+      var rest;
+      if (forwardSlashes) {
+        if (otherSlashes) {
+          rest = match[2] + match[3] + match[4];
+          slashesCount = match[2].length + match[3].length;
+        } else {
+          rest = match[2] + match[4];
+          slashesCount = match[2].length;
+        }
+      } else {
+        if (otherSlashes) {
+          rest = match[3] + match[4];
+          slashesCount = match[3].length;
+        } else {
+          rest = match[4];
+        }
+      }
+      if (protocol === "file:") {
+        if (slashesCount >= 2) {
+          rest = rest.slice(2);
+        }
+      } else if (isSpecial(protocol)) {
+        rest = match[4];
+      } else if (protocol) {
+        if (forwardSlashes) {
+          rest = rest.slice(2);
+        }
+      } else if (slashesCount >= 2 && isSpecial(location.protocol)) {
+        rest = match[4];
+      }
+      return {
+        protocol,
+        slashes: forwardSlashes || isSpecial(protocol),
+        slashesCount,
+        rest
+      };
+    }
+    function resolve(relative, base) {
+      if (relative === "")
+        return base;
+      var path = (base || "/").split("/").slice(0, -1).concat(relative.split("/")), i = path.length, last = path[i - 1], unshift = false, up = 0;
+      while (i--) {
+        if (path[i] === ".") {
+          path.splice(i, 1);
+        } else if (path[i] === "..") {
+          path.splice(i, 1);
+          up++;
+        } else if (up) {
+          if (i === 0)
+            unshift = true;
+          path.splice(i, 1);
+          up--;
+        }
+      }
+      if (unshift)
+        path.unshift("");
+      if (last === "." || last === "..")
+        path.push("");
+      return path.join("/");
+    }
+    function Url(address, location, parser) {
+      address = trimLeft(address);
+      address = address.replace(CRHTLF, "");
+      if (!(this instanceof Url)) {
+        return new Url(address, location, parser);
+      }
+      var relative, extracted, parse, instruction, index, key, instructions = rules.slice(), type = typeof location, url = this, i = 0;
+      if (type !== "object" && type !== "string") {
+        parser = location;
+        location = null;
+      }
+      if (parser && typeof parser !== "function")
+        parser = qs.parse;
+      location = lolcation(location);
+      extracted = extractProtocol(address || "", location);
+      relative = !extracted.protocol && !extracted.slashes;
+      url.slashes = extracted.slashes || relative && location.slashes;
+      url.protocol = extracted.protocol || location.protocol || "";
+      address = extracted.rest;
+      if (extracted.protocol === "file:" && (extracted.slashesCount !== 2 || windowsDriveLetter.test(address)) || !extracted.slashes && (extracted.protocol || extracted.slashesCount < 2 || !isSpecial(url.protocol))) {
+        instructions[3] = [/(.*)/, "pathname"];
+      }
+      for (; i < instructions.length; i++) {
+        instruction = instructions[i];
+        if (typeof instruction === "function") {
+          address = instruction(address, url);
+          continue;
+        }
+        parse = instruction[0];
+        key = instruction[1];
+        if (parse !== parse) {
+          url[key] = address;
+        } else if (typeof parse === "string") {
+          index = parse === "@" ? address.lastIndexOf(parse) : address.indexOf(parse);
+          if (~index) {
+            if (typeof instruction[2] === "number") {
+              url[key] = address.slice(0, index);
+              address = address.slice(index + instruction[2]);
+            } else {
+              url[key] = address.slice(index);
+              address = address.slice(0, index);
+            }
+          }
+        } else if (index = parse.exec(address)) {
+          url[key] = index[1];
+          address = address.slice(0, index.index);
+        }
+        url[key] = url[key] || (relative && instruction[3] ? location[key] || "" : "");
+        if (instruction[4])
+          url[key] = url[key].toLowerCase();
+      }
+      if (parser)
+        url.query = parser(url.query);
+      if (relative && location.slashes && url.pathname.charAt(0) !== "/" && (url.pathname !== "" || location.pathname !== "")) {
+        url.pathname = resolve(url.pathname, location.pathname);
+      }
+      if (url.pathname.charAt(0) !== "/" && isSpecial(url.protocol)) {
+        url.pathname = "/" + url.pathname;
+      }
+      if (!required(url.port, url.protocol)) {
+        url.host = url.hostname;
+        url.port = "";
+      }
+      url.username = url.password = "";
+      if (url.auth) {
+        index = url.auth.indexOf(":");
+        if (~index) {
+          url.username = url.auth.slice(0, index);
+          url.username = encodeURIComponent(decodeURIComponent(url.username));
+          url.password = url.auth.slice(index + 1);
+          url.password = encodeURIComponent(decodeURIComponent(url.password));
+        } else {
+          url.username = encodeURIComponent(decodeURIComponent(url.auth));
+        }
+        url.auth = url.password ? url.username + ":" + url.password : url.username;
+      }
+      url.origin = url.protocol !== "file:" && isSpecial(url.protocol) && url.host ? url.protocol + "//" + url.host : "null";
+      url.href = url.toString();
+    }
+    function set(part, value, fn) {
+      var url = this;
+      switch (part) {
+        case "query":
+          if (typeof value === "string" && value.length) {
+            value = (fn || qs.parse)(value);
+          }
+          url[part] = value;
+          break;
+        case "port":
+          url[part] = value;
+          if (!required(value, url.protocol)) {
+            url.host = url.hostname;
+            url[part] = "";
+          } else if (value) {
+            url.host = url.hostname + ":" + value;
+          }
+          break;
+        case "hostname":
+          url[part] = value;
+          if (url.port)
+            value += ":" + url.port;
+          url.host = value;
+          break;
+        case "host":
+          url[part] = value;
+          if (port.test(value)) {
+            value = value.split(":");
+            url.port = value.pop();
+            url.hostname = value.join(":");
+          } else {
+            url.hostname = value;
+            url.port = "";
+          }
+          break;
+        case "protocol":
+          url.protocol = value.toLowerCase();
+          url.slashes = !fn;
+          break;
+        case "pathname":
+        case "hash":
+          if (value) {
+            var char = part === "pathname" ? "/" : "#";
+            url[part] = value.charAt(0) !== char ? char + value : value;
+          } else {
+            url[part] = value;
+          }
+          break;
+        case "username":
+        case "password":
+          url[part] = encodeURIComponent(value);
+          break;
+        case "auth":
+          var index = value.indexOf(":");
+          if (~index) {
+            url.username = value.slice(0, index);
+            url.username = encodeURIComponent(decodeURIComponent(url.username));
+            url.password = value.slice(index + 1);
+            url.password = encodeURIComponent(decodeURIComponent(url.password));
+          } else {
+            url.username = encodeURIComponent(decodeURIComponent(value));
+          }
+      }
+      for (var i = 0; i < rules.length; i++) {
+        var ins = rules[i];
+        if (ins[4])
+          url[ins[1]] = url[ins[1]].toLowerCase();
+      }
+      url.auth = url.password ? url.username + ":" + url.password : url.username;
+      url.origin = url.protocol !== "file:" && isSpecial(url.protocol) && url.host ? url.protocol + "//" + url.host : "null";
+      url.href = url.toString();
+      return url;
+    }
+    function toString(stringify) {
+      if (!stringify || typeof stringify !== "function")
+        stringify = qs.stringify;
+      var query, url = this, host = url.host, protocol = url.protocol;
+      if (protocol && protocol.charAt(protocol.length - 1) !== ":")
+        protocol += ":";
+      var result = protocol + (url.protocol && url.slashes || isSpecial(url.protocol) ? "//" : "");
+      if (url.username) {
+        result += url.username;
+        if (url.password)
+          result += ":" + url.password;
+        result += "@";
+      } else if (url.password) {
+        result += ":" + url.password;
+        result += "@";
+      } else if (url.protocol !== "file:" && isSpecial(url.protocol) && !host && url.pathname !== "/") {
+        result += "@";
+      }
+      if (host[host.length - 1] === ":" || port.test(url.hostname) && !url.port) {
+        host += ":";
+      }
+      result += host + url.pathname;
+      query = typeof url.query === "object" ? stringify(url.query) : url.query;
+      if (query)
+        result += query.charAt(0) !== "?" ? "?" + query : query;
+      if (url.hash)
+        result += url.hash;
+      return result;
+    }
+    Url.prototype = { set, toString };
+    Url.extractProtocol = extractProtocol;
+    Url.location = lolcation;
+    Url.trimLeft = trimLeft;
+    Url.qs = qs;
+    module.exports = Url;
+  }
+});
+
+// node_modules/get-it/lib/middleware/defaultOptionsProcessor.js
+var require_defaultOptionsProcessor = __commonJS({
+  "node_modules/get-it/lib/middleware/defaultOptionsProcessor.js"(exports, module) {
+    "use strict";
+    var objectAssign = require_object_assign();
+    var urlParse = require_url_parse();
+    var isReactNative = typeof navigator === "undefined" ? false : navigator.product === "ReactNative";
+    var has = Object.prototype.hasOwnProperty;
+    var defaultOptions2 = {
+      timeout: isReactNative ? 6e4 : 12e4
+    };
+    module.exports = function(opts) {
+      var options = typeof opts === "string" ? objectAssign({
+        url: opts
+      }, defaultOptions2) : objectAssign({}, defaultOptions2, opts);
+      var url = urlParse(options.url, {}, true);
+      options.timeout = normalizeTimeout(options.timeout);
+      if (options.query) {
+        url.query = objectAssign({}, url.query, removeUndefined(options.query));
+      }
+      options.method = options.body && !options.method ? "POST" : (options.method || "GET").toUpperCase();
+      options.url = url.toString(stringifyQueryString);
+      return options;
+    };
+    function stringifyQueryString(obj) {
+      var pairs = [];
+      for (var key in obj) {
+        if (has.call(obj, key)) {
+          push(key, obj[key]);
+        }
+      }
+      return pairs.length ? pairs.join("&") : "";
+      function push(key2, val) {
+        if (Array.isArray(val)) {
+          val.forEach(function(item) {
+            return push(key2, item);
+          });
+        } else {
+          pairs.push([key2, val].map(encodeURIComponent).join("="));
+        }
+      }
+    }
+    function normalizeTimeout(time) {
+      if (time === false || time === 0) {
+        return false;
+      }
+      if (time.connect || time.socket) {
+        return time;
+      }
+      var delay = Number(time);
+      if (isNaN(delay)) {
+        return normalizeTimeout(defaultOptions2.timeout);
+      }
+      return {
+        connect: delay,
+        socket: delay
+      };
+    }
+    function removeUndefined(obj) {
+      var target = {};
+      for (var key in obj) {
+        if (obj[key] !== void 0) {
+          target[key] = obj[key];
+        }
+      }
+      return target;
+    }
+  }
+});
+
+// node_modules/get-it/lib/middleware/defaultOptionsValidator.js
+var require_defaultOptionsValidator = __commonJS({
+  "node_modules/get-it/lib/middleware/defaultOptionsValidator.js"(exports, module) {
+    "use strict";
+    var validUrl = /^https?:\/\//i;
+    module.exports = function(options) {
+      if (!validUrl.test(options.url)) {
+        throw new Error('"'.concat(options.url, '" is not a valid URL'));
+      }
+    };
+  }
+});
+
+// node_modules/same-origin/url-parser.js
+var require_url_parser = __commonJS({
+  "node_modules/same-origin/url-parser.js"(exports, module) {
+    "use strict";
+    var regex = /^(?:(?:(?:([^:\/#\?]+:)?(?:(?:\/\/)((?:((?:[^:@\/#\?]+)(?:\:(?:[^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((?:\/?(?:[^\/\?#]+\/+)*)(?:[^\?#]*)))?(\?[^#]+)?)(#.*)?/;
+    module.exports = {
+      regex,
+      parse: function(url) {
+        var match = regex.exec(url);
+        if (!match) {
+          return {};
+        }
+        return {
+          protocol: (match[1] || "").toLowerCase() || void 0,
+          hostname: (match[5] || "").toLowerCase() || void 0,
+          port: match[6] || void 0
+        };
+      }
+    };
+  }
+});
+
+// node_modules/same-origin/index.js
+var require_same_origin = __commonJS({
+  "node_modules/same-origin/index.js"(exports, module) {
+    "use strict";
+    var url = require_url_parser();
+    module.exports = function(uri1, uri2, ieMode) {
+      if (uri1 === uri2) {
+        return true;
+      }
+      var url1 = url.parse(uri1, false, true);
+      var url2 = url.parse(uri2, false, true);
+      var url1Port = url1.port | 0 || (url1.protocol === "https" ? 443 : 80);
+      var url2Port = url2.port | 0 || (url2.protocol === "https" ? 443 : 80);
+      var match = {
+        proto: url1.protocol === url2.protocol,
+        hostname: url1.hostname === url2.hostname,
+        port: url1Port === url2Port
+      };
+      return match.proto && match.hostname && (match.port || ieMode);
+    };
+  }
+});
+
+// node_modules/parse-headers/parse-headers.js
+var require_parse_headers = __commonJS({
+  "node_modules/parse-headers/parse-headers.js"(exports, module) {
+    var trim = function(string) {
+      return string.replace(/^\s+|\s+$/g, "");
+    };
+    var isArray = function(arg) {
+      return Object.prototype.toString.call(arg) === "[object Array]";
+    };
+    module.exports = function(headers) {
+      if (!headers)
+        return {};
+      var result = {};
+      var headersArr = trim(headers).split("\n");
+      for (var i = 0; i < headersArr.length; i++) {
+        var row = headersArr[i];
+        var index = row.indexOf(":"), key = trim(row.slice(0, index)).toLowerCase(), value = trim(row.slice(index + 1));
+        if (typeof result[key] === "undefined") {
+          result[key] = value;
+        } else if (isArray(result[key])) {
+          result[key].push(value);
+        } else {
+          result[key] = [result[key], value];
+        }
+      }
+      return result;
+    };
+  }
+});
+
+// node_modules/get-it/lib/request/browser/fetchXhr.js
+var require_fetchXhr = __commonJS({
+  "node_modules/get-it/lib/request/browser/fetchXhr.js"(exports, module) {
+    "use strict";
+    function FetchXhr() {
+      this.readyState = 0;
+    }
+    FetchXhr.prototype.open = function(method, url) {
+      this._method = method;
+      this._url = url;
+      this._resHeaders = "";
+      this.readyState = 1;
+      this.onreadystatechange();
+    };
+    FetchXhr.prototype.abort = function() {
+      if (this._controller) {
+        this._controller.abort();
+      }
+    };
+    FetchXhr.prototype.getAllResponseHeaders = function() {
+      return this._resHeaders;
+    };
+    FetchXhr.prototype.setRequestHeader = function(key, value) {
+      this._headers = this._headers || {};
+      this._headers[key] = value;
+    };
+    FetchXhr.prototype.send = function(body) {
+      var _this = this;
+      var ctrl = this._controller = typeof AbortController === "function" && new AbortController();
+      var textBody = this.responseType !== "arraybuffer";
+      var options = {
+        method: this._method,
+        headers: this._headers,
+        signal: ctrl && ctrl.signal,
+        body
+      };
+      if (typeof window !== "undefined") {
+        options.credentials = this.withCredentials ? "include" : "omit";
+      }
+      fetch(this._url, options).then(function(res) {
+        res.headers.forEach(function(value, key) {
+          _this._resHeaders += "".concat(key, ": ").concat(value, "\r\n");
+        });
+        _this.status = res.status;
+        _this.statusText = res.statusText;
+        _this.readyState = 3;
+        return textBody ? res.text() : res.arrayBuffer();
+      }).then(function(resBody) {
+        if (textBody) {
+          _this.responseText = resBody;
+        } else {
+          _this.response = resBody;
+        }
+        _this.readyState = 4;
+        _this.onreadystatechange();
+      }).catch(function(err) {
+        if (err.name === "AbortError") {
+          _this.onabort();
+          return;
+        }
+        _this.onerror(err);
+      });
+    };
+    module.exports = FetchXhr;
+  }
+});
+
+// node_modules/get-it/lib/request/browser-request.js
+var require_browser_request = __commonJS({
+  "node_modules/get-it/lib/request/browser-request.js"(exports, module) {
+    "use strict";
+    var sameOrigin = require_same_origin();
+    var parseHeaders = require_parse_headers();
+    var FetchXhr = require_fetchXhr();
+    var noop = function noop2() {
+    };
+    var win = typeof window === "undefined" ? void 0 : window;
+    var adapter = win ? "xhr" : "fetch";
+    var XmlHttpRequest = typeof XMLHttpRequest === "function" ? XMLHttpRequest : noop;
+    var hasXhr2 = "withCredentials" in new XmlHttpRequest();
+    var XDR = typeof XDomainRequest === "undefined" ? void 0 : XDomainRequest;
+    var CrossDomainRequest = hasXhr2 ? XmlHttpRequest : XDR;
+    if (!win) {
+      XmlHttpRequest = FetchXhr;
+      CrossDomainRequest = FetchXhr;
+    }
+    module.exports = function(context, callback) {
+      var opts = context.options;
+      var options = context.applyMiddleware("finalizeOptions", opts);
+      var timers = {};
+      var cors = win && win.location && !sameOrigin(win.location.href, options.url);
+      var injectedResponse = context.applyMiddleware("interceptRequest", void 0, {
+        adapter,
+        context
+      });
+      if (injectedResponse) {
+        var cbTimer = setTimeout(callback, 0, null, injectedResponse);
+        var cancel = function cancel2() {
+          return clearTimeout(cbTimer);
+        };
+        return {
+          abort: cancel
+        };
+      }
+      var xhr = cors ? new CrossDomainRequest() : new XmlHttpRequest();
+      var isXdr = win && win.XDomainRequest && xhr instanceof win.XDomainRequest;
+      var headers = options.headers;
+      var delays = options.timeout;
+      var aborted = false;
+      var loaded = false;
+      var timedOut = false;
+      xhr.onerror = onError;
+      xhr.ontimeout = onError;
+      xhr.onabort = function() {
+        stopTimers(true);
+        aborted = true;
+      };
+      xhr.onprogress = function() {
+      };
+      var loadEvent = isXdr ? "onload" : "onreadystatechange";
+      xhr[loadEvent] = function() {
+        resetTimers();
+        if (aborted || xhr.readyState !== 4 && !isXdr) {
+          return;
+        }
+        if (xhr.status === 0) {
+          return;
+        }
+        onLoad();
+      };
+      xhr.open(options.method, options.url, true);
+      xhr.withCredentials = !!options.withCredentials;
+      if (headers && xhr.setRequestHeader) {
+        for (var key in headers) {
+          if (headers.hasOwnProperty(key)) {
+            xhr.setRequestHeader(key, headers[key]);
+          }
+        }
+      } else if (headers && isXdr) {
+        throw new Error("Headers cannot be set on an XDomainRequest object");
+      }
+      if (options.rawBody) {
+        xhr.responseType = "arraybuffer";
+      }
+      context.applyMiddleware("onRequest", {
+        options,
+        adapter,
+        request: xhr,
+        context
+      });
+      xhr.send(options.body || null);
+      if (delays) {
+        timers.connect = setTimeout(function() {
+          return timeoutRequest("ETIMEDOUT");
+        }, delays.connect);
+      }
+      return {
+        abort
+      };
+      function abort() {
+        aborted = true;
+        if (xhr) {
+          xhr.abort();
+        }
+      }
+      function timeoutRequest(code) {
+        timedOut = true;
+        xhr.abort();
+        var error = new Error(code === "ESOCKETTIMEDOUT" ? "Socket timed out on request to ".concat(options.url) : "Connection timed out on request to ".concat(options.url));
+        error.code = code;
+        context.channels.error.publish(error);
+      }
+      function resetTimers() {
+        if (!delays) {
+          return;
+        }
+        stopTimers();
+        timers.socket = setTimeout(function() {
+          return timeoutRequest("ESOCKETTIMEDOUT");
+        }, delays.socket);
+      }
+      function stopTimers(force) {
+        if (force || aborted || xhr.readyState >= 2 && timers.connect) {
+          clearTimeout(timers.connect);
+        }
+        if (timers.socket) {
+          clearTimeout(timers.socket);
+        }
+      }
+      function onError(error) {
+        if (loaded) {
+          return;
+        }
+        stopTimers(true);
+        loaded = true;
+        xhr = null;
+        var err = error || new Error("Network error while attempting to reach ".concat(options.url));
+        err.isNetworkError = true;
+        err.request = options;
+        callback(err);
+      }
+      function reduceResponse() {
+        var statusCode = xhr.status;
+        var statusMessage = xhr.statusText;
+        if (isXdr && statusCode === void 0) {
+          statusCode = 200;
+        } else if (statusCode > 12e3 && statusCode < 12156) {
+          return onError();
+        } else {
+          statusCode = xhr.status === 1223 ? 204 : xhr.status;
+          statusMessage = xhr.status === 1223 ? "No Content" : statusMessage;
+        }
+        return {
+          body: xhr.response || xhr.responseText,
+          url: options.url,
+          method: options.method,
+          headers: isXdr ? {} : parseHeaders(xhr.getAllResponseHeaders()),
+          statusCode,
+          statusMessage
+        };
+      }
+      function onLoad() {
+        if (aborted || loaded || timedOut) {
+          return;
+        }
+        if (xhr.status === 0) {
+          onError(new Error("Unknown XHR error"));
+          return;
+        }
+        stopTimers();
+        loaded = true;
+        callback(null, reduceResponse());
+      }
+    };
+  }
+});
+
+// node_modules/get-it/lib/request/index.js
+var require_request = __commonJS({
+  "node_modules/get-it/lib/request/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_browser_request();
+  }
+});
+
+// node_modules/get-it/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/get-it/lib/index.js"(exports, module) {
+    "use strict";
+    var pubsub = require_nano_pubsub();
+    var middlewareReducer = require_middlewareReducer();
+    var processOptions = require_defaultOptionsProcessor();
+    var validateOptions = require_defaultOptionsValidator();
+    var httpRequester = require_request();
+    var channelNames = ["request", "response", "progress", "error", "abort"];
+    var middlehooks = ["processOptions", "validateOptions", "interceptRequest", "finalizeOptions", "onRequest", "onResponse", "onError", "onReturn", "onHeaders"];
+    module.exports = function createRequester() {
+      var initMiddleware = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+      var httpRequest2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : httpRequester;
+      var loadedMiddleware = [];
+      var middleware3 = middlehooks.reduce(function(ware, name) {
+        ware[name] = ware[name] || [];
+        return ware;
+      }, {
+        processOptions: [processOptions],
+        validateOptions: [validateOptions]
+      });
+      function request2(opts) {
+        var channels = channelNames.reduce(function(target, name) {
+          target[name] = pubsub();
+          return target;
+        }, {});
+        var applyMiddleware = middlewareReducer(middleware3);
+        var options = applyMiddleware("processOptions", opts);
+        applyMiddleware("validateOptions", options);
+        var context = {
+          options,
+          channels,
+          applyMiddleware
+        };
+        var ongoingRequest = null;
+        var unsubscribe = channels.request.subscribe(function(ctx) {
+          ongoingRequest = httpRequest2(ctx, function(err, res) {
+            return onResponse(err, res, ctx);
+          });
+        });
+        channels.abort.subscribe(function() {
+          unsubscribe();
+          if (ongoingRequest) {
+            ongoingRequest.abort();
+          }
+        });
+        var returnValue = applyMiddleware("onReturn", channels, context);
+        if (returnValue === channels) {
+          channels.request.publish(context);
+        }
+        return returnValue;
+        function onResponse(reqErr, res, ctx) {
+          var error = reqErr;
+          var response = res;
+          if (!error) {
+            try {
+              response = applyMiddleware("onResponse", res, ctx);
+            } catch (err) {
+              response = null;
+              error = err;
+            }
+          }
+          error = error && applyMiddleware("onError", error, ctx);
+          if (error) {
+            channels.error.publish(error);
+          } else if (response) {
+            channels.response.publish(response);
+          }
+        }
+      }
+      request2.use = function use(newMiddleware) {
+        if (!newMiddleware) {
+          throw new Error("Tried to add middleware that resolved to falsey value");
+        }
+        if (typeof newMiddleware === "function") {
+          throw new Error("Tried to add middleware that was a function. It probably expects you to pass options to it.");
+        }
+        if (newMiddleware.onReturn && middleware3.onReturn.length > 0) {
+          throw new Error("Tried to add new middleware with `onReturn` handler, but another handler has already been registered for this event");
+        }
+        middlehooks.forEach(function(key) {
+          if (newMiddleware[key]) {
+            middleware3[key].push(newMiddleware[key]);
+          }
+        });
+        loadedMiddleware.push(newMiddleware);
+        return request2;
+      };
+      request2.clone = function clone() {
+        return createRequester(loadedMiddleware);
+      };
+      initMiddleware.forEach(request2.use);
+      return request2;
+    };
+  }
+});
+
+// node_modules/get-it/index.js
+var require_get_it = __commonJS({
+  "node_modules/get-it/index.js"(exports, module) {
+    module.exports = require_lib();
+  }
+});
+
+// node_modules/get-it/lib/util/global.js
+var require_global = __commonJS({
+  "node_modules/get-it/lib/util/global.js"(exports, module) {
+    "use strict";
+    if (typeof globalThis !== "undefined") {
+      module.exports = globalThis;
+    } else if (typeof window !== "undefined") {
+      module.exports = window;
+    } else if (typeof global !== "undefined") {
+      module.exports = global;
+    } else if (typeof self !== "undefined") {
+      module.exports = self;
+    } else {
+      module.exports = {};
+    }
+  }
+});
+
+// node_modules/get-it/lib/middleware/observable.js
+var require_observable = __commonJS({
+  "node_modules/get-it/lib/middleware/observable.js"(exports, module) {
+    "use strict";
+    var global2 = require_global();
+    var objectAssign = require_object_assign();
+    module.exports = function() {
+      var opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      var Observable2 = opts.implementation || global2.Observable;
+      if (!Observable2) {
+        throw new Error("`Observable` is not available in global scope, and no implementation was passed");
+      }
+      return {
+        onReturn: function onReturn(channels, context) {
+          return new Observable2(function(observer) {
+            channels.error.subscribe(function(err) {
+              return observer.error(err);
+            });
+            channels.progress.subscribe(function(event) {
+              return observer.next(objectAssign({
+                type: "progress"
+              }, event));
+            });
+            channels.response.subscribe(function(response) {
+              observer.next(objectAssign({
+                type: "response"
+              }, response));
+              observer.complete();
+            });
+            channels.request.publish(context);
+            return function() {
+              return channels.abort.publish();
+            };
+          });
+        }
+      };
+    };
+  }
+});
+
+// node_modules/isobject/index.js
+var require_isobject = __commonJS({
+  "node_modules/isobject/index.js"(exports, module) {
+    "use strict";
+    module.exports = function isObject(val) {
+      return val != null && typeof val === "object" && Array.isArray(val) === false;
+    };
+  }
+});
+
+// node_modules/is-plain-object/index.js
+var require_is_plain_object = __commonJS({
+  "node_modules/is-plain-object/index.js"(exports, module) {
+    "use strict";
+    var isObject = require_isobject();
+    function isObjectObject(o) {
+      return isObject(o) === true && Object.prototype.toString.call(o) === "[object Object]";
+    }
+    module.exports = function isPlainObject(o) {
+      var ctor, prot;
+      if (isObjectObject(o) === false)
+        return false;
+      ctor = o.constructor;
+      if (typeof ctor !== "function")
+        return false;
+      prot = ctor.prototype;
+      if (isObjectObject(prot) === false)
+        return false;
+      if (prot.hasOwnProperty("isPrototypeOf") === false) {
+        return false;
+      }
+      return true;
+    };
+  }
+});
+
+// node_modules/get-it/lib/middleware/jsonRequest.js
+var require_jsonRequest = __commonJS({
+  "node_modules/get-it/lib/middleware/jsonRequest.js"(exports, module) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    var objectAssign = require_object_assign();
+    var isPlainObject = require_is_plain_object();
+    var serializeTypes = ["boolean", "string", "number"];
+    var isBuffer = function isBuffer2(obj) {
+      return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+    };
+    module.exports = function() {
+      return {
+        processOptions: function processOptions(options) {
+          var body = options.body;
+          if (!body) {
+            return options;
+          }
+          var isStream = typeof body.pipe === "function";
+          var shouldSerialize = !isStream && !isBuffer(body) && (serializeTypes.indexOf(_typeof(body)) !== -1 || Array.isArray(body) || isPlainObject(body));
+          if (!shouldSerialize) {
+            return options;
+          }
+          return objectAssign({}, options, {
+            body: JSON.stringify(options.body),
+            headers: objectAssign({}, options.headers, {
+              "Content-Type": "application/json"
+            })
+          });
+        }
+      };
+    };
+  }
+});
+
+// node_modules/get-it/lib/middleware/jsonResponse.js
+var require_jsonResponse = __commonJS({
+  "node_modules/get-it/lib/middleware/jsonResponse.js"(exports, module) {
+    "use strict";
+    var objectAssign = require_object_assign();
+    module.exports = function(opts) {
+      return {
+        onResponse: function onResponse(response) {
+          var contentType = response.headers["content-type"] || "";
+          var shouldDecode = opts && opts.force || contentType.indexOf("application/json") !== -1;
+          if (!response.body || !contentType || !shouldDecode) {
+            return response;
+          }
+          return objectAssign({}, response, {
+            body: tryParse(response.body)
+          });
+        },
+        processOptions: function processOptions(options) {
+          return objectAssign({}, options, {
+            headers: objectAssign({
+              Accept: "application/json"
+            }, options.headers)
+          });
+        }
+      };
+    };
+    function tryParse(body) {
+      try {
+        return JSON.parse(body);
+      } catch (err) {
+        err.message = "Failed to parsed response body as JSON: ".concat(err.message);
+        throw err;
+      }
+    }
+  }
+});
+
+// node_modules/get-it/lib/middleware/progress/browser-progress.js
+var require_browser_progress = __commonJS({
+  "node_modules/get-it/lib/middleware/progress/browser-progress.js"(exports, module) {
+    "use strict";
+    module.exports = function() {
+      return {
+        onRequest: function onRequest(evt) {
+          if (evt.adapter !== "xhr") {
+            return;
+          }
+          var xhr = evt.request;
+          var context = evt.context;
+          if ("upload" in xhr && "onprogress" in xhr.upload) {
+            xhr.upload.onprogress = handleProgress("upload");
+          }
+          if ("onprogress" in xhr) {
+            xhr.onprogress = handleProgress("download");
+          }
+          function handleProgress(stage) {
+            return function(event) {
+              var percent = event.lengthComputable ? event.loaded / event.total * 100 : -1;
+              context.channels.progress.publish({
+                stage,
+                percent,
+                total: event.total,
+                loaded: event.loaded,
+                lengthComputable: event.lengthComputable
+              });
+            };
+          }
+        }
+      };
+    };
+  }
+});
+
+// node_modules/get-it/lib/middleware/progress/index.js
+var require_progress = __commonJS({
+  "node_modules/get-it/lib/middleware/progress/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_browser_progress();
+  }
+});
+
+// src/util/observable.js
+import { Observable } from "rxjs/internal/Observable";
+import { filter } from "rxjs/internal/operators/filter";
+import { map } from "rxjs/internal/operators/map";
+
+// src/util/getSelection.js
+function getSelection(sel) {
+  if (typeof sel === "string" || Array.isArray(sel)) {
+    return { id: sel };
+  }
+  if (sel && sel.query) {
+    return "params" in sel ? { query: sel.query, params: sel.params } : { query: sel.query };
+  }
+  const selectionOpts = [
+    "* Document ID (<docId>)",
+    "* Array of document IDs",
+    "* Object containing `query`"
+  ].join("\n");
+  throw new Error(`Unknown selection - must be one of:
+
+${selectionOpts}`);
+}
+
+// src/validators.js
+var VALID_ASSET_TYPES = ["image", "file"];
+var VALID_INSERT_LOCATIONS = ["before", "after", "replace"];
+var dataset = (name) => {
+  if (!/^(~[a-z0-9]{1}[-\w]{0,63}|[a-z0-9]{1}[-\w]{0,63})$/.test(name)) {
+    throw new Error("Datasets can only contain lowercase characters, numbers, underscores and dashes, and start with tilde, and be maximum 64 characters");
+  }
+};
+var projectId = (id) => {
+  if (!/^[-a-z0-9]+$/i.test(id)) {
+    throw new Error("`projectId` can only contain only a-z, 0-9 and dashes");
+  }
+};
+var validateAssetType = (type) => {
+  if (VALID_ASSET_TYPES.indexOf(type) === -1) {
+    throw new Error(`Invalid asset type: ${type}. Must be one of ${VALID_ASSET_TYPES.join(", ")}`);
+  }
+};
+var validateObject = (op, val) => {
+  if (val === null || typeof val !== "object" || Array.isArray(val)) {
+    throw new Error(`${op}() takes an object of properties`);
+  }
+};
+var validateDocumentId = (op, id) => {
+  if (typeof id !== "string" || !/^[a-z0-9_.-]+$/i.test(id)) {
+    throw new Error(`${op}(): "${id}" is not a valid document ID`);
+  }
+};
+var requireDocumentId = (op, doc) => {
+  if (!doc._id) {
+    throw new Error(`${op}() requires that the document contains an ID ("_id" property)`);
+  }
+  validateDocumentId(op, doc._id);
+};
+var validateInsert = (at, selector, items) => {
+  const signature = "insert(at, selector, items)";
+  if (VALID_INSERT_LOCATIONS.indexOf(at) === -1) {
+    const valid = VALID_INSERT_LOCATIONS.map((loc) => `"${loc}"`).join(", ");
+    throw new Error(`${signature} takes an "at"-argument which is one of: ${valid}`);
+  }
+  if (typeof selector !== "string") {
+    throw new Error(`${signature} takes a "selector"-argument which must be a string`);
+  }
+  if (!Array.isArray(items)) {
+    throw new Error(`${signature} takes an "items"-argument which must be an array`);
+  }
+};
+var hasDataset = (config) => {
+  if (!config.dataset) {
+    throw new Error("`dataset` must be provided to perform queries");
+  }
+  return config.dataset || "";
+};
+var requestTag = (tag) => {
+  if (typeof tag !== "string" || !/^[a-z0-9._-]{1,75}$/i.test(tag)) {
+    throw new Error(`Tag can only contain alphanumeric characters, underscores, dashes and dots, and be between one and 75 characters long.`);
+  }
+  return tag;
+};
+
+// src/data/patch.js
+var Patch = class {
+  constructor(selection, operations = {}, client = null) {
+    this.selection = selection;
+    this.operations = Object.assign({}, operations);
+    this.client = client;
+  }
+  clone() {
+    return new Patch(this.selection, Object.assign({}, this.operations), this.client);
+  }
+  set(props) {
+    return this._assign("set", props);
+  }
+  diffMatchPatch(props) {
+    validateObject("diffMatchPatch", props);
+    return this._assign("diffMatchPatch", props);
+  }
+  unset(attrs) {
+    if (!Array.isArray(attrs)) {
+      throw new Error("unset(attrs) takes an array of attributes to unset, non-array given");
+    }
+    this.operations = Object.assign({}, this.operations, { unset: attrs });
+    return this;
+  }
+  setIfMissing(props) {
+    return this._assign("setIfMissing", props);
+  }
+  replace(props) {
+    validateObject("replace", props);
+    return this._set("set", { $: props });
+  }
+  inc(props) {
+    return this._assign("inc", props);
+  }
+  dec(props) {
+    return this._assign("dec", props);
+  }
+  insert(at, selector, items) {
+    validateInsert(at, selector, items);
+    return this._assign("insert", { [at]: selector, items });
+  }
+  append(selector, items) {
+    return this.insert("after", `${selector}[-1]`, items);
+  }
+  prepend(selector, items) {
+    return this.insert("before", `${selector}[0]`, items);
+  }
+  splice(selector, start, deleteCount, items) {
+    const delAll = typeof deleteCount === "undefined" || deleteCount === -1;
+    const startIndex = start < 0 ? start - 1 : start;
+    const delCount = delAll ? -1 : Math.max(0, start + deleteCount);
+    const delRange = startIndex < 0 && delCount >= 0 ? "" : delCount;
+    const rangeSelector = `${selector}[${startIndex}:${delRange}]`;
+    return this.insert("replace", rangeSelector, items || []);
+  }
+  ifRevisionId(rev) {
+    this.operations.ifRevisionID = rev;
+    return this;
+  }
+  serialize() {
+    return Object.assign(getSelection(this.selection), this.operations);
+  }
+  toJSON() {
+    return this.serialize();
+  }
+  commit(options = {}) {
+    if (!this.client) {
+      throw new Error("No `client` passed to patch, either provide one or pass the patch to a clients `mutate()` method");
+    }
+    const returnFirst = typeof this.selection === "string";
+    const opts = Object.assign({ returnFirst, returnDocuments: true }, options);
+    return this.client.mutate({ patch: this.serialize() }, opts);
+  }
+  reset() {
+    this.operations = {};
+    return this;
+  }
+  _set(op, props) {
+    return this._assign(op, props, false);
+  }
+  _assign(op, props, merge = true) {
+    validateObject(op, props);
+    this.operations = Object.assign({}, this.operations, {
+      [op]: Object.assign({}, merge && this.operations[op] || {}, props)
+    });
+    return this;
+  }
+};
+
+// src/data/transaction.js
+var defaultMutateOptions = { returnDocuments: false };
+var Transaction = class {
+  constructor(operations = [], client, transactionId) {
+    this.trxId = transactionId;
+    this.operations = operations;
+    this.client = client;
+  }
+  clone() {
+    return new Transaction(this.operations.slice(0), this.client, this.trxId);
+  }
+  create(doc) {
+    validateObject("create", doc);
+    return this._add({ create: doc });
+  }
+  createIfNotExists(doc) {
+    const op = "createIfNotExists";
+    validateObject(op, doc);
+    requireDocumentId(op, doc);
+    return this._add({ [op]: doc });
+  }
+  createOrReplace(doc) {
+    const op = "createOrReplace";
+    validateObject(op, doc);
+    requireDocumentId(op, doc);
+    return this._add({ [op]: doc });
+  }
+  delete(documentId) {
+    validateDocumentId("delete", documentId);
+    return this._add({ delete: { id: documentId } });
+  }
+  patch(documentId, patchOps) {
+    const isBuilder = typeof patchOps === "function";
+    const isPatch = documentId instanceof Patch;
+    if (isPatch) {
+      return this._add({ patch: documentId.serialize() });
+    }
+    if (isBuilder) {
+      const patch = patchOps(new Patch(documentId, {}, this.client));
+      if (!(patch instanceof Patch)) {
+        throw new Error("function passed to `patch()` must return the patch");
+      }
+      return this._add({ patch: patch.serialize() });
+    }
+    return this._add({ patch: Object.assign({ id: documentId }, patchOps) });
+  }
+  transactionId(id) {
+    if (!id) {
+      return this.trxId;
+    }
+    this.trxId = id;
+    return this;
+  }
+  serialize() {
+    return this.operations.slice();
+  }
+  toJSON() {
+    return this.serialize();
+  }
+  commit(options) {
+    if (!this.client) {
+      throw new Error("No `client` passed to transaction, either provide one or pass the transaction to a clients `mutate()` method");
+    }
+    return this.client.mutate(this.serialize(), Object.assign({ transactionId: this.trxId }, defaultMutateOptions, options || {}));
+  }
+  reset() {
+    this.operations = [];
+    return this;
+  }
+  _add(mut) {
+    this.operations.push(mut);
+    return this;
+  }
+};
+
+// src/data/encodeQueryString.js
+var enc = encodeURIComponent;
+var encodeQueryString = ({ query, params = {}, options = {} }) => {
+  const { tag, ...opts } = options;
+  const q = `query=${enc(query)}`;
+  const base = tag ? `?tag=${enc(tag)}&${q}` : `?${q}`;
+  const qString = Object.keys(params).reduce((qs, param) => `${qs}&${enc(`$${param}`)}=${enc(JSON.stringify(params[param]))}`, base);
+  return Object.keys(opts).reduce((qs, option) => {
+    return options[option] ? `${qs}&${enc(option)}=${enc(options[option])}` : qs;
+  }, qString);
+};
+
+// src/data/listen.js
+import polyfilledEventSource from "@sanity/eventsource";
+
+// src/util/pick.js
+var pick = (obj, props) => props.reduce((selection, prop) => {
+  if (typeof obj[prop] === "undefined") {
+    return selection;
+  }
+  selection[prop] = obj[prop];
+  return selection;
+}, {});
+
+// src/util/defaults.js
+var defaults = (obj, defaults2) => Object.keys(defaults2).concat(Object.keys(obj)).reduce((target, prop) => {
+  target[prop] = typeof obj[prop] === "undefined" ? defaults2[prop] : obj[prop];
+  return target;
+}, {});
+
+// src/data/listen.js
+var MAX_URL_LENGTH = 16e3 - 1200;
+var EventSource = polyfilledEventSource;
+var possibleOptions = [
+  "includePreviousRevision",
+  "includeResult",
+  "visibility",
+  "effectFormat",
+  "tag"
+];
+var defaultOptions = {
+  includeResult: true
+};
+function listen(query, params, opts = {}) {
+  const { url, token, withCredentials, requestTagPrefix } = this.clientConfig;
+  const tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join(".") : opts.tag;
+  const options = { ...defaults(opts, defaultOptions), tag };
+  const listenOpts = pick(options, possibleOptions);
+  const qs = encodeQueryString({ query, params, options: listenOpts, tag });
+  const uri = `${url}${this.getDataUrl("listen", qs)}`;
+  if (uri.length > MAX_URL_LENGTH) {
+    return new Observable((observer) => observer.error(new Error("Query too large for listener")));
+  }
+  const listenFor = options.events ? options.events : ["mutation"];
+  const shouldEmitReconnect = listenFor.indexOf("reconnect") !== -1;
+  const esOptions = {};
+  if (token || withCredentials) {
+    esOptions.withCredentials = true;
+  }
+  if (token) {
+    esOptions.headers = {
+      Authorization: `Bearer ${token}`
+    };
+  }
+  return new Observable((observer) => {
+    let es = getEventSource();
+    let reconnectTimer;
+    let stopped = false;
+    function onError() {
+      if (stopped) {
+        return;
+      }
+      emitReconnect();
+      if (stopped) {
+        return;
+      }
+      if (es.readyState === EventSource.CLOSED) {
+        unsubscribe();
+        clearTimeout(reconnectTimer);
+        reconnectTimer = setTimeout(open, 100);
+      }
+    }
+    function onChannelError(err) {
+      observer.error(cooerceError(err));
+    }
+    function onMessage(evt) {
+      const event = parseEvent(evt);
+      return event instanceof Error ? observer.error(event) : observer.next(event);
+    }
+    function onDisconnect(evt) {
+      stopped = true;
+      unsubscribe();
+      observer.complete();
+    }
+    function unsubscribe() {
+      es.removeEventListener("error", onError, false);
+      es.removeEventListener("channelError", onChannelError, false);
+      es.removeEventListener("disconnect", onDisconnect, false);
+      listenFor.forEach((type) => es.removeEventListener(type, onMessage, false));
+      es.close();
+    }
+    function emitReconnect() {
+      if (shouldEmitReconnect) {
+        observer.next({ type: "reconnect" });
+      }
+    }
+    function getEventSource() {
+      const evs = new EventSource(uri, esOptions);
+      evs.addEventListener("error", onError, false);
+      evs.addEventListener("channelError", onChannelError, false);
+      evs.addEventListener("disconnect", onDisconnect, false);
+      listenFor.forEach((type) => evs.addEventListener(type, onMessage, false));
+      return evs;
+    }
+    function open() {
+      es = getEventSource();
+    }
+    function stop() {
+      stopped = true;
+      unsubscribe();
+    }
+    return stop;
+  });
+}
+function parseEvent(event) {
+  try {
+    const data = event.data && JSON.parse(event.data) || {};
+    return Object.assign({ type: event.type }, data);
+  } catch (err) {
+    return err;
+  }
+}
+function cooerceError(err) {
+  if (err instanceof Error) {
+    return err;
+  }
+  const evt = parseEvent(err);
+  return evt instanceof Error ? evt : new Error(extractErrorMessage(evt));
+}
+function extractErrorMessage(err) {
+  if (!err.error) {
+    return err.message || "Unknown listener error";
+  }
+  if (err.error.description) {
+    return err.error.description;
+  }
+  return typeof err.error === "string" ? err.error : JSON.stringify(err.error, null, 2);
+}
+
+// src/data/dataMethods.js
+var excludeFalsey = (param, defValue) => {
+  const value = typeof param === "undefined" ? defValue : param;
+  return param === false ? void 0 : value;
+};
+var getMutationQuery = (options = {}) => {
+  return {
+    dryRun: options.dryRun,
+    returnIds: true,
+    returnDocuments: excludeFalsey(options.returnDocuments, true),
+    visibility: options.visibility || "sync",
+    autoGenerateArrayKeys: options.autoGenerateArrayKeys,
+    skipCrossDatasetReferenceValidation: options.skipCrossDatasetReferenceValidation
+  };
+};
+var isResponse = (event) => event.type === "response";
+var getBody = (event) => event.body;
+var indexBy = (docs, attr) => docs.reduce((indexed, doc) => {
+  indexed[attr(doc)] = doc;
+  return indexed;
+}, /* @__PURE__ */ Object.create(null));
+var toPromise = (observable2) => observable2.toPromise();
+var getQuerySizeLimit = 11264;
+var dataMethods = {
+  listen,
+  getDataUrl(operation, path) {
+    const config = this.clientConfig;
+    const catalog = hasDataset(config);
+    const baseUri = `/${operation}/${catalog}`;
+    const uri = path ? `${baseUri}/${path}` : baseUri;
+    return `/data${uri}`.replace(/\/($|\?)/, "$1");
+  },
+  fetch(query, params, options = {}) {
+    const mapResponse = options.filterResponse === false ? (res) => res : (res) => res.result;
+    const observable2 = this._dataRequest("query", { query, params }, options).pipe(map(mapResponse));
+    return this.isPromiseAPI() ? toPromise(observable2) : observable2;
+  },
+  getDocument(id, opts = {}) {
+    const options = { uri: this.getDataUrl("doc", id), json: true, tag: opts.tag };
+    const observable2 = this._requestObservable(options).pipe(filter(isResponse), map((event) => event.body.documents && event.body.documents[0]));
+    return this.isPromiseAPI() ? toPromise(observable2) : observable2;
+  },
+  getDocuments(ids, opts = {}) {
+    const options = { uri: this.getDataUrl("doc", ids.join(",")), json: true, tag: opts.tag };
+    const observable2 = this._requestObservable(options).pipe(filter(isResponse), map((event) => {
+      const indexed = indexBy(event.body.documents || [], (doc) => doc._id);
+      return ids.map((id) => indexed[id] || null);
+    }));
+    return this.isPromiseAPI() ? toPromise(observable2) : observable2;
+  },
+  create(doc, options) {
+    return this._create(doc, "create", options);
+  },
+  createIfNotExists(doc, options) {
+    requireDocumentId("createIfNotExists", doc);
+    return this._create(doc, "createIfNotExists", options);
+  },
+  createOrReplace(doc, options) {
+    requireDocumentId("createOrReplace", doc);
+    return this._create(doc, "createOrReplace", options);
+  },
+  patch(selector, operations) {
+    return new Patch(selector, operations, this);
+  },
+  delete(selection, options) {
+    return this.dataRequest("mutate", { mutations: [{ delete: getSelection(selection) }] }, options);
+  },
+  mutate(mutations, options) {
+    const mut = mutations instanceof Patch || mutations instanceof Transaction ? mutations.serialize() : mutations;
+    const muts = Array.isArray(mut) ? mut : [mut];
+    const transactionId = options && options.transactionId;
+    return this.dataRequest("mutate", { mutations: muts, transactionId }, options);
+  },
+  transaction(operations) {
+    return new Transaction(operations, this);
+  },
+  dataRequest(endpoint, body, options = {}) {
+    const request2 = this._dataRequest(endpoint, body, options);
+    return this.isPromiseAPI() ? toPromise(request2) : request2;
+  },
+  _dataRequest(endpoint, body, options = {}) {
+    const isMutation = endpoint === "mutate";
+    const isQuery = endpoint === "query";
+    const strQuery = !isMutation && encodeQueryString(body);
+    const useGet = !isMutation && strQuery.length < getQuerySizeLimit;
+    const stringQuery = useGet ? strQuery : "";
+    const returnFirst = options.returnFirst;
+    const { timeout, token, tag, headers } = options;
+    const uri = this.getDataUrl(endpoint, stringQuery);
+    const reqOptions = {
+      method: useGet ? "GET" : "POST",
+      uri,
+      json: true,
+      body: useGet ? void 0 : body,
+      query: isMutation && getMutationQuery(options),
+      timeout,
+      headers,
+      token,
+      tag,
+      canUseCdn: isQuery
+    };
+    return this._requestObservable(reqOptions).pipe(filter(isResponse), map(getBody), map((res) => {
+      if (!isMutation) {
+        return res;
+      }
+      const results = res.results || [];
+      if (options.returnDocuments) {
+        return returnFirst ? results[0] && results[0].document : results.map((mut) => mut.document);
+      }
+      const key = returnFirst ? "documentId" : "documentIds";
+      const ids = returnFirst ? results[0] && results[0].id : results.map((mut) => mut.id);
+      return {
+        transactionId: res.transactionId,
+        results,
+        [key]: ids
+      };
+    }));
+  },
+  _create(doc, op, options = {}) {
+    const mutation = { [op]: doc };
+    const opts = Object.assign({ returnFirst: true, returnDocuments: true }, options);
+    return this.dataRequest("mutate", { mutations: [mutation] }, opts);
+  }
+};
+
+// src/datasets/datasetsClient.js
+var DatasetsClient = class {
+  constructor(client) {
+    this.request = client.request.bind(client);
+  }
+  create(name, options) {
+    return this._modify("PUT", name, options);
+  }
+  edit(name, options) {
+    return this._modify("PATCH", name, options);
+  }
+  delete(name) {
+    return this._modify("DELETE", name);
+  }
+  list() {
+    return this.request({ uri: "/datasets" });
+  }
+  _modify(method, name, body) {
+    dataset(name);
+    return this.request({ method, uri: `/datasets/${name}`, body });
+  }
+};
+
+// src/projects/projectsClient.js
+var ProjectsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  list() {
+    return this.client.request({ uri: "/projects" });
+  }
+  getById(id) {
+    return this.client.request({ uri: `/projects/${id}` });
+  }
+};
+
+// src/http/queryString.js
+var queryString = (params) => {
+  const qs = [];
+  for (const key in params) {
+    if (params.hasOwnProperty(key)) {
+      qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`);
+    }
+  }
+  return qs.length > 0 ? `?${qs.join("&")}` : "";
+};
+
+// src/assets/assetsClient.js
+var AssetsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  upload(assetType, body, opts = {}) {
+    validateAssetType(assetType);
+    let meta = opts.extract || void 0;
+    if (meta && !meta.length) {
+      meta = ["none"];
+    }
+    const dataset2 = hasDataset(this.client.clientConfig);
+    const assetEndpoint = assetType === "image" ? "images" : "files";
+    const options = optionsFromFile(opts, body);
+    const { tag, label, title, description, creditLine, filename, source } = options;
+    const query = {
+      label,
+      title,
+      description,
+      filename,
+      meta,
+      creditLine
+    };
+    if (source) {
+      query.sourceId = source.id;
+      query.sourceName = source.name;
+      query.sourceUrl = source.url;
+    }
+    const observable2 = this.client._requestObservable({
+      tag,
+      method: "POST",
+      timeout: options.timeout || 0,
+      uri: `/assets/${assetEndpoint}/${dataset2}`,
+      headers: options.contentType ? { "Content-Type": options.contentType } : {},
+      query,
+      body
+    });
+    return this.client.isPromiseAPI() ? observable2.pipe(filter((event) => event.type === "response"), map((event) => event.body.document)).toPromise() : observable2;
+  }
+  delete(type, id) {
+    console.warn("client.assets.delete() is deprecated, please use client.delete(<document-id>)");
+    let docId = id || "";
+    if (!/^(image|file)-/.test(docId)) {
+      docId = `${type}-${docId}`;
+    } else if (type._id) {
+      docId = type._id;
+    }
+    hasDataset(this.client.clientConfig);
+    return this.client.delete(docId);
+  }
+  getImageUrl(ref, query) {
+    const id = ref._ref || ref;
+    if (typeof id !== "string") {
+      throw new Error("getImageUrl() needs either an object with a _ref, or a string with an asset document ID");
+    }
+    if (!/^image-[A-Za-z0-9_]+-\d+x\d+-[a-z]{1,5}$/.test(id)) {
+      throw new Error(`Unsupported asset ID "${id}". URL generation only works for auto-generated IDs.`);
+    }
+    const [, assetId, size, format] = id.split("-");
+    hasDataset(this.client.clientConfig);
+    const { projectId: projectId2, dataset: dataset2 } = this.client.clientConfig;
+    const qs = query ? queryString(query) : "";
+    return `https://cdn.sanity.io/images/${projectId2}/${dataset2}/${assetId}-${size}.${format}${qs}`;
+  }
+};
+function optionsFromFile(opts, file) {
+  if (typeof window === "undefined" || !(file instanceof window.File)) {
+    return opts;
+  }
+  return Object.assign({
+    filename: opts.preserveFilename === false ? void 0 : file.name,
+    contentType: file.type
+  }, opts);
+}
+
+// src/users/usersClient.js
+var UsersClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getById(id) {
+    return this.client.request({ uri: `/users/${id}` });
+  }
+};
+
+// src/auth/authClient.js
+var AuthClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getLoginProviders() {
+    return this.client.request({ uri: "/auth/providers" });
+  }
+  logout() {
+    return this.client.request({ uri: "/auth/logout", method: "POST" });
+  }
+};
+
+// src/http/request.js
+var import_get_it = __toESM(require_get_it());
+var import_observable4 = __toESM(require_observable());
+var import_jsonRequest = __toESM(require_jsonRequest());
+var import_jsonResponse = __toESM(require_jsonResponse());
+var import_progress = __toESM(require_progress());
+
+// src/http/errors.js
+import makeError from "make-error";
+function ClientError(res) {
+  const props = extractErrorProps(res);
+  ClientError.super.call(this, props.message);
+  Object.assign(this, props);
+}
+function ServerError(res) {
+  const props = extractErrorProps(res);
+  ServerError.super.call(this, props.message);
+  Object.assign(this, props);
+}
+function extractErrorProps(res) {
+  const body = res.body;
+  const props = {
+    response: res,
+    statusCode: res.statusCode,
+    responseBody: stringifyBody(body, res)
+  };
+  if (body.error && body.message) {
+    props.message = `${body.error} - ${body.message}`;
+    return props;
+  }
+  if (body.error && body.error.description) {
+    props.message = body.error.description;
+    props.details = body.error;
+    return props;
+  }
+  props.message = body.error || body.message || httpErrorMessage(res);
+  return props;
+}
+function httpErrorMessage(res) {
+  const statusMessage = res.statusMessage ? ` ${res.statusMessage}` : "";
+  return `${res.method}-request to ${res.url} resulted in HTTP ${res.statusCode}${statusMessage}`;
+}
+function stringifyBody(body, res) {
+  const contentType = (res.headers["content-type"] || "").toLowerCase();
+  const isJson = contentType.indexOf("application/json") !== -1;
+  return isJson ? JSON.stringify(body, null, 2) : body;
+}
+makeError(ClientError);
+makeError(ServerError);
+
+// src/http/browserMiddleware.js
+var middleware = [];
+
+// src/http/request.js
+var httpError = {
+  onResponse: (res) => {
+    if (res.statusCode >= 500) {
+      throw new ServerError(res);
+    } else if (res.statusCode >= 400) {
+      throw new ClientError(res);
+    }
+    return res;
+  }
+};
+var printWarnings = {
+  onResponse: (res) => {
+    const warn = res.headers["x-sanity-warning"];
+    const warnings = Array.isArray(warn) ? warn : [warn];
+    warnings.filter(Boolean).forEach((msg) => console.warn(msg));
+    return res;
+  }
+};
+var middleware2 = middleware.concat([
+  printWarnings,
+  (0, import_jsonRequest.default)(),
+  (0, import_jsonResponse.default)(),
+  (0, import_progress.default)(),
+  httpError,
+  (0, import_observable4.default)({ implementation: Observable })
+]);
+var request = (0, import_get_it.default)(middleware2);
+function httpRequest(options, requester = request) {
+  return requester(Object.assign({ maxRedirects: 0 }, options));
+}
+httpRequest.defaultRequester = request;
+httpRequest.ClientError = ClientError;
+httpRequest.ServerError = ServerError;
+
+// src/http/requestOptions.js
+var projectHeader = "X-Sanity-Project-ID";
+var requestOptions = (config, overrides = {}) => {
+  const headers = {};
+  const token = overrides.token || config.token;
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  if (!overrides.useGlobalApi && !config.useProjectHostname && config.projectId) {
+    headers[projectHeader] = config.projectId;
+  }
+  const withCredentials = Boolean(typeof overrides.withCredentials === "undefined" ? config.token || config.withCredentials : overrides.withCredentials);
+  const timeout = typeof overrides.timeout === "undefined" ? config.timeout : overrides.timeout;
+  return Object.assign({}, overrides, {
+    headers: Object.assign({}, headers, overrides.headers || {}),
+    timeout: typeof timeout === "undefined" ? 5 * 60 * 1e3 : timeout,
+    proxy: overrides.proxy || config.proxy,
+    json: true,
+    withCredentials
+  });
+};
+
+// src/config.js
+import { generateHelpUrl as generateHelpUrl2 } from "@sanity/generate-help-url";
+
+// src/warnings.js
+import { generateHelpUrl } from "@sanity/generate-help-url";
+
+// src/util/once.js
+var once = (fn) => {
+  let didCall = false;
+  let returnValue;
+  return (...args) => {
+    if (didCall) {
+      return returnValue;
+    }
+    returnValue = fn(...args);
+    didCall = true;
+    return returnValue;
+  };
+};
+
+// src/warnings.js
+var createWarningPrinter = (message) => once((...args) => console.warn(message.join(" "), ...args));
+var printCdnWarning = createWarningPrinter([
+  "You are not using the Sanity CDN. That means your data is always fresh, but the CDN is faster and",
+  `cheaper. Think about it! For more info, see ${generateHelpUrl("js-client-cdn-configuration")}.`,
+  "To hide this warning, please set the `useCdn` option to either `true` or `false` when creating",
+  "the client."
+]);
+var printBrowserTokenWarning = createWarningPrinter([
+  "You have configured Sanity client to use a token in the browser. This may cause unintentional security issues.",
+  `See ${generateHelpUrl("js-client-browser-token")} for more information and how to hide this warning.`
+]);
+var printNoApiVersionSpecifiedWarning = createWarningPrinter([
+  "Using the Sanity client without specifying an API version is deprecated.",
+  `See ${generateHelpUrl("js-client-api-version")}`
+]);
+
+// src/config.js
+var defaultCdnHost = "apicdn.sanity.io";
+var defaultConfig = {
+  apiHost: "https://api.sanity.io",
+  apiVersion: "1",
+  useProjectHostname: true,
+  isPromiseAPI: true
+};
+var LOCALHOSTS = ["localhost", "127.0.0.1", "0.0.0.0"];
+var isLocal = (host) => LOCALHOSTS.indexOf(host) !== -1;
+var initConfig = (config, prevConfig) => {
+  const specifiedConfig = Object.assign({}, prevConfig, config);
+  if (!specifiedConfig.apiVersion) {
+    printNoApiVersionSpecifiedWarning();
+  }
+  const newConfig = Object.assign({}, defaultConfig, specifiedConfig);
+  const projectBased = newConfig.useProjectHostname;
+  if (typeof Promise === "undefined") {
+    const helpUrl = generateHelpUrl2("js-client-promise-polyfill");
+    throw new Error(`No native Promise-implementation found, polyfill needed - see ${helpUrl}`);
+  }
+  if (projectBased && !newConfig.projectId) {
+    throw new Error("Configuration must contain `projectId`");
+  }
+  const isBrowser = typeof window !== "undefined" && window.location && window.location.hostname;
+  const isLocalhost = isBrowser && isLocal(window.location.hostname);
+  if (isBrowser && isLocalhost && newConfig.token && newConfig.ignoreBrowserTokenWarning !== true) {
+    printBrowserTokenWarning();
+  } else if (typeof newConfig.useCdn === "undefined") {
+    printCdnWarning();
+  }
+  if (projectBased) {
+    projectId(newConfig.projectId);
+  }
+  if (newConfig.dataset) {
+    dataset(newConfig.dataset);
+  }
+  if ("requestTagPrefix" in newConfig) {
+    newConfig.requestTagPrefix = newConfig.requestTagPrefix ? requestTag(newConfig.requestTagPrefix).replace(/\.+$/, "") : void 0;
+  }
+  newConfig.apiVersion = `${newConfig.apiVersion}`.replace(/^v/, "");
+  newConfig.isDefaultApi = newConfig.apiHost === defaultConfig.apiHost;
+  newConfig.useCdn = Boolean(newConfig.useCdn) && !newConfig.withCredentials;
+  validateApiVersion(newConfig.apiVersion);
+  const hostParts = newConfig.apiHost.split("://", 2);
+  const protocol = hostParts[0];
+  const host = hostParts[1];
+  const cdnHost = newConfig.isDefaultApi ? defaultCdnHost : host;
+  if (newConfig.useProjectHostname) {
+    newConfig.url = `${protocol}://${newConfig.projectId}.${host}/v${newConfig.apiVersion}`;
+    newConfig.cdnUrl = `${protocol}://${newConfig.projectId}.${cdnHost}/v${newConfig.apiVersion}`;
+  } else {
+    newConfig.url = `${newConfig.apiHost}/v${newConfig.apiVersion}`;
+    newConfig.cdnUrl = newConfig.url;
+  }
+  return newConfig;
+};
+function validateApiVersion(apiVersion) {
+  if (apiVersion === "1" || apiVersion === "X") {
+    return;
+  }
+  const apiDate = new Date(apiVersion);
+  const apiVersionValid = /^\d{4}-\d{2}-\d{2}$/.test(apiVersion) && apiDate instanceof Date && apiDate.getTime() > 0;
+  if (!apiVersionValid) {
+    throw new Error("Invalid API version string, expected `1` or date in format `YYYY-MM-DD`");
+  }
+}
+
+// src/sanityClient.js
+var toPromise2 = (observable2) => observable2.toPromise();
+var SanityClient = class {
+  constructor(config = defaultConfig) {
+    this.config(config);
+    this.assets = new AssetsClient(this);
+    this.datasets = new DatasetsClient(this);
+    this.projects = new ProjectsClient(this);
+    this.users = new UsersClient(this);
+    this.auth = new AuthClient(this);
+    if (this.clientConfig.isPromiseAPI) {
+      const observableConfig = Object.assign({}, this.clientConfig, { isPromiseAPI: false });
+      this.observable = new SanityClient(observableConfig);
+    }
+  }
+  clone() {
+    return new SanityClient(this.config());
+  }
+  config(newConfig) {
+    if (typeof newConfig === "undefined") {
+      return Object.assign({}, this.clientConfig);
+    }
+    if (this.observable) {
+      const observableConfig = Object.assign({}, newConfig, { isPromiseAPI: false });
+      this.observable.config(observableConfig);
+    }
+    this.clientConfig = initConfig(newConfig, this.clientConfig || {});
+    return this;
+  }
+  withConfig(newConfig) {
+    return this.clone().config(newConfig);
+  }
+  getUrl(uri, useCdn = false) {
+    const base = useCdn ? this.clientConfig.cdnUrl : this.clientConfig.url;
+    return `${base}/${uri.replace(/^\//, "")}`;
+  }
+  isPromiseAPI() {
+    return this.clientConfig.isPromiseAPI;
+  }
+  _requestObservable(options) {
+    const uri = options.url || options.uri;
+    const canUseCdn = typeof options.canUseCdn === "undefined" ? ["GET", "HEAD"].indexOf(options.method || "GET") >= 0 && uri.indexOf("/data/") === 0 : options.canUseCdn;
+    const useCdn = this.clientConfig.useCdn && canUseCdn;
+    const tag = options.tag && this.clientConfig.requestTagPrefix ? [this.clientConfig.requestTagPrefix, options.tag].join(".") : options.tag || this.clientConfig.requestTagPrefix;
+    if (tag) {
+      options.query = { tag: requestTag(tag), ...options.query };
+    }
+    const reqOptions = requestOptions(this.clientConfig, Object.assign({}, options, {
+      url: this.getUrl(uri, useCdn)
+    }));
+    return new Observable((subscriber) => httpRequest(reqOptions, this.clientConfig.requester).subscribe(subscriber));
+  }
+  request(options) {
+    const observable2 = this._requestObservable(options).pipe(filter((event) => event.type === "response"), map((event) => event.body));
+    return this.isPromiseAPI() ? toPromise2(observable2) : observable2;
+  }
+};
+Object.assign(SanityClient.prototype, dataMethods);
+SanityClient.Patch = Patch;
+SanityClient.Transaction = Transaction;
+SanityClient.ClientError = httpRequest.ClientError;
+SanityClient.ServerError = httpRequest.ServerError;
+SanityClient.requester = httpRequest.defaultRequester;
+function createClient(config) {
+  return new SanityClient(config);
+}
+createClient.Patch = Patch;
+createClient.Transaction = Transaction;
+createClient.ClientError = httpRequest.ClientError;
+createClient.ServerError = httpRequest.ServerError;
+createClient.requester = httpRequest.defaultRequester;
+export {
+  SanityClient,
+  createClient
+};
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+/*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+/*!
+ * isobject <https://github.com/jonschlinkert/isobject>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */