// Process promise response from _onNext.
  private _update(inner: Subscriber<EvalDataSet>, resp: EvalIterResponse): void {
    // Merge with everything collected so far.
    this.inFlight.merge(resp.data);

    // Filter out any scrapes that are no longer to be shown.
    let filter: FilterTimeSpec = this.timeSpecService.filter;
    if (filter.active)
      this.inFlight.retainIf((line) => filter.test(line.date));

    // Update request parameters for next request.
    this.params.set('begin', resp.newBegin.getTime().toString());
    this.params.set('cookie', resp.cookie);
    this.params.set('iter', resp.iter);

    // Only continue fetching more data if still live.
    if (!this.stopped) {
      // Emit copy of current inflight.
      inner.next(this.inFlight.clone());

      if (resp.last)  // Close after last item emit.
        inner.complete();
      else  // Continue fetching more data.
        this._onNext(inner);
    }
  }

 return new Observable((subscriber: Subscriber<Response>) => {
   const cachedData = requestOptions.cache === HttpCachePolicy.Update ?
   null : this.httpCacheService.getCacheData(url);
   if (cachedData !== null) {
     // Create new response to avoid side-effects
     subscriber.next(new Response(cachedData));
     subscriber.complete();
   } else {
     this.httpRequest(request, requestOptions).subscribe(
       (response: Response) => {
         // Store the serializable version of the response
         this.httpCacheService.setCacheData(url, null, new ResponseOptions({
           body: response.text(),
           status: response.status,
           headers: response.headers,
           statusText: response.statusText,
           type: response.type,
           url: response.url
         }));
         subscriber.next(response);
       },
       (error: any) => subscriber.error(error),
       () => subscriber.complete()
     );
   }
 });

            (subscriber: Subscriber<ILoadStatusObject>): void => {
                if (!this.merged) {
                    let mesh: IMesh = { faces: [], vertices: [] };
                    subscriber.next({ loaded: { loaded: 0, total: 0 }, object: mesh });
                    subscriber.complete();

                    return;
                }

                let xmlHTTP: XMLHttpRequest = new XMLHttpRequest();
                xmlHTTP.open("GET", Urls.proto_mesh(this.key), true);
                xmlHTTP.responseType = "arraybuffer";
                xmlHTTP.onload = (e: any) => {
                    let mesh: IMesh;
                    if (xmlHTTP.status === 200) {
                        mesh = MeshReader.read(new Buffer(xmlHTTP.response));
                    } else {
                        mesh = { faces: [], vertices: [] };
                    }

                    subscriber.next({ loaded: { loaded: e.loaded, total: e.total }, object: mesh });
                    subscriber.complete();
                };

                xmlHTTP.onprogress = (e: any) => {
                    subscriber.next({ loaded: { loaded: e.loaded, total: e.total }, object: null });
                };

                xmlHTTP.send(null);
            });

 return new Observable((observer: Subscriber<any>) => {
     let applicationState: ApplicationState = {
         applicationFormModified: false,
         applicationFormInvalid: false,
         applicationSaveState: ApplicationSaveState.idle
     };
     observer.next(applicationState);
     observer.complete();
 });

 (value) => {
   try {
     subscriber.next(value);
   } catch (err) {
     subscriber.error(err);
   }
 },

                    image.onload = () => {
                        let texture: THREE.Texture = new THREE.Texture(image);
                        texture.minFilter = THREE.LinearFilter;
                        texture.needsUpdate = true;

                        subscriber.next(texture);
                        subscriber.complete();
                    };

      FB.getLoginStatus(response => {
        if (response.status === 'connected') {
          localStorage.setItem('token', `facebook ${response.authResponse.accessToken}`);
        }

        subscriber.next(response);
        subscriber.complete();
      });

      let onImgLoad = (file, img) => {
        if (!this.isValidDimension(img)) {
          sub.error(('LEAGUES.IMG.INVALID_DIMENSION'));

          return;
        }

        sub.next(reader.result);
      };

                xmlHTTP.onload = (e: any) => {
                    let mesh: IMesh;
                    if (xmlHTTP.status === 200) {
                        mesh = MeshReader.read(new Buffer(xmlHTTP.response));
                    } else {
                        mesh = { faces: [], vertices: [] };
                    }

                    subscriber.next({ loaded: { loaded: e.loaded, total: e.total }, object: mesh });
                    subscriber.complete();
                };

 this._context.acquireToken(res, (message: string, token: string) => {
   if (message) {
     subscriber.error(
       new HttpErrorResponse({
         error: message,
         headers: null,
         status: 401,
         statusText: 'Error from AAD',
         url: res
       })
     );
   }
   subscriber.next(token);
 })