@fncts/observable 0.0.1 → 0.0.4

package/_cjs/Observable/api.cjs

@@ -12,15 +12,14 @@ exports.audit_ = void 0;
 exports.bufferCount_ = bufferCount_;
 exports.bufferTime_ = bufferTime_;
 exports.bufferToggle_ = bufferToggle_;
-exports.bufferWhen = bufferWhen;
-exports.bufferWhen_ = void 0;
+exports.bufferWhen_ = bufferWhen_;
 exports.buffer_ = buffer_;
 exports.catchAllCause = void 0;
 exports.combineLatestAll = combineLatestAll;
 exports.concatAll = exports.combineLatest_ = void 0;
 exports.concatMapWithIndex = concatMapWithIndex;
 exports.concatMap_ = concatMap_;
-exports.concat_ = void 0;
+exports.contramapEnvironment = exports.concat_ = void 0;
 exports.count = count;
 exports.countWithIndex = void 0;
 exports.countWith_ = countWith_;
@@ -32,6 +31,7 @@ exports.dematerialize = dematerialize;
 exports.either = either;
 exports.empty = void 0;
 exports.ensuring_ = ensuring_;
+exports.environmentWithObservable = void 0;
 exports.exhaustAll = exhaustAll;
 exports.exhaustMapWithIndex = void 0;
 exports.exhaustMap_ = exhaustMap_;
@@ -73,13 +73,14 @@ exports.materialize = materialize;
 exports.merge = merge;
 exports.mergeScanWithIndex = exports.mergeMap_ = exports.mergeMapWithIndex = exports.mergeAll_ = void 0;
 exports.mergeScan_ = mergeScan_;
-exports.of = of;
-exports.onEmpty_ = void 0;
+exports.onEmpty_ = exports.of = void 0;
 exports.onErrorResumeNext = onErrorResumeNext;
 exports.partitionMapWithIndex_ = void 0;
 exports.partitionMap_ = partitionMap_;
 exports.partitionWithIndex = void 0;
 exports.partition_ = partition_;
+exports.provideEnvironment = provideEnvironment;
+exports.provideService = provideService;
 exports.repeat_ = repeat_;
 exports.retry_ = retry_;
 exports.sampleTime_ = sampleTime_;
@@ -94,7 +95,9 @@ exports.scheduleObservable = scheduleObservable;
 exports.schedulePromise = schedulePromise;
 exports.scheduleReadableStreamLike = scheduleReadableStreamLike;
 exports.scheduled = void 0;
-exports.single = void 0;
+exports.service = service;
+exports.serviceWith = serviceWith;
+exports.single = exports.serviceWithObservable = void 0;
 exports.skipLast_ = skipLast_;
 exports.skipUntil_ = skipUntil_;
 exports.skipWhile_ = skipWhile_;
@@ -121,23 +124,23 @@ exports.unit = void 0;
 exports.zip = zip;
 exports.zipWith = void 0;
 
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Observable"));
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api"));
 
-var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api"));
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/internal/util"));
 
-var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/internal/util"));
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/util/predicates"));
 
-var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/util/predicates"));
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO"));
 
-var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO"));
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/AsyncScheduler"));
 
-var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/AsyncScheduler"));
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Subscription"));
 
-var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Subscription"));
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Scheduler"));
 
-var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Scheduler"));
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Operator"));
 
-var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Operator"));
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/environment"));
 
 var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/runtime"));
 
@@ -151,15 +154,17 @@ var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/requir
 
 var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
 
-var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Environment/api"));
 
-var tsplus_module_17 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+var tsplus_module_17 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
 
-var tsplus_module_18 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/constructors"));
+var tsplus_module_18 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
 
-var tsplus_module_19 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Notification"));
+var tsplus_module_19 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/constructors"));
 
-var tsplus_module_20 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/HashSet/api"));
+var tsplus_module_20 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/observable/Notification"));
+
+var tsplus_module_21 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/HashSet/api"));
 
 var _args = /*#__PURE__*/require("@fncts/observable/internal/args");
 
@@ -174,6 +179,8 @@ const defer = defer_1;
 exports.defer = defer;
 const empty = empty_1;
 exports.empty = empty;
+const environmentWithObservable = environmentWithObservable_1;
+exports.environmentWithObservable = environmentWithObservable;
 const fail = fail_1;
 exports.fail = fail;
 const from = from_1;
@@ -182,6 +189,8 @@ const fromSubscribable = fromSubscribable_1;
 exports.fromSubscribable = fromSubscribable;
 const interval = interval_1;
 exports.interval = interval;
+const of = of_1;
+exports.of = of;
 const single = single_1;
 exports.single = single;
 const scheduled = scheduled_1;
@@ -210,14 +219,14 @@ const mergeMapWithIndex = mergeMapWithIndex_1;
 exports.mergeMapWithIndex = mergeMapWithIndex;
 const mergeMap_ = mergeMap_1;
 exports.mergeMap_ = mergeMap_;
+const contramapEnvironment = contramapEnvironment_1;
+exports.contramapEnvironment = contramapEnvironment;
 const foldLeftWithIndex = foldLeftWithIndex_1;
 exports.foldLeftWithIndex = foldLeftWithIndex;
 const foldLeft = foldLeft_1;
 exports.foldLeft = foldLeft;
 const audit_ = audit_1;
 exports.audit_ = audit_;
-const bufferWhen_ = bufferWhen_1;
-exports.bufferWhen_ = bufferWhen_;
 const catchAllCause = catchAllCause_1;
 exports.catchAllCause = catchAllCause;
 const concatAll = concatAll_1;
@@ -250,6 +259,8 @@ const sample_ = sample_1;
 exports.sample_ = sample_;
 const scanLeftWithIndex = scanLeftWithIndex_1;
 exports.scanLeftWithIndex = scanLeftWithIndex;
+const serviceWithObservable = serviceWithObservable_1;
+exports.serviceWithObservable = serviceWithObservable;
 const switchMapWithIndex = switchMapWithIndex_1;
 exports.switchMapWithIndex = switchMapWithIndex;
 const switchMap_ = switchMap_1;
@@ -267,17 +278,11 @@ exports.toArray = toArray;
 const uniqueUntilChanged_ = uniqueUntilChanged_1;
 exports.uniqueUntilChanged_ = uniqueUntilChanged_;
 
-/*
- * -------------------------------------------------------------------------------------------------
- * constructors
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus static fncts.observable.ObservableOps halt
  */
 function halt(defect) {
-  return new tsplus_module_1.Observable(s => s.error(tsplus_module_2.halt(defect)));
+  return new _definition2.Observable(s => s.error(tsplus_module_1.halt(defect)));
 }
 /**
  * @tsplus static fncts.observable.ObservableOps defer
@@ -285,7 +290,7 @@ function halt(defect) {
 
 
 function defer_1(observable) {
-  return new tsplus_module_1.Observable(s => {
+  return new _definition2.Observable(s => {
     from_1(observable()).subscribe(s);
   });
 }
@@ -297,13 +302,21 @@ function defer_1(observable) {
 function empty_1() {
   return _definition2.EMPTY;
 }
+/**
+ * @tsplus static fncts.observable.ObservableOps environmentWithObservable
+ */
+
+
+function environmentWithObservable_1(f) {
+  return new _definition2.EnvironmentWith(f);
+}
 /**
  * @tsplus static fncts.observable.ObservableOps failCause
  */
 
 
 function failCause(cause) {
-  return new tsplus_module_1.Observable(s => s.error(cause));
+  return new _definition2.Observable(s => s.error(cause));
 }
 /**
  * @tsplus static fncts.observable.ObservableOps fail
@@ -311,7 +324,7 @@ function failCause(cause) {
 
 
 function fail_1(e) {
-  return new tsplus_module_1.Observable(s => s.error(tsplus_module_2.fail(e)));
+  return new _definition2.Observable(s => s.error(tsplus_module_1.fail(e)));
 }
 /**
  * @tsplus static fncts.observable.ObservableOps from
@@ -319,31 +332,31 @@ function fail_1(e) {
 
 
 function from_1(input) {
-  if (input instanceof tsplus_module_1.Observable) {
+  if (input instanceof _definition2.Observable) {
     return input;
   }
 
-  if (tsplus_module_3.isArrayLike(input)) {
+  if (tsplus_module_2.isArrayLike(input)) {
     return fromArrayLike(input);
   }
 
-  if (tsplus_module_3.isPromiseLike(input)) {
+  if (tsplus_module_2.isPromiseLike(input)) {
     return fromPromise(input);
   }
 
-  if (tsplus_module_3.isAsyncIterable(input)) {
+  if (tsplus_module_2.isAsyncIterable(input)) {
     return fromAsyncIterable(input);
   }
 
-  if (tsplus_module_4.isIterable(input)) {
+  if (tsplus_module_3.isIterable(input)) {
     return fromIterable(input);
   }
 
-  if (tsplus_module_3.isReadableStream(input)) {
+  if (tsplus_module_2.isReadableStream(input)) {
     return fromReadableStreamLike(input);
   }
 
-  if (tsplus_module_5.isIO(input)) {
+  if (tsplus_module_4.isIO(input)) {
     return fromIO_1(input);
   }
 
@@ -355,7 +368,7 @@ function from_1(input) {
 }
 
 function fromArrayLike(input) {
-  return new tsplus_module_1.Observable(s => {
+  return new _definition2.Observable(s => {
     for (let i = 0; i < input.length && !s.closed; i++) {
       s.next(input[i]);
     }
@@ -365,13 +378,13 @@ function fromArrayLike(input) {
 }
 
 function fromAsyncIterable(asyncIterable) {
-  return new tsplus_module_1.Observable(s => {
-    process(asyncIterable, s).catch(err => s.error(tsplus_module_2.halt(err)));
+  return new _definition2.Observable(s => {
+    process(asyncIterable, s).catch(err => s.error(tsplus_module_1.halt(err)));
   });
 }
 
 function fromIterable(iterable) {
-  return new tsplus_module_1.Observable(s => {
+  return new _definition2.Observable(s => {
     for (const value of iterable) {
       s.next(value);
 
@@ -385,18 +398,18 @@ function fromIterable(iterable) {
 }
 
 function fromPromise(promise) {
-  return new tsplus_module_1.Observable(s => {
+  return new _definition2.Observable(s => {
     promise.then(value => {
       if (!s.closed) {
         s.next(value);
         s.complete();
       }
-    }, err => s.error(tsplus_module_2.halt(err))).then(null, tsplus_module_3.reportUnhandledError);
+    }, err => s.error(tsplus_module_1.halt(err))).then(null, tsplus_module_2.reportUnhandledError);
   });
 }
 
 function fromReadableStreamLike(readableStream) {
-  return fromAsyncIterable((0, tsplus_module_3.readableStreamToAsyncGenerator)(readableStream));
+  return fromAsyncIterable((0, tsplus_module_2.readableStreamToAsyncGenerator)(readableStream));
 }
 /**
  * @tsplus static fncts.observable.ObservableOps fromSubscribable
@@ -404,13 +417,13 @@ function fromReadableStreamLike(readableStream) {
 
 
 function fromSubscribable_1(subscribable) {
-  return new tsplus_module_1.Observable(subscriber => subscribable.subscribe(subscriber));
+  return new _definition2.Observable(subscriber => subscribable.subscribe(subscriber));
 }
 
 function fromInterop(subscribable) {
-  return new tsplus_module_1.Observable(subscriber => subscribable.subscribe({
+  return new _definition2.Observable(subscriber => subscribable.subscribe({
     next: value => subscriber.next(value),
-    error: err => subscriber.error(tsplus_module_2.halt(err)),
+    error: err => subscriber.error(tsplus_module_1.halt(err)),
     complete: () => subscriber.complete()
   }));
 }
@@ -452,7 +465,7 @@ async function process(asyncIterable, subscriber) {
  */
 
 
-function interval_1(period = 0, scheduler = tsplus_module_6.asyncScheduler) {
+function interval_1(period = 0, scheduler = tsplus_module_5.asyncScheduler) {
   if (period < 0) {
     // eslint-disable-next-line no-param-reassign
     period = 0;
@@ -470,7 +483,7 @@ function merge(...sources) {
  */
 
 
-function of(...items) {
+function of_1(...items) {
   return fromArrayLike(items);
 }
 /**
@@ -479,7 +492,7 @@ function of(...items) {
 
 
 function single_1(a) {
-  return new tsplus_module_1.Observable(s => {
+  return new _definition2.Observable(s => {
     s.next(a);
     s.complete();
   });
@@ -491,23 +504,23 @@ function single_1(a) {
 
 
 function scheduled_1(input, scheduler) {
-  if (tsplus_module_3.isArrayLike(input)) {
+  if (tsplus_module_2.isArrayLike(input)) {
     return scheduleArray(input, scheduler);
   }
 
-  if (tsplus_module_3.isPromiseLike(input)) {
+  if (tsplus_module_2.isPromiseLike(input)) {
     return schedulePromise(input, scheduler);
   }
 
-  if (tsplus_module_4.isIterable(input)) {
+  if (tsplus_module_3.isIterable(input)) {
     return scheduleIterable(input, scheduler);
   }
 
-  if (tsplus_module_3.isAsyncIterable(input)) {
+  if (tsplus_module_2.isAsyncIterable(input)) {
     return scheduleAsyncIterable(input, scheduler);
   }
 
-  if (tsplus_module_3.isReadableStream(input)) {
+  if (tsplus_module_2.isReadableStream(input)) {
     return scheduleReadableStreamLike(input, scheduler);
   }
 
@@ -515,7 +528,7 @@ function scheduled_1(input, scheduler) {
 }
 
 function scheduleArray(input, scheduler) {
-  return new tsplus_module_1.Observable(s => {
+  return new _definition2.Observable(s => {
     let i = 0;
     return scheduler.schedule(function () {
       if (i === input.length) {
@@ -532,8 +545,8 @@ function scheduleArray(input, scheduler) {
 }
 
 function scheduleAsyncIterable(input, scheduler) {
-  return new tsplus_module_1.Observable(subscriber => {
-    const sub = new tsplus_module_7.Subscription();
+  return new _definition2.Observable(subscriber => {
+    const sub = new tsplus_module_6.Subscription();
     sub.add(scheduler.schedule(() => {
       const iterator = input[Symbol.asyncIterator]();
       sub.add(scheduler.schedule(function () {
@@ -552,11 +565,11 @@ function scheduleAsyncIterable(input, scheduler) {
 }
 
 function scheduleIterable(input, scheduler) {
-  return new tsplus_module_1.Observable(s => {
+  return new _definition2.Observable(s => {
     let iterator;
     s.add(scheduler.schedule(() => {
       iterator = input[Symbol.iterator]();
-      (0, tsplus_module_8.caughtSchedule)(s, scheduler, function () {
+      (0, tsplus_module_7.caughtSchedule)(s, scheduler, function () {
         const {
           value,
           done
@@ -570,13 +583,13 @@ function scheduleIterable(input, scheduler) {
         }
       });
     }));
-    return () => tsplus_module_4.isFunction(iterator?.return) && iterator.return();
+    return () => tsplus_module_3.isFunction(iterator?.return) && iterator.return();
   });
 }
 
 function scheduleObservable(input, scheduler) {
-  return new tsplus_module_1.Observable(subscriber => {
-    const sub = new tsplus_module_7.Subscription();
+  return new _definition2.Observable(subscriber => {
+    const sub = new tsplus_module_6.Subscription();
     sub.add(scheduler.schedule(() => {
       sub.add(input.subscribe({
         next: value => {
@@ -594,7 +607,7 @@ function scheduleObservable(input, scheduler) {
 }
 
 function schedulePromise(input, scheduler) {
-  return new tsplus_module_1.Observable(subscriber => {
+  return new _definition2.Observable(subscriber => {
     return scheduler.schedule(() => {
       input.then(value => {
         subscriber.add(scheduler.schedule(() => {
@@ -602,21 +615,21 @@ function schedulePromise(input, scheduler) {
           subscriber.add(scheduler.schedule(() => subscriber.complete()));
         }));
       }, err => {
-        subscriber.add(scheduler.schedule(() => subscriber.error(tsplus_module_2.halt(err))));
+        subscriber.add(scheduler.schedule(() => subscriber.error(tsplus_module_1.halt(err))));
       });
     });
   });
 }
 
 function scheduleReadableStreamLike(input, scheduler) {
-  return scheduleAsyncIterable((0, tsplus_module_3.readableStreamToAsyncGenerator)(input), scheduler);
+  return scheduleAsyncIterable((0, tsplus_module_2.readableStreamToAsyncGenerator)(input), scheduler);
 }
 
-function timer_1(time = 0, intervalOrScheduler, scheduler = tsplus_module_6.asyncScheduler) {
+function timer_1(time = 0, intervalOrScheduler, scheduler = tsplus_module_5.asyncScheduler) {
   let intervalDuration = -1;
 
   if (intervalOrScheduler != null) {
-    if (tsplus_module_8.isScheduler(intervalOrScheduler)) {
+    if (tsplus_module_7.isScheduler(intervalOrScheduler)) {
       // eslint-disable-next-line no-param-reassign
       scheduler = intervalOrScheduler;
     } else {
@@ -624,8 +637,8 @@ function timer_1(time = 0, intervalOrScheduler, scheduler = tsplus_module_6.asyn
     }
   }
 
-  return new tsplus_module_1.Observable(s => {
-    let due = tsplus_module_3.isValidDate(time) ? +time - scheduler.now() : time;
+  return new _definition2.Observable(s => {
+    let due = tsplus_module_2.isValidDate(time) ? +time - scheduler.now() : time;
 
     if (due < 0) {
       due = 0;
@@ -651,7 +664,7 @@ function timer_1(time = 0, intervalOrScheduler, scheduler = tsplus_module_6.asyn
 
 
 function makeZip(...sources) {
-  return sources.length ? new tsplus_module_1.Observable(subscriber => {
+  return sources.length ? new _definition2.Observable(subscriber => {
     let buffers = sources.map(() => []);
     let completed = sources.map(() => false);
     subscriber.add(() => {
@@ -659,7 +672,7 @@ function makeZip(...sources) {
     });
 
     for (let sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
-      from_1(sources[sourceIndex]).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      from_1(sources[sourceIndex]).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
         next: value => {
           buffers[sourceIndex].push(value);
 
@@ -689,11 +702,11 @@ function makeZip(...sources) {
  */
 
 
-function fromIO_1(io, scheduler = tsplus_module_6.asyncScheduler) {
-  return new tsplus_module_1.Observable(s => {
+function fromIO_1(io, scheduler = tsplus_module_5.asyncScheduler) {
+  return new _definition2.Observable((s, env) => {
     let fiber;
     const scheduled = scheduler.schedule(() => {
-      fiber = tsplus_module_10.unsafeRunFiber(io, fileName_1 + ":473:32");
+      fiber = tsplus_module_10.unsafeRunFiber(tsplus_module_9.provideEnvironment_(io, env, fileName_1 + ":487:36"), fileName_1 + ":487:56");
       fiber.unsafeOnDone(exit => {
         if (!s.closed) {
           tsplus_module_11.match_(tsplus_module_11.flatten(exit), cause => s.error(cause), a => s.next(a));
@@ -703,28 +716,16 @@ function fromIO_1(io, scheduler = tsplus_module_6.asyncScheduler) {
     });
     return () => {
       scheduled.unsubscribe();
-      fiber && tsplus_module_10.unsafeRunAsync(tsplus_module_12.interrupt(fiber), fileName_1 + ":486:46");
+      fiber && tsplus_module_10.unsafeRunAsync(tsplus_module_12.interrupt(fiber, fileName_1 + ":500:21"), fileName_1 + ":500:46");
     };
   });
 }
-/*
- * -------------------------------------------------------------------------------------------------
- * Applicative
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus static fncts.observable.ObservableOps unit
  */
 
 
 const unit = /*#__PURE__*/single_1(undefined);
-/*
- * -------------------------------------------------------------------------------------------------
- * Apply
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus fluent fncts.observable.Observable zipWith
  */
@@ -750,21 +751,15 @@ function zip(fa, fb) {
 function ap(fab, fa) {
   return zipWith_1(fab, fa, (f, a) => f(a));
 }
-/*
- * -------------------------------------------------------------------------------------------------
- * Functor
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus fluent fncts.observable.Observable mapWithIndex
  */
 
 
 function mapWithIndex_1(fa, f) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let i = 0;
-    source.subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+    source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
       next: value => {
         subscriber.next(f(i++, value));
       }
@@ -787,22 +782,16 @@ function map_1(fa, f) {
 function as_1(fa, b) {
   return map_1(fa, b);
 }
-/*
- * -------------------------------------------------------------------------------------------------
- * Bifunctor
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus fluent fncts.observable.Observable mapError
  */
 
 
 function mapError_(fa, f) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    source.subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
       error: err => {
-        subscriber.error(tsplus_module_2.map_(err, f));
+        subscriber.error(tsplus_module_1.map_(err, f));
       }
     }));
   });
@@ -813,13 +802,13 @@ function mapError_(fa, f) {
 
 
 function swap(fa) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    source.subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
       next: value => {
-        subscriber.error(tsplus_module_2.fail(value));
+        subscriber.error(tsplus_module_1.fail(value));
       },
       error: err => {
-        tsplus_module_14.match_(tsplus_module_2.failureOrCause(err), e => {
+        tsplus_module_14.match_(tsplus_module_1.failureOrCause(err), e => {
           subscriber.next(e);
         }, cause => {
           subscriber.error(cause);
@@ -830,9 +819,9 @@ function swap(fa) {
 }
 
 function filterWithIndex_1(fa, predicate) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let index = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => predicate(index++, value) && subscriber.next(value)
     }));
   });
@@ -847,10 +836,10 @@ function filter_(fa, predicate) {
 
 
 function filterMapWithIndex_1(fa, f) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let index = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
-      next: value => tsplus_module_15.match_(f(index++, value), () => tsplus_module_3.noop, b => subscriber.next(b))
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+      next: value => tsplus_module_15.match_(f(index++, value), () => tsplus_module_2.noop, b => subscriber.next(b))
     }));
   });
 }
@@ -876,18 +865,18 @@ function partition_(fa, predicate) {
 
 
 function partitionMapWithIndex_1(fa, f) {
-  return [tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return [tsplus_module_8.operate_(fa, (source, subscriber) => {
     let index = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
-        tsplus_module_14.match_(f(index++, value), b => subscriber.next(b), tsplus_module_3.noop);
+        tsplus_module_14.match_(f(index++, value), b => subscriber.next(b), tsplus_module_2.noop);
       }
     }));
-  }), tsplus_module_9.operate_(fa, (source, subscriber) => {
+  }), tsplus_module_8.operate_(fa, (source, subscriber) => {
     let index = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
-        tsplus_module_14.match_(f(index++, value), tsplus_module_3.noop, c => subscriber.next(c));
+        tsplus_module_14.match_(f(index++, value), tsplus_module_2.noop, c => subscriber.next(c));
       }
     }));
   })];
@@ -900,19 +889,31 @@ function partitionMapWithIndex_1(fa, f) {
 function partitionMap_(fa, f) {
   return partitionMapWithIndex_1(fa, (_, a) => f(a));
 }
-/*
- * -------------------------------------------------------------------------------------------------
- * Monad
- * -------------------------------------------------------------------------------------------------
+/**
+ * @tsplus fluent fncts.observable.Observable provideEnvironment
+ */
+
+
+function provideEnvironment(self, environment) {
+  return self.provide(environment);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable provideService
  */
 
+
+function provideService(self, service,
+/** @tsplus auto */
+tag) {
+  return contramapEnvironment_1(self, environment => tsplus_module_16.add(environment, service, tag));
+}
 /**
  * @tsplus fluent fncts.observable.Observable mergeMapWithIndex
  */
 
 
 function mergeMapWithIndex_1(ma, f, concurrent = Infinity) {
-  return tsplus_module_9.operate_(ma, (source, sub) => mergeInternal(source, sub, f, concurrent));
+  return tsplus_module_8.operate_(ma, (source, sub) => mergeInternal(source, sub, f, concurrent));
 }
 /**
  * @tsplus fluent fncts.observable.Observable mergeMap
@@ -938,6 +939,14 @@ function concatMapWithIndex(ma, f) {
 function concatMap_(ma, f) {
   return mergeMapWithIndex_1(ma, (_, a) => f(a), 1);
 }
+/**
+ * @tsplus fluent fncts.observable.Observable contramapEnvironment
+ */
+
+
+function contramapEnvironment_1(self, f) {
+  return environmentWithObservable_1(environment => self.provide(f(environment)));
+}
 /**
  * @tsplus getter fncts.observable.Observable flatten
  */
@@ -946,19 +955,13 @@ function concatMap_(ma, f) {
 function flatten(mma) {
   return concatAll_1(mma);
 }
-/*
- * -------------------------------------------------------------------------------------------------
- * Foldable
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus fluent fncts.observable.Observable foldLeftWithIndex
  */
 
 
 function foldLeftWithIndex_1(fa, initial, f) {
-  return tsplus_module_9.operate_(fa, scanInternal(f, initial, true, false, true));
+  return tsplus_module_8.operate_(fa, scanInternal(f, initial, true, false, true));
 }
 /**
  * @tsplus fluent fncts.observable.Observable foldLeft
@@ -968,19 +971,13 @@ function foldLeftWithIndex_1(fa, initial, f) {
 function foldLeft_1(fa, initial, f) {
   return foldLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
 }
-/*
- * -------------------------------------------------------------------------------------------------
- * combinators
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus fluent fncts.observable.Observable at
  */
 
 
 function at_(fa, index) {
-  return onEmpty_1(map_1(take_1(filterWithIndex_1(fa, i => i === index), 1), tsplus_module_16.just), () => tsplus_module_16.nothing());
+  return onEmpty_1(map_1(take_1(filterWithIndex_1(fa, i => i === index), 1), tsplus_module_17.just), () => tsplus_module_17.nothing());
 }
 /**
  * @tsplus fluent fncts.observable.Observable audit
@@ -988,8 +985,8 @@ function at_(fa, index) {
 
 
 function audit_1(fa, durationSelector) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    let lastValue = tsplus_module_16.nothing();
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    let lastValue = tsplus_module_17.nothing();
     let durationSubscriber = null;
     let isComplete = false;
 
@@ -997,11 +994,11 @@ function audit_1(fa, durationSelector) {
       durationSubscriber?.unsubscribe();
       durationSubscriber = null;
 
-      if (tsplus_module_17.isJust(lastValue)) {
+      if (tsplus_module_18.isJust(lastValue)) {
         const {
           value
         } = lastValue;
-        lastValue = tsplus_module_16.nothing();
+        lastValue = tsplus_module_17.nothing();
         subscriber.next(value);
       }
 
@@ -1013,12 +1010,12 @@ function audit_1(fa, durationSelector) {
       isComplete && subscriber.complete();
     };
 
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
-        lastValue = tsplus_module_16.just(value);
+        lastValue = tsplus_module_17.just(value);
 
         if (!durationSubscriber) {
-          from_1(durationSelector(value)).subscribe(durationSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+          from_1(durationSelector(value)).subscribe(durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
             next: endDuration,
             complete: cleanupDuration
           }));
@@ -1026,7 +1023,7 @@ function audit_1(fa, durationSelector) {
       },
       complete: () => {
         isComplete = true;
-        (tsplus_module_17.isNothing(lastValue) || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
+        (tsplus_module_18.isNothing(lastValue) || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
       }
     }));
   });
@@ -1036,7 +1033,7 @@ function audit_1(fa, durationSelector) {
  */
 
 
-function auditTime_(fa, duration, scheduler = tsplus_module_6.asyncScheduler) {
+function auditTime_(fa, duration, scheduler = tsplus_module_5.asyncScheduler) {
   return audit_1(fa, () => timer_1(duration, scheduler));
 }
 /**
@@ -1045,22 +1042,22 @@ function auditTime_(fa, duration, scheduler = tsplus_module_6.asyncScheduler) {
 
 
 function buffer_(fa, closingNotifier) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let buffer = [];
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => buffer.push(value),
       complete: () => {
         subscriber.next(buffer);
         subscriber.complete();
       }
     }));
-    closingNotifier.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    closingNotifier.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: () => {
         const b = buffer;
         buffer = [];
         subscriber.next(b);
       },
-      complete: tsplus_module_3.noop
+      complete: tsplus_module_2.noop
     }));
     return () => {
       buffer = null;
@@ -1075,10 +1072,10 @@ function buffer_(fa, closingNotifier) {
 function bufferCount_(fa, bufferSize, startBufferEvery) {
   // eslint-disable-next-line no-param-reassign
   startBufferEvery = startBufferEvery ?? bufferSize;
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let buffers = [];
     let count = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         let toEmit = null;
 
@@ -1097,7 +1094,7 @@ function bufferCount_(fa, bufferSize, startBufferEvery) {
 
         if (toEmit) {
           for (const buffer of toEmit) {
-            (0, tsplus_module_3.arrayRemove)(buffers, buffer);
+            (0, tsplus_module_2.arrayRemove)(buffers, buffer);
             subscriber.next(buffer);
           }
         }
@@ -1124,9 +1121,9 @@ function bufferTime_(fa, config) {
     bufferTimeSpan,
     bufferCreationInterval = null,
     maxBufferSize = Infinity,
-    scheduler = tsplus_module_6.asyncScheduler
+    scheduler = tsplus_module_5.asyncScheduler
   } = config;
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let bufferRecords = [];
     let restartOnEmit = true;
 
@@ -1136,14 +1133,14 @@ function bufferTime_(fa, config) {
         subs
       } = record;
       subs.unsubscribe();
-      (0, tsplus_module_3.arrayRemove)(bufferRecords, record);
+      (0, tsplus_module_2.arrayRemove)(bufferRecords, record);
       subscriber.next(buffer);
       restartOnEmit && startBuffer();
     };
 
     const startBuffer = () => {
       if (bufferRecords) {
-        const subs = new tsplus_module_7.Subscription();
+        const subs = new tsplus_module_6.Subscription();
         subscriber.add(subs);
         const buffer = [];
         const record = {
@@ -1160,7 +1157,7 @@ function bufferTime_(fa, config) {
       !this.closed && subscriber.add(this.schedule(null, bufferCreationInterval));
     }, bufferCreationInterval)) : restartOnEmit = true;
     startBuffer();
-    const bufferTimeSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+    const bufferTimeSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const recordsCopy = bufferRecords.slice();
 
@@ -1191,28 +1188,28 @@ function bufferTime_(fa, config) {
 
 
 function bufferToggle_(fa, openings, closingSelector) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     const buffers = [];
-    from_1(openings).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    from_1(openings).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: openValue => {
         const buffer = [];
         buffers.push(buffer);
-        const closingSubscription = new tsplus_module_7.Subscription();
+        const closingSubscription = new tsplus_module_6.Subscription();
 
         const emitBuffer = () => {
-          (0, tsplus_module_3.arrayRemove)(buffers, buffer);
+          (0, tsplus_module_2.arrayRemove)(buffers, buffer);
           subscriber.next(buffer);
           closingSubscription.unsubscribe();
         };
 
-        closingSubscription.add(from_1(closingSelector(openValue)).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+        closingSubscription.add(from_1(closingSelector(openValue)).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
           next: emitBuffer,
-          complete: tsplus_module_3.noop
+          complete: tsplus_module_2.noop
         })));
       },
-      complete: tsplus_module_3.noop
+      complete: tsplus_module_2.noop
     }));
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         for (const buffer of buffers) {
           buffer.push(value);
@@ -1233,8 +1230,8 @@ function bufferToggle_(fa, openings, closingSelector) {
  */
 
 
-function bufferWhen_1(fa, closingSelector) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+function bufferWhen_(fa, closingSelector) {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let buffer = null;
     let closingSubscriber = null;
 
@@ -1243,14 +1240,14 @@ function bufferWhen_1(fa, closingSelector) {
       const b = buffer;
       buffer = [];
       b && subscriber.next(b);
-      from_1(closingSelector()).subscribe(closingSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+      from_1(closingSelector()).subscribe(closingSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
         next: openBuffer,
-        complete: tsplus_module_3.noop
+        complete: tsplus_module_2.noop
       }));
     };
 
     openBuffer();
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => buffer?.push(value),
       complete: () => {
         buffer && subscriber.next(buffer);
@@ -1259,21 +1256,17 @@ function bufferWhen_1(fa, closingSelector) {
     }, () => buffer = closingSubscriber = null));
   });
 }
-
-function bufferWhen(closingSelector) {
-  return fa => bufferWhen_1(fa, closingSelector);
-}
 /**
  * @tsplus fluent fncts.observable.Observable catchAllCause
  */
 
 
 function catchAllCause_1(self, f) {
-  return tsplus_module_9.operate_(self, (source, subscriber) => {
+  return tsplus_module_8.operate_(self, (source, subscriber) => {
     let innerSub = null;
     let syncUnsub = false;
     let handledResult;
-    innerSub = source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    innerSub = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       error: cause => {
         handledResult = from_1(f(cause, catchAllCause_1(source, f)));
 
@@ -1308,7 +1301,7 @@ function concatAll_1(ffa) {
 
 
 function concat_1(fa, ...sources) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     concatAll_1(fromArrayLike([source, ...sources])).subscribe(subscriber);
   });
 }
@@ -1351,10 +1344,10 @@ function combineLatestAll(fa) {
 
 function combineLatest_1(self, ...sources) {
   if (!sources.length) {
-    return from_1(self);
+    return from_1(self).unsafeCoerce();
   }
 
-  return tsplus_module_9.operate_(from_1(self), (source, subscriber) => {
+  return tsplus_module_8.operate_(from_1(self), (source, subscriber) => {
     combineLatestInternal(subscriber, [source, ...sources]);
   });
 }
@@ -1364,30 +1357,30 @@ function combineLatest_1(self, ...sources) {
 
 
 function debounceWith_(fa, durationSelector) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    let lastValue = tsplus_module_16.nothing();
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    let lastValue = tsplus_module_17.nothing();
     let durationSubscriber = null;
 
     const emit = () => {
       durationSubscriber?.unsubscribe();
       durationSubscriber = null;
 
-      if (tsplus_module_17.isJust(lastValue)) {
+      if (tsplus_module_18.isJust(lastValue)) {
         const {
           value
         } = lastValue;
-        lastValue = tsplus_module_16.nothing();
+        lastValue = tsplus_module_17.nothing();
         subscriber.next(value);
       }
     };
 
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         durationSubscriber?.unsubscribe();
-        lastValue = tsplus_module_16.just(value);
-        durationSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+        lastValue = tsplus_module_17.just(value);
+        durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
           next: emit,
-          complete: tsplus_module_3.noop
+          complete: tsplus_module_2.noop
         });
         from_1(durationSelector(value)).subscribe(durationSubscriber);
       },
@@ -1405,8 +1398,8 @@ function debounceWith_(fa, durationSelector) {
  */
 
 
-function debounce_(fa, dueTime, scheduler = tsplus_module_6.asyncScheduler) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+function debounce_(fa, dueTime, scheduler = tsplus_module_5.asyncScheduler) {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let activeTask = null;
     let lastValue = null;
     let lastTime = null;
@@ -1434,7 +1427,7 @@ function debounce_(fa, dueTime, scheduler = tsplus_module_6.asyncScheduler) {
       emit();
     }
 
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         lastValue = value;
         lastTime = scheduler.now();
@@ -1459,13 +1452,13 @@ function debounce_(fa, dueTime, scheduler = tsplus_module_6.asyncScheduler) {
 
 
 function either(fa) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
-        subscriber.next(tsplus_module_18.right(value));
+        subscriber.next(tsplus_module_19.right(value));
       },
       error: error => {
-        tsplus_module_14.match_(tsplus_module_2.failureOrCause(error), e => subscriber.next(tsplus_module_18.left(e)), cause => subscriber.error(cause));
+        tsplus_module_14.match_(tsplus_module_1.failureOrCause(error), e => subscriber.next(tsplus_module_19.left(e)), cause => subscriber.error(cause));
       }
     }));
   });
@@ -1491,7 +1484,7 @@ function delayWith_1(fa, f) {
  */
 
 
-function delay_(fa, due, scheduler = tsplus_module_6.asyncScheduler) {
+function delay_(fa, due, scheduler = tsplus_module_5.asyncScheduler) {
   const duration = timer_1(due, scheduler);
   return delayWith_1(fa, () => duration);
 }
@@ -1501,9 +1494,9 @@ function delay_(fa, due, scheduler = tsplus_module_6.asyncScheduler) {
 
 
 function dematerialize(fa) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
-      next: notification => tsplus_module_19.observe_(notification, subscriber)
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+      next: notification => tsplus_module_20.observe_(notification, subscriber)
     }));
   });
 }
@@ -1513,7 +1506,7 @@ function dematerialize(fa) {
 
 
 function ensuring_(fa, finalizer) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     source.subscribe(subscriber);
     subscriber.add(finalizer);
   });
@@ -1524,13 +1517,13 @@ function ensuring_(fa, finalizer) {
 
 
 function exhaustAll(ffa) {
-  return tsplus_module_9.operate_(ffa, (source, subscriber) => {
+  return tsplus_module_8.operate_(ffa, (source, subscriber) => {
     let isComplete = false;
     let innerSub = null;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: inner => {
         if (!innerSub) {
-          innerSub = from_1(inner).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+          innerSub = from_1(inner).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
             complete: () => {
               innerSub = null;
               isComplete && subscriber.complete();
@@ -1551,14 +1544,14 @@ function exhaustAll(ffa) {
 
 
 function exhaustMapWithIndex_1(self, f) {
-  return tsplus_module_9.operate_(self, (source, subscriber) => {
+  return tsplus_module_8.operate_(self, (source, subscriber) => {
     let index = 0;
     let innerSub = null;
     let isComplete = false;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: outerValue => {
         if (!innerSub) {
-          innerSub = tsplus_module_9.operatorSubscriber(subscriber, {
+          innerSub = tsplus_module_8.operatorSubscriber(subscriber, {
             complete: () => {
               innerSub = null;
               isComplete && subscriber.complete();
@@ -1590,7 +1583,7 @@ function exhaustMap_(self, f) {
 function expandWithIndex_1(fa, f, concurrent = Infinity) {
   // eslint-disable-next-line no-param-reassign
   concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
-  return tsplus_module_9.operate_(fa, (source, subscriber) => mergeInternal(source, subscriber, f, concurrent, undefined, true));
+  return tsplus_module_8.operate_(fa, (source, subscriber) => mergeInternal(source, subscriber, f, concurrent, undefined, true));
 }
 /**
  * @tsplus fluent fncts.observable.Observable expand
@@ -1602,7 +1595,7 @@ function expand_(fa, f, concurrent = Infinity) {
 }
 
 function findWithIndex_1(fa, predicate) {
-  return tsplus_module_9.operate_(fa, findInternal(predicate, "value"));
+  return tsplus_module_8.operate_(fa, findInternal(predicate, "value"));
 }
 
 function find_(fa, predicate) {
@@ -1610,7 +1603,7 @@ function find_(fa, predicate) {
 }
 
 function findIndexWithIndex_1(fa, predicate) {
-  return tsplus_module_9.operate_(fa, findInternal(predicate, "index"));
+  return tsplus_module_8.operate_(fa, findInternal(predicate, "index"));
 }
 
 function findIndex_(fa, predicate) {
@@ -1621,8 +1614,8 @@ function forkJoin(...args) {
   const {
     args: sources,
     keys
-  } = (0, tsplus_module_3.arrayOrObject)(args);
-  return new tsplus_module_1.Observable(s => {
+  } = (0, tsplus_module_2.arrayOrObject)(args);
+  return new _definition2.Observable(s => {
     const length = sources.length;
 
     if (!length) {
@@ -1636,7 +1629,7 @@ function forkJoin(...args) {
 
     for (let sourceIndex = 0; sourceIndex < length; sourceIndex++) {
       let hasValue = false;
-      from_1(sources[sourceIndex]).subscribe(tsplus_module_9.operatorSubscriber(s, {
+      from_1(sources[sourceIndex]).subscribe(tsplus_module_8.operatorSubscriber(s, {
         next: value => {
           if (!hasValue) {
             hasValue = true;
@@ -1667,9 +1660,9 @@ function forkJoin(...args) {
 
 
 function ignore(fa) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
-      next: tsplus_module_3.noop
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+      next: tsplus_module_2.noop
     }));
   });
 }
@@ -1679,8 +1672,8 @@ function ignore(fa) {
 
 
 function isEmpty(fa) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: () => {
         subscriber.next(false);
         subscriber.complete();
@@ -1698,16 +1691,16 @@ function isEmpty(fa) {
 
 
 function materialize(fa) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
-        subscriber.next(tsplus_module_19.next(value));
+        subscriber.next(tsplus_module_20.next(value));
       },
       error: error => {
-        subscriber.next(tsplus_module_19.error(error));
+        subscriber.next(tsplus_module_20.error(error));
       },
       complete: () => {
-        subscriber.next(tsplus_module_19.complete());
+        subscriber.next(tsplus_module_20.complete());
       }
     }));
   });
@@ -1726,7 +1719,7 @@ function mergeAll_1(self, concurrent = Infinity) {
 
 
 function mergeScanWithIndex_1(fa, initial, f, concurrent = Infinity) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let state = initial;
     return mergeInternal(source, subscriber, (index, value) => f(index, state, value), concurrent, value => {
       state = value;
@@ -1743,7 +1736,7 @@ function mergeScan_(fa, initial, f, concurrent = Infinity) {
 }
 
 function onErrorResumeNext(fa, ...sources) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     const remaining = [source, ...sources];
 
     const subscribeNext = () => {
@@ -1758,9 +1751,9 @@ function onErrorResumeNext(fa, ...sources) {
             return;
           }
 
-          const innerSub = tsplus_module_9.operatorSubscriber(subscriber, {
-            error: tsplus_module_3.noop,
-            complete: tsplus_module_3.noop
+          const innerSub = tsplus_module_8.operatorSubscriber(subscriber, {
+            error: tsplus_module_2.noop,
+            complete: tsplus_module_2.noop
           });
           subscriber.add(nextSource.subscribe(innerSub));
           innerSub.add(subscribeNext);
@@ -1779,9 +1772,9 @@ function onErrorResumeNext(fa, ...sources) {
 
 
 function onEmpty_1(fa, f) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let hasValue = false;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         hasValue = true;
         subscriber.next(value);
@@ -1802,13 +1795,13 @@ function onEmpty_1(fa, f) {
 
 
 function repeat_(fa, count = Infinity) {
-  return count <= 0 ? empty_1() : tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return count <= 0 ? empty_1() : tsplus_module_8.operate_(fa, (source, subscriber) => {
     let repeats = 0;
     let innerSub;
 
     const loop = () => {
       let syncUnsub = false;
-      innerSub = source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      innerSub = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
         complete: () => {
           if (++repeats < count) {
             if (innerSub) {
@@ -1850,13 +1843,13 @@ function retry_(fa, configOrCount = Infinity) {
     count,
     resetOnSuccess = false
   } = config;
-  return count <= 0 ? fa : tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return count <= 0 ? fa : tsplus_module_8.operate_(fa, (source, subscriber) => {
     let retries = 0;
     let innerSub;
 
     const loop = () => {
       let syncUnsub = false;
-      innerSub = source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      innerSub = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
         next: value => {
           if (resetOnSuccess) {
             retries = 0;
@@ -1895,10 +1888,10 @@ function retry_(fa, configOrCount = Infinity) {
 
 
 function sample_1(fa, notifier) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let hasValue = false;
     let lastValue = null;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         hasValue = true;
         lastValue = value;
@@ -1914,9 +1907,9 @@ function sample_1(fa, notifier) {
       }
     };
 
-    notifier.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    notifier.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: emit,
-      complete: tsplus_module_3.noop
+      complete: tsplus_module_2.noop
     }));
   });
 }
@@ -1925,7 +1918,7 @@ function sample_1(fa, notifier) {
  */
 
 
-function sampleTime_(fa, period, scheduler = tsplus_module_6.asyncScheduler) {
+function sampleTime_(fa, period, scheduler = tsplus_module_5.asyncScheduler) {
   return sample_1(fa, interval_1(period, scheduler));
 }
 /**
@@ -1934,7 +1927,7 @@ function sampleTime_(fa, period, scheduler = tsplus_module_6.asyncScheduler) {
 
 
 function scanLeftWithIndex_1(fa, initial, f) {
-  return tsplus_module_9.operate_(fa, scanInternal(f, initial, true, true));
+  return tsplus_module_8.operate_(fa, scanInternal(f, initial, true, true));
 }
 /**
  * @tsplus fluent fncts.observable.Observable scanLeft
@@ -1944,6 +1937,36 @@ function scanLeftWithIndex_1(fa, initial, f) {
 function scanLeft(fa, initial, f) {
   return scanLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
 }
+/**
+ * @tsplus static fncts.observable.ObservableOps service
+ */
+
+
+function service(
+/** @tsplus auto */
+tag) {
+  return serviceWithObservable_1(service => of_1(service), tag);
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps serviceWith
+ */
+
+
+function serviceWith(f,
+/** @tsplus auto */
+tag) {
+  return serviceWithObservable_1(service => of_1(f(service)), tag);
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps serviceWithObservable
+ */
+
+
+function serviceWithObservable_1(f,
+/** @tsplus auto */
+tag) {
+  return environmentWithObservable_1(environment => f(tsplus_module_16.unsafeGet(environment, tag)));
+}
 /**
  * @tsplus fluent fncts.observable.Observable skip
  */
@@ -1958,10 +1981,10 @@ function skip_(fa, count) {
 
 
 function skipLast_(fa, skipCount) {
-  return skipCount <= 0 ? fa : tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return skipCount <= 0 ? fa : tsplus_module_8.operate_(fa, (source, subscriber) => {
     let ring = new Array(skipCount);
     let seen = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const valueIndex = seen++;
 
@@ -1986,17 +2009,17 @@ function skipLast_(fa, skipCount) {
 
 
 function skipUntil_(fa, notifier) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let taking = false;
-    const skipSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+    const skipSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
       next: () => {
         skipSubscriber?.unsubscribe();
         taking = true;
       },
-      complete: tsplus_module_3.noop
+      complete: tsplus_module_2.noop
     });
     from_1(notifier).subscribe(skipSubscriber);
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => taking && subscriber.next(value)
     }));
   });
@@ -2007,10 +2030,10 @@ function skipUntil_(fa, notifier) {
 
 
 function skipWhile_(fa, predicate) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let taking = false;
     let index = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => (taking || (taking = !predicate(index++, value))) && subscriber.next(value)
     }));
   });
@@ -2021,7 +2044,7 @@ function skipWhile_(fa, predicate) {
 
 
 function startWith_(fa, ...values) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     // @ts-expect-error
     concat_1(source, values).subscribe(subscriber);
   });
@@ -2032,7 +2055,7 @@ function startWith_(fa, ...values) {
 
 
 function subscribeOn_(fa, scheduler, delay = 0) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay));
   });
 }
@@ -2050,18 +2073,18 @@ function switchAll(ffa) {
 
 
 function switchMapWithIndex_1(fa, f) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let innerSubscriber = null;
     let index = 0;
     let isComplete = false;
 
     const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
 
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         innerSubscriber?.unsubscribe();
         const outerIndex = index++;
-        from_1(f(outerIndex, value)).subscribe(innerSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+        from_1(f(outerIndex, value)).subscribe(innerSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
           next: innerValue => subscriber.next(innerValue),
           complete: () => {
             innerSubscriber = null;
@@ -2089,7 +2112,7 @@ function switchMap_1(fa, f) {
 
 
 function switchScanWithIndex_1(fa, initial, f) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let state = initial;
     switchMapWithIndex_1(source, (index, value) => map_1(from_1(f(index, state, value)), b => (state = b, b))).subscribe(subscriber);
     return () => {
@@ -2111,9 +2134,9 @@ function switchScan_(fa, initial, f) {
 
 
 function take_1(fa, count) {
-  return count <= 0 ? empty_1() : tsplus_module_9.operate_(fa, (source, sub) => {
+  return count <= 0 ? empty_1() : tsplus_module_8.operate_(fa, (source, sub) => {
     let seen = 0;
-    source.subscribe(new tsplus_module_9.OperatorSubscriber(sub, {
+    source.subscribe(new tsplus_module_8.OperatorSubscriber(sub, {
       next: value => {
         if (++seen <= count) {
           sub.next(value);
@@ -2132,9 +2155,9 @@ function take_1(fa, count) {
 
 
 function takeLast_(fa, count) {
-  return count <= 0 ? empty_1() : tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return count <= 0 ? empty_1() : tsplus_module_8.operate_(fa, (source, subscriber) => {
     let buffer = [];
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         buffer.push(value);
         count < buffer.length && buffer.shift();
@@ -2157,19 +2180,19 @@ function takeLast_(fa, count) {
 
 
 function takeUntil_(fa, notifier) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    from_1(notifier).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    from_1(notifier).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: () => subscriber.complete(),
-      complete: tsplus_module_3.noop
+      complete: tsplus_module_2.noop
     }));
     !subscriber.closed && source.subscribe(subscriber);
   });
 }
 
 function takeWhileWithIndex_1(fa, predicate, inclusive) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let index = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const result = predicate(index++, value);
         (result || inclusive) && subscriber.next(value);
@@ -2188,8 +2211,8 @@ function takeWhile_(fa, predicate, inclusive) {
 
 
 function tap_(fa, observer) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         observer.next?.(value);
         subscriber.next(value);
@@ -2220,8 +2243,8 @@ function throttle_1(fa, durationSelector, {
   leading,
   trailing
 } = defaultThrottleConfig) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    let sendValue = tsplus_module_16.nothing();
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    let sendValue = tsplus_module_17.nothing();
     let throttled = null;
     let isComplete = false;
 
@@ -2240,30 +2263,30 @@ function throttle_1(fa, durationSelector, {
       isComplete && subscriber.complete();
     };
 
-    const startThrottling = value => throttled = from_1(durationSelector(value)).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    const startThrottling = value => throttled = from_1(durationSelector(value)).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: endThrottling,
       complete: cleanupThrottling
     }));
 
     const send = () => {
-      if (tsplus_module_17.isJust(sendValue)) {
+      if (tsplus_module_18.isJust(sendValue)) {
         const {
           value
         } = sendValue;
-        sendValue = tsplus_module_16.nothing();
+        sendValue = tsplus_module_17.nothing();
         subscriber.next(value);
         !isComplete && startThrottling(value);
       }
     };
 
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
-        sendValue = tsplus_module_16.just(value);
+        sendValue = tsplus_module_17.just(value);
         !(throttled && !throttled.closed) && (leading ? send() : startThrottling(value));
       },
       complete: () => {
         isComplete = true;
-        !(trailing && tsplus_module_17.isJust(sendValue) && throttled && !throttled.closed) && subscriber.complete();
+        !(trailing && tsplus_module_18.isJust(sendValue) && throttled && !throttled.closed) && subscriber.complete();
       }
     }));
   });
@@ -2273,7 +2296,7 @@ function throttle_1(fa, durationSelector, {
  */
 
 
-function throttleTime_(fa, duration, scheduler = tsplus_module_6.asyncScheduler, config = defaultThrottleConfig) {
+function throttleTime_(fa, duration, scheduler = tsplus_module_5.asyncScheduler, config = defaultThrottleConfig) {
   const duration$ = timer_1(duration, scheduler);
   return throttle_1(fa, () => duration$, config);
 }
@@ -2294,18 +2317,18 @@ function timeout_(fa, config) {
     first,
     each,
     with: _with = timeoutError,
-    scheduler = tsplus_module_6.asyncScheduler,
+    scheduler = tsplus_module_5.asyncScheduler,
     meta = null
   } = config;
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     // eslint-disable-next-line prefer-const
     let originalSourceSubscription;
     let timerSubscription;
-    let lastValue = tsplus_module_16.nothing();
+    let lastValue = tsplus_module_17.nothing();
     let seen = 0;
 
     const startTimer = delay => {
-      timerSubscription = (0, tsplus_module_8.caughtSchedule)(subscriber, scheduler, () => {
+      timerSubscription = (0, tsplus_module_7.caughtSchedule)(subscriber, scheduler, () => {
         originalSourceSubscription.unsubscribe();
         from_1(_with({
           meta,
@@ -2315,11 +2338,11 @@ function timeout_(fa, config) {
       }, delay);
     };
 
-    originalSourceSubscription = source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    originalSourceSubscription = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         timerSubscription?.unsubscribe();
         seen++;
-        lastValue = tsplus_module_16.just(value);
+        lastValue = tsplus_module_17.just(value);
         subscriber.next(value);
         each > 0 && startTimer(each);
       }
@@ -2328,7 +2351,7 @@ function timeout_(fa, config) {
         timerSubscription?.unsubscribe();
       }
 
-      lastValue = tsplus_module_16.nothing();
+      lastValue = tsplus_module_17.nothing();
     }));
     startTimer(first != null ? typeof first === "number" ? first : +first - scheduler.now() : each);
   });
@@ -2347,7 +2370,7 @@ function toArrayAccumulator(arr, value) {
 
 
 function toArray_1(fa) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     foldLeft_1(source, [], toArrayAccumulator).subscribe(subscriber);
   });
 }
@@ -2357,31 +2380,31 @@ function toArray_1(fa) {
 
 
 function unique_(fa, toKey, flushes) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
-    let distinctKeys = tsplus_module_20.makeDefault();
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+    let distinctKeys = tsplus_module_21.makeDefault();
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const key = toKey ? toKey(value) : value;
 
-        if (!tsplus_module_20.has_(distinctKeys, key)) {
-          tsplus_module_20.add_(distinctKeys, key);
+        if (!tsplus_module_21.has_(distinctKeys, key)) {
+          tsplus_module_21.add_(distinctKeys, key);
           subscriber.next(value);
         }
       }
     }));
-    flushes?.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
-      next: () => distinctKeys = tsplus_module_20.makeDefault(),
-      complete: tsplus_module_3.noop
+    flushes?.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+      next: () => distinctKeys = tsplus_module_21.makeDefault(),
+      complete: tsplus_module_2.noop
     }));
   });
 }
 
 function uniqueUntilChanged_1(fa, E, keySelector = tsplus_module_13.identity) {
   const compare = "equals" in E ? E.equals : E;
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let previousKey;
     let first = true;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const currentKey = keySelector(value);
 
@@ -2399,12 +2422,6 @@ function uniqueUntilKeyChanged_(fa, key, equals) {
   const compare = "equals" in equals ? equals.equals : equals;
   return uniqueUntilChanged_1(fa, (x, y) => compare(x[key], y[key]));
 }
-/*
- * -------------------------------------------------------------------------------------------------
- * internal
- * -------------------------------------------------------------------------------------------------
- */
-
 
 function combineLatestInternal(subscriber, observables, scheduler, valueTransform = tsplus_module_13.identity) {
   return maybeSchedule(subscriber, scheduler, () => {
@@ -2419,7 +2436,7 @@ function combineLatestInternal(subscriber, observables, scheduler, valueTransfor
       maybeSchedule(subscriber, scheduler, () => {
         const source = scheduler ? scheduled_1(observables[i], scheduler) : from_1(observables[i]);
         let hasFirstValue = false;
-        source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+        source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
           next: value => {
             values[i] = value;
 
@@ -2447,17 +2464,17 @@ function findInternal(predicate, emit) {
   const findIndex = emit === "index";
   return (source, subscriber) => {
     let index = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const i = index++;
 
         if (predicate(index++, value)) {
-          subscriber.next(findIndex ? i : tsplus_module_16.just(value));
+          subscriber.next(findIndex ? i : tsplus_module_17.just(value));
           subscriber.complete();
         }
       },
       complete: () => {
-        subscriber.next(findIndex ? -1 : tsplus_module_16.nothing());
+        subscriber.next(findIndex ? -1 : tsplus_module_17.nothing());
         subscriber.complete();
       }
     }));
@@ -2494,7 +2511,7 @@ function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand,
     expand && subscriber.next(a);
     active++;
     let innerComplete = false;
-    from_1(f(index++, a)).subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+    from_1(f(index++, a)).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
       next: b => {
         onBeforeNext?.(b);
 
@@ -2519,13 +2536,13 @@ function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand,
 
           checkComplete();
         } catch (err) {
-          subscriber.error(tsplus_module_2.halt(err));
+          subscriber.error(tsplus_module_1.halt(err));
         }
       }
     }));
   };
 
-  source.subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+  source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
     next: outerNext,
     complete: () => {
       isComplete = true;
@@ -2542,7 +2559,7 @@ function scanInternal(f, initial, hasInitial, emitOnNext, emitBeforeComplete) {
     let hasState = hasInitial;
     let state = initial;
     let index = 0;
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const i = index++;
         state = hasState ? f(i, state, value) : (hasState = true, value);