@sanity/client 4.0.0-alpha.esm.2 → 4.0.0-alpha.esm.5

package/dist/browser/sanityClient.js

@@ -1,7 +1,3194 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+
+// node_modules/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;
+      }
+    };
+  }
+});
+
+// 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() {
+      }
+    };
+  }
+});
+
+// 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;
+      }
+      UnsubscriptionErrorImpl2.prototype = Object.create(Error.prototype);
+      return UnsubscriptionErrorImpl2;
+    }();
+    exports.UnsubscriptionError = UnsubscriptionErrorImpl;
+  }
+});
+
+// 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);
+      }, []);
+    }
+  }
+});
+
+// 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;
+      }
+      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;
+      }
+      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;
+        }
+      }
+      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]();
+        }
+      }
+      if (!nextOrObserver && !error && !complete) {
+        return new Subscriber_1.Subscriber(Observer_1.empty);
+      }
+      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];
+      }
+      return pipeFromArray(fns);
+    }
+    exports.pipe = pipe;
+    function pipeFromArray(fns) {
+      if (fns.length === 0) {
+        return identity_1.identity;
+      }
+      if (fns.length === 1) {
+        return fns[0];
+      }
+      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;
+        }
+      }
+      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;
+      }
+      if (!promiseCtor) {
+        throw new Error("no Promise impl found");
+      }
+      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(global2) {
+      "use strict";
+      var setTimeout2 = global2.setTimeout;
+      var clearTimeout2 = global2.clearTimeout;
+      var XMLHttpRequest2 = global2.XMLHttpRequest;
+      var XDomainRequest2 = global2.XDomainRequest;
+      var ActiveXObject = global2.ActiveXObject;
+      var NativeEventSource = global2.EventSource;
+      var document = global2.document;
+      var Promise2 = global2.Promise;
+      var fetch2 = global2.fetch;
+      var Response = global2.Response;
+      var TextDecoder = global2.TextDecoder;
+      var TextEncoder = global2.TextEncoder;
+      var AbortController2 = global2.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 (XMLHttpRequest2 == null && ActiveXObject != null) {
+        XMLHttpRequest2 = 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 (AbortController2 == void 0) {
+        var originalFetch2 = fetch2;
+        fetch2 = 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;
+                }
+              }
+            };
+          });
+        };
+        AbortController2 = 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 XMLHttpRequest2.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 XMLHttpRequest2.prototype) || !("sendAsBinary" in XMLHttpRequest2.prototype) && !("mozAnon" in XMLHttpRequest2.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 (XMLHttpRequest2 != null && XMLHttpRequest2.HEADERS_RECEIVED == null) {
+        XMLHttpRequest2.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 === XMLHttpRequest2.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 AbortController2();
+        var signal = controller.signal;
+        var textDecoder = new TextDecoder();
+        fetch2(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 XMLHttpRequest2 != void 0 && "withCredentials" in XMLHttpRequest2.prototype || XDomainRequest2 == void 0 ? new XMLHttpRequest2() : new XDomainRequest2();
+      }
+      var isFetchSupported = fetch2 != 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 (XMLHttpRequest2 != 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(global2);
+        }
+      })(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/nano-pubsub/index.js
+var require_nano_pubsub = __commonJS({
+  "node_modules/nano-pubsub/index.js"(exports, module) {
+    module.exports = function Pubsub() {
+      var subscribers = [];
+      return {
+        subscribe,
+        publish
+      };
+      function subscribe(subscriber) {
+        subscribers.push(subscriber);
+        return function unsubscribe() {
+          var idx = subscribers.indexOf(subscriber);
+          if (idx > -1) {
+            subscribers.splice(idx, 1);
+          }
+        };
+      }
+      function publish() {
+        for (var i = 0; i < subscribers.length; i++) {
+          subscribers[i].apply(null, arguments);
+        }
+      }
+    };
+  }
+});
+
+// node_modules/get-it/lib/util/middlewareReducer.js
+var require_middlewareReducer = __commonJS({
+  "node_modules/get-it/lib/util/middlewareReducer.js"(exports, module) {
+    "use strict";
+    module.exports = function(middleware3) {
+      var applyMiddleware = function applyMiddleware2(hook, defaultValue) {
+        var bailEarly = hook === "onError";
+        var value = defaultValue;
+        for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+          args[_key - 2] = arguments[_key];
+        }
+        for (var i = 0; i < middleware3[hook].length; i++) {
+          var handler = middleware3[hook][i];
+          value = handler.apply(void 0, [value].concat(args));
+          if (bailEarly && !value) {
+            break;
+          }
+        }
+        return value;
+      };
+      return applyMiddleware;
+    };
+  }
+});
+
+// node_modules/object-assign/index.js
+var require_object_assign = __commonJS({
+  "node_modules/object-assign/index.js"(exports, module) {
+    "use strict";
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+    function toObject(val) {
+      if (val === null || val === void 0) {
+        throw new TypeError("Object.assign cannot be called with null or undefined");
+      }
+      return Object(val);
+    }
+    function shouldUseNative() {
+      try {
+        if (!Object.assign) {
+          return false;
+        }
+        var test1 = new String("abc");
+        test1[5] = "de";
+        if (Object.getOwnPropertyNames(test1)[0] === "5") {
+          return false;
+        }
+        var test2 = {};
+        for (var i = 0; i < 10; i++) {
+          test2["_" + String.fromCharCode(i)] = i;
+        }
+        var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
+          return test2[n];
+        });
+        if (order2.join("") !== "0123456789") {
+          return false;
+        }
+        var test3 = {};
+        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+          test3[letter] = letter;
+        });
+        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+          return false;
+        }
+        return true;
+      } catch (err) {
+        return false;
+      }
+    }
+    module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+      var from;
+      var to = toObject(target);
+      var symbols;
+      for (var s = 1; s < arguments.length; s++) {
+        from = Object(arguments[s]);
+        for (var key in from) {
+          if (hasOwnProperty.call(from, key)) {
+            to[key] = from[key];
+          }
+        }
+        if (getOwnPropertySymbols) {
+          symbols = getOwnPropertySymbols(from);
+          for (var i = 0; i < symbols.length; i++) {
+            if (propIsEnumerable.call(from, symbols[i])) {
+              to[symbols[i]] = from[symbols[i]];
+            }
+          }
+        }
+      }
+      return to;
+    };
+  }
+});
+
+// node_modules/requires-port/index.js
+var require_requires_port = __commonJS({
+  "node_modules/requires-port/index.js"(exports, module) {
+    "use strict";
+    module.exports = function required(port, protocol) {
+      protocol = protocol.split(":")[0];
+      port = +port;
+      if (!port)
+        return false;
+      switch (protocol) {
+        case "http":
+        case "ws":
+          return port !== 80;
+        case "https":
+        case "wss":
+          return port !== 443;
+        case "ftp":
+          return port !== 21;
+        case "gopher":
+          return port !== 70;
+        case "file":
+          return false;
+      }
+      return port !== 0;
+    };
+  }
+});
+
+// node_modules/querystringify/index.js
+var require_querystringify = __commonJS({
+  "node_modules/querystringify/index.js"(exports) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var undef;
+    function decode(input) {
+      try {
+        return decodeURIComponent(input.replace(/\+/g, " "));
+      } catch (e) {
+        return null;
+      }
+    }
+    function encode(input) {
+      try {
+        return encodeURIComponent(input);
+      } catch (e) {
+        return null;
+      }
+    }
+    function querystring(query) {
+      var parser = /([^=?#&]+)=?([^&]*)/g, result = {}, part;
+      while (part = parser.exec(query)) {
+        var key = decode(part[1]), value = decode(part[2]);
+        if (key === null || value === null || key in result)
+          continue;
+        result[key] = value;
+      }
+      return result;
+    }
+    function querystringify(obj, prefix) {
+      prefix = prefix || "";
+      var pairs = [], value, key;
+      if (typeof prefix !== "string")
+        prefix = "?";
+      for (key in obj) {
+        if (has.call(obj, key)) {
+          value = obj[key];
+          if (!value && (value === null || value === undef || isNaN(value))) {
+            value = "";
+          }
+          key = encode(key);
+          value = encode(value);
+          if (key === null || value === null)
+            continue;
+          pairs.push(key + "=" + value);
+        }
+      }
+      return pairs.length ? prefix + pairs.join("&") : "";
+    }
+    exports.stringify = querystringify;
+    exports.parse = querystring;
+  }
+});
+
+// node_modules/url-parse/index.js
+var require_url_parse = __commonJS({
+  "node_modules/url-parse/index.js"(exports, module) {
+    "use strict";
+    var required = require_requires_port();
+    var qs = require_querystringify();
+    var controlOrWhitespace = /^[\x00-\x20\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/;
+    var CRHTLF = /[\n\r\t]/g;
+    var slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//;
+    var port = /:\d+$/;
+    var protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\\/]+)?([\S\s]*)/i;
+    var windowsDriveLetter = /^[a-zA-Z]:/;
+    function trimLeft(str) {
+      return (str ? str : "").toString().replace(controlOrWhitespace, "");
+    }
+    var rules = [
+      ["#", "hash"],
+      ["?", "query"],
+      function sanitize(address, url) {
+        return isSpecial(url.protocol) ? address.replace(/\\/g, "/") : address;
+      },
+      ["/", "pathname"],
+      ["@", "auth", 1],
+      [NaN, "host", void 0, 1, 1],
+      [/:(\d*)$/, "port", void 0, 1],
+      [NaN, "hostname", void 0, 1, 1]
+    ];
+    var ignore = { hash: 1, query: 1 };
+    function lolcation(loc) {
+      var globalVar;
+      if (typeof window !== "undefined")
+        globalVar = window;
+      else if (typeof global !== "undefined")
+        globalVar = global;
+      else if (typeof self !== "undefined")
+        globalVar = self;
+      else
+        globalVar = {};
+      var location = globalVar.location || {};
+      loc = loc || location;
+      var finaldestination = {}, type = typeof loc, key;
+      if (loc.protocol === "blob:") {
+        finaldestination = new Url(unescape(loc.pathname), {});
+      } else if (type === "string") {
+        finaldestination = new Url(loc, {});
+        for (key in ignore)
+          delete finaldestination[key];
+      } else if (type === "object") {
+        for (key in loc) {
+          if (key in ignore)
+            continue;
+          finaldestination[key] = loc[key];
+        }
+        if (finaldestination.slashes === void 0) {
+          finaldestination.slashes = slashes.test(loc.href);
+        }
+      }
+      return finaldestination;
+    }
+    function isSpecial(scheme) {
+      return scheme === "file:" || scheme === "ftp:" || scheme === "http:" || scheme === "https:" || scheme === "ws:" || scheme === "wss:";
+    }
+    function extractProtocol(address, location) {
+      address = trimLeft(address);
+      address = address.replace(CRHTLF, "");
+      location = location || {};
+      var match = protocolre.exec(address);
+      var protocol = match[1] ? match[1].toLowerCase() : "";
+      var forwardSlashes = !!match[2];
+      var otherSlashes = !!match[3];
+      var slashesCount = 0;
+      var rest;
+      if (forwardSlashes) {
+        if (otherSlashes) {
+          rest = match[2] + match[3] + match[4];
+          slashesCount = match[2].length + match[3].length;
+        } else {
+          rest = match[2] + match[4];
+          slashesCount = match[2].length;
+        }
+      } else {
+        if (otherSlashes) {
+          rest = match[3] + match[4];
+          slashesCount = match[3].length;
+        } else {
+          rest = match[4];
+        }
+      }
+      if (protocol === "file:") {
+        if (slashesCount >= 2) {
+          rest = rest.slice(2);
+        }
+      } else if (isSpecial(protocol)) {
+        rest = match[4];
+      } else if (protocol) {
+        if (forwardSlashes) {
+          rest = rest.slice(2);
+        }
+      } else if (slashesCount >= 2 && isSpecial(location.protocol)) {
+        rest = match[4];
+      }
+      return {
+        protocol,
+        slashes: forwardSlashes || isSpecial(protocol),
+        slashesCount,
+        rest
+      };
+    }
+    function resolve(relative, base) {
+      if (relative === "")
+        return base;
+      var path = (base || "/").split("/").slice(0, -1).concat(relative.split("/")), i = path.length, last = path[i - 1], unshift = false, up = 0;
+      while (i--) {
+        if (path[i] === ".") {
+          path.splice(i, 1);
+        } else if (path[i] === "..") {
+          path.splice(i, 1);
+          up++;
+        } else if (up) {
+          if (i === 0)
+            unshift = true;
+          path.splice(i, 1);
+          up--;
+        }
+      }
+      if (unshift)
+        path.unshift("");
+      if (last === "." || last === "..")
+        path.push("");
+      return path.join("/");
+    }
+    function Url(address, location, parser) {
+      address = trimLeft(address);
+      address = address.replace(CRHTLF, "");
+      if (!(this instanceof Url)) {
+        return new Url(address, location, parser);
+      }
+      var relative, extracted, parse, instruction, index, key, instructions = rules.slice(), type = typeof location, url = this, i = 0;
+      if (type !== "object" && type !== "string") {
+        parser = location;
+        location = null;
+      }
+      if (parser && typeof parser !== "function")
+        parser = qs.parse;
+      location = lolcation(location);
+      extracted = extractProtocol(address || "", location);
+      relative = !extracted.protocol && !extracted.slashes;
+      url.slashes = extracted.slashes || relative && location.slashes;
+      url.protocol = extracted.protocol || location.protocol || "";
+      address = extracted.rest;
+      if (extracted.protocol === "file:" && (extracted.slashesCount !== 2 || windowsDriveLetter.test(address)) || !extracted.slashes && (extracted.protocol || extracted.slashesCount < 2 || !isSpecial(url.protocol))) {
+        instructions[3] = [/(.*)/, "pathname"];
+      }
+      for (; i < instructions.length; i++) {
+        instruction = instructions[i];
+        if (typeof instruction === "function") {
+          address = instruction(address, url);
+          continue;
+        }
+        parse = instruction[0];
+        key = instruction[1];
+        if (parse !== parse) {
+          url[key] = address;
+        } else if (typeof parse === "string") {
+          index = parse === "@" ? address.lastIndexOf(parse) : address.indexOf(parse);
+          if (~index) {
+            if (typeof instruction[2] === "number") {
+              url[key] = address.slice(0, index);
+              address = address.slice(index + instruction[2]);
+            } else {
+              url[key] = address.slice(index);
+              address = address.slice(0, index);
+            }
+          }
+        } else if (index = parse.exec(address)) {
+          url[key] = index[1];
+          address = address.slice(0, index.index);
+        }
+        url[key] = url[key] || (relative && instruction[3] ? location[key] || "" : "");
+        if (instruction[4])
+          url[key] = url[key].toLowerCase();
+      }
+      if (parser)
+        url.query = parser(url.query);
+      if (relative && location.slashes && url.pathname.charAt(0) !== "/" && (url.pathname !== "" || location.pathname !== "")) {
+        url.pathname = resolve(url.pathname, location.pathname);
+      }
+      if (url.pathname.charAt(0) !== "/" && isSpecial(url.protocol)) {
+        url.pathname = "/" + url.pathname;
+      }
+      if (!required(url.port, url.protocol)) {
+        url.host = url.hostname;
+        url.port = "";
+      }
+      url.username = url.password = "";
+      if (url.auth) {
+        index = url.auth.indexOf(":");
+        if (~index) {
+          url.username = url.auth.slice(0, index);
+          url.username = encodeURIComponent(decodeURIComponent(url.username));
+          url.password = url.auth.slice(index + 1);
+          url.password = encodeURIComponent(decodeURIComponent(url.password));
+        } else {
+          url.username = encodeURIComponent(decodeURIComponent(url.auth));
+        }
+        url.auth = url.password ? url.username + ":" + url.password : url.username;
+      }
+      url.origin = url.protocol !== "file:" && isSpecial(url.protocol) && url.host ? url.protocol + "//" + url.host : "null";
+      url.href = url.toString();
+    }
+    function set(part, value, fn) {
+      var url = this;
+      switch (part) {
+        case "query":
+          if (typeof value === "string" && value.length) {
+            value = (fn || qs.parse)(value);
+          }
+          url[part] = value;
+          break;
+        case "port":
+          url[part] = value;
+          if (!required(value, url.protocol)) {
+            url.host = url.hostname;
+            url[part] = "";
+          } else if (value) {
+            url.host = url.hostname + ":" + value;
+          }
+          break;
+        case "hostname":
+          url[part] = value;
+          if (url.port)
+            value += ":" + url.port;
+          url.host = value;
+          break;
+        case "host":
+          url[part] = value;
+          if (port.test(value)) {
+            value = value.split(":");
+            url.port = value.pop();
+            url.hostname = value.join(":");
+          } else {
+            url.hostname = value;
+            url.port = "";
+          }
+          break;
+        case "protocol":
+          url.protocol = value.toLowerCase();
+          url.slashes = !fn;
+          break;
+        case "pathname":
+        case "hash":
+          if (value) {
+            var char = part === "pathname" ? "/" : "#";
+            url[part] = value.charAt(0) !== char ? char + value : value;
+          } else {
+            url[part] = value;
+          }
+          break;
+        case "username":
+        case "password":
+          url[part] = encodeURIComponent(value);
+          break;
+        case "auth":
+          var index = value.indexOf(":");
+          if (~index) {
+            url.username = value.slice(0, index);
+            url.username = encodeURIComponent(decodeURIComponent(url.username));
+            url.password = value.slice(index + 1);
+            url.password = encodeURIComponent(decodeURIComponent(url.password));
+          } else {
+            url.username = encodeURIComponent(decodeURIComponent(value));
+          }
+      }
+      for (var i = 0; i < rules.length; i++) {
+        var ins = rules[i];
+        if (ins[4])
+          url[ins[1]] = url[ins[1]].toLowerCase();
+      }
+      url.auth = url.password ? url.username + ":" + url.password : url.username;
+      url.origin = url.protocol !== "file:" && isSpecial(url.protocol) && url.host ? url.protocol + "//" + url.host : "null";
+      url.href = url.toString();
+      return url;
+    }
+    function toString(stringify) {
+      if (!stringify || typeof stringify !== "function")
+        stringify = qs.stringify;
+      var query, url = this, host = url.host, protocol = url.protocol;
+      if (protocol && protocol.charAt(protocol.length - 1) !== ":")
+        protocol += ":";
+      var result = protocol + (url.protocol && url.slashes || isSpecial(url.protocol) ? "//" : "");
+      if (url.username) {
+        result += url.username;
+        if (url.password)
+          result += ":" + url.password;
+        result += "@";
+      } else if (url.password) {
+        result += ":" + url.password;
+        result += "@";
+      } else if (url.protocol !== "file:" && isSpecial(url.protocol) && !host && url.pathname !== "/") {
+        result += "@";
+      }
+      if (host[host.length - 1] === ":" || port.test(url.hostname) && !url.port) {
+        host += ":";
+      }
+      result += host + url.pathname;
+      query = typeof url.query === "object" ? stringify(url.query) : url.query;
+      if (query)
+        result += query.charAt(0) !== "?" ? "?" + query : query;
+      if (url.hash)
+        result += url.hash;
+      return result;
+    }
+    Url.prototype = { set, toString };
+    Url.extractProtocol = extractProtocol;
+    Url.location = lolcation;
+    Url.trimLeft = trimLeft;
+    Url.qs = qs;
+    module.exports = Url;
+  }
+});
+
+// node_modules/get-it/lib/middleware/defaultOptionsProcessor.js
+var require_defaultOptionsProcessor = __commonJS({
+  "node_modules/get-it/lib/middleware/defaultOptionsProcessor.js"(exports, module) {
+    "use strict";
+    var objectAssign = require_object_assign();
+    var urlParse = require_url_parse();
+    var isReactNative = typeof navigator === "undefined" ? false : navigator.product === "ReactNative";
+    var has = Object.prototype.hasOwnProperty;
+    var defaultOptions2 = {
+      timeout: isReactNative ? 6e4 : 12e4
+    };
+    module.exports = function(opts) {
+      var options = typeof opts === "string" ? objectAssign({
+        url: opts
+      }, defaultOptions2) : objectAssign({}, defaultOptions2, opts);
+      var url = urlParse(options.url, {}, true);
+      options.timeout = normalizeTimeout(options.timeout);
+      if (options.query) {
+        url.query = objectAssign({}, url.query, removeUndefined(options.query));
+      }
+      options.method = options.body && !options.method ? "POST" : (options.method || "GET").toUpperCase();
+      options.url = url.toString(stringifyQueryString);
+      return options;
+    };
+    function stringifyQueryString(obj) {
+      var pairs = [];
+      for (var key in obj) {
+        if (has.call(obj, key)) {
+          push(key, obj[key]);
+        }
+      }
+      return pairs.length ? pairs.join("&") : "";
+      function push(key2, val) {
+        if (Array.isArray(val)) {
+          val.forEach(function(item) {
+            return push(key2, item);
+          });
+        } else {
+          pairs.push([key2, val].map(encodeURIComponent).join("="));
+        }
+      }
+    }
+    function normalizeTimeout(time) {
+      if (time === false || time === 0) {
+        return false;
+      }
+      if (time.connect || time.socket) {
+        return time;
+      }
+      var delay = Number(time);
+      if (isNaN(delay)) {
+        return normalizeTimeout(defaultOptions2.timeout);
+      }
+      return {
+        connect: delay,
+        socket: delay
+      };
+    }
+    function removeUndefined(obj) {
+      var target = {};
+      for (var key in obj) {
+        if (obj[key] !== void 0) {
+          target[key] = obj[key];
+        }
+      }
+      return target;
+    }
+  }
+});
+
+// node_modules/get-it/lib/middleware/defaultOptionsValidator.js
+var require_defaultOptionsValidator = __commonJS({
+  "node_modules/get-it/lib/middleware/defaultOptionsValidator.js"(exports, module) {
+    "use strict";
+    var validUrl = /^https?:\/\//i;
+    module.exports = function(options) {
+      if (!validUrl.test(options.url)) {
+        throw new Error('"'.concat(options.url, '" is not a valid URL'));
+      }
+    };
+  }
+});
+
+// node_modules/same-origin/url-parser.js
+var require_url_parser = __commonJS({
+  "node_modules/same-origin/url-parser.js"(exports, module) {
+    "use strict";
+    var regex = /^(?:(?:(?:([^:\/#\?]+:)?(?:(?:\/\/)((?:((?:[^:@\/#\?]+)(?:\:(?:[^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((?:\/?(?:[^\/\?#]+\/+)*)(?:[^\?#]*)))?(\?[^#]+)?)(#.*)?/;
+    module.exports = {
+      regex,
+      parse: function(url) {
+        var match = regex.exec(url);
+        if (!match) {
+          return {};
+        }
+        return {
+          protocol: (match[1] || "").toLowerCase() || void 0,
+          hostname: (match[5] || "").toLowerCase() || void 0,
+          port: match[6] || void 0
+        };
+      }
+    };
+  }
+});
+
+// node_modules/same-origin/index.js
+var require_same_origin = __commonJS({
+  "node_modules/same-origin/index.js"(exports, module) {
+    "use strict";
+    var url = require_url_parser();
+    module.exports = function(uri1, uri2, ieMode) {
+      if (uri1 === uri2) {
+        return true;
+      }
+      var url1 = url.parse(uri1, false, true);
+      var url2 = url.parse(uri2, false, true);
+      var url1Port = url1.port | 0 || (url1.protocol === "https" ? 443 : 80);
+      var url2Port = url2.port | 0 || (url2.protocol === "https" ? 443 : 80);
+      var match = {
+        proto: url1.protocol === url2.protocol,
+        hostname: url1.hostname === url2.hostname,
+        port: url1Port === url2Port
+      };
+      return match.proto && match.hostname && (match.port || ieMode);
+    };
+  }
+});
+
+// node_modules/parse-headers/parse-headers.js
+var require_parse_headers = __commonJS({
+  "node_modules/parse-headers/parse-headers.js"(exports, module) {
+    var trim = function(string) {
+      return string.replace(/^\s+|\s+$/g, "");
+    };
+    var isArray = function(arg) {
+      return Object.prototype.toString.call(arg) === "[object Array]";
+    };
+    module.exports = function(headers) {
+      if (!headers)
+        return {};
+      var result = {};
+      var headersArr = trim(headers).split("\n");
+      for (var i = 0; i < headersArr.length; i++) {
+        var row = headersArr[i];
+        var index = row.indexOf(":"), key = trim(row.slice(0, index)).toLowerCase(), value = trim(row.slice(index + 1));
+        if (typeof result[key] === "undefined") {
+          result[key] = value;
+        } else if (isArray(result[key])) {
+          result[key].push(value);
+        } else {
+          result[key] = [result[key], value];
+        }
+      }
+      return result;
+    };
+  }
+});
+
+// node_modules/get-it/lib/request/browser/fetchXhr.js
+var require_fetchXhr = __commonJS({
+  "node_modules/get-it/lib/request/browser/fetchXhr.js"(exports, module) {
+    "use strict";
+    function FetchXhr() {
+      this.readyState = 0;
+    }
+    FetchXhr.prototype.open = function(method, url) {
+      this._method = method;
+      this._url = url;
+      this._resHeaders = "";
+      this.readyState = 1;
+      this.onreadystatechange();
+    };
+    FetchXhr.prototype.abort = function() {
+      if (this._controller) {
+        this._controller.abort();
+      }
+    };
+    FetchXhr.prototype.getAllResponseHeaders = function() {
+      return this._resHeaders;
+    };
+    FetchXhr.prototype.setRequestHeader = function(key, value) {
+      this._headers = this._headers || {};
+      this._headers[key] = value;
+    };
+    FetchXhr.prototype.send = function(body) {
+      var _this = this;
+      var ctrl = this._controller = typeof AbortController === "function" && new AbortController();
+      var textBody = this.responseType !== "arraybuffer";
+      var options = {
+        method: this._method,
+        headers: this._headers,
+        signal: ctrl && ctrl.signal,
+        body
+      };
+      if (typeof window !== "undefined") {
+        options.credentials = this.withCredentials ? "include" : "omit";
+      }
+      fetch(this._url, options).then(function(res) {
+        res.headers.forEach(function(value, key) {
+          _this._resHeaders += "".concat(key, ": ").concat(value, "\r\n");
+        });
+        _this.status = res.status;
+        _this.statusText = res.statusText;
+        _this.readyState = 3;
+        return textBody ? res.text() : res.arrayBuffer();
+      }).then(function(resBody) {
+        if (textBody) {
+          _this.responseText = resBody;
+        } else {
+          _this.response = resBody;
+        }
+        _this.readyState = 4;
+        _this.onreadystatechange();
+      }).catch(function(err) {
+        if (err.name === "AbortError") {
+          _this.onabort();
+          return;
+        }
+        _this.onerror(err);
+      });
+    };
+    module.exports = FetchXhr;
+  }
+});
+
+// node_modules/get-it/lib/request/browser-request.js
+var require_browser_request = __commonJS({
+  "node_modules/get-it/lib/request/browser-request.js"(exports, module) {
+    "use strict";
+    var sameOrigin = require_same_origin();
+    var parseHeaders = require_parse_headers();
+    var FetchXhr = require_fetchXhr();
+    var noop = function noop2() {
+    };
+    var win = typeof window === "undefined" ? void 0 : window;
+    var adapter = win ? "xhr" : "fetch";
+    var XmlHttpRequest = typeof XMLHttpRequest === "function" ? XMLHttpRequest : noop;
+    var hasXhr2 = "withCredentials" in new XmlHttpRequest();
+    var XDR = typeof XDomainRequest === "undefined" ? void 0 : XDomainRequest;
+    var CrossDomainRequest = hasXhr2 ? XmlHttpRequest : XDR;
+    if (!win) {
+      XmlHttpRequest = FetchXhr;
+      CrossDomainRequest = FetchXhr;
+    }
+    module.exports = function(context, callback) {
+      var opts = context.options;
+      var options = context.applyMiddleware("finalizeOptions", opts);
+      var timers = {};
+      var cors = win && win.location && !sameOrigin(win.location.href, options.url);
+      var injectedResponse = context.applyMiddleware("interceptRequest", void 0, {
+        adapter,
+        context
+      });
+      if (injectedResponse) {
+        var cbTimer = setTimeout(callback, 0, null, injectedResponse);
+        var cancel = function cancel2() {
+          return clearTimeout(cbTimer);
+        };
+        return {
+          abort: cancel
+        };
+      }
+      var xhr = cors ? new CrossDomainRequest() : new XmlHttpRequest();
+      var isXdr = win && win.XDomainRequest && xhr instanceof win.XDomainRequest;
+      var headers = options.headers;
+      var delays = options.timeout;
+      var aborted = false;
+      var loaded = false;
+      var timedOut = false;
+      xhr.onerror = onError;
+      xhr.ontimeout = onError;
+      xhr.onabort = function() {
+        stopTimers(true);
+        aborted = true;
+      };
+      xhr.onprogress = function() {
+      };
+      var loadEvent = isXdr ? "onload" : "onreadystatechange";
+      xhr[loadEvent] = function() {
+        resetTimers();
+        if (aborted || xhr.readyState !== 4 && !isXdr) {
+          return;
+        }
+        if (xhr.status === 0) {
+          return;
+        }
+        onLoad();
+      };
+      xhr.open(options.method, options.url, true);
+      xhr.withCredentials = !!options.withCredentials;
+      if (headers && xhr.setRequestHeader) {
+        for (var key in headers) {
+          if (headers.hasOwnProperty(key)) {
+            xhr.setRequestHeader(key, headers[key]);
+          }
+        }
+      } else if (headers && isXdr) {
+        throw new Error("Headers cannot be set on an XDomainRequest object");
+      }
+      if (options.rawBody) {
+        xhr.responseType = "arraybuffer";
+      }
+      context.applyMiddleware("onRequest", {
+        options,
+        adapter,
+        request: xhr,
+        context
+      });
+      xhr.send(options.body || null);
+      if (delays) {
+        timers.connect = setTimeout(function() {
+          return timeoutRequest("ETIMEDOUT");
+        }, delays.connect);
+      }
+      return {
+        abort
+      };
+      function abort() {
+        aborted = true;
+        if (xhr) {
+          xhr.abort();
+        }
+      }
+      function timeoutRequest(code) {
+        timedOut = true;
+        xhr.abort();
+        var error = new Error(code === "ESOCKETTIMEDOUT" ? "Socket timed out on request to ".concat(options.url) : "Connection timed out on request to ".concat(options.url));
+        error.code = code;
+        context.channels.error.publish(error);
+      }
+      function resetTimers() {
+        if (!delays) {
+          return;
+        }
+        stopTimers();
+        timers.socket = setTimeout(function() {
+          return timeoutRequest("ESOCKETTIMEDOUT");
+        }, delays.socket);
+      }
+      function stopTimers(force) {
+        if (force || aborted || xhr.readyState >= 2 && timers.connect) {
+          clearTimeout(timers.connect);
+        }
+        if (timers.socket) {
+          clearTimeout(timers.socket);
+        }
+      }
+      function onError(error) {
+        if (loaded) {
+          return;
+        }
+        stopTimers(true);
+        loaded = true;
+        xhr = null;
+        var err = error || new Error("Network error while attempting to reach ".concat(options.url));
+        err.isNetworkError = true;
+        err.request = options;
+        callback(err);
+      }
+      function reduceResponse() {
+        var statusCode = xhr.status;
+        var statusMessage = xhr.statusText;
+        if (isXdr && statusCode === void 0) {
+          statusCode = 200;
+        } else if (statusCode > 12e3 && statusCode < 12156) {
+          return onError();
+        } else {
+          statusCode = xhr.status === 1223 ? 204 : xhr.status;
+          statusMessage = xhr.status === 1223 ? "No Content" : statusMessage;
+        }
+        return {
+          body: xhr.response || xhr.responseText,
+          url: options.url,
+          method: options.method,
+          headers: isXdr ? {} : parseHeaders(xhr.getAllResponseHeaders()),
+          statusCode,
+          statusMessage
+        };
+      }
+      function onLoad() {
+        if (aborted || loaded || timedOut) {
+          return;
+        }
+        if (xhr.status === 0) {
+          onError(new Error("Unknown XHR error"));
+          return;
+        }
+        stopTimers();
+        loaded = true;
+        callback(null, reduceResponse());
+      }
+    };
+  }
+});
+
+// node_modules/get-it/lib/request/index.js
+var require_request = __commonJS({
+  "node_modules/get-it/lib/request/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_browser_request();
+  }
+});
+
+// node_modules/get-it/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/get-it/lib/index.js"(exports, module) {
+    "use strict";
+    var pubsub = require_nano_pubsub();
+    var middlewareReducer = require_middlewareReducer();
+    var processOptions = require_defaultOptionsProcessor();
+    var validateOptions = require_defaultOptionsValidator();
+    var httpRequester = require_request();
+    var channelNames = ["request", "response", "progress", "error", "abort"];
+    var middlehooks = ["processOptions", "validateOptions", "interceptRequest", "finalizeOptions", "onRequest", "onResponse", "onError", "onReturn", "onHeaders"];
+    module.exports = function createRequester() {
+      var initMiddleware = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+      var httpRequest2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : httpRequester;
+      var loadedMiddleware = [];
+      var middleware3 = middlehooks.reduce(function(ware, name) {
+        ware[name] = ware[name] || [];
+        return ware;
+      }, {
+        processOptions: [processOptions],
+        validateOptions: [validateOptions]
+      });
+      function request2(opts) {
+        var channels = channelNames.reduce(function(target, name) {
+          target[name] = pubsub();
+          return target;
+        }, {});
+        var applyMiddleware = middlewareReducer(middleware3);
+        var options = applyMiddleware("processOptions", opts);
+        applyMiddleware("validateOptions", options);
+        var context = {
+          options,
+          channels,
+          applyMiddleware
+        };
+        var ongoingRequest = null;
+        var unsubscribe = channels.request.subscribe(function(ctx) {
+          ongoingRequest = httpRequest2(ctx, function(err, res) {
+            return onResponse(err, res, ctx);
+          });
+        });
+        channels.abort.subscribe(function() {
+          unsubscribe();
+          if (ongoingRequest) {
+            ongoingRequest.abort();
+          }
+        });
+        var returnValue = applyMiddleware("onReturn", channels, context);
+        if (returnValue === channels) {
+          channels.request.publish(context);
+        }
+        return returnValue;
+        function onResponse(reqErr, res, ctx) {
+          var error = reqErr;
+          var response = res;
+          if (!error) {
+            try {
+              response = applyMiddleware("onResponse", res, ctx);
+            } catch (err) {
+              response = null;
+              error = err;
+            }
+          }
+          error = error && applyMiddleware("onError", error, ctx);
+          if (error) {
+            channels.error.publish(error);
+          } else if (response) {
+            channels.response.publish(response);
+          }
+        }
+      }
+      request2.use = function use(newMiddleware) {
+        if (!newMiddleware) {
+          throw new Error("Tried to add middleware that resolved to falsey value");
+        }
+        if (typeof newMiddleware === "function") {
+          throw new Error("Tried to add middleware that was a function. It probably expects you to pass options to it.");
+        }
+        if (newMiddleware.onReturn && middleware3.onReturn.length > 0) {
+          throw new Error("Tried to add new middleware with `onReturn` handler, but another handler has already been registered for this event");
+        }
+        middlehooks.forEach(function(key) {
+          if (newMiddleware[key]) {
+            middleware3[key].push(newMiddleware[key]);
+          }
+        });
+        loadedMiddleware.push(newMiddleware);
+        return request2;
+      };
+      request2.clone = function clone() {
+        return createRequester(loadedMiddleware);
+      };
+      initMiddleware.forEach(request2.use);
+      return request2;
+    };
+  }
+});
+
+// node_modules/get-it/index.js
+var require_get_it = __commonJS({
+  "node_modules/get-it/index.js"(exports, module) {
+    module.exports = require_lib();
+  }
+});
+
+// node_modules/get-it/lib/util/global.js
+var require_global = __commonJS({
+  "node_modules/get-it/lib/util/global.js"(exports, module) {
+    "use strict";
+    if (typeof globalThis !== "undefined") {
+      module.exports = globalThis;
+    } else if (typeof window !== "undefined") {
+      module.exports = window;
+    } else if (typeof global !== "undefined") {
+      module.exports = global;
+    } else if (typeof self !== "undefined") {
+      module.exports = self;
+    } else {
+      module.exports = {};
+    }
+  }
+});
+
+// node_modules/get-it/lib/middleware/observable.js
+var require_observable2 = __commonJS({
+  "node_modules/get-it/lib/middleware/observable.js"(exports, module) {
+    "use strict";
+    var global2 = require_global();
+    var objectAssign = require_object_assign();
+    module.exports = function() {
+      var opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+      var Observable2 = opts.implementation || global2.Observable;
+      if (!Observable2) {
+        throw new Error("`Observable` is not available in global scope, and no implementation was passed");
+      }
+      return {
+        onReturn: function onReturn(channels, context) {
+          return new Observable2(function(observer) {
+            channels.error.subscribe(function(err) {
+              return observer.error(err);
+            });
+            channels.progress.subscribe(function(event) {
+              return observer.next(objectAssign({
+                type: "progress"
+              }, event));
+            });
+            channels.response.subscribe(function(response) {
+              observer.next(objectAssign({
+                type: "response"
+              }, response));
+              observer.complete();
+            });
+            channels.request.publish(context);
+            return function() {
+              return channels.abort.publish();
+            };
+          });
+        }
+      };
+    };
+  }
+});
+
+// node_modules/isobject/index.js
+var require_isobject = __commonJS({
+  "node_modules/isobject/index.js"(exports, module) {
+    "use strict";
+    module.exports = function isObject(val) {
+      return val != null && typeof val === "object" && Array.isArray(val) === false;
+    };
+  }
+});
+
+// node_modules/is-plain-object/index.js
+var require_is_plain_object = __commonJS({
+  "node_modules/is-plain-object/index.js"(exports, module) {
+    "use strict";
+    var isObject = require_isobject();
+    function isObjectObject(o) {
+      return isObject(o) === true && Object.prototype.toString.call(o) === "[object Object]";
+    }
+    module.exports = function isPlainObject(o) {
+      var ctor, prot;
+      if (isObjectObject(o) === false)
+        return false;
+      ctor = o.constructor;
+      if (typeof ctor !== "function")
+        return false;
+      prot = ctor.prototype;
+      if (isObjectObject(prot) === false)
+        return false;
+      if (prot.hasOwnProperty("isPrototypeOf") === false) {
+        return false;
+      }
+      return true;
+    };
+  }
+});
+
+// node_modules/get-it/lib/middleware/jsonRequest.js
+var require_jsonRequest = __commonJS({
+  "node_modules/get-it/lib/middleware/jsonRequest.js"(exports, module) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    var objectAssign = require_object_assign();
+    var isPlainObject = require_is_plain_object();
+    var serializeTypes = ["boolean", "string", "number"];
+    var isBuffer = function isBuffer2(obj) {
+      return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+    };
+    module.exports = function() {
+      return {
+        processOptions: function processOptions(options) {
+          var body = options.body;
+          if (!body) {
+            return options;
+          }
+          var isStream = typeof body.pipe === "function";
+          var shouldSerialize = !isStream && !isBuffer(body) && (serializeTypes.indexOf(_typeof(body)) !== -1 || Array.isArray(body) || isPlainObject(body));
+          if (!shouldSerialize) {
+            return options;
+          }
+          return objectAssign({}, options, {
+            body: JSON.stringify(options.body),
+            headers: objectAssign({}, options.headers, {
+              "Content-Type": "application/json"
+            })
+          });
+        }
+      };
+    };
+  }
+});
+
+// node_modules/get-it/lib/middleware/jsonResponse.js
+var require_jsonResponse = __commonJS({
+  "node_modules/get-it/lib/middleware/jsonResponse.js"(exports, module) {
+    "use strict";
+    var objectAssign = require_object_assign();
+    module.exports = function(opts) {
+      return {
+        onResponse: function onResponse(response) {
+          var contentType = response.headers["content-type"] || "";
+          var shouldDecode = opts && opts.force || contentType.indexOf("application/json") !== -1;
+          if (!response.body || !contentType || !shouldDecode) {
+            return response;
+          }
+          return objectAssign({}, response, {
+            body: tryParse(response.body)
+          });
+        },
+        processOptions: function processOptions(options) {
+          return objectAssign({}, options, {
+            headers: objectAssign({
+              Accept: "application/json"
+            }, options.headers)
+          });
+        }
+      };
+    };
+    function tryParse(body) {
+      try {
+        return JSON.parse(body);
+      } catch (err) {
+        err.message = "Failed to parsed response body as JSON: ".concat(err.message);
+        throw err;
+      }
+    }
+  }
+});
+
+// node_modules/get-it/lib/middleware/progress/browser-progress.js
+var require_browser_progress = __commonJS({
+  "node_modules/get-it/lib/middleware/progress/browser-progress.js"(exports, module) {
+    "use strict";
+    module.exports = function() {
+      return {
+        onRequest: function onRequest(evt) {
+          if (evt.adapter !== "xhr") {
+            return;
+          }
+          var xhr = evt.request;
+          var context = evt.context;
+          if ("upload" in xhr && "onprogress" in xhr.upload) {
+            xhr.upload.onprogress = handleProgress("upload");
+          }
+          if ("onprogress" in xhr) {
+            xhr.onprogress = handleProgress("download");
+          }
+          function handleProgress(stage) {
+            return function(event) {
+              var percent = event.lengthComputable ? event.loaded / event.total * 100 : -1;
+              context.channels.progress.publish({
+                stage,
+                percent,
+                total: event.total,
+                loaded: event.loaded,
+                lengthComputable: event.lengthComputable
+              });
+            };
+          }
+        }
+      };
+    };
+  }
+});
+
+// node_modules/get-it/lib/middleware/progress/index.js
+var require_progress = __commonJS({
+  "node_modules/get-it/lib/middleware/progress/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_browser_progress();
+  }
+});
+
+// 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
-import { Observable } from "rxjs/internal/Observable";
-import { filter } from "rxjs/internal/operators/filter";
-import { map } from "rxjs/internal/operators/map";
+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) {
@@ -258,7 +3445,7 @@ var encodeQueryString = ({ query, params = {}, options = {} }) => {
 };
 
 // src/data/listen.js
-import polyfilledEventSource from "@sanity/eventsource";
+var import_eventsource = __toESM(require_browser());
 
 // src/util/pick.js
 var pick = (obj, props) => props.reduce((selection, prop) => {
@@ -277,7 +3464,7 @@ var defaults = (obj, defaults2) => Object.keys(defaults2).concat(Object.keys(obj
 
 // src/data/listen.js
 var MAX_URL_LENGTH = 16e3 - 1200;
-var EventSource = polyfilledEventSource;
+var EventSource = import_eventsource.default;
 var possibleOptions = [
   "includePreviousRevision",
   "includeResult",
@@ -296,7 +3483,7 @@ function listen(query, params, opts = {}) {
   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")));
+    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;
@@ -309,7 +3496,7 @@ function listen(query, params, opts = {}) {
       Authorization: `Bearer ${token}`
     };
   }
-  return new Observable((observer) => {
+  return new import_Observable.Observable((observer) => {
     let es = getEventSource();
     let reconnectTimer;
     let stopped = false;
@@ -428,17 +3615,17 @@ var dataMethods = {
   },
   fetch(query, params, options = {}) {
     const mapResponse = options.filterResponse === false ? (res) => res : (res) => res.result;
-    const observable2 = this._dataRequest("query", { query, params }, options).pipe(map(mapResponse));
+    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(filter(isResponse), map((event) => event.body.documents && event.body.documents[0]));
+    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(filter(isResponse), map((event) => {
+    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);
     }));
@@ -495,7 +3682,7 @@ var dataMethods = {
       tag,
       canUseCdn: isQuery
     };
-    return this._requestObservable(reqOptions).pipe(filter(isResponse), map(getBody), map((res) => {
+    return this._requestObservable(reqOptions).pipe((0, import_filter.filter)(isResponse), (0, import_map.map)(getBody), (0, import_map.map)((res) => {
       if (!isMutation) {
         return res;
       }
@@ -603,7 +3790,7 @@ var AssetsClient = class {
       query,
       body
     });
-    return this.client.isPromiseAPI() ? observable2.pipe(filter((event) => event.type === "response"), map((event) => event.body.document)).toPromise() : observable2;
+    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>)");
@@ -665,14 +3852,14 @@ var AuthClient = class {
 };
 
 // src/http/request.js
-import getIt from "get-it";
-import observable from "get-it/lib/middleware/observable";
-import jsonRequest from "get-it/lib/middleware/jsonRequest";
-import jsonResponse from "get-it/lib/middleware/jsonResponse";
-import progress from "get-it/lib/middleware/progress";
+var import_get_it = __toESM(require_get_it());
+var import_observable4 = __toESM(require_observable2());
+var import_jsonRequest = __toESM(require_jsonRequest());
+var import_jsonResponse = __toESM(require_jsonResponse());
+var import_progress = __toESM(require_progress());
 
 // src/http/errors.js
-import makeError from "make-error";
+var import_make_error = __toESM(require_make_error());
 function ClientError(res) {
   const props = extractErrorProps(res);
   ClientError.super.call(this, props.message);
@@ -711,8 +3898,8 @@ function stringifyBody(body, res) {
   const isJson = contentType.indexOf("application/json") !== -1;
   return isJson ? JSON.stringify(body, null, 2) : body;
 }
-makeError(ClientError);
-makeError(ServerError);
+(0, import_make_error.default)(ClientError);
+(0, import_make_error.default)(ServerError);
 
 // src/http/browserMiddleware.js
 var middleware = [];
@@ -738,13 +3925,13 @@ var printWarnings = {
 };
 var middleware2 = middleware.concat([
   printWarnings,
-  jsonRequest(),
-  jsonResponse(),
-  progress(),
+  (0, import_jsonRequest.default)(),
+  (0, import_jsonResponse.default)(),
+  (0, import_progress.default)(),
   httpError,
-  observable({ implementation: Observable })
+  (0, import_observable4.default)({ implementation: import_Observable.Observable })
 ]);
-var request = getIt(middleware2);
+var request = (0, import_get_it.default)(middleware2);
 function httpRequest(options, requester = request) {
   return requester(Object.assign({ maxRedirects: 0 }, options));
 }
@@ -774,11 +3961,11 @@ var requestOptions = (config, overrides = {}) => {
   });
 };
 
-// src/config.js
-import { generateHelpUrl as generateHelpUrl2 } from "@sanity/generate-help-url";
-
-// src/warnings.js
-import { generateHelpUrl } from "@sanity/generate-help-url";
+// node_modules/@sanity/generate-help-url/dist/generate-help-url.esm.js
+var BASE_URL = "https://docs.sanity.io/help/";
+function generateHelpUrl(slug) {
+  return BASE_URL + slug;
+}
 
 // src/util/once.js
 var once = (fn) => {
@@ -829,7 +4016,7 @@ var initConfig = (config, prevConfig) => {
   const newConfig = Object.assign({}, defaultConfig, specifiedConfig);
   const projectBased = newConfig.useProjectHostname;
   if (typeof Promise === "undefined") {
-    const helpUrl = generateHelpUrl2("js-client-promise-polyfill");
+    const helpUrl = generateHelpUrl("js-client-promise-polyfill");
     throw new Error(`No native Promise-implementation found, polyfill needed - see ${helpUrl}`);
   }
   if (projectBased && !newConfig.projectId) {
@@ -929,10 +4116,10 @@ var SanityClient = class {
     const reqOptions = requestOptions(this.clientConfig, Object.assign({}, options, {
       url: this.getUrl(uri, useCdn)
     }));
-    return new Observable((subscriber) => httpRequest(reqOptions, this.clientConfig.requester).subscribe(subscriber));
+    return new import_Observable.Observable((subscriber) => httpRequest(reqOptions, this.clientConfig.requester).subscribe(subscriber));
   }
   request(options) {
-    const observable2 = this._requestObservable(options).pipe(filter((event) => event.type === "response"), map((event) => event.body));
+    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;
   }
 };
@@ -954,3 +4141,25 @@ export {
   SanityClient,
   createClient
 };
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+/*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+/*!
+ * isobject <https://github.com/jonschlinkert/isobject>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+/** @license
+ * eventsource.js
+ * Available under MIT License (MIT)
+ * https://github.com/Yaffle/EventSource/
+ */