feat(reorganize): All patch operators moved to internal directory

Moves all patching operator implementations to a directory `internal/patching/operator`.

BREAKING CHANGE: Deep imports to `rxjs/operator/*` (NOT
`rxjs/operators/*`!!!) will no longer work. Again, pipe operators are
still where they were.

src/Rx.ts

@@ -157,7 +157,7 @@ export {ArgumentOutOfRangeError} from './util/ArgumentOutOfRangeError';
 export {ObjectUnsubscribedError} from './util/ObjectUnsubscribedError';
 export {TimeoutError} from './util/TimeoutError';
 export {UnsubscriptionError} from './util/UnsubscriptionError';
-export {TimeInterval} from './operator/timeInterval';
+export {TimeInterval} from './internal/patching/operator/timeInterval';
 export {Timestamp} from './operators/timestamp';
 export {TestScheduler} from './testing/TestScheduler';
 export {VirtualTimeScheduler} from './scheduler/VirtualTimeScheduler';

src/add/operator/audit.ts

@@ -1,10 +1,10 @@
 import { Observable } from '../../Observable';
-import { audit } from '../../operator/audit';
+import { audit } from '../../internal/patching/operator/audit';
 
 Observable.prototype.audit = audit;
 
 declare module '../../Observable' {
   interface Observable<T> {
     audit: typeof audit;
   }
-}
+}

src/add/operator/auditTime.ts

@@ -1,10 +1,10 @@
 import { Observable } from '../../Observable';
-import { auditTime } from '../../operator/auditTime';
+import { auditTime } from '../../internal/patching/operator/auditTime';
 
 Observable.prototype.auditTime = auditTime;
 
 declare module '../../Observable' {
   interface Observable<T> {
     auditTime: typeof auditTime;
   }
-}
+}

src/add/operator/buffer.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { buffer } from '../../operator/buffer';
+import { buffer } from '../../internal/patching/operator/buffer';
 
 Observable.prototype.buffer = buffer;
 
 declare module '../../Observable' {
   interface Observable<T> {
     buffer: typeof buffer;
   }
-}
+}

src/add/operator/bufferCount.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { bufferCount } from '../../operator/bufferCount';
+import { bufferCount } from '../../internal/patching/operator/bufferCount';
 
 Observable.prototype.bufferCount = bufferCount;
 
 declare module '../../Observable' {
   interface Observable<T> {
     bufferCount: typeof bufferCount;
   }
-}
+}

src/add/operator/bufferTime.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { bufferTime } from '../../operator/bufferTime';
+import { bufferTime } from '../../internal/patching/operator/bufferTime';
 
 Observable.prototype.bufferTime = bufferTime;
 
 declare module '../../Observable' {
   interface Observable<T> {
     bufferTime: typeof bufferTime;
   }
-}
+}

src/add/operator/bufferToggle.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { bufferToggle } from '../../operator/bufferToggle';
+import { bufferToggle } from '../../internal/patching/operator/bufferToggle';
 
 Observable.prototype.bufferToggle = bufferToggle;
 
 declare module '../../Observable' {
   interface Observable<T> {
     bufferToggle: typeof bufferToggle;
   }
-}
+}

src/add/operator/bufferWhen.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { bufferWhen } from '../../operator/bufferWhen';
+import { bufferWhen } from '../../internal/patching/operator/bufferWhen';
 
 Observable.prototype.bufferWhen = bufferWhen;
 
 declare module '../../Observable' {
   interface Observable<T> {
     bufferWhen: typeof bufferWhen;
   }
-}
+}

src/add/operator/catch.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../../Observable';
-import { _catch } from '../../operator/catch';
+import { _catch } from '../../internal/patching/operator/catch';
 
 Observable.prototype.catch = _catch;
 Observable.prototype._catch = _catch;
@@ -10,4 +10,4 @@ declare module '../../Observable' {
     catch: typeof _catch;
     _catch: typeof _catch;
   }
-}
+}

src/add/operator/combineAll.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { combineAll } from '../../operator/combineAll';
+import { combineAll } from '../../internal/patching/operator/combineAll';
 
 Observable.prototype.combineAll = combineAll;
 
 declare module '../../Observable' {
   interface Observable<T> {
     combineAll: typeof combineAll;
   }
-}
+}

src/add/operator/combineLatest.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { combineLatest } from '../../operator/combineLatest';
+import { combineLatest } from '../../internal/patching/operator/combineLatest';
 
 Observable.prototype.combineLatest = combineLatest;
 
 declare module '../../Observable' {
   interface Observable<T> {
     combineLatest: typeof combineLatest;
   }
-}
+}

src/add/operator/concat.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { concat } from '../../operator/concat';
+import { concat } from '../../internal/patching/operator/concat';
 
 Observable.prototype.concat = concat;
 
 declare module '../../Observable' {
   interface Observable<T> {
     concat: typeof concat;
   }
-}
+}

src/add/operator/concatAll.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { concatAll } from '../../operator/concatAll';
+import { concatAll } from '../../internal/patching/operator/concatAll';
 
 Observable.prototype.concatAll = concatAll;
 
 declare module '../../Observable' {
   interface Observable<T> {
     concatAll: typeof concatAll;
   }
-}
+}

src/add/operator/concatMap.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { concatMap } from '../../operator/concatMap';
+import { concatMap } from '../../internal/patching/operator/concatMap';
 
 Observable.prototype.concatMap = concatMap;
 
 declare module '../../Observable' {
   interface Observable<T> {
     concatMap: typeof concatMap;
   }
-}
+}

src/add/operator/concatMapTo.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { concatMapTo } from '../../operator/concatMapTo';
+import { concatMapTo } from '../../internal/patching/operator/concatMapTo';
 
 Observable.prototype.concatMapTo = concatMapTo;
 
 declare module '../../Observable' {
   interface Observable<T> {
     concatMapTo: typeof concatMapTo;
   }
-}
+}

src/add/operator/count.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { count } from '../../operator/count';
+import { count } from '../../internal/patching/operator/count';
 
 Observable.prototype.count = count;
 
 declare module '../../Observable' {
   interface Observable<T> {
     count: typeof count;
   }
-}
+}

src/add/operator/debounce.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { debounce } from '../../operator/debounce';
+import { debounce } from '../../internal/patching/operator/debounce';
 
 Observable.prototype.debounce = debounce;
 
 declare module '../../Observable' {
   interface Observable<T> {
     debounce: typeof debounce;
   }
-}
+}

src/add/operator/debounceTime.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { debounceTime } from '../../operator/debounceTime';
+import { debounceTime } from '../../internal/patching/operator/debounceTime';
 
 Observable.prototype.debounceTime = debounceTime;
 
 declare module '../../Observable' {
   interface Observable<T> {
     debounceTime: typeof debounceTime;
   }
-}
+}

src/add/operator/defaultIfEmpty.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { defaultIfEmpty } from '../../operator/defaultIfEmpty';
+import { defaultIfEmpty } from '../../internal/patching/operator/defaultIfEmpty';
 
 Observable.prototype.defaultIfEmpty = defaultIfEmpty;
 
 declare module '../../Observable' {
   interface Observable<T> {
     defaultIfEmpty: typeof defaultIfEmpty;
   }
-}
+}

src/add/operator/delay.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { delay } from '../../operator/delay';
+import { delay } from '../../internal/patching/operator/delay';
 
 Observable.prototype.delay = delay;
 
 declare module '../../Observable' {
   interface Observable<T> {
     delay: typeof delay;
   }
-}
+}

src/add/operator/delayWhen.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { delayWhen } from '../../operator/delayWhen';
+import { delayWhen } from '../../internal/patching/operator/delayWhen';
 
 Observable.prototype.delayWhen = delayWhen;
 
 declare module '../../Observable' {
   interface Observable<T> {
     delayWhen: typeof delayWhen;
   }
-}
+}

src/add/operator/dematerialize.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { dematerialize } from '../../operator/dematerialize';
+import { dematerialize } from '../../internal/patching/operator/dematerialize';
 
 Observable.prototype.dematerialize = dematerialize;
 
 declare module '../../Observable' {
   interface Observable<T> {
     dematerialize: typeof dematerialize;
   }
-}
+}

src/add/operator/distinct.ts

@@ -1,10 +1,10 @@
 import { Observable } from '../../Observable';
-import { distinct } from '../../operator/distinct';
+import { distinct } from '../../internal/patching/operator/distinct';
 
 Observable.prototype.distinct = distinct;
 
 declare module '../../Observable' {
   interface Observable<T> {
     distinct: typeof distinct;
   }
-}
+}

src/add/operator/distinctUntilChanged.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { distinctUntilChanged } from '../../operator/distinctUntilChanged';
+import { distinctUntilChanged } from '../../internal/patching/operator/distinctUntilChanged';
 
 Observable.prototype.distinctUntilChanged = distinctUntilChanged;
 
 declare module '../../Observable' {
   interface Observable<T> {
     distinctUntilChanged: typeof distinctUntilChanged;
   }
-}
+}

src/add/operator/distinctUntilKeyChanged.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { distinctUntilKeyChanged } from '../../operator/distinctUntilKeyChanged';
+import { distinctUntilKeyChanged } from '../../internal/patching/operator/distinctUntilKeyChanged';
 
 Observable.prototype.distinctUntilKeyChanged = distinctUntilKeyChanged;
 
 declare module '../../Observable' {
   interface Observable<T> {
     distinctUntilKeyChanged: typeof distinctUntilKeyChanged;
   }
-}
+}

src/add/operator/do.ts

@@ -1,6 +1,6 @@
 
 import { Observable } from '../../Observable';
-import { _do } from '../../operator/do';
+import { _do } from '../../internal/patching/operator/do';
 
 Observable.prototype.do = _do;
 Observable.prototype._do = _do;
@@ -10,4 +10,4 @@ declare module '../../Observable' {
     do: typeof _do;
     _do: typeof _do;
   }
-}
+}

src/add/operator/elementAt.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { elementAt } from '../../operator/elementAt';
+import { elementAt } from '../../internal/patching/operator/elementAt';
 
 Observable.prototype.elementAt = elementAt;
 
 declare module '../../Observable' {
   interface Observable<T> {
     elementAt: typeof elementAt;
   }
-}
+}