@sanity/client 6.24.0 → 6.25.0-alpha.0

package/umd/sanityClient.js

@@ -4,6 +4,21 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SanityClient = {}));
 })(this, (function (exports) { 'use strict';
 
+  function _mergeNamespaces(n, m) {
+    m.forEach(function (e) {
+      e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+        if (k !== 'default' && !(k in n)) {
+          var d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: function () { return e[k]; }
+          });
+        }
+      });
+    });
+    return Object.freeze(n);
+  }
+
   const e=!(typeof navigator>"u")&&"ReactNative"===navigator.product,t={timeout:e?6e4:12e4},r=function(r){const a={...t,..."string"==typeof r?{url:r}:r};if(a.timeout=n$1(a.timeout),a.query){const{url:t,searchParams:r}=function(t){const r=t.indexOf("?");if(-1===r)return {url:t,searchParams:new URLSearchParams};const n=t.slice(0,r),a=t.slice(r+1);if(!e)return {url:n,searchParams:new URLSearchParams(a)};if("function"!=typeof decodeURIComponent)throw new Error("Broken `URLSearchParams` implementation, and `decodeURIComponent` is not defined");const s=new URLSearchParams;for(const e of a.split("&")){const[t,r]=e.split("=");t&&s.append(o$1(t),o$1(r||""));}return {url:n,searchParams:s}}(a.url);for(const[e,o]of Object.entries(a.query)){if(void 0!==o)if(Array.isArray(o))for(const t of o)r.append(e,t);else r.append(e,o);const n=r.toString();n&&(a.url=`${t}?${n}`);}}return a.method=a.body&&!a.method?"POST":(a.method||"GET").toUpperCase(),a};function o$1(e){return decodeURIComponent(e.replace(/\+/g," "))}function n$1(e){if(!1===e||0===e)return !1;if(e.connect||e.socket)return e;const r=Number(e);return isNaN(r)?n$1(t.timeout):{connect:r,socket:r}}const a$2=/^https?:\/\//i,s$2=function(e){if(!a$2.test(e.url))throw new Error(`"${e.url}" is not a valid URL`)};function c$3(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}
 
   const o=["request","response","progress","error","abort"],s$1=["processOptions","validateOptions","interceptRequest","finalizeOptions","onRequest","onResponse","onError","onReturn","onHeaders"];function n(r$1,a){const i=[],u=s$1.reduce(((e,t)=>(e[t]=e[t]||[],e)),{processOptions:[r],validateOptions:[s$2]});function l(e){const t=o.reduce(((e,t)=>(e[t]=function(){const e=Object.create(null);let t=0;return {publish:function(t){for(const r in e)e[r](t);},subscribe:function(r){const o=t++;return e[o]=r,function(){delete e[o];}}}}(),e)),{}),r=(e=>function(t,r,...o){const s="onError"===t;let n=r;for(let r=0;r<e[t].length&&(n=(0, e[t][r])(n,...o),!s||n);r++);return n})(u),s=r("processOptions",e);r("validateOptions",s);const n={options:s,channels:t,applyMiddleware:r};let i;const l=t.request.subscribe((e=>{i=a(e,((o,s)=>((e,o,s)=>{let n=e,a=o;if(!n)try{a=r("onResponse",o,s);}catch(e){a=null,n=e;}n=n&&r("onError",n,s),n?t.error.publish(n):a&&t.response.publish(a);})(o,s,e)));}));t.abort.subscribe((()=>{l(),i&&i.abort();}));const c=r("onReturn",t,n);return c===t&&t.request.publish(n),c}return l.use=function(e){if(!e)throw new Error("Tried to add middleware that resolved to falsey value");if("function"==typeof e)throw new Error("Tried to add middleware that was a function. It probably expects you to pass options to it.");if(e.onReturn&&u.onReturn.length>0)throw new Error("Tried to add new middleware with `onReturn` handler, but another handler has already been registered for this event");return s$1.forEach((t=>{e[t]&&u[t].push(e[t]);})),i.push(e),l},l.clone=()=>n(i,a),r$1.forEach(l.use),l}var a$1=function(e){return e.replace(/^\s+|\s+$/g,"")},i=c$3((function(e){if(!e)return {};for(var t={},r=a$1(e).split("\n"),o=0;o<r.length;o++){var s=r[o],n=s.indexOf(":"),i=a$1(s.slice(0,n)).toLowerCase(),u=a$1(s.slice(n+1));typeof t[i]>"u"?t[i]=u:(l=t[i],"[object Array]"===Object.prototype.toString.call(l)?t[i].push(u):t[i]=[t[i],u]);}var l;return t}));let u$2 = class u{onabort;onerror;onreadystatechange;ontimeout;readyState=0;response;responseText="";responseType="";status;statusText;withCredentials;#e;#t;#r;#o={};#s;#n={};#a;open(e,t,r){this.#e=e,this.#t=t,this.#r="",this.readyState=1,this.onreadystatechange?.(),this.#s=void 0;}abort(){this.#s&&this.#s.abort();}getAllResponseHeaders(){return this.#r}setRequestHeader(e,t){this.#o[e]=t;}setInit(e,t=!0){this.#n=e,this.#a=t;}send(e){const t="arraybuffer"!==this.responseType,r={...this.#n,method:this.#e,headers:this.#o,body:e};"function"==typeof AbortController&&this.#a&&(this.#s=new AbortController,typeof EventTarget<"u"&&this.#s.signal instanceof EventTarget&&(r.signal=this.#s.signal)),typeof document<"u"&&(r.credentials=this.withCredentials?"include":"omit"),fetch(this.#t,r).then((e=>(e.headers.forEach(((e,t)=>{this.#r+=`${t}: ${e}\r\n`;})),this.status=e.status,this.statusText=e.statusText,this.readyState=3,this.onreadystatechange?.(),t?e.text():e.arrayBuffer()))).then((e=>{"string"==typeof e?this.responseText=e:this.response=e,this.readyState=4,this.onreadystatechange?.();})).catch((e=>{"AbortError"!==e.name?this.onerror?.(e):this.onabort?.();}));}};const l$1="function"==typeof XMLHttpRequest?"xhr":"fetch",c$2="xhr"===l$1?XMLHttpRequest:u$2,h=(e,t)=>{const r=e.options,o=e.applyMiddleware("finalizeOptions",r),s={},n=e.applyMiddleware("interceptRequest",void 0,{adapter:l$1,context:e});if(n){const e=setTimeout(t,0,null,n);return {abort:()=>clearTimeout(e)}}let a=new c$2;a instanceof u$2&&"object"==typeof o.fetch&&a.setInit(o.fetch,o.useAbortSignal??!0);const h=o.headers,d=o.timeout;let p=!1,f=!1,b=!1;if(a.onerror=e=>{m(a instanceof u$2?e instanceof Error?e:new Error(`Request error while attempting to reach is ${o.url}`,{cause:e}):new Error(`Request error while attempting to reach is ${o.url}${e.lengthComputable?`(${e.loaded} of ${e.total} bytes transferred)`:""}`));},a.ontimeout=e=>{m(new Error(`Request timeout while attempting to reach ${o.url}${e.lengthComputable?`(${e.loaded} of ${e.total} bytes transferred)`:""}`));},a.onabort=()=>{w(!0),p=!0;},a.onreadystatechange=()=>{d&&(w(),s.socket=setTimeout((()=>y("ESOCKETTIMEDOUT")),d.socket)),!p&&4===a.readyState&&0!==a.status&&function(){if(!(p||f||b)){if(0===a.status)return void m(new Error("Unknown XHR error"));w(),f=!0,t(null,{body:a.response||(""===a.responseType||"text"===a.responseType?a.responseText:""),url:o.url,method:o.method,headers:i(a.getAllResponseHeaders()),statusCode:a.status,statusMessage:a.statusText});}}();},a.open(o.method,o.url,!0),a.withCredentials=!!o.withCredentials,h&&a.setRequestHeader)for(const e in h)h.hasOwnProperty(e)&&a.setRequestHeader(e,h[e]);return o.rawBody&&(a.responseType="arraybuffer"),e.applyMiddleware("onRequest",{options:o,adapter:l$1,request:a,context:e}),a.send(o.body||null),d&&(s.connect=setTimeout((()=>y("ETIMEDOUT")),d.connect)),{abort:function(){p=!0,a&&a.abort();}};function y(t){b=!0,a.abort();const r=new Error("ESOCKETTIMEDOUT"===t?`Socket timed out on request to ${o.url}`:`Connection timed out on request to ${o.url}`);r.code=t,e.channels.error.publish(r);}function w(e){(e||p||a.readyState>=2&&s.connect)&&clearTimeout(s.connect),s.socket&&clearTimeout(s.socket);}function m(e){if(f)return;w(!0),f=!0,a=null;const r=e||new Error(`Network error while attempting to reach ${o.url}`);r.isNetworkError=!0,r.request=o,t(r);}},d=(e=[],t=h)=>n(e,t),p$1="browser";
@@ -24,7 +39,7 @@
   OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
   PERFORMANCE OF THIS SOFTWARE.
   ***************************************************************************** */
-  /* global Reflect, Promise, SuppressedError, Symbol */
+  /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
   var extendStatics = function(d, b) {
     extendStatics = Object.setPrototypeOf ||
@@ -52,8 +67,8 @@
   }
 
   function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
@@ -125,8 +140,9 @@
   function __asyncGenerator(thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
     function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
     function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
     function fulfill(value) { resume("next", value); }
@@ -304,7 +320,7 @@
       })();
       return Subscription;
   }());
-  Subscription.EMPTY;
+  var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
   function isSubscription(value) {
       return (value instanceof Subscription ||
           (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
@@ -713,12 +729,404 @@
       return OperatorSubscriber;
   }(Subscriber));
 
+  var ObjectUnsubscribedError = createErrorClass(function (_super) {
+      return function ObjectUnsubscribedErrorImpl() {
+          _super(this);
+          this.name = 'ObjectUnsubscribedError';
+          this.message = 'object unsubscribed';
+      };
+  });
+
+  var Subject = (function (_super) {
+      __extends(Subject, _super);
+      function Subject() {
+          var _this = _super.call(this) || this;
+          _this.closed = false;
+          _this.currentObservers = null;
+          _this.observers = [];
+          _this.isStopped = false;
+          _this.hasError = false;
+          _this.thrownError = null;
+          return _this;
+      }
+      Subject.prototype.lift = function (operator) {
+          var subject = new AnonymousSubject(this, this);
+          subject.operator = operator;
+          return subject;
+      };
+      Subject.prototype._throwIfClosed = function () {
+          if (this.closed) {
+              throw new ObjectUnsubscribedError();
+          }
+      };
+      Subject.prototype.next = function (value) {
+          var _this = this;
+          errorContext(function () {
+              var e_1, _a;
+              _this._throwIfClosed();
+              if (!_this.isStopped) {
+                  if (!_this.currentObservers) {
+                      _this.currentObservers = Array.from(_this.observers);
+                  }
+                  try {
+                      for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                          var observer = _c.value;
+                          observer.next(value);
+                      }
+                  }
+                  catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                  finally {
+                      try {
+                          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                      }
+                      finally { if (e_1) throw e_1.error; }
+                  }
+              }
+          });
+      };
+      Subject.prototype.error = function (err) {
+          var _this = this;
+          errorContext(function () {
+              _this._throwIfClosed();
+              if (!_this.isStopped) {
+                  _this.hasError = _this.isStopped = true;
+                  _this.thrownError = err;
+                  var observers = _this.observers;
+                  while (observers.length) {
+                      observers.shift().error(err);
+                  }
+              }
+          });
+      };
+      Subject.prototype.complete = function () {
+          var _this = this;
+          errorContext(function () {
+              _this._throwIfClosed();
+              if (!_this.isStopped) {
+                  _this.isStopped = true;
+                  var observers = _this.observers;
+                  while (observers.length) {
+                      observers.shift().complete();
+                  }
+              }
+          });
+      };
+      Subject.prototype.unsubscribe = function () {
+          this.isStopped = this.closed = true;
+          this.observers = this.currentObservers = null;
+      };
+      Object.defineProperty(Subject.prototype, "observed", {
+          get: function () {
+              var _a;
+              return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Subject.prototype._trySubscribe = function (subscriber) {
+          this._throwIfClosed();
+          return _super.prototype._trySubscribe.call(this, subscriber);
+      };
+      Subject.prototype._subscribe = function (subscriber) {
+          this._throwIfClosed();
+          this._checkFinalizedStatuses(subscriber);
+          return this._innerSubscribe(subscriber);
+      };
+      Subject.prototype._innerSubscribe = function (subscriber) {
+          var _this = this;
+          var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+          if (hasError || isStopped) {
+              return EMPTY_SUBSCRIPTION;
+          }
+          this.currentObservers = null;
+          observers.push(subscriber);
+          return new Subscription(function () {
+              _this.currentObservers = null;
+              arrRemove(observers, subscriber);
+          });
+      };
+      Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+          var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+          if (hasError) {
+              subscriber.error(thrownError);
+          }
+          else if (isStopped) {
+              subscriber.complete();
+          }
+      };
+      Subject.prototype.asObservable = function () {
+          var observable = new Observable();
+          observable.source = this;
+          return observable;
+      };
+      Subject.create = function (destination, source) {
+          return new AnonymousSubject(destination, source);
+      };
+      return Subject;
+  }(Observable));
+  var AnonymousSubject = (function (_super) {
+      __extends(AnonymousSubject, _super);
+      function AnonymousSubject(destination, source) {
+          var _this = _super.call(this) || this;
+          _this.destination = destination;
+          _this.source = source;
+          return _this;
+      }
+      AnonymousSubject.prototype.next = function (value) {
+          var _a, _b;
+          (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+      };
+      AnonymousSubject.prototype.error = function (err) {
+          var _a, _b;
+          (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+      };
+      AnonymousSubject.prototype.complete = function () {
+          var _a, _b;
+          (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+      };
+      AnonymousSubject.prototype._subscribe = function (subscriber) {
+          var _a, _b;
+          return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+      };
+      return AnonymousSubject;
+  }(Subject));
+
+  var dateTimestampProvider = {
+      now: function () {
+          return (dateTimestampProvider.delegate || Date).now();
+      },
+      delegate: undefined,
+  };
+
+  var ReplaySubject = (function (_super) {
+      __extends(ReplaySubject, _super);
+      function ReplaySubject(_bufferSize, _windowTime, _timestampProvider) {
+          if (_bufferSize === void 0) { _bufferSize = Infinity; }
+          if (_windowTime === void 0) { _windowTime = Infinity; }
+          if (_timestampProvider === void 0) { _timestampProvider = dateTimestampProvider; }
+          var _this = _super.call(this) || this;
+          _this._bufferSize = _bufferSize;
+          _this._windowTime = _windowTime;
+          _this._timestampProvider = _timestampProvider;
+          _this._buffer = [];
+          _this._infiniteTimeWindow = true;
+          _this._infiniteTimeWindow = _windowTime === Infinity;
+          _this._bufferSize = Math.max(1, _bufferSize);
+          _this._windowTime = Math.max(1, _windowTime);
+          return _this;
+      }
+      ReplaySubject.prototype.next = function (value) {
+          var _a = this, isStopped = _a.isStopped, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow, _timestampProvider = _a._timestampProvider, _windowTime = _a._windowTime;
+          if (!isStopped) {
+              _buffer.push(value);
+              !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
+          }
+          this._trimBuffer();
+          _super.prototype.next.call(this, value);
+      };
+      ReplaySubject.prototype._subscribe = function (subscriber) {
+          this._throwIfClosed();
+          this._trimBuffer();
+          var subscription = this._innerSubscribe(subscriber);
+          var _a = this, _infiniteTimeWindow = _a._infiniteTimeWindow, _buffer = _a._buffer;
+          var copy = _buffer.slice();
+          for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
+              subscriber.next(copy[i]);
+          }
+          this._checkFinalizedStatuses(subscriber);
+          return subscription;
+      };
+      ReplaySubject.prototype._trimBuffer = function () {
+          var _a = this, _bufferSize = _a._bufferSize, _timestampProvider = _a._timestampProvider, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow;
+          var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
+          _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
+          if (!_infiniteTimeWindow) {
+              var now = _timestampProvider.now();
+              var last = 0;
+              for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
+                  last = i;
+              }
+              last && _buffer.splice(0, last + 1);
+          }
+      };
+      return ReplaySubject;
+  }(Subject));
+
+  var Action = (function (_super) {
+      __extends(Action, _super);
+      function Action(scheduler, work) {
+          return _super.call(this) || this;
+      }
+      Action.prototype.schedule = function (state, delay) {
+          return this;
+      };
+      return Action;
+  }(Subscription));
+
+  var intervalProvider = {
+      setInterval: function (handler, timeout) {
+          var args = [];
+          for (var _i = 2; _i < arguments.length; _i++) {
+              args[_i - 2] = arguments[_i];
+          }
+          return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+      },
+      clearInterval: function (handle) {
+          return (clearInterval)(handle);
+      },
+      delegate: undefined,
+  };
+
+  var AsyncAction = (function (_super) {
+      __extends(AsyncAction, _super);
+      function AsyncAction(scheduler, work) {
+          var _this = _super.call(this, scheduler, work) || this;
+          _this.scheduler = scheduler;
+          _this.work = work;
+          _this.pending = false;
+          return _this;
+      }
+      AsyncAction.prototype.schedule = function (state, delay) {
+          var _a;
+          if (delay === void 0) { delay = 0; }
+          if (this.closed) {
+              return this;
+          }
+          this.state = state;
+          var id = this.id;
+          var scheduler = this.scheduler;
+          if (id != null) {
+              this.id = this.recycleAsyncId(scheduler, id, delay);
+          }
+          this.pending = true;
+          this.delay = delay;
+          this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay);
+          return this;
+      };
+      AsyncAction.prototype.requestAsyncId = function (scheduler, _id, delay) {
+          if (delay === void 0) { delay = 0; }
+          return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+      };
+      AsyncAction.prototype.recycleAsyncId = function (_scheduler, id, delay) {
+          if (delay === void 0) { delay = 0; }
+          if (delay != null && this.delay === delay && this.pending === false) {
+              return id;
+          }
+          if (id != null) {
+              intervalProvider.clearInterval(id);
+          }
+          return undefined;
+      };
+      AsyncAction.prototype.execute = function (state, delay) {
+          if (this.closed) {
+              return new Error('executing a cancelled action');
+          }
+          this.pending = false;
+          var error = this._execute(state, delay);
+          if (error) {
+              return error;
+          }
+          else if (this.pending === false && this.id != null) {
+              this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+          }
+      };
+      AsyncAction.prototype._execute = function (state, _delay) {
+          var errored = false;
+          var errorValue;
+          try {
+              this.work(state);
+          }
+          catch (e) {
+              errored = true;
+              errorValue = e ? e : new Error('Scheduled action threw falsy error');
+          }
+          if (errored) {
+              this.unsubscribe();
+              return errorValue;
+          }
+      };
+      AsyncAction.prototype.unsubscribe = function () {
+          if (!this.closed) {
+              var _a = this, id = _a.id, scheduler = _a.scheduler;
+              var actions = scheduler.actions;
+              this.work = this.state = this.scheduler = null;
+              this.pending = false;
+              arrRemove(actions, this);
+              if (id != null) {
+                  this.id = this.recycleAsyncId(scheduler, id, null);
+              }
+              this.delay = null;
+              _super.prototype.unsubscribe.call(this);
+          }
+      };
+      return AsyncAction;
+  }(Action));
+
+  var Scheduler = (function () {
+      function Scheduler(schedulerActionCtor, now) {
+          if (now === void 0) { now = Scheduler.now; }
+          this.schedulerActionCtor = schedulerActionCtor;
+          this.now = now;
+      }
+      Scheduler.prototype.schedule = function (work, delay, state) {
+          if (delay === void 0) { delay = 0; }
+          return new this.schedulerActionCtor(this, work).schedule(state, delay);
+      };
+      Scheduler.now = dateTimestampProvider.now;
+      return Scheduler;
+  }());
+
+  var AsyncScheduler = (function (_super) {
+      __extends(AsyncScheduler, _super);
+      function AsyncScheduler(SchedulerAction, now) {
+          if (now === void 0) { now = Scheduler.now; }
+          var _this = _super.call(this, SchedulerAction, now) || this;
+          _this.actions = [];
+          _this._active = false;
+          return _this;
+      }
+      AsyncScheduler.prototype.flush = function (action) {
+          var actions = this.actions;
+          if (this._active) {
+              actions.push(action);
+              return;
+          }
+          var error;
+          this._active = true;
+          do {
+              if ((error = action.execute(action.state, action.delay))) {
+                  break;
+              }
+          } while ((action = actions.shift()));
+          this._active = false;
+          if (error) {
+              while ((action = actions.shift())) {
+                  action.unsubscribe();
+              }
+              throw error;
+          }
+      };
+      return AsyncScheduler;
+  }(Scheduler));
+
+  var asyncScheduler = new AsyncScheduler(AsyncAction);
+  var async = asyncScheduler;
+
+  var EMPTY = new Observable(function (subscriber) { return subscriber.complete(); });
+
+  function isScheduler(value) {
+      return value && isFunction(value.schedule);
+  }
+
   function last(arr) {
       return arr[arr.length - 1];
   }
   function popResultSelector(args) {
       return isFunction(last(args)) ? args.pop() : undefined;
   }
+  function popScheduler(args) {
+      return isScheduler(last(args)) ? args.pop() : undefined;
+  }
 
   var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
 
@@ -917,8 +1325,161 @@
       });
   }
 
+  function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+      if (delay === void 0) { delay = 0; }
+      if (repeat === void 0) { repeat = false; }
+      var scheduleSubscription = scheduler.schedule(function () {
+          work();
+          if (repeat) {
+              parentSubscription.add(this.schedule(null, delay));
+          }
+          else {
+              this.unsubscribe();
+          }
+      }, delay);
+      parentSubscription.add(scheduleSubscription);
+      if (!repeat) {
+          return scheduleSubscription;
+      }
+  }
+
+  function observeOn(scheduler, delay) {
+      if (delay === void 0) { delay = 0; }
+      return operate(function (source, subscriber) {
+          source.subscribe(createOperatorSubscriber(subscriber, function (value) { return executeSchedule(subscriber, scheduler, function () { return subscriber.next(value); }, delay); }, function () { return executeSchedule(subscriber, scheduler, function () { return subscriber.complete(); }, delay); }, function (err) { return executeSchedule(subscriber, scheduler, function () { return subscriber.error(err); }, delay); }));
+      });
+  }
+
+  function subscribeOn(scheduler, delay) {
+      if (delay === void 0) { delay = 0; }
+      return operate(function (source, subscriber) {
+          subscriber.add(scheduler.schedule(function () { return source.subscribe(subscriber); }, delay));
+      });
+  }
+
+  function scheduleObservable(input, scheduler) {
+      return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+  }
+
+  function schedulePromise(input, scheduler) {
+      return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+  }
+
+  function scheduleArray(input, scheduler) {
+      return new Observable(function (subscriber) {
+          var i = 0;
+          return scheduler.schedule(function () {
+              if (i === input.length) {
+                  subscriber.complete();
+              }
+              else {
+                  subscriber.next(input[i++]);
+                  if (!subscriber.closed) {
+                      this.schedule();
+                  }
+              }
+          });
+      });
+  }
+
+  function scheduleIterable(input, scheduler) {
+      return new Observable(function (subscriber) {
+          var iterator$1;
+          executeSchedule(subscriber, scheduler, function () {
+              iterator$1 = input[iterator]();
+              executeSchedule(subscriber, scheduler, function () {
+                  var _a;
+                  var value;
+                  var done;
+                  try {
+                      (_a = iterator$1.next(), value = _a.value, done = _a.done);
+                  }
+                  catch (err) {
+                      subscriber.error(err);
+                      return;
+                  }
+                  if (done) {
+                      subscriber.complete();
+                  }
+                  else {
+                      subscriber.next(value);
+                  }
+              }, 0, true);
+          });
+          return function () { return isFunction(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return(); };
+      });
+  }
+
+  function scheduleAsyncIterable(input, scheduler) {
+      if (!input) {
+          throw new Error('Iterable cannot be null');
+      }
+      return new Observable(function (subscriber) {
+          executeSchedule(subscriber, scheduler, function () {
+              var iterator = input[Symbol.asyncIterator]();
+              executeSchedule(subscriber, scheduler, function () {
+                  iterator.next().then(function (result) {
+                      if (result.done) {
+                          subscriber.complete();
+                      }
+                      else {
+                          subscriber.next(result.value);
+                      }
+                  });
+              }, 0, true);
+          });
+      });
+  }
+
+  function scheduleReadableStreamLike(input, scheduler) {
+      return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+  }
+
+  function scheduled(input, scheduler) {
+      if (input != null) {
+          if (isInteropObservable(input)) {
+              return scheduleObservable(input, scheduler);
+          }
+          if (isArrayLike(input)) {
+              return scheduleArray(input, scheduler);
+          }
+          if (isPromise(input)) {
+              return schedulePromise(input, scheduler);
+          }
+          if (isAsyncIterable(input)) {
+              return scheduleAsyncIterable(input, scheduler);
+          }
+          if (isIterable(input)) {
+              return scheduleIterable(input, scheduler);
+          }
+          if (isReadableStreamLike(input)) {
+              return scheduleReadableStreamLike(input, scheduler);
+          }
+      }
+      throw createInvalidObservableTypeError(input);
+  }
+
   function from(input, scheduler) {
-      return innerFrom(input);
+      return scheduler ? scheduled(input, scheduler) : innerFrom(input);
+  }
+
+  function of() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+      }
+      var scheduler = popScheduler(args);
+      return from(args, scheduler);
+  }
+
+  function throwError(errorOrErrorFactory, scheduler) {
+      var errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : function () { return errorOrErrorFactory; };
+      var init = function (subscriber) { return subscriber.error(errorFactory()); };
+      return new Observable(init);
+  }
+
+  function isObservable(obj) {
+      return !!obj && (obj instanceof Observable || (isFunction(obj.lift) && isFunction(obj.subscribe)));
   }
 
   var EmptyError = createErrorClass(function (_super) { return function EmptyErrorImpl() {
@@ -949,6 +1510,10 @@
       });
   }
 
+  function isValidDate$1(value) {
+      return value instanceof Date && !isNaN(value);
+  }
+
   function map(project, thisArg) {
       return operate(function (source, subscriber) {
           var index = 0;
@@ -976,7 +1541,7 @@
               var remainingFirstValues = length;
               var _loop_1 = function (i) {
                   maybeSchedule(scheduler, function () {
-                      var source = from(observables[i]);
+                      var source = from(observables[i], scheduler);
                       var hasFirstValue = false;
                       source.subscribe(createOperatorSubscriber(subscriber, function (value) {
                           values[i] = value;
@@ -1006,6 +1571,108 @@
       }
   }
 
+  function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+      var buffer = [];
+      var active = 0;
+      var index = 0;
+      var isComplete = false;
+      var checkComplete = function () {
+          if (isComplete && !buffer.length && !active) {
+              subscriber.complete();
+          }
+      };
+      var outerNext = function (value) { return (active < concurrent ? doInnerSub(value) : buffer.push(value)); };
+      var doInnerSub = function (value) {
+          active++;
+          var innerComplete = false;
+          innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function (innerValue) {
+              {
+                  subscriber.next(innerValue);
+              }
+          }, function () {
+              innerComplete = true;
+          }, undefined, function () {
+              if (innerComplete) {
+                  try {
+                      active--;
+                      var _loop_1 = function () {
+                          var bufferedValue = buffer.shift();
+                          if (innerSubScheduler) ;
+                          else {
+                              doInnerSub(bufferedValue);
+                          }
+                      };
+                      while (buffer.length && active < concurrent) {
+                          _loop_1();
+                      }
+                      checkComplete();
+                  }
+                  catch (err) {
+                      subscriber.error(err);
+                  }
+              }
+          }));
+      };
+      source.subscribe(createOperatorSubscriber(subscriber, outerNext, function () {
+          isComplete = true;
+          checkComplete();
+      }));
+      return function () {
+      };
+  }
+
+  function mergeMap(project, resultSelector, concurrent) {
+      if (concurrent === void 0) { concurrent = Infinity; }
+      if (isFunction(resultSelector)) {
+          return mergeMap(function (a, i) { return map(function (b, ii) { return resultSelector(a, b, i, ii); })(innerFrom(project(a, i))); }, concurrent);
+      }
+      else if (typeof resultSelector === 'number') {
+          concurrent = resultSelector;
+      }
+      return operate(function (source, subscriber) { return mergeInternals(source, subscriber, project, concurrent); });
+  }
+
+  function mergeAll(concurrent) {
+      return mergeMap(identity, concurrent);
+  }
+
+  function concatAll() {
+      return mergeAll(1);
+  }
+
+  function concat() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+      }
+      return concatAll()(from(args, popScheduler(args)));
+  }
+
+  function defer(observableFactory) {
+      return new Observable(function (subscriber) {
+          innerFrom(observableFactory()).subscribe(subscriber);
+      });
+  }
+
+  function timer(dueTime, intervalOrScheduler, scheduler) {
+      if (scheduler === void 0) { scheduler = async; }
+      return new Observable(function (subscriber) {
+          var due = isValidDate$1(dueTime) ? +dueTime - scheduler.now() : dueTime;
+          if (due < 0) {
+              due = 0;
+          }
+          var n = 0;
+          return scheduler.schedule(function () {
+              if (!subscriber.closed) {
+                  subscriber.next(n++);
+                  {
+                      subscriber.complete();
+                  }
+              }
+          }, due);
+      });
+  }
+
   var isArray$1 = Array.isArray;
   function argsOrArgArray(args) {
       return args.length === 1 && isArray$1(args[0]) ? args[0] : args;
@@ -1018,6 +1685,30 @@
       });
   }
 
+  function catchError(selector) {
+      return operate(function (source, subscriber) {
+          var innerSub = null;
+          var syncUnsub = false;
+          var handledResult;
+          innerSub = source.subscribe(createOperatorSubscriber(subscriber, undefined, undefined, function (err) {
+              handledResult = innerFrom(selector(err, catchError(selector)(source)));
+              if (innerSub) {
+                  innerSub.unsubscribe();
+                  innerSub = null;
+                  handledResult.subscribe(subscriber);
+              }
+              else {
+                  syncUnsub = true;
+              }
+          }));
+          if (syncUnsub) {
+              innerSub.unsubscribe();
+              innerSub = null;
+              handledResult.subscribe(subscriber);
+          }
+      });
+  }
+
   function combineLatest() {
       var args = [];
       for (var _i = 0; _i < arguments.length; _i++) {
@@ -1039,6 +1730,100 @@
       return combineLatest.apply(void 0, __spreadArray([], __read(otherSources)));
   }
 
+  function share(options) {
+      if (options === void 0) { options = {}; }
+      var _a = options.connector, connector = _a === void 0 ? function () { return new Subject(); } : _a, _b = options.resetOnError, resetOnError = _b === void 0 ? true : _b, _c = options.resetOnComplete, resetOnComplete = _c === void 0 ? true : _c, _d = options.resetOnRefCountZero, resetOnRefCountZero = _d === void 0 ? true : _d;
+      return function (wrapperSource) {
+          var connection;
+          var resetConnection;
+          var subject;
+          var refCount = 0;
+          var hasCompleted = false;
+          var hasErrored = false;
+          var cancelReset = function () {
+              resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
+              resetConnection = undefined;
+          };
+          var reset = function () {
+              cancelReset();
+              connection = subject = undefined;
+              hasCompleted = hasErrored = false;
+          };
+          var resetAndUnsubscribe = function () {
+              var conn = connection;
+              reset();
+              conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
+          };
+          return operate(function (source, subscriber) {
+              refCount++;
+              if (!hasErrored && !hasCompleted) {
+                  cancelReset();
+              }
+              var dest = (subject = subject !== null && subject !== void 0 ? subject : connector());
+              subscriber.add(function () {
+                  refCount--;
+                  if (refCount === 0 && !hasErrored && !hasCompleted) {
+                      resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
+                  }
+              });
+              dest.subscribe(subscriber);
+              if (!connection &&
+                  refCount > 0) {
+                  connection = new SafeSubscriber({
+                      next: function (value) { return dest.next(value); },
+                      error: function (err) {
+                          hasErrored = true;
+                          cancelReset();
+                          resetConnection = handleReset(reset, resetOnError, err);
+                          dest.error(err);
+                      },
+                      complete: function () {
+                          hasCompleted = true;
+                          cancelReset();
+                          resetConnection = handleReset(reset, resetOnComplete);
+                          dest.complete();
+                      },
+                  });
+                  innerFrom(source).subscribe(connection);
+              }
+          })(wrapperSource);
+      };
+  }
+  function handleReset(reset, on) {
+      var args = [];
+      for (var _i = 2; _i < arguments.length; _i++) {
+          args[_i - 2] = arguments[_i];
+      }
+      if (on === true) {
+          reset();
+          return;
+      }
+      if (on === false) {
+          return;
+      }
+      var onSubscriber = new SafeSubscriber({
+          next: function () {
+              onSubscriber.unsubscribe();
+              reset();
+          },
+      });
+      return innerFrom(on.apply(void 0, __spreadArray([], __read(args)))).subscribe(onSubscriber);
+  }
+
+  function shareReplay(configOrBufferSize, windowTime, scheduler) {
+      var bufferSize;
+      var refCount = false;
+      {
+          bufferSize = (configOrBufferSize );
+      }
+      return share({
+          connector: function () { return new ReplaySubject(bufferSize, windowTime, scheduler); },
+          resetOnError: true,
+          resetOnComplete: false,
+          resetOnRefCountZero: refCount,
+      });
+  }
+
   var s = { 0: 8203, 1: 8204, 2: 8205, 3: 8290, 4: 8291, 5: 8288, 6: 65279, 7: 8289, 8: 119155, 9: 119156, a: 119157, b: 119158, c: 119159, d: 119160, e: 119161, f: 119162 }, c = { 0: 8203, 1: 8204, 2: 8205, 3: 65279 }, u = new Array(4).fill(String.fromCodePoint(c[0])).join("");
   function E(t) {
     let e = JSON.stringify(t);
@@ -1264,7 +2049,7 @@
     if (!(/^\d{4}-\d{2}-\d{2}$/.test(apiVersion) && apiDate instanceof Date && apiDate.getTime() > 0))
       throw new Error("Invalid API version string, expected `1` or date in format `YYYY-MM-DD`");
   }
-  const validateApiPerspective = function(perspective) {
+  function validateApiPerspective(perspective) {
     if (Array.isArray(perspective)) {
       for (const perspectiveValue of perspective)
         if (perspectiveValue !== "published" && perspectiveValue !== "drafts" && !(typeof perspectiveValue == "string" && perspectiveValue.startsWith("r") && perspectiveValue !== "raw"))
@@ -1284,7 +2069,8 @@
           "Invalid API perspective string, expected `published`, `previewDrafts` or `raw`"
         );
     }
-  }, initConfig = (config, prevConfig) => {
+  }
+  const initConfig = (config, prevConfig) => {
     const specifiedConfig = {
       ...prevConfig,
       ...config,
@@ -1325,6 +2111,112 @@
     const hostParts = newConfig.apiHost.split("://", 2), protocol = hostParts[0], host = hostParts[1], cdnHost = newConfig.isDefaultApi ? defaultCdnHost : host;
     return newConfig.useProjectHostname ? (newConfig.url = `${protocol}://${newConfig.projectId}.${host}/v${newConfig.apiVersion}`, newConfig.cdnUrl = `${protocol}://${newConfig.projectId}.${cdnHost}/v${newConfig.apiVersion}`) : (newConfig.url = `${newConfig.apiHost}/v${newConfig.apiVersion}`, newConfig.cdnUrl = newConfig.url), newConfig;
   };
+  class ConnectionFailedError extends Error {
+    name = "ConnectionFailedError";
+  }
+  class DisconnectError extends Error {
+    name = "DisconnectError";
+    reason;
+    constructor(message, reason, options = {}) {
+      super(message, options), this.reason = reason;
+    }
+  }
+  class ChannelError extends Error {
+    name = "ChannelError";
+    data;
+    constructor(message, data) {
+      super(message), this.data = data;
+    }
+  }
+  class MessageError extends Error {
+    name = "MessageError";
+    data;
+    constructor(message, data, options = {}) {
+      super(message, options), this.data = data;
+    }
+  }
+  class MessageParseError extends Error {
+    name = "MessageParseError";
+  }
+  const REQUIRED_EVENTS = ["channelError", "disconnect"];
+  function connectEventSource(initEventSource, events) {
+    return defer(() => {
+      const es = initEventSource();
+      return isObservable(es) ? es : of(es);
+    }).pipe(mergeMap((es) => connectWithESInstance(es, events)));
+  }
+  function connectWithESInstance(es, events) {
+    return new Observable((observer) => {
+      const emitOpen = events.includes("open"), emitReconnect = events.includes("reconnect");
+      function onError(evt) {
+        if ("data" in evt) {
+          const [parseError, event] = parseEvent(evt);
+          observer.error(
+            parseError ? new MessageParseError("Unable to parse EventSource error message", { cause: event }) : new MessageError((event?.data).message, event)
+          );
+          return;
+        }
+        es.readyState === es.CLOSED ? observer.error(new ConnectionFailedError("EventSource connection failed")) : emitReconnect && observer.next({ type: "reconnect" });
+      }
+      function onOpen() {
+        observer.next({ type: "open" });
+      }
+      function onMessage(message) {
+        const [parseError, event] = parseEvent(message);
+        if (parseError) {
+          observer.error(
+            new MessageParseError("Unable to parse EventSource message", { cause: parseError })
+          );
+          return;
+        }
+        if (message.type === "channelError") {
+          observer.error(new ChannelError(extractErrorMessage(event?.data), event.data));
+          return;
+        }
+        if (message.type === "disconnect") {
+          observer.error(
+            new DisconnectError(
+              `Server disconnected client: ${event.data?.reason || "unknown error"}`
+            )
+          );
+          return;
+        }
+        observer.next({
+          type: message.type,
+          id: message.lastEventId,
+          ...event.data ? { data: event.data } : {}
+        });
+      }
+      es.addEventListener("error", onError), emitOpen && es.addEventListener("open", onOpen);
+      const cleanedEvents = [.../* @__PURE__ */ new Set([...REQUIRED_EVENTS, ...events])].filter((type) => type !== "error" && type !== "open" && type !== "reconnect");
+      return cleanedEvents.forEach((type) => es.addEventListener(type, onMessage)), () => {
+        es.removeEventListener("error", onError), emitOpen && es.removeEventListener("open", onOpen), cleanedEvents.forEach((type) => es.removeEventListener(type, onMessage)), es.close();
+      };
+    });
+  }
+  function parseEvent(message) {
+    try {
+      const data = typeof message.data == "string" && JSON.parse(message.data);
+      return [
+        null,
+        {
+          type: message.type,
+          id: message.lastEventId,
+          ...isEmptyObject(data) ? {} : { data }
+        }
+      ];
+    } catch (err) {
+      return [err, null];
+    }
+  }
+  function extractErrorMessage(err) {
+    return err.error ? err.error.description ? err.error.description : typeof err.error == "string" ? err.error : JSON.stringify(err.error, null, 2) : err.message || "Unknown listener error";
+  }
+  function isEmptyObject(data) {
+    for (const _ in data)
+      return !1;
+    return !0;
+  }
   function getSelection(sel) {
     if (typeof sel == "string")
       return { id: sel };
@@ -1941,7 +2833,18 @@ ${selectionOpts}`);
     );
   }
   var defaults = (obj, defaults2) => Object.keys(defaults2).concat(Object.keys(obj)).reduce((target, prop) => (target[prop] = typeof obj[prop] > "u" ? defaults2[prop] : obj[prop], target), {});
-  const pick = (obj, props) => props.reduce((selection, prop) => (typeof obj[prop] > "u" || (selection[prop] = obj[prop]), selection), {}), MAX_URL_LENGTH = 14800, possibleOptions = [
+  const pick = (obj, props) => props.reduce((selection, prop) => (typeof obj[prop] > "u" || (selection[prop] = obj[prop]), selection), {}), eventSourcePolyfill = defer(() => Promise.resolve().then(function () { return browser$1; })).pipe(
+    map(({ default: EventSource2 }) => EventSource2),
+    shareReplay(1)
+  );
+  function reconnectOnConnectionFailure() {
+    return function(source) {
+      return source.pipe(
+        catchError((err, caught) => err instanceof ConnectionFailedError ? concat(of({ type: "reconnect" }), timer(1e3).pipe(mergeMap(() => caught))) : throwError(() => err))
+      );
+    };
+  }
+  const MAX_URL_LENGTH = 14800, possibleOptions = [
     "includePreviousRevision",
     "includeResult",
     "includeMutations",
@@ -1954,68 +2857,23 @@ ${selectionOpts}`);
   function _listen(query, params, opts = {}) {
     const { url, token, withCredentials, requestTagPrefix } = this.config(), tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join(".") : opts.tag, options = { ...defaults(opts, defaultOptions), tag }, listenOpts = pick(options, possibleOptions), qs = encodeQueryString({ query, params, options: { tag, ...listenOpts } }), uri = `${url}${_getDataUrl(this, "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"], shouldEmitReconnect = listenFor.indexOf("reconnect") !== -1, esOptions = {};
+      return throwError(() => new Error("Query too large for listener"));
+    const listenFor = options.events ? options.events : ["mutation"], esOptions = {};
     return (token || withCredentials) && (esOptions.withCredentials = !0), token && (esOptions.headers = {
       Authorization: `Bearer ${token}`
-    }), new Observable((observer) => {
-      let es, reconnectTimer, stopped = !1, unsubscribed = !1;
-      open();
-      function onError() {
-        stopped || (emitReconnect(), !stopped && es.readyState === es.CLOSED && (unsubscribe(), clearTimeout(reconnectTimer), reconnectTimer = setTimeout(open, 100)));
-      }
-      function onChannelError(err) {
-        observer.error(cooerceError(err));
-      }
-      function onMessage(evt) {
-        const event = parseEvent$1(evt);
-        return event instanceof Error ? observer.error(event) : observer.next(event);
-      }
-      function onDisconnect() {
-        stopped = !0, unsubscribe(), observer.complete();
-      }
-      function unsubscribe() {
-        es && (es.removeEventListener("error", onError), es.removeEventListener("channelError", onChannelError), es.removeEventListener("disconnect", onDisconnect), listenFor.forEach((type) => es.removeEventListener(type, onMessage)), es.close());
-      }
-      function emitReconnect() {
-        shouldEmitReconnect && observer.next({ type: "reconnect" });
-      }
-      async function getEventSource() {
-        const { default: EventSource2 } = await Promise.resolve().then(function () { return browser$1; });
-        if (unsubscribed)
-          return;
-        const evs = new EventSource2(uri, esOptions);
-        return evs.addEventListener("error", onError), evs.addEventListener("channelError", onChannelError), evs.addEventListener("disconnect", onDisconnect), listenFor.forEach((type) => evs.addEventListener(type, onMessage)), evs;
-      }
-      function open() {
-        getEventSource().then((eventSource) => {
-          eventSource && (es = eventSource, unsubscribed && unsubscribe());
-        }).catch((reason) => {
-          observer.error(reason), stop();
-        });
-      }
-      function stop() {
-        stopped = !0, unsubscribe(), unsubscribed = !0;
-      }
-      return stop;
-    });
-  }
-  function parseEvent$1(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$1(err);
-    return evt instanceof Error ? evt : new Error(extractErrorMessage(evt));
-  }
-  function extractErrorMessage(err) {
-    return err.error ? err.error.description ? err.error.description : typeof err.error == "string" ? err.error : JSON.stringify(err.error, null, 2) : err.message || "Unknown listener error";
+    }), connectEventSource(() => (
+      // use polyfill if there is no global EventSource or if we need to set headers
+      (typeof EventSource > "u" || esOptions.headers ? eventSourcePolyfill : of(EventSource)).pipe(map((EventSource2) => new EventSource2(uri, esOptions)))
+    ), listenFor).pipe(
+      reconnectOnConnectionFailure(),
+      filter((event) => listenFor.includes(event.type)),
+      map(
+        (event) => ({
+          type: event.type,
+          ..."data" in event ? event.data : {}
+        })
+      )
+    );
   }
   const requiredApiVersion = "2021-03-26";
   class LiveClient {
@@ -2051,75 +2909,53 @@ ${selectionOpts}`);
         );
       const path = _getDataUrl(this.#client, "live/events"), url = new URL(this.#client.getUrl(path, !1)), tag = _tag && requestTagPrefix ? [requestTagPrefix, _tag].join(".") : _tag;
       tag && url.searchParams.set("tag", tag), includeDrafts && url.searchParams.set("includeDrafts", "true");
-      const listenFor = ["restart", "message", "welcome", "reconnect"], esOptions = {};
-      return includeDrafts && token && (esOptions.headers = {
+      const esOptions = {};
+      includeDrafts && token && (esOptions.headers = {
         Authorization: `Bearer ${token}`
-      }), includeDrafts && withCredentials && (esOptions.withCredentials = !0), new Observable((observer) => {
-        let es, reconnectTimer, stopped = !1, unsubscribed = !1;
-        open();
-        function onError(evt) {
-          if (!stopped) {
-            if ("data" in evt) {
-              const event = parseEvent(evt);
-              observer.error(new Error(event.message, { cause: event }));
-            }
-            es.readyState === es.CLOSED && (unsubscribe(), clearTimeout(reconnectTimer), reconnectTimer = setTimeout(open, 100));
-          }
-        }
-        function onMessage(evt) {
-          const event = parseEvent(evt);
-          return event instanceof Error ? observer.error(event) : observer.next(event);
-        }
-        function unsubscribe() {
-          if (es) {
-            es.removeEventListener("error", onError);
-            for (const type of listenFor)
-              es.removeEventListener(type, onMessage);
-            es.close();
+      }), includeDrafts && withCredentials && (esOptions.withCredentials = !0);
+      const events = connectEventSource(() => (
+        // use polyfill if there is no global EventSource or if we need to set headers
+        (typeof EventSource > "u" || esOptions.headers ? eventSourcePolyfill : of(EventSource)).pipe(map((EventSource2) => new EventSource2(url.href, esOptions)))
+      ), [
+        "message",
+        "restart",
+        "welcome",
+        "reconnect"
+      ]).pipe(
+        reconnectOnConnectionFailure(),
+        map((event) => {
+          if (event.type === "message") {
+            const { data, ...rest } = event;
+            return { ...rest, tags: data.tags };
           }
+          return event;
+        })
+      ), checkCors = fetchObservable(url, {
+        method: "OPTIONS",
+        mode: "cors",
+        credentials: esOptions.withCredentials ? "include" : "omit",
+        headers: esOptions.headers
+      }).pipe(
+        mergeMap(() => EMPTY),
+        catchError(() => {
+          throw new CorsOriginError({ projectId: projectId2 });
+        })
+      );
+      return concat(checkCors, events);
+    }
+  }
+  function fetchObservable(url, init) {
+    return new Observable((observer) => {
+      const controller = new AbortController(), signal = controller.signal;
+      return fetch(url, { ...init, signal: controller.signal }).then(
+        (response) => {
+          observer.next(response), observer.complete();
+        },
+        (err) => {
+          signal.aborted || observer.error(err);
         }
-        async function getEventSource() {
-          const EventSourceImplementation = typeof EventSource > "u" || esOptions.headers || esOptions.withCredentials ? (await Promise.resolve().then(function () { return browser$1; })).default : EventSource;
-          if (unsubscribed)
-            return;
-          try {
-            if (await fetch(url, {
-              method: "OPTIONS",
-              mode: "cors",
-              credentials: esOptions.withCredentials ? "include" : "omit",
-              headers: esOptions.headers
-            }), unsubscribed)
-              return;
-          } catch {
-            throw new CorsOriginError({ projectId: projectId2 });
-          }
-          const evs = new EventSourceImplementation(url.toString(), esOptions);
-          evs.addEventListener("error", onError);
-          for (const type of listenFor)
-            evs.addEventListener(type, onMessage);
-          return evs;
-        }
-        function open() {
-          getEventSource().then((eventSource) => {
-            eventSource && (es = eventSource, unsubscribed && unsubscribe());
-          }).catch((reason) => {
-            observer.error(reason), stop();
-          });
-        }
-        function stop() {
-          stopped = !0, unsubscribe(), unsubscribed = !0;
-        }
-        return stop;
-      });
-    }
-  }
-  function parseEvent(event) {
-    try {
-      const data = event.data && JSON.parse(event.data) || {};
-      return { type: event.type, id: event.lastEventId, ...data };
-    } catch (err) {
-      return err;
-    }
+      ), () => controller.abort();
+    });
   }
   class ObservableDatasetsClient {
     #client;
@@ -4053,15 +4889,20 @@ ${selectionOpts}`);
   var browserExports = /*@__PURE__*/ requireBrowser();
   var browser = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
-  var browser$1 = /*#__PURE__*/Object.freeze({
+  var browser$1 = /*#__PURE__*/_mergeNamespaces({
     __proto__: null,
     default: browser
-  });
+  }, [browserExports]);
 
   exports.BasePatch = BasePatch;
   exports.BaseTransaction = BaseTransaction;
+  exports.ChannelError = ChannelError;
   exports.ClientError = ClientError;
+  exports.ConnectionFailedError = ConnectionFailedError;
   exports.CorsOriginError = CorsOriginError;
+  exports.DisconnectError = DisconnectError;
+  exports.MessageError = MessageError;
+  exports.MessageParseError = MessageParseError;
   exports.ObservablePatch = ObservablePatch;
   exports.ObservableSanityClient = ObservableSanityClient;
   exports.ObservableTransaction = ObservableTransaction;
@@ -4069,6 +4910,7 @@ ${selectionOpts}`);
   exports.SanityClient = SanityClient;
   exports.ServerError = ServerError;
   exports.Transaction = Transaction;
+  exports.connectEventSource = connectEventSource;
   exports.createClient = createClient;
   exports.default = deprecatedCreateClient;
   exports.requester = requester;