refactor: map operators all the way to lettable version rather than r…

…e-export

Fixes ReactiveX#2812

src/operator/audit.ts

@@ -1,6 +1,6 @@
 
 import { Observable, SubscribableOrPromise } from '../Observable';
-import { audit as higherOrder } from '../operators';
+import { audit as higherOrder } from '../operators/audit';
 
 /**
  * Ignores source values for a duration determined by another Observable, then

src/operator/auditTime.ts

@@ -1,7 +1,7 @@
 import { async } from '../scheduler/async';
 import { IScheduler } from '../Scheduler';
 import { Observable } from '../Observable';
-import { auditTime as higherOrder } from '../operators';
+import { auditTime as higherOrder } from '../operators/auditTime';
 
 /**
  * Ignores source values for `duration` milliseconds, then emits the most recent

src/operator/buffer.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { buffer as higherOrder } from '../operators';
+import { buffer as higherOrder } from '../operators/buffer';
 
 /**
  * Buffers the source Observable values until `closingNotifier` emits.

src/operator/bufferCount.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { bufferCount as higherOrder } from '../operators';
+import { bufferCount as higherOrder } from '../operators/bufferCount';
 
 /**
  * Buffers the source Observable values until the size hits the maximum

src/operator/bufferTime.ts

@@ -2,7 +2,7 @@ import { IScheduler } from '../Scheduler';
 import { async } from '../scheduler/async';
 import { Observable } from '../Observable';
 import { isScheduler } from '../util/isScheduler';
-import { bufferTime as higherOrder } from '../operators';
+import { bufferTime as higherOrder } from '../operators/bufferTime';
 
 /* tslint:disable:max-line-length */
 export function bufferTime<T>(this: Observable<T>, bufferTimeSpan: number, scheduler?: IScheduler): Observable<T[]>;

src/operator/bufferToggle.ts

@@ -1,6 +1,6 @@
 
 import { Observable, SubscribableOrPromise } from '../Observable';
-import { bufferToggle as higherOrder } from '../operators';
+import { bufferToggle as higherOrder } from '../operators/bufferToggle';
 
 /**
  * Buffers the source Observable values starting from an emission from

src/operator/bufferWhen.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { bufferWhen as higherOrder } from '../operators';
+import { bufferWhen as higherOrder } from '../operators/bufferWhen';
 
 /**
  * Buffers the source Observable values, using a factory function of closing

src/operator/catch.ts

@@ -1,6 +1,6 @@
 
 import { Observable, ObservableInput } from '../Observable';
-import { catchError as higherOrder } from '../operators';
+import { catchError as higherOrder } from '../operators/catchError';
 
 /**
  * Catches errors on the observable to be handled by returning a new observable or throwing an error.

src/operator/combineAll.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { combineAll as higherOrder } from '../operators';
+import { combineAll as higherOrder } from '../operators/combineAll';
 
 /**
  * Converts a higher-order Observable into a first-order Observable by waiting

src/operator/combineLatest.ts

@@ -1,5 +1,5 @@
 import { Observable, ObservableInput } from '../Observable';
-import { combineLatest as higherOrder } from '../operators';
+import { combineLatest as higherOrder } from '../operators/combineLatest';
 
 /* tslint:disable:max-line-length */
 export function combineLatest<T, R>(this: Observable<T>, project: (v1: T) => R): Observable<R>;

src/operator/concat.ts

@@ -1,6 +1,6 @@
 import { Observable, ObservableInput } from '../Observable';
 import { IScheduler } from '../Scheduler';
-import { concat as higherOrder } from '../operators';
+import { concat as higherOrder } from '../operators/concat';
 
 /* tslint:disable:max-line-length */
 export function concat<T>(this: Observable<T>, scheduler?: IScheduler): Observable<T>;

src/operator/concatMap.ts

@@ -1,4 +1,4 @@
-import { concatMap as higherOrderConcatMap } from '../operators';
+import { concatMap as higherOrderConcatMap } from '../operators/concatMap';
 import { Observable, ObservableInput } from '../Observable';
 
 /* tslint:disable:max-line-length */

src/operator/concatMapTo.ts

@@ -1,5 +1,5 @@
 import { Observable, ObservableInput } from '../Observable';
-import { concatMapTo as higherOrder } from '../operators';
+import { concatMapTo as higherOrder } from '../operators/concatMapTo';
 
 /* tslint:disable:max-line-length */
 export function concatMapTo<T, R>(this: Observable<T>, observable: ObservableInput<R>): Observable<R>;

src/operator/count.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { count as higherOrder } from '../operators';
+import { count as higherOrder } from '../operators/count';
 
 /**
  * Counts the number of emissions on the source and emits that number when the

src/operator/debounce.ts

@@ -1,6 +1,6 @@
 
 import { Observable, SubscribableOrPromise } from '../Observable';
-import { debounce as higherOrder } from '../operators';
+import { debounce as higherOrder } from '../operators/debounce';
 
 /**
  * Emits a value from the source Observable only after a particular time span

src/operator/debounceTime.ts

@@ -2,7 +2,7 @@
 import { Observable } from '../Observable';
 import { IScheduler } from '../Scheduler';
 import { async } from '../scheduler/async';
-import { debounceTime as higherOrder } from '../operators';
+import { debounceTime as higherOrder } from '../operators/debounceTime';
 
 /**
  * Emits a value from the source Observable only after a particular time span

src/operator/defaultIfEmpty.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { defaultIfEmpty as higherOrder } from '../operators';
+import { defaultIfEmpty as higherOrder } from '../operators/defaultIfEmpty';
 
 /* tslint:disable:max-line-length */
 export function defaultIfEmpty<T>(this: Observable<T>, defaultValue?: T): Observable<T>;

src/operator/delay.ts

@@ -1,7 +1,7 @@
 import { async } from '../scheduler/async';
 import { IScheduler } from '../Scheduler';
 import { Observable } from '../Observable';
-import { delay as higherOrder } from '../operators';
+import { delay as higherOrder } from '../operators/delay';
 
 /**
  * Delays the emission of items from the source Observable by a given timeout or

src/operator/delayWhen.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { delayWhen as higherOrder } from '../operators';
+import { delayWhen as higherOrder } from '../operators/delayWhen';
 
 /**
  * Delays the emission of items from the source Observable by a given time span

src/operator/dematerialize.ts

@@ -1,7 +1,7 @@
 
 import { Observable } from '../Observable';
 import { Notification } from '../Notification';
-import { dematerialize as higherOrder } from '../operators';
+import { dematerialize as higherOrder } from '../operators/dematerialize';
 
 /**
  * Converts an Observable of {@link Notification} objects into the emissions

src/operator/distinct.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { distinct as higherOrder } from '../operators';
+import { distinct as higherOrder } from '../operators/distinct';
 
 /**
  * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.

src/operator/distinctUntilChanged.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { distinctUntilChanged as higherOrder } from '../operators';
+import { distinctUntilChanged as higherOrder } from '../operators/distinctUntilChanged';
 
 /* tslint:disable:max-line-length */
 export function distinctUntilChanged<T>(this: Observable<T>, compare?: (x: T, y: T) => boolean): Observable<T>;

src/operator/distinctUntilKeyChanged.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { distinctUntilKeyChanged as higherOrder } from '../operators';
+import { distinctUntilKeyChanged as higherOrder } from '../operators/distinctUntilKeyChanged';
 
 /* tslint:disable:max-line-length */
 export function distinctUntilKeyChanged<T>(this: Observable<T>, key: string): Observable<T>;

src/operator/do.ts

@@ -1,7 +1,7 @@
 
 import { Observable } from '../Observable';
 import { PartialObserver } from '../Observer';
-import { tap as higherOrder } from '../operators';
+import { tap as higherOrder } from '../operators/tap';
 
 /* tslint:disable:max-line-length */
 export function _do<T>(this: Observable<T>, next: (x: T) => void, error?: (e: any) => void, complete?: () => void): Observable<T>;

src/operator/elementAt.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { elementAt as higherOrder } from '../operators';
+import { elementAt as higherOrder } from '../operators/elementAt';
 
 /**
  * Emits the single value at the specified `index` in a sequence of emissions

src/operator/every.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { every as higherOrder } from '../operators';
+import { every as higherOrder } from '../operators/every';
 
 /**
  * Returns an Observable that emits whether or not every item of the source satisfies the condition specified.

src/operator/exhaust.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { exhaust as higherOrder } from '../operators';
+import { exhaust as higherOrder } from '../operators/exhaust';
 
 /**
  * Converts a higher-order Observable into a first-order Observable by dropping

src/operator/exhaustMap.ts

@@ -1,6 +1,6 @@
 
 import { Observable, ObservableInput } from '../Observable';
-import { exhaustMap as higherOrder } from '../operators';
+import { exhaustMap as higherOrder } from '../operators/exhaustMap';
 
 /* tslint:disable:max-line-length */
 export function exhaustMap<T, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<R>): Observable<R>;

src/operator/expand.ts

@@ -1,6 +1,6 @@
 import { Observable } from '../Observable';
 import { IScheduler } from '../Scheduler';
-import { expand as higherOrder } from '../operators';
+import { expand as higherOrder } from '../operators/expand';
 
 /* tslint:disable:max-line-length */
 export function expand<T>(this: Observable<T>, project: (value: T, index: number) => Observable<T>, concurrent?: number, scheduler?: IScheduler): Observable<T>;

src/operator/filter.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { filter as higherOrderFilter } from '../operators';
+import { filter as higherOrderFilter } from '../operators/filter';
 
 /* tslint:disable:max-line-length */
 export function filter<T, S extends T>(this: Observable<T>,

src/operator/finally.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { finalize } from '../operators';
+import { finalize } from '../operators/finalize';
 
 /**
  * Returns an Observable that mirrors the source Observable, but will call a specified function when

src/operator/find.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { find as higherOrder } from '../operators';
+import { find as higherOrder } from '../operators/find';
 
 /* tslint:disable:max-line-length */
 export function find<T, S extends T>(this: Observable<T>,

src/operator/findIndex.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { findIndex as higherOrder } from '../operators';
+import { findIndex as higherOrder } from '../operators/findIndex';
 /**
  * Emits only the index of the first value emitted by the source Observable that
  * meets some condition.

src/operator/first.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { first as higherOrder } from '../operators';
+import { first as higherOrder } from '../operators/first';
 
 /* tslint:disable:max-line-length */
 export function first<T, S extends T>(this: Observable<T>,

src/operator/ignoreElements.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { ignoreElements as higherOrder } from '../operators';
+import { ignoreElements as higherOrder } from '../operators/ignoreElements';
 
 /**
  * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`.

src/operator/isEmpty.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../Observable';
-import { isEmpty as higherOrder } from '../operators';
+import { isEmpty as higherOrder } from '../operators/isEmpty';
 
 /**
  * If the source Observable is empty it returns an Observable that emits true, otherwise it emits false.

src/operator/last.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { last as higherOrder } from '../operators';
+import { last as higherOrder } from '../operators/last';
 
 /* tslint:disable:max-line-length */
 export function last<T, S extends T>(this: Observable<T>,

src/operator/map.ts

@@ -1,4 +1,4 @@
-import { map as higherOrderMap } from '../operators';
+import { map as higherOrderMap } from '../operators/map';
 import { Observable } from '../Observable';
 
 /**

src/operator/mapTo.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { mapTo as higherOrder } from '../operators';
+import { mapTo as higherOrder } from '../operators/mapTo';
 
 /**
  * Emits the given constant value on the output Observable every time the source

src/operator/materialize.ts

@@ -1,7 +1,7 @@
 
 import { Observable } from '../Observable';
 import { Notification } from '../Notification';
-import { materialize as higherOrder } from '../operators';
+import { materialize as higherOrder } from '../operators/materialize';
 
 /**
  * Represents all of the notifications from the source Observable as `next`

src/operator/max.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { max as higherOrderMax } from '../operators';
+import { max as higherOrderMax } from '../operators/max';
 
 /**
  * The Max operator operates on an Observable that emits numbers (or items that can be compared with a provided function),

src/operator/merge.ts

@@ -1,6 +1,6 @@
 import { Observable, ObservableInput } from '../Observable';
 import { IScheduler } from '../Scheduler';
-import { merge as higherOrder } from '../operators';
+import { merge as higherOrder } from '../operators/merge';
 
 export { mergeStatic } from '../operators/merge';
 

src/operator/mergeMap.ts

@@ -1,5 +1,5 @@
 import { Observable, ObservableInput } from '../Observable';
-import { mergeMap as higherOrderMergeMap } from '../operators';
+import { mergeMap as higherOrderMergeMap } from '../operators/mergeMap';
 
 /* tslint:disable:max-line-length */
 export function mergeMap<T, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<R>, concurrent?: number): Observable<R>;

src/operator/min.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { min as higherOrderMin } from '../operators';
+import { min as higherOrderMin } from '../operators/min';
 
 /**
  * The Min operator operates on an Observable that emits numbers (or items that can be compared with a provided function),

src/operator/multicast.ts

@@ -1,7 +1,7 @@
 import { Subject } from '../Subject';
 import { Observable } from '../Observable';
 import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { multicast as higherOrder } from '../operators';
+import { multicast as higherOrder } from '../operators/multicast';
 import { FactoryOrValue, MonoTypeOperatorFunction } from '../interfaces';
 
 /* tslint:disable:max-line-length */

src/operator/observeOn.ts

@@ -1,6 +1,6 @@
 import { Observable } from '../Observable';
 import { IScheduler } from '../Scheduler';
-import { observeOn as higherOrder } from '../operators';
+import { observeOn as higherOrder } from '../operators/observeOn';
 
 /**
  *

src/operator/publish.ts

@@ -1,7 +1,7 @@
 
 import { Observable } from '../Observable';
 import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { publish as higherOrder } from '../operators';
+import { publish as higherOrder } from '../operators/publish';
 
 /* tslint:disable:max-line-length */
 export function publish<T>(this: Observable<T>): ConnectableObservable<T>;

src/operator/publishLast.ts

@@ -1,6 +1,6 @@
 import { Observable } from '../Observable';
 import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { publishLast as higherOrder } from '../operators';
+import { publishLast as higherOrder } from '../operators/publishLast';
 /**
  * @return {ConnectableObservable<T>}
  * @method publishLast

src/operator/publishReplay.ts

@@ -1,7 +1,7 @@
 import { Observable } from '../Observable';
 import { IScheduler } from '../Scheduler';
 import { ConnectableObservable } from '../observable/ConnectableObservable';
-import { publishReplay as higherOrder } from '../operators';
+import { publishReplay as higherOrder } from '../operators/publishReplay';
 
 /**
  * @param bufferSize

src/operator/race.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { race as higherOrder } from '../operators';
+import { race as higherOrder } from '../operators/race';
 
 // NOTE: to support backwards compatability with 5.4.* and lower
 export { race as raceStatic } from '../observable/race';

src/operator/reduce.ts

@@ -1,5 +1,5 @@
 import { Observable } from '../Observable';
-import { reduce as higherOrderReduce } from '../operators';
+import { reduce as higherOrderReduce } from '../operators/reduce';
 
 /* tslint:disable:max-line-length */
 export function reduce<T>(this: Observable<T>, accumulator: (acc: T, value: T, index: number) => T, seed?: T): Observable<T>;