type('should support selectors of a different type', () => {
   /* tslint:disable:no-unused-variable */
   let o: Observable<number>;
   let s: Observable<string>;
   let r: Observable<number> = o.pipe(debounce((n) => s));
   /* tslint:enable:no-unused-variable */
 });

  it('should raises error when promise rejects', (done: MochaDone) => {
    const e1 = concat(
      of(1),
      timer(10).pipe(mapTo(2)),
      timer(10).pipe(mapTo(3)),
      timer(100).pipe(mapTo(4))
    );
    const expected = [1, 2];
    const error = new Error('error');

    e1.pipe(
      debounce((x: number) => {
        if (x === 3) {
          return new Promise((resolve: any, reject: any) => { reject(error); });
        } else {
          return new Promise((resolve: any) => { resolve(42); });
        }
      })
    ).subscribe((x: number) => {
      expect(x).to.equal(expected.shift()); },
      (err: any) => {
        expect(err).to.be.an('error', 'error');
        expect(expected.length).to.equal(0);
        done();
      }, () => {
        done(new Error('should not be called'));
      });
  });

 .subscribe(doc => {
     if (!validationByDoc.has(doc.uri)) {
         const uri = doc.uri;
         if (isUriBlackListed(uri)) {
             validationByDoc.set(doc.uri, validationRequestStream.pipe(
                 filter(doc => uri === doc.uri),
                 take(1),
                 tap(doc => log('Ignoring:', doc.uri)),
                 ).subscribe()
             );
         } else {
             validationByDoc.set(doc.uri, validationRequestStream.pipe(
                 filter(doc => uri === doc.uri),
                 tap(doc => log('Request Validate:', doc.uri)),
                 debounceTime(50),
                 tap(doc => log('Request Validate 2:', doc.uri)),
                 flatMap(async doc => ({ doc, settings: await getActiveSettings(doc) }) as DocSettingPair),
                 debounce(dsp => timer(dsp.settings.spellCheckDelayMs || defaultDebounce)
                     .pipe(filter(() => !isValidationBusy))
                 ),
                 flatMap(validateTextDocument),
                 ).subscribe(diag => connection.sendDiagnostics(diag))
             );
         }
     }
 });

  asDiagram('debounce')('should debounce values by a specified cold Observable', () => {
    const e1 =   hot('-a--bc--d---|');
    const e2 =  cold('--|          ');
    const expected = '---a---c--d-|';

    const result = e1.pipe(debounce(() => e2));

    expectObservable(result).toBe(expected);
  });

  /**
   *
   * @param period milliseconds
   */
  constructor(
    period?: number, // milliseconds
  ) {
    super(period);

    this.subject = new Subject<T>();
    this.subscription = this.subject.pipe(
      debounce(() => interval(this.period)),
    )
      .subscribe((item: T) => super.next(item));
  }

 debounce2() {
   // emit value every 1 second, ex. 0...1...2
   const interval$ = interval(1000);
   // raise the debounce time by 200ms each second
   const debouncedInterval = interval$.pipe(debounce(val => timer(val * 200)));
   /*
     After 5 seconds, debounce time will be greater than interval time,
     all future values will be thrown away
     output: 0...1...2...3...4......(debounce time over 1s, no values emitted)
   */
   const subscribe = debouncedInterval.subscribe(val =>
     console.log(`Example Two: ${val}`)
   );
 }

 debounce1() {
   // emit four strings
   const example = of('WAIT', 'ONE', 'SECOND', 'Last will display');
   /*
       Only emit values after a second has passed between the last emission,
       throw away all other values
   */
   const debouncedExample = example.pipe(debounce(() => timer(1000)));
   /*
       In this example, all values but the last will be omitted
       output: 'Last will display'
   */
   const subscribe = debouncedExample.subscribe(val => console.log(val));
 }

export function debounce<T>(this: Observable<T>, durationSelector: (value: T) => SubscribableOrPromise<any>): Observable<T> {
  return higherOrder(durationSelector)(this);
}