hunk.code_window:   const length = properties.length;
     if (length === 0) {
       throw new Error('list of properties cannot be empty.');
     }
     return (source: Observable<T>) => map(plucker(properties, length))(source as any);
   }
   function plucker(props: string[], length: number): (x: string) => any {
     const mapper = (x: any) => {
       let currentProp = x;
       for (let i = 0; i < length; i++) {
  
hunk.labels: keep keep keep keep replace replace replace replace replace replace keep
hunk.after_edit:   return map((x) => {
       let currentProp: any = x;
  
hunk.file_path: src/internal/operators/pluck.ts
hunk.type: replace
file: import { Observable } from './Observable';
  import { Deferred } from './util/deferred';
  
  export function asyncIteratorFrom<T>(source: Observable<T>) {
    return coroutine(source);
  }
  
  async function* coroutine<T>(source: Observable<T>) {
    const deferreds: Deferred<IteratorResult<T>>[] = [];
    const values: T[] = [];
    let hasError = false;
    let error: any = null;
    let completed = false;
  
    const subs = source.subscribe({
      next: value => {
        if (deferreds.length > 0) {
          deferreds.shift()!.resolve({ value, done: false });
        } else {
          values.push(value);
        }
      },
      error: err => {
        hasError = true;
        error = err;
        while (deferreds.length > 0) {
          deferreds.shift()!.reject(err);
        }
      },
      complete: () => {
        completed = true;
        while (deferreds.length > 0) {
          deferreds.shift()!.resolve({ value: undefined, done: true });
        }
      },
    });
  
    try {
      while (true) {
        if (values.length > 0) {
          yield values.shift();
        } else if (completed) {
          return;
        } else if (hasError) {
          throw error;
        } else {
          const d = new Deferred<IteratorResult<T>>();
          deferreds.push(d);
          const result = await d.promise;
          if (result.done) {
            return;
          } else {
            yield result.value;
          }
        }
      }
    } catch (err) {
      throw err;
    } finally {
      subs.unsubscribe();
    }
  }