@prose-reader/core 1.32.0 → 1.33.0

package/dist/prose.umd.cjs

@@ -1,6 +1,6 @@
 (function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("rxjs"), require("@prose-reader/shared")) : typeof define === "function" && define.amd ? define(["exports", "rxjs", "@prose-reader/shared"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.prose = {}, global.rxjs, global["@prose-reader/shared"]));
-})(this, function(exports2, rxjs, shared) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("rxjs"), require("rxjs/operators"), require("@prose-reader/shared")) : typeof define === "function" && define.amd ? define(["exports", "rxjs", "rxjs/operators", "@prose-reader/shared"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.prose = {}, global.rxjs, global.operators, global.shared));
+})(this, function(exports2, rxjs, operators, shared) {
   "use strict";
   const SHOULD_NOT_LAYOUT$3 = false;
   const chromeEnhancer = (next) => (options) => {
@@ -20,2081 +20,6 @@
     });
     return reader;
   };
-  function isFunction(value) {
-    return typeof value === "function";
-  }
-  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");
-    };
-  }
-  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);
-    }
-  }
-  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 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, timeout) {
-      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, timeout], __read(args)));
-      }
-      return setTimeout.apply(void 0, __spreadArray([handler, timeout], __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() {
-      {
-        throw err;
-      }
-    });
-  }
-  function noop() {
-  }
-  function errorContext(cb) {
-    {
-      cb();
-    }
-  }
-  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)
-        ;
-      else {
-        this._next(value);
-      }
-    };
-    Subscriber2.prototype.error = function(err) {
-      if (this.isStopped)
-        ;
-      else {
-        this.isStopped = true;
-        this._error(err);
-      }
-    };
-    Subscriber2.prototype.complete = function() {
-      if (this.isStopped)
-        ;
-      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) {
-    {
-      reportUnhandledError(error);
-    }
-  }
-  function defaultErrorHandler(err) {
-    throw err;
-  }
-  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 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 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:
-            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) {
-      process(asyncIterable, subscriber).catch(function(err) {
-        return subscriber.error(err);
-      });
-    });
-  }
-  function fromReadableStreamLike(readableStream) {
-    return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
-  }
-  function process(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 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 Action = function(_super) {
-    __extends(Action2, _super);
-    function Action2(scheduler, work) {
-      return _super.call(this) || this;
-    }
-    Action2.prototype.schedule = function(state, delay2) {
-      return this;
-    };
-    return Action2;
-  }(Subscription);
-  var intervalProvider = {
-    setInterval: function(handler, timeout) {
-      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, timeout], __read(args)));
-      }
-      return setInterval.apply(void 0, __spreadArray([handler, timeout], __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 dateTimestampProvider = {
-    now: function() {
-      return (dateTimestampProvider.delegate || Date).now();
-    },
-    delegate: void 0
-  };
-  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;
-  function isScheduler(value) {
-    return value && isFunction(value.schedule);
-  }
-  function isValidDate(value) {
-    return value instanceof Date && !isNaN(value);
-  }
-  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 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 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 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 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 iterator$1;
-      executeSchedule(subscriber, scheduler, function() {
-        iterator$1 = input[iterator]();
-        executeSchedule(subscriber, scheduler, function() {
-          var _a;
-          var value;
-          var done;
-          try {
-            _a = iterator$1.next(), value = _a.value, done = _a.done;
-          } catch (err) {
-            subscriber.error(err);
-            return;
-          }
-          if (done) {
-            subscriber.complete();
-          } else {
-            subscriber.next(value);
-          }
-        }, 0, true);
-      });
-      return function() {
-        return isFunction(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return();
-      };
-    });
-  }
-  function scheduleAsyncIterable(input, scheduler) {
-    if (!input) {
-      throw new Error("Iterable cannot be null");
-    }
-    return new Observable(function(subscriber) {
-      executeSchedule(subscriber, scheduler, function() {
-        var 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 map(project, thisArg) {
-    return operate(function(source, subscriber) {
-      var index = 0;
-      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-        subscriber.next(project.call(thisArg, value, index++));
-      }));
-    });
-  }
-  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);
-  }
-  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);
-  function debounce(durationSelector) {
-    return operate(function(source, subscriber) {
-      var hasValue = false;
-      var lastValue = null;
-      var durationSubscriber = null;
-      var emit = function() {
-        durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
-        durationSubscriber = null;
-        if (hasValue) {
-          hasValue = false;
-          var value = lastValue;
-          lastValue = null;
-          subscriber.next(value);
-        }
-      };
-      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-        durationSubscriber === null || durationSubscriber === void 0 ? void 0 : durationSubscriber.unsubscribe();
-        hasValue = true;
-        lastValue = value;
-        durationSubscriber = createOperatorSubscriber(subscriber, emit, noop);
-        innerFrom(durationSelector(value)).subscribe(durationSubscriber);
-      }, function() {
-        emit();
-        subscriber.complete();
-      }, void 0, function() {
-        lastValue = durationSubscriber = null;
-      }));
-    });
-  }
-  function debounceTime(dueTime, scheduler) {
-    if (scheduler === void 0) {
-      scheduler = asyncScheduler;
-    }
-    return operate(function(source, subscriber) {
-      var activeTask = null;
-      var lastValue = null;
-      var lastTime = null;
-      var emit = function() {
-        if (activeTask) {
-          activeTask.unsubscribe();
-          activeTask = null;
-          var value = lastValue;
-          lastValue = null;
-          subscriber.next(value);
-        }
-      };
-      function emitWhenIdle() {
-        var targetTime = lastTime + dueTime;
-        var now = scheduler.now();
-        if (now < targetTime) {
-          activeTask = this.schedule(void 0, targetTime - now);
-          subscriber.add(activeTask);
-          return;
-        }
-        emit();
-      }
-      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-        lastValue = value;
-        lastTime = scheduler.now();
-        if (!activeTask) {
-          activeTask = scheduler.schedule(emitWhenIdle, dueTime);
-          subscriber.add(activeTask);
-        }
-      }, function() {
-        emit();
-        subscriber.complete();
-      }, void 0, function() {
-        lastValue = activeTask = null;
-      }));
-    });
-  }
-  function concat() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      args[_i] = arguments[_i];
-    }
-    return concatAll()(from(args, popScheduler(args)));
-  }
-  var EMPTY = new Observable(function(subscriber) {
-    return 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 delay(due, scheduler) {
-    if (scheduler === void 0) {
-      scheduler = asyncScheduler;
-    }
-    var duration = timer(due, scheduler);
-    return delayWhen(function() {
-      return duration;
-    });
-  }
-  function distinctUntilChanged(comparator, keySelector) {
-    if (keySelector === void 0) {
-      keySelector = identity;
-    }
-    comparator = comparator !== null && comparator !== void 0 ? comparator : defaultCompare;
-    return operate(function(source, subscriber) {
-      var previousKey;
-      var first = true;
-      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-        var currentKey = keySelector(value);
-        if (first || !comparator(previousKey, currentKey)) {
-          first = false;
-          previousKey = currentKey;
-          subscriber.next(value);
-        }
-      }));
-    });
-  }
-  function defaultCompare(a, b) {
-    return a === b;
-  }
-  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 exhaustMap(project, resultSelector) {
-    if (resultSelector) {
-      return function(source) {
-        return source.pipe(exhaustMap(function(a, i) {
-          return innerFrom(project(a, i)).pipe(map(function(b, ii) {
-            return resultSelector(a, b, i, ii);
-          }));
-        }));
-      };
-    }
-    return operate(function(source, subscriber) {
-      var index = 0;
-      var innerSub = null;
-      var isComplete = false;
-      source.subscribe(createOperatorSubscriber(subscriber, function(outerValue) {
-        if (!innerSub) {
-          innerSub = createOperatorSubscriber(subscriber, void 0, function() {
-            innerSub = null;
-            isComplete && subscriber.complete();
-          });
-          innerFrom(project(outerValue, index++)).subscribe(innerSub);
-        }
-      }, function() {
-        isComplete = true;
-        !innerSub && subscriber.complete();
-      }));
-    });
-  }
-  function pairwise() {
-    return operate(function(source, subscriber) {
-      var prev;
-      var hasPrev = false;
-      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-        var p = prev;
-        prev = value;
-        hasPrev && subscriber.next([p, value]);
-        hasPrev = true;
-      }));
-    });
-  }
-  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);
-  function share(options) {
-    if (options === void 0) {
-      options = {};
-    }
-    var _a = options.connector, connector = _a === void 0 ? function() {
-      return new Subject();
-    } : _a, _b = options.resetOnError, resetOnError = _b === void 0 ? true : _b, _c = options.resetOnComplete, resetOnComplete = _c === void 0 ? true : _c, _d = options.resetOnRefCountZero, resetOnRefCountZero = _d === void 0 ? true : _d;
-    return function(wrapperSource) {
-      var connection;
-      var resetConnection;
-      var subject;
-      var refCount = 0;
-      var hasCompleted = false;
-      var hasErrored = false;
-      var cancelReset = function() {
-        resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
-        resetConnection = void 0;
-      };
-      var reset = function() {
-        cancelReset();
-        connection = subject = void 0;
-        hasCompleted = hasErrored = false;
-      };
-      var resetAndUnsubscribe = function() {
-        var conn = connection;
-        reset();
-        conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
-      };
-      return operate(function(source, subscriber) {
-        refCount++;
-        if (!hasErrored && !hasCompleted) {
-          cancelReset();
-        }
-        var dest = subject = subject !== null && subject !== void 0 ? subject : connector();
-        subscriber.add(function() {
-          refCount--;
-          if (refCount === 0 && !hasErrored && !hasCompleted) {
-            resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
-          }
-        });
-        dest.subscribe(subscriber);
-        if (!connection && refCount > 0) {
-          connection = new SafeSubscriber({
-            next: function(value) {
-              return dest.next(value);
-            },
-            error: function(err) {
-              hasErrored = true;
-              cancelReset();
-              resetConnection = handleReset(reset, resetOnError, err);
-              dest.error(err);
-            },
-            complete: function() {
-              hasCompleted = true;
-              cancelReset();
-              resetConnection = handleReset(reset, resetOnComplete);
-              dest.complete();
-            }
-          });
-          innerFrom(source).subscribe(connection);
-        }
-      })(wrapperSource);
-    };
-  }
-  function handleReset(reset, on) {
-    var args = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-      args[_i - 2] = arguments[_i];
-    }
-    if (on === true) {
-      reset();
-      return;
-    }
-    if (on === false) {
-      return;
-    }
-    var onSubscriber = new SafeSubscriber({
-      next: function() {
-        onSubscriber.unsubscribe();
-        reset();
-      }
-    });
-    return innerFrom(on.apply(void 0, __spreadArray([], __read(args)))).subscribe(onSubscriber);
-  }
-  function shareReplay(configOrBufferSize, windowTime, scheduler) {
-    var _a, _b, _c;
-    var bufferSize;
-    var refCount = false;
-    if (configOrBufferSize && typeof configOrBufferSize === "object") {
-      _a = configOrBufferSize.bufferSize, bufferSize = _a === void 0 ? Infinity : _a, _b = configOrBufferSize.windowTime, windowTime = _b === void 0 ? Infinity : _b, _c = configOrBufferSize.refCount, refCount = _c === void 0 ? false : _c, scheduler = configOrBufferSize.scheduler;
-    } else {
-      bufferSize = configOrBufferSize !== null && configOrBufferSize !== void 0 ? configOrBufferSize : Infinity;
-    }
-    return share({
-      connector: function() {
-        return new ReplaySubject(bufferSize, windowTime, scheduler);
-      },
-      resetOnError: true,
-      resetOnComplete: false,
-      resetOnRefCountZero: refCount
-    });
-  }
-  function skip(count) {
-    return filter(function(_, index) {
-      return count <= index;
-    });
-  }
-  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;
-  }
-  function withLatestFrom() {
-    var inputs = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      inputs[_i] = arguments[_i];
-    }
-    var project = popResultSelector(inputs);
-    return operate(function(source, subscriber) {
-      var len = inputs.length;
-      var otherValues = new Array(len);
-      var hasValue = inputs.map(function() {
-        return false;
-      });
-      var ready = false;
-      var _loop_1 = function(i2) {
-        innerFrom(inputs[i2]).subscribe(createOperatorSubscriber(subscriber, function(value) {
-          otherValues[i2] = value;
-          if (!ready && !hasValue[i2]) {
-            hasValue[i2] = true;
-            (ready = hasValue.every(identity)) && (hasValue = null);
-          }
-        }, noop));
-      };
-      for (var i = 0; i < len; i++) {
-        _loop_1(i);
-      }
-      source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-        if (ready) {
-          var values = __spreadArray([value], __read(otherValues));
-          subscriber.next(project ? project.apply(void 0, __spreadArray([], __read(values))) : values);
-        }
-      }));
-    });
-  }
   const hasOwn = Object.prototype.hasOwnProperty;
   const is = (x, y) => {
     if (x === y) {
@@ -2190,7 +115,7 @@
       }
     });
     const shouldRequireLayout = (source) => source.pipe(
-      pairwise(),
+      operators.pairwise(),
       rxjs.map(([old, latest]) => {
         if (latest.fontScale !== old.fontScale)
           return true;
@@ -2200,18 +125,18 @@
       })
     );
     const newSettings$ = changes$.pipe(
-      withLatestFrom(settings$),
+      operators.withLatestFrom(settings$),
       rxjs.map(([changes, settings]) => ({
         fontJustification: changes.fontJustification ?? settings.fontJustification,
         fontWeight: changes.fontWeight ?? settings.fontWeight,
         lineHeight: changes.lineHeight ?? settings.lineHeight,
         fontScale: Math.max(0.01, changes.fontScale ?? settings.fontScale)
       })),
-      distinctUntilChanged(isShallowEqual),
-      shareReplay(1)
+      operators.distinctUntilChanged(isShallowEqual),
+      operators.shareReplay(1)
     );
     newSettings$.subscribe(settings$);
-    settings$.pipe(shouldRequireLayout, tap(applyChangeToSpineItem), rxjs.takeUntil(reader.$.destroy$)).subscribe();
+    settings$.pipe(shouldRequireLayout, operators.tap(applyChangeToSpineItem), rxjs.takeUntil(reader.$.destroy$)).subscribe();
     const settingsMerge$ = rxjs.combineLatest([reader.settings$, settings$]).pipe(
       rxjs.map(([innerSettings, settings]) => ({
         ...innerSettings,
@@ -2288,32 +213,32 @@
       return SHOULD_NOT_LAYOUT$2;
     });
     const createResetLock$ = (source) => rxjs.scheduled(source, rxjs.animationFrameScheduler).pipe(
-      tap(() => {
+      operators.tap(() => {
         iframeOverlayForAnimationsElement == null ? void 0 : iframeOverlayForAnimationsElement.style.setProperty(`visibility`, `hidden`);
       })
     );
-    const viewportFree$ = reader.$.viewportState$.pipe(filter((data) => data === `free`));
-    const viewportBusy$ = reader.$.viewportState$.pipe(filter((data) => data === `busy`));
+    const viewportFree$ = reader.$.viewportState$.pipe(operators.filter((data) => data === `free`));
+    const viewportBusy$ = reader.$.viewportState$.pipe(operators.filter((data) => data === `busy`));
     const lockAfterViewportBusy$ = viewportBusy$.pipe(
-      tap(() => {
+      operators.tap(() => {
         iframeOverlayForAnimationsElement == null ? void 0 : iframeOverlayForAnimationsElement.style.setProperty(`visibility`, `visible`);
       })
     );
-    const resetLockViewportFree$ = createResetLock$(viewportFree$).pipe(take(1));
+    const resetLockViewportFree$ = createResetLock$(viewportFree$).pipe(operators.take(1));
     const pageTurnMode$ = reader.context.$.settings$.pipe(
-      map(() => reader.context.getSettings().computedPageTurnMode),
-      distinctUntilChanged()
+      operators.map(() => reader.context.getSettings().computedPageTurnMode),
+      operators.distinctUntilChanged()
     );
     const handleViewportLock$ = pageTurnMode$.pipe(
-      switchMap(
-        (mode) => mode === `controlled` ? lockAfterViewportBusy$.pipe(switchMap(() => resetLockViewportFree$)) : createResetLock$(rxjs.of(void 0))
+      operators.switchMap(
+        (mode) => mode === `controlled` ? lockAfterViewportBusy$.pipe(operators.switchMap(() => resetLockViewportFree$)) : createResetLock$(rxjs.of(void 0))
       ),
-      takeUntil(reader.$.destroy$)
+      operators.takeUntil(reader.$.destroy$)
     );
     return handleViewportLock$;
   };
   const mapKeysTo = (keys) => {
-    return map((obj) => {
+    return operators.map((obj) => {
       return Object.entries(obj).reduce((acc, [key, entry]) => {
         if (keys.includes(key)) {
           return {
@@ -2412,12 +337,12 @@
     movingSafePan$.subscribe();
     settingsSubject$.pipe(
       mapKeysTo([`pageHorizontalMargin`, `pageVerticalMargin`]),
-      distinctUntilChanged(isShallowEqual),
-      skip(1),
-      tap(() => {
+      operators.distinctUntilChanged(isShallowEqual),
+      operators.skip(1),
+      operators.tap(() => {
         reader.layout();
       }),
-      takeUntil(reader.$.destroy$)
+      operators.takeUntil(reader.$.destroy$)
     ).subscribe();
     return {
       ...reader,
@@ -2435,7 +360,7 @@
         reader.setSettings(rest);
       },
       settings$: rxjs.combineLatest([reader.settings$, settingsSubject$.asObservable()]).pipe(
-        map(([innerSettings, settings]) => ({
+        operators.map(([innerSettings, settings]) => ({
           ...innerSettings,
           ...settings
         }))
@@ -2758,24 +683,24 @@
       return getSpineItemNumberOfPages(item);
     }, 0);
     reader.spineItems$.pipe(
-      tap(
+      operators.tap(
         (items) => items.forEach(({ item }) => {
           chaptersInfo[item.id] = getChapterInfo2(item);
         })
       ),
-      takeUntil(reader.$.destroy$)
+      operators.takeUntil(reader.$.destroy$)
     ).subscribe();
     const innerPaginationExtendedInfo$ = reader.pagination$.pipe(
-      map((info) => ({
+      operators.map((info) => ({
         ...info,
         ...mapPaginationInfoToExtendedInfo(info)
       })),
-      distinctUntilChanged(isShallowEqual)
+      operators.distinctUntilChanged(isShallowEqual)
     );
     const totalPages$ = reader.$.layout$.pipe(
-      debounceTime(10, rxjs.animationFrameScheduler),
-      withLatestFrom(reader.pagination$),
-      map(() => {
+      operators.debounceTime(10, rxjs.animationFrameScheduler),
+      operators.withLatestFrom(reader.pagination$),
+      operators.map(() => {
         const numberOfPagesPerItems = getNumberOfPagesPerItems();
         return {
           numberOfPagesPerItems,
@@ -2785,21 +710,21 @@
           numberOfTotalPages: numberOfPagesPerItems.reduce((acc, numberOfPagesForItem) => acc + numberOfPagesForItem, 0)
         };
       }),
-      distinctUntilChanged(isShallowEqual),
-      startWith({
+      operators.distinctUntilChanged(isShallowEqual),
+      operators.startWith({
         numberOfPagesPerItems: [],
         numberOfTotalPages: 0
       })
     );
     const pagination$ = rxjs.combineLatest([innerPaginationExtendedInfo$, totalPages$]).pipe(
-      map(([pageInfo, totalPageInfo]) => ({
+      operators.map(([pageInfo, totalPageInfo]) => ({
         ...pageInfo,
         ...totalPageInfo,
         beginAbsolutePageIndex: totalPageInfo.numberOfPagesPerItems.slice(0, pageInfo.beginSpineItemIndex).reduce((acc, numberOfPagesForItem) => acc + numberOfPagesForItem, pageInfo.beginPageIndexInChapter ?? 0),
         endAbsolutePageIndex: totalPageInfo.numberOfPagesPerItems.slice(0, pageInfo.endSpineItemIndex).reduce((acc, numberOfPagesForItem) => acc + numberOfPagesForItem, pageInfo.endPageIndexInChapter ?? 0)
       })),
-      shareReplay(1),
-      takeUntil(reader.$.destroy$)
+      operators.shareReplay(1),
+      operators.takeUntil(reader.$.destroy$)
     );
     return {
       ...reader,
@@ -2900,14 +825,14 @@
       addStyle(`prose-reader-theme`, getStyle());
     });
     reader.spineItems$.pipe(
-      tap((items) => items.map(({ element }) => applyChangeToSpineItemElement({ container: element }))),
-      takeUntil(reader.$.destroy$)
+      operators.tap((items) => items.map(({ element }) => applyChangeToSpineItemElement({ container: element }))),
+      operators.takeUntil(reader.$.destroy$)
     ).subscribe();
     currentThemeSubject$.pipe(
-      tap(() => {
+      operators.tap(() => {
         applyChangeToSpineItem();
       }),
-      takeUntil(reader.$.destroy$)
+      operators.takeUntil(reader.$.destroy$)
     ).subscribe();
     return {
       ...reader,
@@ -3212,7 +1137,7 @@
       recompute,
       destroy,
       $: {
-        settings$: settingsSubject$.asObservable().pipe(distinctUntilChanged(isShallowEqual))
+        settings$: settingsSubject$.asObservable().pipe(operators.distinctUntilChanged(isShallowEqual))
       }
     };
   };
@@ -3283,12 +1208,12 @@
     };
     const setHasVerticalWriting = () => hasVerticalWritingSubject$.next(true);
     hasVerticalWritingSubject$.pipe(
-      skip(1),
-      distinctUntilChanged(),
-      tap(() => {
+      operators.skip(1),
+      operators.distinctUntilChanged(),
+      operators.tap(() => {
         settings.recompute({ manifest, hasVerticalWritingSubject: hasVerticalWritingSubject$.value });
       }),
-      takeUntil(destroy$)
+      operators.takeUntil(destroy$)
     ).subscribe();
     const destroy = () => {
       settings.destroy();
@@ -3327,7 +1252,7 @@
         manifest
       }),
       $: {
-        hasVerticalWriting$: hasVerticalWritingSubject$.asObservable().pipe(distinctUntilChanged()),
+        hasVerticalWriting$: hasVerticalWritingSubject$.asObservable().pipe(operators.distinctUntilChanged()),
         destroy$: destroy$.asObservable(),
         settings$: settings.$.settings$,
         load$: loadSubject$.asObservable()
@@ -3462,20 +1387,20 @@
     let onLoadHookReturns = [];
     let computedStyleAfterLoad;
     const makeItHot = (source$) => {
-      source$.pipe(takeUntil(context.$.destroy$)).subscribe();
+      source$.pipe(operators.takeUntil(context.$.destroy$)).subscribe();
       return source$;
     };
     const getHtmlFromResource = (response) => createHtmlPageFromResource(response, item);
     const waitForViewportFree$ = viewportState$.pipe(
-      filter((v) => v === `free`),
-      take(1)
+      operators.filter((v) => v === `free`),
+      operators.take(1)
     );
     const unload$ = unloadSubject$.asObservable().pipe(
       // @todo remove iframe when viewport is free
       // @todo use takeUntil(load$) when it's the case to cancel
-      withLatestFrom(frameElementSubject$),
-      filter(([_, frame]) => !!frame),
-      map(([, frame]) => {
+      operators.withLatestFrom(frameElementSubject$),
+      operators.filter(([_, frame]) => !!frame),
+      operators.map(([, frame]) => {
         onLoadHookReturns.forEach((fn) => {
           if (fn && `unsubscribe` in fn) {
             fn.unsubscribe();
@@ -3487,17 +1412,17 @@
         frame == null ? void 0 : frame.remove();
         frameElementSubject$.next(void 0);
       }),
-      share(),
-      takeUntil(destroySubject$)
+      operators.share(),
+      operators.takeUntil(destroySubject$)
     );
     const load$ = loadSubject$.asObservable().pipe(
-      withLatestFrom(isLoadedSubject$),
-      filter(([_, isLoaded]) => !isLoaded),
+      operators.withLatestFrom(isLoadedSubject$),
+      operators.filter(([_, isLoaded]) => !isLoaded),
       // let's ignore later load as long as the first one still runs
-      exhaustMap(() => {
+      operators.exhaustMap(() => {
         return createFrame$().pipe(
-          mergeMap((frame) => waitForViewportFree$.pipe(map(() => frame))),
-          mergeMap((frame) => {
+          operators.mergeMap((frame) => waitForViewportFree$.pipe(operators.map(() => frame))),
+          operators.mergeMap((frame) => {
             parent.appendChild(frame);
             frameElementSubject$.next(frame);
             if (!fetchResource && item.href.startsWith(window.location.origin) && // we have an encoding and it's a valid html
@@ -3508,14 +1433,14 @@
             } else {
               const fetchFn = fetchResource || (() => fetch(item.href));
               return rxjs.from(fetchFn(item)).pipe(
-                mergeMap((response) => getHtmlFromResource(response)),
-                tap((htmlDoc) => {
+                operators.mergeMap((response) => getHtmlFromResource(response)),
+                operators.tap((htmlDoc) => {
                   if (htmlDoc) {
                     frame == null ? void 0 : frame.setAttribute(`srcdoc`, htmlDoc);
                   }
                 }),
-                map(() => frame),
-                catchError((e) => {
+                operators.map(() => frame),
+                operators.catchError((e) => {
                   Report.error(`Error while trying to fetch or load resource for item ${item.id}`);
                   console.error(e);
                   return rxjs.of(frame);
@@ -3523,13 +1448,13 @@
               );
             }
           }),
-          mergeMap((frame) => {
+          operators.mergeMap((frame) => {
             if (!frame)
               return rxjs.EMPTY;
             return rxjs.fromEvent(frame, `load`).pipe(
-              take(1),
-              withLatestFrom(hooks$),
-              mergeMap(([_, hooks]) => {
+              operators.take(1),
+              operators.withLatestFrom(hooks$),
+              operators.mergeMap(([_, hooks]) => {
                 var _a, _b;
                 const body = (_a = frame.contentDocument) == null ? void 0 : _a.body;
                 if (!body) {
@@ -3559,24 +1484,24 @@
             );
           }),
           // we stop loading as soon as unload is requested
-          takeUntil(unloadSubject$)
+          operators.takeUntil(unloadSubject$)
         );
       }),
-      share(),
+      operators.share(),
       makeItHot,
-      takeUntil(destroySubject$)
+      operators.takeUntil(destroySubject$)
     );
     const ready$ = load$.pipe(
-      switchMap((frame) => {
+      operators.switchMap((frame) => {
         var _a;
-        return rxjs.from(((_a = frame == null ? void 0 : frame.contentDocument) == null ? void 0 : _a.fonts.ready) || rxjs.of(void 0)).pipe(takeUntil(unloadSubject$));
+        return rxjs.from(((_a = frame == null ? void 0 : frame.contentDocument) == null ? void 0 : _a.fonts.ready) || rxjs.of(void 0)).pipe(operators.takeUntil(unloadSubject$));
       }),
-      share(),
+      operators.share(),
       makeItHot,
-      takeUntil(destroySubject$)
+      operators.takeUntil(destroySubject$)
     );
-    rxjs.merge(load$.pipe(map(() => true)), unloadSubject$.pipe(map(() => false))).pipe(distinctUntilChanged(), takeUntil(destroySubject$)).subscribe(isLoadedSubject$);
-    rxjs.merge(ready$.pipe(map(() => true)), unloadSubject$.pipe(map(() => false))).pipe(distinctUntilChanged(), takeUntil(destroySubject$)).subscribe(isReadySubject$);
+    rxjs.merge(load$.pipe(operators.map(() => true)), unloadSubject$.pipe(operators.map(() => false))).pipe(operators.distinctUntilChanged(), operators.takeUntil(destroySubject$)).subscribe(isLoadedSubject$);
+    rxjs.merge(ready$.pipe(operators.map(() => true)), unloadSubject$.pipe(operators.map(() => false))).pipe(operators.distinctUntilChanged(), operators.takeUntil(destroySubject$)).subscribe(isReadySubject$);
     unload$.subscribe();
     return {
       load: () => loadSubject$.next(),
@@ -3596,7 +1521,7 @@
         unload$: unloadSubject$.asObservable(),
         loaded$: load$,
         isLoaded$: isLoadedSubject$.asObservable(),
-        isReady$: isReadySubject$.asObservable().pipe(distinctUntilChanged()),
+        isReady$: isReadySubject$.asObservable().pipe(operators.distinctUntilChanged()),
         ready$,
         unloaded$: unload$,
         frameElement$: frameElementSubject$
@@ -3672,8 +1597,8 @@
       return createHtmlPageFromResource(response, item);
     };
     const contentLayoutChange$ = rxjs.merge(
-      unloaded$.pipe(map(() => ({ isFirstLayout: false }))),
-      ready$.pipe(map(() => ({ isFirstLayout: true })))
+      unloaded$.pipe(operators.map(() => ({ isFirstLayout: false }))),
+      ready$.pipe(operators.map(() => ({ isFirstLayout: true })))
     );
     const destroy = () => {
       unload();
@@ -4003,7 +1928,7 @@
       item,
       context,
       fetchResource: (_a = context.getLoadOptions()) == null ? void 0 : _a.fetchResource,
-      hooks$: hooks$.asObservable().pipe(map((hooks) => [...hooks, ...frameHooks])),
+      hooks$: hooks$.asObservable().pipe(operators.map((hooks) => [...hooks, ...frameHooks])),
       viewportState$
     });
     containerElement.appendChild(overlayElement);
@@ -4177,8 +2102,8 @@
       }
     });
     const contentLayout$ = spineItemFrame.$.contentLayoutChange$.pipe(
-      withLatestFrom(spineItemFrame.$.isReady$),
-      map(([data, isReady]) => ({
+      operators.withLatestFrom(spineItemFrame.$.isReady$),
+      operators.map(([data, isReady]) => ({
         isFirstLayout: data.isFirstLayout,
         isReady
       }))
@@ -5681,13 +3606,13 @@
       }
       if (opts.range) {
         const range = dom.createRange();
-        const from2 = this.getFrom();
-        if (from2.relativeToNode === `before`) {
-          range.setStartBefore(from2.node, from2.offset);
-        } else if (from2.relativeToNode === `after`) {
-          range.setStartAfter(from2.node, from2.offset);
+        const from = this.getFrom();
+        if (from.relativeToNode === `before`) {
+          range.setStartBefore(from.node, from.offset);
+        } else if (from.relativeToNode === `after`) {
+          range.setStartAfter(from.node, from.offset);
         } else {
-          range.setStart(from2.node, from2.offset);
+          range.setStart(from.node, from.offset);
         }
         const to = this.getTo();
         if (to.relativeToNode === `before`) {
@@ -5794,14 +3719,14 @@
       var _a;
       (_a = spineItemManager.get(id)) == null ? void 0 : _a.manipulateSpineItem(cb);
     };
-    context.$.load$.pipe(tap(reload), takeUntil(context.$.destroy$)).subscribe();
+    context.$.load$.pipe(operators.tap(reload), operators.takeUntil(context.$.destroy$)).subscribe();
     const waitForViewportFree$ = viewportState$.pipe(
-      filter((v) => v === `free`),
-      take(1)
+      operators.filter((v) => v === `free`),
+      operators.take(1)
     );
     const adjustPagination = (position) => {
       return waitForViewportFree$.pipe(
-        tap(
+        operators.tap(
           report.measurePerformance(
             `adjustPagination`,
             1,
@@ -5853,15 +3778,15 @@
     };
     rxjs.merge(
       spineItemManager.$.focus$.pipe(
-        tap((event) => {
+        operators.tap((event) => {
           const spineItem = event.data;
           const fingerTracker$ = spineItem.fingerTracker.$;
           const selectionTracker$ = spineItem.selectionTracker.$;
           selectionSubscription == null ? void 0 : selectionSubscription.unsubscribe();
           selectionSubscription = rxjs.merge(
             selectionTracker$.pipe(
-              filter((event2) => event2.event === `selectionchange`),
-              tap((event2) => {
+              operators.filter((event2) => event2.event === `selectionchange`),
+              operators.tap((event2) => {
                 subject.next({
                   type: `onSelectionChange`,
                   data: event2.data ? createSelection(event2.data, spineItem.item) : null
@@ -5869,34 +3794,34 @@
               })
             ),
             selectionTracker$.pipe(
-              filter(({ event: event2 }) => event2 === `selectstart`),
-              switchMap(
+              operators.filter(({ event: event2 }) => event2 === `selectstart`),
+              operators.switchMap(
                 (_) => fingerTracker$.pipe(
-                  filter(({ event: event2 }) => event2 === `fingermove`),
-                  debounce(() => rxjs.interval(1e3)),
-                  takeUntil(
+                  operators.filter(({ event: event2 }) => event2 === `fingermove`),
+                  operators.debounce(() => rxjs.interval(1e3)),
+                  operators.takeUntil(
                     fingerTracker$.pipe(
-                      filter(({ event: event2 }) => event2 === `fingerout`),
-                      tap(() => {
+                      operators.filter(({ event: event2 }) => event2 === `fingerout`),
+                      operators.tap(() => {
                       })
                     )
                   ),
-                  tap(({ data }) => {
+                  operators.tap(({ data }) => {
                   })
                 )
               )
             )
           ).subscribe();
         }),
-        catchError((e) => {
+        operators.catchError((e) => {
           Report.error(e);
           return rxjs.EMPTY;
         }),
-        takeUntil(context.$.destroy$)
+        operators.takeUntil(context.$.destroy$)
       )
     ).subscribe();
     const itemUpdateOnNavigation$ = navigation$.pipe(
-      tap((data) => {
+      operators.tap((data) => {
         const time2 = report.time(`navigation`, 1);
         const currentSpineItem = spineItemManager.getFocusedSpineItem();
         const spineItemsFromPosition = spineLocator.getSpineItemsFromReadingOrderPosition(data.position);
@@ -5973,14 +3898,14 @@
         }
         time2();
       }),
-      share(),
-      takeUntil(context.$.destroy$)
+      operators.share(),
+      operators.takeUntil(context.$.destroy$)
     );
     itemUpdateOnNavigation$.pipe(
-      switchMap((data) => {
-        return adjustPagination(data.position).pipe(takeUntil(spineItemManager.$.layout$));
+      operators.switchMap((data) => {
+        return adjustPagination(data.position).pipe(operators.takeUntil(spineItemManager.$.layout$));
       }),
-      takeUntil(context.$.destroy$)
+      operators.takeUntil(context.$.destroy$)
     ).subscribe();
     rxjs.merge(
       /**
@@ -5995,10 +3920,10 @@
        */
       navigationAdjusted$
     ).pipe(
-      switchMap(() => {
+      operators.switchMap(() => {
         return waitForViewportFree$.pipe(
-          withLatestFrom(currentNavigationPosition$),
-          map(([, currentNavigationPosition]) => {
+          operators.withLatestFrom(currentNavigationPosition$),
+          operators.map(([, currentNavigationPosition]) => {
             const focusedSpineItemIndex = spineItemManager.getFocusedSpineItemIndex();
             report.log(`update contents`, { focusedSpineItemIndex });
             if (focusedSpineItemIndex === void 0)
@@ -6011,10 +3936,10 @@
               spineItemManager.loadContents([begin, end]);
             }
           }),
-          take(1)
+          operators.take(1)
         );
       }),
-      takeUntil(context.$.destroy$)
+      operators.takeUntil(context.$.destroy$)
     ).subscribe();
     return {
       element: containerElement,
@@ -6237,16 +4162,16 @@
     };
     const add = (spineItem) => {
       orderedSpineItemsSubject$.value.push(spineItem);
-      spineItem.$.contentLayout$.pipe(takeUntil(context.$.destroy$)).subscribe(() => {
+      spineItem.$.contentLayout$.pipe(operators.takeUntil(context.$.destroy$)).subscribe(() => {
         layout();
       });
       spineItem.$.loaded$.pipe(
-        tap(() => {
+        operators.tap(() => {
           if (spineItem.isUsingVerticalWriting()) {
             context.setHasVerticalWriting();
           }
         }),
-        takeUntil(context.$.destroy$)
+        operators.takeUntil(context.$.destroy$)
       ).subscribe();
       spineItem.load();
     };
@@ -6285,8 +4210,8 @@
         focus$: focus$.asObservable(),
         layout$: layout$.asObservable(),
         itemIsReady$: orderedSpineItemsSubject$.asObservable().pipe(
-          switchMap((items) => {
-            const itemsIsReady$ = items.map((item) => item.$.isReady$.pipe(map((isReady) => ({ item: item.item, isReady }))));
+          operators.switchMap((items) => {
+            const itemsIsReady$ = items.map((item) => item.$.isReady$.pipe(operators.map((isReady) => ({ item: item.item, isReady }))));
             return rxjs.merge(...itemsIsReady$);
           })
         )
@@ -6679,12 +4604,12 @@
       const midScreenPositionSafePosition = wrapPositionWithSafeEdge({ x: triggerXPosition, y: triggerYPosition });
       return getNavigationForPosition(midScreenPositionSafePosition);
     };
-    const isNavigationGoingForwardFrom = (to, from2) => {
+    const isNavigationGoingForwardFrom = (to, from) => {
       const pageTurnDirection = context.getSettings().computedPageTurnDirection;
       if (pageTurnDirection === `vertical`) {
-        return to.y > from2.y;
+        return to.y > from.y;
       }
-      return to.x > from2.x;
+      return to.x > from.x;
     };
     return {
       getNavigationForCfi,
@@ -6713,7 +4638,7 @@
   }) => {
     let lastScrollWasProgrammaticallyTriggered = false;
     const onlyUserScrollFilter = (source) => source.pipe(
-      filter(() => {
+      operators.filter(() => {
         if (lastScrollWasProgrammaticallyTriggered) {
           lastScrollWasProgrammaticallyTriggered = false;
           return false;
@@ -6730,14 +4655,14 @@
       return false;
     };
     const runOnFreePageTurnModeOnly$ = (source) => context.$.settings$.pipe(
-      map(() => context.getSettings().computedPageTurnMode),
-      distinctUntilChanged(),
-      switchMap((mode) => rxjs.iif(() => mode === `controlled`, rxjs.EMPTY, source))
+      operators.map(() => context.getSettings().computedPageTurnMode),
+      operators.distinctUntilChanged(),
+      operators.switchMap((mode) => rxjs.iif(() => mode === `controlled`, rxjs.EMPTY, source))
     );
     const userScroll$ = runOnFreePageTurnModeOnly$(rxjs.fromEvent(element, `scroll`)).pipe(
       onlyUserScrollFilter,
-      share(),
-      takeUntil(context.$.destroy$)
+      operators.share(),
+      operators.takeUntil(context.$.destroy$)
     );
     const getScaledDownPosition = ({ x, y }) => {
       const spineScaleX = spine.element.getBoundingClientRect().width / spine.element.offsetWidth;
@@ -6767,26 +4692,26 @@
       return getScaledDownPosition({ x: element.scrollLeft, y: element.scrollTop });
     };
     const navigationOnScroll$ = userScroll$.pipe(
-      debounceTime(SCROLL_FINISHED_DEBOUNCE_TIMEOUT, rxjs.animationFrameScheduler),
-      withLatestFrom(currentNavigationSubject$),
-      switchMap(() => {
+      operators.debounceTime(SCROLL_FINISHED_DEBOUNCE_TIMEOUT, rxjs.animationFrameScheduler),
+      operators.withLatestFrom(currentNavigationSubject$),
+      operators.switchMap(() => {
         const navigation = getNavigationForPosition(getScaledDownPosition({ x: element.scrollLeft, y: element.scrollTop }));
         return rxjs.of({ position: navigation, animate: false, lastUserExpectedNavigation: void 0 });
       }),
-      share()
+      operators.share()
     );
     const userScrollEnd$ = userScroll$.pipe(
-      debounceTime(SCROLL_FINISHED_DEBOUNCE_TIMEOUT, rxjs.animationFrameScheduler),
-      share(),
-      takeUntil(context.$.destroy$)
+      operators.debounceTime(SCROLL_FINISHED_DEBOUNCE_TIMEOUT, rxjs.animationFrameScheduler),
+      operators.share(),
+      operators.takeUntil(context.$.destroy$)
     );
     const state$ = rxjs.merge(
       userScroll$.pipe(
-        map(() => `start`),
-        distinctUntilChanged()
+        operators.map(() => `start`),
+        operators.distinctUntilChanged()
       ),
-      userScrollEnd$.pipe(map(() => `end`))
-    ).pipe(startWith(`end`));
+      userScrollEnd$.pipe(operators.map(() => `end`))
+    ).pipe(operators.startWith(`end`));
     return {
       destroy: () => {
       },
@@ -6821,8 +4746,8 @@
       navigationTriggerSubject$.next({ type: `spineItem`, data: { indexOrId, ...options } });
     };
     const urlNavigation$ = navigationTriggerSubject$.pipe(
-      filter((e) => e.type === `url`),
-      switchMap(({ data }) => {
+      operators.filter((e) => e.type === `url`),
+      operators.switchMap(({ data }) => {
         const navigation = navigator2.getNavigationForUrl(data);
         Report.log(NAMESPACE$2, `urlNavigation`, { data, navigation });
         if (navigation) {
@@ -6836,8 +4761,8 @@
       })
     );
     const spineItemNavigation$ = navigationTriggerSubject$.pipe(
-      filter((e) => e.type === `spineItem`),
-      switchMap(({ data: { animate, indexOrId } }) => {
+      operators.filter((e) => e.type === `spineItem`),
+      operators.switchMap(({ data: { animate, indexOrId } }) => {
         const navigation = navigator2.getNavigationForSpineIndexOrId(indexOrId);
         const lastUserExpectedNavigation = { type: `navigate-from-previous-item` };
         Report.log(NAMESPACE$2, `goToSpineItem`, { indexOrId, animate, navigation });
@@ -6845,8 +4770,8 @@
       })
     );
     const cfiNavigation$ = navigationTriggerSubject$.pipe(
-      filter((e) => e.type === `cfi`),
-      map(({ data: { animate, cfi } }) => {
+      operators.filter((e) => e.type === `cfi`),
+      operators.map(({ data: { animate, cfi } }) => {
         const navigation = navigator2.getNavigationForCfi(cfi);
         Report.log(NAMESPACE$2, `goToCfi`, { cfi, animate, navigation });
         return {
@@ -6857,8 +4782,8 @@
       })
     );
     const chapterPageNavigation$ = navigationTriggerSubject$.pipe(
-      filter((e) => e.type === `chapterPage`),
-      switchMap(({ data: { pageIndex } }) => {
+      operators.filter((e) => e.type === `chapterPage`),
+      operators.switchMap(({ data: { pageIndex } }) => {
         const spineItem = spineItemManager.getFocusedSpineItem();
         if (spineItem) {
           const navigation = navigator2.getNavigationForPage(pageIndex, spineItem);
@@ -6868,8 +4793,8 @@
       })
     );
     const pageNavigation$ = navigationTriggerSubject$.pipe(
-      filter((e) => e.type === `pageIndex`),
-      filter(() => {
+      operators.filter((e) => e.type === `pageIndex`),
+      operators.filter(() => {
         var _a;
         if (((_a = context.getManifest()) == null ? void 0 : _a.renditionLayout) === `reflowable`) {
           Report.warn(`This method only works for pre-paginated content`);
@@ -6877,7 +4802,7 @@
         }
         return true;
       }),
-      switchMap(({ data: { pageIndex } }) => {
+      operators.switchMap(({ data: { pageIndex } }) => {
         return rxjs.of({
           ...navigator2.getNavigationForPage(pageIndex),
           lastUserExpectedNavigation: void 0,
@@ -6918,9 +4843,9 @@
       }
     );
     const leftPageNavigation$ = navigationTriggerSubject$.pipe(
-      filter((e) => e.type === `leftPage`),
-      withLatestFrom(currentNavigationSubject$),
-      switchMap(
+      operators.filter((e) => e.type === `leftPage`),
+      operators.withLatestFrom(currentNavigationSubject$),
+      operators.switchMap(
         ([
           {
             data: { allowSpineItemChange }
@@ -6934,9 +4859,9 @@
       )
     );
     const rightPageNavigation$ = navigationTriggerSubject$.pipe(
-      filter((e) => e.type === `rightPage`),
-      withLatestFrom(currentNavigationSubject$),
-      switchMap(
+      operators.filter((e) => e.type === `rightPage`),
+      operators.withLatestFrom(currentNavigationSubject$),
+      operators.switchMap(
         ([
           {
             data: { allowSpineItemChange }
@@ -6963,9 +4888,9 @@
        * This is because manual navigation is not used with scroll where you can move within the same item. A manual
        * navigation would theoretically always move to different items.
        */
-      withLatestFrom(currentNavigationSubject$),
-      filter(([navigation, currentNavigation]) => navigator2.areNavigationDifferent(navigation, currentNavigation)),
-      map(([navigation]) => navigation)
+      operators.withLatestFrom(currentNavigationSubject$),
+      operators.filter(([navigation, currentNavigation]) => navigator2.areNavigationDifferent(navigation, currentNavigation)),
+      operators.map(([navigation]) => navigation)
     );
     return {
       destroy: () => {
@@ -7067,17 +4992,17 @@
       }
     );
     const snapNavigation$ = navigationTriggerSubject$.pipe(
-      filter((e) => e.type === `snap`),
+      operators.filter((e) => e.type === `snap`),
       rxjs.withLatestFrom(context.$.settings$),
-      switchMap(
+      operators.switchMap(
         ([
           {
-            data: { from: from2, to }
+            data: { from, to }
           },
           { navigationSnapThreshold }
         ]) => {
           const pageTurnDirection = context.getSettings().computedPageTurnDirection;
-          const movingForward = navigator2.isNavigationGoingForwardFrom(to, from2);
+          const movingForward = navigator2.isNavigationGoingForwardFrom(to, from);
           const triggerPercentage = movingForward ? 1 - navigationSnapThreshold : navigationSnapThreshold;
           const triggerXPosition = pageTurnDirection === `horizontal` ? to.x + context.getVisibleAreaRect().width * triggerPercentage : 0;
           const triggerYPosition = pageTurnDirection === `horizontal` ? 0 : to.y + context.getVisibleAreaRect().height * triggerPercentage;
@@ -7181,7 +5106,7 @@
     const viewportNavigatorsSharedState$ = rxjs.merge(...viewportNavigators.map(({ $: { state$: state$2 } }) => state$2));
     let lastUserExpectedNavigation;
     const makeItHot = (source$) => {
-      source$.pipe(takeUntil(context.$.destroy$)).subscribe();
+      source$.pipe(operators.takeUntil(context.$.destroy$)).subscribe();
       return source$;
     };
     const adjustReadingOffset = Report.measurePerformance(
@@ -7254,11 +5179,11 @@
     });
     const layoutChangeSettings$ = context.$.settings$.pipe(
       mapKeysTo([`computedPageTurnDirection`, `computedPageTurnMode`, `numberOfAdjacentSpineItemToPreLoad`]),
-      distinctUntilChanged(isShallowEqual),
-      skip(1)
+      operators.distinctUntilChanged(isShallowEqual),
+      operators.skip(1)
     );
     const layout$ = rxjs.merge(layoutSubject$, layoutChangeSettings$).pipe(
-      tap(() => {
+      operators.tap(() => {
         if (context.getSettings().computedPageTurnMode === `scrollable`) {
           element.style.removeProperty(`transform`);
           element.style.removeProperty(`transition`);
@@ -7273,7 +5198,7 @@
     layout$.subscribe();
     const navigation$ = rxjs.merge(
       panViewportNavigator.$.navigation$.pipe(
-        map((event) => ({
+        operators.map((event) => ({
           ...event,
           position: { x: event.x, y: event.y, spineItem: event.spineItem },
           animation: `snap`,
@@ -7281,7 +5206,7 @@
         }))
       ),
       manualViewportNavigator.$.navigation$.pipe(
-        map((event) => ({
+        operators.map((event) => ({
           ...event,
           position: { x: event.x, y: event.y, spineItem: event.spineItem },
           animation: event.animate ? `turn` : false,
@@ -7289,32 +5214,32 @@
         }))
       ),
       adjustNavigationSubject$.pipe(
-        map((event) => ({
+        operators.map((event) => ({
           ...event,
           triggeredBy: `adjust`,
           animation: event.animate ? `turn` : false
         }))
       ),
       scrollViewportNavigator.$.navigation$.pipe(
-        map((event) => ({
+        operators.map((event) => ({
           ...event,
           triggeredBy: `scroll`,
           animation: event.animate ? `turn` : false
         }))
       )
     ).pipe(
-      map((event) => {
+      operators.map((event) => {
         if (`lastUserExpectedNavigation` in event) {
           lastUserExpectedNavigation = event.lastUserExpectedNavigation;
         }
         currentNavigationPositionSubject$.next(event.position);
         return { ...event, lastUserExpectedNavigation };
       }),
-      share(),
-      takeUntil(context.$.destroy$)
+      operators.share(),
+      operators.takeUntil(context.$.destroy$)
     );
     const navigationWhichRequireManualAdjust$ = navigation$.pipe(
-      filter(({ triggeredBy }) => {
+      operators.filter(({ triggeredBy }) => {
         if (triggeredBy === `scroll` || context.getSettings().computedPageTurnMode === `scrollable` && triggeredBy === `adjust`) {
           return false;
         } else {
@@ -7323,10 +5248,10 @@
       })
     );
     const manualAdjust$ = rxjs.merge(
-      panViewportNavigator.$.moveToSubject$.asObservable().pipe(map((event) => ({ ...event, animation: false }))),
+      panViewportNavigator.$.moveToSubject$.asObservable().pipe(operators.map((event) => ({ ...event, animation: false }))),
       navigationWhichRequireManualAdjust$
     ).pipe(
-      map(({ animation, position }) => {
+      operators.map(({ animation, position }) => {
         const shouldAnimate = !(!animation || animation === `turn` && context.getSettings().computedPageTurnAnimation === `none`);
         return {
           type: `manualAdjust`,
@@ -7335,18 +5260,18 @@
           position
         };
       }),
-      share()
+      operators.share()
     );
     const processManualAdjust$ = rxjs.merge(manualAdjust$).pipe(
-      startWith(void 0),
-      pairwise(),
-      tap(([prevEvent, currentEvent]) => {
+      operators.startWith(void 0),
+      operators.pairwise(),
+      operators.tap(([prevEvent, currentEvent]) => {
         if ((prevEvent == null ? void 0 : prevEvent.type) === `manualAdjust` && (currentEvent == null ? void 0 : currentEvent.type) !== `manualAdjust`) {
           element.style.setProperty(`transition`, `none`);
           element.style.setProperty(`opacity`, `1`);
         }
       }),
-      switchMap(([, currentEvent]) => {
+      operators.switchMap(([, currentEvent]) => {
         if ((currentEvent == null ? void 0 : currentEvent.type) !== `manualAdjust`)
           return rxjs.EMPTY;
         const animationDuration = currentEvent.animation === `snap` ? context.getSettings().computedSnapAnimationDuration : context.getSettings().computedPageTurnAnimationDuration;
@@ -7360,8 +5285,8 @@
            * anything for x ms while we effectively adjust. We want it to be immediate.
            * However when user is repeatedly turning page, we can improve smoothness by delaying a bit the adjustment
            */
-          currentEvent.shouldAnimate ? delay(1, rxjs.animationFrameScheduler) : rxjs.identity,
-          tap((data) => {
+          currentEvent.shouldAnimate ? operators.delay(1, rxjs.animationFrameScheduler) : rxjs.identity,
+          operators.tap((data) => {
             const noAdjustmentNeeded = false;
             if (data.shouldAnimate && !noAdjustmentNeeded) {
               if (pageTurnAnimation === `fade`) {
@@ -7384,44 +5309,44 @@
            * need to adjust to anchor to the payload position. This is because we use viewport computed position,
            * not the value set by `setProperty`
            */
-          withLatestFrom(hooks$),
-          tap(([data, hooks]) => {
+          operators.withLatestFrom(hooks$),
+          operators.tap(([data, hooks]) => {
             if (pageTurnAnimation !== `fade`) {
               adjustReadingOffset(data.position, hooks);
             }
           }),
-          currentEvent.shouldAnimate ? delay(animationDuration / 2, rxjs.animationFrameScheduler) : rxjs.identity,
-          tap(([data, hooks]) => {
+          currentEvent.shouldAnimate ? operators.delay(animationDuration / 2, rxjs.animationFrameScheduler) : rxjs.identity,
+          operators.tap(([data, hooks]) => {
             if (pageTurnAnimation === `fade`) {
               adjustReadingOffset(data.position, hooks);
               element.style.setProperty(`opacity`, `1`);
             }
           }),
-          currentEvent.shouldAnimate ? delay(animationDuration / 2, rxjs.animationFrameScheduler) : rxjs.identity,
-          tap(([data, hooks]) => {
+          currentEvent.shouldAnimate ? operators.delay(animationDuration / 2, rxjs.animationFrameScheduler) : rxjs.identity,
+          operators.tap(([data, hooks]) => {
             if (pageTurnAnimation === `fade`) {
               adjustReadingOffset(data.position, hooks);
             }
           }),
-          takeUntil(
+          operators.takeUntil(
             viewportNavigatorsSharedState$.pipe(
-              filter((state) => state === `start`),
-              skip(1)
+              operators.filter((state) => state === `start`),
+              operators.skip(1)
             )
           )
         );
       }),
-      share(),
-      takeUntil(context.$.destroy$)
+      operators.share(),
+      operators.takeUntil(context.$.destroy$)
     );
     const adjustmentState$ = rxjs.merge(
-      rxjs.merge(manualAdjust$).pipe(map(() => `start`)),
-      rxjs.merge(processManualAdjust$).pipe(map(() => `end`))
+      rxjs.merge(manualAdjust$).pipe(operators.map(() => `start`)),
+      rxjs.merge(processManualAdjust$).pipe(operators.map(() => `end`))
     );
     const state$ = rxjs.combineLatest([...viewportNavigators.map(({ $: { state$: state$2 } }) => state$2), adjustmentState$]).pipe(
-      map((states) => states.every((state) => state === `end`) ? `free` : `busy`),
-      distinctUntilChanged(),
-      shareReplay(1),
+      operators.map((states) => states.every((state) => state === `end`) ? `free` : `busy`),
+      operators.distinctUntilChanged(),
+      operators.shareReplay(1),
       /**
        * @important
        * Since state$ is being updated from navigation$ and other exported streams we need it to be
@@ -7431,7 +5356,7 @@
       makeItHot
     );
     const waitForViewportFree$ = state$.pipe(
-      filter((v) => v === `free`),
+      operators.filter((v) => v === `free`),
       rxjs.take(1)
     );
     const navigationAdjustedAfterLayout$ = spine.$.layout$.pipe(
@@ -7453,18 +5378,18 @@
        * - do not use debounce / throttle and navigate back to the item right on the same tick
        */
       // debounceTime(10, animationFrameScheduler),
-      switchMap(
+      operators.switchMap(
         () => waitForViewportFree$.pipe(
-          switchMap(() => {
+          operators.switchMap(() => {
             const focusedSpineItem = spineItemManager.getFocusedSpineItem();
             if (!focusedSpineItem)
               return rxjs.EMPTY;
             return adjustNavigation(focusedSpineItem);
           }),
-          takeUntil(navigation$)
+          operators.takeUntil(navigation$)
         )
       ),
-      share()
+      operators.share()
     );
     const destroy = () => {
       layoutSubject$.complete();
@@ -7804,23 +5729,23 @@
       cb(element);
     };
     spine.$.$.pipe(
-      tap((event) => {
+      operators.tap((event) => {
         if (event.type === `onSelectionChange`) {
           selectionSubject$.next(event.data);
         }
       }),
-      takeUntil(destroy$)
+      operators.takeUntil(destroy$)
     ).subscribe();
     viewportNavigator.$.navigationAdjustedAfterLayout$.pipe(
       rxjs.switchMap(({ adjustedSpinePosition }) => {
-        return spine.adjustPagination(adjustedSpinePosition).pipe(takeUntil(navigation$));
+        return spine.adjustPagination(adjustedSpinePosition).pipe(operators.takeUntil(navigation$));
       }),
-      takeUntil(context.$.destroy$)
+      operators.takeUntil(context.$.destroy$)
     ).subscribe();
     rxjs.merge(context.$.load$, context.$.settings$, context.$.hasVerticalWriting$).pipe(
-      mapTo(void 0),
-      withLatestFrom(context.$.hasVerticalWriting$),
-      map(([, hasVerticalWriting]) => {
+      operators.mapTo(void 0),
+      operators.withLatestFrom(context.$.hasVerticalWriting$),
+      operators.map(([, hasVerticalWriting]) => {
         const settings2 = context.getSettings();
         const manifest = context.getManifest();
         return {
@@ -7830,8 +5755,8 @@
           computedPageTurnMode: settings2.computedPageTurnMode
         };
       }),
-      distinctUntilChanged(isShallowEqual),
-      map(
+      operators.distinctUntilChanged(isShallowEqual),
+      operators.map(
         ({
           hasVerticalWriting,
           renditionFlow,
@@ -7844,7 +5769,7 @@
           supportedPageTurnDirection: computedPageTurnMode === `scrollable` ? [`vertical`] : renditionLayout === `reflowable` ? [`horizontal`] : [`horizontal`, `vertical`]
         })
       ),
-      takeUntil(destroy$)
+      operators.takeUntil(destroy$)
     ).subscribe(stateSubject$);
     const destroy = () => {
       hooksSubject$.next([]);
@@ -8096,47 +6021,47 @@
       cache$.next({ id: itemIndexOrId, data });
     };
     cache$.asObservable().pipe(
-      mergeMap(({ id, data }) => {
+      operators.mergeMap(({ id, data }) => {
         const item = retrieveItem(id);
         if (!item)
           return rxjs.EMPTY;
         return rxjs.from(rxjs.forkJoin([openDatabase(`prose-reader`), rxjs.from(data.blob())])).pipe(
-          switchMap(([db, blob]) => {
+          operators.switchMap(([db, blob]) => {
             return rxjs.from(db.put(`${uniqueID}_${item.id}`, blob));
           }),
-          catchError((error) => {
+          operators.catchError((error) => {
             Report.error(error);
             return rxjs.EMPTY;
           })
         );
       }),
-      takeUntil(context.$.destroy$)
+      operators.takeUntil(context.$.destroy$)
     ).subscribe();
     const onLoad$ = context.$.load$.pipe(
-      tap(() => {
+      operators.tap(() => {
         uniqueID = Date.now().toString();
       })
     );
     rxjs.merge(onLoad$).pipe(
-      switchMap(() => {
+      operators.switchMap(() => {
         Report.log(`Cleanup up old cache...`);
         return rxjs.from(openDatabase(`prose-reader`)).pipe(
-          switchMap(
+          operators.switchMap(
             (db) => rxjs.from(db.keys()).pipe(
-              map((keys) => keys.filter((key) => !key.toString().startsWith(uniqueID))),
-              switchMap((keysToRemove) => {
+              operators.map((keys) => keys.filter((key) => !key.toString().startsWith(uniqueID))),
+              operators.switchMap((keysToRemove) => {
                 const promises = keysToRemove.map((key) => db.remove(key));
                 return rxjs.from(Promise.all(promises));
               })
             )
           ),
-          catchError((error) => {
+          operators.catchError((error) => {
             Report.error(error);
             return rxjs.EMPTY;
           })
         );
       }),
-      takeUntil(context.$.destroy$)
+      operators.takeUntil(context.$.destroy$)
     ).subscribe();
     const destroy = () => {
       cache$.complete();
@@ -8381,12 +6306,12 @@
       }, {})
     );
     const updateEntriesLayout$ = (entries) => rxjs.combineLatest([reader.$.layout$, reader.theme.$.theme$]).pipe(
-      map(([, theme]) => ({
+      operators.map(([, theme]) => ({
         width: reader.context.getVisibleAreaRect().width,
         theme
       })),
-      distinctUntilChanged(isShallowEqual),
-      tap(({ width, theme }) => {
+      operators.distinctUntilChanged(isShallowEqual),
+      operators.tap(({ width, theme }) => {
         Object.values(entries).forEach((element) => {
           element.style.setProperty(`max-width`, `${width}px`);
           element.style.setProperty(`color`, theme === `sepia` ? `#939393` : `rgb(202, 202, 202)`);
@@ -8394,26 +6319,26 @@
       })
     );
     const updateEntriesVisibility$ = (entries) => reader.$.itemIsReady$.pipe(
-      tap(({ item, isReady }) => {
+      operators.tap(({ item, isReady }) => {
         var _a;
         (_a = entries[item.id]) == null ? void 0 : _a.style.setProperty(`visibility`, isReady ? `hidden` : `visible`);
       })
     );
     const destroyEntries$ = (entries) => reader.$.itemsBeforeDestroy$.pipe(
-      map(() => {
+      operators.map(() => {
         Object.values(entries).forEach((element) => element.remove());
         return {};
       })
     );
     const items$ = reader.spineItems$.pipe(
-      switchMap((items) => createEntries$(items)),
-      shareReplay(1),
-      takeUntil(reader.context.$.destroy$)
+      operators.switchMap((items) => createEntries$(items)),
+      operators.shareReplay(1),
+      operators.takeUntil(reader.context.$.destroy$)
     );
     items$.pipe(
-      switchMap((entries) => rxjs.merge(rxjs.of(entries), destroyEntries$(entries))),
-      switchMap((entries) => rxjs.merge(updateEntriesLayout$(entries), updateEntriesVisibility$(entries))),
-      takeUntil(reader.$.destroy$)
+      operators.switchMap((entries) => rxjs.merge(rxjs.of(entries), destroyEntries$(entries))),
+      operators.switchMap((entries) => rxjs.merge(updateEntriesLayout$(entries), updateEntriesVisibility$(entries))),
+      operators.takeUntil(reader.$.destroy$)
     ).subscribe();
     return {
       ...reader,