hunk.code_window:       const thisArg = {
           schedule: sinon.spy()
         };
         dispatch.call(thisArg, state);
         expect(state.subscriber.complete).not.have.been.called;
         expect(state.subscriber.next).have.been.calledWith(5);
  
hunk.labels: keep keep keep keep keep replace keep keep keep
hunk.after_edit:       dispatch.call(thisArg as any, state);
  
hunk.file_path: spec/observables/range-spec.ts
hunk.type: replace
file: import { Observable } from '../Observable';
  import { AsyncSubject } from '../AsyncSubject';
  import { multicast } from './multicast';
  import { ConnectableObservable } from '../observable/ConnectableObservable';
  import { UnaryFunction } from '../types';
  
  /**
   * Returns a connectable observable sequence that shares a single subscription to the
   * underlying sequence containing only the last notification.
   *
   * ![](publishLast.png)
   *
   * Similar to {@link publish}, but it waits until the source observable completes and stores
   * the last emitted value.
   * Similarly to {@link publishReplay} and {@link publishBehavior}, this keeps storing the last
   * value even if it has no more subscribers. If subsequent subscriptions happen, they will
   * immediately get that last stored value and complete.
   *
   * ## Example
   *
   * ```ts
   * import { interval } from 'rxjs';
   * import { publishLast, tap, take } from 'rxjs/operators';
   *
   * const connectable =
   *   interval(1000)
   *     .pipe(
   *       tap(x => console.log("side effect", x)),
   *       take(3),
   *       publishLast());
   *
   * connectable.subscribe(
   *   x => console.log(  "Sub. A", x),
   *   err => console.log("Sub. A Error", err),
   *   () => console.log( "Sub. A Complete"));
   *
   * connectable.subscribe(
   *   x => console.log(  "Sub. B", x),
   *   err => console.log("Sub. B Error", err),
   *   () => console.log( "Sub. B Complete"));
   *
   * connectable.connect();
   *
   * // Results:
   * //    "side effect 0"
   * //    "side effect 1"
   * //    "side effect 2"
   * //    "Sub. A 2"
   * //    "Sub. B 2"
   * //    "Sub. A Complete"
   * //    "Sub. B Complete"
   * ```
   *
   * @see {@link ConnectableObservable}
   * @see {@link publish}
   * @see {@link publishReplay}
   * @see {@link publishBehavior}
   *
   * @return {ConnectableObservable} An observable sequence that contains the elements of a
   * sequence produced by multicasting the source sequence.
   * @method publishLast
   * @owner Observable
   */
  
  export function publishLast<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>> {
    return (source: Observable<T>) => multicast(new AsyncSubject<T>())(source);
  }
  