message: refactor(throwIfEmpty): smaller impl
diff: +/** @prettier */
  import { EmptyError } from '../util/EmptyError';
  import { Observable } from '../Observable';
  import { Operator } from '../Operator';
  import { Subscriber } from '../Subscriber';
  import { TeardownLogic, MonoTypeOperatorFunction } from '../types';
  import { lift } from '../util/lift';
  +import { OperatorSubscriber } from './OperatorSubscriber';
  /**
  * If the source observable completes without emitting a value, it will emit
  @@ -35,46 +37,23 @@ import { lift } from '../util/lift';
  * error to be thrown when the source observable completes without emitting a
  * value.
  */
  -export function throwIfEmpty <T>(errorFactory: (() => any) = defaultErrorFactory): MonoTypeOperatorFunction<T> {
  - return (source: Observable<T>) => {
  - return lift(source, new ThrowIfEmptyOperator(errorFactory));
  - };
  -}
  -
  -class ThrowIfEmptyOperator<T> implements Operator<T, T> {
  - constructor(private errorFactory: () => any) {
  - }
  -
  - call(subscriber: Subscriber<T>, source: any): TeardownLogic {
  - return source.subscribe(new ThrowIfEmptySubscriber(subscriber, this.errorFactory));
  - }
  -}
  -
  -class ThrowIfEmptySubscriber<T> extends Subscriber<T> {
  - private hasValue: boolean = false;
  -
  - constructor(destination: Subscriber<T>, private errorFactory: () => any) {
  - super(destination);
  - }
  -
  - protected _next(value: T): void {
  - this.hasValue = true;
  - this.destination.next(value);
  - }
  -
  - protected _complete() {
  - if (!this.hasValue) {
  - let err: any;
  - try {
  - err = this.errorFactory();
  - } catch (e) {
  - err = e;
  - }
  - this.destination.error(err);
  - } else {
  - return this.destination.complete();
  - }
  - }
  +export function throwIfEmpty<T>(errorFactory: () => any = defaultErrorFactory): MonoTypeOperatorFunction<T> {
  + return (source: Observable<T>) =>
  + lift(source, function (this: Subscriber<T>, source: Observable<T>) {
  + const subscriber = this;
  + let hasValue = false;
  + source.subscribe(
  + new OperatorSubscriber(
  + subscriber,
  + (value) => {
  + hasValue = true;
  + subscriber.next(value);
  + },
  + undefined,
  + () => (hasValue ? subscriber.complete() : subscriber.error(errorFactory()))
  + )
  + );
  + });
  }
  function defaultErrorFactory() {
  