@elizaos/cli 1.4.3 → 1.4.5

package/dist/chunk-ABGBVB74.js

@@ -0,0 +1,3501 @@
+import {
+  packageVersion
+} from "./chunk-XFJIHUT3.js";
+
+// ../../node_modules/puppeteer-core/lib/esm/third_party/rxjs/rxjs.js
+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 (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1) throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return { value: op[1], done: false };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from2, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from2.length, ar; i < l; i++) {
+    if (ar || !(i in from2)) {
+      if (!ar) ar = Array.prototype.slice.call(from2, 0, i);
+      ar[i] = from2[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from2));
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function verb(n) {
+    if (g[n]) i[n] = function(v) {
+      return new Promise(function(a, b) {
+        q.push([n, v, a, b]) > 1 || resume(n, v);
+      });
+    };
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(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;
+  };
+});
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+var Subscription = (function() {
+  function Subscription2(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription2.prototype.unsubscribe = function() {
+    var e_1, _a, e_2, _b;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
+              }
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
+  };
+  Subscription2.prototype.add = function(teardown) {
+    var _a;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription2) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+      }
+    }
+  };
+  Subscription2.prototype._hasParent = function(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription2.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription2.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription2.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription2) {
+      teardown._removeParent(this);
+    }
+  };
+  Subscription2.EMPTY = (function() {
+    var empty = new Subscription2();
+    empty.closed = true;
+    return empty;
+  })();
+  return Subscription2;
+})();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+var config = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: false,
+  useDeprecatedNextContext: false
+};
+var timeoutProvider = {
+  setTimeout: function(handler, timeout2) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    var delegate = timeoutProvider.delegate;
+    if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+      return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout2], __read(args)));
+    }
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout2], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    var delegate = timeoutProvider.delegate;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+  },
+  delegate: void 0
+};
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    var onUnhandledError = config.onUnhandledError;
+    if (onUnhandledError) {
+      onUnhandledError(err);
+    } else {
+      throw err;
+    }
+  });
+}
+function noop() {
+}
+var COMPLETE_NOTIFICATION = (function() {
+  return createNotification("C", void 0, void 0);
+})();
+function errorNotification(error) {
+  return createNotification("E", void 0, error);
+}
+function nextNotification(value) {
+  return createNotification("N", value, void 0);
+}
+function createNotification(kind, value, error) {
+  return {
+    kind,
+    value,
+    error
+  };
+}
+var context = null;
+function errorContext(cb) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    var isRoot = !context;
+    if (isRoot) {
+      context = { errorThrown: false, error: null };
+    }
+    cb();
+    if (isRoot) {
+      var _a = context, errorThrown = _a.errorThrown, error = _a.error;
+      context = null;
+      if (errorThrown) {
+        throw error;
+      }
+    }
+  } else {
+    cb();
+  }
+}
+function captureError(err) {
+  if (config.useDeprecatedSynchronousErrorHandling && context) {
+    context.errorThrown = true;
+    context.error = err;
+  }
+}
+var Subscriber = (function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
+      }
+    } else {
+      _this.destination = EMPTY_OBSERVER;
+    }
+    return _this;
+  }
+  Subscriber2.create = function(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber2.prototype.next = function(value) {
+    if (this.isStopped) {
+      handleStoppedNotification(nextNotification(value), this);
+    } else {
+      this._next(value);
+    }
+  };
+  Subscriber2.prototype.error = function(err) {
+    if (this.isStopped) {
+      handleStoppedNotification(errorNotification(err), this);
+    } else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber2.prototype.complete = function() {
+    if (this.isStopped) {
+      handleStoppedNotification(COMPLETE_NOTIFICATION, this);
+    } else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber2.prototype._next = function(value) {
+    this.destination.next(value);
+  };
+  Subscriber2.prototype._error = function(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  return Subscriber2;
+})(Subscription);
+var _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+  return _bind.call(fn, thisArg);
+}
+var ConsumerObserver = (function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver2.prototype.next = function(value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver2;
+})();
+var SafeSubscriber = (function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+        error: error !== null && error !== void 0 ? error : void 0,
+        complete: complete !== null && complete !== void 0 ? complete : void 0
+      };
+    } else {
+      var context_1;
+      if (_this && config.useDeprecatedNextContext) {
+        context_1 = Object.create(observerOrNext);
+        context_1.unsubscribe = function() {
+          return _this.unsubscribe();
+        };
+        partialObserver = {
+          next: observerOrNext.next && bind(observerOrNext.next, context_1),
+          error: observerOrNext.error && bind(observerOrNext.error, context_1),
+          complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+        };
+      } else {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber2;
+})(Subscriber);
+function handleUnhandledError(error) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    captureError(error);
+  } else {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+function handleStoppedNotification(notification, subscriber) {
+  var onStoppedNotification = config.onStoppedNotification;
+  onStoppedNotification && timeoutProvider.setTimeout(function() {
+    return onStoppedNotification(notification, subscriber);
+  });
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+var observable = (function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+})();
+function identity(x) {
+  return x;
+}
+function pipe() {
+  var fns = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    fns[_i] = arguments[_i];
+  }
+  return pipeFromArray(fns);
+}
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function(prev, fn) {
+      return fn(prev);
+    }, input);
+  };
+}
+var Observable = (function() {
+  function Observable2(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable2.prototype.lift = function(operator) {
+    var observable2 = new Observable2();
+    observable2.source = this;
+    observable2.operator = operator;
+    return observable2;
+  };
+  Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function() {
+      var _a = _this, operator = _a.operator, source = _a.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+    });
+    return subscriber;
+  };
+  Observable2.prototype._trySubscribe = function(sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  };
+  Observable2.prototype.forEach = function(next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function(value) {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+      _this.subscribe(subscriber);
+    });
+  };
+  Observable2.prototype._subscribe = function(subscriber) {
+    var _a;
+    return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+  };
+  Observable2.prototype[observable] = function() {
+    return this;
+  };
+  Observable2.prototype.pipe = function() {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable2.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);
+      });
+    });
+  };
+  Observable2.create = function(subscribe) {
+    return new Observable2(subscribe);
+  };
+  return Observable2;
+})();
+function getPromiseCtor(promiseCtor) {
+  var _a;
+  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
+function hasLift(source) {
+  return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+  return function(source) {
+    if (hasLift(source)) {
+      return source.lift(function(liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    }
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = (function(_super) {
+  __extends(OperatorSubscriber2, _super);
+  function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    var _this = _super.call(this, destination) || this;
+    _this.onFinalize = onFinalize;
+    _this.shouldUnsubscribe = shouldUnsubscribe;
+    _this._next = onNext ? function(value) {
+      try {
+        onNext(value);
+      } catch (err) {
+        destination.error(err);
+      }
+    } : _super.prototype._next;
+    _this._error = onError ? function(err) {
+      try {
+        onError(err);
+      } catch (err2) {
+        destination.error(err2);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._error;
+    _this._complete = onComplete ? function() {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._complete;
+    return _this;
+  }
+  OperatorSubscriber2.prototype.unsubscribe = function() {
+    var _a;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var closed_1 = this.closed;
+      _super.prototype.unsubscribe.call(this);
+      !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+    }
+  };
+  return OperatorSubscriber2;
+})(Subscriber);
+var ObjectUnsubscribedError = createErrorClass(function(_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = "ObjectUnsubscribedError";
+    this.message = "object unsubscribed";
+  };
+});
+var Subject = (function(_super) {
+  __extends(Subject2, _super);
+  function Subject2() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject2.prototype.lift = function(operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject2.prototype._throwIfClosed = function() {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  };
+  Subject2.prototype.next = function(value) {
+    var _this = this;
+    errorContext(function() {
+      var e_1, _a;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
+        }
+        try {
+          for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var observer = _c.value;
+            observer.next(value);
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      }
+    });
+  };
+  Subject2.prototype.error = function(err) {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.hasError = _this.isStopped = true;
+        _this.thrownError = err;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().error(err);
+        }
+      }
+    });
+  };
+  Subject2.prototype.complete = function() {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.isStopped = true;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  };
+  Subject2.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  };
+  Object.defineProperty(Subject2.prototype, "observed", {
+    get: function() {
+      var _a;
+      return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Subject2.prototype._trySubscribe = function(subscriber) {
+    this._throwIfClosed();
+    return _super.prototype._trySubscribe.call(this, subscriber);
+  };
+  Subject2.prototype._subscribe = function(subscriber) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber);
+    return this._innerSubscribe(subscriber);
+  };
+  Subject2.prototype._innerSubscribe = function(subscriber) {
+    var _this = this;
+    var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+    if (hasError || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber);
+    return new Subscription(function() {
+      _this.currentObservers = null;
+      arrRemove(observers, subscriber);
+    });
+  };
+  Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+    var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
+    }
+  };
+  Subject2.prototype.asObservable = function() {
+    var observable2 = new Observable();
+    observable2.source = this;
+    return observable2;
+  };
+  Subject2.create = function(destination, source) {
+    return new AnonymousSubject(destination, source);
+  };
+  return Subject2;
+})(Observable);
+var AnonymousSubject = (function(_super) {
+  __extends(AnonymousSubject2, _super);
+  function AnonymousSubject2(destination, source) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination;
+    _this.source = source;
+    return _this;
+  }
+  AnonymousSubject2.prototype.next = function(value) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+  };
+  AnonymousSubject2.prototype.error = function(err) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+  };
+  AnonymousSubject2.prototype.complete = function() {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+  };
+  AnonymousSubject2.prototype._subscribe = function(subscriber) {
+    var _a, _b;
+    return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject2;
+})(Subject);
+var dateTimestampProvider = {
+  now: function() {
+    return (dateTimestampProvider.delegate || Date).now();
+  },
+  delegate: void 0
+};
+var ReplaySubject = (function(_super) {
+  __extends(ReplaySubject2, _super);
+  function ReplaySubject2(_bufferSize, _windowTime, _timestampProvider) {
+    if (_bufferSize === void 0) {
+      _bufferSize = Infinity;
+    }
+    if (_windowTime === void 0) {
+      _windowTime = Infinity;
+    }
+    if (_timestampProvider === void 0) {
+      _timestampProvider = dateTimestampProvider;
+    }
+    var _this = _super.call(this) || this;
+    _this._bufferSize = _bufferSize;
+    _this._windowTime = _windowTime;
+    _this._timestampProvider = _timestampProvider;
+    _this._buffer = [];
+    _this._infiniteTimeWindow = true;
+    _this._infiniteTimeWindow = _windowTime === Infinity;
+    _this._bufferSize = Math.max(1, _bufferSize);
+    _this._windowTime = Math.max(1, _windowTime);
+    return _this;
+  }
+  ReplaySubject2.prototype.next = function(value) {
+    var _a = this, isStopped = _a.isStopped, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow, _timestampProvider = _a._timestampProvider, _windowTime = _a._windowTime;
+    if (!isStopped) {
+      _buffer.push(value);
+      !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
+    }
+    this._trimBuffer();
+    _super.prototype.next.call(this, value);
+  };
+  ReplaySubject2.prototype._subscribe = function(subscriber) {
+    this._throwIfClosed();
+    this._trimBuffer();
+    var subscription = this._innerSubscribe(subscriber);
+    var _a = this, _infiniteTimeWindow = _a._infiniteTimeWindow, _buffer = _a._buffer;
+    var copy = _buffer.slice();
+    for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
+      subscriber.next(copy[i]);
+    }
+    this._checkFinalizedStatuses(subscriber);
+    return subscription;
+  };
+  ReplaySubject2.prototype._trimBuffer = function() {
+    var _a = this, _bufferSize = _a._bufferSize, _timestampProvider = _a._timestampProvider, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow;
+    var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
+    _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
+    if (!_infiniteTimeWindow) {
+      var now = _timestampProvider.now();
+      var last2 = 0;
+      for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
+        last2 = i;
+      }
+      last2 && _buffer.splice(0, last2 + 1);
+    }
+  };
+  return ReplaySubject2;
+})(Subject);
+var Action = (function(_super) {
+  __extends(Action2, _super);
+  function Action2(scheduler, work) {
+    return _super.call(this) || this;
+  }
+  Action2.prototype.schedule = function(state, delay2) {
+    if (delay2 === void 0) {
+      delay2 = 0;
+    }
+    return this;
+  };
+  return Action2;
+})(Subscription);
+var intervalProvider = {
+  setInterval: function(handler, timeout2) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    var delegate = intervalProvider.delegate;
+    if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
+      return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout2], __read(args)));
+    }
+    return setInterval.apply(void 0, __spreadArray([handler, timeout2], __read(args)));
+  },
+  clearInterval: function(handle) {
+    var delegate = intervalProvider.delegate;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
+  },
+  delegate: void 0
+};
+var AsyncAction = (function(_super) {
+  __extends(AsyncAction2, _super);
+  function AsyncAction2(scheduler, work) {
+    var _this = _super.call(this, scheduler, work) || this;
+    _this.scheduler = scheduler;
+    _this.work = work;
+    _this.pending = false;
+    return _this;
+  }
+  AsyncAction2.prototype.schedule = function(state, delay2) {
+    var _a;
+    if (delay2 === void 0) {
+      delay2 = 0;
+    }
+    if (this.closed) {
+      return this;
+    }
+    this.state = state;
+    var id = this.id;
+    var scheduler = this.scheduler;
+    if (id != null) {
+      this.id = this.recycleAsyncId(scheduler, id, delay2);
+    }
+    this.pending = true;
+    this.delay = delay2;
+    this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay2);
+    return this;
+  };
+  AsyncAction2.prototype.requestAsyncId = function(scheduler, _id, delay2) {
+    if (delay2 === void 0) {
+      delay2 = 0;
+    }
+    return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay2);
+  };
+  AsyncAction2.prototype.recycleAsyncId = function(_scheduler, id, delay2) {
+    if (delay2 === void 0) {
+      delay2 = 0;
+    }
+    if (delay2 != null && this.delay === delay2 && this.pending === false) {
+      return id;
+    }
+    if (id != null) {
+      intervalProvider.clearInterval(id);
+    }
+    return void 0;
+  };
+  AsyncAction2.prototype.execute = function(state, delay2) {
+    if (this.closed) {
+      return new Error("executing a cancelled action");
+    }
+    this.pending = false;
+    var error = this._execute(state, delay2);
+    if (error) {
+      return error;
+    } else if (this.pending === false && this.id != null) {
+      this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+    }
+  };
+  AsyncAction2.prototype._execute = function(state, _delay) {
+    var errored = false;
+    var errorValue;
+    try {
+      this.work(state);
+    } catch (e) {
+      errored = true;
+      errorValue = e ? e : new Error("Scheduled action threw falsy error");
+    }
+    if (errored) {
+      this.unsubscribe();
+      return errorValue;
+    }
+  };
+  AsyncAction2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      var _a = this, id = _a.id, scheduler = _a.scheduler;
+      var actions = scheduler.actions;
+      this.work = this.state = this.scheduler = null;
+      this.pending = false;
+      arrRemove(actions, this);
+      if (id != null) {
+        this.id = this.recycleAsyncId(scheduler, id, null);
+      }
+      this.delay = null;
+      _super.prototype.unsubscribe.call(this);
+    }
+  };
+  return AsyncAction2;
+})(Action);
+var Scheduler = (function() {
+  function Scheduler2(schedulerActionCtor, now) {
+    if (now === void 0) {
+      now = Scheduler2.now;
+    }
+    this.schedulerActionCtor = schedulerActionCtor;
+    this.now = now;
+  }
+  Scheduler2.prototype.schedule = function(work, delay2, state) {
+    if (delay2 === void 0) {
+      delay2 = 0;
+    }
+    return new this.schedulerActionCtor(this, work).schedule(state, delay2);
+  };
+  Scheduler2.now = dateTimestampProvider.now;
+  return Scheduler2;
+})();
+var AsyncScheduler = (function(_super) {
+  __extends(AsyncScheduler2, _super);
+  function AsyncScheduler2(SchedulerAction, now) {
+    if (now === void 0) {
+      now = Scheduler.now;
+    }
+    var _this = _super.call(this, SchedulerAction, now) || this;
+    _this.actions = [];
+    _this._active = false;
+    return _this;
+  }
+  AsyncScheduler2.prototype.flush = function(action) {
+    var actions = this.actions;
+    if (this._active) {
+      actions.push(action);
+      return;
+    }
+    var error;
+    this._active = true;
+    do {
+      if (error = action.execute(action.state, action.delay)) {
+        break;
+      }
+    } while (action = actions.shift());
+    this._active = false;
+    if (error) {
+      while (action = actions.shift()) {
+        action.unsubscribe();
+      }
+      throw error;
+    }
+  };
+  return AsyncScheduler2;
+})(Scheduler);
+var asyncScheduler = new AsyncScheduler(AsyncAction);
+var async = asyncScheduler;
+var EMPTY = new Observable(function(subscriber) {
+  return subscriber.complete();
+});
+function isScheduler(value) {
+  return value && isFunction(value.schedule);
+}
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function popResultSelector(args) {
+  return isFunction(last(args)) ? args.pop() : void 0;
+}
+function popScheduler(args) {
+  return isScheduler(last(args)) ? args.pop() : void 0;
+}
+function popNumber(args, defaultValue) {
+  return typeof last(args) === "number" ? args.pop() : defaultValue;
+}
+var isArrayLike = function(x) {
+  return x && typeof x.length === "number" && typeof x !== "function";
+};
+function isPromise(value) {
+  return isFunction(value === null || value === void 0 ? void 0 : value.then);
+}
+function isInteropObservable(input) {
+  return isFunction(input[observable]);
+}
+function isAsyncIterable(obj) {
+  return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+}
+function createInvalidObservableTypeError(input) {
+  return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function getSymbolIterator() {
+  if (typeof Symbol !== "function" || !Symbol.iterator) {
+    return "@@iterator";
+  }
+  return Symbol.iterator;
+}
+var iterator = getSymbolIterator();
+function isIterable(input) {
+  return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+}
+function readableStreamLikeToAsyncGenerator(readableStream) {
+  return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+    var reader, _a, value, done;
+    return __generator(this, function(_b) {
+      switch (_b.label) {
+        case 0:
+          reader = readableStream.getReader();
+          _b.label = 1;
+        case 1:
+          _b.trys.push([1, , 9, 10]);
+          _b.label = 2;
+        case 2:
+          if (false) return [3, 8];
+          return [4, __await(reader.read())];
+        case 3:
+          _a = _b.sent(), value = _a.value, done = _a.done;
+          if (!done) return [3, 5];
+          return [4, __await(void 0)];
+        case 4:
+          return [2, _b.sent()];
+        case 5:
+          return [4, __await(value)];
+        case 6:
+          return [4, _b.sent()];
+        case 7:
+          _b.sent();
+          return [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          reader.releaseLock();
+          return [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function isReadableStreamLike(obj) {
+  return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+}
+function innerFrom(input) {
+  if (input instanceof Observable) {
+    return input;
+  }
+  if (input != null) {
+    if (isInteropObservable(input)) {
+      return fromInteropObservable(input);
+    }
+    if (isArrayLike(input)) {
+      return fromArrayLike(input);
+    }
+    if (isPromise(input)) {
+      return fromPromise(input);
+    }
+    if (isAsyncIterable(input)) {
+      return fromAsyncIterable(input);
+    }
+    if (isIterable(input)) {
+      return fromIterable(input);
+    }
+    if (isReadableStreamLike(input)) {
+      return fromReadableStreamLike(input);
+    }
+  }
+  throw createInvalidObservableTypeError(input);
+}
+function fromInteropObservable(obj) {
+  return new Observable(function(subscriber) {
+    var obs = obj[observable]();
+    if (isFunction(obs.subscribe)) {
+      return obs.subscribe(subscriber);
+    }
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function fromArrayLike(array) {
+  return new Observable(function(subscriber) {
+    for (var i = 0; i < array.length && !subscriber.closed; i++) {
+      subscriber.next(array[i]);
+    }
+    subscriber.complete();
+  });
+}
+function fromPromise(promise) {
+  return new Observable(function(subscriber) {
+    promise.then(function(value) {
+      if (!subscriber.closed) {
+        subscriber.next(value);
+        subscriber.complete();
+      }
+    }, function(err) {
+      return subscriber.error(err);
+    }).then(null, reportUnhandledError);
+  });
+}
+function fromIterable(iterable) {
+  return new Observable(function(subscriber) {
+    var e_1, _a;
+    try {
+      for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+        var value = iterable_1_1.value;
+        subscriber.next(value);
+        if (subscriber.closed) {
+          return;
+        }
+      }
+    } catch (e_1_1) {
+      e_1 = { error: e_1_1 };
+    } finally {
+      try {
+        if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+      } finally {
+        if (e_1) throw e_1.error;
+      }
+    }
+    subscriber.complete();
+  });
+}
+function fromAsyncIterable(asyncIterable) {
+  return new Observable(function(subscriber) {
+    process2(asyncIterable, subscriber).catch(function(err) {
+      return subscriber.error(err);
+    });
+  });
+}
+function fromReadableStreamLike(readableStream) {
+  return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+}
+function process2(asyncIterable, subscriber) {
+  var asyncIterable_1, asyncIterable_1_1;
+  var e_2, _a;
+  return __awaiter(this, void 0, void 0, function() {
+    var value, e_2_1;
+    return __generator(this, function(_b) {
+      switch (_b.label) {
+        case 0:
+          _b.trys.push([0, 5, 6, 11]);
+          asyncIterable_1 = __asyncValues(asyncIterable);
+          _b.label = 1;
+        case 1:
+          return [4, asyncIterable_1.next()];
+        case 2:
+          if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+          value = asyncIterable_1_1.value;
+          subscriber.next(value);
+          if (subscriber.closed) {
+            return [2];
+          }
+          _b.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          e_2_1 = _b.sent();
+          e_2 = { error: e_2_1 };
+          return [3, 11];
+        case 6:
+          _b.trys.push([6, , 9, 10]);
+          if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+          return [4, _a.call(asyncIterable_1)];
+        case 7:
+          _b.sent();
+          _b.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (e_2) throw e_2.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          subscriber.complete();
+          return [2];
+      }
+    });
+  });
+}
+function executeSchedule(parentSubscription, scheduler, work, delay2, repeat) {
+  if (delay2 === void 0) {
+    delay2 = 0;
+  }
+  if (repeat === void 0) {
+    repeat = false;
+  }
+  var scheduleSubscription = scheduler.schedule(function() {
+    work();
+    if (repeat) {
+      parentSubscription.add(this.schedule(null, delay2));
+    } else {
+      this.unsubscribe();
+    }
+  }, delay2);
+  parentSubscription.add(scheduleSubscription);
+  if (!repeat) {
+    return scheduleSubscription;
+  }
+}
+function observeOn(scheduler, delay2) {
+  if (delay2 === void 0) {
+    delay2 = 0;
+  }
+  return operate(function(source, subscriber) {
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      return executeSchedule(subscriber, scheduler, function() {
+        return subscriber.next(value);
+      }, delay2);
+    }, function() {
+      return executeSchedule(subscriber, scheduler, function() {
+        return subscriber.complete();
+      }, delay2);
+    }, function(err) {
+      return executeSchedule(subscriber, scheduler, function() {
+        return subscriber.error(err);
+      }, delay2);
+    }));
+  });
+}
+function subscribeOn(scheduler, delay2) {
+  if (delay2 === void 0) {
+    delay2 = 0;
+  }
+  return operate(function(source, subscriber) {
+    subscriber.add(scheduler.schedule(function() {
+      return source.subscribe(subscriber);
+    }, delay2));
+  });
+}
+function scheduleObservable(input, scheduler) {
+  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+function schedulePromise(input, scheduler) {
+  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+function scheduleArray(input, scheduler) {
+  return new Observable(function(subscriber) {
+    var i = 0;
+    return scheduler.schedule(function() {
+      if (i === input.length) {
+        subscriber.complete();
+      } else {
+        subscriber.next(input[i++]);
+        if (!subscriber.closed) {
+          this.schedule();
+        }
+      }
+    });
+  });
+}
+function scheduleIterable(input, scheduler) {
+  return new Observable(function(subscriber) {
+    var iterator2;
+    executeSchedule(subscriber, scheduler, function() {
+      iterator2 = input[iterator]();
+      executeSchedule(subscriber, scheduler, function() {
+        var _a;
+        var value;
+        var done;
+        try {
+          _a = iterator2.next(), value = _a.value, done = _a.done;
+        } catch (err) {
+          subscriber.error(err);
+          return;
+        }
+        if (done) {
+          subscriber.complete();
+        } else {
+          subscriber.next(value);
+        }
+      }, 0, true);
+    });
+    return function() {
+      return isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
+    };
+  });
+}
+function scheduleAsyncIterable(input, scheduler) {
+  if (!input) {
+    throw new Error("Iterable cannot be null");
+  }
+  return new Observable(function(subscriber) {
+    executeSchedule(subscriber, scheduler, function() {
+      var iterator2 = input[Symbol.asyncIterator]();
+      executeSchedule(subscriber, scheduler, function() {
+        iterator2.next().then(function(result) {
+          if (result.done) {
+            subscriber.complete();
+          } else {
+            subscriber.next(result.value);
+          }
+        });
+      }, 0, true);
+    });
+  });
+}
+function scheduleReadableStreamLike(input, scheduler) {
+  return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+}
+function scheduled(input, scheduler) {
+  if (input != null) {
+    if (isInteropObservable(input)) {
+      return scheduleObservable(input, scheduler);
+    }
+    if (isArrayLike(input)) {
+      return scheduleArray(input, scheduler);
+    }
+    if (isPromise(input)) {
+      return schedulePromise(input, scheduler);
+    }
+    if (isAsyncIterable(input)) {
+      return scheduleAsyncIterable(input, scheduler);
+    }
+    if (isIterable(input)) {
+      return scheduleIterable(input, scheduler);
+    }
+    if (isReadableStreamLike(input)) {
+      return scheduleReadableStreamLike(input, scheduler);
+    }
+  }
+  throw createInvalidObservableTypeError(input);
+}
+function from(input, scheduler) {
+  return scheduler ? scheduled(input, scheduler) : innerFrom(input);
+}
+function of() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  var scheduler = popScheduler(args);
+  return from(args, scheduler);
+}
+var EmptyError = createErrorClass(function(_super) {
+  return function EmptyErrorImpl() {
+    _super(this);
+    this.name = "EmptyError";
+    this.message = "no elements in sequence";
+  };
+});
+function lastValueFrom(source, config2) {
+  var hasConfig = typeof config2 === "object";
+  return new Promise(function(resolve, reject) {
+    var _hasValue = false;
+    var _value;
+    source.subscribe({
+      next: function(value) {
+        _value = value;
+        _hasValue = true;
+      },
+      error: reject,
+      complete: function() {
+        if (_hasValue) {
+          resolve(_value);
+        } else if (hasConfig) {
+          resolve(config2.defaultValue);
+        } else {
+          reject(new EmptyError());
+        }
+      }
+    });
+  });
+}
+function firstValueFrom(source, config2) {
+  var hasConfig = typeof config2 === "object";
+  return new Promise(function(resolve, reject) {
+    var subscriber = new SafeSubscriber({
+      next: function(value) {
+        resolve(value);
+        subscriber.unsubscribe();
+      },
+      error: reject,
+      complete: function() {
+        if (hasConfig) {
+          resolve(config2.defaultValue);
+        } else {
+          reject(new EmptyError());
+        }
+      }
+    });
+    source.subscribe(subscriber);
+  });
+}
+function isValidDate(value) {
+  return value instanceof Date && !isNaN(value);
+}
+function map(project, thisArg) {
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      subscriber.next(project.call(thisArg, value, index++));
+    }));
+  });
+}
+var isArray = Array.isArray;
+function callOrApply(fn, args) {
+  return isArray(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
+}
+function mapOneOrManyArgs(fn) {
+  return map(function(args) {
+    return callOrApply(fn, args);
+  });
+}
+var isArray2 = Array.isArray;
+var getPrototypeOf = Object.getPrototypeOf;
+var objectProto = Object.prototype;
+var getKeys = Object.keys;
+function argsArgArrayOrObject(args) {
+  if (args.length === 1) {
+    var first_1 = args[0];
+    if (isArray2(first_1)) {
+      return { args: first_1, keys: null };
+    }
+    if (isPOJO(first_1)) {
+      var keys = getKeys(first_1);
+      return {
+        args: keys.map(function(key) {
+          return first_1[key];
+        }),
+        keys
+      };
+    }
+  }
+  return { args, keys: null };
+}
+function isPOJO(obj) {
+  return obj && typeof obj === "object" && getPrototypeOf(obj) === objectProto;
+}
+function createObject(keys, values) {
+  return keys.reduce(function(result, key, i) {
+    return result[key] = values[i], result;
+  }, {});
+}
+function combineLatest() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  var scheduler = popScheduler(args);
+  var resultSelector = popResultSelector(args);
+  var _a = argsArgArrayOrObject(args), observables = _a.args, keys = _a.keys;
+  if (observables.length === 0) {
+    return from([], scheduler);
+  }
+  var result = new Observable(combineLatestInit(observables, scheduler, keys ? function(values) {
+    return createObject(keys, values);
+  } : identity));
+  return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+}
+function combineLatestInit(observables, scheduler, valueTransform) {
+  if (valueTransform === void 0) {
+    valueTransform = identity;
+  }
+  return function(subscriber) {
+    maybeSchedule(scheduler, function() {
+      var length = observables.length;
+      var values = new Array(length);
+      var active = length;
+      var remainingFirstValues = length;
+      var _loop_1 = function(i2) {
+        maybeSchedule(scheduler, function() {
+          var source = from(observables[i2], scheduler);
+          var hasFirstValue = false;
+          source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+            values[i2] = value;
+            if (!hasFirstValue) {
+              hasFirstValue = true;
+              remainingFirstValues--;
+            }
+            if (!remainingFirstValues) {
+              subscriber.next(valueTransform(values.slice()));
+            }
+          }, function() {
+            if (!--active) {
+              subscriber.complete();
+            }
+          }));
+        }, subscriber);
+      };
+      for (var i = 0; i < length; i++) {
+        _loop_1(i);
+      }
+    }, subscriber);
+  };
+}
+function maybeSchedule(scheduler, execute, subscription) {
+  if (scheduler) {
+    executeSchedule(subscription, scheduler, execute);
+  } else {
+    execute();
+  }
+}
+function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+  var buffer = [];
+  var active = 0;
+  var index = 0;
+  var isComplete = false;
+  var checkComplete = function() {
+    if (isComplete && !buffer.length && !active) {
+      subscriber.complete();
+    }
+  };
+  var outerNext = function(value) {
+    return active < concurrent ? doInnerSub(value) : buffer.push(value);
+  };
+  var doInnerSub = function(value) {
+    expand && subscriber.next(value);
+    active++;
+    var innerComplete = false;
+    innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function(innerValue) {
+      onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
+      if (expand) {
+        outerNext(innerValue);
+      } else {
+        subscriber.next(innerValue);
+      }
+    }, function() {
+      innerComplete = true;
+    }, void 0, function() {
+      if (innerComplete) {
+        try {
+          active--;
+          var _loop_1 = function() {
+            var bufferedValue = buffer.shift();
+            if (innerSubScheduler) {
+              executeSchedule(subscriber, innerSubScheduler, function() {
+                return doInnerSub(bufferedValue);
+              });
+            } else {
+              doInnerSub(bufferedValue);
+            }
+          };
+          while (buffer.length && active < concurrent) {
+            _loop_1();
+          }
+          checkComplete();
+        } catch (err) {
+          subscriber.error(err);
+        }
+      }
+    }));
+  };
+  source.subscribe(createOperatorSubscriber(subscriber, outerNext, function() {
+    isComplete = true;
+    checkComplete();
+  }));
+  return function() {
+    additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
+  };
+}
+function mergeMap(project, resultSelector, concurrent) {
+  if (concurrent === void 0) {
+    concurrent = Infinity;
+  }
+  if (isFunction(resultSelector)) {
+    return mergeMap(function(a, i) {
+      return map(function(b, ii) {
+        return resultSelector(a, b, i, ii);
+      })(innerFrom(project(a, i)));
+    }, concurrent);
+  } else if (typeof resultSelector === "number") {
+    concurrent = resultSelector;
+  }
+  return operate(function(source, subscriber) {
+    return mergeInternals(source, subscriber, project, concurrent);
+  });
+}
+function mergeAll(concurrent) {
+  if (concurrent === void 0) {
+    concurrent = Infinity;
+  }
+  return mergeMap(identity, concurrent);
+}
+function concatAll() {
+  return mergeAll(1);
+}
+function concat() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  return concatAll()(from(args, popScheduler(args)));
+}
+function defer(observableFactory) {
+  return new Observable(function(subscriber) {
+    innerFrom(observableFactory()).subscribe(subscriber);
+  });
+}
+var nodeEventEmitterMethods = ["addListener", "removeListener"];
+var eventTargetMethods = ["addEventListener", "removeEventListener"];
+var jqueryMethods = ["on", "off"];
+function fromEvent(target, eventName, options, resultSelector) {
+  if (isFunction(options)) {
+    resultSelector = options;
+    options = void 0;
+  }
+  if (resultSelector) {
+    return fromEvent(target, eventName, options).pipe(mapOneOrManyArgs(resultSelector));
+  }
+  var _a = __read(isEventTarget(target) ? eventTargetMethods.map(function(methodName) {
+    return function(handler) {
+      return target[methodName](eventName, handler, options);
+    };
+  }) : isNodeStyleEventEmitter(target) ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName)) : isJQueryStyleEventEmitter(target) ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName)) : [], 2), add = _a[0], remove = _a[1];
+  if (!add) {
+    if (isArrayLike(target)) {
+      return mergeMap(function(subTarget) {
+        return fromEvent(subTarget, eventName, options);
+      })(innerFrom(target));
+    }
+  }
+  if (!add) {
+    throw new TypeError("Invalid event target");
+  }
+  return new Observable(function(subscriber) {
+    var handler = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return subscriber.next(1 < args.length ? args : args[0]);
+    };
+    add(handler);
+    return function() {
+      return remove(handler);
+    };
+  });
+}
+function toCommonHandlerRegistry(target, eventName) {
+  return function(methodName) {
+    return function(handler) {
+      return target[methodName](eventName, handler);
+    };
+  };
+}
+function isNodeStyleEventEmitter(target) {
+  return isFunction(target.addListener) && isFunction(target.removeListener);
+}
+function isJQueryStyleEventEmitter(target) {
+  return isFunction(target.on) && isFunction(target.off);
+}
+function isEventTarget(target) {
+  return isFunction(target.addEventListener) && isFunction(target.removeEventListener);
+}
+function timer(dueTime, intervalOrScheduler, scheduler) {
+  if (dueTime === void 0) {
+    dueTime = 0;
+  }
+  if (scheduler === void 0) {
+    scheduler = async;
+  }
+  var intervalDuration = -1;
+  if (intervalOrScheduler != null) {
+    if (isScheduler(intervalOrScheduler)) {
+      scheduler = intervalOrScheduler;
+    } else {
+      intervalDuration = intervalOrScheduler;
+    }
+  }
+  return new Observable(function(subscriber) {
+    var due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
+    if (due < 0) {
+      due = 0;
+    }
+    var n = 0;
+    return scheduler.schedule(function() {
+      if (!subscriber.closed) {
+        subscriber.next(n++);
+        if (0 <= intervalDuration) {
+          this.schedule(void 0, intervalDuration);
+        } else {
+          subscriber.complete();
+        }
+      }
+    }, due);
+  });
+}
+function merge() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  var scheduler = popScheduler(args);
+  var concurrent = popNumber(args, Infinity);
+  var sources = args;
+  return !sources.length ? EMPTY : sources.length === 1 ? innerFrom(sources[0]) : mergeAll(concurrent)(from(sources, scheduler));
+}
+var NEVER = new Observable(noop);
+var isArray3 = Array.isArray;
+function argsOrArgArray(args) {
+  return args.length === 1 && isArray3(args[0]) ? args[0] : args;
+}
+function filter(predicate, thisArg) {
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      return predicate.call(thisArg, value, index++) && subscriber.next(value);
+    }));
+  });
+}
+function race() {
+  var sources = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    sources[_i] = arguments[_i];
+  }
+  sources = argsOrArgArray(sources);
+  return sources.length === 1 ? innerFrom(sources[0]) : new Observable(raceInit(sources));
+}
+function raceInit(sources) {
+  return function(subscriber) {
+    var subscriptions = [];
+    var _loop_1 = function(i2) {
+      subscriptions.push(innerFrom(sources[i2]).subscribe(createOperatorSubscriber(subscriber, function(value) {
+        if (subscriptions) {
+          for (var s = 0; s < subscriptions.length; s++) {
+            s !== i2 && subscriptions[s].unsubscribe();
+          }
+          subscriptions = null;
+        }
+        subscriber.next(value);
+      })));
+    };
+    for (var i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) {
+      _loop_1(i);
+    }
+  };
+}
+function bufferCount(bufferSize, startBufferEvery) {
+  if (startBufferEvery === void 0) {
+    startBufferEvery = null;
+  }
+  startBufferEvery = startBufferEvery !== null && startBufferEvery !== void 0 ? startBufferEvery : bufferSize;
+  return operate(function(source, subscriber) {
+    var buffers = [];
+    var count = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      var e_1, _a, e_2, _b;
+      var toEmit = null;
+      if (count++ % startBufferEvery === 0) {
+        buffers.push([]);
+      }
+      try {
+        for (var buffers_1 = __values(buffers), buffers_1_1 = buffers_1.next(); !buffers_1_1.done; buffers_1_1 = buffers_1.next()) {
+          var buffer = buffers_1_1.value;
+          buffer.push(value);
+          if (bufferSize <= buffer.length) {
+            toEmit = toEmit !== null && toEmit !== void 0 ? toEmit : [];
+            toEmit.push(buffer);
+          }
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (buffers_1_1 && !buffers_1_1.done && (_a = buffers_1.return)) _a.call(buffers_1);
+        } finally {
+          if (e_1) throw e_1.error;
+        }
+      }
+      if (toEmit) {
+        try {
+          for (var toEmit_1 = __values(toEmit), toEmit_1_1 = toEmit_1.next(); !toEmit_1_1.done; toEmit_1_1 = toEmit_1.next()) {
+            var buffer = toEmit_1_1.value;
+            arrRemove(buffers, buffer);
+            subscriber.next(buffer);
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (toEmit_1_1 && !toEmit_1_1.done && (_b = toEmit_1.return)) _b.call(toEmit_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+    }, function() {
+      var e_3, _a;
+      try {
+        for (var buffers_2 = __values(buffers), buffers_2_1 = buffers_2.next(); !buffers_2_1.done; buffers_2_1 = buffers_2.next()) {
+          var buffer = buffers_2_1.value;
+          subscriber.next(buffer);
+        }
+      } catch (e_3_1) {
+        e_3 = { error: e_3_1 };
+      } finally {
+        try {
+          if (buffers_2_1 && !buffers_2_1.done && (_a = buffers_2.return)) _a.call(buffers_2);
+        } finally {
+          if (e_3) throw e_3.error;
+        }
+      }
+      subscriber.complete();
+    }, void 0, function() {
+      buffers = null;
+    }));
+  });
+}
+function catchError(selector) {
+  return operate(function(source, subscriber) {
+    var innerSub = null;
+    var syncUnsub = false;
+    var handledResult;
+    innerSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, void 0, function(err) {
+      handledResult = innerFrom(selector(err, catchError(selector)(source)));
+      if (innerSub) {
+        innerSub.unsubscribe();
+        innerSub = null;
+        handledResult.subscribe(subscriber);
+      } else {
+        syncUnsub = true;
+      }
+    }));
+    if (syncUnsub) {
+      innerSub.unsubscribe();
+      innerSub = null;
+      handledResult.subscribe(subscriber);
+    }
+  });
+}
+function concatMap(project, resultSelector) {
+  return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
+}
+function defaultIfEmpty(defaultValue) {
+  return operate(function(source, subscriber) {
+    var hasValue = false;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      hasValue = true;
+      subscriber.next(value);
+    }, function() {
+      if (!hasValue) {
+        subscriber.next(defaultValue);
+      }
+      subscriber.complete();
+    }));
+  });
+}
+function take(count) {
+  return count <= 0 ? function() {
+    return EMPTY;
+  } : operate(function(source, subscriber) {
+    var seen = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      if (++seen <= count) {
+        subscriber.next(value);
+        if (count <= seen) {
+          subscriber.complete();
+        }
+      }
+    }));
+  });
+}
+function ignoreElements() {
+  return operate(function(source, subscriber) {
+    source.subscribe(createOperatorSubscriber(subscriber, noop));
+  });
+}
+function mapTo(value) {
+  return map(function() {
+    return value;
+  });
+}
+function delayWhen(delayDurationSelector, subscriptionDelay) {
+  if (subscriptionDelay) {
+    return function(source) {
+      return concat(subscriptionDelay.pipe(take(1), ignoreElements()), source.pipe(delayWhen(delayDurationSelector)));
+    };
+  }
+  return mergeMap(function(value, index) {
+    return innerFrom(delayDurationSelector(value, index)).pipe(take(1), mapTo(value));
+  });
+}
+function throwIfEmpty(errorFactory) {
+  if (errorFactory === void 0) {
+    errorFactory = defaultErrorFactory;
+  }
+  return operate(function(source, subscriber) {
+    var hasValue = false;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      hasValue = true;
+      subscriber.next(value);
+    }, function() {
+      return hasValue ? subscriber.complete() : subscriber.error(errorFactory());
+    }));
+  });
+}
+function defaultErrorFactory() {
+  return new EmptyError();
+}
+function first(predicate, defaultValue) {
+  var hasDefaultValue = arguments.length >= 2;
+  return function(source) {
+    return source.pipe(predicate ? filter(function(v, i) {
+      return predicate(v, i, source);
+    }) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function() {
+      return new EmptyError();
+    }));
+  };
+}
+function mergeScan(accumulator, seed, concurrent) {
+  if (concurrent === void 0) {
+    concurrent = Infinity;
+  }
+  return operate(function(source, subscriber) {
+    var state = seed;
+    return mergeInternals(source, subscriber, function(value, index) {
+      return accumulator(state, value, index);
+    }, concurrent, function(value) {
+      state = value;
+    }, false, void 0, function() {
+      return state = null;
+    });
+  });
+}
+function raceWith() {
+  var otherSources = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    otherSources[_i] = arguments[_i];
+  }
+  return !otherSources.length ? identity : operate(function(source, subscriber) {
+    raceInit(__spreadArray([source], __read(otherSources)))(subscriber);
+  });
+}
+function retry(configOrCount) {
+  if (configOrCount === void 0) {
+    configOrCount = Infinity;
+  }
+  var config2;
+  if (configOrCount && typeof configOrCount === "object") {
+    config2 = configOrCount;
+  } else {
+    config2 = {
+      count: configOrCount
+    };
+  }
+  var _a = config2.count, count = _a === void 0 ? Infinity : _a, delay2 = config2.delay, _b = config2.resetOnSuccess, resetOnSuccess = _b === void 0 ? false : _b;
+  return count <= 0 ? identity : operate(function(source, subscriber) {
+    var soFar = 0;
+    var innerSub;
+    var subscribeForRetry = function() {
+      var syncUnsub = false;
+      innerSub = source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+        if (resetOnSuccess) {
+          soFar = 0;
+        }
+        subscriber.next(value);
+      }, void 0, function(err) {
+        if (soFar++ < count) {
+          var resub_1 = function() {
+            if (innerSub) {
+              innerSub.unsubscribe();
+              innerSub = null;
+              subscribeForRetry();
+            } else {
+              syncUnsub = true;
+            }
+          };
+          if (delay2 != null) {
+            var notifier = typeof delay2 === "number" ? timer(delay2) : innerFrom(delay2(err, soFar));
+            var notifierSubscriber_1 = createOperatorSubscriber(subscriber, function() {
+              notifierSubscriber_1.unsubscribe();
+              resub_1();
+            }, function() {
+              subscriber.complete();
+            });
+            notifier.subscribe(notifierSubscriber_1);
+          } else {
+            resub_1();
+          }
+        } else {
+          subscriber.error(err);
+        }
+      }));
+      if (syncUnsub) {
+        innerSub.unsubscribe();
+        innerSub = null;
+        subscribeForRetry();
+      }
+    };
+    subscribeForRetry();
+  });
+}
+function startWith() {
+  var values = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    values[_i] = arguments[_i];
+  }
+  var scheduler = popScheduler(values);
+  return operate(function(source, subscriber) {
+    (scheduler ? concat(values, source, scheduler) : concat(values, source)).subscribe(subscriber);
+  });
+}
+function switchMap(project, resultSelector) {
+  return operate(function(source, subscriber) {
+    var innerSubscriber = null;
+    var index = 0;
+    var isComplete = false;
+    var checkComplete = function() {
+      return isComplete && !innerSubscriber && subscriber.complete();
+    };
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
+      var innerIndex = 0;
+      var outerIndex = index++;
+      innerFrom(project(value, outerIndex)).subscribe(innerSubscriber = createOperatorSubscriber(subscriber, function(innerValue) {
+        return subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue);
+      }, function() {
+        innerSubscriber = null;
+        checkComplete();
+      }));
+    }, function() {
+      isComplete = true;
+      checkComplete();
+    }));
+  });
+}
+function takeUntil(notifier) {
+  return operate(function(source, subscriber) {
+    innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, function() {
+      return subscriber.complete();
+    }, noop));
+    !subscriber.closed && source.subscribe(subscriber);
+  });
+}
+function tap(observerOrNext, error, complete) {
+  var tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext;
+  return tapObserver ? operate(function(source, subscriber) {
+    var _a;
+    (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+    var isUnsub = true;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      var _a2;
+      (_a2 = tapObserver.next) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, value);
+      subscriber.next(value);
+    }, function() {
+      var _a2;
+      isUnsub = false;
+      (_a2 = tapObserver.complete) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
+      subscriber.complete();
+    }, function(err) {
+      var _a2;
+      isUnsub = false;
+      (_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err);
+      subscriber.error(err);
+    }, function() {
+      var _a2, _b;
+      if (isUnsub) {
+        (_a2 = tapObserver.unsubscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
+      }
+      (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+    }));
+  }) : identity;
+}
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/util/disposable.js
+Symbol.dispose ??= Symbol("dispose");
+Symbol.asyncDispose ??= Symbol("asyncDispose");
+var disposeSymbol = Symbol.dispose;
+var asyncDisposeSymbol = Symbol.asyncDispose;
+var DisposableStack = class _DisposableStack {
+  #disposed = false;
+  #stack = [];
+  /**
+   * Returns a value indicating whether this stack has been disposed.
+   */
+  get disposed() {
+    return this.#disposed;
+  }
+  /**
+   * Disposes each resource in the stack in the reverse order that they were added.
+   */
+  dispose() {
+    if (this.#disposed) {
+      return;
+    }
+    this.#disposed = true;
+    for (const resource of this.#stack.reverse()) {
+      resource[disposeSymbol]();
+    }
+  }
+  /**
+   * Adds a disposable resource to the stack, returning the resource.
+   *
+   * @param value - The resource to add. `null` and `undefined` will not be added,
+   * but will be returned.
+   * @returns The provided `value`.
+   */
+  use(value) {
+    if (value) {
+      this.#stack.push(value);
+    }
+    return value;
+  }
+  /**
+   * Adds a value and associated disposal callback as a resource to the stack.
+   *
+   * @param value - The value to add.
+   * @param onDispose - The callback to use in place of a `[disposeSymbol]()`
+   * method. Will be invoked with `value` as the first parameter.
+   * @returns The provided `value`.
+   */
+  adopt(value, onDispose) {
+    this.#stack.push({
+      [disposeSymbol]() {
+        onDispose(value);
+      }
+    });
+    return value;
+  }
+  /**
+   * Adds a callback to be invoked when the stack is disposed.
+   */
+  defer(onDispose) {
+    this.#stack.push({
+      [disposeSymbol]() {
+        onDispose();
+      }
+    });
+  }
+  /**
+   * Move all resources out of this stack and into a new `DisposableStack`, and
+   * marks this stack as disposed.
+   *
+   * @example
+   *
+   * ```ts
+   * class C {
+   *   #res1: Disposable;
+   *   #res2: Disposable;
+   *   #disposables: DisposableStack;
+   *   constructor() {
+   *     // stack will be disposed when exiting constructor for any reason
+   *     using stack = new DisposableStack();
+   *
+   *     // get first resource
+   *     this.#res1 = stack.use(getResource1());
+   *
+   *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
+   *     this.#res2 = stack.use(getResource2());
+   *
+   *     // all operations succeeded, move resources out of `stack` so that
+   *     // they aren't disposed when constructor exits
+   *     this.#disposables = stack.move();
+   *   }
+   *
+   *   [disposeSymbol]() {
+   *     this.#disposables.dispose();
+   *   }
+   * }
+   * ```
+   */
+  move() {
+    if (this.#disposed) {
+      throw new ReferenceError("a disposed stack can not use anything new");
+    }
+    const stack = new _DisposableStack();
+    stack.#stack = this.#stack;
+    this.#disposed = true;
+    return stack;
+  }
+  [disposeSymbol] = this.dispose;
+  [Symbol.toStringTag] = "DisposableStack";
+};
+var AsyncDisposableStack = class _AsyncDisposableStack {
+  #disposed = false;
+  #stack = [];
+  /**
+   * Returns a value indicating whether this stack has been disposed.
+   */
+  get disposed() {
+    return this.#disposed;
+  }
+  /**
+   * Disposes each resource in the stack in the reverse order that they were added.
+   */
+  async dispose() {
+    if (this.#disposed) {
+      return;
+    }
+    this.#disposed = true;
+    for (const resource of this.#stack.reverse()) {
+      await resource[asyncDisposeSymbol]();
+    }
+  }
+  /**
+   * Adds a disposable resource to the stack, returning the resource.
+   *
+   * @param value - The resource to add. `null` and `undefined` will not be added,
+   * but will be returned.
+   * @returns The provided `value`.
+   */
+  use(value) {
+    if (value) {
+      this.#stack.push(value);
+    }
+    return value;
+  }
+  /**
+   * Adds a value and associated disposal callback as a resource to the stack.
+   *
+   * @param value - The value to add.
+   * @param onDispose - The callback to use in place of a `[disposeSymbol]()`
+   * method. Will be invoked with `value` as the first parameter.
+   * @returns The provided `value`.
+   */
+  adopt(value, onDispose) {
+    this.#stack.push({
+      [asyncDisposeSymbol]() {
+        return onDispose(value);
+      }
+    });
+    return value;
+  }
+  /**
+   * Adds a callback to be invoked when the stack is disposed.
+   */
+  defer(onDispose) {
+    this.#stack.push({
+      [asyncDisposeSymbol]() {
+        return onDispose();
+      }
+    });
+  }
+  /**
+   * Move all resources out of this stack and into a new `DisposableStack`, and
+   * marks this stack as disposed.
+   *
+   * @example
+   *
+   * ```ts
+   * class C {
+   *   #res1: Disposable;
+   *   #res2: Disposable;
+   *   #disposables: DisposableStack;
+   *   constructor() {
+   *     // stack will be disposed when exiting constructor for any reason
+   *     using stack = new DisposableStack();
+   *
+   *     // get first resource
+   *     this.#res1 = stack.use(getResource1());
+   *
+   *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
+   *     this.#res2 = stack.use(getResource2());
+   *
+   *     // all operations succeeded, move resources out of `stack` so that
+   *     // they aren't disposed when constructor exits
+   *     this.#disposables = stack.move();
+   *   }
+   *
+   *   [disposeSymbol]() {
+   *     this.#disposables.dispose();
+   *   }
+   * }
+   * ```
+   */
+  move() {
+    if (this.#disposed) {
+      throw new ReferenceError("a disposed stack can not use anything new");
+    }
+    const stack = new _AsyncDisposableStack();
+    stack.#stack = this.#stack;
+    this.#disposed = true;
+    return stack;
+  }
+  [asyncDisposeSymbol] = this.dispose;
+  [Symbol.toStringTag] = "AsyncDisposableStack";
+};
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/util/assert.js
+var assert = (value, message) => {
+  if (!value) {
+    throw new Error(message);
+  }
+};
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/environment.js
+var isNode = !!(typeof process !== "undefined" && process.version);
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/common/Debug.js
+var debugModule = null;
+async function importDebug() {
+  if (!debugModule) {
+    debugModule = (await import("./src-EJG4ILDC.js")).default;
+  }
+  return debugModule;
+}
+var debug = (prefix) => {
+  if (isNode) {
+    return async (...logArgs) => {
+      if (captureLogs) {
+        capturedLogs.push(prefix + logArgs);
+      }
+      (await importDebug())(prefix)(logArgs);
+    };
+  }
+  return (...logArgs) => {
+    const debugLevel = globalThis.__PUPPETEER_DEBUG;
+    if (!debugLevel) {
+      return;
+    }
+    const everythingShouldBeLogged = debugLevel === "*";
+    const prefixMatchesDebugLevel = everythingShouldBeLogged || /**
+     * If the debug level is `foo*`, that means we match any prefix that
+     * starts with `foo`. If the level is `foo`, we match only the prefix
+     * `foo`.
+     */
+    (debugLevel.endsWith("*") ? prefix.startsWith(debugLevel) : prefix === debugLevel);
+    if (!prefixMatchesDebugLevel) {
+      return;
+    }
+    console.log(`${prefix}:`, ...logArgs);
+  };
+};
+var capturedLogs = [];
+var captureLogs = false;
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/common/Errors.js
+var PuppeteerError = class extends Error {
+  /**
+   * @internal
+   */
+  constructor(message, options) {
+    super(message, options);
+    this.name = this.constructor.name;
+  }
+  /**
+   * @internal
+   */
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+};
+var TimeoutError = class extends PuppeteerError {
+};
+var ProtocolError = class extends PuppeteerError {
+  #code;
+  #originalMessage = "";
+  set code(code) {
+    this.#code = code;
+  }
+  /**
+   * @readonly
+   * @public
+   */
+  get code() {
+    return this.#code;
+  }
+  set originalMessage(originalMessage) {
+    this.#originalMessage = originalMessage;
+  }
+  /**
+   * @readonly
+   * @public
+   */
+  get originalMessage() {
+    return this.#originalMessage;
+  }
+};
+var UnsupportedOperation = class extends PuppeteerError {
+};
+var TargetCloseError = class extends ProtocolError {
+};
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/common/PDFOptions.js
+var paperFormats = {
+  letter: { width: 8.5, height: 11 },
+  legal: { width: 8.5, height: 14 },
+  tabloid: { width: 11, height: 17 },
+  ledger: { width: 17, height: 11 },
+  a0: { width: 33.1, height: 46.8 },
+  a1: { width: 23.4, height: 33.1 },
+  a2: { width: 16.54, height: 23.4 },
+  a3: { width: 11.7, height: 16.54 },
+  a4: { width: 8.27, height: 11.7 },
+  a5: { width: 5.83, height: 8.27 },
+  a6: { width: 4.13, height: 5.83 }
+};
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/common/util.js
+var debugError = debug("puppeteer:error");
+var DEFAULT_VIEWPORT = Object.freeze({ width: 800, height: 600 });
+var SOURCE_URL = Symbol("Source URL for Puppeteer evaluation scripts");
+var PuppeteerURL = class _PuppeteerURL {
+  static INTERNAL_URL = "pptr:internal";
+  static fromCallSite(functionName, site) {
+    const url = new _PuppeteerURL();
+    url.#functionName = functionName;
+    url.#siteString = site.toString();
+    return url;
+  }
+  static parse = (url) => {
+    url = url.slice("pptr:".length);
+    const [functionName = "", siteString = ""] = url.split(";");
+    const puppeteerUrl = new _PuppeteerURL();
+    puppeteerUrl.#functionName = functionName;
+    puppeteerUrl.#siteString = decodeURIComponent(siteString);
+    return puppeteerUrl;
+  };
+  static isPuppeteerURL = (url) => {
+    return url.startsWith("pptr:");
+  };
+  #functionName;
+  #siteString;
+  get functionName() {
+    return this.#functionName;
+  }
+  get siteString() {
+    return this.#siteString;
+  }
+  toString() {
+    return `pptr:${[
+      this.#functionName,
+      encodeURIComponent(this.#siteString)
+    ].join(";")}`;
+  }
+};
+var withSourcePuppeteerURLIfNone = (functionName, object) => {
+  if (Object.prototype.hasOwnProperty.call(object, SOURCE_URL)) {
+    return object;
+  }
+  const original = Error.prepareStackTrace;
+  Error.prepareStackTrace = (_, stack) => {
+    return stack[2];
+  };
+  const site = new Error().stack;
+  Error.prepareStackTrace = original;
+  return Object.assign(object, {
+    [SOURCE_URL]: PuppeteerURL.fromCallSite(functionName, site)
+  });
+};
+var getSourcePuppeteerURLIfAvailable = (object) => {
+  if (Object.prototype.hasOwnProperty.call(object, SOURCE_URL)) {
+    return object[SOURCE_URL];
+  }
+  return void 0;
+};
+var isString = (obj) => {
+  return typeof obj === "string" || obj instanceof String;
+};
+var isNumber = (obj) => {
+  return typeof obj === "number" || obj instanceof Number;
+};
+var isPlainObject = (obj) => {
+  return typeof obj === "object" && obj?.constructor === Object;
+};
+var isRegExp = (obj) => {
+  return typeof obj === "object" && obj?.constructor === RegExp;
+};
+var isDate = (obj) => {
+  return typeof obj === "object" && obj?.constructor === Date;
+};
+function evaluationString(fun, ...args) {
+  if (isString(fun)) {
+    assert(args.length === 0, "Cannot evaluate a string with arguments");
+    return fun;
+  }
+  function serializeArgument(arg) {
+    if (Object.is(arg, void 0)) {
+      return "undefined";
+    }
+    return JSON.stringify(arg);
+  }
+  return `(${fun})(${args.map(serializeArgument).join(",")})`;
+}
+var fs = null;
+async function importFSPromises() {
+  if (!fs) {
+    try {
+      fs = await import("fs/promises");
+    } catch (error) {
+      if (error instanceof TypeError) {
+        throw new Error("Cannot write to a path outside of a Node-like environment.");
+      }
+      throw error;
+    }
+  }
+  return fs;
+}
+async function getReadableAsBuffer(readable, path) {
+  const buffers = [];
+  const reader = readable.getReader();
+  if (path) {
+    const fs2 = await importFSPromises();
+    const fileHandle = await fs2.open(path, "w+");
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffers.push(value);
+        await fileHandle.writeFile(value);
+      }
+    } finally {
+      await fileHandle.close();
+    }
+  } else {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffers.push(value);
+    }
+  }
+  try {
+    return Buffer.concat(buffers);
+  } catch (error) {
+    debugError(error);
+    return null;
+  }
+}
+async function getReadableFromProtocolStream(client, handle) {
+  return new ReadableStream({
+    async pull(controller) {
+      function getUnit8Array(data2, isBase64) {
+        if (isBase64) {
+          return Uint8Array.from(atob(data2), (m) => {
+            return m.codePointAt(0);
+          });
+        }
+        const encoder = new TextEncoder();
+        return encoder.encode(data2);
+      }
+      const { data, base64Encoded, eof } = await client.send("IO.read", {
+        handle
+      });
+      controller.enqueue(getUnit8Array(data, base64Encoded ?? false));
+      if (eof) {
+        await client.send("IO.close", { handle });
+        controller.close();
+      }
+    }
+  });
+}
+function validateDialogType(type) {
+  let dialogType = null;
+  const validDialogTypes = /* @__PURE__ */ new Set([
+    "alert",
+    "confirm",
+    "prompt",
+    "beforeunload"
+  ]);
+  if (validDialogTypes.has(type)) {
+    dialogType = type;
+  }
+  assert(dialogType, `Unknown javascript dialog type: ${type}`);
+  return dialogType;
+}
+function timeout(ms, cause) {
+  return ms === 0 ? NEVER : timer(ms).pipe(map(() => {
+    throw new TimeoutError(`Timed out after waiting ${ms}ms`, { cause });
+  }));
+}
+var UTILITY_WORLD_NAME = "__puppeteer_utility_world__" + packageVersion;
+var SOURCE_URL_REGEX = /^[\040\t]*\/\/[@#] sourceURL=\s*(\S*?)\s*$/m;
+function getSourceUrlComment(url) {
+  return `//# sourceURL=${url}`;
+}
+var NETWORK_IDLE_TIME = 500;
+function parsePDFOptions(options = {}, lengthUnit = "in") {
+  const defaults = {
+    scale: 1,
+    displayHeaderFooter: false,
+    headerTemplate: "",
+    footerTemplate: "",
+    printBackground: false,
+    landscape: false,
+    pageRanges: "",
+    preferCSSPageSize: false,
+    omitBackground: false,
+    outline: false,
+    tagged: true,
+    waitForFonts: true
+  };
+  let width = 8.5;
+  let height = 11;
+  if (options.format) {
+    const format = paperFormats[options.format.toLowerCase()];
+    assert(format, "Unknown paper format: " + options.format);
+    width = format.width;
+    height = format.height;
+  } else {
+    width = convertPrintParameterToInches(options.width, lengthUnit) ?? width;
+    height = convertPrintParameterToInches(options.height, lengthUnit) ?? height;
+  }
+  const margin = {
+    top: convertPrintParameterToInches(options.margin?.top, lengthUnit) || 0,
+    left: convertPrintParameterToInches(options.margin?.left, lengthUnit) || 0,
+    bottom: convertPrintParameterToInches(options.margin?.bottom, lengthUnit) || 0,
+    right: convertPrintParameterToInches(options.margin?.right, lengthUnit) || 0
+  };
+  if (options.outline) {
+    options.tagged = true;
+  }
+  return {
+    ...defaults,
+    ...options,
+    width,
+    height,
+    margin
+  };
+}
+var unitToPixels = {
+  px: 1,
+  in: 96,
+  cm: 37.8,
+  mm: 3.78
+};
+function convertPrintParameterToInches(parameter, lengthUnit = "in") {
+  if (typeof parameter === "undefined") {
+    return void 0;
+  }
+  let pixels;
+  if (isNumber(parameter)) {
+    pixels = parameter;
+  } else if (isString(parameter)) {
+    const text = parameter;
+    let unit = text.substring(text.length - 2).toLowerCase();
+    let valueText = "";
+    if (unit in unitToPixels) {
+      valueText = text.substring(0, text.length - 2);
+    } else {
+      unit = "px";
+      valueText = text;
+    }
+    const value = Number(valueText);
+    assert(!isNaN(value), "Failed to parse parameter value: " + text);
+    pixels = value * unitToPixels[unit];
+  } else {
+    throw new Error("page.pdf() Cannot handle parameter type: " + typeof parameter);
+  }
+  return pixels / unitToPixels[lengthUnit];
+}
+function fromEmitterEvent(emitter, eventName) {
+  return new Observable((subscriber) => {
+    const listener = (event) => {
+      subscriber.next(event);
+    };
+    emitter.on(eventName, listener);
+    return () => {
+      emitter.off(eventName, listener);
+    };
+  });
+}
+function fromAbortSignal(signal, cause) {
+  return signal ? fromEvent(signal, "abort").pipe(map(() => {
+    if (signal.reason instanceof Error) {
+      signal.reason.cause = cause;
+      throw signal.reason;
+    }
+    throw new Error(signal.reason, { cause });
+  })) : NEVER;
+}
+function filterAsync(predicate) {
+  return mergeMap((value) => {
+    return from(Promise.resolve(predicate(value))).pipe(filter((isMatch) => {
+      return isMatch;
+    }), map(() => {
+      return value;
+    }));
+  });
+}
+
+// ../../node_modules/puppeteer-core/lib/esm/third_party/mitt/mitt.js
+function mitt_default(n) {
+  return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) {
+    var i = n.get(t);
+    i ? i.push(e) : n.set(t, [e]);
+  }, off: function(t, e) {
+    var i = n.get(t);
+    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+  }, emit: function(t, e) {
+    var i = n.get(t);
+    i && i.slice().map(function(n2) {
+      n2(e);
+    }), (i = n.get("*")) && i.slice().map(function(n2) {
+      n2(t, e);
+    });
+  } };
+}
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/common/EventEmitter.js
+var EventEmitter = class {
+  #emitter;
+  #handlers = /* @__PURE__ */ new Map();
+  /**
+   * If you pass an emitter, the returned emitter will wrap the passed emitter.
+   *
+   * @internal
+   */
+  constructor(emitter = mitt_default(/* @__PURE__ */ new Map())) {
+    this.#emitter = emitter;
+  }
+  /**
+   * Bind an event listener to fire when an event occurs.
+   * @param type - the event type you'd like to listen to. Can be a string or symbol.
+   * @param handler - the function to be called when the event occurs.
+   * @returns `this` to enable you to chain method calls.
+   */
+  on(type, handler) {
+    const handlers = this.#handlers.get(type);
+    if (handlers === void 0) {
+      this.#handlers.set(type, [handler]);
+    } else {
+      handlers.push(handler);
+    }
+    this.#emitter.on(type, handler);
+    return this;
+  }
+  /**
+   * Remove an event listener from firing.
+   * @param type - the event type you'd like to stop listening to.
+   * @param handler - the function that should be removed.
+   * @returns `this` to enable you to chain method calls.
+   */
+  off(type, handler) {
+    const handlers = this.#handlers.get(type) ?? [];
+    if (handler === void 0) {
+      for (const handler2 of handlers) {
+        this.#emitter.off(type, handler2);
+      }
+      this.#handlers.delete(type);
+      return this;
+    }
+    const index = handlers.lastIndexOf(handler);
+    if (index > -1) {
+      this.#emitter.off(type, ...handlers.splice(index, 1));
+    }
+    return this;
+  }
+  /**
+   * Emit an event and call any associated listeners.
+   *
+   * @param type - the event you'd like to emit
+   * @param eventData - any data you'd like to emit with the event
+   * @returns `true` if there are any listeners, `false` if there are not.
+   */
+  emit(type, event) {
+    this.#emitter.emit(type, event);
+    return this.listenerCount(type) > 0;
+  }
+  /**
+   * Like `on` but the listener will only be fired once and then it will be removed.
+   * @param type - the event you'd like to listen to
+   * @param handler - the handler function to run when the event occurs
+   * @returns `this` to enable you to chain method calls.
+   */
+  once(type, handler) {
+    const onceHandler = (eventData) => {
+      handler(eventData);
+      this.off(type, onceHandler);
+    };
+    return this.on(type, onceHandler);
+  }
+  /**
+   * Gets the number of listeners for a given event.
+   *
+   * @param type - the event to get the listener count for
+   * @returns the number of listeners bound to the given event
+   */
+  listenerCount(type) {
+    return this.#handlers.get(type)?.length || 0;
+  }
+  /**
+   * Removes all listeners. If given an event argument, it will remove only
+   * listeners for that event.
+   *
+   * @param type - the event to remove listeners for.
+   * @returns `this` to enable you to chain method calls.
+   */
+  removeAllListeners(type) {
+    if (type !== void 0) {
+      return this.off(type);
+    }
+    this[disposeSymbol]();
+    return this;
+  }
+  /**
+   * @internal
+   */
+  [disposeSymbol]() {
+    for (const [type, handlers] of this.#handlers) {
+      for (const handler of handlers) {
+        this.#emitter.off(type, handler);
+      }
+    }
+    this.#handlers.clear();
+  }
+};
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/api/CDPSession.js
+var CDPSessionEvent;
+(function(CDPSessionEvent2) {
+  CDPSessionEvent2.Disconnected = Symbol("CDPSession.Disconnected");
+  CDPSessionEvent2.Swapped = Symbol("CDPSession.Swapped");
+  CDPSessionEvent2.Ready = Symbol("CDPSession.Ready");
+  CDPSessionEvent2.SessionAttached = "sessionattached";
+  CDPSessionEvent2.SessionDetached = "sessiondetached";
+})(CDPSessionEvent || (CDPSessionEvent = {}));
+var CDPSession = class extends EventEmitter {
+  /**
+   * @internal
+   */
+  constructor() {
+    super();
+  }
+  /**
+   * Parent session in terms of CDP's auto-attach mechanism.
+   *
+   * @internal
+   */
+  parentSession() {
+    return void 0;
+  }
+};
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/util/Deferred.js
+var Deferred = class _Deferred {
+  static create(opts) {
+    return new _Deferred(opts);
+  }
+  static async race(awaitables) {
+    const deferredWithTimeout = /* @__PURE__ */ new Set();
+    try {
+      const promises = awaitables.map((value) => {
+        if (value instanceof _Deferred) {
+          if (value.#timeoutId) {
+            deferredWithTimeout.add(value);
+          }
+          return value.valueOrThrow();
+        }
+        return value;
+      });
+      return await Promise.race(promises);
+    } finally {
+      for (const deferred of deferredWithTimeout) {
+        deferred.reject(new Error("Timeout cleared"));
+      }
+    }
+  }
+  #isResolved = false;
+  #isRejected = false;
+  #value;
+  // SAFETY: This is ensured by #taskPromise.
+  #resolve;
+  #taskPromise = new Promise((resolve) => {
+    this.#resolve = resolve;
+  });
+  #timeoutId;
+  #timeoutError;
+  constructor(opts) {
+    if (opts && opts.timeout > 0) {
+      this.#timeoutError = new TimeoutError(opts.message);
+      this.#timeoutId = setTimeout(() => {
+        this.reject(this.#timeoutError);
+      }, opts.timeout);
+    }
+  }
+  #finish(value) {
+    clearTimeout(this.#timeoutId);
+    this.#value = value;
+    this.#resolve();
+  }
+  resolve(value) {
+    if (this.#isRejected || this.#isResolved) {
+      return;
+    }
+    this.#isResolved = true;
+    this.#finish(value);
+  }
+  reject(error) {
+    if (this.#isRejected || this.#isResolved) {
+      return;
+    }
+    this.#isRejected = true;
+    this.#finish(error);
+  }
+  resolved() {
+    return this.#isResolved;
+  }
+  finished() {
+    return this.#isResolved || this.#isRejected;
+  }
+  value() {
+    return this.#value;
+  }
+  #promise;
+  valueOrThrow() {
+    if (!this.#promise) {
+      this.#promise = (async () => {
+        await this.#taskPromise;
+        if (this.#isRejected) {
+          throw this.#value;
+        }
+        return this.#value;
+      })();
+    }
+    return this.#promise;
+  }
+};
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/util/Mutex.js
+var Mutex = class _Mutex {
+  static Guard = class Guard {
+    #mutex;
+    #onRelease;
+    constructor(mutex, onRelease) {
+      this.#mutex = mutex;
+      this.#onRelease = onRelease;
+    }
+    [disposeSymbol]() {
+      this.#onRelease?.();
+      return this.#mutex.release();
+    }
+  };
+  #locked = false;
+  #acquirers = [];
+  // This is FIFO.
+  async acquire(onRelease) {
+    if (!this.#locked) {
+      this.#locked = true;
+      return new _Mutex.Guard(this);
+    }
+    const deferred = Deferred.create();
+    this.#acquirers.push(deferred.resolve.bind(deferred));
+    await deferred.valueOrThrow();
+    return new _Mutex.Guard(this, onRelease);
+  }
+  release() {
+    const resolve = this.#acquirers.shift();
+    if (!resolve) {
+      this.#locked = false;
+      return;
+    }
+    resolve();
+  }
+};
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/util/decorators.js
+var __addDisposableResource = function(env, value, async2) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose;
+    if (async2) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    env.stack.push({ value, dispose, async: async2 });
+  } else if (async2) {
+    env.stack.push({ async: true });
+  }
+  return value;
+};
+var __disposeResources = /* @__PURE__ */ (function(SuppressedError2) {
+  return function(env) {
+    function fail(e) {
+      env.error = env.hasError ? new SuppressedError2(e, env.error, "An error was suppressed during disposal.") : e;
+      env.hasError = true;
+    }
+    function next() {
+      while (env.stack.length) {
+        var rec = env.stack.pop();
+        try {
+          var result = rec.dispose && rec.dispose.call(rec.value);
+          if (rec.async) return Promise.resolve(result).then(next, function(e) {
+            fail(e);
+            return next();
+          });
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (env.hasError) throw env.error;
+    }
+    return next();
+  };
+})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var instances = /* @__PURE__ */ new WeakSet();
+function moveable(Class, _) {
+  let hasDispose = false;
+  if (Class.prototype[disposeSymbol]) {
+    const dispose = Class.prototype[disposeSymbol];
+    Class.prototype[disposeSymbol] = function() {
+      if (instances.has(this)) {
+        instances.delete(this);
+        return;
+      }
+      return dispose.call(this);
+    };
+    hasDispose = true;
+  }
+  if (Class.prototype[asyncDisposeSymbol]) {
+    const asyncDispose = Class.prototype[asyncDisposeSymbol];
+    Class.prototype[asyncDisposeSymbol] = function() {
+      if (instances.has(this)) {
+        instances.delete(this);
+        return;
+      }
+      return asyncDispose.call(this);
+    };
+    hasDispose = true;
+  }
+  if (hasDispose) {
+    Class.prototype.move = function() {
+      instances.add(this);
+      return this;
+    };
+  }
+  return Class;
+}
+function throwIfDisposed(message = (value) => {
+  return `Attempted to use disposed ${value.constructor.name}.`;
+}) {
+  return (target, _) => {
+    return function(...args) {
+      if (this.disposed) {
+        throw new Error(message(this));
+      }
+      return target.call(this, ...args);
+    };
+  };
+}
+function inertIfDisposed(target, _) {
+  return function(...args) {
+    if (this.disposed) {
+      return;
+    }
+    return target.call(this, ...args);
+  };
+}
+function invokeAtMostOnceForArguments(target, _) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  let cacheDepth = -1;
+  return function(...args) {
+    if (cacheDepth === -1) {
+      cacheDepth = args.length;
+    }
+    if (cacheDepth !== args.length) {
+      throw new Error("Memoized method was called with the wrong number of arguments");
+    }
+    let freshArguments = false;
+    let cacheIterator = cache;
+    for (const arg of args) {
+      if (cacheIterator.has(arg)) {
+        cacheIterator = cacheIterator.get(arg);
+      } else {
+        freshArguments = true;
+        cacheIterator.set(arg, /* @__PURE__ */ new WeakMap());
+        cacheIterator = cacheIterator.get(arg);
+      }
+    }
+    if (!freshArguments) {
+      return;
+    }
+    return target.call(this, ...args);
+  };
+}
+function guarded(getKey = function() {
+  return this;
+}) {
+  return (target, _) => {
+    const mutexes = /* @__PURE__ */ new WeakMap();
+    return async function(...args) {
+      const env_1 = { stack: [], error: void 0, hasError: false };
+      try {
+        const key = getKey.call(this);
+        let mutex = mutexes.get(key);
+        if (!mutex) {
+          mutex = new Mutex();
+          mutexes.set(key, mutex);
+        }
+        const _2 = __addDisposableResource(env_1, await mutex.acquire(), true);
+        return await target.call(this, ...args);
+      } catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+      } finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+          await result_1;
+      }
+    };
+  };
+}
+var bubbleHandlers = /* @__PURE__ */ new WeakMap();
+var bubbleInitializer = function(events) {
+  const handlers = bubbleHandlers.get(this) ?? /* @__PURE__ */ new Map();
+  if (handlers.has(events)) {
+    return;
+  }
+  const handler = events !== void 0 ? (type, event) => {
+    if (events.includes(type)) {
+      this.emit(type, event);
+    }
+  } : (type, event) => {
+    this.emit(type, event);
+  };
+  handlers.set(events, handler);
+  bubbleHandlers.set(this, handlers);
+};
+function bubble(events) {
+  return ({ set, get }, context2) => {
+    context2.addInitializer(function() {
+      return bubbleInitializer.apply(this, [events]);
+    });
+    return {
+      set(emitter) {
+        const handler = bubbleHandlers.get(this).get(events);
+        const oldEmitter = get.call(this);
+        if (oldEmitter !== void 0) {
+          oldEmitter.off("*", handler);
+        }
+        if (emitter === void 0) {
+          return;
+        }
+        emitter.on("*", handler);
+        set.call(this, emitter);
+      },
+      init(emitter) {
+        if (emitter === void 0) {
+          return emitter;
+        }
+        bubbleInitializer.apply(this, [events]);
+        const handler = bubbleHandlers.get(this).get(events);
+        emitter.on("*", handler);
+        return emitter;
+      }
+    };
+  };
+}
+
+export {
+  noop,
+  identity,
+  pipe,
+  ReplaySubject,
+  EMPTY,
+  from,
+  of,
+  lastValueFrom,
+  firstValueFrom,
+  map,
+  combineLatest,
+  mergeMap,
+  concat,
+  defer,
+  fromEvent,
+  timer,
+  merge,
+  filter,
+  race,
+  bufferCount,
+  catchError,
+  concatMap,
+  defaultIfEmpty,
+  take,
+  ignoreElements,
+  delayWhen,
+  throwIfEmpty,
+  first,
+  mergeScan,
+  raceWith,
+  retry,
+  startWith,
+  switchMap,
+  takeUntil,
+  tap,
+  disposeSymbol,
+  asyncDisposeSymbol,
+  DisposableStack,
+  AsyncDisposableStack,
+  EventEmitter,
+  assert,
+  isNode,
+  debug,
+  TimeoutError,
+  ProtocolError,
+  UnsupportedOperation,
+  TargetCloseError,
+  debugError,
+  DEFAULT_VIEWPORT,
+  PuppeteerURL,
+  withSourcePuppeteerURLIfNone,
+  getSourcePuppeteerURLIfAvailable,
+  isString,
+  isPlainObject,
+  isRegExp,
+  isDate,
+  evaluationString,
+  importFSPromises,
+  getReadableAsBuffer,
+  getReadableFromProtocolStream,
+  validateDialogType,
+  timeout,
+  UTILITY_WORLD_NAME,
+  SOURCE_URL_REGEX,
+  getSourceUrlComment,
+  NETWORK_IDLE_TIME,
+  parsePDFOptions,
+  fromEmitterEvent,
+  fromAbortSignal,
+  filterAsync,
+  Deferred,
+  Mutex,
+  CDPSessionEvent,
+  CDPSession,
+  moveable,
+  throwIfDisposed,
+  inertIfDisposed,
+  invokeAtMostOnceForArguments,
+  guarded,
+  bubble
+};
+/*! Bundled license information:
+
+puppeteer-core/lib/esm/puppeteer/util/disposable.js:
+puppeteer-core/lib/esm/puppeteer/util/decorators.js:
+  (**
+   * @license
+   * Copyright 2023 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+
+puppeteer-core/lib/esm/puppeteer/util/assert.js:
+puppeteer-core/lib/esm/puppeteer/environment.js:
+puppeteer-core/lib/esm/puppeteer/common/Debug.js:
+puppeteer-core/lib/esm/puppeteer/common/PDFOptions.js:
+  (**
+   * @license
+   * Copyright 2020 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+
+puppeteer-core/lib/esm/puppeteer/common/Errors.js:
+  (**
+   * @license
+   * Copyright 2018 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+
+puppeteer-core/lib/esm/puppeteer/common/util.js:
+  (**
+   * @license
+   * Copyright 2017 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+
+puppeteer-core/lib/esm/puppeteer/common/EventEmitter.js:
+  (**
+   * @license
+   * Copyright 2022 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+
+puppeteer-core/lib/esm/puppeteer/util/Deferred.js:
+puppeteer-core/lib/esm/puppeteer/util/Mutex.js:
+  (**
+   * @license
+   * Copyright 2024 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/