@fncts/observable 0.0.1 → 0.0.4

package/_mjs/Observable/api.mjs

@@ -1,30 +1,33 @@
 const fileName_1 = "(@fncts/observable) src/Observable/api.ts";
-import * as tsplus_module_1 from "@fncts/observable/Observable";
-import * as tsplus_module_2 from "@fncts/base/data/Cause/api";
-import * as tsplus_module_3 from "@fncts/observable/internal/util";
-import * as tsplus_module_4 from "@fncts/base/util/predicates";
-import * as tsplus_module_5 from "@fncts/io/IO";
-import * as tsplus_module_6 from "@fncts/observable/AsyncScheduler";
-import * as tsplus_module_7 from "@fncts/observable/Subscription";
-import * as tsplus_module_8 from "@fncts/observable/Scheduler";
-import * as tsplus_module_9 from "@fncts/observable/Operator";
+import * as tsplus_module_1 from "@fncts/base/data/Cause/api";
+import * as tsplus_module_2 from "@fncts/observable/internal/util";
+import * as tsplus_module_3 from "@fncts/base/util/predicates";
+import * as tsplus_module_4 from "@fncts/io/IO";
+import * as tsplus_module_5 from "@fncts/observable/AsyncScheduler";
+import * as tsplus_module_6 from "@fncts/observable/Subscription";
+import * as tsplus_module_7 from "@fncts/observable/Scheduler";
+import * as tsplus_module_8 from "@fncts/observable/Operator";
+import * as tsplus_module_9 from "@fncts/io/IO/api/environment";
 import * as tsplus_module_10 from "@fncts/io/IO/runtime";
 import * as tsplus_module_11 from "@fncts/base/data/Exit/api";
 import * as tsplus_module_12 from "@fncts/io/Fiber/api/interrupt";
 import * as tsplus_module_13 from "@fncts/base/data/function/api";
 import * as tsplus_module_14 from "@fncts/base/data/Either/destructors";
 import * as tsplus_module_15 from "@fncts/base/data/Maybe/destructors";
-import * as tsplus_module_16 from "@fncts/base/data/Maybe/constructors";
-import * as tsplus_module_17 from "@fncts/base/data/Maybe/definition";
-import * as tsplus_module_18 from "@fncts/base/data/Either/constructors";
-import * as tsplus_module_19 from "@fncts/observable/Notification";
-import * as tsplus_module_20 from "@fncts/base/collection/immutable/HashSet/api";
+import * as tsplus_module_16 from "@fncts/base/data/Environment/api";
+import * as tsplus_module_17 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_18 from "@fncts/base/data/Maybe/definition";
+import * as tsplus_module_19 from "@fncts/base/data/Either/constructors";
+import * as tsplus_module_20 from "@fncts/observable/Notification";
+import * as tsplus_module_21 from "@fncts/base/collection/immutable/HashSet/api";
 export const defer = defer_1;
 export const empty = empty_1;
+export const environmentWithObservable = environmentWithObservable_1;
 export const fail = fail_1;
 export const from = from_1;
 export const fromSubscribable = fromSubscribable_1;
 export const interval = interval_1;
+export const of = of_1;
 export const single = single_1;
 export const scheduled = scheduled_1;
 export const timer = timer_1;
@@ -39,10 +42,10 @@ export const partitionWithIndex = partitionWithIndex_1;
 export const partitionMapWithIndex_ = partitionMapWithIndex_1;
 export const mergeMapWithIndex = mergeMapWithIndex_1;
 export const mergeMap_ = mergeMap_1;
+export const contramapEnvironment = contramapEnvironment_1;
 export const foldLeftWithIndex = foldLeftWithIndex_1;
 export const foldLeft = foldLeft_1;
 export const audit_ = audit_1;
-export const bufferWhen_ = bufferWhen_1;
 export const catchAllCause = catchAllCause_1;
 export const concatAll = concatAll_1;
 export const concat_ = concat_1;
@@ -59,6 +62,7 @@ export const mergeScanWithIndex = mergeScanWithIndex_1;
 export const onEmpty_ = onEmpty_1;
 export const sample_ = sample_1;
 export const scanLeftWithIndex = scanLeftWithIndex_1;
+export const serviceWithObservable = serviceWithObservable_1;
 export const switchMapWithIndex = switchMapWithIndex_1;
 export const switchMap_ = switchMap_1;
 export const switchScanWithIndex = switchScanWithIndex_1;
@@ -69,27 +73,21 @@ export const toArray = toArray_1;
 export const uniqueUntilChanged_ = uniqueUntilChanged_1;
 import { popNumber } from "@fncts/observable/internal/args";
 import { arrayOrObject, arrayRemove, readableStreamToAsyncGenerator } from "@fncts/observable/internal/util";
-import { EMPTY } from "@fncts/observable/Observable/definition";
+import { EMPTY, EnvironmentWith, Observable } from "@fncts/observable/Observable/definition";
 import { caughtSchedule } from "@fncts/observable/Scheduler";
-/*
- * -------------------------------------------------------------------------------------------------
- * constructors
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus static fncts.observable.ObservableOps halt
  */
 
 export function halt(defect) {
-  return new tsplus_module_1.Observable(s => s.error(tsplus_module_2.halt(defect)));
+  return new Observable(s => s.error(tsplus_module_1.halt(defect)));
 }
 /**
  * @tsplus static fncts.observable.ObservableOps defer
  */
 
 function defer_1(observable) {
-  return new tsplus_module_1.Observable(s => {
+  return new Observable(s => {
     from_1(observable()).subscribe(s);
   });
 }
@@ -101,20 +99,28 @@ function defer_1(observable) {
 function empty_1() {
   return EMPTY;
 }
+/**
+ * @tsplus static fncts.observable.ObservableOps environmentWithObservable
+ */
+
+
+function environmentWithObservable_1(f) {
+  return new EnvironmentWith(f);
+}
 /**
  * @tsplus static fncts.observable.ObservableOps failCause
  */
 
 
 export function failCause(cause) {
-  return new tsplus_module_1.Observable(s => s.error(cause));
+  return new Observable(s => s.error(cause));
 }
 /**
  * @tsplus static fncts.observable.ObservableOps fail
  */
 
 function fail_1(e) {
-  return new tsplus_module_1.Observable(s => s.error(tsplus_module_2.fail(e)));
+  return new Observable(s => s.error(tsplus_module_1.fail(e)));
 }
 /**
  * @tsplus static fncts.observable.ObservableOps from
@@ -122,31 +128,31 @@ function fail_1(e) {
 
 
 function from_1(input) {
-  if (input instanceof tsplus_module_1.Observable) {
+  if (input instanceof 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);
   }
 
@@ -158,7 +164,7 @@ function from_1(input) {
 }
 
 export function fromArrayLike(input) {
-  return new tsplus_module_1.Observable(s => {
+  return new Observable(s => {
     for (let i = 0; i < input.length && !s.closed; i++) {
       s.next(input[i]);
     }
@@ -167,12 +173,12 @@ export function fromArrayLike(input) {
   });
 }
 export function fromAsyncIterable(asyncIterable) {
-  return new tsplus_module_1.Observable(s => {
-    process(asyncIterable, s).catch(err => s.error(tsplus_module_2.halt(err)));
+  return new Observable(s => {
+    process(asyncIterable, s).catch(err => s.error(tsplus_module_1.halt(err)));
   });
 }
 export function fromIterable(iterable) {
-  return new tsplus_module_1.Observable(s => {
+  return new Observable(s => {
     for (const value of iterable) {
       s.next(value);
 
@@ -185,13 +191,13 @@ export function fromIterable(iterable) {
   });
 }
 export function fromPromise(promise) {
-  return new tsplus_module_1.Observable(s => {
+  return new 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);
   });
 }
 export function fromReadableStreamLike(readableStream) {
@@ -202,13 +208,13 @@ export function fromReadableStreamLike(readableStream) {
  */
 
 function fromSubscribable_1(subscribable) {
-  return new tsplus_module_1.Observable(subscriber => subscribable.subscribe(subscriber));
+  return new Observable(subscriber => subscribable.subscribe(subscriber));
 }
 
 export function fromInterop(subscribable) {
-  return new tsplus_module_1.Observable(subscriber => subscribable.subscribe({
+  return new 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()
   }));
 }
@@ -251,7 +257,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;
@@ -268,15 +274,16 @@ export function merge(...sources) {
  * @tsplus static fncts.observable.ObservableOps of
  */
 
-export function of(...items) {
+function of_1(...items) {
   return fromArrayLike(items);
 }
 /**
  * @tsplus static fncts.observable.ObservableOps single
  */
 
+
 function single_1(a) {
-  return new tsplus_module_1.Observable(s => {
+  return new Observable(s => {
     s.next(a);
     s.complete();
   });
@@ -288,23 +295,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);
   }
 
@@ -312,7 +319,7 @@ function scheduled_1(input, scheduler) {
 }
 
 export function scheduleArray(input, scheduler) {
-  return new tsplus_module_1.Observable(s => {
+  return new Observable(s => {
     let i = 0;
     return scheduler.schedule(function () {
       if (i === input.length) {
@@ -328,8 +335,8 @@ export function scheduleArray(input, scheduler) {
   });
 }
 export function scheduleAsyncIterable(input, scheduler) {
-  return new tsplus_module_1.Observable(subscriber => {
-    const sub = new tsplus_module_7.Subscription();
+  return new Observable(subscriber => {
+    const sub = new tsplus_module_6.Subscription();
     sub.add(scheduler.schedule(() => {
       const iterator = input[Symbol.asyncIterator]();
       sub.add(scheduler.schedule(function () {
@@ -347,7 +354,7 @@ export function scheduleAsyncIterable(input, scheduler) {
   });
 }
 export function scheduleIterable(input, scheduler) {
-  return new tsplus_module_1.Observable(s => {
+  return new Observable(s => {
     let iterator;
     s.add(scheduler.schedule(() => {
       iterator = input[Symbol.iterator]();
@@ -365,12 +372,12 @@ export function scheduleIterable(input, scheduler) {
         }
       });
     }));
-    return () => tsplus_module_4.isFunction(iterator?.return) && iterator.return();
+    return () => tsplus_module_3.isFunction(iterator?.return) && iterator.return();
   });
 }
 export function scheduleObservable(input, scheduler) {
-  return new tsplus_module_1.Observable(subscriber => {
-    const sub = new tsplus_module_7.Subscription();
+  return new Observable(subscriber => {
+    const sub = new tsplus_module_6.Subscription();
     sub.add(scheduler.schedule(() => {
       sub.add(input.subscribe({
         next: value => {
@@ -387,7 +394,7 @@ export function scheduleObservable(input, scheduler) {
   });
 }
 export function schedulePromise(input, scheduler) {
-  return new tsplus_module_1.Observable(subscriber => {
+  return new Observable(subscriber => {
     return scheduler.schedule(() => {
       input.then(value => {
         subscriber.add(scheduler.schedule(() => {
@@ -395,7 +402,7 @@ export 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))));
       });
     });
   });
@@ -404,11 +411,11 @@ export function scheduleReadableStreamLike(input, scheduler) {
   return scheduleAsyncIterable(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 {
@@ -416,8 +423,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 Observable(s => {
+    let due = tsplus_module_2.isValidDate(time) ? +time - scheduler.now() : time;
 
     if (due < 0) {
       due = 0;
@@ -443,7 +450,7 @@ function timer_1(time = 0, intervalOrScheduler, scheduler = tsplus_module_6.asyn
 
 
 export function makeZip(...sources) {
-  return sources.length ? new tsplus_module_1.Observable(subscriber => {
+  return sources.length ? new Observable(subscriber => {
     let buffers = sources.map(() => []);
     let completed = sources.map(() => false);
     subscriber.add(() => {
@@ -451,7 +458,7 @@ export 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);
 
@@ -480,11 +487,11 @@ export function makeZip(...sources) {
  * @tsplus static fncts.observable.ObservableOps fromIO
  */
 
-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 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));
@@ -494,28 +501,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
  */
 
 
 export const unit = /*#__PURE__*/single_1(undefined);
-/*
- * -------------------------------------------------------------------------------------------------
- * Apply
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus fluent fncts.observable.Observable zipWith
  */
@@ -538,20 +533,14 @@ export function zip(fa, fb) {
 export 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));
       }
@@ -574,22 +563,16 @@ function map_1(fa, f) {
 function as_1(fa, b) {
   return map_1(fa, b);
 }
-/*
- * -------------------------------------------------------------------------------------------------
- * Bifunctor
- * -------------------------------------------------------------------------------------------------
- */
-
 /**
  * @tsplus fluent fncts.observable.Observable mapError
  */
 
 
 export 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));
       }
     }));
   });
@@ -599,13 +582,13 @@ export function mapError_(fa, f) {
  */
 
 export 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);
@@ -616,9 +599,9 @@ export 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)
     }));
   });
@@ -632,10 +615,10 @@ export 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))
     }));
   });
 }
@@ -660,18 +643,18 @@ export 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));
       }
     }));
   })];
@@ -684,18 +667,28 @@ function partitionMapWithIndex_1(fa, f) {
 export function partitionMap_(fa, f) {
   return partitionMapWithIndex_1(fa, (_, a) => f(a));
 }
-/*
- * -------------------------------------------------------------------------------------------------
- * Monad
- * -------------------------------------------------------------------------------------------------
+/**
+ * @tsplus fluent fncts.observable.Observable provideEnvironment
+ */
+
+export function provideEnvironment(self, environment) {
+  return self.provide(environment);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable provideService
  */
 
+export 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
@@ -720,25 +713,27 @@ export function concatMapWithIndex(ma, f) {
 export 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
  */
 
+
 export 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
@@ -748,27 +743,21 @@ 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
  */
 
 
 export 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
  */
 
 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;
 
@@ -776,11 +765,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);
       }
 
@@ -792,12 +781,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
           }));
@@ -805,7 +794,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();
       }
     }));
   });
@@ -815,7 +804,7 @@ function audit_1(fa, durationSelector) {
  */
 
 
-export function auditTime_(fa, duration, scheduler = tsplus_module_6.asyncScheduler) {
+export function auditTime_(fa, duration, scheduler = tsplus_module_5.asyncScheduler) {
   return audit_1(fa, () => timer_1(duration, scheduler));
 }
 /**
@@ -823,22 +812,22 @@ export function auditTime_(fa, duration, scheduler = tsplus_module_6.asyncSchedu
  */
 
 export 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;
@@ -852,10 +841,10 @@ export function buffer_(fa, closingNotifier) {
 export 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;
 
@@ -900,9 +889,9 @@ export 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;
 
@@ -919,7 +908,7 @@ export function bufferTime_(fa, config) {
 
     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 = {
@@ -936,7 +925,7 @@ export 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();
 
@@ -966,13 +955,13 @@ export function bufferTime_(fa, config) {
  */
 
 export 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 = () => {
           arrayRemove(buffers, buffer);
@@ -980,14 +969,14 @@ export function bufferToggle_(fa, openings, closingSelector) {
           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);
@@ -1007,8 +996,8 @@ export function bufferToggle_(fa, openings, closingSelector) {
  * @tsplus fluent fncts.observable.Observable bufferWhen
  */
 
-function bufferWhen_1(fa, closingSelector) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+export function bufferWhen_(fa, closingSelector) {
+  return tsplus_module_8.operate_(fa, (source, subscriber) => {
     let buffer = null;
     let closingSubscriber = null;
 
@@ -1017,14 +1006,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);
@@ -1033,20 +1022,16 @@ function bufferWhen_1(fa, closingSelector) {
     }, () => buffer = closingSubscriber = null));
   });
 }
-
-export 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)));
 
@@ -1081,7 +1066,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);
   });
 }
@@ -1121,10 +1106,10 @@ export 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]);
   });
 }
@@ -1134,30 +1119,30 @@ function combineLatest_1(self, ...sources) {
 
 
 export 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);
       },
@@ -1174,8 +1159,8 @@ export function debounceWith_(fa, durationSelector) {
  * @tsplus fluent fncts.observable.Observable debounce
  */
 
-export function debounce_(fa, dueTime, scheduler = tsplus_module_6.asyncScheduler) {
-  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+export 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;
@@ -1203,7 +1188,7 @@ export function debounce_(fa, dueTime, scheduler = tsplus_module_6.asyncSchedule
       emit();
     }
 
-    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         lastValue = value;
         lastTime = scheduler.now();
@@ -1227,13 +1212,13 @@ export function debounce_(fa, dueTime, scheduler = tsplus_module_6.asyncSchedule
  */
 
 export 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));
       }
     }));
   });
@@ -1258,7 +1243,7 @@ function delayWith_1(fa, f) {
  */
 
 
-export function delay_(fa, due, scheduler = tsplus_module_6.asyncScheduler) {
+export function delay_(fa, due, scheduler = tsplus_module_5.asyncScheduler) {
   const duration = timer_1(due, scheduler);
   return delayWith_1(fa, () => duration);
 }
@@ -1267,9 +1252,9 @@ export function delay_(fa, due, scheduler = tsplus_module_6.asyncScheduler) {
  */
 
 export 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)
     }));
   });
 }
@@ -1278,7 +1263,7 @@ export function dematerialize(fa) {
  */
 
 export 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);
   });
@@ -1288,13 +1273,13 @@ export function ensuring_(fa, finalizer) {
  */
 
 export 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();
@@ -1314,14 +1299,14 @@ export 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();
@@ -1352,7 +1337,7 @@ export 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
@@ -1364,7 +1349,7 @@ export 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"));
 }
 
 export function find_(fa, predicate) {
@@ -1372,7 +1357,7 @@ export 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"));
 }
 
 export function findIndex_(fa, predicate) {
@@ -1383,7 +1368,7 @@ export function forkJoin(...args) {
     args: sources,
     keys
   } = arrayOrObject(args);
-  return new tsplus_module_1.Observable(s => {
+  return new Observable(s => {
     const length = sources.length;
 
     if (!length) {
@@ -1397,7 +1382,7 @@ export 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;
@@ -1427,9 +1412,9 @@ export function forkJoin(...args) {
  */
 
 export 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
     }));
   });
 }
@@ -1438,8 +1423,8 @@ export function ignore(fa) {
  */
 
 export 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();
@@ -1456,16 +1441,16 @@ export function isEmpty(fa) {
  */
 
 export 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());
       }
     }));
   });
@@ -1483,7 +1468,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;
@@ -1499,7 +1484,7 @@ export function mergeScan_(fa, initial, f, concurrent = Infinity) {
   return mergeScanWithIndex_1(fa, initial, (_, b, a) => f(b, a), concurrent);
 }
 export 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 = () => {
@@ -1514,9 +1499,9 @@ export 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);
@@ -1534,9 +1519,9 @@ export 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);
@@ -1557,13 +1542,13 @@ function onEmpty_1(fa, f) {
 
 
 export 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) {
@@ -1604,13 +1589,13 @@ export 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;
@@ -1648,10 +1633,10 @@ export 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;
@@ -1667,9 +1652,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
     }));
   });
 }
@@ -1678,7 +1663,7 @@ function sample_1(fa, notifier) {
  */
 
 
-export function sampleTime_(fa, period, scheduler = tsplus_module_6.asyncScheduler) {
+export function sampleTime_(fa, period, scheduler = tsplus_module_5.asyncScheduler) {
   return sample_1(fa, interval_1(period, scheduler));
 }
 /**
@@ -1686,7 +1671,7 @@ export function sampleTime_(fa, period, scheduler = tsplus_module_6.asyncSchedul
  */
 
 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
@@ -1696,10 +1681,38 @@ function scanLeftWithIndex_1(fa, initial, f) {
 export function scanLeft(fa, initial, f) {
   return scanLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
 }
+/**
+ * @tsplus static fncts.observable.ObservableOps service
+ */
+
+export function service(
+/** @tsplus auto */
+tag) {
+  return serviceWithObservable_1(service => of_1(service), tag);
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps serviceWith
+ */
+
+export 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
  */
 
+
 export function skip_(fa, count) {
   return filterWithIndex_1(fa, (index, _) => count <= index);
 }
@@ -1708,10 +1721,10 @@ export function skip_(fa, count) {
  */
 
 export 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++;
 
@@ -1735,17 +1748,17 @@ export function skipLast_(fa, skipCount) {
  */
 
 export 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)
     }));
   });
@@ -1755,10 +1768,10 @@ export function skipUntil_(fa, notifier) {
  */
 
 export 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)
     }));
   });
@@ -1768,7 +1781,7 @@ export function skipWhile_(fa, predicate) {
  */
 
 export 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);
   });
@@ -1778,7 +1791,7 @@ export function startWith_(fa, ...values) {
  */
 
 export 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));
   });
 }
@@ -1794,18 +1807,18 @@ export 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;
@@ -1833,7 +1846,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 () => {
@@ -1854,9 +1867,9 @@ export 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);
@@ -1875,9 +1888,9 @@ function take_1(fa, count) {
 
 
 export 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();
@@ -1899,19 +1912,19 @@ export function takeLast_(fa, count) {
  */
 
 export 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);
@@ -1929,8 +1942,8 @@ export function takeWhile_(fa, predicate, inclusive) {
  */
 
 export 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);
@@ -1958,8 +1971,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;
 
@@ -1978,30 +1991,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();
       }
     }));
   });
@@ -2011,7 +2024,7 @@ function throttle_1(fa, durationSelector, {
  */
 
 
-export function throttleTime_(fa, duration, scheduler = tsplus_module_6.asyncScheduler, config = defaultThrottleConfig) {
+export function throttleTime_(fa, duration, scheduler = tsplus_module_5.asyncScheduler, config = defaultThrottleConfig) {
   const duration$ = timer_1(duration, scheduler);
   return throttle_1(fa, () => duration$, config);
 }
@@ -2028,14 +2041,14 @@ export 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 => {
@@ -2049,11 +2062,11 @@ export 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);
       }
@@ -2062,7 +2075,7 @@ export 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);
   });
@@ -2081,7 +2094,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);
   });
 }
@@ -2091,31 +2104,31 @@ function toArray_1(fa) {
 
 
 export 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);
 
@@ -2133,11 +2146,6 @@ export 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, () => {
@@ -2152,7 +2160,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;
 
@@ -2180,17 +2188,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();
       }
     }));
@@ -2227,7 +2235,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);
 
@@ -2252,13 +2260,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;
@@ -2275,7 +2283,7 @@ export function scanInternal(f, initial, hasInitial, emitOnNext, emitBeforeCompl
     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);