@sanity/client 3.3.3-esm.0 → 3.3.3-esm.11

package/dist/sanityClient.browser.mjs

@@ -1,1176 +1,2948 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw new Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
+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
+));
 
-// src/util/observable.js
-var require_observable = __commonJS({
-  "src/util/observable.js"(exports, module) {
-    var { Observable } = __require("rxjs/internal/Observable");
-    var { filter } = __require("rxjs/internal/operators/filter");
-    var { map } = __require("rxjs/internal/operators/map");
-    module.exports = {
-      Observable,
-      filter,
-      map
+// node_modules/rxjs/internal/util/isFunction.js
+var require_isFunction = __commonJS({
+  "node_modules/rxjs/internal/util/isFunction.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function isFunction(x) {
+      return typeof x === "function";
+    }
+    exports.isFunction = isFunction;
+  }
+});
+
+// node_modules/rxjs/internal/config.js
+var require_config = __commonJS({
+  "node_modules/rxjs/internal/config.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var _enable_super_gross_mode_that_will_cause_bad_things = false;
+    exports.config = {
+      Promise: void 0,
+      set useDeprecatedSynchronousErrorHandling(value) {
+        if (value) {
+          var error = new Error();
+          console.warn("DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n" + error.stack);
+        } else if (_enable_super_gross_mode_that_will_cause_bad_things) {
+          console.log("RxJS: Back to a better error behavior. Thank you. <3");
+        }
+        _enable_super_gross_mode_that_will_cause_bad_things = value;
+      },
+      get useDeprecatedSynchronousErrorHandling() {
+        return _enable_super_gross_mode_that_will_cause_bad_things;
+      }
     };
   }
 });
 
-// src/util/getSelection.js
-var require_getSelection = __commonJS({
-  "src/util/getSelection.js"(exports, module) {
-    module.exports = function getSelection(sel) {
-      if (typeof sel === "string" || Array.isArray(sel)) {
-        return { id: sel };
+// node_modules/rxjs/internal/util/hostReportError.js
+var require_hostReportError = __commonJS({
+  "node_modules/rxjs/internal/util/hostReportError.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function hostReportError(err) {
+      setTimeout(function() {
+        throw err;
+      }, 0);
+    }
+    exports.hostReportError = hostReportError;
+  }
+});
+
+// node_modules/rxjs/internal/Observer.js
+var require_Observer = __commonJS({
+  "node_modules/rxjs/internal/Observer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var config_1 = require_config();
+    var hostReportError_1 = require_hostReportError();
+    exports.empty = {
+      closed: true,
+      next: function(value) {
+      },
+      error: function(err) {
+        if (config_1.config.useDeprecatedSynchronousErrorHandling) {
+          throw err;
+        } else {
+          hostReportError_1.hostReportError(err);
+        }
+      },
+      complete: function() {
       }
-      if (sel && sel.query) {
-        return "params" in sel ? { query: sel.query, params: sel.params } : { query: sel.query };
+    };
+  }
+});
+
+// node_modules/rxjs/internal/util/isArray.js
+var require_isArray = __commonJS({
+  "node_modules/rxjs/internal/util/isArray.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isArray = function() {
+      return Array.isArray || function(x) {
+        return x && typeof x.length === "number";
+      };
+    }();
+  }
+});
+
+// node_modules/rxjs/internal/util/isObject.js
+var require_isObject = __commonJS({
+  "node_modules/rxjs/internal/util/isObject.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function isObject(x) {
+      return x !== null && typeof x === "object";
+    }
+    exports.isObject = isObject;
+  }
+});
+
+// node_modules/rxjs/internal/util/UnsubscriptionError.js
+var require_UnsubscriptionError = __commonJS({
+  "node_modules/rxjs/internal/util/UnsubscriptionError.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var UnsubscriptionErrorImpl = function() {
+      function UnsubscriptionErrorImpl2(errors) {
+        Error.call(this);
+        this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+          return i + 1 + ") " + err.toString();
+        }).join("\n  ") : "";
+        this.name = "UnsubscriptionError";
+        this.errors = errors;
+        return this;
       }
-      const selectionOpts = [
-        "* Document ID (<docId>)",
-        "* Array of document IDs",
-        "* Object containing `query`"
-      ].join("\n");
-      throw new Error(`Unknown selection - must be one of:
+      UnsubscriptionErrorImpl2.prototype = Object.create(Error.prototype);
+      return UnsubscriptionErrorImpl2;
+    }();
+    exports.UnsubscriptionError = UnsubscriptionErrorImpl;
+  }
+});
 
-${selectionOpts}`);
-    };
+// node_modules/rxjs/internal/Subscription.js
+var require_Subscription = __commonJS({
+  "node_modules/rxjs/internal/Subscription.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var isArray_1 = require_isArray();
+    var isObject_1 = require_isObject();
+    var isFunction_1 = require_isFunction();
+    var UnsubscriptionError_1 = require_UnsubscriptionError();
+    var Subscription = function() {
+      function Subscription2(unsubscribe) {
+        this.closed = false;
+        this._parentOrParents = null;
+        this._subscriptions = null;
+        if (unsubscribe) {
+          this._ctorUnsubscribe = true;
+          this._unsubscribe = unsubscribe;
+        }
+      }
+      Subscription2.prototype.unsubscribe = function() {
+        var errors;
+        if (this.closed) {
+          return;
+        }
+        var _a = this, _parentOrParents = _a._parentOrParents, _ctorUnsubscribe = _a._ctorUnsubscribe, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;
+        this.closed = true;
+        this._parentOrParents = null;
+        this._subscriptions = null;
+        if (_parentOrParents instanceof Subscription2) {
+          _parentOrParents.remove(this);
+        } else if (_parentOrParents !== null) {
+          for (var index = 0; index < _parentOrParents.length; ++index) {
+            var parent_1 = _parentOrParents[index];
+            parent_1.remove(this);
+          }
+        }
+        if (isFunction_1.isFunction(_unsubscribe)) {
+          if (_ctorUnsubscribe) {
+            this._unsubscribe = void 0;
+          }
+          try {
+            _unsubscribe.call(this);
+          } catch (e) {
+            errors = e instanceof UnsubscriptionError_1.UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];
+          }
+        }
+        if (isArray_1.isArray(_subscriptions)) {
+          var index = -1;
+          var len = _subscriptions.length;
+          while (++index < len) {
+            var sub = _subscriptions[index];
+            if (isObject_1.isObject(sub)) {
+              try {
+                sub.unsubscribe();
+              } catch (e) {
+                errors = errors || [];
+                if (e instanceof UnsubscriptionError_1.UnsubscriptionError) {
+                  errors = errors.concat(flattenUnsubscriptionErrors(e.errors));
+                } else {
+                  errors.push(e);
+                }
+              }
+            }
+          }
+        }
+        if (errors) {
+          throw new UnsubscriptionError_1.UnsubscriptionError(errors);
+        }
+      };
+      Subscription2.prototype.add = function(teardown) {
+        var subscription = teardown;
+        if (!teardown) {
+          return Subscription2.EMPTY;
+        }
+        switch (typeof teardown) {
+          case "function":
+            subscription = new Subscription2(teardown);
+          case "object":
+            if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== "function") {
+              return subscription;
+            } else if (this.closed) {
+              subscription.unsubscribe();
+              return subscription;
+            } else if (!(subscription instanceof Subscription2)) {
+              var tmp = subscription;
+              subscription = new Subscription2();
+              subscription._subscriptions = [tmp];
+            }
+            break;
+          default: {
+            throw new Error("unrecognized teardown " + teardown + " added to Subscription.");
+          }
+        }
+        var _parentOrParents = subscription._parentOrParents;
+        if (_parentOrParents === null) {
+          subscription._parentOrParents = this;
+        } else if (_parentOrParents instanceof Subscription2) {
+          if (_parentOrParents === this) {
+            return subscription;
+          }
+          subscription._parentOrParents = [_parentOrParents, this];
+        } else if (_parentOrParents.indexOf(this) === -1) {
+          _parentOrParents.push(this);
+        } else {
+          return subscription;
+        }
+        var subscriptions = this._subscriptions;
+        if (subscriptions === null) {
+          this._subscriptions = [subscription];
+        } else {
+          subscriptions.push(subscription);
+        }
+        return subscription;
+      };
+      Subscription2.prototype.remove = function(subscription) {
+        var subscriptions = this._subscriptions;
+        if (subscriptions) {
+          var subscriptionIndex = subscriptions.indexOf(subscription);
+          if (subscriptionIndex !== -1) {
+            subscriptions.splice(subscriptionIndex, 1);
+          }
+        }
+      };
+      Subscription2.EMPTY = function(empty) {
+        empty.closed = true;
+        return empty;
+      }(new Subscription2());
+      return Subscription2;
+    }();
+    exports.Subscription = Subscription;
+    function flattenUnsubscriptionErrors(errors) {
+      return errors.reduce(function(errs, err) {
+        return errs.concat(err instanceof UnsubscriptionError_1.UnsubscriptionError ? err.errors : err);
+      }, []);
+    }
   }
 });
 
-// src/validators.js
-var require_validators = __commonJS({
-  "src/validators.js"(exports) {
-    var VALID_ASSET_TYPES = ["image", "file"];
-    var VALID_INSERT_LOCATIONS = ["before", "after", "replace"];
-    exports.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"
-        );
+// node_modules/rxjs/internal/symbol/rxSubscriber.js
+var require_rxSubscriber = __commonJS({
+  "node_modules/rxjs/internal/symbol/rxSubscriber.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.rxSubscriber = function() {
+      return typeof Symbol === "function" ? Symbol("rxSubscriber") : "@@rxSubscriber_" + Math.random();
+    }();
+    exports.$$rxSubscriber = exports.rxSubscriber;
+  }
+});
+
+// node_modules/rxjs/internal/Subscriber.js
+var require_Subscriber = __commonJS({
+  "node_modules/rxjs/internal/Subscriber.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2)
+            if (b2.hasOwnProperty(p))
+              d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var isFunction_1 = require_isFunction();
+    var Observer_1 = require_Observer();
+    var Subscription_1 = require_Subscription();
+    var rxSubscriber_1 = require_rxSubscriber();
+    var config_1 = require_config();
+    var hostReportError_1 = require_hostReportError();
+    var Subscriber = function(_super) {
+      __extends(Subscriber2, _super);
+      function Subscriber2(destinationOrNext, error, complete) {
+        var _this = _super.call(this) || this;
+        _this.syncErrorValue = null;
+        _this.syncErrorThrown = false;
+        _this.syncErrorThrowable = false;
+        _this.isStopped = false;
+        switch (arguments.length) {
+          case 0:
+            _this.destination = Observer_1.empty;
+            break;
+          case 1:
+            if (!destinationOrNext) {
+              _this.destination = Observer_1.empty;
+              break;
+            }
+            if (typeof destinationOrNext === "object") {
+              if (destinationOrNext instanceof Subscriber2) {
+                _this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;
+                _this.destination = destinationOrNext;
+                destinationOrNext.add(_this);
+              } else {
+                _this.syncErrorThrowable = true;
+                _this.destination = new SafeSubscriber(_this, destinationOrNext);
+              }
+              break;
+            }
+          default:
+            _this.syncErrorThrowable = true;
+            _this.destination = new SafeSubscriber(_this, destinationOrNext, error, complete);
+            break;
+        }
+        return _this;
       }
-    };
-    exports.projectId = (id) => {
-      if (!/^[-a-z0-9]+$/i.test(id)) {
-        throw new Error("`projectId` can only contain only a-z, 0-9 and dashes");
+      Subscriber2.prototype[rxSubscriber_1.rxSubscriber] = function() {
+        return this;
+      };
+      Subscriber2.create = function(next, error, complete) {
+        var subscriber = new Subscriber2(next, error, complete);
+        subscriber.syncErrorThrowable = false;
+        return subscriber;
+      };
+      Subscriber2.prototype.next = function(value) {
+        if (!this.isStopped) {
+          this._next(value);
+        }
+      };
+      Subscriber2.prototype.error = function(err) {
+        if (!this.isStopped) {
+          this.isStopped = true;
+          this._error(err);
+        }
+      };
+      Subscriber2.prototype.complete = function() {
+        if (!this.isStopped) {
+          this.isStopped = true;
+          this._complete();
+        }
+      };
+      Subscriber2.prototype.unsubscribe = function() {
+        if (this.closed) {
+          return;
+        }
+        this.isStopped = true;
+        _super.prototype.unsubscribe.call(this);
+      };
+      Subscriber2.prototype._next = function(value) {
+        this.destination.next(value);
+      };
+      Subscriber2.prototype._error = function(err) {
+        this.destination.error(err);
+        this.unsubscribe();
+      };
+      Subscriber2.prototype._complete = function() {
+        this.destination.complete();
+        this.unsubscribe();
+      };
+      Subscriber2.prototype._unsubscribeAndRecycle = function() {
+        var _parentOrParents = this._parentOrParents;
+        this._parentOrParents = null;
+        this.unsubscribe();
+        this.closed = false;
+        this.isStopped = false;
+        this._parentOrParents = _parentOrParents;
+        return this;
+      };
+      return Subscriber2;
+    }(Subscription_1.Subscription);
+    exports.Subscriber = Subscriber;
+    var SafeSubscriber = function(_super) {
+      __extends(SafeSubscriber2, _super);
+      function SafeSubscriber2(_parentSubscriber, observerOrNext, error, complete) {
+        var _this = _super.call(this) || this;
+        _this._parentSubscriber = _parentSubscriber;
+        var next;
+        var context = _this;
+        if (isFunction_1.isFunction(observerOrNext)) {
+          next = observerOrNext;
+        } else if (observerOrNext) {
+          next = observerOrNext.next;
+          error = observerOrNext.error;
+          complete = observerOrNext.complete;
+          if (observerOrNext !== Observer_1.empty) {
+            context = Object.create(observerOrNext);
+            if (isFunction_1.isFunction(context.unsubscribe)) {
+              _this.add(context.unsubscribe.bind(context));
+            }
+            context.unsubscribe = _this.unsubscribe.bind(_this);
+          }
+        }
+        _this._context = context;
+        _this._next = next;
+        _this._error = error;
+        _this._complete = complete;
+        return _this;
       }
-    };
-    exports.validateAssetType = (type) => {
-      if (VALID_ASSET_TYPES.indexOf(type) === -1) {
-        throw new Error(`Invalid asset type: ${type}. Must be one of ${VALID_ASSET_TYPES.join(", ")}`);
+      SafeSubscriber2.prototype.next = function(value) {
+        if (!this.isStopped && this._next) {
+          var _parentSubscriber = this._parentSubscriber;
+          if (!config_1.config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
+            this.__tryOrUnsub(this._next, value);
+          } else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {
+            this.unsubscribe();
+          }
+        }
+      };
+      SafeSubscriber2.prototype.error = function(err) {
+        if (!this.isStopped) {
+          var _parentSubscriber = this._parentSubscriber;
+          var useDeprecatedSynchronousErrorHandling = config_1.config.useDeprecatedSynchronousErrorHandling;
+          if (this._error) {
+            if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
+              this.__tryOrUnsub(this._error, err);
+              this.unsubscribe();
+            } else {
+              this.__tryOrSetError(_parentSubscriber, this._error, err);
+              this.unsubscribe();
+            }
+          } else if (!_parentSubscriber.syncErrorThrowable) {
+            this.unsubscribe();
+            if (useDeprecatedSynchronousErrorHandling) {
+              throw err;
+            }
+            hostReportError_1.hostReportError(err);
+          } else {
+            if (useDeprecatedSynchronousErrorHandling) {
+              _parentSubscriber.syncErrorValue = err;
+              _parentSubscriber.syncErrorThrown = true;
+            } else {
+              hostReportError_1.hostReportError(err);
+            }
+            this.unsubscribe();
+          }
+        }
+      };
+      SafeSubscriber2.prototype.complete = function() {
+        var _this = this;
+        if (!this.isStopped) {
+          var _parentSubscriber = this._parentSubscriber;
+          if (this._complete) {
+            var wrappedComplete = function() {
+              return _this._complete.call(_this._context);
+            };
+            if (!config_1.config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
+              this.__tryOrUnsub(wrappedComplete);
+              this.unsubscribe();
+            } else {
+              this.__tryOrSetError(_parentSubscriber, wrappedComplete);
+              this.unsubscribe();
+            }
+          } else {
+            this.unsubscribe();
+          }
+        }
+      };
+      SafeSubscriber2.prototype.__tryOrUnsub = function(fn, value) {
+        try {
+          fn.call(this._context, value);
+        } catch (err) {
+          this.unsubscribe();
+          if (config_1.config.useDeprecatedSynchronousErrorHandling) {
+            throw err;
+          } else {
+            hostReportError_1.hostReportError(err);
+          }
+        }
+      };
+      SafeSubscriber2.prototype.__tryOrSetError = function(parent, fn, value) {
+        if (!config_1.config.useDeprecatedSynchronousErrorHandling) {
+          throw new Error("bad call");
+        }
+        try {
+          fn.call(this._context, value);
+        } catch (err) {
+          if (config_1.config.useDeprecatedSynchronousErrorHandling) {
+            parent.syncErrorValue = err;
+            parent.syncErrorThrown = true;
+            return true;
+          } else {
+            hostReportError_1.hostReportError(err);
+            return true;
+          }
+        }
+        return false;
+      };
+      SafeSubscriber2.prototype._unsubscribe = function() {
+        var _parentSubscriber = this._parentSubscriber;
+        this._context = null;
+        this._parentSubscriber = null;
+        _parentSubscriber.unsubscribe();
+      };
+      return SafeSubscriber2;
+    }(Subscriber);
+    exports.SafeSubscriber = SafeSubscriber;
+  }
+});
+
+// node_modules/rxjs/internal/util/canReportError.js
+var require_canReportError = __commonJS({
+  "node_modules/rxjs/internal/util/canReportError.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var Subscriber_1 = require_Subscriber();
+    function canReportError(observer) {
+      while (observer) {
+        var _a = observer, closed_1 = _a.closed, destination = _a.destination, isStopped = _a.isStopped;
+        if (closed_1 || isStopped) {
+          return false;
+        } else if (destination && destination instanceof Subscriber_1.Subscriber) {
+          observer = destination;
+        } else {
+          observer = null;
+        }
       }
-    };
-    exports.validateObject = (op, val) => {
-      if (val === null || typeof val !== "object" || Array.isArray(val)) {
-        throw new Error(`${op}() takes an object of properties`);
+      return true;
+    }
+    exports.canReportError = canReportError;
+  }
+});
+
+// node_modules/rxjs/internal/util/toSubscriber.js
+var require_toSubscriber = __commonJS({
+  "node_modules/rxjs/internal/util/toSubscriber.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var Subscriber_1 = require_Subscriber();
+    var rxSubscriber_1 = require_rxSubscriber();
+    var Observer_1 = require_Observer();
+    function toSubscriber(nextOrObserver, error, complete) {
+      if (nextOrObserver) {
+        if (nextOrObserver instanceof Subscriber_1.Subscriber) {
+          return nextOrObserver;
+        }
+        if (nextOrObserver[rxSubscriber_1.rxSubscriber]) {
+          return nextOrObserver[rxSubscriber_1.rxSubscriber]();
+        }
       }
-    };
-    exports.requireDocumentId = (op, doc) => {
-      if (!doc._id) {
-        throw new Error(`${op}() requires that the document contains an ID ("_id" property)`);
+      if (!nextOrObserver && !error && !complete) {
+        return new Subscriber_1.Subscriber(Observer_1.empty);
       }
-      exports.validateDocumentId(op, doc._id);
-    };
-    exports.validateDocumentId = (op, id) => {
-      if (typeof id !== "string" || !/^[a-z0-9_.-]+$/i.test(id)) {
-        throw new Error(`${op}(): "${id}" is not a valid document ID`);
+      return new Subscriber_1.Subscriber(nextOrObserver, error, complete);
+    }
+    exports.toSubscriber = toSubscriber;
+  }
+});
+
+// node_modules/rxjs/internal/symbol/observable.js
+var require_observable = __commonJS({
+  "node_modules/rxjs/internal/symbol/observable.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.observable = function() {
+      return typeof Symbol === "function" && Symbol.observable || "@@observable";
+    }();
+  }
+});
+
+// node_modules/rxjs/internal/util/identity.js
+var require_identity = __commonJS({
+  "node_modules/rxjs/internal/util/identity.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function identity(x) {
+      return x;
+    }
+    exports.identity = identity;
+  }
+});
+
+// node_modules/rxjs/internal/util/pipe.js
+var require_pipe = __commonJS({
+  "node_modules/rxjs/internal/util/pipe.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var identity_1 = require_identity();
+    function pipe() {
+      var fns = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        fns[_i] = arguments[_i];
       }
-    };
-    exports.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}`);
+      return pipeFromArray(fns);
+    }
+    exports.pipe = pipe;
+    function pipeFromArray(fns) {
+      if (fns.length === 0) {
+        return identity_1.identity;
       }
-      if (typeof selector !== "string") {
-        throw new Error(`${signature} takes a "selector"-argument which must be a string`);
+      if (fns.length === 1) {
+        return fns[0];
       }
-      if (!Array.isArray(items)) {
-        throw new Error(`${signature} takes an "items"-argument which must be an array`);
+      return function piped(input) {
+        return fns.reduce(function(prev, fn) {
+          return fn(prev);
+        }, input);
+      };
+    }
+    exports.pipeFromArray = pipeFromArray;
+  }
+});
+
+// node_modules/rxjs/internal/Observable.js
+var require_Observable = __commonJS({
+  "node_modules/rxjs/internal/Observable.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var canReportError_1 = require_canReportError();
+    var toSubscriber_1 = require_toSubscriber();
+    var observable_1 = require_observable();
+    var pipe_1 = require_pipe();
+    var config_1 = require_config();
+    var Observable2 = function() {
+      function Observable3(subscribe) {
+        this._isScalar = false;
+        if (subscribe) {
+          this._subscribe = subscribe;
+        }
       }
-    };
-    exports.hasDataset = (config) => {
-      if (!config.dataset) {
-        throw new Error("`dataset` must be provided to perform queries");
+      Observable3.prototype.lift = function(operator) {
+        var observable2 = new Observable3();
+        observable2.source = this;
+        observable2.operator = operator;
+        return observable2;
+      };
+      Observable3.prototype.subscribe = function(observerOrNext, error, complete) {
+        var operator = this.operator;
+        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);
+        if (operator) {
+          sink.add(operator.call(sink, this.source));
+        } else {
+          sink.add(this.source || config_1.config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable ? this._subscribe(sink) : this._trySubscribe(sink));
+        }
+        if (config_1.config.useDeprecatedSynchronousErrorHandling) {
+          if (sink.syncErrorThrowable) {
+            sink.syncErrorThrowable = false;
+            if (sink.syncErrorThrown) {
+              throw sink.syncErrorValue;
+            }
+          }
+        }
+        return sink;
+      };
+      Observable3.prototype._trySubscribe = function(sink) {
+        try {
+          return this._subscribe(sink);
+        } catch (err) {
+          if (config_1.config.useDeprecatedSynchronousErrorHandling) {
+            sink.syncErrorThrown = true;
+            sink.syncErrorValue = err;
+          }
+          if (canReportError_1.canReportError(sink)) {
+            sink.error(err);
+          } else {
+            console.warn(err);
+          }
+        }
+      };
+      Observable3.prototype.forEach = function(next, promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function(resolve, reject) {
+          var subscription;
+          subscription = _this.subscribe(function(value) {
+            try {
+              next(value);
+            } catch (err) {
+              reject(err);
+              if (subscription) {
+                subscription.unsubscribe();
+              }
+            }
+          }, reject, resolve);
+        });
+      };
+      Observable3.prototype._subscribe = function(subscriber) {
+        var source = this.source;
+        return source && source.subscribe(subscriber);
+      };
+      Observable3.prototype[observable_1.observable] = function() {
+        return this;
+      };
+      Observable3.prototype.pipe = function() {
+        var operations = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          operations[_i] = arguments[_i];
+        }
+        if (operations.length === 0) {
+          return this;
+        }
+        return pipe_1.pipeFromArray(operations)(this);
+      };
+      Observable3.prototype.toPromise = function(promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function(resolve, reject) {
+          var value;
+          _this.subscribe(function(x) {
+            return value = x;
+          }, function(err) {
+            return reject(err);
+          }, function() {
+            return resolve(value);
+          });
+        });
+      };
+      Observable3.create = function(subscribe) {
+        return new Observable3(subscribe);
+      };
+      return Observable3;
+    }();
+    exports.Observable = Observable2;
+    function getPromiseCtor(promiseCtor) {
+      if (!promiseCtor) {
+        promiseCtor = config_1.config.Promise || Promise;
       }
-      return config.dataset || "";
-    };
-    exports.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.`
-        );
+      if (!promiseCtor) {
+        throw new Error("no Promise impl found");
       }
-      return tag;
-    };
+      return promiseCtor;
+    }
+  }
+});
+
+// node_modules/rxjs/internal/operators/filter.js
+var require_filter = __commonJS({
+  "node_modules/rxjs/internal/operators/filter.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2)
+            if (b2.hasOwnProperty(p))
+              d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var Subscriber_1 = require_Subscriber();
+    function filter2(predicate, thisArg) {
+      return function filterOperatorFunction(source) {
+        return source.lift(new FilterOperator(predicate, thisArg));
+      };
+    }
+    exports.filter = filter2;
+    var FilterOperator = function() {
+      function FilterOperator2(predicate, thisArg) {
+        this.predicate = predicate;
+        this.thisArg = thisArg;
+      }
+      FilterOperator2.prototype.call = function(subscriber, source) {
+        return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));
+      };
+      return FilterOperator2;
+    }();
+    var FilterSubscriber = function(_super) {
+      __extends(FilterSubscriber2, _super);
+      function FilterSubscriber2(destination, predicate, thisArg) {
+        var _this = _super.call(this, destination) || this;
+        _this.predicate = predicate;
+        _this.thisArg = thisArg;
+        _this.count = 0;
+        return _this;
+      }
+      FilterSubscriber2.prototype._next = function(value) {
+        var result;
+        try {
+          result = this.predicate.call(this.thisArg, value, this.count++);
+        } catch (err) {
+          this.destination.error(err);
+          return;
+        }
+        if (result) {
+          this.destination.next(value);
+        }
+      };
+      return FilterSubscriber2;
+    }(Subscriber_1.Subscriber);
+  }
+});
+
+// node_modules/rxjs/internal/operators/map.js
+var require_map = __commonJS({
+  "node_modules/rxjs/internal/operators/map.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2)
+            if (b2.hasOwnProperty(p))
+              d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var Subscriber_1 = require_Subscriber();
+    function map2(project, thisArg) {
+      return function mapOperation(source) {
+        if (typeof project !== "function") {
+          throw new TypeError("argument is not a function. Are you looking for `mapTo()`?");
+        }
+        return source.lift(new MapOperator(project, thisArg));
+      };
+    }
+    exports.map = map2;
+    var MapOperator = function() {
+      function MapOperator2(project, thisArg) {
+        this.project = project;
+        this.thisArg = thisArg;
+      }
+      MapOperator2.prototype.call = function(subscriber, source) {
+        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));
+      };
+      return MapOperator2;
+    }();
+    exports.MapOperator = MapOperator;
+    var MapSubscriber = function(_super) {
+      __extends(MapSubscriber2, _super);
+      function MapSubscriber2(destination, project, thisArg) {
+        var _this = _super.call(this, destination) || this;
+        _this.project = project;
+        _this.count = 0;
+        _this.thisArg = thisArg || _this;
+        return _this;
+      }
+      MapSubscriber2.prototype._next = function(value) {
+        var result;
+        try {
+          result = this.project.call(this.thisArg, value, this.count++);
+        } catch (err) {
+          this.destination.error(err);
+          return;
+        }
+        this.destination.next(result);
+      };
+      return MapSubscriber2;
+    }(Subscriber_1.Subscriber);
+  }
+});
+
+// node_modules/event-source-polyfill/src/eventsource.js
+var require_eventsource = __commonJS({
+  "node_modules/event-source-polyfill/src/eventsource.js"(exports, module) {
+    (function(global) {
+      "use strict";
+      var setTimeout2 = global.setTimeout;
+      var clearTimeout2 = global.clearTimeout;
+      var XMLHttpRequest = global.XMLHttpRequest;
+      var XDomainRequest = global.XDomainRequest;
+      var ActiveXObject = global.ActiveXObject;
+      var NativeEventSource = global.EventSource;
+      var document = global.document;
+      var Promise2 = global.Promise;
+      var fetch = global.fetch;
+      var Response = global.Response;
+      var TextDecoder = global.TextDecoder;
+      var TextEncoder = global.TextEncoder;
+      var AbortController = global.AbortController;
+      if (typeof window !== "undefined" && typeof document !== "undefined" && !("readyState" in document) && document.body == null) {
+        document.readyState = "loading";
+        window.addEventListener("load", function(event) {
+          document.readyState = "complete";
+        }, false);
+      }
+      if (XMLHttpRequest == null && ActiveXObject != null) {
+        XMLHttpRequest = function() {
+          return new ActiveXObject("Microsoft.XMLHTTP");
+        };
+      }
+      if (Object.create == void 0) {
+        Object.create = function(C) {
+          function F() {
+          }
+          F.prototype = C;
+          return new F();
+        };
+      }
+      if (!Date.now) {
+        Date.now = function now() {
+          return new Date().getTime();
+        };
+      }
+      if (AbortController == void 0) {
+        var originalFetch2 = fetch;
+        fetch = function(url, options) {
+          var signal = options.signal;
+          return originalFetch2(url, { headers: options.headers, credentials: options.credentials, cache: options.cache }).then(function(response) {
+            var reader = response.body.getReader();
+            signal._reader = reader;
+            if (signal._aborted) {
+              signal._reader.cancel();
+            }
+            return {
+              status: response.status,
+              statusText: response.statusText,
+              headers: response.headers,
+              body: {
+                getReader: function() {
+                  return reader;
+                }
+              }
+            };
+          });
+        };
+        AbortController = function() {
+          this.signal = {
+            _reader: null,
+            _aborted: false
+          };
+          this.abort = function() {
+            if (this.signal._reader != null) {
+              this.signal._reader.cancel();
+            }
+            this.signal._aborted = true;
+          };
+        };
+      }
+      function TextDecoderPolyfill() {
+        this.bitsNeeded = 0;
+        this.codePoint = 0;
+      }
+      TextDecoderPolyfill.prototype.decode = function(octets) {
+        function valid(codePoint2, shift, octetsCount2) {
+          if (octetsCount2 === 1) {
+            return codePoint2 >= 128 >> shift && codePoint2 << shift <= 2047;
+          }
+          if (octetsCount2 === 2) {
+            return codePoint2 >= 2048 >> shift && codePoint2 << shift <= 55295 || codePoint2 >= 57344 >> shift && codePoint2 << shift <= 65535;
+          }
+          if (octetsCount2 === 3) {
+            return codePoint2 >= 65536 >> shift && codePoint2 << shift <= 1114111;
+          }
+          throw new Error();
+        }
+        function octetsCount(bitsNeeded2, codePoint2) {
+          if (bitsNeeded2 === 6 * 1) {
+            return codePoint2 >> 6 > 15 ? 3 : codePoint2 > 31 ? 2 : 1;
+          }
+          if (bitsNeeded2 === 6 * 2) {
+            return codePoint2 > 15 ? 3 : 2;
+          }
+          if (bitsNeeded2 === 6 * 3) {
+            return 3;
+          }
+          throw new Error();
+        }
+        var REPLACER = 65533;
+        var string = "";
+        var bitsNeeded = this.bitsNeeded;
+        var codePoint = this.codePoint;
+        for (var i = 0; i < octets.length; i += 1) {
+          var octet = octets[i];
+          if (bitsNeeded !== 0) {
+            if (octet < 128 || octet > 191 || !valid(codePoint << 6 | octet & 63, bitsNeeded - 6, octetsCount(bitsNeeded, codePoint))) {
+              bitsNeeded = 0;
+              codePoint = REPLACER;
+              string += String.fromCharCode(codePoint);
+            }
+          }
+          if (bitsNeeded === 0) {
+            if (octet >= 0 && octet <= 127) {
+              bitsNeeded = 0;
+              codePoint = octet;
+            } else if (octet >= 192 && octet <= 223) {
+              bitsNeeded = 6 * 1;
+              codePoint = octet & 31;
+            } else if (octet >= 224 && octet <= 239) {
+              bitsNeeded = 6 * 2;
+              codePoint = octet & 15;
+            } else if (octet >= 240 && octet <= 247) {
+              bitsNeeded = 6 * 3;
+              codePoint = octet & 7;
+            } else {
+              bitsNeeded = 0;
+              codePoint = REPLACER;
+            }
+            if (bitsNeeded !== 0 && !valid(codePoint, bitsNeeded, octetsCount(bitsNeeded, codePoint))) {
+              bitsNeeded = 0;
+              codePoint = REPLACER;
+            }
+          } else {
+            bitsNeeded -= 6;
+            codePoint = codePoint << 6 | octet & 63;
+          }
+          if (bitsNeeded === 0) {
+            if (codePoint <= 65535) {
+              string += String.fromCharCode(codePoint);
+            } else {
+              string += String.fromCharCode(55296 + (codePoint - 65535 - 1 >> 10));
+              string += String.fromCharCode(56320 + (codePoint - 65535 - 1 & 1023));
+            }
+          }
+        }
+        this.bitsNeeded = bitsNeeded;
+        this.codePoint = codePoint;
+        return string;
+      };
+      var supportsStreamOption = function() {
+        try {
+          return new TextDecoder().decode(new TextEncoder().encode("test"), { stream: true }) === "test";
+        } catch (error) {
+          console.debug("TextDecoder does not support streaming option. Using polyfill instead: " + error);
+        }
+        return false;
+      };
+      if (TextDecoder == void 0 || TextEncoder == void 0 || !supportsStreamOption()) {
+        TextDecoder = TextDecoderPolyfill;
+      }
+      var k = function() {
+      };
+      function XHRWrapper(xhr) {
+        this.withCredentials = false;
+        this.readyState = 0;
+        this.status = 0;
+        this.statusText = "";
+        this.responseText = "";
+        this.onprogress = k;
+        this.onload = k;
+        this.onerror = k;
+        this.onreadystatechange = k;
+        this._contentType = "";
+        this._xhr = xhr;
+        this._sendTimeout = 0;
+        this._abort = k;
+      }
+      XHRWrapper.prototype.open = function(method, url) {
+        this._abort(true);
+        var that = this;
+        var xhr = this._xhr;
+        var state = 1;
+        var timeout = 0;
+        this._abort = function(silent) {
+          if (that._sendTimeout !== 0) {
+            clearTimeout2(that._sendTimeout);
+            that._sendTimeout = 0;
+          }
+          if (state === 1 || state === 2 || state === 3) {
+            state = 4;
+            xhr.onload = k;
+            xhr.onerror = k;
+            xhr.onabort = k;
+            xhr.onprogress = k;
+            xhr.onreadystatechange = k;
+            xhr.abort();
+            if (timeout !== 0) {
+              clearTimeout2(timeout);
+              timeout = 0;
+            }
+            if (!silent) {
+              that.readyState = 4;
+              that.onabort(null);
+              that.onreadystatechange();
+            }
+          }
+          state = 0;
+        };
+        var onStart = function() {
+          if (state === 1) {
+            var status = 0;
+            var statusText = "";
+            var contentType = void 0;
+            if (!("contentType" in xhr)) {
+              try {
+                status = xhr.status;
+                statusText = xhr.statusText;
+                contentType = xhr.getResponseHeader("Content-Type");
+              } catch (error) {
+                status = 0;
+                statusText = "";
+                contentType = void 0;
+              }
+            } else {
+              status = 200;
+              statusText = "OK";
+              contentType = xhr.contentType;
+            }
+            if (status !== 0) {
+              state = 2;
+              that.readyState = 2;
+              that.status = status;
+              that.statusText = statusText;
+              that._contentType = contentType;
+              that.onreadystatechange();
+            }
+          }
+        };
+        var onProgress = function() {
+          onStart();
+          if (state === 2 || state === 3) {
+            state = 3;
+            var responseText = "";
+            try {
+              responseText = xhr.responseText;
+            } catch (error) {
+            }
+            that.readyState = 3;
+            that.responseText = responseText;
+            that.onprogress();
+          }
+        };
+        var onFinish = function(type, event) {
+          if (event == null || event.preventDefault == null) {
+            event = {
+              preventDefault: k
+            };
+          }
+          onProgress();
+          if (state === 1 || state === 2 || state === 3) {
+            state = 4;
+            if (timeout !== 0) {
+              clearTimeout2(timeout);
+              timeout = 0;
+            }
+            that.readyState = 4;
+            if (type === "load") {
+              that.onload(event);
+            } else if (type === "error") {
+              that.onerror(event);
+            } else if (type === "abort") {
+              that.onabort(event);
+            } else {
+              throw new TypeError();
+            }
+            that.onreadystatechange();
+          }
+        };
+        var onReadyStateChange = function(event) {
+          if (xhr != void 0) {
+            if (xhr.readyState === 4) {
+              if (!("onload" in xhr) || !("onerror" in xhr) || !("onabort" in xhr)) {
+                onFinish(xhr.responseText === "" ? "error" : "load", event);
+              }
+            } else if (xhr.readyState === 3) {
+              if (!("onprogress" in xhr)) {
+                onProgress();
+              }
+            } else if (xhr.readyState === 2) {
+              onStart();
+            }
+          }
+        };
+        var onTimeout = function() {
+          timeout = setTimeout2(function() {
+            onTimeout();
+          }, 500);
+          if (xhr.readyState === 3) {
+            onProgress();
+          }
+        };
+        if ("onload" in xhr) {
+          xhr.onload = function(event) {
+            onFinish("load", event);
+          };
+        }
+        if ("onerror" in xhr) {
+          xhr.onerror = function(event) {
+            onFinish("error", event);
+          };
+        }
+        if ("onabort" in xhr) {
+          xhr.onabort = function(event) {
+            onFinish("abort", event);
+          };
+        }
+        if ("onprogress" in xhr) {
+          xhr.onprogress = onProgress;
+        }
+        if ("onreadystatechange" in xhr) {
+          xhr.onreadystatechange = function(event) {
+            onReadyStateChange(event);
+          };
+        }
+        if ("contentType" in xhr || !("ontimeout" in XMLHttpRequest.prototype)) {
+          url += (url.indexOf("?") === -1 ? "?" : "&") + "padding=true";
+        }
+        xhr.open(method, url, true);
+        if ("readyState" in xhr) {
+          timeout = setTimeout2(function() {
+            onTimeout();
+          }, 0);
+        }
+      };
+      XHRWrapper.prototype.abort = function() {
+        this._abort(false);
+      };
+      XHRWrapper.prototype.getResponseHeader = function(name) {
+        return this._contentType;
+      };
+      XHRWrapper.prototype.setRequestHeader = function(name, value) {
+        var xhr = this._xhr;
+        if ("setRequestHeader" in xhr) {
+          xhr.setRequestHeader(name, value);
+        }
+      };
+      XHRWrapper.prototype.getAllResponseHeaders = function() {
+        return this._xhr.getAllResponseHeaders != void 0 ? this._xhr.getAllResponseHeaders() || "" : "";
+      };
+      XHRWrapper.prototype.send = function() {
+        if ((!("ontimeout" in XMLHttpRequest.prototype) || !("sendAsBinary" in XMLHttpRequest.prototype) && !("mozAnon" in XMLHttpRequest.prototype)) && document != void 0 && document.readyState != void 0 && document.readyState !== "complete") {
+          var that = this;
+          that._sendTimeout = setTimeout2(function() {
+            that._sendTimeout = 0;
+            that.send();
+          }, 4);
+          return;
+        }
+        var xhr = this._xhr;
+        if ("withCredentials" in xhr) {
+          xhr.withCredentials = this.withCredentials;
+        }
+        try {
+          xhr.send(void 0);
+        } catch (error1) {
+          throw error1;
+        }
+      };
+      function toLowerCase(name) {
+        return name.replace(/[A-Z]/g, function(c) {
+          return String.fromCharCode(c.charCodeAt(0) + 32);
+        });
+      }
+      function HeadersPolyfill(all) {
+        var map2 = /* @__PURE__ */ Object.create(null);
+        var array = all.split("\r\n");
+        for (var i = 0; i < array.length; i += 1) {
+          var line = array[i];
+          var parts = line.split(": ");
+          var name = parts.shift();
+          var value = parts.join(": ");
+          map2[toLowerCase(name)] = value;
+        }
+        this._map = map2;
+      }
+      HeadersPolyfill.prototype.get = function(name) {
+        return this._map[toLowerCase(name)];
+      };
+      if (XMLHttpRequest != null && XMLHttpRequest.HEADERS_RECEIVED == null) {
+        XMLHttpRequest.HEADERS_RECEIVED = 2;
+      }
+      function XHRTransport() {
+      }
+      XHRTransport.prototype.open = function(xhr, onStartCallback, onProgressCallback, onFinishCallback, url, withCredentials, headers) {
+        xhr.open("GET", url);
+        var offset = 0;
+        xhr.onprogress = function() {
+          var responseText = xhr.responseText;
+          var chunk = responseText.slice(offset);
+          offset += chunk.length;
+          onProgressCallback(chunk);
+        };
+        xhr.onerror = function(event) {
+          event.preventDefault();
+          onFinishCallback(new Error("NetworkError"));
+        };
+        xhr.onload = function() {
+          onFinishCallback(null);
+        };
+        xhr.onabort = function() {
+          onFinishCallback(null);
+        };
+        xhr.onreadystatechange = function() {
+          if (xhr.readyState === XMLHttpRequest.HEADERS_RECEIVED) {
+            var status = xhr.status;
+            var statusText = xhr.statusText;
+            var contentType = xhr.getResponseHeader("Content-Type");
+            var headers2 = xhr.getAllResponseHeaders();
+            onStartCallback(status, statusText, contentType, new HeadersPolyfill(headers2));
+          }
+        };
+        xhr.withCredentials = withCredentials;
+        for (var name in headers) {
+          if (Object.prototype.hasOwnProperty.call(headers, name)) {
+            xhr.setRequestHeader(name, headers[name]);
+          }
+        }
+        xhr.send();
+        return xhr;
+      };
+      function HeadersWrapper(headers) {
+        this._headers = headers;
+      }
+      HeadersWrapper.prototype.get = function(name) {
+        return this._headers.get(name);
+      };
+      function FetchTransport() {
+      }
+      FetchTransport.prototype.open = function(xhr, onStartCallback, onProgressCallback, onFinishCallback, url, withCredentials, headers) {
+        var reader = null;
+        var controller = new AbortController();
+        var signal = controller.signal;
+        var textDecoder = new TextDecoder();
+        fetch(url, {
+          headers,
+          credentials: withCredentials ? "include" : "same-origin",
+          signal,
+          cache: "no-store"
+        }).then(function(response) {
+          reader = response.body.getReader();
+          onStartCallback(response.status, response.statusText, response.headers.get("Content-Type"), new HeadersWrapper(response.headers));
+          return new Promise2(function(resolve, reject) {
+            var readNextChunk = function() {
+              reader.read().then(function(result) {
+                if (result.done) {
+                  resolve(void 0);
+                } else {
+                  var chunk = textDecoder.decode(result.value, { stream: true });
+                  onProgressCallback(chunk);
+                  readNextChunk();
+                }
+              })["catch"](function(error) {
+                reject(error);
+              });
+            };
+            readNextChunk();
+          });
+        })["catch"](function(error) {
+          if (error.name === "AbortError") {
+            return void 0;
+          } else {
+            return error;
+          }
+        }).then(function(error) {
+          onFinishCallback(error);
+        });
+        return {
+          abort: function() {
+            if (reader != null) {
+              reader.cancel();
+            }
+            controller.abort();
+          }
+        };
+      };
+      function EventTarget() {
+        this._listeners = /* @__PURE__ */ Object.create(null);
+      }
+      function throwError(e) {
+        setTimeout2(function() {
+          throw e;
+        }, 0);
+      }
+      EventTarget.prototype.dispatchEvent = function(event) {
+        event.target = this;
+        var typeListeners = this._listeners[event.type];
+        if (typeListeners != void 0) {
+          var length = typeListeners.length;
+          for (var i = 0; i < length; i += 1) {
+            var listener = typeListeners[i];
+            try {
+              if (typeof listener.handleEvent === "function") {
+                listener.handleEvent(event);
+              } else {
+                listener.call(this, event);
+              }
+            } catch (e) {
+              throwError(e);
+            }
+          }
+        }
+      };
+      EventTarget.prototype.addEventListener = function(type, listener) {
+        type = String(type);
+        var listeners = this._listeners;
+        var typeListeners = listeners[type];
+        if (typeListeners == void 0) {
+          typeListeners = [];
+          listeners[type] = typeListeners;
+        }
+        var found = false;
+        for (var i = 0; i < typeListeners.length; i += 1) {
+          if (typeListeners[i] === listener) {
+            found = true;
+          }
+        }
+        if (!found) {
+          typeListeners.push(listener);
+        }
+      };
+      EventTarget.prototype.removeEventListener = function(type, listener) {
+        type = String(type);
+        var listeners = this._listeners;
+        var typeListeners = listeners[type];
+        if (typeListeners != void 0) {
+          var filtered = [];
+          for (var i = 0; i < typeListeners.length; i += 1) {
+            if (typeListeners[i] !== listener) {
+              filtered.push(typeListeners[i]);
+            }
+          }
+          if (filtered.length === 0) {
+            delete listeners[type];
+          } else {
+            listeners[type] = filtered;
+          }
+        }
+      };
+      function Event(type) {
+        this.type = type;
+        this.target = void 0;
+      }
+      function MessageEvent(type, options) {
+        Event.call(this, type);
+        this.data = options.data;
+        this.lastEventId = options.lastEventId;
+      }
+      MessageEvent.prototype = Object.create(Event.prototype);
+      function ConnectionEvent(type, options) {
+        Event.call(this, type);
+        this.status = options.status;
+        this.statusText = options.statusText;
+        this.headers = options.headers;
+      }
+      ConnectionEvent.prototype = Object.create(Event.prototype);
+      function ErrorEvent(type, options) {
+        Event.call(this, type);
+        this.error = options.error;
+      }
+      ErrorEvent.prototype = Object.create(Event.prototype);
+      var WAITING = -1;
+      var CONNECTING = 0;
+      var OPEN = 1;
+      var CLOSED = 2;
+      var AFTER_CR = -1;
+      var FIELD_START = 0;
+      var FIELD = 1;
+      var VALUE_START = 2;
+      var VALUE = 3;
+      var contentTypeRegExp = /^text\/event\-stream(;.*)?$/i;
+      var MINIMUM_DURATION = 1e3;
+      var MAXIMUM_DURATION = 18e6;
+      var parseDuration = function(value, def) {
+        var n = value == null ? def : parseInt(value, 10);
+        if (n !== n) {
+          n = def;
+        }
+        return clampDuration(n);
+      };
+      var clampDuration = function(n) {
+        return Math.min(Math.max(n, MINIMUM_DURATION), MAXIMUM_DURATION);
+      };
+      var fire = function(that, f, event) {
+        try {
+          if (typeof f === "function") {
+            f.call(that, event);
+          }
+        } catch (e) {
+          throwError(e);
+        }
+      };
+      function EventSourcePolyfill(url, options) {
+        EventTarget.call(this);
+        options = options || {};
+        this.onopen = void 0;
+        this.onmessage = void 0;
+        this.onerror = void 0;
+        this.url = void 0;
+        this.readyState = void 0;
+        this.withCredentials = void 0;
+        this.headers = void 0;
+        this._close = void 0;
+        start(this, url, options);
+      }
+      function getBestXHRTransport() {
+        return XMLHttpRequest != void 0 && "withCredentials" in XMLHttpRequest.prototype || XDomainRequest == void 0 ? new XMLHttpRequest() : new XDomainRequest();
+      }
+      var isFetchSupported = fetch != void 0 && Response != void 0 && "body" in Response.prototype;
+      function start(es, url, options) {
+        url = String(url);
+        var withCredentials = Boolean(options.withCredentials);
+        var lastEventIdQueryParameterName = options.lastEventIdQueryParameterName || "lastEventId";
+        var initialRetry = clampDuration(1e3);
+        var heartbeatTimeout = parseDuration(options.heartbeatTimeout, 45e3);
+        var lastEventId = "";
+        var retry = initialRetry;
+        var wasActivity = false;
+        var textLength = 0;
+        var headers = options.headers || {};
+        var TransportOption = options.Transport;
+        var xhr = isFetchSupported && TransportOption == void 0 ? void 0 : new XHRWrapper(TransportOption != void 0 ? new TransportOption() : getBestXHRTransport());
+        var transport = TransportOption != null && typeof TransportOption !== "string" ? new TransportOption() : xhr == void 0 ? new FetchTransport() : new XHRTransport();
+        var abortController = void 0;
+        var timeout = 0;
+        var currentState = WAITING;
+        var dataBuffer = "";
+        var lastEventIdBuffer = "";
+        var eventTypeBuffer = "";
+        var textBuffer = "";
+        var state = FIELD_START;
+        var fieldStart = 0;
+        var valueStart = 0;
+        var onStart = function(status, statusText, contentType, headers2) {
+          if (currentState === CONNECTING) {
+            if (status === 200 && contentType != void 0 && contentTypeRegExp.test(contentType)) {
+              currentState = OPEN;
+              wasActivity = Date.now();
+              retry = initialRetry;
+              es.readyState = OPEN;
+              var event = new ConnectionEvent("open", {
+                status,
+                statusText,
+                headers: headers2
+              });
+              es.dispatchEvent(event);
+              fire(es, es.onopen, event);
+            } else {
+              var message = "";
+              if (status !== 200) {
+                if (statusText) {
+                  statusText = statusText.replace(/\s+/g, " ");
+                }
+                message = "EventSource's response has a status " + status + " " + statusText + " that is not 200. Aborting the connection.";
+              } else {
+                message = "EventSource's response has a Content-Type specifying an unsupported type: " + (contentType == void 0 ? "-" : contentType.replace(/\s+/g, " ")) + ". Aborting the connection.";
+              }
+              close();
+              var event = new ConnectionEvent("error", {
+                status,
+                statusText,
+                headers: headers2
+              });
+              es.dispatchEvent(event);
+              fire(es, es.onerror, event);
+              console.error(message);
+            }
+          }
+        };
+        var onProgress = function(textChunk) {
+          if (currentState === OPEN) {
+            var n = -1;
+            for (var i = 0; i < textChunk.length; i += 1) {
+              var c = textChunk.charCodeAt(i);
+              if (c === "\n".charCodeAt(0) || c === "\r".charCodeAt(0)) {
+                n = i;
+              }
+            }
+            var chunk = (n !== -1 ? textBuffer : "") + textChunk.slice(0, n + 1);
+            textBuffer = (n === -1 ? textBuffer : "") + textChunk.slice(n + 1);
+            if (textChunk !== "") {
+              wasActivity = Date.now();
+              textLength += textChunk.length;
+            }
+            for (var position = 0; position < chunk.length; position += 1) {
+              var c = chunk.charCodeAt(position);
+              if (state === AFTER_CR && c === "\n".charCodeAt(0)) {
+                state = FIELD_START;
+              } else {
+                if (state === AFTER_CR) {
+                  state = FIELD_START;
+                }
+                if (c === "\r".charCodeAt(0) || c === "\n".charCodeAt(0)) {
+                  if (state !== FIELD_START) {
+                    if (state === FIELD) {
+                      valueStart = position + 1;
+                    }
+                    var field = chunk.slice(fieldStart, valueStart - 1);
+                    var value = chunk.slice(valueStart + (valueStart < position && chunk.charCodeAt(valueStart) === " ".charCodeAt(0) ? 1 : 0), position);
+                    if (field === "data") {
+                      dataBuffer += "\n";
+                      dataBuffer += value;
+                    } else if (field === "id") {
+                      lastEventIdBuffer = value;
+                    } else if (field === "event") {
+                      eventTypeBuffer = value;
+                    } else if (field === "retry") {
+                      initialRetry = parseDuration(value, initialRetry);
+                      retry = initialRetry;
+                    } else if (field === "heartbeatTimeout") {
+                      heartbeatTimeout = parseDuration(value, heartbeatTimeout);
+                      if (timeout !== 0) {
+                        clearTimeout2(timeout);
+                        timeout = setTimeout2(function() {
+                          onTimeout();
+                        }, heartbeatTimeout);
+                      }
+                    }
+                  }
+                  if (state === FIELD_START) {
+                    if (dataBuffer !== "") {
+                      lastEventId = lastEventIdBuffer;
+                      if (eventTypeBuffer === "") {
+                        eventTypeBuffer = "message";
+                      }
+                      var event = new MessageEvent(eventTypeBuffer, {
+                        data: dataBuffer.slice(1),
+                        lastEventId: lastEventIdBuffer
+                      });
+                      es.dispatchEvent(event);
+                      if (eventTypeBuffer === "open") {
+                        fire(es, es.onopen, event);
+                      } else if (eventTypeBuffer === "message") {
+                        fire(es, es.onmessage, event);
+                      } else if (eventTypeBuffer === "error") {
+                        fire(es, es.onerror, event);
+                      }
+                      if (currentState === CLOSED) {
+                        return;
+                      }
+                    }
+                    dataBuffer = "";
+                    eventTypeBuffer = "";
+                  }
+                  state = c === "\r".charCodeAt(0) ? AFTER_CR : FIELD_START;
+                } else {
+                  if (state === FIELD_START) {
+                    fieldStart = position;
+                    state = FIELD;
+                  }
+                  if (state === FIELD) {
+                    if (c === ":".charCodeAt(0)) {
+                      valueStart = position + 1;
+                      state = VALUE_START;
+                    }
+                  } else if (state === VALUE_START) {
+                    state = VALUE;
+                  }
+                }
+              }
+            }
+          }
+        };
+        var onFinish = function(error) {
+          if (currentState === OPEN || currentState === CONNECTING) {
+            currentState = WAITING;
+            if (timeout !== 0) {
+              clearTimeout2(timeout);
+              timeout = 0;
+            }
+            timeout = setTimeout2(function() {
+              onTimeout();
+            }, retry);
+            retry = clampDuration(Math.min(initialRetry * 16, retry * 2));
+            es.readyState = CONNECTING;
+            var event = new ErrorEvent("error", { error });
+            es.dispatchEvent(event);
+            fire(es, es.onerror, event);
+            if (error != void 0) {
+              console.error(error);
+            }
+          }
+        };
+        var close = function() {
+          currentState = CLOSED;
+          if (abortController != void 0) {
+            abortController.abort();
+            abortController = void 0;
+          }
+          if (timeout !== 0) {
+            clearTimeout2(timeout);
+            timeout = 0;
+          }
+          es.readyState = CLOSED;
+        };
+        var onTimeout = function() {
+          timeout = 0;
+          if (currentState !== WAITING) {
+            if (!wasActivity && abortController != void 0) {
+              onFinish(new Error("No activity within " + heartbeatTimeout + " milliseconds. " + (currentState === CONNECTING ? "No response received." : textLength + " chars received.") + " Reconnecting."));
+              if (abortController != void 0) {
+                abortController.abort();
+                abortController = void 0;
+              }
+            } else {
+              var nextHeartbeat = Math.max((wasActivity || Date.now()) + heartbeatTimeout - Date.now(), 1);
+              wasActivity = false;
+              timeout = setTimeout2(function() {
+                onTimeout();
+              }, nextHeartbeat);
+            }
+            return;
+          }
+          wasActivity = false;
+          textLength = 0;
+          timeout = setTimeout2(function() {
+            onTimeout();
+          }, heartbeatTimeout);
+          currentState = CONNECTING;
+          dataBuffer = "";
+          eventTypeBuffer = "";
+          lastEventIdBuffer = lastEventId;
+          textBuffer = "";
+          fieldStart = 0;
+          valueStart = 0;
+          state = FIELD_START;
+          var requestURL = url;
+          if (url.slice(0, 5) !== "data:" && url.slice(0, 5) !== "blob:") {
+            if (lastEventId !== "") {
+              var i = url.indexOf("?");
+              requestURL = i === -1 ? url : url.slice(0, i + 1) + url.slice(i + 1).replace(/(?:^|&)([^=&]*)(?:=[^&]*)?/g, function(p, paramName) {
+                return paramName === lastEventIdQueryParameterName ? "" : p;
+              });
+              requestURL += (url.indexOf("?") === -1 ? "?" : "&") + lastEventIdQueryParameterName + "=" + encodeURIComponent(lastEventId);
+            }
+          }
+          var withCredentials2 = es.withCredentials;
+          var requestHeaders = {};
+          requestHeaders["Accept"] = "text/event-stream";
+          var headers2 = es.headers;
+          if (headers2 != void 0) {
+            for (var name in headers2) {
+              if (Object.prototype.hasOwnProperty.call(headers2, name)) {
+                requestHeaders[name] = headers2[name];
+              }
+            }
+          }
+          try {
+            abortController = transport.open(xhr, onStart, onProgress, onFinish, requestURL, withCredentials2, requestHeaders);
+          } catch (error) {
+            close();
+            throw error;
+          }
+        };
+        es.url = url;
+        es.readyState = CONNECTING;
+        es.withCredentials = withCredentials;
+        es.headers = headers;
+        es._close = close;
+        onTimeout();
+      }
+      EventSourcePolyfill.prototype = Object.create(EventTarget.prototype);
+      EventSourcePolyfill.prototype.CONNECTING = CONNECTING;
+      EventSourcePolyfill.prototype.OPEN = OPEN;
+      EventSourcePolyfill.prototype.CLOSED = CLOSED;
+      EventSourcePolyfill.prototype.close = function() {
+        this._close();
+      };
+      EventSourcePolyfill.CONNECTING = CONNECTING;
+      EventSourcePolyfill.OPEN = OPEN;
+      EventSourcePolyfill.CLOSED = CLOSED;
+      EventSourcePolyfill.prototype.withCredentials = void 0;
+      var R = NativeEventSource;
+      if (XMLHttpRequest != void 0 && (NativeEventSource == void 0 || !("withCredentials" in NativeEventSource.prototype))) {
+        R = EventSourcePolyfill;
+      }
+      (function(factory) {
+        if (typeof module === "object" && typeof module.exports === "object") {
+          var v = factory(exports);
+          if (v !== void 0)
+            module.exports = v;
+        } else if (typeof define === "function" && define.amd) {
+          define(["exports"], factory);
+        } else {
+          factory(global);
+        }
+      })(function(exports2) {
+        exports2.EventSourcePolyfill = EventSourcePolyfill;
+        exports2.NativeEventSource = NativeEventSource;
+        exports2.EventSource = R;
+      });
+    })(typeof globalThis === "undefined" ? typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : exports : globalThis);
+  }
+});
+
+// node_modules/@sanity/eventsource/browser.js
+var require_browser = __commonJS({
+  "node_modules/@sanity/eventsource/browser.js"(exports, module) {
+    var evs = require_eventsource();
+    module.exports = evs.EventSourcePolyfill;
+  }
+});
+
+// node_modules/make-error/index.js
+var require_make_error = __commonJS({
+  "node_modules/make-error/index.js"(exports, module) {
+    "use strict";
+    var construct = typeof Reflect !== "undefined" ? Reflect.construct : void 0;
+    var defineProperty = Object.defineProperty;
+    var captureStackTrace = Error.captureStackTrace;
+    if (captureStackTrace === void 0) {
+      captureStackTrace = function captureStackTrace2(error) {
+        var container = new Error();
+        defineProperty(error, "stack", {
+          configurable: true,
+          get: function getStack() {
+            var stack = container.stack;
+            defineProperty(this, "stack", {
+              configurable: true,
+              value: stack,
+              writable: true
+            });
+            return stack;
+          },
+          set: function setStack(stack) {
+            defineProperty(error, "stack", {
+              configurable: true,
+              value: stack,
+              writable: true
+            });
+          }
+        });
+      };
+    }
+    function BaseError(message) {
+      if (message !== void 0) {
+        defineProperty(this, "message", {
+          configurable: true,
+          value: message,
+          writable: true
+        });
+      }
+      var cname = this.constructor.name;
+      if (cname !== void 0 && cname !== this.name) {
+        defineProperty(this, "name", {
+          configurable: true,
+          value: cname,
+          writable: true
+        });
+      }
+      captureStackTrace(this, this.constructor);
+    }
+    BaseError.prototype = Object.create(Error.prototype, {
+      constructor: {
+        configurable: true,
+        value: BaseError,
+        writable: true
+      }
+    });
+    var setFunctionName = function() {
+      function setFunctionName2(fn, name) {
+        return defineProperty(fn, "name", {
+          configurable: true,
+          value: name
+        });
+      }
+      try {
+        var f = function() {
+        };
+        setFunctionName2(f, "foo");
+        if (f.name === "foo") {
+          return setFunctionName2;
+        }
+      } catch (_) {
+      }
+    }();
+    function makeError2(constructor, super_) {
+      if (super_ == null || super_ === Error) {
+        super_ = BaseError;
+      } else if (typeof super_ !== "function") {
+        throw new TypeError("super_ should be a function");
+      }
+      var name;
+      if (typeof constructor === "string") {
+        name = constructor;
+        constructor = construct !== void 0 ? function() {
+          return construct(super_, arguments, this.constructor);
+        } : function() {
+          super_.apply(this, arguments);
+        };
+        if (setFunctionName !== void 0) {
+          setFunctionName(constructor, name);
+          name = void 0;
+        }
+      } else if (typeof constructor !== "function") {
+        throw new TypeError("constructor should be either a string or a function");
+      }
+      constructor.super_ = constructor["super"] = super_;
+      var properties = {
+        constructor: {
+          configurable: true,
+          value: constructor,
+          writable: true
+        }
+      };
+      if (name !== void 0) {
+        properties.name = {
+          configurable: true,
+          value: name,
+          writable: true
+        };
+      }
+      constructor.prototype = Object.create(super_.prototype, properties);
+      return constructor;
+    }
+    exports = module.exports = makeError2;
+    exports.BaseError = BaseError;
+  }
+});
+
+// src/util/observable.js
+var import_Observable = __toESM(require_Observable());
+var import_filter = __toESM(require_filter());
+var import_map = __toESM(require_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 require_patch = __commonJS({
-  "src/data/patch.js"(exports, module) {
-    var assign = __require("object-assign");
-    var getSelection = require_getSelection();
-    var validate = require_validators();
-    var validateObject = validate.validateObject;
-    var validateInsert = validate.validateInsert;
-    function Patch(selection, operations = {}, client = null) {
-      this.selection = selection;
-      this.operations = assign({}, operations);
-      this.client = client;
+function Patch(selection, operations = {}, client = null) {
+  this.selection = selection;
+  this.operations = Object.assign({}, operations);
+  this.client = client;
+}
+Object.assign(Patch.prototype, {
+  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");
     }
-    assign(Patch.prototype, {
-      clone() {
-        return new Patch(this.selection, 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 = 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 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 = 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 = assign({}, this.operations, {
-          [op]: assign({}, merge && this.operations[op] || {}, props)
-        });
-        return this;
-      }
+    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)
     });
-    module.exports = Patch;
+    return this;
   }
 });
+var patch_default = Patch;
 
 // src/data/transaction.js
-var require_transaction = __commonJS({
-  "src/data/transaction.js"(exports, module) {
-    var assign = __require("object-assign");
-    var validators = require_validators();
-    var Patch = require_patch();
-    var defaultMutateOptions = { returnDocuments: false };
-    function Transaction(operations = [], client, transactionId) {
-      this.trxId = transactionId;
-      this.operations = operations;
-      this.client = client;
+var defaultMutateOptions = { returnDocuments: false };
+function Transaction(operations = [], client, transactionId) {
+  this.trxId = transactionId;
+  this.operations = operations;
+  this.client = client;
+}
+Object.assign(Transaction.prototype, {
+  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_default;
+    if (isPatch) {
+      return this._add({ patch: documentId.serialize() });
     }
-    assign(Transaction.prototype, {
-      clone() {
-        return new Transaction(this.operations.slice(0), this.client, this.trxId);
-      },
-      create(doc) {
-        validators.validateObject("create", doc);
-        return this._add({ create: doc });
-      },
-      createIfNotExists(doc) {
-        const op = "createIfNotExists";
-        validators.validateObject(op, doc);
-        validators.requireDocumentId(op, doc);
-        return this._add({ [op]: doc });
-      },
-      createOrReplace(doc) {
-        const op = "createOrReplace";
-        validators.validateObject(op, doc);
-        validators.requireDocumentId(op, doc);
-        return this._add({ [op]: doc });
-      },
-      delete(documentId) {
-        validators.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: 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(),
-          assign({ transactionId: this.trxId }, defaultMutateOptions, options || {})
-        );
-      },
-      reset() {
-        this.operations = [];
-        return this;
-      },
-      _add(mut) {
-        this.operations.push(mut);
-        return this;
+    if (isBuilder) {
+      const patch = patchOps(new patch_default(documentId, {}, this.client));
+      if (!(patch instanceof patch_default)) {
+        throw new Error("function passed to `patch()` must return the patch");
       }
-    });
-    module.exports = Transaction;
+      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;
   }
 });
+var transaction_default = Transaction;
 
 // src/data/encodeQueryString.js
-var require_encodeQueryString = __commonJS({
-  "src/data/encodeQueryString.js"(exports, module) {
-    var enc = encodeURIComponent;
-    module.exports = ({ 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);
-    };
-  }
-});
+var enc = encodeURIComponent;
+var encodeQueryString_default = ({ 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
+var import_eventsource = __toESM(require_browser());
 
 // src/util/pick.js
-var require_pick = __commonJS({
-  "src/util/pick.js"(exports, module) {
-    module.exports = (obj, props) => props.reduce((selection, prop) => {
-      if (typeof obj[prop] === "undefined") {
-        return selection;
-      }
-      selection[prop] = obj[prop];
-      return selection;
-    }, {});
+var pick_default = (obj, props) => props.reduce((selection, prop) => {
+  if (typeof obj[prop] === "undefined") {
+    return selection;
   }
-});
+  selection[prop] = obj[prop];
+  return selection;
+}, {});
 
 // src/util/defaults.js
-var require_defaults = __commonJS({
-  "src/util/defaults.js"(exports, module) {
-    module.exports = (obj, defaults) => Object.keys(defaults).concat(Object.keys(obj)).reduce((target, prop) => {
-      target[prop] = typeof obj[prop] === "undefined" ? defaults[prop] : obj[prop];
-      return target;
-    }, {});
-  }
-});
+var defaults_default = (obj, defaults) => Object.keys(defaults).concat(Object.keys(obj)).reduce((target, prop) => {
+  target[prop] = typeof obj[prop] === "undefined" ? defaults[prop] : obj[prop];
+  return target;
+}, {});
 
 // src/data/listen.js
-var require_listen = __commonJS({
-  "src/data/listen.js"(exports, module) {
-    var assign = __require("object-assign");
-    var { Observable } = require_observable();
-    var polyfilledEventSource = __require("@sanity/eventsource");
-    var pick = require_pick();
-    var defaults = require_defaults();
-    var encodeQueryString = require_encodeQueryString();
-    var MAX_URL_LENGTH = 16e3 - 1200;
-    var EventSource = polyfilledEventSource;
-    var possibleOptions = [
-      "includePreviousRevision",
-      "includeResult",
-      "visibility",
-      "effectFormat",
-      "tag"
-    ];
-    var defaultOptions = {
-      includeResult: true
+var MAX_URL_LENGTH = 16e3 - 1200;
+var EventSource = import_eventsource.default;
+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_default(opts, defaultOptions), tag };
+  const listenOpts = pick_default(options, possibleOptions);
+  const qs = encodeQueryString_default({ query, params, options: listenOpts, tag });
+  const uri = `${url}${this.getDataUrl("listen", qs)}`;
+  if (uri.length > MAX_URL_LENGTH) {
+    return new import_Observable.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}`
     };
-    module.exports = 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;
+  }
+  return new import_Observable.Observable((observer) => {
+    let es = getEventSource();
+    let reconnectTimer;
+    let stopped = false;
+    function onError() {
+      if (stopped) {
+        return;
       }
-      if (token) {
-        esOptions.headers = {
-          Authorization: `Bearer ${token}`
-        };
+      emitReconnect();
+      if (stopped) {
+        return;
       }
-      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 assign({ type: event.type }, data);
-      } catch (err) {
-        return err;
+      if (es.readyState === EventSource.CLOSED) {
+        unsubscribe();
+        clearTimeout(reconnectTimer);
+        reconnectTimer = setTimeout(open, 100);
       }
     }
-    function cooerceError(err) {
-      if (err instanceof Error) {
-        return err;
-      }
-      const evt = parseEvent(err);
-      return evt instanceof Error ? evt : new Error(extractErrorMessage(evt));
+    function onChannelError(err) {
+      observer.error(cooerceError(err));
     }
-    function extractErrorMessage(err) {
-      if (!err.error) {
-        return err.message || "Unknown listener error";
-      }
-      if (err.error.description) {
-        return err.error.description;
+    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" });
       }
-      return typeof err.error === "string" ? err.error : JSON.stringify(err.error, null, 2);
     }
+    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 require_dataMethods = __commonJS({
-  "src/data/dataMethods.js"(exports, module) {
-    var assign = __require("object-assign");
-    var { map, filter } = require_observable();
-    var validators = require_validators();
-    var getSelection = require_getSelection();
-    var encodeQueryString = require_encodeQueryString();
-    var Transaction = require_transaction();
-    var Patch = require_patch();
-    var listen = require_listen();
-    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 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_default = {
+  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((0, import_map.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(
+      (0, import_filter.filter)(isResponse),
+      (0, import_map.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(
+      (0, import_filter.filter)(isResponse),
+      (0, import_map.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_default(selector, operations, this);
+  },
+  delete(selection, options) {
+    return this.dataRequest("mutate", { mutations: [{ delete: getSelection(selection) }] }, options);
+  },
+  mutate(mutations, options) {
+    const mut = mutations instanceof patch_default || mutations instanceof transaction_default ? 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_default(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_default(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
     };
-    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 = (observable) => observable.toPromise();
-    var getQuerySizeLimit = 11264;
-    module.exports = {
-      listen,
-      getDataUrl(operation, path) {
-        const config = this.clientConfig;
-        const catalog = validators.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 observable = this._dataRequest("query", { query, params }, options).pipe(map(mapResponse));
-        return this.isPromiseAPI() ? toPromise(observable) : observable;
-      },
-      getDocument(id, opts = {}) {
-        const options = { uri: this.getDataUrl("doc", id), json: true, tag: opts.tag };
-        const observable = this._requestObservable(options).pipe(
-          filter(isResponse),
-          map((event) => event.body.documents && event.body.documents[0])
-        );
-        return this.isPromiseAPI() ? toPromise(observable) : observable;
-      },
-      getDocuments(ids, opts = {}) {
-        const options = { uri: this.getDataUrl("doc", ids.join(",")), json: true, tag: opts.tag };
-        const observable = 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(observable) : observable;
-      },
-      create(doc, options) {
-        return this._create(doc, "create", options);
-      },
-      createIfNotExists(doc, options) {
-        validators.requireDocumentId("createIfNotExists", doc);
-        return this._create(doc, "createIfNotExists", options);
-      },
-      createOrReplace(doc, options) {
-        validators.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 request = this._dataRequest(endpoint, body, options);
-        return this.isPromiseAPI() ? toPromise(request) : request;
-      },
-      _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(
+      (0, import_filter.filter)(isResponse),
+      (0, import_map.map)(getBody),
+      (0, import_map.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
         };
-        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 = assign({ returnFirst: true, returnDocuments: true }, options);
-        return this.dataRequest("mutate", { mutations: [mutation] }, opts);
-      }
-    };
+      })
+    );
+  },
+  _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 require_datasetsClient = __commonJS({
-  "src/datasets/datasetsClient.js"(exports, module) {
-    var assign = __require("object-assign");
-    var validate = require_validators();
-    function DatasetsClient(client) {
-      this.request = client.request.bind(client);
-    }
-    assign(DatasetsClient.prototype, {
-      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) {
-        validate.dataset(name);
-        return this.request({ method, uri: `/datasets/${name}`, body });
-      }
-    });
-    module.exports = DatasetsClient;
+function DatasetsClient(client) {
+  this.request = client.request.bind(client);
+}
+Object.assign(DatasetsClient.prototype, {
+  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 });
   }
 });
+var datasetsClient_default = DatasetsClient;
 
 // src/projects/projectsClient.js
-var require_projectsClient = __commonJS({
-  "src/projects/projectsClient.js"(exports, module) {
-    var assign = __require("object-assign");
-    function ProjectsClient(client) {
-      this.client = client;
-    }
-    assign(ProjectsClient.prototype, {
-      list() {
-        return this.client.request({ uri: "/projects" });
-      },
-      getById(id) {
-        return this.client.request({ uri: `/projects/${id}` });
-      }
-    });
-    module.exports = ProjectsClient;
+function ProjectsClient(client) {
+  this.client = client;
+}
+Object.assign(ProjectsClient.prototype, {
+  list() {
+    return this.client.request({ uri: "/projects" });
+  },
+  getById(id) {
+    return this.client.request({ uri: `/projects/${id}` });
   }
 });
+var projectsClient_default = ProjectsClient;
 
 // src/http/queryString.js
-var require_queryString = __commonJS({
-  "src/http/queryString.js"(exports, module) {
-    module.exports = (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("&")}` : "";
-    };
+var queryString_default = (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 require_assetsClient = __commonJS({
-  "src/assets/assetsClient.js"(exports, module) {
-    var assign = __require("object-assign");
-    var { map, filter } = require_observable();
-    var queryString = require_queryString();
-    var validators = require_validators();
-    function AssetsClient(client) {
-      this.client = client;
+function AssetsClient(client) {
+  this.client = client;
+}
+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
+  );
+}
+Object.assign(AssetsClient.prototype, {
+  upload(assetType, body, opts = {}) {
+    validateAssetType(assetType);
+    let meta = opts.extract || void 0;
+    if (meta && !meta.length) {
+      meta = ["none"];
     }
-    function optionsFromFile(opts, file) {
-      if (typeof window === "undefined" || !(file instanceof window.File)) {
-        return opts;
-      }
-      return assign(
-        {
-          filename: opts.preserveFilename === false ? void 0 : file.name,
-          contentType: file.type
-        },
-        opts
-      );
+    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;
     }
-    assign(AssetsClient.prototype, {
-      upload(assetType, body, opts = {}) {
-        validators.validateAssetType(assetType);
-        let meta = opts.extract || void 0;
-        if (meta && !meta.length) {
-          meta = ["none"];
-        }
-        const dataset = validators.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 observable = this.client._requestObservable({
-          tag,
-          method: "POST",
-          timeout: options.timeout || 0,
-          uri: `/assets/${assetEndpoint}/${dataset}`,
-          headers: options.contentType ? { "Content-Type": options.contentType } : {},
-          query,
-          body
-        });
-        return this.client.isPromiseAPI() ? observable.pipe(
-          filter((event) => event.type === "response"),
-          map((event) => event.body.document)
-        ).toPromise() : observable;
-      },
-      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;
-        }
-        validators.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("-");
-        validators.hasDataset(this.client.clientConfig);
-        const { projectId, dataset } = this.client.clientConfig;
-        const qs = query ? queryString(query) : "";
-        return `https://cdn.sanity.io/images/${projectId}/${dataset}/${assetId}-${size}.${format}${qs}`;
-      }
+    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
     });
-    module.exports = AssetsClient;
+    return this.client.isPromiseAPI() ? observable2.pipe(
+      (0, import_filter.filter)((event) => event.type === "response"),
+      (0, import_map.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_default(query) : "";
+    return `https://cdn.sanity.io/images/${projectId2}/${dataset2}/${assetId}-${size}.${format}${qs}`;
   }
 });
+var assetsClient_default = AssetsClient;
 
 // src/users/usersClient.js
-var require_usersClient = __commonJS({
-  "src/users/usersClient.js"(exports, module) {
-    var assign = __require("object-assign");
-    function UsersClient(client) {
-      this.client = client;
-    }
-    assign(UsersClient.prototype, {
-      getById(id) {
-        return this.client.request({ uri: `/users/${id}` });
-      }
-    });
-    module.exports = UsersClient;
+function UsersClient(client) {
+  this.client = client;
+}
+Object.assign(UsersClient.prototype, {
+  getById(id) {
+    return this.client.request({ uri: `/users/${id}` });
   }
 });
+var usersClient_default = UsersClient;
 
 // src/auth/authClient.js
-var require_authClient = __commonJS({
-  "src/auth/authClient.js"(exports, module) {
-    var assign = __require("object-assign");
-    function AuthClient(client) {
-      this.client = client;
-    }
-    assign(AuthClient.prototype, {
-      getLoginProviders() {
-        return this.client.request({ uri: "/auth/providers" });
-      },
-      logout() {
-        return this.client.request({ uri: "/auth/logout", method: "POST" });
-      }
-    });
-    module.exports = AuthClient;
+function AuthClient(client) {
+  this.client = client;
+}
+Object.assign(AuthClient.prototype, {
+  getLoginProviders() {
+    return this.client.request({ uri: "/auth/providers" });
+  },
+  logout() {
+    return this.client.request({ uri: "/auth/logout", method: "POST" });
   }
 });
+var authClient_default = AuthClient;
+
+// src/http/request.js
+import getIt from "get-it";
+import { observable, jsonRequest, jsonResponse, progress } from "get-it/middleware";
 
 // src/http/errors.js
-var require_errors = __commonJS({
-  "src/http/errors.js"(exports) {
-    var makeError = __require("make-error");
-    var assign = __require("object-assign");
-    function ClientError(res) {
-      const props = extractErrorProps(res);
-      ClientError.super.call(this, props.message);
-      assign(this, props);
-    }
-    function ServerError(res) {
-      const props = extractErrorProps(res);
-      ServerError.super.call(this, props.message);
-      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);
-    exports.ClientError = ClientError;
-    exports.ServerError = ServerError;
+var import_make_error = __toESM(require_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;
+}
+(0, import_make_error.default)(ClientError);
+(0, import_make_error.default)(ServerError);
 
 // src/http/browserMiddleware.js
-var require_browserMiddleware = __commonJS({
-  "src/http/browserMiddleware.js"(exports, module) {
-    module.exports = [];
-  }
-});
+var browserMiddleware_default = [];
 
 // src/http/request.js
-var require_request = __commonJS({
-  "src/http/request.js"(exports, module) {
-    var getIt = __require("get-it");
-    var assign = __require("object-assign");
-    var observable = __require("get-it/lib/middleware/observable");
-    var jsonRequest = __require("get-it/lib/middleware/jsonRequest");
-    var jsonResponse = __require("get-it/lib/middleware/jsonResponse");
-    var progress = __require("get-it/lib/middleware/progress");
-    var { Observable } = require_observable();
-    var { ClientError, ServerError } = require_errors();
-    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 envSpecific = require_browserMiddleware();
-    var middleware = envSpecific.concat([
-      printWarnings,
-      jsonRequest(),
-      jsonResponse(),
-      progress(),
-      httpError,
-      observable({ implementation: Observable })
-    ]);
-    var request = getIt(middleware);
-    function httpRequest(options, requester = request) {
-      return requester(assign({ maxRedirects: 0 }, options));
+var httpError = {
+  onResponse: (res) => {
+    if (res.statusCode >= 500) {
+      throw new ServerError(res);
+    } else if (res.statusCode >= 400) {
+      throw new ClientError(res);
     }
-    httpRequest.defaultRequester = request;
-    httpRequest.ClientError = ClientError;
-    httpRequest.ServerError = ServerError;
-    module.exports = httpRequest;
+    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 envSpecific = browserMiddleware_default;
+var middleware = envSpecific.concat([
+  printWarnings,
+  jsonRequest(),
+  jsonResponse(),
+  progress(),
+  httpError,
+  observable({ implementation: import_Observable.Observable })
+]);
+var request = getIt(middleware);
+function httpRequest(options, requester = request) {
+  return requester(Object.assign({ maxRedirects: 0 }, options));
+}
+httpRequest.defaultRequester = request;
+httpRequest.ClientError = ClientError;
+httpRequest.ServerError = ServerError;
+var request_default = httpRequest;
 
 // src/http/requestOptions.js
-var require_requestOptions = __commonJS({
-  "src/http/requestOptions.js"(exports, module) {
-    var assign = __require("object-assign");
-    var projectHeader = "X-Sanity-Project-ID";
-    module.exports = (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 assign({}, overrides, {
-        headers: assign({}, headers, overrides.headers || {}),
-        timeout: typeof timeout === "undefined" ? 5 * 60 * 1e3 : timeout,
-        proxy: overrides.proxy || config.proxy,
-        json: true,
-        withCredentials
-      });
-    };
+var projectHeader = "X-Sanity-Project-ID";
+var requestOptions_default = (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/generateHelpUrl.js
-var require_generateHelpUrl = __commonJS({
-  "src/generateHelpUrl.js"(exports, module) {
-    var BASE_URL = "https://docs.sanity.io/help/";
-    module.exports = function generateHelpUrl(slug) {
-      return BASE_URL + slug;
-    };
-  }
-});
+var BASE_URL = "https://docs.sanity.io/help/";
+function generateHelpUrl(slug) {
+  return BASE_URL + slug;
+}
 
 // src/util/once.js
-var require_once = __commonJS({
-  "src/util/once.js"(exports, module) {
-    module.exports = (fn) => {
-      let didCall = false;
-      let returnValue;
-      return (...args) => {
-        if (didCall) {
-          return returnValue;
-        }
-        returnValue = fn(...args);
-        didCall = true;
-        return returnValue;
-      };
-    };
-  }
-});
+var once_default = (fn) => {
+  let didCall = false;
+  let returnValue;
+  return (...args) => {
+    if (didCall) {
+      return returnValue;
+    }
+    returnValue = fn(...args);
+    didCall = true;
+    return returnValue;
+  };
+};
 
 // src/warnings.js
-var require_warnings = __commonJS({
-  "src/warnings.js"(exports) {
-    var generateHelpUrl = require_generateHelpUrl();
-    var once = require_once();
-    var createWarningPrinter = (message) => once((...args) => console.warn(message.join(" "), ...args));
-    exports.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."
-    ]);
-    exports.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.`
-    ]);
-    exports.printNoApiVersionSpecifiedWarning = createWarningPrinter([
-      "Using the Sanity client without specifying an API version is deprecated.",
-      `See ${generateHelpUrl("js-client-api-version")}`
-    ]);
-  }
-});
+var createWarningPrinter = (message) => once_default((...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 require_config = __commonJS({
-  "src/config.js"(exports) {
-    var assign = __require("object-assign");
-    var generateHelpUrl = require_generateHelpUrl();
-    var validate = require_validators();
-    var warnings = require_warnings();
-    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;
-    exports.defaultConfig = defaultConfig;
-    exports.initConfig = (config, prevConfig) => {
-      const specifiedConfig = assign({}, prevConfig, config);
-      if (!specifiedConfig.apiVersion) {
-        warnings.printNoApiVersionSpecifiedWarning();
-      }
-      const newConfig = assign({}, defaultConfig, specifiedConfig);
-      const projectBased = newConfig.useProjectHostname;
-      if (typeof Promise === "undefined") {
-        const helpUrl = generateHelpUrl("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) {
-        warnings.printBrowserTokenWarning();
-      } else if (typeof newConfig.useCdn === "undefined") {
-        warnings.printCdnWarning();
-      }
-      if (projectBased) {
-        validate.projectId(newConfig.projectId);
-      }
-      if (newConfig.dataset) {
-        validate.dataset(newConfig.dataset);
-      }
-      if ("requestTagPrefix" in newConfig) {
-        newConfig.requestTagPrefix = newConfig.requestTagPrefix ? validate.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;
-      exports.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;
-    };
-    exports.validateApiVersion = 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`");
-      }
-    };
+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 validateApiVersion = function validateApiVersion2(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`");
+  }
+};
+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 = generateHelpUrl("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;
+};
 
 // src/sanityClient.js
-var require_sanityClient = __commonJS({
-  "src/sanityClient.js"(exports, module) {
-    var assign = __require("object-assign");
-    var { Observable, map, filter } = require_observable();
-    var Patch = require_patch();
-    var Transaction = require_transaction();
-    var dataMethods = require_dataMethods();
-    var DatasetsClient = require_datasetsClient();
-    var ProjectsClient = require_projectsClient();
-    var AssetsClient = require_assetsClient();
-    var UsersClient = require_usersClient();
-    var AuthClient = require_authClient();
-    var httpRequest = require_request();
-    var getRequestOptions = require_requestOptions();
-    var { defaultConfig, initConfig } = require_config();
-    var validate = require_validators();
-    var toPromise = (observable) => observable.toPromise();
-    function SanityClient(config = defaultConfig) {
-      if (!(this instanceof SanityClient)) {
-        return new SanityClient(config);
-      }
-      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 = assign({}, this.clientConfig, { isPromiseAPI: false });
-        this.observable = new SanityClient(observableConfig);
-      }
+var toPromise2 = (observable2) => observable2.toPromise();
+function SanityClient(config = defaultConfig) {
+  if (!(this instanceof SanityClient)) {
+    return new SanityClient(config);
+  }
+  this.config(config);
+  this.assets = new assetsClient_default(this);
+  this.datasets = new datasetsClient_default(this);
+  this.projects = new projectsClient_default(this);
+  this.users = new usersClient_default(this);
+  this.auth = new authClient_default(this);
+  if (this.clientConfig.isPromiseAPI) {
+    const observableConfig = Object.assign({}, this.clientConfig, { isPromiseAPI: false });
+    this.observable = new SanityClient(observableConfig);
+  }
+}
+Object.assign(SanityClient.prototype, dataMethods_default);
+Object.assign(SanityClient.prototype, {
+  clone() {
+    return new SanityClient(this.config());
+  },
+  config(newConfig) {
+    if (typeof newConfig === "undefined") {
+      return Object.assign({}, this.clientConfig);
     }
-    assign(SanityClient.prototype, dataMethods);
-    assign(SanityClient.prototype, {
-      clone() {
-        return new SanityClient(this.config());
-      },
-      config(newConfig) {
-        if (typeof newConfig === "undefined") {
-          return assign({}, this.clientConfig);
-        }
-        if (this.observable) {
-          const observableConfig = 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: validate.requestTag(tag), ...options.query };
-        }
-        const reqOptions = getRequestOptions(
-          this.clientConfig,
-          assign({}, options, {
-            url: this.getUrl(uri, useCdn)
-          })
-        );
-        return new Observable(
-          (subscriber) => httpRequest(reqOptions, this.clientConfig.requester).subscribe(subscriber)
-        );
-      },
-      request(options) {
-        const observable = this._requestObservable(options).pipe(
-          filter((event) => event.type === "response"),
-          map((event) => event.body)
-        );
-        return this.isPromiseAPI() ? toPromise(observable) : observable;
-      }
-    });
-    SanityClient.Patch = Patch;
-    SanityClient.Transaction = Transaction;
-    SanityClient.ClientError = httpRequest.ClientError;
-    SanityClient.ServerError = httpRequest.ServerError;
-    SanityClient.requester = httpRequest.defaultRequester;
-    module.exports = SanityClient;
+    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_default(
+      this.clientConfig,
+      Object.assign({}, options, {
+        url: this.getUrl(uri, useCdn)
+      })
+    );
+    return new import_Observable.Observable(
+      (subscriber) => request_default(reqOptions, this.clientConfig.requester).subscribe(subscriber)
+    );
+  },
+  request(options) {
+    const observable2 = this._requestObservable(options).pipe(
+      (0, import_filter.filter)((event) => event.type === "response"),
+      (0, import_map.map)((event) => event.body)
+    );
+    return this.isPromiseAPI() ? toPromise2(observable2) : observable2;
   }
 });
-export default require_sanityClient();
+SanityClient.Patch = patch_default;
+SanityClient.Transaction = transaction_default;
+SanityClient.ClientError = request_default.ClientError;
+SanityClient.ServerError = request_default.ServerError;
+SanityClient.requester = request_default.defaultRequester;
+var sanityClient_default = SanityClient;
+export {
+  sanityClient_default as default
+};
+/** @license
+ * eventsource.js
+ * Available under MIT License (MIT)
+ * https://github.com/Yaffle/EventSource/
+ */
 //# sourceMappingURL=sanityClient.browser.mjs.map