@hinkal/common 0.0.115 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/xstream/index.mjs

@@ -0,0 +1,765 @@
+import { commonjsGlobal as l } from "../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as h } from "../../../../../../../_virtual/index67.mjs";
+import { p as d } from "./node_modules/symbol-observable/ponyfill.mjs";
+import { g as w } from "../globalthis/index.mjs";
+var b = l && l.__extends || /* @__PURE__ */ function() {
+  var i = function(t, n) {
+    return i = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, e) {
+      r.__proto__ = e;
+    } || function(r, e) {
+      for (var s in e)
+        e.hasOwnProperty(s) && (r[s] = e[s]);
+    }, i(t, n);
+  };
+  return function(t, n) {
+    i(t, n);
+    function r() {
+      this.constructor = t;
+    }
+    t.prototype = n === null ? Object.create(n) : (r.prototype = n.prototype, new r());
+  };
+}();
+Object.defineProperty(h, "__esModule", { value: !0 });
+h.NO_IL = h.NO = h.MemoryStream = h.Stream = void 0;
+var g = d, N = w, a = g.default(N.getPolyfill()), o = {};
+h.NO = o;
+function u() {
+}
+function c(i) {
+  for (var t = i.length, n = Array(t), r = 0; r < t; ++r)
+    n[r] = i[r];
+  return n;
+}
+function S(i, t) {
+  return function(r) {
+    return i(r) && t(r);
+  };
+}
+function y(i, t, n) {
+  try {
+    return i.f(t);
+  } catch (r) {
+    return n._e(r), o;
+  }
+}
+var f = {
+  _n: u,
+  _e: u,
+  _c: u
+};
+h.NO_IL = f;
+function m(i) {
+  i._start = function(n) {
+    n.next = n._n, n.error = n._e, n.complete = n._c, this.start(n);
+  }, i._stop = i.stop;
+}
+var O = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this._stream = t, this._listener = n;
+    }
+    return i.prototype.unsubscribe = function() {
+      this._stream._remove(this._listener);
+    }, i;
+  }()
+), L = (
+  /** @class */
+  function() {
+    function i(t) {
+      this._listener = t;
+    }
+    return i.prototype.next = function(t) {
+      this._listener._n(t);
+    }, i.prototype.error = function(t) {
+      this._listener._e(t);
+    }, i.prototype.complete = function() {
+      this._listener._c();
+    }, i;
+  }()
+), A = (
+  /** @class */
+  function() {
+    function i(t) {
+      this.type = "fromObservable", this.ins = t, this.active = !1;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.active = !0, this._sub = this.ins.subscribe(new L(t)), this.active || this._sub.unsubscribe();
+    }, i.prototype._stop = function() {
+      this._sub && this._sub.unsubscribe(), this.active = !1;
+    }, i;
+  }()
+), D = (
+  /** @class */
+  function() {
+    function i(t) {
+      this.type = "merge", this.insArr = t, this.out = o, this.ac = 0;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t;
+      var n = this.insArr, r = n.length;
+      this.ac = r;
+      for (var e = 0; e < r; e++)
+        n[e]._add(this);
+    }, i.prototype._stop = function() {
+      for (var t = this.insArr, n = t.length, r = 0; r < n; r++)
+        t[r]._remove(this);
+      this.out = o;
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      n !== o && n._n(t);
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      if (--this.ac <= 0) {
+        var t = this.out;
+        if (t === o)
+          return;
+        t._c();
+      }
+    }, i;
+  }()
+), I = (
+  /** @class */
+  function() {
+    function i(t, n, r) {
+      this.i = t, this.out = n, this.p = r, r.ils.push(this);
+    }
+    return i.prototype._n = function(t) {
+      var n = this.p, r = this.out;
+      if (r !== o && n.up(t, this.i)) {
+        var e = c(n.vals);
+        r._n(e);
+      }
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      var t = this.p;
+      t.out !== o && --t.Nc === 0 && t.out._c();
+    }, i;
+  }()
+), x = (
+  /** @class */
+  function() {
+    function i(t) {
+      this.type = "combine", this.insArr = t, this.out = o, this.ils = [], this.Nc = this.Nn = 0, this.vals = [];
+    }
+    return i.prototype.up = function(t, n) {
+      var r = this.vals[n], e = this.Nn ? r === o ? --this.Nn : this.Nn : 0;
+      return this.vals[n] = t, e === 0;
+    }, i.prototype._start = function(t) {
+      this.out = t;
+      var n = this.insArr, r = this.Nc = this.Nn = n.length, e = this.vals = new Array(r);
+      if (r === 0)
+        t._n([]), t._c();
+      else
+        for (var s = 0; s < r; s++)
+          e[s] = o, n[s]._add(new I(s, t, this));
+    }, i.prototype._stop = function() {
+      for (var t = this.insArr, n = t.length, r = this.ils, e = 0; e < n; e++)
+        t[e]._remove(r[e]);
+      this.out = o, this.ils = [], this.vals = [];
+    }, i;
+  }()
+), E = (
+  /** @class */
+  function() {
+    function i(t) {
+      this.type = "fromArray", this.a = t;
+    }
+    return i.prototype._start = function(t) {
+      for (var n = this.a, r = 0, e = n.length; r < e; r++)
+        t._n(n[r]);
+      t._c();
+    }, i.prototype._stop = function() {
+    }, i;
+  }()
+), F = (
+  /** @class */
+  function() {
+    function i(t) {
+      this.type = "fromPromise", this.on = !1, this.p = t;
+    }
+    return i.prototype._start = function(t) {
+      var n = this;
+      this.on = !0, this.p.then(function(r) {
+        n.on && (t._n(r), t._c());
+      }, function(r) {
+        t._e(r);
+      }).then(u, function(r) {
+        setTimeout(function() {
+          throw r;
+        });
+      });
+    }, i.prototype._stop = function() {
+      this.on = !1;
+    }, i;
+  }()
+), W = (
+  /** @class */
+  function() {
+    function i(t) {
+      this.type = "periodic", this.period = t, this.intervalID = -1, this.i = 0;
+    }
+    return i.prototype._start = function(t) {
+      var n = this;
+      function r() {
+        t._n(n.i++);
+      }
+      this.intervalID = setInterval(r, this.period);
+    }, i.prototype._stop = function() {
+      this.intervalID !== -1 && clearInterval(this.intervalID), this.intervalID = -1, this.i = 0;
+    }, i;
+  }()
+), k = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.type = "debug", this.ins = t, this.out = o, this.s = u, this.l = "", typeof n == "string" ? this.l = n : typeof n == "function" && (this.s = n);
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.out = o;
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      if (n !== o) {
+        var r = this.s, e = this.l;
+        if (r !== u)
+          try {
+            r(t);
+          } catch (s) {
+            n._e(s);
+          }
+        else
+          e ? console.log(e + ":", t) : console.log(t);
+        n._n(t);
+      }
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      var t = this.out;
+      t !== o && t._c();
+    }, i;
+  }()
+), P = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.type = "drop", this.ins = n, this.out = o, this.max = t, this.dropped = 0;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.dropped = 0, this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.out = o;
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      n !== o && this.dropped++ >= this.max && n._n(t);
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      var t = this.out;
+      t !== o && t._c();
+    }, i;
+  }()
+), T = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.out = t, this.op = n;
+    }
+    return i.prototype._n = function() {
+      this.op.end();
+    }, i.prototype._e = function(t) {
+      this.out._e(t);
+    }, i.prototype._c = function() {
+      this.op.end();
+    }, i;
+  }()
+), M = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.type = "endWhen", this.ins = n, this.out = o, this.o = t, this.oil = f;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.o._add(this.oil = new T(t, this)), this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.o._remove(this.oil), this.out = o, this.oil = f;
+    }, i.prototype.end = function() {
+      var t = this.out;
+      t !== o && t._c();
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      n !== o && n._n(t);
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      this.end();
+    }, i;
+  }()
+), _ = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.type = "filter", this.ins = n, this.out = o, this.f = t;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.out = o;
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      if (n !== o) {
+        var r = y(this, t, n);
+        r === o || !r || n._n(t);
+      }
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      var t = this.out;
+      t !== o && t._c();
+    }, i;
+  }()
+), C = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.out = t, this.op = n;
+    }
+    return i.prototype._n = function(t) {
+      this.out._n(t);
+    }, i.prototype._e = function(t) {
+      this.out._e(t);
+    }, i.prototype._c = function() {
+      this.op.inner = o, this.op.less();
+    }, i;
+  }()
+), R = (
+  /** @class */
+  function() {
+    function i(t) {
+      this.type = "flatten", this.ins = t, this.out = o, this.open = !0, this.inner = o, this.il = f;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.open = !0, this.inner = o, this.il = f, this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.inner !== o && this.inner._remove(this.il), this.out = o, this.open = !0, this.inner = o, this.il = f;
+    }, i.prototype.less = function() {
+      var t = this.out;
+      t !== o && !this.open && this.inner === o && t._c();
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      if (n !== o) {
+        var r = this, e = r.inner, s = r.il;
+        e !== o && s !== f && e._remove(s), (this.inner = t)._add(this.il = new C(n, this));
+      }
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      this.open = !1, this.less();
+    }, i;
+  }()
+), j = (
+  /** @class */
+  function() {
+    function i(t, n, r) {
+      var e = this;
+      this.type = "fold", this.ins = r, this.out = o, this.f = function(s) {
+        return t(e.acc, s);
+      }, this.acc = this.seed = n;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.acc = this.seed, t._n(this.acc), this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.out = o, this.acc = this.seed;
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      if (n !== o) {
+        var r = y(this, t, n);
+        r !== o && n._n(this.acc = r);
+      }
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      var t = this.out;
+      t !== o && t._c();
+    }, i;
+  }()
+), q = (
+  /** @class */
+  function() {
+    function i(t) {
+      this.type = "last", this.ins = t, this.out = o, this.has = !1, this.val = o;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.has = !1, this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.out = o, this.val = o;
+    }, i.prototype._n = function(t) {
+      this.has = !0, this.val = t;
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      var t = this.out;
+      t !== o && (this.has ? (t._n(this.val), t._c()) : t._e(new Error("last() failed because input stream completed")));
+    }, i;
+  }()
+), z = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.type = "map", this.ins = n, this.out = o, this.f = t;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.out = o;
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      if (n !== o) {
+        var r = y(this, t, n);
+        r !== o && n._n(r);
+      }
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      var t = this.out;
+      t !== o && t._c();
+    }, i;
+  }()
+), $ = (
+  /** @class */
+  function() {
+    function i(t) {
+      this.type = "remember", this.ins = t, this.out = o;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.ins._add(t);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this.out), this.out = o;
+    }, i;
+  }()
+), G = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.type = "replaceError", this.ins = n, this.out = o, this.f = t;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.out = o;
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      n !== o && n._n(t);
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      if (n !== o)
+        try {
+          this.ins._remove(this), (this.ins = this.f(t))._add(this);
+        } catch (r) {
+          n._e(r);
+        }
+    }, i.prototype._c = function() {
+      var t = this.out;
+      t !== o && t._c();
+    }, i;
+  }()
+), H = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.type = "startWith", this.ins = t, this.out = o, this.val = n;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.out._n(this.val), this.ins._add(t);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this.out), this.out = o;
+    }, i;
+  }()
+), B = (
+  /** @class */
+  function() {
+    function i(t, n) {
+      this.type = "take", this.ins = n, this.out = o, this.max = t, this.taken = 0;
+    }
+    return i.prototype._start = function(t) {
+      this.out = t, this.taken = 0, this.max <= 0 ? t._c() : this.ins._add(this);
+    }, i.prototype._stop = function() {
+      this.ins._remove(this), this.out = o;
+    }, i.prototype._n = function(t) {
+      var n = this.out;
+      if (n !== o) {
+        var r = ++this.taken;
+        r < this.max ? n._n(t) : r === this.max && (n._n(t), n._c());
+      }
+    }, i.prototype._e = function(t) {
+      var n = this.out;
+      n !== o && n._e(t);
+    }, i.prototype._c = function() {
+      var t = this.out;
+      t !== o && t._c();
+    }, i;
+  }()
+), v = (
+  /** @class */
+  function() {
+    function i(t) {
+      this._prod = t || o, this._ils = [], this._stopID = o, this._dl = o, this._d = !1, this._target = null, this._err = o;
+    }
+    return i.prototype._n = function(t) {
+      var n = this._ils, r = n.length;
+      if (this._d && this._dl._n(t), r == 1)
+        n[0]._n(t);
+      else {
+        if (r == 0)
+          return;
+        for (var e = c(n), s = 0; s < r; s++)
+          e[s]._n(t);
+      }
+    }, i.prototype._e = function(t) {
+      if (this._err === o) {
+        this._err = t;
+        var n = this._ils, r = n.length;
+        if (this._x(), this._d && this._dl._e(t), r == 1)
+          n[0]._e(t);
+        else {
+          if (r == 0)
+            return;
+          for (var e = c(n), s = 0; s < r; s++)
+            e[s]._e(t);
+        }
+        if (!this._d && r == 0)
+          throw this._err;
+      }
+    }, i.prototype._c = function() {
+      var t = this._ils, n = t.length;
+      if (this._x(), this._d && this._dl._c(), n == 1)
+        t[0]._c();
+      else {
+        if (n == 0)
+          return;
+        for (var r = c(t), e = 0; e < n; e++)
+          r[e]._c();
+      }
+    }, i.prototype._x = function() {
+      this._ils.length !== 0 && (this._prod !== o && this._prod._stop(), this._err = o, this._ils = []);
+    }, i.prototype._stopNow = function() {
+      this._prod._stop(), this._err = o, this._stopID = o;
+    }, i.prototype._add = function(t) {
+      var n = this._target;
+      if (n)
+        return n._add(t);
+      var r = this._ils;
+      if (r.push(t), !(r.length > 1))
+        if (this._stopID !== o)
+          clearTimeout(this._stopID), this._stopID = o;
+        else {
+          var e = this._prod;
+          e !== o && e._start(this);
+        }
+    }, i.prototype._remove = function(t) {
+      var n = this, r = this._target;
+      if (r)
+        return r._remove(t);
+      var e = this._ils, s = e.indexOf(t);
+      s > -1 && (e.splice(s, 1), this._prod !== o && e.length <= 0 ? (this._err = o, this._stopID = setTimeout(function() {
+        return n._stopNow();
+      })) : e.length === 1 && this._pruneCycles());
+    }, i.prototype._pruneCycles = function() {
+      this._hasNoSinks(this, []) && this._remove(this._ils[0]);
+    }, i.prototype._hasNoSinks = function(t, n) {
+      if (n.indexOf(t) !== -1)
+        return !0;
+      if (t.out === this)
+        return !0;
+      if (t.out && t.out !== o)
+        return this._hasNoSinks(t.out, n.concat(t));
+      if (t._ils) {
+        for (var r = 0, e = t._ils.length; r < e; r++)
+          if (!this._hasNoSinks(t._ils[r], n.concat(t)))
+            return !1;
+        return !0;
+      } else
+        return !1;
+    }, i.prototype.ctor = function() {
+      return this instanceof p ? p : i;
+    }, i.prototype.addListener = function(t) {
+      t._n = t.next || u, t._e = t.error || u, t._c = t.complete || u, this._add(t);
+    }, i.prototype.removeListener = function(t) {
+      this._remove(t);
+    }, i.prototype.subscribe = function(t) {
+      return this.addListener(t), new O(this, t);
+    }, i.prototype[a] = function() {
+      return this;
+    }, i.create = function(t) {
+      if (t) {
+        if (typeof t.start != "function" || typeof t.stop != "function")
+          throw new Error("producer requires both start and stop functions");
+        m(t);
+      }
+      return new i(t);
+    }, i.createWithMemory = function(t) {
+      return t && m(t), new p(t);
+    }, i.never = function() {
+      return new i({ _start: u, _stop: u });
+    }, i.empty = function() {
+      return new i({
+        _start: function(t) {
+          t._c();
+        },
+        _stop: u
+      });
+    }, i.throw = function(t) {
+      return new i({
+        _start: function(n) {
+          n._e(t);
+        },
+        _stop: u
+      });
+    }, i.from = function(t) {
+      if (typeof t[a] == "function")
+        return i.fromObservable(t);
+      if (typeof t.then == "function")
+        return i.fromPromise(t);
+      if (Array.isArray(t))
+        return i.fromArray(t);
+      throw new TypeError("Type of input to from() must be an Array, Promise, or Observable");
+    }, i.of = function() {
+      for (var t = [], n = 0; n < arguments.length; n++)
+        t[n] = arguments[n];
+      return i.fromArray(t);
+    }, i.fromArray = function(t) {
+      return new i(new E(t));
+    }, i.fromPromise = function(t) {
+      return new i(new F(t));
+    }, i.fromObservable = function(t) {
+      if (t.endWhen !== void 0)
+        return t;
+      var n = typeof t[a] == "function" ? t[a]() : t;
+      return new i(new A(n));
+    }, i.periodic = function(t) {
+      return new i(new W(t));
+    }, i.prototype._map = function(t) {
+      return new (this.ctor())(new z(t, this));
+    }, i.prototype.map = function(t) {
+      return this._map(t);
+    }, i.prototype.mapTo = function(t) {
+      var n = this.map(function() {
+        return t;
+      }), r = n._prod;
+      return r.type = "mapTo", n;
+    }, i.prototype.filter = function(t) {
+      var n = this._prod;
+      return n instanceof _ ? new i(new _(S(n.f, t), n.ins)) : new i(new _(t, this));
+    }, i.prototype.take = function(t) {
+      return new (this.ctor())(new B(t, this));
+    }, i.prototype.drop = function(t) {
+      return new i(new P(t, this));
+    }, i.prototype.last = function() {
+      return new i(new q(this));
+    }, i.prototype.startWith = function(t) {
+      return new p(new H(this, t));
+    }, i.prototype.endWhen = function(t) {
+      return new (this.ctor())(new M(t, this));
+    }, i.prototype.fold = function(t, n) {
+      return new p(new j(t, n, this));
+    }, i.prototype.replaceError = function(t) {
+      return new (this.ctor())(new G(t, this));
+    }, i.prototype.flatten = function() {
+      return new i(new R(this));
+    }, i.prototype.compose = function(t) {
+      return t(this);
+    }, i.prototype.remember = function() {
+      return new p(new $(this));
+    }, i.prototype.debug = function(t) {
+      return new (this.ctor())(new k(this, t));
+    }, i.prototype.imitate = function(t) {
+      if (t instanceof p)
+        throw new Error("A MemoryStream was given to imitate(), but it only supports a Stream. Read more about this restriction here: https://github.com/staltz/xstream#faq");
+      this._target = t;
+      for (var n = this._ils, r = n.length, e = 0; e < r; e++)
+        t._add(n[e]);
+      this._ils = [];
+    }, i.prototype.shamefullySendNext = function(t) {
+      this._n(t);
+    }, i.prototype.shamefullySendError = function(t) {
+      this._e(t);
+    }, i.prototype.shamefullySendComplete = function() {
+      this._c();
+    }, i.prototype.setDebugListener = function(t) {
+      t ? (this._d = !0, t._n = t.next || u, t._e = t.error || u, t._c = t.complete || u, this._dl = t) : (this._d = !1, this._dl = o);
+    }, i.merge = function() {
+      for (var n = [], r = 0; r < arguments.length; r++)
+        n[r] = arguments[r];
+      return new i(new D(n));
+    }, i.combine = function() {
+      for (var n = [], r = 0; r < arguments.length; r++)
+        n[r] = arguments[r];
+      return new i(new x(n));
+    }, i;
+  }()
+);
+h.Stream = v;
+var p = (
+  /** @class */
+  function(i) {
+    b(t, i);
+    function t(n) {
+      var r = i.call(this, n) || this;
+      return r._has = !1, r;
+    }
+    return t.prototype._n = function(n) {
+      this._v = n, this._has = !0, i.prototype._n.call(this, n);
+    }, t.prototype._add = function(n) {
+      var r = this._target;
+      if (r)
+        return r._add(n);
+      var e = this._ils;
+      if (e.push(n), e.length > 1) {
+        this._has && n._n(this._v);
+        return;
+      }
+      if (this._stopID !== o)
+        this._has && n._n(this._v), clearTimeout(this._stopID), this._stopID = o;
+      else if (this._has)
+        n._n(this._v);
+      else {
+        var s = this._prod;
+        s !== o && s._start(this);
+      }
+    }, t.prototype._stopNow = function() {
+      this._has = !1, i.prototype._stopNow.call(this);
+    }, t.prototype._x = function() {
+      this._has = !1, i.prototype._x.call(this);
+    }, t.prototype.map = function(n) {
+      return this._map(n);
+    }, t.prototype.mapTo = function(n) {
+      return i.prototype.mapTo.call(this, n);
+    }, t.prototype.take = function(n) {
+      return i.prototype.take.call(this, n);
+    }, t.prototype.endWhen = function(n) {
+      return i.prototype.endWhen.call(this, n);
+    }, t.prototype.replaceError = function(n) {
+      return i.prototype.replaceError.call(this, n);
+    }, t.prototype.remember = function() {
+      return this;
+    }, t.prototype.debug = function(n) {
+      return i.prototype.debug.call(this, n);
+    }, t;
+  }(v)
+);
+h.MemoryStream = p;
+var J = v;
+h.default = J;