/*
 *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
*****************************************************************************/
(function(m, h) {
  'object' === typeof exports && 'undefined' !== typeof module
    ? h(exports)
    : 'function' === typeof define && define.amd
    ? define('rxjs', ['exports'], h)
    : h((m.rxjs = {}));
})(this, function(m) {
  function h(b, a) {
    function c() {
      this.constructor = b;
    }
    vd(b, a);
    b.prototype =
      null === a ? Object.create(a) : ((c.prototype = a.prototype), new c());
  }
  function T(b) {
    return 'function' === typeof b;
  }
  function U(b) {
    setTimeout(function() {
      throw b;
    }, 0);
  }
  function za(b) {
    return null !== b && 'object' === typeof b;
  }
  function Wa(b) {
    return b.reduce(function(a, c) {
      return a.concat(c instanceof fa ? c.errors : c);
    }, []);
  }
  function Aa(b) {
    for (; b; ) {
      var a = b.destination,
        c = b.isStopped;
      if (b.closed || c) return !1;
      b = a && a instanceof l ? a : null;
    }
    return !0;
  }
  function N(b) {
    return b;
  }
  function Ba() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return Xa(b);
  }
  function Xa(b) {
    return 0 === b.length
      ? N
      : 1 === b.length
      ? b[0]
      : function(a) {
          return b.reduce(function(c, a) {
            return a(c);
          }, a);
        };
  }
  function Ya(b) {
    b || (b = E.Promise || Promise);
    if (!b) throw Error('no Promise impl found');
    return b;
  }
  function Ca() {
    return function(b) {
      return b.lift(new wd(b));
    };
  }
  function Za(b, a, c, d) {
    return function(e) {
      return e.lift(new xd(b, a, c, d));
    };
  }
  function V(b) {
    return b ? yd(b) : ga;
  }
  function yd(b) {
    return new g(function(a) {
      return b.schedule(function() {
        return a.complete();
      });
    });
  }
  function y(b) {
    return b && 'function' === typeof b.schedule;
  }
  function Da(b, a) {
    return new g(function(c) {
      var d = new p(),
        e = 0;
      d.add(
        a.schedule(function() {
          e === b.length
            ? c.complete()
            : (c.next(b[e++]), c.closed || d.add(this.schedule()));
        }),
      );
      return d;
    });
  }
  function ha(b, a) {
    return a ? Da(b, a) : new g($a(b));
  }
  function ia() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    a = b[b.length - 1];
    return y(a) ? (b.pop(), Da(b, a)) : ha(b);
  }
  function pa(b, a) {
    return a
      ? new g(function(c) {
          return a.schedule(zd, 0, { error: b, subscriber: c });
        })
      : new g(function(c) {
          return c.error(b);
        });
  }
  function zd(b) {
    b.subscriber.error(b.error);
  }
  function ab(b, a) {
    void 0 === a && (a = 0);
    return function(c) {
      return c.lift(new Ad(b, a));
    };
  }
  function bb(b) {
    return b in Ea ? (delete Ea[b], !0) : !1;
  }
  function H() {}
  function A(b, a) {
    return function(c) {
      if ('function' !== typeof b)
        throw new TypeError(
          'argument is not a function. Are you looking for `mapTo()`?',
        );
      return c.lift(new Bd(b, a));
    };
  }
  function cb(b, a, c) {
    if (a)
      if (y(a)) c = a;
      else
        return function() {
          for (var d = [], e = 0; e < arguments.length; e++)
            d[e] = arguments[e];
          return cb(b, c)
            .apply(void 0, d)
            .pipe(
              A(function(c) {
                return z(c) ? a.apply(void 0, c) : a(c);
              }),
            );
        };
    return function() {
      for (var a = [], e = 0; e < arguments.length; e++) a[e] = arguments[e];
      var f = this,
        k,
        v = { context: f, subject: k, callbackFunc: b, scheduler: c };
      return new g(function(d) {
        if (c) return c.schedule(Cd, 0, { args: a, subscriber: d, params: v });
        if (!k) {
          k = new W();
          try {
            b.apply(
              f,
              a.concat([
                function() {
                  for (var c = [], a = 0; a < arguments.length; a++)
                    c[a] = arguments[a];
                  k.next(1 >= c.length ? c[0] : c);
                  k.complete();
                },
              ]),
            );
          } catch (O) {
            Aa(k) ? k.error(O) : console.warn(O);
          }
        }
        return k.subscribe(d);
      });
    };
  }
  function Cd(b) {
    var a = this,
      c = b.args,
      d = b.subscriber;
    b = b.params;
    var e = b.callbackFunc,
      f = b.context,
      k = b.scheduler,
      g = b.subject;
    if (!g) {
      g = b.subject = new W();
      try {
        e.apply(
          f,
          c.concat([
            function() {
              for (var c = [], b = 0; b < arguments.length; b++)
                c[b] = arguments[b];
              a.add(
                k.schedule(Dd, 0, {
                  value: 1 >= c.length ? c[0] : c,
                  subject: g,
                }),
              );
            },
          ]),
        );
      } catch (n) {
        g.error(n);
      }
    }
    this.add(g.subscribe(d));
  }
  function Dd(b) {
    var a = b.subject;
    a.next(b.value);
    a.complete();
  }
  function db(b, a, c) {
    if (a)
      if (y(a)) c = a;
      else
        return function() {
          for (var d = [], e = 0; e < arguments.length; e++)
            d[e] = arguments[e];
          return db(b, c)
            .apply(void 0, d)
            .pipe(
              A(function(c) {
                return z(c) ? a.apply(void 0, c) : a(c);
              }),
            );
        };
    return function() {
      for (var a = [], e = 0; e < arguments.length; e++) a[e] = arguments[e];
      var f = {
        subject: void 0,
        args: a,
        callbackFunc: b,
        scheduler: c,
        context: this,
      };
      return new g(function(d) {
        var e = f.context,
          k = f.subject;
        if (c)
          return c.schedule(Ed, 0, { params: f, subscriber: d, context: e });
        if (!k) {
          k = f.subject = new W();
          try {
            b.apply(
              e,
              a.concat([
                function() {
                  for (var c = [], a = 0; a < arguments.length; a++)
                    c[a] = arguments[a];
                  (a = c.shift())
                    ? k.error(a)
                    : (k.next(1 >= c.length ? c[0] : c), k.complete());
                },
              ]),
            );
          } catch (O) {
            Aa(k) ? k.error(O) : console.warn(O);
          }
        }
        return k.subscribe(d);
      });
    };
  }
  function Ed(b) {
    var a = this,
      c = b.params,
      d = b.subscriber;
    b = b.context;
    var e = c.callbackFunc,
      f = c.args,
      k = c.scheduler,
      g = c.subject;
    if (!g) {
      g = c.subject = new W();
      try {
        e.apply(
          b,
          f.concat([
            function() {
              for (var c = [], b = 0; b < arguments.length; b++)
                c[b] = arguments[b];
              (b = c.shift())
                ? a.add(k.schedule(eb, 0, { err: b, subject: g }))
                : a.add(
                    k.schedule(Fd, 0, {
                      value: 1 >= c.length ? c[0] : c,
                      subject: g,
                    }),
                  );
            },
          ]),
        );
      } catch (n) {
        this.add(k.schedule(eb, 0, { err: n, subject: g }));
      }
    }
    this.add(g.subscribe(d));
  }
  function Fd(b) {
    var a = b.subject;
    a.next(b.value);
    a.complete();
  }
  function eb(b) {
    b.subject.error(b.err);
  }
  function fb(b) {
    return (
      !!b && 'function' !== typeof b.subscribe && 'function' === typeof b.then
    );
  }
  function I(b, a, c, d, e) {
    void 0 === e && (e = new Gd(b, c, d));
    if (!e.closed) return a instanceof g ? a.subscribe(e) : Fa(a)(e);
  }
  function Hd(b, a) {
    return new g(function(c) {
      var d = new p();
      d.add(
        a.schedule(function() {
          var e = b[X]();
          d.add(
            e.subscribe({
              next: function(b) {
                d.add(
                  a.schedule(function() {
                    return c.next(b);
                  }),
                );
              },
              error: function(b) {
                d.add(
                  a.schedule(function() {
                    return c.error(b);
                  }),
                );
              },
              complete: function() {
                d.add(
                  a.schedule(function() {
                    return c.complete();
                  }),
                );
              },
            }),
          );
        }),
      );
      return d;
    });
  }
  function Id(b, a) {
    return new g(function(c) {
      var d = new p();
      d.add(
        a.schedule(function() {
          return b.then(
            function(b) {
              d.add(
                a.schedule(function() {
                  c.next(b);
                  d.add(
                    a.schedule(function() {
                      return c.complete();
                    }),
                  );
                }),
              );
            },
            function(b) {
              d.add(
                a.schedule(function() {
                  return c.error(b);
                }),
              );
            },
          );
        }),
      );
      return d;
    });
  }
  function Jd(b, a) {
    if (!b) throw Error('Iterable cannot be null');
    return new g(function(c) {
      var d = new p(),
        e;
      d.add(function() {
        e && 'function' === typeof e.return && e.return();
      });
      d.add(
        a.schedule(function() {
          e = b[F]();
          d.add(
            a.schedule(function() {
              if (!c.closed) {
                var a, b;
                try {
                  var d = e.next();
                  a = d.value;
                  b = d.done;
                } catch (n) {
                  c.error(n);
                  return;
                }
                b ? c.complete() : (c.next(a), this.schedule());
              }
            }),
          );
        }),
      );
      return d;
    });
  }
  function Kd(b, a) {
    if (null != b) {
      if (b && 'function' === typeof b[X]) return Hd(b, a);
      if (fb(b)) return Id(b, a);
      if (gb(b)) return Da(b, a);
      if ((b && 'function' === typeof b[F]) || 'string' === typeof b)
        return Jd(b, a);
    }
    throw new TypeError(((null !== b && typeof b) || b) + ' is not observable');
  }
  function G(b, a) {
    return a ? Kd(b, a) : b instanceof g ? b : new g(Fa(b));
  }
  function u(b, a) {
    if (!a.closed) return b instanceof g ? b.subscribe(a) : Fa(b)(a);
  }
  function J(b, a, c) {
    void 0 === c && (c = Number.POSITIVE_INFINITY);
    if ('function' === typeof a)
      return function(d) {
        return d.pipe(
          J(function(c, d) {
            return G(b(c, d)).pipe(
              A(function(b, e) {
                return a(c, b, d, e);
              }),
            );
          }, c),
        );
      };
    'number' === typeof a && (c = a);
    return function(a) {
      return a.lift(new Ld(b, c));
    };
  }
  function qa(b) {
    void 0 === b && (b = Number.POSITIVE_INFINITY);
    return J(N, b);
  }
  function Ga() {
    return qa(1);
  }
  function Y() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return Ga()(ia.apply(void 0, b));
  }
  function Ha(b) {
    return new g(function(a) {
      var c;
      try {
        c = b();
      } catch (d) {
        a.error(d);
        return;
      }
      return (c ? G(c) : V()).subscribe(a);
    });
  }
  function ra(b, a) {
    return new g(function(c) {
      var d = b.length;
      if (0 === d) c.complete();
      else
        for (
          var e = Array(d),
            f = 0,
            k = 0,
            g = function(g) {
              var v = G(b[g]),
                h = !1;
              c.add(
                v.subscribe({
                  next: function(c) {
                    h || ((h = !0), k++);
                    e[g] = c;
                  },
                  error: function(a) {
                    return c.error(a);
                  },
                  complete: function() {
                    f++;
                    (f !== d && h) ||
                      (k === d &&
                        c.next(
                          a
                            ? a.reduce(function(c, a, b) {
                                return (c[a] = e[b]), c;
                              }, {})
                            : e,
                        ),
                      c.complete());
                  },
                }),
              );
            },
            h = 0;
          h < d;
          h++
        )
          g(h);
    });
  }
  function hb(b, a, c, d) {
    T(c) && ((d = c), (c = void 0));
    return d
      ? hb(b, a, c).pipe(
          A(function(c) {
            return z(c) ? d.apply(void 0, c) : d(c);
          }),
        )
      : new g(function(d) {
          ib(
            b,
            a,
            function(c) {
              1 < arguments.length
                ? d.next(Array.prototype.slice.call(arguments))
                : d.next(c);
            },
            d,
            c,
          );
        });
  }
  function ib(b, a, c, d, e) {
    var f;
    if (
      b &&
      'function' === typeof b.addEventListener &&
      'function' === typeof b.removeEventListener
    )
      b.addEventListener(a, c, e),
        (f = function() {
          return b.removeEventListener(a, c, e);
        });
    else if (b && 'function' === typeof b.on && 'function' === typeof b.off)
      b.on(a, c),
        (f = function() {
          return b.off(a, c);
        });
    else if (
      b &&
      'function' === typeof b.addListener &&
      'function' === typeof b.removeListener
    )
      b.addListener(a, c),
        (f = function() {
          return b.removeListener(a, c);
        });
    else if (b && b.length)
      for (var k = 0, g = b.length; k < g; k++) ib(b[k], a, c, d, e);
    else throw new TypeError('Invalid event target');
    d.add(f);
  }
  function jb(b, a, c) {
    return c
      ? jb(b, a).pipe(
          A(function(a) {
            return z(a) ? c.apply(void 0, a) : c(a);
          }),
        )
      : new g(function(c) {
          var d = function() {
              for (var a = [], b = 0; b < arguments.length; b++)
                a[b] = arguments[b];
              return c.next(1 === a.length ? a[0] : a);
            },
            f;
          try {
            f = b(d);
          } catch (k) {
            c.error(k);
            return;
          }
          if (T(a))
            return function() {
              return a(d, f);
            };
        });
  }
  function Pd(b) {
    var a = b.subscriber,
      c = b.condition;
    if (!a.closed) {
      if (b.needIterate)
        try {
          b.state = b.iterate(b.state);
        } catch (f) {
          a.error(f);
          return;
        }
      else b.needIterate = !0;
      if (c) {
        var d = void 0;
        try {
          d = c(b.state);
        } catch (f) {
          a.error(f);
          return;
        }
        if (!d) {
          a.complete();
          return;
        }
        if (a.closed) return;
      }
      var e;
      try {
        e = b.resultSelector(b.state);
      } catch (f) {
        a.error(f);
        return;
      }
      if (!a.closed && (a.next(e), !a.closed)) return this.schedule(b);
    }
  }
  function K(b) {
    return !z(b) && 0 <= b - parseFloat(b) + 1;
  }
  function Qd(b) {
    var a = b.subscriber,
      c = b.counter;
    b = b.period;
    a.next(c);
    this.schedule({ subscriber: a, counter: c + 1, period: b }, b);
  }
  function Ia() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    var a = Number.POSITIVE_INFINITY,
      c = null,
      d = b[b.length - 1];
    y(d)
      ? ((c = b.pop()),
        1 < b.length && 'number' === typeof b[b.length - 1] && (a = b.pop()))
      : 'number' === typeof d && (a = b.pop());
    return null === c && 1 === b.length && b[0] instanceof g
      ? b[0]
      : qa(a)(ha(b, c));
  }
  function Ja() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    if (0 === b.length) return ga;
    var c = b[0],
      d = b.slice(1);
    return 1 === b.length && z(c)
      ? Ja.apply(void 0, c)
      : new g(function(a) {
          var b = function() {
            return a.add(Ja.apply(void 0, d).subscribe(a));
          };
          return G(c).subscribe({
            next: function(c) {
              a.next(c);
            },
            error: b,
            complete: b,
          });
        });
  }
  function Rd(b) {
    var a = b.keys,
      c = b.index,
      d = b.subscriber,
      e = b.subscription;
    b = b.obj;
    if (!d.closed)
      if (c < a.length) {
        var f = a[c];
        d.next([f, b[f]]);
        e.add(
          this.schedule({
            keys: a,
            index: c + 1,
            subscriber: d,
            subscription: e,
            obj: b,
          }),
        );
      } else d.complete();
  }
  function Sd(b, a) {
    function c() {
      return !c.pred.apply(c.thisArg, arguments);
    }
    c.pred = b;
    c.thisArg = a;
    return c;
  }
  function P(b, a) {
    return function(c) {
      return c.lift(new Td(b, a));
    };
  }
  function kb() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    if (1 === b.length)
      if (z(b[0])) b = b[0];
      else return b[0];
    return ha(b, void 0).lift(new Ud());
  }
  function Vd(b) {
    var a = b.start,
      c = b.index,
      d = b.subscriber;
    c >= b.count
      ? d.complete()
      : (d.next(a),
        d.closed || ((b.index = c + 1), (b.start = a + 1), this.schedule(b)));
  }
  function lb(b, a, c) {
    void 0 === b && (b = 0);
    var d = -1;
    K(a) ? (d = (1 > Number(a) && 1) || Number(a)) : y(a) && (c = a);
    y(c) || (c = B);
    return new g(function(a) {
      var e = K(b) ? b : +b - c.now();
      return c.schedule(Wd, e, { index: 0, period: d, subscriber: a });
    });
  }
  function Wd(b) {
    var a = b.index,
      c = b.period,
      d = b.subscriber;
    d.next(a);
    if (!d.closed) {
      if (-1 === c) return d.complete();
      b.index = a + 1;
      this.schedule(b, c);
    }
  }
  function Ka() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    a = b[b.length - 1];
    'function' === typeof a && b.pop();
    return ha(b, void 0).lift(new mb(a));
  }
  function Xd(b, a) {
    void 0 === a && (a = null);
    return new Q({ method: 'GET', url: b, headers: a });
  }
  function Yd(b, a, c) {
    return new Q({ method: 'POST', url: b, body: a, headers: c });
  }
  function Zd(b, a) {
    return new Q({ method: 'DELETE', url: b, headers: a });
  }
  function $d(b, a, c) {
    return new Q({ method: 'PUT', url: b, body: a, headers: c });
  }
  function ae(b, a, c) {
    return new Q({ method: 'PATCH', url: b, body: a, headers: c });
  }
  function be(b, a) {
    return ce(
      new Q({ method: 'GET', url: b, responseType: 'json', headers: a }),
    );
  }
  function nb(b, a) {
    switch (b) {
      case 'json':
        return (
          (b =
            'response' in a
              ? a.responseType
                ? a.response
                : JSON.parse(a.response || a.responseText || 'null')
              : JSON.parse(a.responseText || 'null')),
          b
        );
      case 'xml':
        return a.responseXML;
      default:
        return 'response' in a ? a.response : a.responseText;
    }
  }
  function ob(b) {
    return new pb(b);
  }
  function qb(b) {
    void 0 === b && (b = B);
    return A(function(a) {
      return new rb(a, b.now());
    });
  }
  function Z(b, a) {
    var c = !1;
    2 <= arguments.length && (c = !0);
    return function(d) {
      return d.lift(new de(b, a, c));
    };
  }
  function sb(b) {
    void 0 === b && (b = B);
    return function(a) {
      return Ha(function() {
        return a.pipe(
          Z(
            function(c, a) {
              c = c.current;
              return { value: a, current: b.now(), last: c };
            },
            { current: b.now(), value: void 0, last: void 0 },
          ),
          A(function(c) {
            return new tb(c.value, c.current - c.last);
          }),
        );
      });
    };
  }
  function ub(b, a) {
    void 0 === a && (a = sa);
    return function(c) {
      return c.lift(new ee(b, !!a.leading, !!a.trailing));
    };
  }
  function vb(b, a) {
    for (var c = 0, d = a.length; c < d; c++)
      for (
        var e = a[c],
          f = Object.getOwnPropertyNames(e.prototype),
          k = 0,
          g = f.length;
        k < g;
        k++
      ) {
        var h = f[k];
        b.prototype[h] = e.prototype[h];
      }
  }
  function La(b) {
    return function(a) {
      return a.lift(new fe(b));
    };
  }
  function wb(b, a) {
    void 0 === a && (a = B);
    return La(function() {
      return lb(b, a);
    });
  }
  function xb(b) {
    return function(a) {
      return a.lift(new ge(b));
    };
  }
  function yb(b, a) {
    void 0 === a && (a = null);
    return function(c) {
      return c.lift(new he(b, a));
    };
  }
  function zb(b) {
    var a = arguments.length,
      c = B;
    y(arguments[arguments.length - 1]) &&
      ((c = arguments[arguments.length - 1]), a--);
    var d = null;
    2 <= a && (d = arguments[1]);
    var e = Number.POSITIVE_INFINITY;
    3 <= a && (e = arguments[2]);
    return function(a) {
      return a.lift(new ie(b, d, e, c));
    };
  }
  function Ab(b) {
    var a = b.subscriber,
      c = b.context;
    c && a.closeContext(c);
    a.closed ||
      ((b.context = a.openContext()),
      (b.context.closeAction = this.schedule(b, b.bufferTimeSpan)));
  }
  function je(b) {
    var a = b.bufferCreationInterval,
      c = b.bufferTimeSpan,
      d = b.subscriber,
      e = b.scheduler,
      f = d.openContext();
    d.closed ||
      (d.add(
        (f.closeAction = e.schedule(Bb, c, { subscriber: d, context: f })),
      ),
      this.schedule(b, a));
  }
  function Bb(b) {
    b.subscriber.closeContext(b.context);
  }
  function Cb(b, a) {
    return function(c) {
      return c.lift(new ke(b, a));
    };
  }
  function Db(b) {
    return function(a) {
      return a.lift(new le(b));
    };
  }
  function Eb(b) {
    return function(a) {
      var c = new me(b);
      a = a.lift(c);
      return (c.caught = a);
    };
  }
  function Fb(b) {
    return function(a) {
      return a.lift(new ta(b));
    };
  }
  function Ma(b, a) {
    return J(b, a, 1);
  }
  function Gb(b, a) {
    return Ma(function() {
      return b;
    }, a);
  }
  function Hb(b) {
    return function(a) {
      return a.lift(new ne(b, a));
    };
  }
  function Ib(b) {
    return function(a) {
      return a.lift(new oe(b));
    };
  }
  function Jb(b, a) {
    void 0 === a && (a = B);
    return function(c) {
      return c.lift(new pe(b, a));
    };
  }
  function qe(b) {
    b.debouncedNext();
  }
  function aa(b) {
    void 0 === b && (b = null);
    return function(a) {
      return a.lift(new re(b));
    };
  }
  function Kb(b, a) {
    void 0 === a && (a = B);
    var c = b instanceof Date && !isNaN(+b) ? +b - a.now() : Math.abs(b);
    return function(b) {
      return b.lift(new se(c, a));
    };
  }
  function Lb(b, a) {
    return a
      ? function(c) {
          return new te(c, a).lift(new Mb(b));
        }
      : function(c) {
          return c.lift(new Mb(b));
        };
  }
  function Nb() {
    return function(b) {
      return b.lift(new ue());
    };
  }
  function Ob(b, a) {
    return function(c) {
      return c.lift(new ve(b, a));
    };
  }
  function Na(b, a) {
    return function(c) {
      return c.lift(new we(b, a));
    };
  }
  function Pb(b, a) {
    return Na(function(c, d) {
      return a ? a(c[b], d[b]) : c[b] === d[b];
    });
  }
  function ua(b) {
    void 0 === b && (b = xe);
    return function(a) {
      return a.lift(new ye(b));
    };
  }
  function xe() {
    return new ja();
  }
  function va(b) {
    return function(a) {
      return 0 === b ? V() : a.lift(new ze(b));
    };
  }
  function Qb(b, a) {
    if (0 > b) throw new ba();
    var c = 2 <= arguments.length;
    return function(d) {
      return d.pipe(
        P(function(c, a) {
          return a === b;
        }),
        va(1),
        c
          ? aa(a)
          : ua(function() {
              return new ba();
            }),
      );
    };
  }
  function Rb(b, a) {
    return function(c) {
      return c.lift(new Ae(b, a, c));
    };
  }
  function Sb() {
    return function(b) {
      return b.lift(new Be());
    };
  }
  function Oa(b, a) {
    return a
      ? function(c) {
          return c.pipe(
            Oa(function(c, e) {
              return G(b(c, e)).pipe(
                A(function(b, d) {
                  return a(c, b, e, d);
                }),
              );
            }),
          );
        }
      : function(c) {
          return c.lift(new Ce(b));
        };
  }
  function Tb(b, a, c) {
    void 0 === a && (a = Number.POSITIVE_INFINITY);
    a = 1 > (a || 0) ? Number.POSITIVE_INFINITY : a;
    return function(d) {
      return d.lift(new De(b, a, c));
    };
  }
  function Ub(b) {
    return function(a) {
      return a.lift(new Ee(b));
    };
  }
  function Vb(b, a) {
    if ('function' !== typeof b)
      throw new TypeError('predicate is not a function');
    return function(c) {
      return c.lift(new Wb(b, c, !1, a));
    };
  }
  function Xb(b, a) {
    return function(c) {
      return c.lift(new Wb(b, c, !0, a));
    };
  }
  function Yb(b, a) {
    var c = 2 <= arguments.length;
    return function(d) {
      return d.pipe(
        b
          ? P(function(c, a) {
              return b(c, a, d);
            })
          : N,
        va(1),
        c
          ? aa(a)
          : ua(function() {
              return new ja();
            }),
      );
    };
  }
  function Zb() {
    return function(b) {
      return b.lift(new Fe());
    };
  }
  function $b() {
    return function(b) {
      return b.lift(new Ge());
    };
  }
  function ka(b) {
    return function(a) {
      return 0 === b ? V() : a.lift(new He(b));
    };
  }
  function ac(b, a) {
    var c = 2 <= arguments.length;
    return function(d) {
      return d.pipe(
        b
          ? P(function(c, a) {
              return b(c, a, d);
            })
          : N,
        ka(1),
        c
          ? aa(a)
          : ua(function() {
              return new ja();
            }),
      );
    };
  }
  function bc(b) {
    return function(a) {
      return a.lift(new Ie(b));
    };
  }
  function cc() {
    return function(b) {
      return b.lift(new Je());
    };
  }
  function ca(b, a) {
    return 2 <= arguments.length
      ? function(c) {
          return Ba(Z(b, a), ka(1), aa(a))(c);
        }
      : function(c) {
          return Ba(
            Z(function(c, a, f) {
              return b(c, a, f + 1);
            }),
            ka(1),
          )(c);
        };
  }
  function dc(b) {
    return ca(
      'function' === typeof b
        ? function(a, c) {
            return 0 < b(a, c) ? a : c;
          }
        : function(a, c) {
            return a > c ? a : c;
          },
    );
  }
  function ec(b, a, c) {
    void 0 === c && (c = Number.POSITIVE_INFINITY);
    if ('function' === typeof a)
      return J(
        function() {
          return b;
        },
        a,
        c,
      );
    'number' === typeof a && (c = a);
    return J(function() {
      return b;
    }, c);
  }
  function fc(b, a, c) {
    void 0 === c && (c = Number.POSITIVE_INFINITY);
    return function(d) {
      return d.lift(new Ke(b, a, c));
    };
  }
  function gc(b) {
    return ca(
      'function' === typeof b
        ? function(a, c) {
            return 0 > b(a, c) ? a : c;
          }
        : function(a, c) {
            return a < c ? a : c;
          },
    );
  }
  function L(b, a) {
    return function(c) {
      var d;
      d =
        'function' === typeof b
          ? b
          : function() {
              return b;
            };
      if ('function' === typeof a) return c.lift(new Le(d, a));
      var e = Object.create(c, Me);
      e.source = c;
      e.subjectFactory = d;
      return e;
    };
  }
  function hc() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    1 === b.length && z(b[0]) && (b = b[0]);
    return function(c) {
      return c.lift(new Ne(b));
    };
  }
  function ic() {
    return function(b) {
      return b.lift(new Oe());
    };
  }
  function jc(b, a) {
    return function(c) {
      return [P(b, a)(c), P(Sd(b, a))(c)];
    };
  }
  function kc() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    var c = b.length;
    if (0 === c) throw Error('list of properties cannot be empty.');
    return function(a) {
      return A(Pe(b, c))(a);
    };
  }
  function Pe(b, a) {
    return function(c) {
      var d = c;
      for (c = 0; c < a; c++)
        if (((d = null != d ? d[b[c]] : void 0), void 0 === d)) return;
      return d;
    };
  }
  function lc(b) {
    return b
      ? L(function() {
          return new w();
        }, b)
      : L(new w());
  }
  function mc(b) {
    return function(a) {
      return L(new nc(b))(a);
    };
  }
  function oc() {
    return function(b) {
      return L(new W())(b);
    };
  }
  function pc(b, a, c, d) {
    c && 'function' !== typeof c && (d = c);
    var e = 'function' === typeof c ? c : void 0,
      f = new da(b, a, d);
    return function(c) {
      return L(function() {
        return f;
      }, e)(c);
    };
  }
  function qc() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return function(c) {
      1 === b.length && z(b[0]) && (b = b[0]);
      return c.lift.call(kb.apply(void 0, [c].concat(b)));
    };
  }
  function rc(b) {
    void 0 === b && (b = -1);
    return function(a) {
      return 0 === b
        ? V()
        : 0 > b
        ? a.lift(new sc(-1, a))
        : a.lift(new sc(b - 1, a));
    };
  }
  function tc(b) {
    return function(a) {
      return a.lift(new Qe(b));
    };
  }
  function uc(b) {
    void 0 === b && (b = -1);
    return function(a) {
      return a.lift(new Re(b, a));
    };
  }
  function vc(b) {
    return function(a) {
      return a.lift(new Se(b, a));
    };
  }
  function wc(b) {
    return function(a) {
      return a.lift(new Te(b));
    };
  }
  function xc(b, a) {
    void 0 === a && (a = B);
    return function(c) {
      return c.lift(new Ue(b, a));
    };
  }
  function Ve(b) {
    var a = b.period;
    b.subscriber.notifyNext();
    this.schedule(b, a);
  }
  function yc(b, a) {
    return function(c) {
      return c.lift(new We(b, a));
    };
  }
  function Xe() {
    return new w();
  }
  function zc() {
    return function(b) {
      return Ca()(L(Xe)(b));
    };
  }
  function Pa(b, a, c) {
    var d;
    d =
      b && 'object' === typeof b
        ? b
        : { bufferSize: b, windowTime: a, refCount: !1, scheduler: c };
    return function(c) {
      return c.lift(Ye(d));
    };
  }
  function Ye(b) {
    var a = b.bufferSize,
      c = void 0 === a ? Number.POSITIVE_INFINITY : a,
      a = b.windowTime,
      d = void 0 === a ? Number.POSITIVE_INFINITY : a,
      e = b.refCount,
      f = b.scheduler,
      k,
      g = 0,
      h,
      l = !1,
      q = !1;
    return function(a) {
      g++;
      var b;
      !k || l
        ? ((l = !1),
          (k = new da(c, d, f)),
          (b = k.subscribe(this)),
          (h = a.subscribe({
            next: function(c) {
              k.next(c);
            },
            error: function(c) {
              l = !0;
              k.error(c);
            },
            complete: function() {
              q = !0;
              h = void 0;
              k.complete();
            },
          })))
        : (b = k.subscribe(this));
      this.add(function() {
        g--;
        b.unsubscribe();
        h && !q && e && 0 === g && (h.unsubscribe(), (k = h = void 0));
      });
    };
  }
  function Ac(b) {
    return function(a) {
      return a.lift(new Ze(b, a));
    };
  }
  function Bc(b) {
    return function(a) {
      return a.lift(new $e(b));
    };
  }
  function Cc(b) {
    return function(a) {
      return a.lift(new af(b));
    };
  }
  function Dc(b) {
    return function(a) {
      return a.lift(new bf(b));
    };
  }
  function Ec(b) {
    return function(a) {
      return a.lift(new cf(b));
    };
  }
  function Fc() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    var c = b[b.length - 1];
    return y(c)
      ? (b.pop(),
        function(a) {
          return Y(b, a, c);
        })
      : function(c) {
          return Y(b, c);
        };
  }
  function Gc(b, a) {
    void 0 === a && (a = 0);
    return function(c) {
      return c.lift(new df(b, a));
    };
  }
  function ea(b, a) {
    return 'function' === typeof a
      ? function(c) {
          return c.pipe(
            ea(function(c, e) {
              return G(b(c, e)).pipe(
                A(function(b, d) {
                  return a(c, b, e, d);
                }),
              );
            }),
          );
        }
      : function(c) {
          return c.lift(new ef(b));
        };
  }
  function Hc() {
    return ea(N);
  }
  function Ic(b, a) {
    return a
      ? ea(function() {
          return b;
        }, a)
      : ea(function() {
          return b;
        });
  }
  function Jc(b) {
    return function(a) {
      return a.lift(new ff(b));
    };
  }
  function Kc(b, a) {
    void 0 === a && (a = !1);
    return function(c) {
      return c.lift(new gf(b, a));
    };
  }
  function Lc(b, a, c) {
    return function(d) {
      return d.lift(new hf(b, a, c));
    };
  }
  function Mc(b, a, c) {
    void 0 === a && (a = B);
    void 0 === c && (c = sa);
    return function(d) {
      return d.lift(new jf(b, a, c.leading, c.trailing));
    };
  }
  function kf(b) {
    b.subscriber.clearThrottle();
  }
  function Qa(b, a, c) {
    void 0 === c && (c = B);
    return function(d) {
      var e = b instanceof Date && !isNaN(+b),
        f = e ? +b - c.now() : Math.abs(b);
      return d.lift(new lf(f, e, a, c));
    };
  }
  function Nc(b, a) {
    void 0 === a && (a = B);
    return Qa(b, pa(new Oc()), a);
  }
  function mf(b, a, c) {
    if (0 === c) return [a];
    b.push(a);
    return b;
  }
  function Pc() {
    return ca(mf, []);
  }
  function Qc(b) {
    return function(a) {
      return a.lift(new nf(b));
    };
  }
  function Rc(b, a) {
    void 0 === a && (a = 0);
    return function(c) {
      return c.lift(new of(b, a));
    };
  }
  function Sc(b, a, c, d) {
    var e = B,
      f = null,
      k = Number.POSITIVE_INFINITY;
    y(d) && (e = d);
    y(c) ? (e = c) : K(c) && (k = Number(c));
    y(a) ? (e = a) : K(a) && (f = Number(a));
    return function(c) {
      return c.lift(new pf(b, f, k, e));
    };
  }
  function qf(b) {
    var a = b.subscriber,
      c = b.windowTimeSpan,
      d = b.window;
    d && a.closeWindow(d);
    b.window = a.openWindow();
    this.schedule(b, c);
  }
  function rf(b) {
    var a = b.windowTimeSpan,
      c = b.subscriber,
      d = b.scheduler,
      e = b.windowCreationInterval,
      f = c.openWindow(),
      k = { action: this, subscription: null };
    k.subscription = d.schedule(Tc, a, {
      subscriber: c,
      window: f,
      context: k,
    });
    this.add(k.subscription);
    this.schedule(b, e);
  }
  function Tc(b) {
    var a = b.subscriber,
      c = b.window;
    (b = b.context) &&
      b.action &&
      b.subscription &&
      b.action.remove(b.subscription);
    a.closeWindow(c);
  }
  function Uc(b, a) {
    return function(c) {
      return c.lift(new sf(b, a));
    };
  }
  function Vc(b) {
    return function(a) {
      return a.lift(new tf(b));
    };
  }
  function Wc() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return function(c) {
      var a;
      'function' === typeof b[b.length - 1] && (a = b.pop());
      return c.lift(new uf(b, a));
    };
  }
  function Xc(b) {
    return function(a) {
      return a.lift(new mb(b));
    };
  }
  function Yc(b) {
    return Eb(b)(this);
  }
  function Zc(b, a, c) {
    return Lc(b, a, c)(this);
  }
  function $c(b) {
    return Ub(b)(this);
  }
  function ad(b) {
    return b(this);
  }
  function bd(b, a) {
    void 0 === a && (a = Number.POSITIVE_INFINITY);
    return J(b, a)(this);
  }
  function cd(b, a) {
    void 0 === a && (a = Number.POSITIVE_INFINITY);
    return ec(b, a)(this);
  }
  function dd() {
    return Hc()(this);
  }
  var vd =
      Object.setPrototypeOf ||
      ({ __proto__: [] } instanceof Array &&
        function(b, a) {
          b.__proto__ = a;
        }) ||
      function(b, a) {
        for (var c in a) a.hasOwnProperty(c) && (b[c] = a[c]);
      },
    vf =
      Object.assign ||
      function(b) {
        for (var a, c = 1, d = arguments.length; c < d; c++) {
          a = arguments[c];
          for (var e in a)
            Object.prototype.hasOwnProperty.call(a, e) && (b[e] = a[e]);
        }
        return b;
      },
    Ra = !1,
    E = {
      Promise: void 0,
      set useDeprecatedSynchronousErrorHandling(b) {
        b
          ? console.warn(
              'DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n' +
                Error().stack,
            )
          : Ra &&
            console.log(
              'RxJS: Back to a better error behavior. Thank you. \x3c3',
            );
        Ra = b;
      },
      get useDeprecatedSynchronousErrorHandling() {
        return Ra;
      },
    },
    wa = {
      closed: !0,
      next: function(b) {},
      error: function(b) {
        if (E.useDeprecatedSynchronousErrorHandling) throw b;
        U(b);
      },
      complete: function() {},
    },
    z = (function() {
      return (
        Array.isArray ||
        function(b) {
          return b && 'number' === typeof b.length;
        }
      );
    })(),
    fa = (function() {
      function b(a) {
        Error.call(this);
        this.message = a
          ? a.length +
            ' errors occurred during unsubscription:\n' +
            a
              .map(function(c, a) {
                return a + 1 + ') ' + c.toString();
              })
              .join('\n  ')
          : '';
        this.name = 'UnsubscriptionError';
        this.errors = a;
        return this;
      }
      b.prototype = Object.create(Error.prototype);
      return b;
    })(),
    p = (function() {
      function b(a) {
        this.closed = !1;
        this._subscriptions = this._parentOrParents = null;
        a && ((this._ctorUnsubscribe = !0), (this._unsubscribe = a));
      }
      b.prototype.unsubscribe = function() {
        var a;
        if (!this.closed) {
          var c = this._parentOrParents,
            d = this._ctorUnsubscribe,
            e = this._unsubscribe,
            f = this._subscriptions;
          this.closed = !0;
          this._subscriptions = this._parentOrParents = null;
          if (c instanceof b) c.remove(this);
          else if (null !== c)
            for (var k = 0; k < c.length; ++k) c[k].remove(this);
          if (T(e)) {
            d && (this._unsubscribe = void 0);
            try {
              e.call(this);
            } catch (v) {
              a = v instanceof fa ? Wa(v.errors) : [v];
            }
          }
          if (z(f))
            for (k = -1, c = f.length; ++k < c; )
              if (((d = f[k]), za(d)))
                try {
                  d.unsubscribe();
                } catch (v) {
                  (a = a || []),
                    v instanceof fa ? (a = a.concat(Wa(v.errors))) : a.push(v);
                }
          if (a) throw new fa(a);
        }
      };
      b.prototype.add = function(a) {
        var c = a;
        if (!a) return b.EMPTY;
        switch (typeof a) {
          case 'function':
            c = new b(a);
          case 'object':
            if (c === this || c.closed || 'function' !== typeof c.unsubscribe)
              return c;
            if (this.closed) return c.unsubscribe(), c;
            c instanceof b ||
              ((a = c), (c = new b()), (c._subscriptions = [a]));
            break;
          default:
            throw Error(
              'unrecognized teardown ' + a + ' added to Subscription.',
            );
        }
        a = c._parentOrParents;
        if (null === a) c._parentOrParents = this;
        else if (a instanceof b) {
          if (a === this) return c;
          c._parentOrParents = [a, this];
        } else if (-1 === a.indexOf(this)) a.push(this);
        else return c;
        a = this._subscriptions;
        null === a ? (this._subscriptions = [c]) : a.push(c);
        return c;
      };
      b.prototype.remove = function(a) {
        var c = this._subscriptions;
        c && ((a = c.indexOf(a)), -1 !== a && c.splice(a, 1));
      };
      b.EMPTY = (function(a) {
        a.closed = !0;
        return a;
      })(new b());
      return b;
    })(),
    la =
      'function' === typeof Symbol
        ? Symbol('rxSubscriber')
        : '@@rxSubscriber_' + Math.random(),
    l = (function(b) {
      function a(c, d, e) {
        var f = b.call(this) || this;
        f.syncErrorValue = null;
        f.syncErrorThrown = !1;
        f.syncErrorThrowable = !1;
        f.isStopped = !1;
        switch (arguments.length) {
          case 0:
            f.destination = wa;
            break;
          case 1:
            if (!c) {
              f.destination = wa;
              break;
            }
            if ('object' === typeof c) {
              c instanceof a
                ? ((f.syncErrorThrowable = c.syncErrorThrowable),
                  (f.destination = c),
                  c.add(f))
                : ((f.syncErrorThrowable = !0), (f.destination = new ed(f, c)));
              break;
            }
          default:
            (f.syncErrorThrowable = !0), (f.destination = new ed(f, c, d, e));
        }
        return f;
      }
      h(a, b);
      a.prototype[la] = function() {
        return this;
      };
      a.create = function(c, b, e) {
        c = new a(c, b, e);
        c.syncErrorThrowable = !1;
        return c;
      };
      a.prototype.next = function(c) {
        this.isStopped || this._next(c);
      };
      a.prototype.error = function(c) {
        this.isStopped || ((this.isStopped = !0), this._error(c));
      };
      a.prototype.complete = function() {
        this.isStopped || ((this.isStopped = !0), this._complete());
      };
      a.prototype.unsubscribe = function() {
        this.closed ||
          ((this.isStopped = !0), b.prototype.unsubscribe.call(this));
      };
      a.prototype._next = function(c) {
        this.destination.next(c);
      };
      a.prototype._error = function(c) {
        this.destination.error(c);
        this.unsubscribe();
      };
      a.prototype._complete = function() {
        this.destination.complete();
        this.unsubscribe();
      };
      a.prototype._unsubscribeAndRecycle = function() {
        var c = this._parentOrParents;
        this._parentOrParents = null;
        this.unsubscribe();
        this.isStopped = this.closed = !1;
        this._parentOrParents = c;
        return this;
      };
      return a;
    })(p),
    ed = (function(b) {
      function a(c, a, e, f) {
        var d = b.call(this) || this;
        d._parentSubscriber = c;
        var g;
        c = d;
        T(a)
          ? (g = a)
          : a &&
            ((g = a.next),
            (e = a.error),
            (f = a.complete),
            a !== wa &&
              ((c = Object.create(a)),
              T(c.unsubscribe) && d.add(c.unsubscribe.bind(c)),
              (c.unsubscribe = d.unsubscribe.bind(d))));
        d._context = c;
        d._next = g;
        d._error = e;
        d._complete = f;
        return d;
      }
      h(a, b);
      a.prototype.next = function(c) {
        if (!this.isStopped && this._next) {
          var a = this._parentSubscriber;
          E.useDeprecatedSynchronousErrorHandling && a.syncErrorThrowable
            ? this.__tryOrSetError(a, this._next, c) && this.unsubscribe()
            : this.__tryOrUnsub(this._next, c);
        }
      };
      a.prototype.error = function(c) {
        if (!this.isStopped) {
          var a = this._parentSubscriber,
            b = E.useDeprecatedSynchronousErrorHandling;
          if (this._error)
            b && a.syncErrorThrowable
              ? this.__tryOrSetError(a, this._error, c)
              : this.__tryOrUnsub(this._error, c),
              this.unsubscribe();
          else if (a.syncErrorThrowable)
            b ? ((a.syncErrorValue = c), (a.syncErrorThrown = !0)) : U(c),
              this.unsubscribe();
          else {
            this.unsubscribe();
            if (b) throw c;
            U(c);
          }
        }
      };
      a.prototype.complete = function() {
        var c = this;
        if (!this.isStopped) {
          var a = this._parentSubscriber;
          if (this._complete) {
            var b = function() {
              return c._complete.call(c._context);
            };
            E.useDeprecatedSynchronousErrorHandling && a.syncErrorThrowable
              ? this.__tryOrSetError(a, b)
              : this.__tryOrUnsub(b);
          }
          this.unsubscribe();
        }
      };
      a.prototype.__tryOrUnsub = function(c, a) {
        try {
          c.call(this._context, a);
        } catch (e) {
          this.unsubscribe();
          if (E.useDeprecatedSynchronousErrorHandling) throw e;
          U(e);
        }
      };
      a.prototype.__tryOrSetError = function(c, a, b) {
        if (!E.useDeprecatedSynchronousErrorHandling) throw Error('bad call');
        try {
          a.call(this._context, b);
        } catch (f) {
          return (
            E.useDeprecatedSynchronousErrorHandling
              ? ((c.syncErrorValue = f), (c.syncErrorThrown = !0))
              : U(f),
            !0
          );
        }
        return !1;
      };
      a.prototype._unsubscribe = function() {
        var c = this._parentSubscriber;
        this._parentSubscriber = this._context = null;
        c.unsubscribe();
      };
      return a;
    })(l),
    X = ('function' === typeof Symbol && Symbol.observable) || '@@observable',
    g = (function() {
      function b(a) {
        this._isScalar = !1;
        a && (this._subscribe = a);
      }
      b.prototype.lift = function(a) {
        var c = new b();
        c.source = this;
        c.operator = a;
        return c;
      };
      b.prototype.subscribe = function(a, c, b) {
        var d = this.operator;
        a: {
          if (a) {
            if (a instanceof l) break a;
            if (a[la]) {
              a = a[la]();
              break a;
            }
          }
          a = a || c || b ? new l(a, c, b) : new l(wa);
        }
        d
          ? a.add(d.call(a, this.source))
          : a.add(
              this.source ||
                (E.useDeprecatedSynchronousErrorHandling &&
                  !a.syncErrorThrowable)
                ? this._subscribe(a)
                : this._trySubscribe(a),
            );
        if (
          E.useDeprecatedSynchronousErrorHandling &&
          a.syncErrorThrowable &&
          ((a.syncErrorThrowable = !1), a.syncErrorThrown)
        )
          throw a.syncErrorValue;
        return a;
      };
      b.prototype._trySubscribe = function(a) {
        try {
          return this._subscribe(a);
        } catch (c) {
          E.useDeprecatedSynchronousErrorHandling &&
            ((a.syncErrorThrown = !0), (a.syncErrorValue = c)),
            Aa(a) ? a.error(c) : console.warn(c);
        }
      };
      b.prototype.forEach = function(a, c) {
        var b = this;
        c = Ya(c);
        return new c(function(c, d) {
          var e;
          e = b.subscribe(
            function(c) {
              try {
                a(c);
              } catch (n) {
                d(n), e && e.unsubscribe();
              }
            },
            d,
            c,
          );
        });
      };
      b.prototype._subscribe = function(a) {
        var c = this.source;
        return c && c.subscribe(a);
      };
      b.prototype[X] = function() {
        return this;
      };
      b.prototype.pipe = function() {
        for (var a = [], c = 0; c < arguments.length; c++) a[c] = arguments[c];
        return 0 === a.length ? this : Xa(a)(this);
      };
      b.prototype.toPromise = function(a) {
        var c = this;
        a = Ya(a);
        return new a(function(a, b) {
          var d;
          c.subscribe(
            function(c) {
              return (d = c);
            },
            function(c) {
              return b(c);
            },
            function() {
              return a(d);
            },
          );
        });
      };
      b.create = function(a) {
        return new b(a);
      };
      return b;
    })(),
    M = (function() {
      function b() {
        Error.call(this);
        this.message = 'object unsubscribed';
        this.name = 'ObjectUnsubscribedError';
        return this;
      }
      b.prototype = Object.create(Error.prototype);
      return b;
    })(),
    fd = (function(b) {
      function a(c, a) {
        var d = b.call(this) || this;
        d.subject = c;
        d.subscriber = a;
        d.closed = !1;
        return d;
      }
      h(a, b);
      a.prototype.unsubscribe = function() {
        if (!this.closed) {
          this.closed = !0;
          var c = this.subject,
            a = c.observers;
          this.subject = null;
          !a ||
            0 === a.length ||
            c.isStopped ||
            c.closed ||
            ((c = a.indexOf(this.subscriber)), -1 !== c && a.splice(c, 1));
        }
      };
      return a;
    })(p),
    gd = (function(b) {
      function a(c) {
        var a = b.call(this, c) || this;
        a.destination = c;
        return a;
      }
      h(a, b);
      return a;
    })(l),
    w = (function(b) {
      function a() {
        var c = b.call(this) || this;
        c.observers = [];
        c.closed = !1;
        c.isStopped = !1;
        c.hasError = !1;
        c.thrownError = null;
        return c;
      }
      h(a, b);
      a.prototype[la] = function() {
        return new gd(this);
      };
      a.prototype.lift = function(c) {
        var a = new xa(this, this);
        a.operator = c;
        return a;
      };
      a.prototype.next = function(c) {
        if (this.closed) throw new M();
        if (!this.isStopped)
          for (
            var a = this.observers, b = a.length, a = a.slice(), f = 0;
            f < b;
            f++
          )
            a[f].next(c);
      };
      a.prototype.error = function(c) {
        if (this.closed) throw new M();
        this.hasError = !0;
        this.thrownError = c;
        this.isStopped = !0;
        for (
          var a = this.observers, b = a.length, a = a.slice(), f = 0;
          f < b;
          f++
        )
          a[f].error(c);
        this.observers.length = 0;
      };
      a.prototype.complete = function() {
        if (this.closed) throw new M();
        this.isStopped = !0;
        for (
          var c = this.observers, a = c.length, c = c.slice(), b = 0;
          b < a;
          b++
        )
          c[b].complete();
        this.observers.length = 0;
      };
      a.prototype.unsubscribe = function() {
        this.closed = this.isStopped = !0;
        this.observers = null;
      };
      a.prototype._trySubscribe = function(c) {
        if (this.closed) throw new M();
        return b.prototype._trySubscribe.call(this, c);
      };
      a.prototype._subscribe = function(c) {
        if (this.closed) throw new M();
        if (this.hasError) return c.error(this.thrownError), p.EMPTY;
        if (this.isStopped) return c.complete(), p.EMPTY;
        this.observers.push(c);
        return new fd(this, c);
      };
      a.prototype.asObservable = function() {
        var c = new g();
        c.source = this;
        return c;
      };
      a.create = function(c, a) {
        return new xa(c, a);
      };
      return a;
    })(g),
    xa = (function(b) {
      function a(c, a) {
        var d = b.call(this) || this;
        d.destination = c;
        d.source = a;
        return d;
      }
      h(a, b);
      a.prototype.next = function(c) {
        var a = this.destination;
        a && a.next && a.next(c);
      };
      a.prototype.error = function(c) {
        var a = this.destination;
        a && a.error && this.destination.error(c);
      };
      a.prototype.complete = function() {
        var c = this.destination;
        c && c.complete && this.destination.complete();
      };
      a.prototype._subscribe = function(c) {
        return this.source ? this.source.subscribe(c) : p.EMPTY;
      };
      return a;
    })(w),
    wd = (function() {
      function b(a) {
        this.connectable = a;
      }
      b.prototype.call = function(a, c) {
        var b = this.connectable;
        b._refCount++;
        a = new wf(a, b);
        c = c.subscribe(a);
        a.closed || (a.connection = b.connect());
        return c;
      };
      return b;
    })(),
    wf = (function(b) {
      function a(c, a) {
        c = b.call(this, c) || this;
        c.connectable = a;
        return c;
      }
      h(a, b);
      a.prototype._unsubscribe = function() {
        var c = this.connectable;
        if (c) {
          this.connectable = null;
          var a = c._refCount;
          0 >= a
            ? (this.connection = null)
            : ((c._refCount = a - 1),
              1 < a
                ? (this.connection = null)
                : ((a = this.connection),
                  (c = c._connection),
                  (this.connection = null),
                  !c || (a && c !== a) || c.unsubscribe()));
        } else this.connection = null;
      };
      return a;
    })(l),
    hd = (function(b) {
      function a(c, a) {
        var d = b.call(this) || this;
        d.source = c;
        d.subjectFactory = a;
        d._refCount = 0;
        d._isComplete = !1;
        return d;
      }
      h(a, b);
      a.prototype._subscribe = function(c) {
        return this.getSubject().subscribe(c);
      };
      a.prototype.getSubject = function() {
        var c = this._subject;
        if (!c || c.isStopped) this._subject = this.subjectFactory();
        return this._subject;
      };
      a.prototype.connect = function() {
        var c = this._connection;
        c ||
          ((this._isComplete = !1),
          (c = this._connection = new p()),
          c.add(this.source.subscribe(new xf(this.getSubject(), this))),
          c.closed && ((this._connection = null), (c = p.EMPTY)));
        return c;
      };
      a.prototype.refCount = function() {
        return Ca()(this);
      };
      return a;
    })(g),
    Me = (function() {
      var b = hd.prototype;
      return {
        operator: { value: null },
        _refCount: { value: 0, writable: !0 },
        _subject: { value: null, writable: !0 },
        _connection: { value: null, writable: !0 },
        _subscribe: { value: b._subscribe },
        _isComplete: { value: b._isComplete, writable: !0 },
        getSubject: { value: b.getSubject },
        connect: { value: b.connect },
        refCount: { value: b.refCount },
      };
    })(),
    xf = (function(b) {
      function a(c, a) {
        c = b.call(this, c) || this;
        c.connectable = a;
        return c;
      }
      h(a, b);
      a.prototype._error = function(c) {
        this._unsubscribe();
        b.prototype._error.call(this, c);
      };
      a.prototype._complete = function() {
        this.connectable._isComplete = !0;
        this._unsubscribe();
        b.prototype._complete.call(this);
      };
      a.prototype._unsubscribe = function() {
        var c = this.connectable;
        if (c) {
          this.connectable = null;
          var a = c._connection;
          c._refCount = 0;
          c._subject = null;
          c._connection = null;
          a && a.unsubscribe();
        }
      };
      return a;
    })(gd);
  (function(b) {
    function a(c, a) {
      c = b.call(this, c) || this;
      c.connectable = a;
      return c;
    }
    h(a, b);
    a.prototype._unsubscribe = function() {
      var c = this.connectable;
      if (c) {
        this.connectable = null;
        var a = c._refCount;
        0 >= a
          ? (this.connection = null)
          : ((c._refCount = a - 1),
            1 < a
              ? (this.connection = null)
              : ((a = this.connection),
                (c = c._connection),
                (this.connection = null),
                !c || (a && c !== a) || c.unsubscribe()));
      } else this.connection = null;
    };
    return a;
  })(l);
  var xd = (function() {
      function b(a, c, b, e) {
        this.keySelector = a;
        this.elementSelector = c;
        this.durationSelector = b;
        this.subjectSelector = e;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new yf(
            a,
            this.keySelector,
            this.elementSelector,
            this.durationSelector,
            this.subjectSelector,
          ),
        );
      };
      return b;
    })(),
    yf = (function(b) {
      function a(c, a, e, f, k) {
        c = b.call(this, c) || this;
        c.keySelector = a;
        c.elementSelector = e;
        c.durationSelector = f;
        c.subjectSelector = k;
        c.groups = null;
        c.attemptedToUnsubscribe = !1;
        c.count = 0;
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        var a;
        try {
          a = this.keySelector(c);
        } catch (e) {
          this.error(e);
          return;
        }
        this._group(c, a);
      };
      a.prototype._group = function(c, a) {
        var b = this.groups;
        b || (b = this.groups = new Map());
        var d = b.get(a),
          k;
        if (this.elementSelector)
          try {
            k = this.elementSelector(c);
          } catch (v) {
            this.error(v);
          }
        else k = c;
        if (
          !d &&
          ((d = this.subjectSelector ? this.subjectSelector() : new w()),
          b.set(a, d),
          (c = new id(a, d, this)),
          this.destination.next(c),
          this.durationSelector)
        ) {
          c = void 0;
          try {
            c = this.durationSelector(new id(a, d));
          } catch (v) {
            this.error(v);
            return;
          }
          this.add(c.subscribe(new zf(a, d, this)));
        }
        d.closed || d.next(k);
      };
      a.prototype._error = function(c) {
        var a = this.groups;
        a &&
          (a.forEach(function(a, b) {
            a.error(c);
          }),
          a.clear());
        this.destination.error(c);
      };
      a.prototype._complete = function() {
        var c = this.groups;
        c &&
          (c.forEach(function(c, a) {
            c.complete();
          }),
          c.clear());
        this.destination.complete();
      };
      a.prototype.removeGroup = function(c) {
        this.groups.delete(c);
      };
      a.prototype.unsubscribe = function() {
        this.closed ||
          ((this.attemptedToUnsubscribe = !0),
          0 === this.count && b.prototype.unsubscribe.call(this));
      };
      return a;
    })(l),
    zf = (function(b) {
      function a(c, a, e) {
        var d = b.call(this, a) || this;
        d.key = c;
        d.group = a;
        d.parent = e;
        return d;
      }
      h(a, b);
      a.prototype._next = function(c) {
        this.complete();
      };
      a.prototype._unsubscribe = function() {
        var c = this.parent,
          a = this.key;
        this.key = this.parent = null;
        c && c.removeGroup(a);
      };
      return a;
    })(l),
    id = (function(b) {
      function a(c, a, e) {
        var d = b.call(this) || this;
        d.key = c;
        d.groupSubject = a;
        d.refCountSubscription = e;
        return d;
      }
      h(a, b);
      a.prototype._subscribe = function(c) {
        var a = new p(),
          b = this.refCountSubscription,
          f = this.groupSubject;
        b && !b.closed && a.add(new Af(b));
        a.add(f.subscribe(c));
        return a;
      };
      return a;
    })(g),
    Af = (function(b) {
      function a(c) {
        var a = b.call(this) || this;
        a.parent = c;
        c.count++;
        return a;
      }
      h(a, b);
      a.prototype.unsubscribe = function() {
        var c = this.parent;
        c.closed ||
          this.closed ||
          (b.prototype.unsubscribe.call(this),
          --c.count,
          0 === c.count && c.attemptedToUnsubscribe && c.unsubscribe());
      };
      return a;
    })(p),
    nc = (function(b) {
      function a(c) {
        var a = b.call(this) || this;
        a._value = c;
        return a;
      }
      h(a, b);
      Object.defineProperty(a.prototype, 'value', {
        get: function() {
          return this.getValue();
        },
        enumerable: !0,
        configurable: !0,
      });
      a.prototype._subscribe = function(c) {
        var a = b.prototype._subscribe.call(this, c);
        a && !a.closed && c.next(this._value);
        return a;
      };
      a.prototype.getValue = function() {
        if (this.hasError) throw this.thrownError;
        if (this.closed) throw new M();
        return this._value;
      };
      a.prototype.next = function(c) {
        b.prototype.next.call(this, (this._value = c));
      };
      return a;
    })(w),
    ma = (function(b) {
      function a(c, a) {
        var d = b.call(this, c, a) || this;
        d.scheduler = c;
        d.work = a;
        d.pending = !1;
        return d;
      }
      h(a, b);
      a.prototype.schedule = function(c, a) {
        void 0 === a && (a = 0);
        if (this.closed) return this;
        this.state = c;
        c = this.id;
        var b = this.scheduler;
        null != c && (this.id = this.recycleAsyncId(b, c, a));
        this.pending = !0;
        this.delay = a;
        this.id = this.id || this.requestAsyncId(b, this.id, a);
        return this;
      };
      a.prototype.requestAsyncId = function(c, a, b) {
        void 0 === b && (b = 0);
        return setInterval(c.flush.bind(c, this), b);
      };
      a.prototype.recycleAsyncId = function(c, a, b) {
        void 0 === b && (b = 0);
        if (null !== b && this.delay === b && !1 === this.pending) return a;
        clearInterval(a);
      };
      a.prototype.execute = function(c, a) {
        if (this.closed) return Error('executing a cancelled action');
        this.pending = !1;
        if ((c = this._execute(c, a))) return c;
        !1 === this.pending &&
          null != this.id &&
          (this.id = this.recycleAsyncId(this.scheduler, this.id, null));
      };
      a.prototype._execute = function(c, a) {
        a = !1;
        var b = void 0;
        try {
          this.work(c);
        } catch (f) {
          (a = !0), (b = (!!f && f) || Error(f));
        }
        if (a) return this.unsubscribe(), b;
      };
      a.prototype._unsubscribe = function() {
        var c = this.id,
          a = this.scheduler,
          b = a.actions,
          f = b.indexOf(this);
        this.state = this.work = null;
        this.pending = !1;
        this.scheduler = null;
        -1 !== f && b.splice(f, 1);
        null != c && (this.id = this.recycleAsyncId(a, c, null));
        this.delay = null;
      };
      return a;
    })(
      (function(b) {
        function a(c, a) {
          return b.call(this) || this;
        }
        h(a, b);
        a.prototype.schedule = function(c, a) {
          return this;
        };
        return a;
      })(p),
    ),
    Bf = (function(b) {
      function a(c, a) {
        var d = b.call(this, c, a) || this;
        d.scheduler = c;
        d.work = a;
        return d;
      }
      h(a, b);
      a.prototype.schedule = function(c, a) {
        void 0 === a && (a = 0);
        if (0 < a) return b.prototype.schedule.call(this, c, a);
        this.delay = a;
        this.state = c;
        this.scheduler.flush(this);
        return this;
      };
      a.prototype.execute = function(c, a) {
        return 0 < a || this.closed
          ? b.prototype.execute.call(this, c, a)
          : this._execute(c, a);
      };
      a.prototype.requestAsyncId = function(c, a, e) {
        void 0 === e && (e = 0);
        return (null !== e && 0 < e) || (null === e && 0 < this.delay)
          ? b.prototype.requestAsyncId.call(this, c, a, e)
          : c.flush(this);
      };
      return a;
    })(ma),
    jd = (function() {
      function b(a, c) {
        void 0 === c && (c = b.now);
        this.SchedulerAction = a;
        this.now = c;
      }
      b.prototype.schedule = function(a, c, b) {
        void 0 === c && (c = 0);
        return new this.SchedulerAction(this, a).schedule(b, c);
      };
      b.now = function() {
        return Date.now();
      };
      return b;
    })(),
    R = (function(b) {
      function a(c, d) {
        void 0 === d && (d = jd.now);
        var e =
          b.call(this, c, function() {
            return a.delegate && a.delegate !== e ? a.delegate.now() : d();
          }) || this;
        e.actions = [];
        e.active = !1;
        e.scheduled = void 0;
        return e;
      }
      h(a, b);
      a.prototype.schedule = function(c, d, e) {
        void 0 === d && (d = 0);
        return a.delegate && a.delegate !== this
          ? a.delegate.schedule(c, d, e)
          : b.prototype.schedule.call(this, c, d, e);
      };
      a.prototype.flush = function(c) {
        var a = this.actions;
        if (this.active) a.push(c);
        else {
          var b;
          this.active = !0;
          do if ((b = c.execute(c.state, c.delay))) break;
          while ((c = a.shift()));
          this.active = !1;
          if (b) {
            for (; (c = a.shift()); ) c.unsubscribe();
            throw b;
          }
        }
      };
      return a;
    })(jd),
    kd = new ((function(b) {
      function a() {
        return (null !== b && b.apply(this, arguments)) || this;
      }
      h(a, b);
      return a;
    })(R))(Bf),
    ga = new g(function(b) {
      return b.complete();
    }),
    $a = function(b) {
      return function(a) {
        for (var c = 0, d = b.length; c < d && !a.closed; c++) a.next(b[c]);
        a.complete();
      };
    },
    ld;
  (function(b) {
    b.NEXT = 'N';
    b.ERROR = 'E';
    b.COMPLETE = 'C';
  })(ld || (ld = {}));
  var x = (function() {
      function b(a, c, b) {
        this.kind = a;
        this.value = c;
        this.error = b;
        this.hasValue = 'N' === a;
      }
      b.prototype.observe = function(a) {
        switch (this.kind) {
          case 'N':
            return a.next && a.next(this.value);
          case 'E':
            return a.error && a.error(this.error);
          case 'C':
            return a.complete && a.complete();
        }
      };
      b.prototype.do = function(a, c, b) {
        switch (this.kind) {
          case 'N':
            return a && a(this.value);
          case 'E':
            return c && c(this.error);
          case 'C':
            return b && b();
        }
      };
      b.prototype.accept = function(a, c, b) {
        return a && 'function' === typeof a.next
          ? this.observe(a)
          : this.do(a, c, b);
      };
      b.prototype.toObservable = function() {
        switch (this.kind) {
          case 'N':
            return ia(this.value);
          case 'E':
            return pa(this.error);
          case 'C':
            return V();
        }
        throw Error('unexpected notification kind value');
      };
      b.createNext = function(a) {
        return 'undefined' !== typeof a
          ? new b('N', a)
          : b.undefinedValueNotification;
      };
      b.createError = function(a) {
        return new b('E', void 0, a);
      };
      b.createComplete = function() {
        return b.completeNotification;
      };
      b.completeNotification = new b('C');
      b.undefinedValueNotification = new b('N', void 0);
      return b;
    })(),
    Ad = (function() {
      function b(a, c) {
        void 0 === c && (c = 0);
        this.scheduler = a;
        this.delay = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new md(a, this.scheduler, this.delay));
      };
      return b;
    })(),
    md = (function(b) {
      function a(c, a, e) {
        void 0 === e && (e = 0);
        c = b.call(this, c) || this;
        c.scheduler = a;
        c.delay = e;
        return c;
      }
      h(a, b);
      a.dispatch = function(c) {
        c.notification.observe(c.destination);
        this.unsubscribe();
      };
      a.prototype.scheduleMessage = function(c) {
        this.destination.add(
          this.scheduler.schedule(
            a.dispatch,
            this.delay,
            new Cf(c, this.destination),
          ),
        );
      };
      a.prototype._next = function(c) {
        this.scheduleMessage(x.createNext(c));
      };
      a.prototype._error = function(c) {
        this.scheduleMessage(x.createError(c));
        this.unsubscribe();
      };
      a.prototype._complete = function() {
        this.scheduleMessage(x.createComplete());
        this.unsubscribe();
      };
      return a;
    })(l),
    Cf = (function() {
      return function(b, a) {
        this.notification = b;
        this.destination = a;
      };
    })(),
    da = (function(b) {
      function a(c, a, e) {
        void 0 === c && (c = Number.POSITIVE_INFINITY);
        void 0 === a && (a = Number.POSITIVE_INFINITY);
        var d = b.call(this) || this;
        d.scheduler = e;
        d._events = [];
        d._infiniteTimeWindow = !1;
        d._bufferSize = 1 > c ? 1 : c;
        d._windowTime = 1 > a ? 1 : a;
        a === Number.POSITIVE_INFINITY
          ? ((d._infiniteTimeWindow = !0), (d.next = d.nextInfiniteTimeWindow))
          : (d.next = d.nextTimeWindow);
        return d;
      }
      h(a, b);
      a.prototype.nextInfiniteTimeWindow = function(c) {
        if (!this.isStopped) {
          var a = this._events;
          a.push(c);
          a.length > this._bufferSize && a.shift();
        }
        b.prototype.next.call(this, c);
      };
      a.prototype.nextTimeWindow = function(c) {
        this.isStopped ||
          (this._events.push(new Df(this._getNow(), c)),
          this._trimBufferThenGetEvents());
        b.prototype.next.call(this, c);
      };
      a.prototype._subscribe = function(c) {
        var a = this._infiniteTimeWindow,
          b = a ? this._events : this._trimBufferThenGetEvents(),
          f = this.scheduler,
          k = b.length,
          g;
        if (this.closed) throw new M();
        this.isStopped || this.hasError
          ? (g = p.EMPTY)
          : (this.observers.push(c), (g = new fd(this, c)));
        f && c.add((c = new md(c, f)));
        if (a) for (a = 0; a < k && !c.closed; a++) c.next(b[a]);
        else for (a = 0; a < k && !c.closed; a++) c.next(b[a].value);
        this.hasError
          ? c.error(this.thrownError)
          : this.isStopped && c.complete();
        return g;
      };
      a.prototype._getNow = function() {
        return (this.scheduler || kd).now();
      };
      a.prototype._trimBufferThenGetEvents = function() {
        for (
          var c = this._getNow(),
            a = this._bufferSize,
            b = this._windowTime,
            f = this._events,
            k = f.length,
            g = 0;
          g < k && !(c - f[g].time < b);

        )
          g++;
        k > a && (g = Math.max(g, k - a));
        0 < g && f.splice(0, g);
        return f;
      };
      return a;
    })(w),
    Df = (function() {
      return function(b, a) {
        this.time = b;
        this.value = a;
      };
    })(),
    W = (function(b) {
      function a() {
        var c = (null !== b && b.apply(this, arguments)) || this;
        c.value = null;
        c.hasNext = !1;
        c.hasCompleted = !1;
        return c;
      }
      h(a, b);
      a.prototype._subscribe = function(c) {
        return this.hasError
          ? (c.error(this.thrownError), p.EMPTY)
          : this.hasCompleted && this.hasNext
          ? (c.next(this.value), c.complete(), p.EMPTY)
          : b.prototype._subscribe.call(this, c);
      };
      a.prototype.next = function(c) {
        this.hasCompleted || ((this.value = c), (this.hasNext = !0));
      };
      a.prototype.error = function(c) {
        this.hasCompleted || b.prototype.error.call(this, c);
      };
      a.prototype.complete = function() {
        this.hasCompleted = !0;
        this.hasNext && b.prototype.next.call(this, this.value);
        b.prototype.complete.call(this);
      };
      return a;
    })(w),
    Ef = 1,
    Ff = Promise.resolve(),
    Ea = {},
    nd = {
      setImmediate: function(b) {
        var a = Ef++;
        Ea[a] = !0;
        Ff.then(function() {
          return bb(a) && b();
        });
        return a;
      },
      clearImmediate: function(b) {
        bb(b);
      },
    },
    Gf = (function(b) {
      function a(c, a) {
        var d = b.call(this, c, a) || this;
        d.scheduler = c;
        d.work = a;
        return d;
      }
      h(a, b);
      a.prototype.requestAsyncId = function(c, a, e) {
        void 0 === e && (e = 0);
        if (null !== e && 0 < e)
          return b.prototype.requestAsyncId.call(this, c, a, e);
        c.actions.push(this);
        return (
          c.scheduled || (c.scheduled = nd.setImmediate(c.flush.bind(c, null)))
        );
      };
      a.prototype.recycleAsyncId = function(c, a, e) {
        void 0 === e && (e = 0);
        if ((null !== e && 0 < e) || (null === e && 0 < this.delay))
          return b.prototype.recycleAsyncId.call(this, c, a, e);
        0 === c.actions.length &&
          (nd.clearImmediate(a), (c.scheduled = void 0));
      };
      return a;
    })(ma),
    ya = new ((function(b) {
      function a() {
        return (null !== b && b.apply(this, arguments)) || this;
      }
      h(a, b);
      a.prototype.flush = function(c) {
        this.active = !0;
        this.scheduled = void 0;
        var a = this.actions,
          b,
          f = -1,
          k = a.length;
        c = c || a.shift();
        do if ((b = c.execute(c.state, c.delay))) break;
        while (++f < k && (c = a.shift()));
        this.active = !1;
        if (b) {
          for (; ++f < k && (c = a.shift()); ) c.unsubscribe();
          throw b;
        }
      };
      return a;
    })(R))(Gf),
    D = new R(ma),
    B = D,
    Hf = (function(b) {
      function a(c, a) {
        var d = b.call(this, c, a) || this;
        d.scheduler = c;
        d.work = a;
        return d;
      }
      h(a, b);
      a.prototype.requestAsyncId = function(c, a, e) {
        void 0 === e && (e = 0);
        if (null !== e && 0 < e)
          return b.prototype.requestAsyncId.call(this, c, a, e);
        c.actions.push(this);
        return (
          c.scheduled ||
          (c.scheduled = requestAnimationFrame(function() {
            return c.flush(null);
          }))
        );
      };
      a.prototype.recycleAsyncId = function(c, a, e) {
        void 0 === e && (e = 0);
        if ((null !== e && 0 < e) || (null === e && 0 < this.delay))
          return b.prototype.recycleAsyncId.call(this, c, a, e);
        0 === c.actions.length &&
          (cancelAnimationFrame(a), (c.scheduled = void 0));
      };
      return a;
    })(ma),
    If = new ((function(b) {
      function a() {
        return (null !== b && b.apply(this, arguments)) || this;
      }
      h(a, b);
      a.prototype.flush = function(c) {
        this.active = !0;
        this.scheduled = void 0;
        var a = this.actions,
          b,
          f = -1,
          k = a.length;
        c = c || a.shift();
        do if ((b = c.execute(c.state, c.delay))) break;
        while (++f < k && (c = a.shift()));
        this.active = !1;
        if (b) {
          for (; ++f < k && (c = a.shift()); ) c.unsubscribe();
          throw b;
        }
      };
      return a;
    })(R))(Hf),
    pd = (function(b) {
      function a(c, a) {
        void 0 === c && (c = od);
        void 0 === a && (a = Number.POSITIVE_INFINITY);
        var d =
          b.call(this, c, function() {
            return d.frame;
          }) || this;
        d.maxFrames = a;
        d.frame = 0;
        d.index = -1;
        return d;
      }
      h(a, b);
      a.prototype.flush = function() {
        for (
          var c = this.actions, a = this.maxFrames, b, f;
          (f = c[0]) &&
          f.delay <= a &&
          !(c.shift(),
          (this.frame = f.delay),
          (b = f.execute(f.state, f.delay)));

        );
        if (b) {
          for (; (f = c.shift()); ) f.unsubscribe();
          throw b;
        }
      };
      a.frameTimeFactor = 10;
      return a;
    })(R),
    od = (function(b) {
      function a(c, a, e) {
        void 0 === e && (e = c.index += 1);
        var d = b.call(this, c, a) || this;
        d.scheduler = c;
        d.work = a;
        d.index = e;
        d.active = !0;
        d.index = c.index = e;
        return d;
      }
      h(a, b);
      a.prototype.schedule = function(c, d) {
        void 0 === d && (d = 0);
        if (!this.id) return b.prototype.schedule.call(this, c, d);
        this.active = !1;
        var e = new a(this.scheduler, this.work);
        this.add(e);
        return e.schedule(c, d);
      };
      a.prototype.requestAsyncId = function(c, b, e) {
        void 0 === e && (e = 0);
        this.delay = c.frame + e;
        c = c.actions;
        c.push(this);
        c.sort(a.sortActions);
        return !0;
      };
      a.prototype.recycleAsyncId = function(c, a, b) {};
      a.prototype._execute = function(c, a) {
        if (!0 === this.active) return b.prototype._execute.call(this, c, a);
      };
      a.sortActions = function(c, a) {
        return c.delay === a.delay
          ? c.index === a.index
            ? 0
            : c.index > a.index
            ? 1
            : -1
          : c.delay > a.delay
          ? 1
          : -1;
      };
      return a;
    })(ma),
    ba = (function() {
      function b() {
        Error.call(this);
        this.message = 'argument out of range';
        this.name = 'ArgumentOutOfRangeError';
        return this;
      }
      b.prototype = Object.create(Error.prototype);
      return b;
    })(),
    ja = (function() {
      function b() {
        Error.call(this);
        this.message = 'no elements in sequence';
        this.name = 'EmptyError';
        return this;
      }
      b.prototype = Object.create(Error.prototype);
      return b;
    })(),
    Oc = (function() {
      function b() {
        Error.call(this);
        this.message = 'Timeout has occurred';
        this.name = 'TimeoutError';
        return this;
      }
      b.prototype = Object.create(Error.prototype);
      return b;
    })(),
    Bd = (function() {
      function b(a, c) {
        this.project = a;
        this.thisArg = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Jf(a, this.project, this.thisArg));
      };
      return b;
    })(),
    Jf = (function(b) {
      function a(c, a, e) {
        c = b.call(this, c) || this;
        c.project = a;
        c.count = 0;
        c.thisArg = e || c;
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        var a;
        try {
          a = this.project.call(this.thisArg, c, this.count++);
        } catch (e) {
          this.destination.error(e);
          return;
        }
        this.destination.next(a);
      };
      return a;
    })(l),
    S = (function(b) {
      function a() {
        return (null !== b && b.apply(this, arguments)) || this;
      }
      h(a, b);
      a.prototype.notifyNext = function(c, a, b, f, k) {
        this.destination.next(a);
      };
      a.prototype.notifyError = function(c, a) {
        this.destination.error(c);
      };
      a.prototype.notifyComplete = function(c) {
        this.destination.complete();
      };
      return a;
    })(l),
    Gd = (function(b) {
      function a(c, a, e) {
        var d = b.call(this) || this;
        d.parent = c;
        d.outerValue = a;
        d.outerIndex = e;
        d.index = 0;
        return d;
      }
      h(a, b);
      a.prototype._next = function(c) {
        this.parent.notifyNext(
          this.outerValue,
          c,
          this.outerIndex,
          this.index++,
          this,
        );
      };
      a.prototype._error = function(c) {
        this.parent.notifyError(c, this);
        this.unsubscribe();
      };
      a.prototype._complete = function() {
        this.parent.notifyComplete(this);
        this.unsubscribe();
      };
      return a;
    })(l),
    Kf = function(b) {
      return function(a) {
        b.then(
          function(c) {
            a.closed || (a.next(c), a.complete());
          },
          function(c) {
            return a.error(c);
          },
        ).then(null, U);
        return a;
      };
    },
    F;
  F =
    'function' === typeof Symbol && Symbol.iterator
      ? Symbol.iterator
      : '@@iterator';
  var Lf = function(b) {
      return function(a) {
        var c = b[F]();
        do {
          var d = void 0;
          try {
            d = c.next();
          } catch (e) {
            return a.error(e), a;
          }
          if (d.done) {
            a.complete();
            break;
          }
          a.next(d.value);
          if (a.closed) break;
        } while (1);
        'function' === typeof c.return &&
          a.add(function() {
            c.return && c.return();
          });
        return a;
      };
    },
    Mf = function(b) {
      return function(a) {
        var c = b[X]();
        if ('function' !== typeof c.subscribe)
          throw new TypeError(
            'Provided object does not correctly implement Symbol.observable',
          );
        return c.subscribe(a);
      };
    },
    gb = function(b) {
      return b && 'number' === typeof b.length && 'function' !== typeof b;
    },
    Fa = function(b) {
      if (b && 'function' === typeof b[X]) return Mf(b);
      if (gb(b)) return $a(b);
      if (fb(b)) return Kf(b);
      if (b && 'function' === typeof b[F]) return Lf(b);
      b = za(b) ? 'an invalid object' : "'" + b + "'";
      throw new TypeError(
        'You provided ' +
          b +
          ' where a stream was expected. You can provide an Observable, Promise, Array, or Iterable.',
      );
    },
    qd = {},
    ta = (function() {
      function b(a) {
        this.resultSelector = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Nf(a, this.resultSelector));
      };
      return b;
    })(),
    Nf = (function(b) {
      function a(c, a) {
        c = b.call(this, c) || this;
        c.resultSelector = a;
        c.active = 0;
        c.values = [];
        c.observables = [];
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        this.values.push(qd);
        this.observables.push(c);
      };
      a.prototype._complete = function() {
        var c = this.observables,
          a = c.length;
        if (0 === a) this.destination.complete();
        else {
          this.toRespond = this.active = a;
          for (var b = 0; b < a; b++) this.add(I(this, c[b], void 0, b));
        }
      };
      a.prototype.notifyComplete = function(c) {
        0 === --this.active && this.destination.complete();
      };
      a.prototype.notifyNext = function(c, a, b) {
        c = this.values;
        var d = c[b],
          d = this.toRespond
            ? d === qd
              ? --this.toRespond
              : this.toRespond
            : 0;
        c[b] = a;
        0 === d &&
          (this.resultSelector
            ? this._tryResultSelector(c)
            : this.destination.next(c.slice()));
      };
      a.prototype._tryResultSelector = function(c) {
        var a;
        try {
          a = this.resultSelector.apply(this, c);
        } catch (e) {
          this.destination.error(e);
          return;
        }
        this.destination.next(a);
      };
      return a;
    })(S),
    t = (function(b) {
      function a(c) {
        var a = b.call(this) || this;
        a.parent = c;
        return a;
      }
      h(a, b);
      a.prototype._next = function(c) {
        this.parent.notifyNext(c);
      };
      a.prototype._error = function(c) {
        this.parent.notifyError(c);
        this.unsubscribe();
      };
      a.prototype._complete = function() {
        this.parent.notifyComplete();
        this.unsubscribe();
      };
      return a;
    })(l);
  (function(b) {
    function a(c, a, e) {
      var d = b.call(this) || this;
      d.parent = c;
      d.outerValue = a;
      d.outerIndex = e;
      return d;
    }
    h(a, b);
    a.prototype._next = function(c) {
      this.parent.notifyNext(this.outerValue, c, this.outerIndex, this);
    };
    a.prototype._error = function(c) {
      this.parent.notifyError(c);
      this.unsubscribe();
    };
    a.prototype._complete = function() {
      this.parent.notifyComplete(this);
      this.unsubscribe();
    };
    return a;
  })(l);
  var r = (function(b) {
    function a() {
      return (null !== b && b.apply(this, arguments)) || this;
    }
    h(a, b);
    a.prototype.notifyNext = function(c) {
      this.destination.next(c);
    };
    a.prototype.notifyError = function(c) {
      this.destination.error(c);
    };
    a.prototype.notifyComplete = function() {
      this.destination.complete();
    };
    return a;
  })(l);
  (function(b) {
    function a() {
      return (null !== b && b.apply(this, arguments)) || this;
    }
    h(a, b);
    a.prototype.notifyNext = function(c, a, b, f) {
      this.destination.next(a);
    };
    a.prototype.notifyError = function(c) {
      this.destination.error(c);
    };
    a.prototype.notifyComplete = function(c) {
      this.destination.complete();
    };
    return a;
  })(l);
  var Ld = (function() {
      function b(a, c) {
        void 0 === c && (c = Number.POSITIVE_INFINITY);
        this.project = a;
        this.concurrent = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Of(a, this.project, this.concurrent));
      };
      return b;
    })(),
    Of = (function(b) {
      function a(c, a, e) {
        void 0 === e && (e = Number.POSITIVE_INFINITY);
        c = b.call(this, c) || this;
        c.project = a;
        c.concurrent = e;
        c.hasCompleted = !1;
        c.buffer = [];
        c.active = 0;
        c.index = 0;
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        this.active < this.concurrent ? this._tryNext(c) : this.buffer.push(c);
      };
      a.prototype._tryNext = function(c) {
        var a,
          b = this.index++;
        try {
          a = this.project(c, b);
        } catch (f) {
          this.destination.error(f);
          return;
        }
        this.active++;
        this._innerSub(a);
      };
      a.prototype._innerSub = function(c) {
        var a = new t(this),
          b = this.destination;
        b.add(a);
        c = u(c, a);
        c !== a && b.add(c);
      };
      a.prototype._complete = function() {
        this.hasCompleted = !0;
        0 === this.active &&
          0 === this.buffer.length &&
          this.destination.complete();
        this.unsubscribe();
      };
      a.prototype.notifyNext = function(c) {
        this.destination.next(c);
      };
      a.prototype.notifyComplete = function() {
        var c = this.buffer;
        this.active--;
        0 < c.length
          ? this._next(c.shift())
          : 0 === this.active &&
            this.hasCompleted &&
            this.destination.complete();
      };
      return a;
    })(r),
    Pf = new g(H),
    Td = (function() {
      function b(a, c) {
        this.predicate = a;
        this.thisArg = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Qf(a, this.predicate, this.thisArg));
      };
      return b;
    })(),
    Qf = (function(b) {
      function a(c, a, e) {
        c = b.call(this, c) || this;
        c.predicate = a;
        c.thisArg = e;
        c.count = 0;
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        var a;
        try {
          a = this.predicate.call(this.thisArg, c, this.count++);
        } catch (e) {
          this.destination.error(e);
          return;
        }
        a && this.destination.next(c);
      };
      return a;
    })(l),
    Ud = (function() {
      function b() {}
      b.prototype.call = function(a, c) {
        return c.subscribe(new Rf(a));
      };
      return b;
    })(),
    Rf = (function(b) {
      function a(c) {
        c = b.call(this, c) || this;
        c.hasFirst = !1;
        c.observables = [];
        c.subscriptions = [];
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        this.observables.push(c);
      };
      a.prototype._complete = function() {
        var c = this.observables,
          a = c.length;
        if (0 === a) this.destination.complete();
        else {
          for (var b = 0; b < a && !this.hasFirst; b++) {
            var f = I(this, c[b], void 0, b);
            this.subscriptions && this.subscriptions.push(f);
            this.add(f);
          }
          this.observables = null;
        }
      };
      a.prototype.notifyNext = function(c, a, b) {
        if (!this.hasFirst) {
          this.hasFirst = !0;
          for (c = 0; c < this.subscriptions.length; c++)
            if (c !== b) {
              var d = this.subscriptions[c];
              d.unsubscribe();
              this.remove(d);
            }
          this.subscriptions = null;
        }
        this.destination.next(a);
      };
      return a;
    })(S),
    mb = (function() {
      function b(a) {
        this.resultSelector = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Sf(a, this.resultSelector));
      };
      return b;
    })(),
    Sf = (function(b) {
      function a(c, a, e) {
        void 0 === e && Object.create(null);
        c = b.call(this, c) || this;
        c.resultSelector = a;
        c.iterators = [];
        c.active = 0;
        c.resultSelector = 'function' === typeof a ? a : void 0;
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        var a = this.iterators;
        z(c)
          ? a.push(new Tf(c))
          : 'function' === typeof c[F]
          ? a.push(new Uf(c[F]()))
          : a.push(new Vf(this.destination, this, c));
      };
      a.prototype._complete = function() {
        var c = this.iterators,
          a = c.length;
        this.unsubscribe();
        if (0 === a) this.destination.complete();
        else {
          this.active = a;
          for (var b = 0; b < a; b++) {
            var f = c[b];
            f.stillUnsubscribed
              ? this.destination.add(f.subscribe())
              : this.active--;
          }
        }
      };
      a.prototype.notifyInactive = function() {
        this.active--;
        0 === this.active && this.destination.complete();
      };
      a.prototype.checkIterators = function() {
        for (
          var c = this.iterators, a = c.length, b = this.destination, f = 0;
          f < a;
          f++
        ) {
          var k = c[f];
          if ('function' === typeof k.hasValue && !k.hasValue()) return;
        }
        for (var g = !1, h = [], f = 0; f < a; f++) {
          var k = c[f],
            l = k.next();
          k.hasCompleted() && (g = !0);
          if (l.done) {
            b.complete();
            return;
          }
          h.push(l.value);
        }
        this.resultSelector ? this._tryresultSelector(h) : b.next(h);
        g && b.complete();
      };
      a.prototype._tryresultSelector = function(c) {
        var a;
        try {
          a = this.resultSelector.apply(this, c);
        } catch (e) {
          this.destination.error(e);
          return;
        }
        this.destination.next(a);
      };
      return a;
    })(l),
    Uf = (function() {
      function b(a) {
        this.iterator = a;
        this.nextResult = a.next();
      }
      b.prototype.hasValue = function() {
        return !0;
      };
      b.prototype.next = function() {
        var a = this.nextResult;
        this.nextResult = this.iterator.next();
        return a;
      };
      b.prototype.hasCompleted = function() {
        var a = this.nextResult;
        return !(!a || !a.done);
      };
      return b;
    })(),
    Tf = (function() {
      function b(a) {
        this.array = a;
        this.length = this.index = 0;
        this.length = a.length;
      }
      b.prototype[F] = function() {
        return this;
      };
      b.prototype.next = function(a) {
        a = this.index++;
        var c = this.array;
        return a < this.length
          ? { value: c[a], done: !1 }
          : { value: null, done: !0 };
      };
      b.prototype.hasValue = function() {
        return this.array.length > this.index;
      };
      b.prototype.hasCompleted = function() {
        return this.array.length === this.index;
      };
      return b;
    })(),
    Vf = (function(b) {
      function a(c, a, e) {
        c = b.call(this, c) || this;
        c.parent = a;
        c.observable = e;
        c.stillUnsubscribed = !0;
        c.buffer = [];
        c.isComplete = !1;
        return c;
      }
      h(a, b);
      a.prototype[F] = function() {
        return this;
      };
      a.prototype.next = function() {
        var c = this.buffer;
        return 0 === c.length && this.isComplete
          ? { value: null, done: !0 }
          : { value: c.shift(), done: !1 };
      };
      a.prototype.hasValue = function() {
        return 0 < this.buffer.length;
      };
      a.prototype.hasCompleted = function() {
        return 0 === this.buffer.length && this.isComplete;
      };
      a.prototype.notifyComplete = function() {
        0 < this.buffer.length
          ? ((this.isComplete = !0), this.parent.notifyInactive())
          : this.destination.complete();
      };
      a.prototype.notifyNext = function(c) {
        this.buffer.push(c);
        this.parent.checkIterators();
      };
      a.prototype.subscribe = function() {
        return u(this.observable, new t(this));
      };
      return a;
    })(r),
    Wf =
      'undefined' !== typeof self &&
      'undefined' !== typeof WorkerGlobalScope &&
      self instanceof WorkerGlobalScope &&
      self,
    Xf = 'undefined' !== typeof global && global,
    C = ('undefined' !== typeof window && window) || Xf || Wf;
  if (!C)
    throw Error(
      'RxJS could not find any global context (window, self, global)',
    );
  var ce = A(function(b, a) {
      return b.response;
    }),
    Q = (function(b) {
      function a(c) {
        var a = b.call(this) || this,
          e = {
            async: !0,
            createXHR: function() {
              var c;
              if (this.crossDomain)
                if (C.XMLHttpRequest) c = new C.XMLHttpRequest();
                else if (C.XDomainRequest) c = new C.XDomainRequest();
                else throw Error('CORS is not supported by your browser');
              else if (C.XMLHttpRequest) c = new C.XMLHttpRequest();
              else {
                var a = void 0;
                try {
                  for (
                    var b = [
                        'Msxml2.XMLHTTP',
                        'Microsoft.XMLHTTP',
                        'Msxml2.XMLHTTP.4.0',
                      ],
                      d = 0;
                    3 > d;
                    d++
                  )
                    try {
                      a = b[d];
                      new C.ActiveXObject(a);
                      break;
                    } catch (q) {}
                  c = new C.ActiveXObject(a);
                } catch (q) {
                  throw Error(
                    'XMLHttpRequest is not supported by your browser',
                  );
                }
              }
              return c;
            },
            crossDomain: !0,
            withCredentials: !1,
            headers: {},
            method: 'GET',
            responseType: 'json',
            timeout: 0,
          };
        if ('string' === typeof c) e.url = c;
        else for (var f in c) c.hasOwnProperty(f) && (e[f] = c[f]);
        a.request = e;
        return a;
      }
      h(a, b);
      a.prototype._subscribe = function(c) {
        return new Yf(c, this.request);
      };
      a.create = (function() {
        var c = function(c) {
          return new a(c);
        };
        c.get = Xd;
        c.post = Yd;
        c.delete = Zd;
        c.put = $d;
        c.patch = ae;
        c.getJSON = be;
        return c;
      })();
      return a;
    })(g),
    Yf = (function(b) {
      function a(c, a) {
        c = b.call(this, c) || this;
        c.request = a;
        c.done = !1;
        var d = (a.headers = a.headers || {});
        a.crossDomain ||
          c.getHeader(d, 'X-Requested-With') ||
          (d['X-Requested-With'] = 'XMLHttpRequest');
        c.getHeader(d, 'Content-Type') ||
          (C.FormData && a.body instanceof C.FormData) ||
          'undefined' === typeof a.body ||
          (d['Content-Type'] =
            'application/x-www-form-urlencoded; charset\x3dutf-8');
        a.body = c.serializeBody(
          a.body,
          c.getHeader(a.headers, 'Content-Type'),
        );
        c.send();
        return c;
      }
      h(a, b);
      a.prototype.next = function(c) {
        this.done = !0;
        var a = this.xhr,
          b = this.request,
          f = this.destination,
          k;
        try {
          k = new Sa(c, a, b);
        } catch (v) {
          return f.error(v);
        }
        f.next(k);
      };
      a.prototype.send = function() {
        var c = this.request,
          a = this.request,
          b = a.user,
          f = a.method,
          k = a.url,
          g = a.async,
          h = a.password,
          l = a.headers,
          a = a.body;
        try {
          var q = (this.xhr = c.createXHR());
          this.setupEvents(q, c);
          b ? q.open(f, k, g, b, h) : q.open(f, k, g);
          g && ((q.timeout = c.timeout), (q.responseType = c.responseType));
          'withCredentials' in q && (q.withCredentials = !!c.withCredentials);
          this.setHeaders(q, l);
          a ? q.send(a) : q.send();
        } catch (Md) {
          this.error(Md);
        }
      };
      a.prototype.serializeBody = function(c, a) {
        if (
          !c ||
          'string' === typeof c ||
          (C.FormData && c instanceof C.FormData)
        )
          return c;
        if (a) {
          var b = a.indexOf(';');
          -1 !== b && (a = a.substring(0, b));
        }
        switch (a) {
          case 'application/x-www-form-urlencoded':
            return Object.keys(c)
              .map(function(a) {
                return (
                  encodeURIComponent(a) + '\x3d' + encodeURIComponent(c[a])
                );
              })
              .join('\x26');
          case 'application/json':
            return JSON.stringify(c);
          default:
            return c;
        }
      };
      a.prototype.setHeaders = function(c, a) {
        for (var b in a) a.hasOwnProperty(b) && c.setRequestHeader(b, a[b]);
      };
      a.prototype.getHeader = function(c, a) {
        for (var b in c) if (b.toLowerCase() === a.toLowerCase()) return c[b];
      };
      a.prototype.setupEvents = function(c, a) {
        function b(c) {
          var a = b.subscriber,
            d = b.progressSubscriber,
            e = b.request;
          d && d.error(c);
          var f;
          try {
            f = new Ta(this, e);
          } catch (Ua) {
            f = Ua;
          }
          a.error(f);
        }
        function d(c) {}
        function k(c) {
          var a = k.subscriber,
            b = k.progressSubscriber,
            d = k.request;
          if (4 === this.readyState) {
            var e = 1223 === this.status ? 204 : this.status,
              f =
                'text' === this.responseType
                  ? this.response || this.responseText
                  : this.response;
            0 === e && (e = f ? 200 : 0);
            if (400 > e) b && b.complete(), a.next(c), a.complete();
            else {
              b && b.error(c);
              c = void 0;
              try {
                c = new na('ajax error ' + e, this, d);
              } catch (Zf) {
                c = Zf;
              }
              a.error(c);
            }
          }
        }
        var g = a.progressSubscriber;
        c.ontimeout = b;
        b.request = a;
        b.subscriber = this;
        b.progressSubscriber = g;
        if (c.upload && 'withCredentials' in c) {
          if (g) {
            var h;
            h = function(c) {
              h.progressSubscriber.next(c);
            };
            C.XDomainRequest ? (c.onprogress = h) : (c.upload.onprogress = h);
            h.progressSubscriber = g;
          }
          var l;
          l = function(c) {
            var a = l.progressSubscriber,
              b = l.subscriber,
              d = l.request;
            a && a.error(c);
            var e;
            try {
              e = new na('ajax error', this, d);
            } catch (Ua) {
              e = Ua;
            }
            b.error(e);
          };
          c.onerror = l;
          l.request = a;
          l.subscriber = this;
          l.progressSubscriber = g;
        }
        c.onreadystatechange = d;
        d.subscriber = this;
        d.progressSubscriber = g;
        d.request = a;
        c.onload = k;
        k.subscriber = this;
        k.progressSubscriber = g;
        k.request = a;
      };
      a.prototype.unsubscribe = function() {
        var c = this.xhr;
        !this.done &&
          c &&
          4 !== c.readyState &&
          'function' === typeof c.abort &&
          c.abort();
        b.prototype.unsubscribe.call(this);
      };
      return a;
    })(l),
    Sa = (function() {
      return function(b, a, c) {
        this.originalEvent = b;
        this.xhr = a;
        this.request = c;
        this.status = a.status;
        this.responseType = a.responseType || c.responseType;
        this.response = nb(this.responseType, a);
      };
    })(),
    na = (function() {
      function b(a, c, b) {
        Error.call(this);
        this.message = a;
        this.name = 'AjaxError';
        this.xhr = c;
        this.request = b;
        this.status = c.status;
        this.responseType = c.responseType || b.responseType;
        this.response = nb(this.responseType, c);
        return this;
      }
      b.prototype = Object.create(Error.prototype);
      return b;
    })(),
    Ta = function(b, a) {
      na.call(this, 'ajax timeout', b, a);
      this.name = 'AjaxTimeoutError';
      return this;
    },
    rd = Q.create,
    $f = {
      url: '',
      deserializer: function(b) {
        return JSON.parse(b.data);
      },
      serializer: function(b) {
        return JSON.stringify(b);
      },
    },
    pb = (function(b) {
      function a(c, a) {
        var d = b.call(this) || this;
        if (c instanceof g) (d.destination = a), (d.source = c);
        else {
          a = d._config = vf({}, $f);
          d._output = new w();
          if ('string' === typeof c) a.url = c;
          else for (var f in c) c.hasOwnProperty(f) && (a[f] = c[f]);
          if (!a.WebSocketCtor && WebSocket) a.WebSocketCtor = WebSocket;
          else if (!a.WebSocketCtor)
            throw Error('no WebSocket constructor can be found');
          d.destination = new da();
        }
        return d;
      }
      h(a, b);
      a.prototype.lift = function(c) {
        var b = new a(this._config, this.destination);
        b.operator = c;
        b.source = this;
        return b;
      };
      a.prototype._resetState = function() {
        this._socket = null;
        this.source || (this.destination = new da());
        this._output = new w();
      };
      a.prototype.multiplex = function(c, a, b) {
        var d = this;
        return new g(function(e) {
          try {
            d.next(c());
          } catch (n) {
            e.error(n);
          }
          var f = d.subscribe(
            function(c) {
              try {
                b(c) && e.next(c);
              } catch (O) {
                e.error(O);
              }
            },
            function(c) {
              return e.error(c);
            },
            function() {
              return e.complete();
            },
          );
          return function() {
            try {
              d.next(a());
            } catch (n) {
              e.error(n);
            }
            f.unsubscribe();
          };
        });
      };
      a.prototype._connectSocket = function() {
        var c = this,
          a = this._config,
          b = a.WebSocketCtor,
          f = a.protocol,
          g = a.url,
          a = a.binaryType,
          h = this._output,
          n = null;
        try {
          (this._socket = n = f ? new b(g, f) : new b(g)),
            a && (this._socket.binaryType = a);
        } catch (q) {
          h.error(q);
          return;
        }
        var m = new p(function() {
          c._socket = null;
          n && 1 === n.readyState && n.close();
        });
        n.onopen = function(a) {
          if (c._socket) {
            var b = c._config.openObserver;
            b && b.next(a);
            a = c.destination;
            c.destination = l.create(
              function(a) {
                if (1 === n.readyState)
                  try {
                    var b = c._config.serializer;
                    n.send(b(a));
                  } catch (Od) {
                    c.destination.error(Od);
                  }
              },
              function(a) {
                var b = c._config.closingObserver;
                b && b.next(void 0);
                a && a.code
                  ? n.close(a.code, a.reason)
                  : h.error(
                      new TypeError(
                        'WebSocketSubject.error must be called with an object with an error code, and an optional reason: { code: number, reason: string }',
                      ),
                    );
                c._resetState();
              },
              function() {
                var a = c._config.closingObserver;
                a && a.next(void 0);
                n.close();
                c._resetState();
              },
            );
            a && a instanceof da && m.add(a.subscribe(c.destination));
          } else n.close(), c._resetState();
        };
        n.onerror = function(a) {
          c._resetState();
          h.error(a);
        };
        n.onclose = function(a) {
          c._resetState();
          var b = c._config.closeObserver;
          b && b.next(a);
          a.wasClean ? h.complete() : h.error(a);
        };
        n.onmessage = function(a) {
          try {
            var b = c._config.deserializer;
            h.next(b(a));
          } catch (Nd) {
            h.error(Nd);
          }
        };
      };
      a.prototype._subscribe = function(c) {
        var a = this,
          b = this.source;
        if (b) return b.subscribe(c);
        this._socket || this._connectSocket();
        this._output.subscribe(c);
        c.add(function() {
          var c = a._socket;
          0 === a._output.observers.length &&
            (c && 1 === c.readyState && c.close(), a._resetState());
        });
        return c;
      };
      a.prototype.unsubscribe = function() {
        var c = this._socket;
        c && 1 === c.readyState && c.close();
        this._resetState();
        b.prototype.unsubscribe.call(this);
      };
      return a;
    })(xa),
    ag = (function(b) {
      function a(c, a, e) {
        void 0 === a && (a = 0);
        void 0 === e && (e = ya);
        var d = b.call(this) || this;
        d.source = c;
        d.delayTime = a;
        d.scheduler = e;
        if (!K(a) || 0 > a) d.delayTime = 0;
        (e && 'function' === typeof e.schedule) || (d.scheduler = ya);
        return d;
      }
      h(a, b);
      a.create = function(c, b, e) {
        void 0 === b && (b = 0);
        void 0 === e && (e = ya);
        return new a(c, b, e);
      };
      a.dispatch = function(c) {
        return this.add(c.source.subscribe(c.subscriber));
      };
      a.prototype._subscribe = function(c) {
        return this.scheduler.schedule(a.dispatch, this.delayTime, {
          source: this.source,
          subscriber: c,
        });
      };
      return a;
    })(g),
    rb = (function() {
      return function(b, a) {
        this.value = b;
        this.timestamp = a;
      };
    })(),
    de = (function() {
      function b(a, c, b) {
        void 0 === b && (b = !1);
        this.accumulator = a;
        this.seed = c;
        this.hasSeed = b;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new bg(a, this.accumulator, this.seed, this.hasSeed),
        );
      };
      return b;
    })(),
    bg = (function(b) {
      function a(c, a, e, f) {
        c = b.call(this, c) || this;
        c.accumulator = a;
        c._seed = e;
        c.hasSeed = f;
        c.index = 0;
        return c;
      }
      h(a, b);
      Object.defineProperty(a.prototype, 'seed', {
        get: function() {
          return this._seed;
        },
        set: function(c) {
          this.hasSeed = !0;
          this._seed = c;
        },
        enumerable: !0,
        configurable: !0,
      });
      a.prototype._next = function(c) {
        if (this.hasSeed) return this._tryNext(c);
        this.seed = c;
        this.destination.next(c);
      };
      a.prototype._tryNext = function(c) {
        var a = this.index++,
          b;
        try {
          b = this.accumulator(this.seed, c, a);
        } catch (f) {
          this.destination.error(f);
        }
        this.seed = b;
        this.destination.next(b);
      };
      return a;
    })(l),
    tb = (function() {
      return function(b, a) {
        this.value = b;
        this.interval = a;
      };
    })(),
    sa = { leading: !0, trailing: !1 },
    ee = (function() {
      function b(a, c, b) {
        this.durationSelector = a;
        this.leading = c;
        this.trailing = b;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new cg(a, this.durationSelector, this.leading, this.trailing),
        );
      };
      return b;
    })(),
    cg = (function(b) {
      function a(c, a, e, f) {
        var d = b.call(this, c) || this;
        d.destination = c;
        d.durationSelector = a;
        d._leading = e;
        d._trailing = f;
        d._hasValue = !1;
        return d;
      }
      h(a, b);
      a.prototype._next = function(c) {
        this._hasValue = !0;
        this._sendValue = c;
        this._throttled || (this._leading ? this.send() : this.throttle(c));
      };
      a.prototype.send = function() {
        var c = this._sendValue;
        this._hasValue && (this.destination.next(c), this.throttle(c));
        this._hasValue = !1;
        this._sendValue = void 0;
      };
      a.prototype.throttle = function(c) {
        (c = this.tryDurationSelector(c)) &&
          this.add((this._throttled = u(c, new t(this))));
      };
      a.prototype.tryDurationSelector = function(c) {
        try {
          return this.durationSelector(c);
        } catch (d) {
          return this.destination.error(d), null;
        }
      };
      a.prototype.throttlingDone = function() {
        var c = this._throttled,
          a = this._trailing;
        c && c.unsubscribe();
        this._throttled = void 0;
        a && this.send();
      };
      a.prototype.notifyNext = function() {
        this.throttlingDone();
      };
      a.prototype.notifyComplete = function() {
        this.throttlingDone();
      };
      return a;
    })(r);
  g.bindCallback = cb;
  g.bindNodeCallback = db;
  g.combineLatest = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    var c = (a = void 0);
    y(b[b.length - 1]) && (c = b.pop());
    'function' === typeof b[b.length - 1] && (a = b.pop());
    1 === b.length && z(b[0]) && (b = b[0]);
    return ha(b, c).lift(new ta(a));
  };
  g.concat = Y;
  g.defer = Ha;
  g.empty = V;
  g.forkJoin = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    if (1 === b.length) {
      var c = b[0];
      if (z(c)) return ra(c, null);
      if (za(c) && Object.getPrototypeOf(c) === Object.prototype)
        return (
          (b = Object.keys(c)),
          ra(
            b.map(function(a) {
              return c[a];
            }),
            b,
          )
        );
    }
    if ('function' === typeof b[b.length - 1]) {
      var d = b.pop(),
        b = 1 === b.length && z(b[0]) ? b[0] : b;
      return ra(b, null).pipe(
        A(function(c) {
          return d.apply(void 0, c);
        }),
      );
    }
    return ra(b, null);
  };
  g.from = G;
  g.fromEvent = hb;
  g.fromEventPattern = jb;
  g.fromPromise = G;
  g.generate = function(b, a, c, d, e) {
    var f, k;
    1 == arguments.length
      ? ((k = b.initialState),
        (a = b.condition),
        (c = b.iterate),
        (f = b.resultSelector || N),
        (e = b.scheduler))
      : void 0 === d || y(d)
      ? ((k = b), (f = N), (e = d))
      : ((k = b), (f = d));
    return new g(function(b) {
      var d = k;
      if (e)
        return e.schedule(Pd, 0, {
          subscriber: b,
          iterate: c,
          condition: a,
          resultSelector: f,
          state: d,
        });
      do {
        if (a) {
          var g = void 0;
          try {
            g = a(d);
          } catch (q) {
            b.error(q);
            break;
          }
          if (!g) {
            b.complete();
            break;
          }
        }
        g = void 0;
        try {
          g = f(d);
        } catch (q) {
          b.error(q);
          break;
        }
        b.next(g);
        if (b.closed) break;
        try {
          d = c(d);
        } catch (q) {
          b.error(q);
          break;
        }
      } while (1);
    });
  };
  g.if = function(b, a, c) {
    void 0 === a && (a = ga);
    void 0 === c && (c = ga);
    return Ha(function() {
      return b() ? a : c;
    });
  };
  g.interval = function(b, a) {
    void 0 === b && (b = 0);
    void 0 === a && (a = B);
    if (!K(b) || 0 > b) b = 0;
    (a && 'function' === typeof a.schedule) || (a = B);
    return new g(function(c) {
      c.add(a.schedule(Qd, b, { subscriber: c, counter: 0, period: b }));
      return c;
    });
  };
  g.merge = Ia;
  g.race = kb;
  g.never = function() {
    return Pf;
  };
  g.of = ia;
  g.onErrorResumeNext = Ja;
  g.pairs = function(b, a) {
    return a
      ? new g(function(c) {
          var d = Object.keys(b),
            e = new p();
          e.add(
            a.schedule(Rd, 0, {
              keys: d,
              index: 0,
              subscriber: c,
              subscription: e,
              obj: b,
            }),
          );
          return e;
        })
      : new g(function(c) {
          for (var a = Object.keys(b), e = 0; e < a.length && !c.closed; e++) {
            var f = a[e];
            b.hasOwnProperty(f) && c.next([f, b[f]]);
          }
          c.complete();
        });
  };
  g.range = function(b, a, c) {
    void 0 === b && (b = 0);
    return new g(function(d) {
      void 0 === a && ((a = b), (b = 0));
      var e = 0,
        f = b;
      if (c)
        return c.schedule(Vd, 0, {
          index: e,
          count: a,
          start: b,
          subscriber: d,
        });
      do {
        if (e++ >= a) {
          d.complete();
          break;
        }
        d.next(f++);
        if (d.closed) break;
      } while (1);
    });
  };
  g.using = function(b, a) {
    return new g(function(c) {
      var d;
      try {
        d = b();
      } catch (k) {
        c.error(k);
        return;
      }
      var e;
      try {
        e = a(d);
      } catch (k) {
        c.error(k);
        return;
      }
      var f = (e ? G(e) : ga).subscribe(c);
      return function() {
        f.unsubscribe();
        d && d.unsubscribe();
      };
    });
  };
  g.throw = pa;
  g.throwError = pa;
  g.timer = lb;
  g.zip = Ka;
  var dg = Object.freeze({
    ajax: rd,
    AjaxResponse: Sa,
    AjaxError: na,
    AjaxTimeoutError: Ta,
  });
  g.ajax = rd;
  var eg = Object.freeze({ webSocket: ob, WebSocketSubject: pb });
  g.webSocket = ob;
  var fe = (function() {
      function b(a) {
        this.durationSelector = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new fg(a, this.durationSelector));
      };
      return b;
    })(),
    fg = (function(b) {
      function a(c, a) {
        c = b.call(this, c) || this;
        c.durationSelector = a;
        c.hasValue = !1;
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        this.value = c;
        this.hasValue = !0;
        if (!this.throttled) {
          var a = void 0;
          try {
            var b = this.durationSelector,
              a = b(c);
          } catch (f) {
            return this.destination.error(f);
          }
          c = u(a, new t(this));
          !c || c.closed
            ? this.clearThrottle()
            : this.add((this.throttled = c));
        }
      };
      a.prototype.clearThrottle = function() {
        var c = this.value,
          a = this.hasValue,
          b = this.throttled;
        b && (this.remove(b), (this.throttled = void 0), b.unsubscribe());
        a &&
          ((this.value = void 0),
          (this.hasValue = !1),
          this.destination.next(c));
      };
      a.prototype.notifyNext = function() {
        this.clearThrottle();
      };
      a.prototype.notifyComplete = function() {
        this.clearThrottle();
      };
      return a;
    })(r),
    ge = (function() {
      function b(a) {
        this.closingNotifier = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new gg(a, this.closingNotifier));
      };
      return b;
    })(),
    gg = (function(b) {
      function a(c, a) {
        c = b.call(this, c) || this;
        c.buffer = [];
        c.add(u(a, new t(c)));
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        this.buffer.push(c);
      };
      a.prototype.notifyNext = function() {
        var c = this.buffer;
        this.buffer = [];
        this.destination.next(c);
      };
      return a;
    })(r),
    he = (function() {
      function b(a, c) {
        this.bufferSize = a;
        this.subscriberClass = (this.startBufferEvery = c) && a !== c ? hg : ig;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new this.subscriberClass(a, this.bufferSize, this.startBufferEvery),
        );
      };
      return b;
    })(),
    ig = (function(b) {
      function a(c, a) {
        c = b.call(this, c) || this;
        c.bufferSize = a;
        c.buffer = [];
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        var a = this.buffer;
        a.push(c);
        a.length == this.bufferSize &&
          (this.destination.next(a), (this.buffer = []));
      };
      a.prototype._complete = function() {
        var c = this.buffer;
        0 < c.length && this.destination.next(c);
        b.prototype._complete.call(this);
      };
      return a;
    })(l),
    hg = (function(b) {
      function a(c, a, e) {
        c = b.call(this, c) || this;
        c.bufferSize = a;
        c.startBufferEvery = e;
        c.buffers = [];
        c.count = 0;
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        var a = this.bufferSize,
          b = this.startBufferEvery,
          f = this.buffers,
          g = this.count;
        this.count++;
        0 === g % b && f.push([]);
        for (b = f.length; b--; )
          (g = f[b]),
            g.push(c),
            g.length === a && (f.splice(b, 1), this.destination.next(g));
      };
      a.prototype._complete = function() {
        for (var c = this.buffers, a = this.destination; 0 < c.length; ) {
          var e = c.shift();
          0 < e.length && a.next(e);
        }
        b.prototype._complete.call(this);
      };
      return a;
    })(l),
    ie = (function() {
      function b(a, c, b, e) {
        this.bufferTimeSpan = a;
        this.bufferCreationInterval = c;
        this.maxBufferSize = b;
        this.scheduler = e;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new jg(
            a,
            this.bufferTimeSpan,
            this.bufferCreationInterval,
            this.maxBufferSize,
            this.scheduler,
          ),
        );
      };
      return b;
    })(),
    kg = (function() {
      return function() {
        this.buffer = [];
      };
    })(),
    jg = (function(b) {
      function a(c, a, e, f, g) {
        c = b.call(this, c) || this;
        c.bufferTimeSpan = a;
        c.bufferCreationInterval = e;
        c.maxBufferSize = f;
        c.scheduler = g;
        c.contexts = [];
        f = c.openContext();
        c.timespanOnly = null == e || 0 > e;
        if (c.timespanOnly)
          c.add(
            (f.closeAction = g.schedule(Ab, a, {
              subscriber: c,
              context: f,
              bufferTimeSpan: a,
            })),
          );
        else {
          var d = {
            bufferTimeSpan: a,
            bufferCreationInterval: e,
            subscriber: c,
            scheduler: g,
          };
          c.add(
            (f.closeAction = g.schedule(Bb, a, { subscriber: c, context: f })),
          );
          c.add(g.schedule(je, e, d));
        }
        return c;
      }
      h(a, b);
      a.prototype._next = function(c) {
        for (var a = this.contexts, b = a.length, f, g = 0; g < b; g++) {
          var h = a[g],
            l = h.buffer;
          l.push(c);
          l.length == this.maxBufferSize && (f = h);
        }
        if (f) this.onBufferFull(f);
      };
      a.prototype._error = function(c) {
        this.contexts.length = 0;
        b.prototype._error.call(this, c);
      };
      a.prototype._complete = function() {
        for (var c = this.contexts, a = this.destination; 0 < c.length; ) {
          var e = c.shift();
          a.next(e.buffer);
        }
        b.prototype._complete.call(this);
      };
      a.prototype._unsubscribe = function() {
        this.contexts = null;
      };
      a.prototype.onBufferFull = function(c) {
        this.closeContext(c);
        c = c.closeAction;
        c.unsubscribe();
        this.remove(c);
        if (!this.closed && this.timespanOnly) {
          c = this.openContext();
          var a = this.bufferTimeSpan;
          this.add(
            (c.closeAction = this.scheduler.schedule(Ab, a, {
              subscriber: this,
              context: c,
              bufferTimeSpan: a,
            })),
          );
        }
      };
      a.prototype.openContext = function() {
        var a = new kg();
        this.contexts.push(a);
        return a;
      };
      a.prototype.closeContext = function(a) {
        this.destination.next(a.buffer);
        var c = this.contexts;
        0 <= (c ? c.indexOf(a) : -1) && c.splice(c.indexOf(a), 1);
      };
      return a;
    })(l),
    ke = (function() {
      function b(a, c) {
        this.openings = a;
        this.closingSelector = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new lg(a, this.openings, this.closingSelector));
      };
      return b;
    })(),
    lg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.closingSelector = e;
        a.contexts = [];
        a.add(I(a, d));
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        for (var c = this.contexts, b = c.length, f = 0; f < b; f++)
          c[f].buffer.push(a);
      };
      a.prototype._error = function(a) {
        for (var c = this.contexts; 0 < c.length; ) {
          var e = c.shift();
          e.subscription.unsubscribe();
          e.buffer = null;
          e.subscription = null;
        }
        this.contexts = null;
        b.prototype._error.call(this, a);
      };
      a.prototype._complete = function() {
        for (var a = this.contexts; 0 < a.length; ) {
          var d = a.shift();
          this.destination.next(d.buffer);
          d.subscription.unsubscribe();
          d.buffer = null;
          d.subscription = null;
        }
        this.contexts = null;
        b.prototype._complete.call(this);
      };
      a.prototype.notifyNext = function(a, b) {
        a ? this.closeBuffer(a) : this.openBuffer(b);
      };
      a.prototype.notifyComplete = function(a) {
        this.closeBuffer(a.context);
      };
      a.prototype.openBuffer = function(a) {
        try {
          var c = this.closingSelector.call(this, a);
          c && this.trySubscribe(c);
        } catch (e) {
          this._error(e);
        }
      };
      a.prototype.closeBuffer = function(a) {
        var c = this.contexts;
        if (c && a) {
          var b = a.subscription;
          this.destination.next(a.buffer);
          c.splice(c.indexOf(a), 1);
          this.remove(b);
          b.unsubscribe();
        }
      };
      a.prototype.trySubscribe = function(a) {
        var c = this.contexts,
          b = new p(),
          f = { buffer: [], subscription: b };
        c.push(f);
        a = I(this, a, f);
        !a || a.closed
          ? this.closeBuffer(f)
          : ((a.context = f), this.add(a), b.add(a));
      };
      return a;
    })(S),
    le = (function() {
      function b(a) {
        this.closingSelector = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new mg(a, this.closingSelector));
      };
      return b;
    })(),
    mg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.closingSelector = d;
        a.subscribing = !1;
        a.openBuffer();
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.buffer.push(a);
      };
      a.prototype._complete = function() {
        var a = this.buffer;
        a && this.destination.next(a);
        b.prototype._complete.call(this);
      };
      a.prototype._unsubscribe = function() {
        this.buffer = void 0;
        this.subscribing = !1;
      };
      a.prototype.notifyNext = function() {
        this.openBuffer();
      };
      a.prototype.notifyComplete = function() {
        this.subscribing ? this.complete() : this.openBuffer();
      };
      a.prototype.openBuffer = function() {
        var a = this.closingSubscription;
        a && (this.remove(a), a.unsubscribe());
        (a = this.buffer) && this.destination.next(a);
        this.buffer = [];
        var b;
        try {
          var e = this.closingSelector;
          b = e();
        } catch (f) {
          return this.error(f);
        }
        this.closingSubscription = a = new p();
        this.add(a);
        this.subscribing = !0;
        a.add(u(b, new t(this)));
        this.subscribing = !1;
      };
      return a;
    })(r),
    me = (function() {
      function b(a) {
        this.selector = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new ng(a, this.selector, this.caught));
      };
      return b;
    })(),
    ng = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.selector = d;
        a.caught = e;
        return a;
      }
      h(a, b);
      a.prototype.error = function(a) {
        if (!this.isStopped) {
          var c = void 0;
          try {
            c = this.selector(a, this.caught);
          } catch (e) {
            b.prototype.error.call(this, e);
            return;
          }
          this._unsubscribeAndRecycle();
          a = new t(this);
          this.add(a);
          c = u(c, a);
          c !== a && this.add(c);
        }
      };
      return a;
    })(r),
    ne = (function() {
      function b(a, c) {
        this.predicate = a;
        this.source = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new og(a, this.predicate, this.source));
      };
      return b;
    })(),
    og = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.predicate = d;
        a.source = e;
        a.count = 0;
        a.index = 0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.predicate ? this._tryPredicate(a) : this.count++;
      };
      a.prototype._tryPredicate = function(a) {
        var c;
        try {
          c = this.predicate(a, this.index++, this.source);
        } catch (e) {
          this.destination.error(e);
          return;
        }
        c && this.count++;
      };
      a.prototype._complete = function() {
        this.destination.next(this.count);
        this.destination.complete();
      };
      return a;
    })(l),
    oe = (function() {
      function b(a) {
        this.durationSelector = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new pg(a, this.durationSelector));
      };
      return b;
    })(),
    pg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.durationSelector = d;
        a.hasValue = !1;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        try {
          var c = this.durationSelector.call(this, a);
          c && this._tryNext(a, c);
        } catch (e) {
          this.destination.error(e);
        }
      };
      a.prototype._complete = function() {
        this.emitValue();
        this.destination.complete();
      };
      a.prototype._tryNext = function(a, b) {
        var c = this.durationSubscription;
        this.value = a;
        this.hasValue = !0;
        c && (c.unsubscribe(), this.remove(c));
        (c = u(b, new t(this))) &&
          !c.closed &&
          this.add((this.durationSubscription = c));
      };
      a.prototype.notifyNext = function() {
        this.emitValue();
      };
      a.prototype.notifyComplete = function() {
        this.emitValue();
      };
      a.prototype.emitValue = function() {
        if (this.hasValue) {
          var a = this.value,
            d = this.durationSubscription;
          d &&
            ((this.durationSubscription = void 0),
            d.unsubscribe(),
            this.remove(d));
          this.value = void 0;
          this.hasValue = !1;
          b.prototype._next.call(this, a);
        }
      };
      return a;
    })(r),
    pe = (function() {
      function b(a, c) {
        this.dueTime = a;
        this.scheduler = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new qg(a, this.dueTime, this.scheduler));
      };
      return b;
    })(),
    qg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.dueTime = d;
        a.scheduler = e;
        a.debouncedSubscription = null;
        a.lastValue = null;
        a.hasValue = !1;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.clearDebounce();
        this.lastValue = a;
        this.hasValue = !0;
        this.add(
          (this.debouncedSubscription = this.scheduler.schedule(
            qe,
            this.dueTime,
            this,
          )),
        );
      };
      a.prototype._complete = function() {
        this.debouncedNext();
        this.destination.complete();
      };
      a.prototype.debouncedNext = function() {
        this.clearDebounce();
        if (this.hasValue) {
          var a = this.lastValue;
          this.lastValue = null;
          this.hasValue = !1;
          this.destination.next(a);
        }
      };
      a.prototype.clearDebounce = function() {
        var a = this.debouncedSubscription;
        null !== a &&
          (this.remove(a),
          a.unsubscribe(),
          (this.debouncedSubscription = null));
      };
      return a;
    })(l),
    re = (function() {
      function b(a) {
        this.defaultValue = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new rg(a, this.defaultValue));
      };
      return b;
    })(),
    rg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.defaultValue = d;
        a.isEmpty = !0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.isEmpty = !1;
        this.destination.next(a);
      };
      a.prototype._complete = function() {
        this.isEmpty && this.destination.next(this.defaultValue);
        this.destination.complete();
      };
      return a;
    })(l),
    se = (function() {
      function b(a, c) {
        this.delay = a;
        this.scheduler = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new sg(a, this.delay, this.scheduler));
      };
      return b;
    })(),
    sg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.delay = d;
        a.scheduler = e;
        a.queue = [];
        a.active = !1;
        a.errored = !1;
        return a;
      }
      h(a, b);
      a.dispatch = function(a) {
        for (
          var c = a.source, b = c.queue, f = a.scheduler, g = a.destination;
          0 < b.length && 0 >= b[0].time - f.now();

        )
          b.shift().notification.observe(g);
        0 < b.length
          ? ((c = Math.max(0, b[0].time - f.now())), this.schedule(a, c))
          : (this.unsubscribe(), (c.active = !1));
      };
      a.prototype._schedule = function(c) {
        this.active = !0;
        this.destination.add(
          c.schedule(a.dispatch, this.delay, {
            source: this,
            destination: this.destination,
            scheduler: c,
          }),
        );
      };
      a.prototype.scheduleNotification = function(a) {
        if (!0 !== this.errored) {
          var c = this.scheduler;
          a = new tg(c.now() + this.delay, a);
          this.queue.push(a);
          !1 === this.active && this._schedule(c);
        }
      };
      a.prototype._next = function(a) {
        this.scheduleNotification(x.createNext(a));
      };
      a.prototype._error = function(a) {
        this.errored = !0;
        this.queue = [];
        this.destination.error(a);
        this.unsubscribe();
      };
      a.prototype._complete = function() {
        this.scheduleNotification(x.createComplete());
        this.unsubscribe();
      };
      return a;
    })(l),
    tg = (function() {
      return function(b, a) {
        this.time = b;
        this.notification = a;
      };
    })(),
    Mb = (function() {
      function b(a) {
        this.delayDurationSelector = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new ug(a, this.delayDurationSelector));
      };
      return b;
    })(),
    ug = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.delayDurationSelector = d;
        a.completed = !1;
        a.delayNotifierSubscriptions = [];
        a.index = 0;
        return a;
      }
      h(a, b);
      a.prototype.notifyNext = function(a, b, e, f, g) {
        this.destination.next(a);
        this.removeSubscription(g);
        this.tryComplete();
      };
      a.prototype.notifyError = function(a, b) {
        this._error(a);
      };
      a.prototype.notifyComplete = function(a) {
        (a = this.removeSubscription(a)) && this.destination.next(a);
        this.tryComplete();
      };
      a.prototype._next = function(a) {
        var c = this.index++;
        try {
          var b = this.delayDurationSelector(a, c);
          b && this.tryDelay(b, a);
        } catch (f) {
          this.destination.error(f);
        }
      };
      a.prototype._complete = function() {
        this.completed = !0;
        this.tryComplete();
        this.unsubscribe();
      };
      a.prototype.removeSubscription = function(a) {
        a.unsubscribe();
        var c = this.delayNotifierSubscriptions.indexOf(a);
        -1 !== c && this.delayNotifierSubscriptions.splice(c, 1);
        return a.outerValue;
      };
      a.prototype.tryDelay = function(a, b) {
        (a = I(this, a, b)) &&
          !a.closed &&
          (this.destination.add(a), this.delayNotifierSubscriptions.push(a));
      };
      a.prototype.tryComplete = function() {
        this.completed &&
          0 === this.delayNotifierSubscriptions.length &&
          this.destination.complete();
      };
      return a;
    })(S),
    te = (function(b) {
      function a(a, d) {
        var c = b.call(this) || this;
        c.source = a;
        c.subscriptionDelay = d;
        return c;
      }
      h(a, b);
      a.prototype._subscribe = function(a) {
        this.subscriptionDelay.subscribe(new vg(a, this.source));
      };
      return a;
    })(g),
    vg = (function(b) {
      function a(a, d) {
        var c = b.call(this) || this;
        c.parent = a;
        c.source = d;
        c.sourceSubscribed = !1;
        return c;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.subscribeToSource();
      };
      a.prototype._error = function(a) {
        this.unsubscribe();
        this.parent.error(a);
      };
      a.prototype._complete = function() {
        this.unsubscribe();
        this.subscribeToSource();
      };
      a.prototype.subscribeToSource = function() {
        this.sourceSubscribed ||
          ((this.sourceSubscribed = !0),
          this.unsubscribe(),
          this.source.subscribe(this.parent));
      };
      return a;
    })(l),
    ue = (function() {
      function b() {}
      b.prototype.call = function(a, c) {
        return c.subscribe(new wg(a));
      };
      return b;
    })(),
    wg = (function(b) {
      function a(a) {
        return b.call(this, a) || this;
      }
      h(a, b);
      a.prototype._next = function(a) {
        a.observe(this.destination);
      };
      return a;
    })(l),
    ve = (function() {
      function b(a, c) {
        this.keySelector = a;
        this.flushes = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new xg(a, this.keySelector, this.flushes));
      };
      return b;
    })(),
    xg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.keySelector = d;
        a.values = new Set();
        e && a.add(u(e, new t(a)));
        return a;
      }
      h(a, b);
      a.prototype.notifyNext = function() {
        this.values.clear();
      };
      a.prototype.notifyError = function(a) {
        this._error(a);
      };
      a.prototype._next = function(a) {
        this.keySelector ? this._useKeySelector(a) : this._finalizeNext(a, a);
      };
      a.prototype._useKeySelector = function(a) {
        var c,
          b = this.destination;
        try {
          c = this.keySelector(a);
        } catch (f) {
          b.error(f);
          return;
        }
        this._finalizeNext(c, a);
      };
      a.prototype._finalizeNext = function(a, b) {
        var c = this.values;
        c.has(a) || (c.add(a), this.destination.next(b));
      };
      return a;
    })(r),
    we = (function() {
      function b(a, c) {
        this.compare = a;
        this.keySelector = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new yg(a, this.compare, this.keySelector));
      };
      return b;
    })(),
    yg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.keySelector = e;
        a.hasKey = !1;
        'function' === typeof d && (a.compare = d);
        return a;
      }
      h(a, b);
      a.prototype.compare = function(a, b) {
        return a === b;
      };
      a.prototype._next = function(a) {
        var c;
        try {
          var b = this.keySelector;
          c = b ? b(a) : a;
        } catch (k) {
          return this.destination.error(k);
        }
        b = !1;
        if (this.hasKey)
          try {
            var f = this.compare,
              b = f(this.key, c);
          } catch (k) {
            return this.destination.error(k);
          }
        else this.hasKey = !0;
        b || ((this.key = c), this.destination.next(a));
      };
      return a;
    })(l),
    ye = (function() {
      function b(a) {
        this.errorFactory = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new zg(a, this.errorFactory));
      };
      return b;
    })(),
    zg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.errorFactory = d;
        a.hasValue = !1;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.hasValue = !0;
        this.destination.next(a);
      };
      a.prototype._complete = function() {
        if (this.hasValue) return this.destination.complete();
        var a = void 0;
        try {
          a = this.errorFactory();
        } catch (d) {
          a = d;
        }
        this.destination.error(a);
      };
      return a;
    })(l),
    ze = (function() {
      function b(a) {
        this.total = a;
        if (0 > this.total) throw new ba();
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Ag(a, this.total));
      };
      return b;
    })(),
    Ag = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.total = d;
        a.count = 0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        var c = this.total,
          b = ++this.count;
        b <= c &&
          (this.destination.next(a),
          b === c && (this.destination.complete(), this.unsubscribe()));
      };
      return a;
    })(l),
    Ae = (function() {
      function b(a, c, b) {
        this.predicate = a;
        this.thisArg = c;
        this.source = b;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new Bg(a, this.predicate, this.thisArg, this.source),
        );
      };
      return b;
    })(),
    Bg = (function(b) {
      function a(a, d, e, f) {
        a = b.call(this, a) || this;
        a.predicate = d;
        a.thisArg = e;
        a.source = f;
        a.index = 0;
        a.thisArg = e || a;
        return a;
      }
      h(a, b);
      a.prototype.notifyComplete = function(a) {
        this.destination.next(a);
        this.destination.complete();
      };
      a.prototype._next = function(a) {
        var c = !1;
        try {
          c = this.predicate.call(this.thisArg, a, this.index++, this.source);
        } catch (e) {
          this.destination.error(e);
          return;
        }
        c || this.notifyComplete(!1);
      };
      a.prototype._complete = function() {
        this.notifyComplete(!0);
      };
      return a;
    })(l),
    Be = (function() {
      function b() {}
      b.prototype.call = function(a, c) {
        return c.subscribe(new Cg(a));
      };
      return b;
    })(),
    Cg = (function(b) {
      function a(a) {
        a = b.call(this, a) || this;
        a.hasCompleted = !1;
        a.hasSubscription = !1;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.hasSubscription ||
          ((this.hasSubscription = !0), this.add(u(a, new t(this))));
      };
      a.prototype._complete = function() {
        this.hasCompleted = !0;
        this.hasSubscription || this.destination.complete();
      };
      a.prototype.notifyComplete = function() {
        this.hasSubscription = !1;
        this.hasCompleted && this.destination.complete();
      };
      return a;
    })(r),
    Ce = (function() {
      function b(a) {
        this.project = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Dg(a, this.project));
      };
      return b;
    })(),
    Dg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.project = d;
        a.hasSubscription = !1;
        a.hasCompleted = !1;
        a.index = 0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.hasSubscription || this.tryNext(a);
      };
      a.prototype.tryNext = function(a) {
        var c,
          b = this.index++;
        try {
          c = this.project(a, b);
        } catch (f) {
          this.destination.error(f);
          return;
        }
        this.hasSubscription = !0;
        this._innerSub(c);
      };
      a.prototype._innerSub = function(a) {
        var c = new t(this),
          b = this.destination;
        b.add(c);
        a = u(a, c);
        a !== c && b.add(a);
      };
      a.prototype._complete = function() {
        this.hasCompleted = !0;
        this.hasSubscription || this.destination.complete();
        this.unsubscribe();
      };
      a.prototype.notifyNext = function(a) {
        this.destination.next(a);
      };
      a.prototype.notifyError = function(a) {
        this.destination.error(a);
      };
      a.prototype.notifyComplete = function() {
        this.hasSubscription = !1;
        this.hasCompleted && this.destination.complete();
      };
      return a;
    })(r),
    De = (function() {
      function b(a, c, b) {
        this.project = a;
        this.concurrent = c;
        this.scheduler = b;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new Eg(a, this.project, this.concurrent, this.scheduler),
        );
      };
      return b;
    })(),
    Eg = (function(b) {
      function a(a, d, e, f) {
        a = b.call(this, a) || this;
        a.project = d;
        a.concurrent = e;
        a.scheduler = f;
        a.index = 0;
        a.active = 0;
        a.hasCompleted = !1;
        e < Number.POSITIVE_INFINITY && (a.buffer = []);
        return a;
      }
      h(a, b);
      a.dispatch = function(a) {
        a.subscriber.subscribeToProjection(a.result, a.value, a.index);
      };
      a.prototype._next = function(c) {
        var b = this.destination;
        if (b.closed) this._complete();
        else {
          var e = this.index++;
          if (this.active < this.concurrent) {
            b.next(c);
            try {
              var f = this.project,
                g = f(c, e);
              this.scheduler
                ? this.destination.add(
                    this.scheduler.schedule(a.dispatch, 0, {
                      subscriber: this,
                      result: g,
                      value: c,
                      index: e,
                    }),
                  )
                : this.subscribeToProjection(g, c, e);
            } catch (v) {
              b.error(v);
            }
          } else this.buffer.push(c);
        }
      };
      a.prototype.subscribeToProjection = function(a, b, e) {
        this.active++;
        this.destination.add(u(a, new t(this)));
      };
      a.prototype._complete = function() {
        ((this.hasCompleted = !0), 0 === this.active) &&
          this.destination.complete();
        this.unsubscribe();
      };
      a.prototype.notifyNext = function(a) {
        this._next(a);
      };
      a.prototype.notifyComplete = function() {
        var a = this.buffer;
        this.active--;
        a && 0 < a.length && this._next(a.shift());
        this.hasCompleted && 0 === this.active && this.destination.complete();
      };
      return a;
    })(r),
    Ee = (function() {
      function b(a) {
        this.callback = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Fg(a, this.callback));
      };
      return b;
    })(),
    Fg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.add(new p(d));
        return a;
      }
      h(a, b);
      return a;
    })(l),
    Wb = (function() {
      function b(a, c, b, e) {
        this.predicate = a;
        this.source = c;
        this.yieldIndex = b;
        this.thisArg = e;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new Gg(a, this.predicate, this.source, this.yieldIndex, this.thisArg),
        );
      };
      return b;
    })(),
    Gg = (function(b) {
      function a(a, d, e, f, g) {
        a = b.call(this, a) || this;
        a.predicate = d;
        a.source = e;
        a.yieldIndex = f;
        a.thisArg = g;
        a.index = 0;
        return a;
      }
      h(a, b);
      a.prototype.notifyComplete = function(a) {
        var c = this.destination;
        c.next(a);
        c.complete();
        this.unsubscribe();
      };
      a.prototype._next = function(a) {
        var c = this.predicate,
          b = this.thisArg,
          f = this.index++;
        try {
          c.call(b || this, a, f, this.source) &&
            this.notifyComplete(this.yieldIndex ? f : a);
        } catch (k) {
          this.destination.error(k);
        }
      };
      a.prototype._complete = function() {
        this.notifyComplete(this.yieldIndex ? -1 : void 0);
      };
      return a;
    })(l),
    Fe = (function() {
      function b() {}
      b.prototype.call = function(a, c) {
        return c.subscribe(new Hg(a));
      };
      return b;
    })(),
    Hg = (function(b) {
      function a() {
        return (null !== b && b.apply(this, arguments)) || this;
      }
      h(a, b);
      a.prototype._next = function(a) {};
      return a;
    })(l),
    Ge = (function() {
      function b() {}
      b.prototype.call = function(a, c) {
        return c.subscribe(new Ig(a));
      };
      return b;
    })(),
    Ig = (function(b) {
      function a(a) {
        return b.call(this, a) || this;
      }
      h(a, b);
      a.prototype.notifyComplete = function(a) {
        var c = this.destination;
        c.next(a);
        c.complete();
      };
      a.prototype._next = function(a) {
        this.notifyComplete(!1);
      };
      a.prototype._complete = function() {
        this.notifyComplete(!0);
      };
      return a;
    })(l),
    He = (function() {
      function b(a) {
        this.total = a;
        if (0 > this.total) throw new ba();
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Jg(a, this.total));
      };
      return b;
    })(),
    Jg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.total = d;
        a.ring = [];
        a.count = 0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        var c = this.ring,
          b = this.total,
          f = this.count++;
        c.length < b ? c.push(a) : (c[f % b] = a);
      };
      a.prototype._complete = function() {
        var a = this.destination,
          b = this.count;
        if (0 < b)
          for (
            var e = this.count >= this.total ? this.total : this.count,
              f = this.ring,
              g = 0;
            g < e;
            g++
          ) {
            var h = b++ % e;
            a.next(f[h]);
          }
        a.complete();
      };
      return a;
    })(l),
    Ie = (function() {
      function b(a) {
        this.value = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Kg(a, this.value));
      };
      return b;
    })(),
    Kg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.value = d;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.destination.next(this.value);
      };
      return a;
    })(l),
    Je = (function() {
      function b() {}
      b.prototype.call = function(a, c) {
        return c.subscribe(new Lg(a));
      };
      return b;
    })(),
    Lg = (function(b) {
      function a(a) {
        return b.call(this, a) || this;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.destination.next(x.createNext(a));
      };
      a.prototype._error = function(a) {
        var c = this.destination;
        c.next(x.createError(a));
        c.complete();
      };
      a.prototype._complete = function() {
        var a = this.destination;
        a.next(x.createComplete());
        a.complete();
      };
      return a;
    })(l),
    Ke = (function() {
      function b(a, c, b) {
        this.accumulator = a;
        this.seed = c;
        this.concurrent = b;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new Mg(a, this.accumulator, this.seed, this.concurrent),
        );
      };
      return b;
    })(),
    Mg = (function(b) {
      function a(a, d, e, f) {
        a = b.call(this, a) || this;
        a.accumulator = d;
        a.acc = e;
        a.concurrent = f;
        a.hasValue = !1;
        a.hasCompleted = !1;
        a.buffer = [];
        a.active = 0;
        a.index = 0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        if (this.active < this.concurrent) {
          var c = this.index++,
            b = this.destination,
            f = void 0;
          try {
            var g = this.accumulator,
              f = g(this.acc, a, c);
          } catch (v) {
            return b.error(v);
          }
          this.active++;
          this._innerSub(f);
        } else this.buffer.push(a);
      };
      a.prototype._innerSub = function(a) {
        var c = new t(this),
          b = this.destination;
        b.add(c);
        a = u(a, c);
        a !== c && b.add(a);
      };
      a.prototype._complete = function() {
        this.hasCompleted = !0;
        0 === this.active &&
          0 === this.buffer.length &&
          (!1 === this.hasValue && this.destination.next(this.acc),
          this.destination.complete());
        this.unsubscribe();
      };
      a.prototype.notifyNext = function(a) {
        var c = this.destination;
        this.acc = a;
        this.hasValue = !0;
        c.next(a);
      };
      a.prototype.notifyComplete = function() {
        var a = this.buffer;
        this.active--;
        0 < a.length
          ? this._next(a.shift())
          : 0 === this.active &&
            this.hasCompleted &&
            (!1 === this.hasValue && this.destination.next(this.acc),
            this.destination.complete());
      };
      return a;
    })(r),
    Le = (function() {
      function b(a, c) {
        this.subjectFactory = a;
        this.selector = c;
      }
      b.prototype.call = function(a, c) {
        var b = this.selector,
          e = this.subjectFactory();
        a = b(e).subscribe(a);
        a.add(c.subscribe(e));
        return a;
      };
      return b;
    })(),
    Ne = (function() {
      function b(a) {
        this.nextSources = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Ng(a, this.nextSources));
      };
      return b;
    })(),
    Ng = (function(b) {
      function a(a, d) {
        var c = b.call(this, a) || this;
        c.destination = a;
        c.nextSources = d;
        return c;
      }
      h(a, b);
      a.prototype.notifyError = function() {
        this.subscribeToNextSource();
      };
      a.prototype.notifyComplete = function() {
        this.subscribeToNextSource();
      };
      a.prototype._error = function(a) {
        this.subscribeToNextSource();
        this.unsubscribe();
      };
      a.prototype._complete = function() {
        this.subscribeToNextSource();
        this.unsubscribe();
      };
      a.prototype.subscribeToNextSource = function() {
        var a = this.nextSources.shift();
        if (a) {
          var b = new t(this),
            e = this.destination;
          e.add(b);
          a = u(a, b);
          a !== b && e.add(a);
        } else this.destination.complete();
      };
      return a;
    })(r),
    Oe = (function() {
      function b() {}
      b.prototype.call = function(a, c) {
        return c.subscribe(new Og(a));
      };
      return b;
    })(),
    Og = (function(b) {
      function a(a) {
        a = b.call(this, a) || this;
        a.hasPrev = !1;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        var c;
        this.hasPrev ? (c = [this.prev, a]) : (this.hasPrev = !0);
        this.prev = a;
        c && this.destination.next(c);
      };
      return a;
    })(l),
    sc = (function() {
      function b(a, c) {
        this.count = a;
        this.source = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Pg(a, this.count, this.source));
      };
      return b;
    })(),
    Pg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.count = d;
        a.source = e;
        return a;
      }
      h(a, b);
      a.prototype.complete = function() {
        if (!this.isStopped) {
          var a = this.source,
            d = this.count;
          if (0 === d) return b.prototype.complete.call(this);
          -1 < d && (this.count = d - 1);
          a.subscribe(this._unsubscribeAndRecycle());
        }
      };
      return a;
    })(l),
    Qe = (function() {
      function b(a) {
        this.notifier = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Qg(a, this.notifier, c));
      };
      return b;
    })(),
    Qg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.notifier = d;
        a.source = e;
        a.sourceIsBeingSubscribedTo = !0;
        return a;
      }
      h(a, b);
      a.prototype.notifyNext = function() {
        this.sourceIsBeingSubscribedTo = !0;
        this.source.subscribe(this);
      };
      a.prototype.notifyComplete = function() {
        if (!1 === this.sourceIsBeingSubscribedTo)
          return b.prototype.complete.call(this);
      };
      a.prototype.complete = function() {
        this.sourceIsBeingSubscribedTo = !1;
        if (!this.isStopped) {
          this.retries || this.subscribeToRetries();
          if (!this.retriesSubscription || this.retriesSubscription.closed)
            return b.prototype.complete.call(this);
          this._unsubscribeAndRecycle();
          this.notifications.next(void 0);
        }
      };
      a.prototype._unsubscribe = function() {
        var a = this.notifications,
          b = this.retriesSubscription;
        a && (a.unsubscribe(), (this.notifications = void 0));
        b && (b.unsubscribe(), (this.retriesSubscription = void 0));
        this.retries = void 0;
      };
      a.prototype._unsubscribeAndRecycle = function() {
        var a = this._unsubscribe;
        this._unsubscribe = null;
        b.prototype._unsubscribeAndRecycle.call(this);
        this._unsubscribe = a;
        return this;
      };
      a.prototype.subscribeToRetries = function() {
        this.notifications = new w();
        var a;
        try {
          var d = this.notifier;
          a = d(this.notifications);
        } catch (e) {
          return b.prototype.complete.call(this);
        }
        this.retries = a;
        this.retriesSubscription = u(a, new t(this));
      };
      return a;
    })(r),
    Re = (function() {
      function b(a, c) {
        this.count = a;
        this.source = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Rg(a, this.count, this.source));
      };
      return b;
    })(),
    Rg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.count = d;
        a.source = e;
        return a;
      }
      h(a, b);
      a.prototype.error = function(a) {
        if (!this.isStopped) {
          var c = this.source,
            e = this.count;
          if (0 === e) return b.prototype.error.call(this, a);
          -1 < e && (this.count = e - 1);
          c.subscribe(this._unsubscribeAndRecycle());
        }
      };
      return a;
    })(l),
    Se = (function() {
      function b(a, c) {
        this.notifier = a;
        this.source = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Sg(a, this.notifier, this.source));
      };
      return b;
    })(),
    Sg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.notifier = d;
        a.source = e;
        return a;
      }
      h(a, b);
      a.prototype.error = function(a) {
        if (!this.isStopped) {
          var c = this.errors,
            e = this.retries,
            f = this.retriesSubscription;
          if (e) this.retriesSubscription = this.errors = void 0;
          else {
            c = new w();
            try {
              var g = this.notifier,
                e = g(c);
            } catch (v) {
              return b.prototype.error.call(this, v);
            }
            f = u(e, new t(this));
          }
          this._unsubscribeAndRecycle();
          this.errors = c;
          this.retries = e;
          this.retriesSubscription = f;
          c.next(a);
        }
      };
      a.prototype._unsubscribe = function() {
        var a = this.errors,
          b = this.retriesSubscription;
        a && (a.unsubscribe(), (this.errors = void 0));
        b && (b.unsubscribe(), (this.retriesSubscription = void 0));
        this.retries = void 0;
      };
      a.prototype.notifyNext = function() {
        var a = this._unsubscribe;
        this._unsubscribe = null;
        this._unsubscribeAndRecycle();
        this._unsubscribe = a;
        this.source.subscribe(this);
      };
      return a;
    })(r),
    Te = (function() {
      function b(a) {
        this.notifier = a;
      }
      b.prototype.call = function(a, c) {
        a = new Tg(a);
        c = c.subscribe(a);
        c.add(u(this.notifier, new t(a)));
        return c;
      };
      return b;
    })(),
    Tg = (function(b) {
      function a() {
        var a = (null !== b && b.apply(this, arguments)) || this;
        a.hasValue = !1;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.value = a;
        this.hasValue = !0;
      };
      a.prototype.notifyNext = function() {
        this.emitValue();
      };
      a.prototype.notifyComplete = function() {
        this.emitValue();
      };
      a.prototype.emitValue = function() {
        this.hasValue &&
          ((this.hasValue = !1), this.destination.next(this.value));
      };
      return a;
    })(r),
    Ue = (function() {
      function b(a, c) {
        this.period = a;
        this.scheduler = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Ug(a, this.period, this.scheduler));
      };
      return b;
    })(),
    Ug = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.period = d;
        a.scheduler = e;
        a.hasValue = !1;
        a.add(e.schedule(Ve, d, { subscriber: a, period: d }));
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.lastValue = a;
        this.hasValue = !0;
      };
      a.prototype.notifyNext = function() {
        this.hasValue &&
          ((this.hasValue = !1), this.destination.next(this.lastValue));
      };
      return a;
    })(l),
    We = (function() {
      function b(a, c) {
        this.compareTo = a;
        this.comparator = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Vg(a, this.compareTo, this.comparator));
      };
      return b;
    })(),
    Vg = (function(b) {
      function a(a, d, e) {
        var c = b.call(this, a) || this;
        c.compareTo = d;
        c.comparator = e;
        c._a = [];
        c._b = [];
        c._oneComplete = !1;
        c.destination.add(d.subscribe(new Wg(a, c)));
        return c;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this._oneComplete && 0 === this._b.length
          ? this.emit(!1)
          : (this._a.push(a), this.checkValues());
      };
      a.prototype._complete = function() {
        this._oneComplete
          ? this.emit(0 === this._a.length && 0 === this._b.length)
          : (this._oneComplete = !0);
        this.unsubscribe();
      };
      a.prototype.checkValues = function() {
        for (
          var a = this._a, b = this._b, e = this.comparator;
          0 < a.length && 0 < b.length;

        ) {
          var f = a.shift(),
            g = b.shift(),
            h = !1;
          try {
            h = e ? e(f, g) : f === g;
          } catch (n) {
            this.destination.error(n);
          }
          h || this.emit(!1);
        }
      };
      a.prototype.emit = function(a) {
        var c = this.destination;
        c.next(a);
        c.complete();
      };
      a.prototype.nextB = function(a) {
        this._oneComplete && 0 === this._a.length
          ? this.emit(!1)
          : (this._b.push(a), this.checkValues());
      };
      a.prototype.completeB = function() {
        this._oneComplete
          ? this.emit(0 === this._a.length && 0 === this._b.length)
          : (this._oneComplete = !0);
      };
      return a;
    })(l),
    Wg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.parent = d;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.parent.nextB(a);
      };
      a.prototype._error = function(a) {
        this.parent.error(a);
        this.unsubscribe();
      };
      a.prototype._complete = function() {
        this.parent.completeB();
        this.unsubscribe();
      };
      return a;
    })(l),
    Ze = (function() {
      function b(a, c) {
        this.predicate = a;
        this.source = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Xg(a, this.predicate, this.source));
      };
      return b;
    })(),
    Xg = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.predicate = d;
        a.source = e;
        a.seenValue = !1;
        a.index = 0;
        return a;
      }
      h(a, b);
      a.prototype.applySingleValue = function(a) {
        this.seenValue
          ? this.destination.error('Sequence contains more than one element')
          : ((this.seenValue = !0), (this.singleValue = a));
      };
      a.prototype._next = function(a) {
        var c = this.index++;
        this.predicate ? this.tryNext(a, c) : this.applySingleValue(a);
      };
      a.prototype.tryNext = function(a, b) {
        try {
          this.predicate(a, b, this.source) && this.applySingleValue(a);
        } catch (e) {
          this.destination.error(e);
        }
      };
      a.prototype._complete = function() {
        var a = this.destination;
        0 < this.index
          ? (a.next(this.seenValue ? this.singleValue : void 0), a.complete())
          : a.error(new ja());
      };
      return a;
    })(l),
    $e = (function() {
      function b(a) {
        this.total = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new Yg(a, this.total));
      };
      return b;
    })(),
    Yg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.total = d;
        a.count = 0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        ++this.count > this.total && this.destination.next(a);
      };
      return a;
    })(l),
    af = (function() {
      function b(a) {
        this._skipCount = a;
        if (0 > this._skipCount) throw new ba();
      }
      b.prototype.call = function(a, c) {
        return 0 === this._skipCount
          ? c.subscribe(new l(a))
          : c.subscribe(new Zg(a, this._skipCount));
      };
      return b;
    })(),
    Zg = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a._skipCount = d;
        a._count = 0;
        a._ring = Array(d);
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        var c = this._skipCount,
          b = this._count++;
        if (b < c) this._ring[b] = a;
        else {
          var c = b % c,
            b = this._ring,
            f = b[c];
          b[c] = a;
          this.destination.next(f);
        }
      };
      return a;
    })(l),
    bf = (function() {
      function b(a) {
        this.notifier = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new $g(a, this.notifier));
      };
      return b;
    })(),
    $g = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.hasValue = !1;
        var c = new t(a);
        a.add(c);
        a.innerSubscription = c;
        d = u(d, c);
        d !== c && (a.add(d), (a.innerSubscription = d));
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.hasValue && b.prototype._next.call(this, a);
      };
      a.prototype.notifyNext = function() {
        this.hasValue = !0;
        this.innerSubscription && this.innerSubscription.unsubscribe();
      };
      a.prototype.notifyComplete = function() {};
      return a;
    })(r),
    cf = (function() {
      function b(a) {
        this.predicate = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new ah(a, this.predicate));
      };
      return b;
    })(),
    ah = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.predicate = d;
        a.skipping = !0;
        a.index = 0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        var c = this.destination;
        this.skipping && this.tryCallPredicate(a);
        this.skipping || c.next(a);
      };
      a.prototype.tryCallPredicate = function(a) {
        try {
          this.skipping = !!this.predicate(a, this.index++);
        } catch (d) {
          this.destination.error(d);
        }
      };
      return a;
    })(l),
    df = (function() {
      function b(a, c) {
        this.scheduler = a;
        this.delay = c;
      }
      b.prototype.call = function(a, c) {
        return new ag(c, this.delay, this.scheduler).subscribe(a);
      };
      return b;
    })(),
    ef = (function() {
      function b(a) {
        this.project = a;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new bh(a, this.project));
      };
      return b;
    })(),
    bh = (function(b) {
      function a(a, d) {
        a = b.call(this, a) || this;
        a.project = d;
        a.index = 0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        var c,
          b = this.index++;
        try {
          c = this.project(a, b);
        } catch (f) {
          this.destination.error(f);
          return;
        }
        this._innerSub(c);
      };
      a.prototype._innerSub = function(a) {
        var c = this.innerSubscription;
        c && c.unsubscribe();
        var c = new t(this),
          b = this.destination;
        b.add(c);
        this.innerSubscription = u(a, c);
        this.innerSubscription !== c && b.add(this.innerSubscription);
      };
      a.prototype._complete = function() {
        var a = this.innerSubscription;
        (a && !a.closed) || b.prototype._complete.call(this);
        this.unsubscribe();
      };
      a.prototype._unsubscribe = function() {
        this.innerSubscription = void 0;
      };
      a.prototype.notifyComplete = function() {
        this.innerSubscription = void 0;
        this.isStopped && b.prototype._complete.call(this);
      };
      a.prototype.notifyNext = function(a) {
        this.destination.next(a);
      };
      return a;
    })(r),
    ff = (function() {
      function b(a) {
        this.notifier = a;
      }
      b.prototype.call = function(a, c) {
        a = new ch(a);
        var b = u(this.notifier, new t(a));
        return b && !a.seenValue ? (a.add(b), c.subscribe(a)) : a;
      };
      return b;
    })(),
    ch = (function(b) {
      function a(a) {
        a = b.call(this, a) || this;
        a.seenValue = !1;
        return a;
      }
      h(a, b);
      a.prototype.notifyNext = function() {
        this.seenValue = !0;
        this.complete();
      };
      a.prototype.notifyComplete = function() {};
      return a;
    })(r),
    gf = (function() {
      function b(a, c) {
        this.predicate = a;
        this.inclusive = c;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(new dh(a, this.predicate, this.inclusive));
      };
      return b;
    })(),
    dh = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.predicate = d;
        a.inclusive = e;
        a.index = 0;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        var c = this.destination,
          b;
        try {
          b = this.predicate(a, this.index++);
        } catch (f) {
          c.error(f);
          return;
        }
        this.nextOrComplete(a, b);
      };
      a.prototype.nextOrComplete = function(a, b) {
        var c = this.destination;
        b ? c.next(a) : (this.inclusive && c.next(a), c.complete());
      };
      return a;
    })(l),
    hf = (function() {
      function b(a, c, b) {
        this.nextOrObserver = a;
        this.error = c;
        this.complete = b;
      }
      b.prototype.call = function(a, c) {
        return c.subscribe(
          new eh(a, this.nextOrObserver, this.error, this.complete),
        );
      };
      return b;
    })(),
    eh = (function(b) {
      function a(a, d, e, f) {
        a = b.call(this, a) || this;
        a._tapNext = H;
        a._tapError = H;
        a._tapComplete = H;
        a._tapError = e || H;
        a._tapComplete = f || H;
        T(d)
          ? ((a._context = a), (a._tapNext = d))
          : d &&
            ((a._context = d),
            (a._tapNext = d.next || H),
            (a._tapError = d.error || H),
            (a._tapComplete = d.complete || H));
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        try {
          this._tapNext.call(this._context, a);
        } catch (d) {
          this.destination.error(d);
          return;
        }
        this.destination.next(a);
      };
      a.prototype._error = function(a) {
        try {
          this._tapError.call(this._context, a);
        } catch (d) {
          this.destination.error(d);
          return;
        }
        this.destination.error(a);
      };
      a.prototype._complete = function() {
        try {
          this._tapComplete.call(this._context);
        } catch (c) {
          this.destination.error(c);
          return;
        }
        return this.destination.complete();
      };
      return a;
    })(l),
    jf = (function() {
      function b(a, c, b, e) {
        this.duration = a;
        this.scheduler = c;
        this.leading = b;
        this.trailing = e;
      }
      b.prototype.call = function(a, b) {
        return b.subscribe(
          new fh(a, this.duration, this.scheduler, this.leading, this.trailing),
        );
      };
      return b;
    })(),
    fh = (function(b) {
      function a(a, d, e, f, g) {
        a = b.call(this, a) || this;
        a.duration = d;
        a.scheduler = e;
        a.leading = f;
        a.trailing = g;
        a._hasTrailingValue = !1;
        a._trailingValue = null;
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        this.throttled
          ? this.trailing &&
            ((this._trailingValue = a), (this._hasTrailingValue = !0))
          : (this.add(
              (this.throttled = this.scheduler.schedule(kf, this.duration, {
                subscriber: this,
              })),
            ),
            this.leading
              ? this.destination.next(a)
              : this.trailing &&
                ((this._trailingValue = a), (this._hasTrailingValue = !0)));
      };
      a.prototype._complete = function() {
        this._hasTrailingValue && this.destination.next(this._trailingValue);
        this.destination.complete();
      };
      a.prototype.clearThrottle = function() {
        var a = this.throttled;
        a &&
          (this.trailing &&
            this._hasTrailingValue &&
            (this.destination.next(this._trailingValue),
            (this._trailingValue = null),
            (this._hasTrailingValue = !1)),
          a.unsubscribe(),
          this.remove(a),
          (this.throttled = null));
      };
      return a;
    })(l),
    lf = (function() {
      function b(a, b, d, e) {
        this.waitFor = a;
        this.absoluteTimeout = b;
        this.withObservable = d;
        this.scheduler = e;
      }
      b.prototype.call = function(a, b) {
        return b.subscribe(
          new gh(
            a,
            this.absoluteTimeout,
            this.waitFor,
            this.withObservable,
            this.scheduler,
          ),
        );
      };
      return b;
    })(),
    gh = (function(b) {
      function a(a, d, e, f, g) {
        a = b.call(this, a) || this;
        a.absoluteTimeout = d;
        a.waitFor = e;
        a.withObservable = f;
        a.scheduler = g;
        a.scheduleTimeout();
        return a;
      }
      h(a, b);
      a.dispatchTimeout = function(a) {
        var b = a.withObservable;
        a._unsubscribeAndRecycle();
        a.add(u(b, new t(a)));
      };
      a.prototype.scheduleTimeout = function() {
        var b = this.action;
        b
          ? (this.action = b.schedule(this, this.waitFor))
          : this.add(
              (this.action = this.scheduler.schedule(
                a.dispatchTimeout,
                this.waitFor,
                this,
              )),
            );
      };
      a.prototype._next = function(a) {
        this.absoluteTimeout || this.scheduleTimeout();
        b.prototype._next.call(this, a);
      };
      a.prototype._unsubscribe = function() {
        this.action = void 0;
        this.withObservable = this.scheduler = null;
      };
      return a;
    })(r),
    nf = (function() {
      function b(a) {
        this.windowBoundaries = a;
      }
      b.prototype.call = function(a, b) {
        a = new hh(a);
        b = b.subscribe(a);
        b.closed || a.add(u(this.windowBoundaries, new t(a)));
        return b;
      };
      return b;
    })(),
    hh = (function(b) {
      function a(a) {
        var c = b.call(this, a) || this;
        c.window = new w();
        a.next(c.window);
        return c;
      }
      h(a, b);
      a.prototype.notifyNext = function() {
        this.openWindow();
      };
      a.prototype.notifyError = function(a) {
        this._error(a);
      };
      a.prototype.notifyComplete = function() {
        this._complete();
      };
      a.prototype._next = function(a) {
        this.window.next(a);
      };
      a.prototype._error = function(a) {
        this.window.error(a);
        this.destination.error(a);
      };
      a.prototype._complete = function() {
        this.window.complete();
        this.destination.complete();
      };
      a.prototype._unsubscribe = function() {
        this.window = null;
      };
      a.prototype.openWindow = function() {
        var a = this.window;
        a && a.complete();
        var a = this.destination,
          b = (this.window = new w());
        a.next(b);
      };
      return a;
    })(r),
    of = (function() {
      function b(a, b) {
        this.windowSize = a;
        this.startWindowEvery = b;
      }
      b.prototype.call = function(a, b) {
        return b.subscribe(new ih(a, this.windowSize, this.startWindowEvery));
      };
      return b;
    })(),
    ih = (function(b) {
      function a(a, d, e) {
        var c = b.call(this, a) || this;
        c.destination = a;
        c.windowSize = d;
        c.startWindowEvery = e;
        c.windows = [new w()];
        c.count = 0;
        a.next(c.windows[0]);
        return c;
      }
      h(a, b);
      a.prototype._next = function(a) {
        for (
          var b =
              0 < this.startWindowEvery
                ? this.startWindowEvery
                : this.windowSize,
            c = this.destination,
            f = this.windowSize,
            g = this.windows,
            h = g.length,
            l = 0;
          l < h && !this.closed;
          l++
        )
          g[l].next(a);
        a = this.count - f + 1;
        0 <= a && 0 === a % b && !this.closed && g.shift().complete();
        0 !== ++this.count % b ||
          this.closed ||
          ((b = new w()), g.push(b), c.next(b));
      };
      a.prototype._error = function(a) {
        var b = this.windows;
        if (b) for (; 0 < b.length && !this.closed; ) b.shift().error(a);
        this.destination.error(a);
      };
      a.prototype._complete = function() {
        var a = this.windows;
        if (a) for (; 0 < a.length && !this.closed; ) a.shift().complete();
        this.destination.complete();
      };
      a.prototype._unsubscribe = function() {
        this.count = 0;
        this.windows = null;
      };
      return a;
    })(l),
    pf = (function() {
      function b(a, b, d, e) {
        this.windowTimeSpan = a;
        this.windowCreationInterval = b;
        this.maxWindowSize = d;
        this.scheduler = e;
      }
      b.prototype.call = function(a, b) {
        return b.subscribe(
          new jh(
            a,
            this.windowTimeSpan,
            this.windowCreationInterval,
            this.maxWindowSize,
            this.scheduler,
          ),
        );
      };
      return b;
    })(),
    kh = (function(b) {
      function a() {
        var a = (null !== b && b.apply(this, arguments)) || this;
        a._numberOfNextedValues = 0;
        return a;
      }
      h(a, b);
      a.prototype.next = function(a) {
        this._numberOfNextedValues++;
        b.prototype.next.call(this, a);
      };
      Object.defineProperty(a.prototype, 'numberOfNextedValues', {
        get: function() {
          return this._numberOfNextedValues;
        },
        enumerable: !0,
        configurable: !0,
      });
      return a;
    })(w),
    jh = (function(b) {
      function a(a, d, e, f, g) {
        var c = b.call(this, a) || this;
        c.destination = a;
        c.windowTimeSpan = d;
        c.windowCreationInterval = e;
        c.maxWindowSize = f;
        c.scheduler = g;
        c.windows = [];
        a = c.openWindow();
        null !== e && 0 <= e
          ? ((f = {
              windowTimeSpan: d,
              windowCreationInterval: e,
              subscriber: c,
              scheduler: g,
            }),
            c.add(
              g.schedule(Tc, d, { subscriber: c, window: a, context: null }),
            ),
            c.add(g.schedule(rf, e, f)))
          : c.add(
              g.schedule(qf, d, {
                subscriber: c,
                window: a,
                windowTimeSpan: d,
              }),
            );
        return c;
      }
      h(a, b);
      a.prototype._next = function(a) {
        for (var b = this.windows, c = b.length, f = 0; f < c; f++) {
          var g = b[f];
          g.closed ||
            (g.next(a),
            g.numberOfNextedValues >= this.maxWindowSize &&
              this.closeWindow(g));
        }
      };
      a.prototype._error = function(a) {
        for (var b = this.windows; 0 < b.length; ) b.shift().error(a);
        this.destination.error(a);
      };
      a.prototype._complete = function() {
        for (var a = this.windows; 0 < a.length; ) {
          var b = a.shift();
          b.closed || b.complete();
        }
        this.destination.complete();
      };
      a.prototype.openWindow = function() {
        var a = new kh();
        this.windows.push(a);
        this.destination.next(a);
        return a;
      };
      a.prototype.closeWindow = function(a) {
        a.complete();
        var b = this.windows;
        b.splice(b.indexOf(a), 1);
      };
      return a;
    })(l),
    sf = (function() {
      function b(a, b) {
        this.openings = a;
        this.closingSelector = b;
      }
      b.prototype.call = function(a, b) {
        return b.subscribe(new lh(a, this.openings, this.closingSelector));
      };
      return b;
    })(),
    lh = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.openings = d;
        a.closingSelector = e;
        a.contexts = [];
        a.add((a.openSubscription = I(a, d, d)));
        return a;
      }
      h(a, b);
      a.prototype._next = function(a) {
        var b = this.contexts;
        if (b) for (var c = b.length, f = 0; f < c; f++) b[f].window.next(a);
      };
      a.prototype._error = function(a) {
        var c = this.contexts;
        this.contexts = null;
        if (c)
          for (var e = c.length, f = -1; ++f < e; ) {
            var g = c[f];
            g.window.error(a);
            g.subscription.unsubscribe();
          }
        b.prototype._error.call(this, a);
      };
      a.prototype._complete = function() {
        var a = this.contexts;
        this.contexts = null;
        if (a)
          for (var d = a.length, e = -1; ++e < d; ) {
            var f = a[e];
            f.window.complete();
            f.subscription.unsubscribe();
          }
        b.prototype._complete.call(this);
      };
      a.prototype._unsubscribe = function() {
        var a = this.contexts;
        this.contexts = null;
        if (a)
          for (var b = a.length, e = -1; ++e < b; ) {
            var f = a[e];
            f.window.unsubscribe();
            f.subscription.unsubscribe();
          }
      };
      a.prototype.notifyNext = function(a, b, e, f, g) {
        if (a === this.openings) {
          a = void 0;
          try {
            var c = this.closingSelector;
            a = c(b);
          } catch (n) {
            return this.error(n);
          }
          b = new w();
          c = new p();
          e = { window: b, subscription: c };
          this.contexts.push(e);
          a = I(this, a, e);
          a.closed
            ? this.closeWindow(this.contexts.length - 1)
            : ((a.context = e), c.add(a));
          this.destination.next(b);
        } else this.closeWindow(this.contexts.indexOf(a));
      };
      a.prototype.notifyError = function(a) {
        this.error(a);
      };
      a.prototype.notifyComplete = function(a) {
        a !== this.openSubscription &&
          this.closeWindow(this.contexts.indexOf(a.context));
      };
      a.prototype.closeWindow = function(a) {
        if (-1 !== a) {
          var b = this.contexts,
            c = b[a],
            f = c.window,
            c = c.subscription;
          b.splice(a, 1);
          f.complete();
          c.unsubscribe();
        }
      };
      return a;
    })(S),
    tf = (function() {
      function b(a) {
        this.closingSelector = a;
      }
      b.prototype.call = function(a, b) {
        return b.subscribe(new mh(a, this.closingSelector));
      };
      return b;
    })(),
    mh = (function(b) {
      function a(a, d) {
        var c = b.call(this, a) || this;
        c.destination = a;
        c.closingSelector = d;
        c.openWindow();
        return c;
      }
      h(a, b);
      a.prototype.notifyNext = function(a, b, e, f, g) {
        this.openWindow(g);
      };
      a.prototype.notifyError = function(a) {
        this._error(a);
      };
      a.prototype.notifyComplete = function(a) {
        this.openWindow(a);
      };
      a.prototype._next = function(a) {
        this.window.next(a);
      };
      a.prototype._error = function(a) {
        this.window.error(a);
        this.destination.error(a);
        this.unsubscribeClosingNotification();
      };
      a.prototype._complete = function() {
        this.window.complete();
        this.destination.complete();
        this.unsubscribeClosingNotification();
      };
      a.prototype.unsubscribeClosingNotification = function() {
        this.closingNotification && this.closingNotification.unsubscribe();
      };
      a.prototype.openWindow = function(a) {
        void 0 === a && (a = null);
        a && (this.remove(a), a.unsubscribe());
        (a = this.window) && a.complete();
        a = this.window = new w();
        this.destination.next(a);
        var b;
        try {
          var c = this.closingSelector;
          b = c();
        } catch (f) {
          this.destination.error(f);
          this.window.error(f);
          return;
        }
        this.add((this.closingNotification = I(this, b)));
      };
      return a;
    })(S),
    uf = (function() {
      function b(a, b) {
        this.observables = a;
        this.project = b;
      }
      b.prototype.call = function(a, b) {
        return b.subscribe(new nh(a, this.observables, this.project));
      };
      return b;
    })(),
    nh = (function(b) {
      function a(a, d, e) {
        a = b.call(this, a) || this;
        a.observables = d;
        a.project = e;
        a.toRespond = [];
        e = d.length;
        a.values = Array(e);
        for (var c = 0; c < e; c++) a.toRespond.push(c);
        for (c = 0; c < e; c++) a.add(I(a, d[c], void 0, c));
        return a;
      }
      h(a, b);
      a.prototype.notifyNext = function(a, b, e) {
        this.values[e] = b;
        a = this.toRespond;
        0 < a.length && ((e = a.indexOf(e)), -1 !== e && a.splice(e, 1));
      };
      a.prototype.notifyComplete = function() {};
      a.prototype._next = function(a) {
        0 === this.toRespond.length &&
          ((a = [a].concat(this.values)),
          this.project ? this._tryProject(a) : this.destination.next(a));
      };
      a.prototype._tryProject = function(a) {
        var b;
        try {
          b = this.project.apply(this, a);
        } catch (e) {
          this.destination.error(e);
          return;
        }
        this.destination.next(b);
      };
      return a;
    })(S),
    oh = Object.freeze({
      audit: La,
      auditTime: wb,
      buffer: xb,
      bufferCount: yb,
      bufferTime: zb,
      bufferToggle: Cb,
      bufferWhen: Db,
      catchError: Eb,
      combineAll: Fb,
      combineLatest: function() {
        for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
        var c = null;
        'function' === typeof b[b.length - 1] && (c = b.pop());
        1 === b.length && z(b[0]) && (b = b[0].slice());
        return function(a) {
          return a.lift.call(G([a].concat(b)), new ta(c));
        };
      },
      concat: function() {
        for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
        return function(a) {
          return a.lift.call(Y.apply(void 0, [a].concat(b)));
        };
      },
      concatAll: Ga,
      concatMap: Ma,
      concatMapTo: Gb,
      count: Hb,
      debounce: Ib,
      debounceTime: Jb,
      defaultIfEmpty: aa,
      delay: Kb,
      delayWhen: Lb,
      dematerialize: Nb,
      distinct: Ob,
      distinctUntilChanged: Na,
      distinctUntilKeyChanged: Pb,
      elementAt: Qb,
      endWith: function() {
        for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
        return function(a) {
          return Y(a, ia.apply(void 0, b));
        };
      },
      every: Rb,
      exhaust: Sb,
      exhaustMap: Oa,
      expand: Tb,
      filter: P,
      finalize: Ub,
      find: Vb,
      findIndex: Xb,
      first: Yb,
      groupBy: Za,
      ignoreElements: Zb,
      isEmpty: $b,
      last: ac,
      map: A,
      mapTo: bc,
      materialize: cc,
      max: dc,
      merge: function() {
        for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
        return function(a) {
          return a.lift.call(Ia.apply(void 0, [a].concat(b)));
        };
      },
      mergeAll: qa,
      mergeMap: J,
      flatMap: J,
      mergeMapTo: ec,
      mergeScan: fc,
      min: gc,
      multicast: L,
      observeOn: ab,
      onErrorResumeNext: hc,
      pairwise: ic,
      partition: jc,
      pluck: kc,
      publish: lc,
      publishBehavior: mc,
      publishLast: oc,
      publishReplay: pc,
      race: qc,
      reduce: ca,
      repeat: rc,
      repeatWhen: tc,
      retry: uc,
      retryWhen: vc,
      refCount: Ca,
      sample: wc,
      sampleTime: xc,
      scan: Z,
      sequenceEqual: yc,
      share: zc,
      shareReplay: Pa,
      single: Ac,
      skip: Bc,
      skipLast: Cc,
      skipUntil: Dc,
      skipWhile: Ec,
      startWith: Fc,
      subscribeOn: Gc,
      switchAll: Hc,
      switchMap: ea,
      switchMapTo: Ic,
      take: va,
      takeLast: ka,
      takeUntil: Jc,
      takeWhile: Kc,
      tap: Lc,
      throttle: ub,
      throttleTime: Mc,
      throwIfEmpty: ua,
      timeInterval: sb,
      timeout: Nc,
      timeoutWith: Qa,
      timestamp: qb,
      toArray: Pc,
      window: Qc,
      windowCount: Rc,
      windowTime: Sc,
      windowToggle: Uc,
      windowWhen: Vc,
      withLatestFrom: Wc,
      zip: function() {
        for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
        return function(a) {
          return a.lift.call(Ka.apply(void 0, [a].concat(b)));
        };
      },
      zipAll: Xc,
    });
  g.prototype.buffer = function(b) {
    return xb(b)(this);
  };
  g.prototype.bufferCount = function(b, a) {
    void 0 === a && (a = null);
    return yb(b, a)(this);
  };
  g.prototype.bufferTime = function(b) {
    var a = arguments.length,
      c = D;
    y(arguments[arguments.length - 1]) &&
      ((c = arguments[arguments.length - 1]), a--);
    var d = null;
    2 <= a && (d = arguments[1]);
    var e = Number.POSITIVE_INFINITY;
    3 <= a && (e = arguments[2]);
    return zb(b, d, e, c)(this);
  };
  g.prototype.bufferToggle = function(b, a) {
    return Cb(b, a)(this);
  };
  g.prototype.bufferWhen = function(b) {
    return Db(b)(this);
  };
  g.prototype.catch = Yc;
  g.prototype._catch = Yc;
  g.prototype.combineAll = function(b) {
    return Fb(b)(this);
  };
  g.prototype.combineLatest = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    a = null;
    'function' === typeof b[b.length - 1] && (a = b.pop());
    1 === b.length && z(b[0]) && (b = b[0].slice());
    return this.lift.call(ia.apply(void 0, [this].concat(b)), new ta(a));
  };
  g.prototype.concat = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return this.lift.call(Y.apply(void 0, [this].concat(b)));
  };
  g.prototype.concatAll = function() {
    return Ga()(this);
  };
  g.prototype.concatMap = function(b) {
    return Ma(b)(this);
  };
  g.prototype.concatMapTo = function(b) {
    return Gb(b)(this);
  };
  g.prototype.count = function(b) {
    return Hb(b)(this);
  };
  g.prototype.dematerialize = function() {
    return Nb()(this);
  };
  g.prototype.debounce = function(b) {
    return Ib(b)(this);
  };
  g.prototype.debounceTime = function(b, a) {
    void 0 === a && (a = D);
    return Jb(b, a)(this);
  };
  g.prototype.defaultIfEmpty = function(b) {
    void 0 === b && (b = null);
    return aa(b)(this);
  };
  g.prototype.delay = function(b, a) {
    void 0 === a && (a = D);
    return Kb(b, a)(this);
  };
  g.prototype.delayWhen = function(b, a) {
    return Lb(b, a)(this);
  };
  g.prototype.distinct = function(b, a) {
    return Ob(b, a)(this);
  };
  g.prototype.distinctUntilChanged = function(b, a) {
    return Na(b, a)(this);
  };
  g.prototype.distinctUntilKeyChanged = function(b, a) {
    return Pb(b, a)(this);
  };
  g.prototype.do = Zc;
  g.prototype._do = Zc;
  g.prototype.exhaust = function() {
    return Sb()(this);
  };
  g.prototype.exhaustMap = function(b) {
    return Oa(b)(this);
  };
  g.prototype.expand = function(b, a, c) {
    void 0 === a && (a = Number.POSITIVE_INFINITY);
    void 0 === c && (c = void 0);
    a = 1 > (a || 0) ? Number.POSITIVE_INFINITY : a;
    return Tb(b, a, c)(this);
  };
  g.prototype.elementAt = function(b, a) {
    return Qb.apply(void 0, arguments)(this);
  };
  g.prototype.filter = function(b, a) {
    return P(b, a)(this);
  };
  g.prototype.finally = $c;
  g.prototype._finally = $c;
  g.prototype.find = function(b, a) {
    return Vb(b, a)(this);
  };
  g.prototype.findIndex = function(b, a) {
    return Xb(b, a)(this);
  };
  g.prototype.first = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return Yb.apply(void 0, b)(this);
  };
  g.prototype.groupBy = function(b, a, c, d) {
    return Za(b, a, c, d)(this);
  };
  g.prototype.ignoreElements = function() {
    return Zb()(this);
  };
  g.prototype.isEmpty = function() {
    return $b()(this);
  };
  g.prototype.audit = function(b) {
    return La(b)(this);
  };
  g.prototype.auditTime = function(b, a) {
    void 0 === a && (a = D);
    return wb(b, a)(this);
  };
  g.prototype.last = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return ac.apply(void 0, b)(this);
  };
  g.prototype.let = ad;
  g.prototype.letBind = ad;
  g.prototype.every = function(b, a) {
    return Rb(b, a)(this);
  };
  g.prototype.map = function(b, a) {
    return A(b, a)(this);
  };
  g.prototype.mapTo = function(b) {
    return bc(b)(this);
  };
  g.prototype.materialize = function() {
    return cc()(this);
  };
  g.prototype.max = function(b) {
    return dc(b)(this);
  };
  g.prototype.merge = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return this.lift.call(Ia.apply(void 0, [this].concat(b)));
  };
  g.prototype.mergeAll = function(b) {
    void 0 === b && (b = Number.POSITIVE_INFINITY);
    return qa(b)(this);
  };
  g.prototype.mergeMap = bd;
  g.prototype.flatMap = bd;
  g.prototype.flatMapTo = cd;
  g.prototype.mergeMapTo = cd;
  g.prototype.mergeScan = function(b, a, c) {
    void 0 === c && (c = Number.POSITIVE_INFINITY);
    return fc(b, a, c)(this);
  };
  g.prototype.min = function(b) {
    return gc(b)(this);
  };
  g.prototype.multicast = function(b, a) {
    return L(b, a)(this);
  };
  g.prototype.observeOn = function(b, a) {
    void 0 === a && (a = 0);
    return ab(b, a)(this);
  };
  g.prototype.onErrorResumeNext = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return hc.apply(void 0, b)(this);
  };
  g.prototype.pairwise = function() {
    return ic()(this);
  };
  g.prototype.partition = function(b, a) {
    return jc(b, a)(this);
  };
  g.prototype.pluck = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return kc.apply(void 0, b)(this);
  };
  g.prototype.publish = function(b) {
    return lc(b)(this);
  };
  g.prototype.publishBehavior = function(b) {
    return mc(b)(this);
  };
  g.prototype.publishReplay = function(b, a, c, d) {
    return pc(b, a, c, d)(this);
  };
  g.prototype.publishLast = function() {
    return oc()(this);
  };
  g.prototype.race = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return qc.apply(void 0, b)(this);
  };
  g.prototype.reduce = function(b, a) {
    return 2 <= arguments.length ? ca(b, a)(this) : ca(b)(this);
  };
  g.prototype.repeat = function(b) {
    void 0 === b && (b = -1);
    return rc(b)(this);
  };
  g.prototype.repeatWhen = function(b) {
    return tc(b)(this);
  };
  g.prototype.retry = function(b) {
    void 0 === b && (b = -1);
    return uc(b)(this);
  };
  g.prototype.retryWhen = function(b) {
    return vc(b)(this);
  };
  g.prototype.sample = function(b) {
    return wc(b)(this);
  };
  g.prototype.sampleTime = function(b, a) {
    void 0 === a && (a = D);
    return xc(b, a)(this);
  };
  g.prototype.scan = function(b, a) {
    return 2 <= arguments.length ? Z(b, a)(this) : Z(b)(this);
  };
  g.prototype.sequenceEqual = function(b, a) {
    return yc(b, a)(this);
  };
  g.prototype.share = function() {
    return zc()(this);
  };
  g.prototype.shareReplay = function(b, a, c) {
    return b && 'object' === typeof b ? Pa(b)(this) : Pa(b, a, c)(this);
  };
  g.prototype.single = function(b) {
    return Ac(b)(this);
  };
  g.prototype.skip = function(b) {
    return Bc(b)(this);
  };
  g.prototype.skipLast = function(b) {
    return Cc(b)(this);
  };
  g.prototype.skipUntil = function(b) {
    return Dc(b)(this);
  };
  g.prototype.skipWhile = function(b) {
    return Ec(b)(this);
  };
  g.prototype.startWith = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return Fc.apply(void 0, b)(this);
  };
  g.prototype.subscribeOn = function(b, a) {
    void 0 === a && (a = 0);
    return Gc(b, a)(this);
  };
  g.prototype.switch = dd;
  g.prototype._switch = dd;
  g.prototype.switchMap = function(b) {
    return ea(b)(this);
  };
  g.prototype.switchMapTo = function(b) {
    return Ic(b)(this);
  };
  g.prototype.take = function(b) {
    return va(b)(this);
  };
  g.prototype.takeLast = function(b) {
    return ka(b)(this);
  };
  g.prototype.takeUntil = function(b) {
    return Jc(b)(this);
  };
  g.prototype.takeWhile = function(b) {
    return Kc(b)(this);
  };
  g.prototype.throttle = function(b, a) {
    void 0 === a && (a = sa);
    return ub(b, a)(this);
  };
  g.prototype.throttleTime = function(b, a, c) {
    void 0 === a && (a = D);
    void 0 === c && (c = sa);
    return Mc(b, a, c)(this);
  };
  g.prototype.timeInterval = function(b) {
    void 0 === b && (b = D);
    return sb(b)(this);
  };
  g.prototype.timeout = function(b, a) {
    void 0 === a && (a = D);
    return Nc(b, a)(this);
  };
  g.prototype.timeoutWith = function(b, a, c) {
    void 0 === c && (c = D);
    return Qa(b, a, c)(this);
  };
  g.prototype.timestamp = function(b) {
    void 0 === b && (b = D);
    return qb(b)(this);
  };
  g.prototype.toArray = function() {
    return Pc()(this);
  };
  g.prototype.window = function(b) {
    return Qc(b)(this);
  };
  g.prototype.windowCount = function(b, a) {
    void 0 === a && (a = 0);
    return Rc(b, a)(this);
  };
  g.prototype.windowTime = function(b, a, c, d) {
    var e = D,
      f = null,
      g = Number.POSITIVE_INFINITY;
    y(d) && (e = d);
    y(c) ? (e = c) : K(c) && (g = Number(c));
    y(a) ? (e = a) : K(a) && (f = Number(a));
    return Sc(b, f, g, e)(this);
  };
  g.prototype.windowToggle = function(b, a) {
    return Uc(b, a)(this);
  };
  g.prototype.windowWhen = function(b) {
    return Vc(b)(this);
  };
  g.prototype.withLatestFrom = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return Wc.apply(void 0, b)(this);
  };
  g.prototype.zip = function() {
    for (var b = [], a = 0; a < arguments.length; a++) b[a] = arguments[a];
    return this.lift.call(Ka.apply(void 0, [this].concat(b)));
  };
  g.prototype.zipAll = function(b) {
    return Xc(b)(this);
  };
  var oa = (function() {
      return function(b, a) {
        void 0 === a && (a = Number.POSITIVE_INFINITY);
        this.subscribedFrame = b;
        this.unsubscribedFrame = a;
      };
    })(),
    sd = (function() {
      function b() {
        this.subscriptions = [];
      }
      b.prototype.logSubscribedFrame = function() {
        this.subscriptions.push(new oa(this.scheduler.now()));
        return this.subscriptions.length - 1;
      };
      b.prototype.logUnsubscribedFrame = function(a) {
        var b = this.subscriptions;
        b[a] = new oa(b[a].subscribedFrame, this.scheduler.now());
      };
      return b;
    })(),
    Va = (function(b) {
      function a(a, d) {
        var c =
          b.call(this, function(a) {
            var b = this,
              c = b.logSubscribedFrame(),
              d = new p();
            d.add(
              new p(function() {
                b.logUnsubscribedFrame(c);
              }),
            );
            b.scheduleMessages(a);
            return d;
          }) || this;
        c.messages = a;
        c.subscriptions = [];
        c.scheduler = d;
        return c;
      }
      h(a, b);
      a.prototype.scheduleMessages = function(a) {
        for (var b = this.messages.length, c = 0; c < b; c++) {
          var f = this.messages[c];
          a.add(
            this.scheduler.schedule(
              function(a) {
                a.message.notification.observe(a.subscriber);
              },
              f.frame,
              { message: f, subscriber: a },
            ),
          );
        }
      };
      return a;
    })(g);
  vb(Va, [sd]);
  var td = (function(b) {
    function a(a, d) {
      var c = b.call(this) || this;
      c.messages = a;
      c.subscriptions = [];
      c.scheduler = d;
      return c;
    }
    h(a, b);
    a.prototype._subscribe = function(a) {
      var c = this,
        e = c.logSubscribedFrame(),
        f = new p();
      f.add(
        new p(function() {
          c.logUnsubscribedFrame(e);
        }),
      );
      f.add(b.prototype._subscribe.call(this, a));
      return f;
    };
    a.prototype.setup = function() {
      for (var a = this, b = a.messages.length, e = 0; e < b; e++)
        (function() {
          var b = a.messages[e];
          a.scheduler.schedule(function() {
            b.notification.observe(a);
          }, b.frame);
        })();
    };
    return a;
  })(w);
  vb(td, [sd]);
  var ud = (function(b) {
      function a(a) {
        var c = b.call(this, od, 750) || this;
        c.assertDeepEqual = a;
        c.hotObservables = [];
        c.coldObservables = [];
        c.flushTests = [];
        c.runMode = !1;
        return c;
      }
      h(a, b);
      a.prototype.createTime = function(b) {
        b = b.indexOf('|');
        if (-1 === b)
          throw Error(
            'marble diagram for time should have a completion marker "|"',
          );
        return b * a.frameTimeFactor;
      };
      a.prototype.createColdObservable = function(b, d, e) {
        if (-1 !== b.indexOf('^'))
          throw Error('cold observable cannot have subscription offset "^"');
        if (-1 !== b.indexOf('!'))
          throw Error('cold observable cannot have unsubscription marker "!"');
        b = a.parseMarbles(b, d, e, void 0, this.runMode);
        b = new Va(b, this);
        this.coldObservables.push(b);
        return b;
      };
      a.prototype.createHotObservable = function(b, d, e) {
        if (-1 !== b.indexOf('!'))
          throw Error('hot observable cannot have unsubscription marker "!"');
        b = a.parseMarbles(b, d, e, void 0, this.runMode);
        b = new td(b, this);
        this.hotObservables.push(b);
        return b;
      };
      a.prototype.materializeInnerObservable = function(a, b) {
        var c = this,
          d = [];
        a.subscribe(
          function(a) {
            d.push({ frame: c.frame - b, notification: x.createNext(a) });
          },
          function(a) {
            d.push({ frame: c.frame - b, notification: x.createError(a) });
          },
          function() {
            d.push({ frame: c.frame - b, notification: x.createComplete() });
          },
        );
        return d;
      };
      a.prototype.expectObservable = function(b, d) {
        var c = this;
        void 0 === d && (d = null);
        var f = [],
          h = { actual: f, ready: !1 };
        d = a.parseMarblesAsSubscriptions(d, this.runMode);
        var l = d.unsubscribedFrame,
          n;
        this.schedule(
          function() {
            n = b.subscribe(
              function(a) {
                var b = a;
                a instanceof g &&
                  (b = c.materializeInnerObservable(b, c.frame));
                f.push({ frame: c.frame, notification: x.createNext(b) });
              },
              function(a) {
                f.push({ frame: c.frame, notification: x.createError(a) });
              },
              function() {
                f.push({ frame: c.frame, notification: x.createComplete() });
              },
            );
          },
          d.subscribedFrame === Number.POSITIVE_INFINITY
            ? 0
            : d.subscribedFrame,
        );
        l !== Number.POSITIVE_INFINITY &&
          this.schedule(function() {
            return n.unsubscribe();
          }, l);
        this.flushTests.push(h);
        var m = this.runMode;
        return {
          toBe: function(b, c, d) {
            h.ready = !0;
            h.expected = a.parseMarbles(b, c, d, !0, m);
          },
        };
      };
      a.prototype.expectSubscriptions = function(b) {
        var c = { actual: b, ready: !1 };
        this.flushTests.push(c);
        var e = this.runMode;
        return {
          toBe: function(b) {
            b = 'string' === typeof b ? [b] : b;
            c.ready = !0;
            c.expected = b.map(function(b) {
              return a.parseMarblesAsSubscriptions(b, e);
            });
          },
        };
      };
      a.prototype.flush = function() {
        for (var a = this, d = this.hotObservables; 0 < d.length; )
          d.shift().setup();
        b.prototype.flush.call(this);
        this.flushTests = this.flushTests.filter(function(b) {
          return b.ready ? (a.assertDeepEqual(b.actual, b.expected), !1) : !0;
        });
      };
      a.parseMarblesAsSubscriptions = function(a, b) {
        var c = this;
        void 0 === b && (b = !1);
        if ('string' !== typeof a) return new oa(Number.POSITIVE_INFINITY);
        for (
          var d = a.length,
            g = -1,
            h = Number.POSITIVE_INFINITY,
            l = Number.POSITIVE_INFINITY,
            m = 0,
            q = function(d) {
              var e = m,
                f = function(a) {
                  e += a * c.frameTimeFactor;
                },
                k = a[d];
              switch (k) {
                case ' ':
                  b || f(1);
                  break;
                case '-':
                  f(1);
                  break;
                case '(':
                  g = m;
                  f(1);
                  break;
                case ')':
                  g = -1;
                  f(1);
                  break;
                case '^':
                  if (h !== Number.POSITIVE_INFINITY)
                    throw Error(
                      "found a second subscription point '^' in a subscription marble diagram. There can only be one.",
                    );
                  h = -1 < g ? g : m;
                  f(1);
                  break;
                case '!':
                  if (l !== Number.POSITIVE_INFINITY)
                    throw Error(
                      "found a second subscription point '^' in a subscription marble diagram. There can only be one.",
                    );
                  l = -1 < g ? g : m;
                  break;
                default:
                  if (
                    b &&
                    k.match(/^[0-9]$/) &&
                    (0 === d || ' ' === a[d - 1])
                  ) {
                    var n = a.slice(d).match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
                    if (n) {
                      d += n[0].length - 1;
                      var k = parseFloat(n[1]),
                        q = void 0;
                      switch (n[2]) {
                        case 'ms':
                          q = k;
                          break;
                        case 's':
                          q = 1e3 * k;
                          break;
                        case 'm':
                          q = 6e4 * k;
                      }
                      f(q / p.frameTimeFactor);
                      break;
                    }
                  }
                  throw Error(
                    "there can only be '^' and '!' markers in a subscription marble diagram. Found instead '" +
                      k +
                      "'.",
                  );
              }
              m = e;
              u = d;
            },
            p = this,
            u,
            t = 0;
          t < d;
          t++
        )
          q(t), (t = u);
        return 0 > l ? new oa(h) : new oa(h, l);
      };
      a.parseMarbles = function(a, b, e, f, g) {
        var c = this;
        void 0 === f && (f = !1);
        void 0 === g && (g = !1);
        if (-1 !== a.indexOf('!'))
          throw Error(
            'conventional marble diagrams cannot have the unsubscription marker "!"',
          );
        for (
          var d = a.length,
            h = [],
            k = g ? a.replace(/^[ ]+/, '').indexOf('^') : a.indexOf('^'),
            l = -1 === k ? 0 : k * -this.frameTimeFactor,
            m =
              'object' !== typeof b
                ? function(a) {
                    return a;
                  }
                : function(a) {
                    return f && b[a] instanceof Va ? b[a].messages : b[a];
                  },
            p = -1,
            k = function(b) {
              var d = l,
                f = function(a) {
                  d += a * c.frameTimeFactor;
                },
                k = void 0,
                n = a[b];
              switch (n) {
                case ' ':
                  g || f(1);
                  break;
                case '-':
                  f(1);
                  break;
                case '(':
                  p = l;
                  f(1);
                  break;
                case ')':
                  p = -1;
                  f(1);
                  break;
                case '|':
                  k = x.createComplete();
                  f(1);
                  break;
                case '^':
                  f(1);
                  break;
                case '#':
                  k = x.createError(e || 'error');
                  f(1);
                  break;
                default:
                  if (
                    g &&
                    n.match(/^[0-9]$/) &&
                    (0 === b || ' ' === a[b - 1])
                  ) {
                    var q = a.slice(b).match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
                    if (q) {
                      b += q[0].length - 1;
                      var n = parseFloat(q[1]),
                        r = void 0;
                      switch (q[2]) {
                        case 'ms':
                          r = n;
                          break;
                        case 's':
                          r = 1e3 * n;
                          break;
                        case 'm':
                          r = 6e4 * n;
                      }
                      f(r / t.frameTimeFactor);
                      break;
                    }
                  }
                  k = x.createNext(m(n));
                  f(1);
              }
              k && h.push({ frame: -1 < p ? p : l, notification: k });
              l = d;
              u = b;
            },
            t = this,
            u,
            r = 0;
          r < d;
          r++
        )
          k(r), (r = u);
        return h;
      };
      a.prototype.run = function(b) {
        var c = a.frameTimeFactor,
          e = this.maxFrames;
        a.frameTimeFactor = 1;
        this.maxFrames = Number.POSITIVE_INFINITY;
        this.runMode = !0;
        R.delegate = this;
        var f = {
          cold: this.createColdObservable.bind(this),
          hot: this.createHotObservable.bind(this),
          flush: this.flush.bind(this),
          expectObservable: this.expectObservable.bind(this),
          expectSubscriptions: this.expectSubscriptions.bind(this),
        };
        try {
          var g = b(f);
          this.flush();
          return g;
        } finally {
          (a.frameTimeFactor = c),
            (this.maxFrames = e),
            (this.runMode = !1),
            (R.delegate = void 0);
        }
      };
      return a;
    })(pd),
    ph = Object.freeze({ TestScheduler: ud }),
    qh = { asap: ya, queue: kd, animationFrame: If, async: D },
    rh = { rxSubscriber: la, observable: X, iterator: F };
  m.testing = ph;
  m.ajax = dg;
  m.webSocket = eg;
  m.operators = oh;
  m.Scheduler = qh;
  m.Symbol = rh;
  m.Observable = g;
  m.Subject = w;
  m.AnonymousSubject = xa;
  m.config = E;
  m.Subscription = p;
  m.ReplaySubject = da;
  m.BehaviorSubject = nc;
  m.Notification = x;
  m.EmptyError = ja;
  m.ArgumentOutOfRangeError = ba;
  m.ObjectUnsubscribedError = M;
  m.UnsubscriptionError = fa;
  m.pipe = Ba;
  m.TestScheduler = ud;
  m.Subscriber = l;
  m.AsyncSubject = W;
  m.ConnectableObservable = hd;
  m.TimeoutError = Oc;
  m.VirtualTimeScheduler = pd;
  m.AjaxResponse = Sa;
  m.AjaxError = na;
  m.AjaxTimeoutError = Ta;
  m.TimeInterval = tb;
  m.Timestamp = rb;
  Object.defineProperty(m, '__esModule', { value: !0 });
});
//# sourceMappingURL=rxjs-compat.umd.min.js.map