.then(() => {

          let query1 = FirebaseListFactory(`questions`, {
            query: {
              orderByChild: 'data',
              endAt: { value: 0 }
            }
          });
          query1 = take.call(query1, 1);
          query1 = toPromise.call(query1);

          let query2 = FirebaseListFactory(`questions`, {
            query: {
              orderByChild: 'data',
              endAt: { value: 0, key: 'val2' }
            }
          });
          query2 = take.call(query2, 1);
          query2 = toPromise.call(query2);

          Promise.all([query1, query2]).then(([list1, list2]) => {
            expect(list1.map(i => i.$key)).toEqual(['val1', 'val2', 'val3']);
            expect(list2.map(i => i.$key)).toEqual(['val1', 'val2']);
            done();
          });
        })

 const initializer = () => {
   const app = injector.get<ApplicationRef>(ApplicationRef);
   if (!('serviceWorker' in navigator)) {
     return;
   }
   const onStable =
       op_filter.call(app.isStable, (stable: boolean) => !!stable) as Observable<boolean>;
   const isStable = op_take.call(onStable, 1) as Observable<boolean>;
   const whenStable = op_toPromise.call(isStable) as Promise<boolean>;
   return whenStable.then(() => navigator.serviceWorker.register(script, options))
       .then(() => undefined) as Promise<void>;
 };

  const initializer = () => {
    const app = injector.get<ApplicationRef>(ApplicationRef);
    if (!('serviceWorker' in navigator)) {
      return;
    }
    const onStable =
        op_filter.call(app.isStable, (stable: boolean) => !!stable) as Observable<boolean>;
    const isStable = op_take.call(onStable, 1) as Observable<boolean>;
    const whenStable = op_toPromise.call(isStable) as Promise<boolean>;

    // Don't return the Promise, as that will block the application until the SW is registered, and
    // cause a crash if the SW registration fails.
    whenStable.then(() => navigator.serviceWorker.register(script, options));
  };

        .then(() => {

          let query1 = FirebaseListFactory(app.database().ref(`questions`), {
            query: {
              orderByChild: 'data',
              equalTo: { value: 0 }
            }
          });
          let promise1 = toPromise.call(take.call(query1, 1));

          let query2 = FirebaseListFactory(app.database().ref(`questions`), {
            query: {
              orderByChild: 'data',
              equalTo: { value: 0, key: 'val2' }
            }
          });
          let promise2 = toPromise.call(take.call(query2, 1));

          Promise.all([promise1, promise2]).then(([list1, list2]) => {
            expect(list1.map(i => i.$key)).toEqual(['val1', 'val2', 'val3']);
            expect(list2.map(i => i.$key)).toEqual(['val2']);
            done();
          });
        })

    it('should re-emit identical instances of unchanged children as snapshots', (done: any) => {

      let prev;

      take.call(questionsSnapshotted, 2).subscribe(
        (list) => {
          if (prev) {
            expect(list[0]).toBe(prev[0]);
            done();
          } else {
            prev = list;
            questionsSnapshotted.push({ name: 'bob' });
          }
        },
        done.fail
      );
      questionsSnapshotted.push({ name: 'alice' });
    });

  const initializer = () => {
    const app = injector.get<ApplicationRef>(ApplicationRef);
    if (!(isPlatformBrowser(platformId) && ('serviceWorker' in navigator) &&
          options.enabled !== false)) {
      return;
    }
    const onStable =
        op_filter.call(app.isStable, (stable: boolean) => !!stable) as Observable<boolean>;
    const isStable = op_take.call(onStable, 1) as Observable<boolean>;
    const whenStable = op_toPromise.call(isStable) as Promise<boolean>;

    // Wait for service worker controller changes, and fire an INITIALIZE action when a new SW
    // becomes active. This allows the SW to initialize itself even if there is no application
    // traffic.
    navigator.serviceWorker.addEventListener('controllerchange', () => {
      if (navigator.serviceWorker.controller !== null) {
        navigator.serviceWorker.controller.postMessage({action: 'INITIALIZE'});
      }
    });

    // Don't return the Promise, as that will block the application until the SW is registered, and
    // cause a crash if the SW registration fails.
    whenStable.then(() => navigator.serviceWorker.register(script, {scope: options.scope}));
  };

function skipAndTake<T>(obs: Observable<T>, takeCount: number = 1, skipCount: number = 0) {
  return take.call(skip.call(obs, skipCount), takeCount);
}

function obsToSinglePromise<T>(obs: Observable<T>): Promise<T> {
  const takeOne = take.call(obs, 1);
  return toPromise.call(takeOne);
}