@fncts/observable 0.0.8 → 0.0.10

package/_mjs/Observable/api.mjs

@@ -35,42 +35,42 @@ export const fromIO = fromIO_1;
 export const zipWith = zipWith_1;
 export const mapWithIndex = mapWithIndex_1;
 export const map_ = map_1;
-export const as_ = as_1;
-export const filterWithIndex_ = filterWithIndex_1;
+export const as = as_1;
+export const filterWithIndex = filterWithIndex_1;
 export const filterMapWithIndex = filterMapWithIndex_1;
 export const partitionWithIndex = partitionWithIndex_1;
-export const partitionMapWithIndex_ = partitionMapWithIndex_1;
+export const partitionMapWithIndex = partitionMapWithIndex_1;
 export const mergeMapWithIndex = mergeMapWithIndex_1;
-export const mergeMap_ = mergeMap_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 audit = audit_1;
 export const catchAllCause = catchAllCause_1;
 export const concatAll = concatAll_1;
-export const concat_ = concat_1;
+export const concat = concat_1;
 export const countWithIndex = countWithIndex_1;
-export const combineLatest_ = combineLatest_1;
+export const zipLatest = zipLatest_1;
 export const delayWithIndex = delayWithIndex_1;
-export const delayWith_ = delayWith_1;
+export const delayWith = delayWith_1;
 export const exhaustMapWithIndex = exhaustMapWithIndex_1;
 export const expandWithIndex = expandWithIndex_1;
 export const findWithIndex = findWithIndex_1;
 export const findIndexWithIndex = findIndexWithIndex_1;
-export const mergeAll_ = mergeAll_1;
+export const mergeAll = mergeAll_1;
 export const mergeScanWithIndex = mergeScanWithIndex_1;
-export const onEmpty_ = onEmpty_1;
-export const sample_ = sample_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 switchMap = switchMap_1;
 export const switchScanWithIndex = switchScanWithIndex_1;
-export const take_ = take_1;
+export const take = take_1;
 export const takeWhileWithIndex = takeWhileWithIndex_1;
-export const throttle_ = throttle_1;
+export const throttle = throttle_1;
 export const toArray = toArray_1;
-export const uniqueUntilChanged_ = uniqueUntilChanged_1;
+export const uniqueUntilChanged = uniqueUntilChanged_1;
 import { popNumber } from "@fncts/observable/internal/args";
 import { arrayOrObject, arrayRemove, readableStreamToAsyncGenerator } from "@fncts/observable/internal/util";
 import { EMPTY, EnvironmentWith, Observable } from "@fncts/observable/Observable/definition";
@@ -87,8 +87,8 @@ export function halt(defect) {
  */
 
 function defer_1(observable) {
-  return new Observable(s => {
-    from_1(observable()).subscribe(s);
+  return new Observable((s, environment) => {
+    from_1(observable()).provideEnvironment(environment).subscribe(s);
   });
 }
 /**
@@ -268,7 +268,7 @@ function interval_1(period = 0, scheduler = tsplus_module_5.asyncScheduler) {
 
 export function merge(...sources) {
   const concurrency = popNumber(sources, Infinity);
-  return !sources.length ? empty_1() : sources.length === 1 ? from_1(sources[0]) : mergeAll_1(fromArrayLike(sources), concurrency);
+  return !sources.length ? empty_1() : sources.length === 1 ? from_1(sources[0]) : mergeAll_1(concurrency)(fromArrayLike(sources));
 }
 /**
  * @tsplus static fncts.observable.ObservableOps of
@@ -289,33 +289,35 @@ function single_1(a) {
   });
 }
 /**
- * @tsplus fluent fncts.observable.Observable scheduled
+ * @tsplus pipeable fncts.observable.Observable scheduled
  * @tsplus static fncts.observable.ObservableOps scheduled
  */
 
 
-function scheduled_1(input, scheduler) {
-  if (tsplus_module_2.isArrayLike(input)) {
-    return scheduleArray(input, scheduler);
-  }
+function scheduled_1(scheduler) {
+  return input => {
+    if (tsplus_module_2.isArrayLike(input)) {
+      return scheduleArray(input, scheduler);
+    }
 
-  if (tsplus_module_2.isPromiseLike(input)) {
-    return schedulePromise(input, scheduler);
-  }
+    if (tsplus_module_2.isPromiseLike(input)) {
+      return schedulePromise(input, scheduler);
+    }
 
-  if (tsplus_module_3.isIterable(input)) {
-    return scheduleIterable(input, scheduler);
-  }
+    if (tsplus_module_3.isIterable(input)) {
+      return scheduleIterable(input, scheduler);
+    }
 
-  if (tsplus_module_2.isAsyncIterable(input)) {
-    return scheduleAsyncIterable(input, scheduler);
-  }
+    if (tsplus_module_2.isAsyncIterable(input)) {
+      return scheduleAsyncIterable(input, scheduler);
+    }
 
-  if (tsplus_module_2.isReadableStream(input)) {
-    return scheduleReadableStreamLike(input, scheduler);
-  }
+    if (tsplus_module_2.isReadableStream(input)) {
+      return scheduleReadableStreamLike(input, scheduler);
+    }
 
-  return scheduleObservable(from_1(input), scheduler);
+    return scheduleObservable(from_1(input), scheduler);
+  };
 }
 
 export function scheduleArray(input, scheduler) {
@@ -376,10 +378,10 @@ export function scheduleIterable(input, scheduler) {
   });
 }
 export function scheduleObservable(input, scheduler) {
-  return new Observable(subscriber => {
+  return new Observable((subscriber, environment) => {
     const sub = new tsplus_module_6.Subscription();
     sub.add(scheduler.schedule(() => {
-      sub.add(input.subscribe({
+      sub.add(input.provideEnvironment(environment).subscribe({
         next: value => {
           sub.add(scheduler.schedule(() => subscriber.next(value)));
         },
@@ -450,7 +452,7 @@ function timer_1(time = 0, intervalOrScheduler, scheduler = tsplus_module_5.asyn
 
 
 export function makeZip(...sources) {
-  return sources.length ? new Observable(subscriber => {
+  return sources.length ? new Observable((subscriber, environment) => {
     let buffers = sources.map(() => []);
     let completed = sources.map(() => false);
     subscriber.add(() => {
@@ -458,7 +460,7 @@ export function makeZip(...sources) {
     });
 
     for (let sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
-      from_1(sources[sourceIndex]).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+      from_1(sources[sourceIndex]).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
         next: value => {
           buffers[sourceIndex].push(value);
 
@@ -491,17 +493,17 @@ 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(tsplus_module_9.provideEnvironment_(io, env, fileName_1 + ":487:36"), fileName_1 + ":487:56");
+      fiber = tsplus_module_10.unsafeRunFiber(tsplus_module_9.provideEnvironment(env, fileName_1 + ":489:36")(io), fileName_1 + ":489:56");
       fiber.unsafeOnDone(exit => {
         if (!s.closed) {
-          tsplus_module_11.match_(tsplus_module_11.flatten(exit), cause => s.error(cause), a => s.next(a));
+          tsplus_module_11.match(cause => s.error(cause), a => s.next(a))(tsplus_module_11.flatten(exit));
           s.complete();
         }
       });
     });
     return () => {
       scheduled.unsubscribe();
-      fiber && tsplus_module_10.unsafeRunAsync(tsplus_module_12.interrupt(fiber, fileName_1 + ":500:21"), fileName_1 + ":500:46");
+      fiber && tsplus_module_10.unsafeRunAsync(tsplus_module_12.interrupt(fiber, fileName_1 + ":502:21"), fileName_1 + ":502:46");
     };
   });
 }
@@ -512,213 +514,248 @@ function fromIO_1(io, scheduler = tsplus_module_5.asyncScheduler) {
 
 export const unit = /*#__PURE__*/single_1(undefined);
 /**
- * @tsplus fluent fncts.observable.Observable zipWith
+ * @tsplus pipeable fncts.observable.Observable zipWith
  */
 
-function zipWith_1(fa, fb, f) {
-  return mergeMap_1(fa, a => map_1(fb, b => f(a, b)));
+function zipWith_1(fb, f) {
+  return fa => {
+    return mergeMap_1(a => map_1(b => f(a, b))(fb))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable zip
+ * @tsplus pipeable fncts.observable.Observable zip
  */
 
 
-export function zip(fa, fb) {
-  return zipWith_1(fa, fb, tsplus_module_13.tuple);
+export function zip(fb) {
+  return fa => {
+    return zipWith_1(fb, tsplus_module_13.tuple)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable ap
+ * @tsplus pipeable fncts.observable.Observable ap
  */
 
-export function ap(fab, fa) {
-  return zipWith_1(fab, fa, (f, a) => f(a));
+export function ap(fa) {
+  return fab => {
+    return zipWith_1(fa, (f, a) => f(a))(fab);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mapWithIndex
+ * @tsplus pipeable fncts.observable.Observable mapWithIndex
  */
 
-function mapWithIndex_1(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let i = 0;
-    source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
-      next: value => {
-        subscriber.next(f(i++, value));
-      }
-    }));
-  });
+function mapWithIndex_1(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let i = 0;
+      source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
+        next: value => {
+          subscriber.next(f(i++, value));
+        }
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable map
+ * @tsplus pipeable fncts.observable.Observable map
  */
 
 
-function map_1(fa, f) {
-  return mapWithIndex_1(fa, (_, a) => f(a));
+function map_1(f) {
+  return fa => {
+    return mapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable as
+ * @tsplus pipeable fncts.observable.Observable as
  */
 
 
-function as_1(fa, b) {
-  return map_1(fa, b);
+function as_1(b) {
+  return fa => {
+    return map_1(b)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mapError
+ * @tsplus pipeable fncts.observable.Observable mapError
  */
 
 
-export function mapError_(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
-      error: err => {
-        subscriber.error(tsplus_module_1.map_(err, f));
-      }
-    }));
-  });
+export function mapError(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
+        error: err => {
+          subscriber.error(tsplus_module_1.map(f)(err));
+        }
+      }));
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable swap
  */
 
 export function swap(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
       next: value => {
         subscriber.error(tsplus_module_1.fail(value));
       },
       error: err => {
-        tsplus_module_14.match_(tsplus_module_1.failureOrCause(err), e => {
+        tsplus_module_14.match(e => {
           subscriber.next(e);
         }, cause => {
           subscriber.error(cause);
-        });
+        })(tsplus_module_1.failureOrCause(err));
       }
     }));
-  });
+  })(fa);
 }
 
-function filterWithIndex_1(fa, predicate) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => predicate(index++, value) && subscriber.next(value)
-    }));
-  });
+function filterWithIndex_1(predicate) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => predicate(index++, value) && subscriber.next(value)
+      }));
+    })(fa);
+  };
 }
 
-export function filter_(fa, predicate) {
-  return filterWithIndex_1(fa, (_, a) => predicate(a));
+export function filter(predicate) {
+  return fa => {
+    return filterWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable filterMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable filterMapWithIndex
  */
 
-function filterMapWithIndex_1(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => tsplus_module_15.match_(f(index++, value), () => tsplus_module_2.noop, b => subscriber.next(b))
-    }));
-  });
+function filterMapWithIndex_1(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => tsplus_module_15.match(() => tsplus_module_2.noop, b => subscriber.next(b))(f(index++, value))
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable filterMap
+ * @tsplus pipeable fncts.observable.Observable filterMap
  */
 
 
-export function filterMap_(fa, f) {
-  return filterMapWithIndex_1(fa, (_, a) => f(a));
+export function filterMap(f) {
+  return fa => {
+    return filterMapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 
-function partitionWithIndex_1(fa, predicate) {
-  return [filterWithIndex_1(fa, (i, a) => !predicate(i, a)), filterWithIndex_1(fa, predicate)];
+function partitionWithIndex_1(predicate) {
+  return fa => {
+    return [filterWithIndex_1((i, a) => !predicate(i, a))(fa), filterWithIndex_1(predicate)(fa)];
+  };
 }
 
-export function partition_(fa, predicate) {
-  return partitionWithIndex_1(fa, (_, a) => predicate(a));
+export function partition(predicate) {
+  return fa => {
+    return partitionWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable partitionMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable partitionMapWithIndex
  */
 
-function partitionMapWithIndex_1(fa, f) {
-  return [tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        tsplus_module_14.match_(f(index++, value), b => subscriber.next(b), tsplus_module_2.noop);
-      }
-    }));
-  }), tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        tsplus_module_14.match_(f(index++, value), tsplus_module_2.noop, c => subscriber.next(c));
-      }
-    }));
-  })];
+function partitionMapWithIndex_1(f) {
+  return fa => {
+    return [tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          tsplus_module_14.match(b => subscriber.next(b), tsplus_module_2.noop)(f(index++, value));
+        }
+      }));
+    })(fa), tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          tsplus_module_14.match(tsplus_module_2.noop, c => subscriber.next(c))(f(index++, value));
+        }
+      }));
+    })(fa)];
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable partitionMap
+ * @tsplus pipeable fncts.observable.Observable partitionMap
  */
 
 
-export function partitionMap_(fa, f) {
-  return partitionMapWithIndex_1(fa, (_, a) => f(a));
-}
-/**
- * @tsplus fluent fncts.observable.Observable provideEnvironment
- */
-
-export function provideEnvironment(self, environment) {
-  return self.provide(environment);
+export function partitionMap(f) {
+  return fa => {
+    return partitionMapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable provideService
+ * @tsplus pipeable fncts.observable.Observable provideService
  */
 
-export function provideService(self, service,
+export function provideService(service,
 /** @tsplus auto */
 tag) {
-  return contramapEnvironment_1(self, environment => tsplus_module_16.add(environment, service, tag));
+  return self => {
+    return contramapEnvironment_1(environment => tsplus_module_16.add(service, tag)(environment))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable mergeMapWithIndex
  */
 
-function mergeMapWithIndex_1(ma, f, concurrent = Infinity) {
-  return tsplus_module_8.operate_(ma, (source, sub) => mergeInternal(source, sub, f, concurrent));
+function mergeMapWithIndex_1(f, concurrent = Infinity) {
+  return ma => {
+    return tsplus_module_8.operate_((source, sub, environment) => mergeInternal(source, sub, environment, f, concurrent))(ma);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeMap
+ * @tsplus pipeable fncts.observable.Observable mergeMap
  */
 
 
-function mergeMap_1(ma, f, concurrent = Infinity) {
-  return mergeMapWithIndex_1(ma, (_, a) => f(a), concurrent);
+function mergeMap_1(f, concurrent = Infinity) {
+  return ma => {
+    return mergeMapWithIndex_1((_, a) => f(a), concurrent)(ma);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable concatMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable concatMapWithIndex
  */
 
 
-export function concatMapWithIndex(ma, f) {
-  return mergeMapWithIndex_1(ma, f, 1);
+export function concatMapWithIndex(f) {
+  return ma => {
+    return mergeMapWithIndex_1(f, 1)(ma);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable concatMap
+ * @tsplus pipeable fncts.observable.Observable concatMap
  */
 
-export function concatMap_(ma, f) {
-  return mergeMapWithIndex_1(ma, (_, a) => f(a), 1);
+export function concatMap(f) {
+  return ma => {
+    return mergeMapWithIndex_1((_, a) => f(a), 1)(ma);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable contramapEnvironment
+ * @tsplus pipeable fncts.observable.Observable contramapEnvironment
  */
 
-function contramapEnvironment_1(self, f) {
-  return environmentWithObservable_1(environment => self.provide(f(environment)));
+function contramapEnvironment_1(f) {
+  return self => {
+    return environmentWithObservable_1(environment => self.provideEnvironment(f(environment)));
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable flatten
@@ -729,328 +766,350 @@ export function flatten(mma) {
   return concatAll_1(mma);
 }
 /**
- * @tsplus fluent fncts.observable.Observable foldLeftWithIndex
+ * @tsplus pipeable fncts.observable.Observable foldLeftWithIndex
  */
 
-function foldLeftWithIndex_1(fa, initial, f) {
-  return tsplus_module_8.operate_(fa, scanInternal(f, initial, true, false, true));
+function foldLeftWithIndex_1(initial, f) {
+  return fa => {
+    return tsplus_module_8.operate_(scanInternal(f, initial, true, false, true))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable foldLeft
+ * @tsplus pipeable fncts.observable.Observable foldLeft
  */
 
 
-function foldLeft_1(fa, initial, f) {
-  return foldLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+function foldLeft_1(initial, f) {
+  return fa => {
+    return foldLeftWithIndex_1(initial, (_, b, a) => f(b, a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable at
+ * @tsplus pipeable 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_17.just), () => tsplus_module_17.nothing());
+export function at(index) {
+  return fa => {
+    return onEmpty_1(() => tsplus_module_17.nothing())(map_1(tsplus_module_17.just)(take_1(1)(filterWithIndex_1(i => i === index)(fa))));
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable audit
+ * @tsplus pipeable fncts.observable.Observable audit
  */
 
-function audit_1(fa, durationSelector) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let lastValue = tsplus_module_17.nothing();
-    let durationSubscriber = null;
-    let isComplete = false;
+function audit_1(durationSelector) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let lastValue = tsplus_module_17.nothing();
+      let durationSubscriber = null;
+      let isComplete = false;
 
-    const endDuration = () => {
-      durationSubscriber?.unsubscribe();
-      durationSubscriber = null;
+      const endDuration = () => {
+        durationSubscriber?.unsubscribe();
+        durationSubscriber = null;
 
-      if (tsplus_module_18.isJust(lastValue)) {
-        const {
-          value
-        } = lastValue;
-        lastValue = tsplus_module_17.nothing();
-        subscriber.next(value);
-      }
+        if (tsplus_module_18.isJust(lastValue)) {
+          const {
+            value
+          } = lastValue;
+          lastValue = tsplus_module_17.nothing();
+          subscriber.next(value);
+        }
 
-      isComplete && subscriber.complete();
-    };
+        isComplete && subscriber.complete();
+      };
 
-    const cleanupDuration = () => {
-      durationSubscriber = null;
-      isComplete && subscriber.complete();
-    };
+      const cleanupDuration = () => {
+        durationSubscriber = null;
+        isComplete && subscriber.complete();
+      };
 
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        lastValue = tsplus_module_17.just(value);
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          lastValue = tsplus_module_17.just(value);
 
-        if (!durationSubscriber) {
-          from_1(durationSelector(value)).subscribe(durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-            next: endDuration,
-            complete: cleanupDuration
-          }));
+          if (!durationSubscriber) {
+            from_1(durationSelector(value)).provideEnvironment(environment).subscribe(durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+              next: endDuration,
+              complete: cleanupDuration
+            }));
+          }
+        },
+        complete: () => {
+          isComplete = true;
+          (tsplus_module_18.isNothing(lastValue) || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
         }
-      },
-      complete: () => {
-        isComplete = true;
-        (tsplus_module_18.isNothing(lastValue) || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
-      }
-    }));
-  });
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable auditTime
+ * @tsplus pipeable fncts.observable.Observable auditTime
  */
 
 
-export function auditTime_(fa, duration, scheduler = tsplus_module_5.asyncScheduler) {
-  return audit_1(fa, () => timer_1(duration, scheduler));
+export function auditTime(duration, scheduler = tsplus_module_5.asyncScheduler) {
+  return fa => {
+    return audit_1(() => timer_1(duration, scheduler))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable buffer
+ * @tsplus pipeable fncts.observable.Observable buffer
  */
 
-export function buffer_(fa, closingNotifier) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let buffer = [];
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => buffer.push(value),
-      complete: () => {
-        subscriber.next(buffer);
-        subscriber.complete();
-      }
-    }));
-    closingNotifier.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: () => {
-        const b = buffer;
-        buffer = [];
-        subscriber.next(b);
-      },
-      complete: tsplus_module_2.noop
-    }));
-    return () => {
-      buffer = null;
-    };
-  });
+export function buffer(closingNotifier) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let buffer = [];
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => buffer.push(value),
+        complete: () => {
+          subscriber.next(buffer);
+          subscriber.complete();
+        }
+      }));
+      closingNotifier.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: () => {
+          const b = buffer;
+          buffer = [];
+          subscriber.next(b);
+        },
+        complete: tsplus_module_2.noop
+      }));
+      return () => {
+        buffer = null;
+      };
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable bufferCount
+ * @tsplus pipeable fncts.observable.Observable bufferCount
  */
 
-export function bufferCount_(fa, bufferSize, startBufferEvery) {
-  // eslint-disable-next-line no-param-reassign
-  startBufferEvery = startBufferEvery ?? bufferSize;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let buffers = [];
-    let count = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        let toEmit = null;
+export function bufferCount(bufferSize, startBufferEvery) {
+  return fa => {
+    // eslint-disable-next-line no-param-reassign
+    startBufferEvery = startBufferEvery ?? bufferSize;
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let buffers = [];
+      let count = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          let toEmit = null;
 
-        if (count++ % startBufferEvery === 0) {
-          buffers.push([]);
-        }
+          if (count++ % startBufferEvery === 0) {
+            buffers.push([]);
+          }
 
-        for (const buffer of buffers) {
-          buffer.push(value);
+          for (const buffer of buffers) {
+            buffer.push(value);
 
-          if (bufferSize <= buffer.length) {
-            toEmit = toEmit ?? [];
-            toEmit.push(buffer);
+            if (bufferSize <= buffer.length) {
+              toEmit = toEmit ?? [];
+              toEmit.push(buffer);
+            }
           }
-        }
 
-        if (toEmit) {
-          for (const buffer of toEmit) {
-            arrayRemove(buffers, buffer);
+          if (toEmit) {
+            for (const buffer of toEmit) {
+              arrayRemove(buffers, buffer);
+              subscriber.next(buffer);
+            }
+          }
+        },
+        complete: () => {
+          for (const buffer of buffers) {
             subscriber.next(buffer);
           }
-        }
-      },
-      complete: () => {
-        for (const buffer of buffers) {
-          subscriber.next(buffer);
-        }
 
-        subscriber.complete();
-      }
-    }, () => {
-      buffers = null;
-    }));
-  });
+          subscriber.complete();
+        }
+      }, () => {
+        buffers = null;
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable bufferTime
+ * @tsplus pipeable fncts.observable.Observable bufferTime
  */
 
-export function bufferTime_(fa, config) {
-  const {
-    bufferTimeSpan,
-    bufferCreationInterval = null,
-    maxBufferSize = Infinity,
-    scheduler = tsplus_module_5.asyncScheduler
-  } = config;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let bufferRecords = [];
-    let restartOnEmit = true;
-
-    const emit = record => {
-      const {
-        buffer,
-        subs
-      } = record;
-      subs.unsubscribe();
-      arrayRemove(bufferRecords, record);
-      subscriber.next(buffer);
-      restartOnEmit && startBuffer();
-    };
-
-    const startBuffer = () => {
-      if (bufferRecords) {
-        const subs = new tsplus_module_6.Subscription();
-        subscriber.add(subs);
-        const buffer = [];
-        const record = {
+export function bufferTime(config) {
+  return fa => {
+    const {
+      bufferTimeSpan,
+      bufferCreationInterval = null,
+      maxBufferSize = Infinity,
+      scheduler = tsplus_module_5.asyncScheduler
+    } = config;
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let bufferRecords = [];
+      let restartOnEmit = true;
+
+      const emit = record => {
+        const {
           buffer,
           subs
-        };
-        bufferRecords.push(record);
-        subs.add(scheduler.schedule(() => emit(record), bufferTimeSpan));
-      }
-    };
+        } = record;
+        subs.unsubscribe();
+        arrayRemove(bufferRecords, record);
+        subscriber.next(buffer);
+        restartOnEmit && startBuffer();
+      };
+
+      const startBuffer = () => {
+        if (bufferRecords) {
+          const subs = new tsplus_module_6.Subscription();
+          subscriber.add(subs);
+          const buffer = [];
+          const record = {
+            buffer,
+            subs
+          };
+          bufferRecords.push(record);
+          subs.add(scheduler.schedule(() => emit(record), bufferTimeSpan));
+        }
+      };
 
-    bufferCreationInterval !== null && bufferCreationInterval >= 0 ? subscriber.add(scheduler.schedule(function () {
+      bufferCreationInterval !== null && bufferCreationInterval >= 0 ? subscriber.add(scheduler.schedule(function () {
+        startBuffer();
+        !this.closed && subscriber.add(this.schedule(null, bufferCreationInterval));
+      }, bufferCreationInterval)) : restartOnEmit = true;
       startBuffer();
-      !this.closed && subscriber.add(this.schedule(null, bufferCreationInterval));
-    }, bufferCreationInterval)) : restartOnEmit = true;
-    startBuffer();
-    const bufferTimeSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        const recordsCopy = bufferRecords.slice();
+      const bufferTimeSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          const recordsCopy = bufferRecords.slice();
+
+          for (const record of recordsCopy) {
+            const {
+              buffer
+            } = record;
+            buffer.push(value);
+            maxBufferSize <= buffer.length && emit(record);
+          }
+        },
+        complete: () => {
+          while (bufferRecords?.length) {
+            subscriber.next(bufferRecords.shift().buffer);
+          }
 
-        for (const record of recordsCopy) {
-          const {
-            buffer
-          } = record;
-          buffer.push(value);
-          maxBufferSize <= buffer.length && emit(record);
-        }
-      },
-      complete: () => {
-        while (bufferRecords?.length) {
-          subscriber.next(bufferRecords.shift().buffer);
+          bufferTimeSubscriber?.unsubscribe();
+          subscriber.complete();
+          subscriber.unsubscribe();
         }
-
-        bufferTimeSubscriber?.unsubscribe();
-        subscriber.complete();
-        subscriber.unsubscribe();
-      }
-    }, () => bufferRecords = null);
-    source.subscribe(bufferTimeSubscriber);
-  });
+      }, () => bufferRecords = null);
+      source.provideEnvironment(environment).subscribe(bufferTimeSubscriber);
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable bufferToggle
+ * @tsplus pipeable fncts.observable.Observable bufferToggle
  */
 
-export function bufferToggle_(fa, openings, closingSelector) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    const buffers = [];
-    from_1(openings).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: openValue => {
-        const buffer = [];
-        buffers.push(buffer);
-        const closingSubscription = new tsplus_module_6.Subscription();
+export function bufferToggle(openings, closingSelector) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      const buffers = [];
+      from_1(openings).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: openValue => {
+          const buffer = [];
+          buffers.push(buffer);
+          const closingSubscription = new tsplus_module_6.Subscription();
 
-        const emitBuffer = () => {
-          arrayRemove(buffers, buffer);
-          subscriber.next(buffer);
-          closingSubscription.unsubscribe();
-        };
+          const emitBuffer = () => {
+            arrayRemove(buffers, buffer);
+            subscriber.next(buffer);
+            closingSubscription.unsubscribe();
+          };
 
-        closingSubscription.add(from_1(closingSelector(openValue)).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-          next: emitBuffer,
-          complete: tsplus_module_2.noop
-        })));
-      },
-      complete: tsplus_module_2.noop
-    }));
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        for (const buffer of buffers) {
-          buffer.push(value);
-        }
-      },
-      complete: () => {
-        while (buffers.length > 0) {
-          subscriber.next(buffers.shift());
-        }
+          closingSubscription.add(from_1(closingSelector(openValue)).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+            next: emitBuffer,
+            complete: tsplus_module_2.noop
+          })));
+        },
+        complete: tsplus_module_2.noop
+      }));
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          for (const buffer of buffers) {
+            buffer.push(value);
+          }
+        },
+        complete: () => {
+          while (buffers.length > 0) {
+            subscriber.next(buffers.shift());
+          }
 
-        subscriber.complete();
-      }
-    }));
-  });
+          subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable bufferWhen
+ * @tsplus pipeable fncts.observable.Observable bufferWhen
  */
 
-export function bufferWhen_(fa, closingSelector) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let buffer = null;
-    let closingSubscriber = null;
+export function bufferWhen(closingSelector) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let buffer = null;
+      let closingSubscriber = null;
 
-    const openBuffer = () => {
-      closingSubscriber?.unsubscribe();
-      const b = buffer;
-      buffer = [];
-      b && subscriber.next(b);
-      from_1(closingSelector()).subscribe(closingSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-        next: openBuffer,
-        complete: tsplus_module_2.noop
-      }));
-    };
+      const openBuffer = () => {
+        closingSubscriber?.unsubscribe();
+        const b = buffer;
+        buffer = [];
+        b && subscriber.next(b);
+        from_1(closingSelector()).provideEnvironment(environment).subscribe(closingSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+          next: openBuffer,
+          complete: tsplus_module_2.noop
+        }));
+      };
 
-    openBuffer();
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => buffer?.push(value),
-      complete: () => {
-        buffer && subscriber.next(buffer);
-        subscriber.complete();
-      }
-    }, () => buffer = closingSubscriber = null));
-  });
+      openBuffer();
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => buffer?.push(value),
+        complete: () => {
+          buffer && subscriber.next(buffer);
+          subscriber.complete();
+        }
+      }, () => buffer = closingSubscriber = null));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable catchAllCause
+ * @tsplus pipeable fncts.observable.Observable catchAllCause
  */
 
-function catchAllCause_1(self, f) {
-  return tsplus_module_8.operate_(self, (source, subscriber) => {
-    let innerSub = null;
-    let syncUnsub = false;
-    let handledResult;
-    innerSub = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      error: cause => {
-        handledResult = from_1(f(cause, catchAllCause_1(source, f)));
-
-        if (innerSub) {
-          innerSub.unsubscribe();
-          innerSub = null;
-          handledResult.subscribe(subscriber);
-        } else {
-          syncUnsub = true;
+function catchAllCause_1(f) {
+  return self => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let innerSub = null;
+      let syncUnsub = false;
+      let handledResult;
+      innerSub = source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        error: cause => {
+          handledResult = from_1(f(cause, catchAllCause_1(f)(source)));
+
+          if (innerSub) {
+            innerSub.unsubscribe();
+            innerSub = null;
+            handledResult.provideEnvironment(environment).subscribe(subscriber);
+          } else {
+            syncUnsub = true;
+          }
         }
-      }
-    }));
+      }));
 
-    if (syncUnsub) {
-      innerSub.unsubscribe();
-      innerSub = null;
-      handledResult.subscribe(subscriber);
-    }
-  });
+      if (syncUnsub) {
+        innerSub.unsubscribe();
+        innerSub = null;
+        handledResult.provideEnvironment(environment).subscribe(subscriber);
+      }
+    })(self);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable concatAll
@@ -1058,17 +1117,19 @@ function catchAllCause_1(self, f) {
 
 
 function concatAll_1(ffa) {
-  return mergeAll_1(ffa, 1);
+  return mergeAll_1(1)(ffa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable concat
+ * @tsplus pipeable fncts.observable.Observable concat
  */
 
 
-function concat_1(fa, ...sources) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    concatAll_1(fromArrayLike([source, ...sources])).subscribe(subscriber);
-  });
+function concat_1(...sources) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      concatAll_1(fromArrayLike([source, ...sources])).provideEnvironment(environment).subscribe(subscriber);
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable count
@@ -1076,210 +1137,237 @@ function concat_1(fa, ...sources) {
 
 
 export function count(fa) {
-  return foldLeft_1(fa, 0, (total, _) => total + 1);
+  return foldLeft_1(0, (total, _) => total + 1)(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable countWithIndex
+ * @tsplus pipeable fncts.observable.Observable countWithIndex
  */
 
-function countWithIndex_1(fa, predicate) {
-  return foldLeftWithIndex_1(fa, 0, (i, total, v) => predicate(i, v) ? total + 1 : total);
+function countWithIndex_1(predicate) {
+  return fa => {
+    return foldLeftWithIndex_1(0, (i, total, v) => predicate(i, v) ? total + 1 : total)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable countWith
+ * @tsplus pipeable fncts.observable.Observable countWith
  */
 
 
-export function countWith_(fa, predicate) {
-  return countWithIndex_1(fa, (_, a) => predicate(a));
+export function countWith(predicate) {
+  return fa => {
+    return countWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable combineLatestAll
  */
 
 export function combineLatestAll(fa) {
-  return joinAllInternal(fa, sources => !sources.length ? empty_1() : combineLatest_1(sources[0], ...sources.slice(1)));
+  return joinAllInternal(fa, sources => !sources.length ? empty_1() : zipLatest_1(sources[0], ...sources.slice(1)));
 }
 /**
- * @tsplus fluent fncts.observable.Observable combineLatest
+ * @tsplus pipeable fncts.observable.Observable zipLatest
  */
 
-function combineLatest_1(self, ...sources) {
-  if (!sources.length) {
-    return from_1(self).unsafeCoerce();
-  }
+function zipLatest_1(...sources) {
+  return self => {
+    if (!sources.length) {
+      return from_1(self).unsafeCoerce();
+    }
 
-  return tsplus_module_8.operate_(from_1(self), (source, subscriber) => {
-    combineLatestInternal(subscriber, [source, ...sources]);
-  });
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      combineLatestInternal(subscriber, environment, [source, ...sources]);
+    })(from_1(self));
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable debounceWith
+ * @tsplus pipeable fncts.observable.Observable zipWithLatest
  */
 
 
-export function debounceWith_(fa, durationSelector) {
-  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_18.isJust(lastValue)) {
-        const {
-          value
-        } = lastValue;
-        lastValue = tsplus_module_17.nothing();
-        subscriber.next(value);
-      }
-    };
-
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        durationSubscriber?.unsubscribe();
-        lastValue = tsplus_module_17.just(value);
-        durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-          next: emit,
-          complete: tsplus_module_2.noop
-        });
-        from_1(durationSelector(value)).subscribe(durationSubscriber);
-      },
-      complete: () => {
-        emit();
-        subscriber.complete();
-      }
-    }, () => {
-      lastValue = durationSubscriber = null;
-    }));
-  });
+export function zipWithLatest(that, f) {
+  return self => {
+    return map_1(tsplus_module_13.tupled(f))(zipLatest_1(from_1(that))(self));
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable debounce
+ * @tsplus pipeable fncts.observable.Observable debounceWith
  */
 
-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;
+export function debounceWith(durationSelector) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let lastValue = tsplus_module_17.nothing();
+      let durationSubscriber = null;
 
-    const emit = () => {
-      if (activeTask) {
-        activeTask.unsubscribe();
-        activeTask = null;
-        const value = lastValue;
-        lastValue = null;
-        subscriber.next(value);
-      }
-    };
+      const emit = () => {
+        durationSubscriber?.unsubscribe();
+        durationSubscriber = null;
 
-    function emitWhenIdle() {
-      const targetTime = lastTime + dueTime;
-      const now = scheduler.now();
+        if (tsplus_module_18.isJust(lastValue)) {
+          const {
+            value
+          } = lastValue;
+          lastValue = tsplus_module_17.nothing();
+          subscriber.next(value);
+        }
+      };
 
-      if (now < targetTime) {
-        activeTask = this.schedule(undefined, targetTime - now);
-        subscriber.add(activeTask);
-        return;
-      }
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          durationSubscriber?.unsubscribe();
+          lastValue = tsplus_module_17.just(value);
+          durationSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+            next: emit,
+            complete: tsplus_module_2.noop
+          });
+          from_1(durationSelector(value)).provideEnvironment(environment).subscribe(durationSubscriber);
+        },
+        complete: () => {
+          emit();
+          subscriber.complete();
+        }
+      }, () => {
+        lastValue = durationSubscriber = null;
+      }));
+    })(fa);
+  };
+}
+/**
+ * @tsplus pipeable fncts.observable.Observable debounce
+ */
 
-      emit();
-    }
+export function debounce(dueTime, scheduler = tsplus_module_5.asyncScheduler) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let activeTask = null;
+      let lastValue = null;
+      let lastTime = null;
 
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        lastValue = value;
-        lastTime = scheduler.now();
+      const emit = () => {
+        if (activeTask) {
+          activeTask.unsubscribe();
+          activeTask = null;
+          const value = lastValue;
+          lastValue = null;
+          subscriber.next(value);
+        }
+      };
 
-        if (!activeTask) {
-          activeTask = scheduler.schedule(emitWhenIdle, dueTime);
+      function emitWhenIdle() {
+        const targetTime = lastTime + dueTime;
+        const now = scheduler.now();
+
+        if (now < targetTime) {
+          activeTask = this.schedule(undefined, targetTime - now);
           subscriber.add(activeTask);
+          return;
         }
-      },
-      complete: () => {
+
         emit();
-        subscriber.complete();
       }
-    }, () => {
-      lastValue = activeTask = null;
-    }));
-  });
+
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          lastValue = value;
+          lastTime = scheduler.now();
+
+          if (!activeTask) {
+            activeTask = scheduler.schedule(emitWhenIdle, dueTime);
+            subscriber.add(activeTask);
+          }
+        },
+        complete: () => {
+          emit();
+          subscriber.complete();
+        }
+      }, () => {
+        lastValue = activeTask = null;
+      }));
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable either
  */
 
 export function either(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         subscriber.next(tsplus_module_19.right(value));
       },
       error: error => {
-        tsplus_module_14.match_(tsplus_module_1.failureOrCause(error), e => subscriber.next(tsplus_module_19.left(e)), cause => subscriber.error(cause));
+        tsplus_module_14.match(e => subscriber.next(tsplus_module_19.left(e)), cause => subscriber.error(cause))(tsplus_module_1.failureOrCause(error));
       }
     }));
-  });
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable delayWithIndex
+ * @tsplus pipeable fncts.observable.Observable delayWithIndex
  */
 
-function delayWithIndex_1(fa, f) {
-  return mergeMapWithIndex_1(fa, (i, a) => as_1(take_1(f(i, a), 1), () => a));
+function delayWithIndex_1(f) {
+  return fa => {
+    return mergeMapWithIndex_1((i, a) => as_1(() => a)(take_1(1)(f(i, a))))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable delayWith
+ * @tsplus pipeable fncts.observable.Observable delayWith
  */
 
 
-function delayWith_1(fa, f) {
-  return delayWithIndex_1(fa, (_, a) => f(a));
+function delayWith_1(f) {
+  return fa => {
+    return delayWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable delay
+ * @tsplus pipeable fncts.observable.Observable delay
  */
 
 
-export function delay_(fa, due, scheduler = tsplus_module_5.asyncScheduler) {
-  const duration = timer_1(due, scheduler);
-  return delayWith_1(fa, () => duration);
+export function delay(due, scheduler = tsplus_module_5.asyncScheduler) {
+  return fa => {
+    const duration = timer_1(due, scheduler);
+    return delayWith_1(() => duration)(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable dematerialize
  */
 
 export function dematerialize(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: notification => tsplus_module_20.observe_(notification, subscriber)
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+      next: notification => tsplus_module_20.observe(subscriber)(notification)
     }));
-  });
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable ensuring
+ * @tsplus pipeable fncts.observable.Observable ensuring
  */
 
-export function ensuring_(fa, finalizer) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(subscriber);
-    subscriber.add(finalizer);
-  });
+export function ensuring(finalizer) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      source.provideEnvironment(environment).subscribe(subscriber);
+      subscriber.add(finalizer);
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable exhaustAll
  */
 
 export function exhaustAll(ffa) {
-  return tsplus_module_8.operate_(ffa, (source, subscriber) => {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
     let isComplete = false;
     let innerSub = null;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: inner => {
         if (!innerSub) {
-          innerSub = from_1(inner).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+          innerSub = from_1(inner).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
             complete: () => {
               innerSub = null;
               isComplete && subscriber.complete();
@@ -1292,76 +1380,91 @@ export function exhaustAll(ffa) {
         !innerSub && subscriber.complete();
       }
     }));
-  });
-}
-/**
- * @tsplus fluent fncts.observable.Observable exhaustMapWithIndex
- */
-
-function exhaustMapWithIndex_1(self, f) {
-  return tsplus_module_8.operate_(self, (source, subscriber) => {
-    let index = 0;
-    let innerSub = null;
-    let isComplete = false;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: outerValue => {
-        if (!innerSub) {
-          innerSub = tsplus_module_8.operatorSubscriber(subscriber, {
-            complete: () => {
-              innerSub = null;
-              isComplete && subscriber.complete();
-            }
-          });
-          from_1(f(index++, outerValue)).subscribe(innerSub);
+  })(ffa);
+}
+/**
+ * @tsplus pipeable fncts.observable.Observable exhaustMapWithIndex
+ */
+
+function exhaustMapWithIndex_1(f) {
+  return self => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      let innerSub = null;
+      let isComplete = false;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: outerValue => {
+          if (!innerSub) {
+            innerSub = tsplus_module_8.operatorSubscriber(subscriber, {
+              complete: () => {
+                innerSub = null;
+                isComplete && subscriber.complete();
+              }
+            });
+            from_1(f(index++, outerValue)).provideEnvironment(environment).subscribe(innerSub);
+          }
+        },
+        complete: () => {
+          isComplete = true;
+          !innerSub && subscriber.complete();
         }
-      },
-      complete: () => {
-        isComplete = true;
-        !innerSub && subscriber.complete();
-      }
-    }));
-  });
+      }));
+    })(self);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable exhaustMap
+ * @tsplus pipeable fncts.observable.Observable exhaustMap
  */
 
 
-export function exhaustMap_(self, f) {
-  return exhaustMapWithIndex_1(self, (_, a) => f(a));
+export function exhaustMap(f) {
+  return self => {
+    return exhaustMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable expandWithIndex
+ * @tsplus pipeable fncts.observable.Observable expandWithIndex
  */
 
-function expandWithIndex_1(fa, f, concurrent = Infinity) {
-  // eslint-disable-next-line no-param-reassign
-  concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => mergeInternal(source, subscriber, f, concurrent, undefined, true));
+function expandWithIndex_1(f, concurrent = Infinity) {
+  return fa => {
+    concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
+    return tsplus_module_8.operate_((source, subscriber, environment) => mergeInternal(source, subscriber, environment, f, concurrent, undefined, true))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable expand
+ * @tsplus pipeable fncts.observable.Observable expand
  */
 
 
-export function expand_(fa, f, concurrent = Infinity) {
-  return expandWithIndex_1(fa, (_, a) => f(a), concurrent);
+export function expand(f, concurrent = Infinity) {
+  return fa => {
+    return expandWithIndex_1((_, a) => f(a), concurrent)(fa);
+  };
 }
 
-function findWithIndex_1(fa, predicate) {
-  return tsplus_module_8.operate_(fa, findInternal(predicate, "value"));
+function findWithIndex_1(predicate) {
+  return fa => {
+    return tsplus_module_8.operate_(findInternal(predicate, "value"))(fa);
+  };
 }
 
-export function find_(fa, predicate) {
-  return findWithIndex_1(fa, (_, a) => predicate(a));
+export function find(predicate) {
+  return fa => {
+    return findWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 
-function findIndexWithIndex_1(fa, predicate) {
-  return tsplus_module_8.operate_(fa, findInternal(predicate, "index"));
+function findIndexWithIndex_1(predicate) {
+  return fa => {
+    return tsplus_module_8.operate_(findInternal(predicate, "index"))(fa);
+  };
 }
 
-export function findIndex_(fa, predicate) {
-  return findIndexWithIndex_1(fa, (_, a) => predicate(a));
+export function findIndex(predicate) {
+  return fa => {
+    return findIndexWithIndex_1((_, a) => predicate(a))(fa);
+  };
 }
 export function forkJoin(...args) {
   const {
@@ -1412,19 +1515,19 @@ export function forkJoin(...args) {
  */
 
 export function ignore(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: tsplus_module_2.noop
     }));
-  });
+  })(fa);
 }
 /**
  * @tsplus getter fncts.observable.Observable isEmpty
  */
 
 export function isEmpty(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: () => {
         subscriber.next(false);
         subscriber.complete();
@@ -1434,15 +1537,15 @@ export function isEmpty(fa) {
         subscriber.complete();
       }
     }));
-  });
+  })(fa);
 }
 /**
  * @tsplus getter fncts.observable.Observable materialize
  */
 
 export function materialize(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         subscriber.next(tsplus_module_20.next(value));
       },
@@ -1453,38 +1556,44 @@ export function materialize(fa) {
         subscriber.next(tsplus_module_20.complete());
       }
     }));
-  });
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeAll
+ * @tsplus pipeable fncts.observable.Observable mergeAll
  */
 
-function mergeAll_1(self, concurrent = Infinity) {
-  return mergeMap_1(self, tsplus_module_13.identity, concurrent);
+function mergeAll_1(concurrent = Infinity) {
+  return self => {
+    return mergeMap_1(tsplus_module_13.identity, concurrent)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeScanWithIndex
+ * @tsplus pipeable fncts.observable.Observable mergeScanWithIndex
  */
 
 
-function mergeScanWithIndex_1(fa, initial, f, concurrent = Infinity) {
-  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;
-    }, false, undefined, () => state = null);
-  });
+function mergeScanWithIndex_1(initial, f, concurrent = Infinity) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let state = initial;
+      return mergeInternal(source, subscriber, environment, (index, value) => f(index, state, value), concurrent, value => {
+        state = value;
+      }, false, undefined, () => state = null);
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable mergeScan
+ * @tsplus pipeable fncts.observable.Observable mergeScan
  */
 
 
-export function mergeScan_(fa, initial, f, concurrent = Infinity) {
-  return mergeScanWithIndex_1(fa, initial, (_, b, a) => f(b, a), concurrent);
+export function mergeScan(initial, f, concurrent = Infinity) {
+  return fa => {
+    return mergeScanWithIndex_1(initial, (_, b, a) => f(b, a), concurrent)(fa);
+  };
 }
 export function onErrorResumeNext(fa, ...sources) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
     const remaining = [source, ...sources];
 
     const subscribeNext = () => {
@@ -1503,7 +1612,7 @@ export function onErrorResumeNext(fa, ...sources) {
             error: tsplus_module_2.noop,
             complete: tsplus_module_2.noop
           });
-          subscriber.add(nextSource.subscribe(innerSub));
+          subscriber.add(nextSource.provideEnvironment(environment).subscribe(innerSub));
           innerSub.add(subscribeNext);
         } else {
           subscriber.complete();
@@ -1512,174 +1621,188 @@ export function onErrorResumeNext(fa, ...sources) {
     };
 
     subscribeNext();
-  });
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable onEmpty
+ * @tsplus pipeable fncts.observable.Observable onEmpty
  */
 
-function onEmpty_1(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let hasValue = false;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        hasValue = true;
-        subscriber.next(value);
-      },
-      complete: () => {
-        if (!hasValue) {
-          subscriber.next(f());
-        }
+function onEmpty_1(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let hasValue = false;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          hasValue = true;
+          subscriber.next(value);
+        },
+        complete: () => {
+          if (!hasValue) {
+            subscriber.next(f());
+          }
 
-        subscriber.complete();
-      }
-    }));
-  });
+          subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable repeat
+ * @tsplus pipeable fncts.observable.Observable repeat
  */
 
 
-export function repeat_(fa, count = Infinity) {
-  return count <= 0 ? empty_1() : tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let repeats = 0;
-    let innerSub;
+export function repeat(count = Infinity) {
+  return fa => {
+    return count <= 0 ? empty_1() : tsplus_module_8.operate_((source, subscriber, environment) => {
+      let repeats = 0;
+      let innerSub;
 
-    const loop = () => {
-      let syncUnsub = false;
-      innerSub = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-        complete: () => {
-          if (++repeats < count) {
-            if (innerSub) {
-              innerSub.unsubscribe();
-              innerSub = null;
-              loop();
+      const loop = () => {
+        let syncUnsub = false;
+        innerSub = source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+          complete: () => {
+            if (++repeats < count) {
+              if (innerSub) {
+                innerSub.unsubscribe();
+                innerSub = null;
+                loop();
+              } else {
+                syncUnsub = true;
+              }
             } else {
-              syncUnsub = true;
+              subscriber.complete;
             }
-          } else {
-            subscriber.complete;
           }
-        }
-      }));
+        }));
 
-      if (syncUnsub) {
-        innerSub.unsubscribe();
-        innerSub = null;
-        loop();
-      }
-    };
+        if (syncUnsub) {
+          innerSub.unsubscribe();
+          innerSub = null;
+          loop();
+        }
+      };
 
-    loop();
-  });
+      loop();
+    })(fa);
+  };
 }
-export function retry_(fa, configOrCount = Infinity) {
-  let config;
+export function retry(configOrCount = Infinity) {
+  return fa => {
+    let config;
 
-  if (configOrCount && typeof configOrCount === "object") {
-    config = configOrCount;
-  } else {
-    config = {
-      count: configOrCount
-    };
-  }
+    if (configOrCount && typeof configOrCount === "object") {
+      config = configOrCount;
+    } else {
+      config = {
+        count: configOrCount
+      };
+    }
 
-  const {
-    count,
-    resetOnSuccess = false
-  } = config;
-  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_8.operatorSubscriber(subscriber, {
-        next: value => {
-          if (resetOnSuccess) {
-            retries = 0;
-          }
+    const {
+      count,
+      resetOnSuccess = false
+    } = config;
+    return count <= 0 ? fa : tsplus_module_8.operate_((source, subscriber, environment) => {
+      let retries = 0;
+      let innerSub;
+
+      const loop = () => {
+        let syncUnsub = false;
+        innerSub = source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+          next: value => {
+            if (resetOnSuccess) {
+              retries = 0;
+            }
 
-          subscriber.next(value);
-        },
-        error: err => {
-          if (retries++ < count) {
-            if (innerSub) {
-              innerSub.unsubscribe();
-              innerSub = null;
-              loop();
+            subscriber.next(value);
+          },
+          error: err => {
+            if (retries++ < count) {
+              if (innerSub) {
+                innerSub.unsubscribe();
+                innerSub = null;
+                loop();
+              } else {
+                syncUnsub = true;
+              }
             } else {
-              syncUnsub = true;
+              subscriber.error(err);
             }
-          } else {
-            subscriber.error(err);
           }
-        }
-      }));
+        }));
 
-      if (syncUnsub) {
-        innerSub.unsubscribe();
-        innerSub = null;
-        loop();
-      }
-    };
+        if (syncUnsub) {
+          innerSub.unsubscribe();
+          innerSub = null;
+          loop();
+        }
+      };
 
-    loop();
-  });
+      loop();
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable sample
+ * @tsplus pipeable fncts.observable.Observable sample
  */
 
-function sample_1(fa, notifier) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let hasValue = false;
-    let lastValue = null;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        hasValue = true;
-        lastValue = value;
-      }
-    }));
+function sample_1(notifier) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let hasValue = false;
+      let lastValue = null;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          hasValue = true;
+          lastValue = value;
+        }
+      }));
 
-    const emit = () => {
-      if (hasValue) {
-        hasValue = false;
-        const value = lastValue;
-        lastValue = null;
-        subscriber.next(value);
-      }
-    };
+      const emit = () => {
+        if (hasValue) {
+          hasValue = false;
+          const value = lastValue;
+          lastValue = null;
+          subscriber.next(value);
+        }
+      };
 
-    notifier.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: emit,
-      complete: tsplus_module_2.noop
-    }));
-  });
+      notifier.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: emit,
+        complete: tsplus_module_2.noop
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable sampleTime
+ * @tsplus pipeable fncts.observable.Observable sampleTime
  */
 
 
-export function sampleTime_(fa, period, scheduler = tsplus_module_5.asyncScheduler) {
-  return sample_1(fa, interval_1(period, scheduler));
+export function sampleTime(period, scheduler = tsplus_module_5.asyncScheduler) {
+  return fa => {
+    return sample_1(interval_1(period, scheduler))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable scanLeftWithIndex
+ * @tsplus pipeable fncts.observable.Observable scanLeftWithIndex
  */
 
-function scanLeftWithIndex_1(fa, initial, f) {
-  return tsplus_module_8.operate_(fa, scanInternal(f, initial, true, true));
+function scanLeftWithIndex_1(initial, f) {
+  return fa => {
+    return tsplus_module_8.operate_(scanInternal(f, initial, true, true))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable scanLeft
+ * @tsplus pipeable fncts.observable.Observable scanLeft
  */
 
 
-export function scanLeft(fa, initial, f) {
-  return scanLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+export function scanLeft(initial, f) {
+  return fa => {
+    return scanLeftWithIndex_1(initial, (_, b, a) => f(b, a))(fa);
+  };
 }
 /**
  * @tsplus static fncts.observable.ObservableOps service
@@ -1706,327 +1829,363 @@ tag) {
 function serviceWithObservable_1(f,
 /** @tsplus auto */
 tag) {
-  return environmentWithObservable_1(environment => f(tsplus_module_16.unsafeGet(environment, tag)));
+  return environmentWithObservable_1(environment => f(tsplus_module_16.unsafeGet(tag)(environment)));
 }
 /**
- * @tsplus fluent fncts.observable.Observable skip
+ * @tsplus pipeable fncts.observable.Observable skip
  */
 
 
-export function skip_(fa, count) {
-  return filterWithIndex_1(fa, (index, _) => count <= index);
+export function skip(count) {
+  return fa => {
+    return filterWithIndex_1((index, _) => count <= index)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable skipLast
+ * @tsplus pipeable fncts.observable.Observable skipLast
  */
 
-export function skipLast_(fa, skipCount) {
-  return skipCount <= 0 ? fa : tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let ring = new Array(skipCount);
-    let seen = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        const valueIndex = seen++;
+export function skipLast(skipCount) {
+  return fa => {
+    return skipCount <= 0 ? fa : tsplus_module_8.operate_((source, subscriber, environment) => {
+      let ring = new Array(skipCount);
+      let seen = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          const valueIndex = seen++;
 
-        if (valueIndex < skipCount) {
-          ring[valueIndex] = value;
-        } else {
-          const index = valueIndex % skipCount;
-          const oldValue = ring[index];
-          ring[index] = value;
-          subscriber.next(oldValue);
+          if (valueIndex < skipCount) {
+            ring[valueIndex] = value;
+          } else {
+            const index = valueIndex % skipCount;
+            const oldValue = ring[index];
+            ring[index] = value;
+            subscriber.next(oldValue);
+          }
         }
-      }
-    }));
-    return () => {
-      ring = null;
-    };
-  });
+      }));
+      return () => {
+        ring = null;
+      };
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable skipUntil
+ * @tsplus pipeable fncts.observable.Observable skipUntil
  */
 
-export function skipUntil_(fa, notifier) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let taking = false;
-    const skipSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-      next: () => {
-        skipSubscriber?.unsubscribe();
-        taking = true;
-      },
-      complete: tsplus_module_2.noop
-    });
-    from_1(notifier).subscribe(skipSubscriber);
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => taking && subscriber.next(value)
-    }));
-  });
+export function skipUntil(notifier) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let taking = false;
+      const skipSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+        next: () => {
+          skipSubscriber?.unsubscribe();
+          taking = true;
+        },
+        complete: tsplus_module_2.noop
+      });
+      from_1(notifier).provideEnvironment(environment).subscribe(skipSubscriber);
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => taking && subscriber.next(value)
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable skipWhile
+ * @tsplus pipeable fncts.observable.Observable skipWhile
  */
 
-export function skipWhile_(fa, predicate) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let taking = false;
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => (taking || (taking = !predicate(index++, value))) && subscriber.next(value)
-    }));
-  });
+export function skipWhile(predicate) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let taking = false;
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => (taking || (taking = !predicate(index++, value))) && subscriber.next(value)
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable startWith
+ * @tsplus pipeable fncts.observable.Observable startWith
  */
 
-export function startWith_(fa, ...values) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    // @ts-expect-error
-    concat_1(source, values).subscribe(subscriber);
-  });
+export function startWith(...values) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber) => {
+      // @ts-expect-error
+      concat_1(values)(source).subscribe(subscriber);
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable subscribeOn
+ * @tsplus pipeable fncts.observable.Observable subscribeOn
  */
 
-export function subscribeOn_(fa, scheduler, delay = 0) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay));
-  });
+export function subscribeOn(scheduler, delay = 0) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      subscriber.add(scheduler.schedule(() => source.provideEnvironment(environment).subscribe(subscriber), delay));
+    })(fa);
+  };
 }
 /**
  * @tsplus getter fncts.observable.Observable switchAll
  */
 
 export function switchAll(ffa) {
-  return switchMap_1(ffa, tsplus_module_13.identity);
+  return switchMap_1(tsplus_module_13.identity)(ffa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable switchMapWithIndex
+ * @tsplus pipeable fncts.observable.Observable switchMapWithIndex
  */
 
-function switchMapWithIndex_1(fa, f) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let innerSubscriber = null;
-    let index = 0;
-    let isComplete = false;
+function switchMapWithIndex_1(f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let innerSubscriber = null;
+      let index = 0;
+      let isComplete = false;
 
-    const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
+      const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
 
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        innerSubscriber?.unsubscribe();
-        const outerIndex = index++;
-        from_1(f(outerIndex, value)).subscribe(innerSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
-          next: innerValue => subscriber.next(innerValue),
-          complete: () => {
-            innerSubscriber = null;
-            checkComplete();
-          }
-        }));
-      }
-    }, () => {
-      isComplete = true;
-      checkComplete();
-    }));
-  });
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          innerSubscriber?.unsubscribe();
+          const outerIndex = index++;
+          from_1(f(outerIndex, value)).provideEnvironment(environment).subscribe(innerSubscriber = tsplus_module_8.operatorSubscriber(subscriber, {
+            next: innerValue => subscriber.next(innerValue),
+            complete: () => {
+              innerSubscriber = null;
+              checkComplete();
+            }
+          }));
+        }
+      }, () => {
+        isComplete = true;
+        checkComplete();
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable switchMap
+ * @tsplus pipeable fncts.observable.Observable switchMap
  */
 
 
-function switchMap_1(fa, f) {
-  return switchMapWithIndex_1(fa, (_, a) => f(a));
+function switchMap_1(f) {
+  return fa => {
+    return switchMapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable switchScanWithIndex
+ * @tsplus pipeable fncts.observable.Observable switchScanWithIndex
  */
 
 
-function switchScanWithIndex_1(fa, initial, f) {
-  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 () => {
-      state = null;
-    };
-  });
+function switchScanWithIndex_1(initial, f) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let state = initial;
+      switchMapWithIndex_1((index, value) => map_1(b => (state = b, b))(from_1(f(index, state, value))))(source).provideEnvironment(environment).subscribe(subscriber);
+      return () => {
+        state = null;
+      };
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable switchScan
+ * @tsplus pipeable fncts.observable.Observable switchScan
  */
 
 
-export function switchScan_(fa, initial, f) {
-  return switchScanWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+export function switchScan(initial, f) {
+  return fa => {
+    return switchScanWithIndex_1(initial, (_, b, a) => f(b, a))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable take
+ * @tsplus pipeable fncts.observable.Observable take
  */
 
-function take_1(fa, count) {
-  return count <= 0 ? empty_1() : tsplus_module_8.operate_(fa, (source, sub) => {
-    let seen = 0;
-    source.subscribe(new tsplus_module_8.OperatorSubscriber(sub, {
-      next: value => {
-        if (++seen <= count) {
-          sub.next(value);
+function take_1(count) {
+  return fa => {
+    return count <= 0 ? empty_1() : tsplus_module_8.operate_((source, sub, environment) => {
+      let seen = 0;
+      source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(sub, {
+        next: value => {
+          if (++seen <= count) {
+            sub.next(value);
 
-          if (count <= seen) {
-            sub.complete();
+            if (count <= seen) {
+              sub.complete();
+            }
           }
         }
-      }
-    }));
-  });
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable takeLast
+ * @tsplus pipeable fncts.observable.Observable takeLast
  */
 
 
-export function takeLast_(fa, count) {
-  return count <= 0 ? empty_1() : tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let buffer = [];
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        buffer.push(value);
-        count < buffer.length && buffer.shift();
-      },
-      complete: () => {
-        for (const value of buffer) {
-          subscriber.next(value);
-        }
+export function takeLast(count) {
+  return fa => {
+    return count <= 0 ? empty_1() : tsplus_module_8.operate_((source, subscriber, environment) => {
+      let buffer = [];
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          buffer.push(value);
+          count < buffer.length && buffer.shift();
+        },
+        complete: () => {
+          for (const value of buffer) {
+            subscriber.next(value);
+          }
 
-        subscriber.complete();
-      }
-    }, () => {
-      buffer = null;
-    }));
-  });
+          subscriber.complete();
+        }
+      }, () => {
+        buffer = null;
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable takeUntil
+ * @tsplus pipeable fncts.observable.Observable takeUntil
  */
 
-export function takeUntil_(fa, notifier) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    from_1(notifier).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: () => subscriber.complete(),
-      complete: tsplus_module_2.noop
-    }));
-    !subscriber.closed && source.subscribe(subscriber);
-  });
+export function takeUntil(notifier) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      from_1(notifier).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: () => subscriber.complete(),
+        complete: tsplus_module_2.noop
+      }));
+      !subscriber.closed && source.provideEnvironment(environment).subscribe(subscriber);
+    })(fa);
+  };
 }
 
-function takeWhileWithIndex_1(fa, predicate, inclusive) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        const result = predicate(index++, value);
-        (result || inclusive) && subscriber.next(value);
-        !result && subscriber.complete();
-      }
-    }));
-  });
+function takeWhileWithIndex_1(predicate, inclusive) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let index = 0;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          const result = predicate(index++, value);
+          (result || inclusive) && subscriber.next(value);
+          !result && subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 
-export function takeWhile_(fa, predicate, inclusive) {
-  return takeWhileWithIndex_1(fa, (_, a) => predicate(a), inclusive);
+export function takeWhile(predicate, inclusive) {
+  return fa => {
+    return takeWhileWithIndex_1((_, a) => predicate(a), inclusive)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable tap
+ * @tsplus pipeable fncts.observable.Observable tap
  */
 
-export function tap_(fa, observer) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        observer.next?.(value);
-        subscriber.next(value);
-      },
-      error: err => {
-        observer.error?.(err);
-        subscriber.error(err);
-      },
-      complete: () => {
-        observer.complete?.();
-        subscriber.complete();
-      }
-    }));
-  });
+export function tap(observer) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          observer.next?.(value);
+          subscriber.next(value);
+        },
+        error: err => {
+          observer.error?.(err);
+          subscriber.error(err);
+        },
+        complete: () => {
+          observer.complete?.();
+          subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 export const defaultThrottleConfig = {
   leading: true,
   trailing: false
 };
 /**
- * @tsplus fluent fncts.observable.Observable throttle
+ * @tsplus pipeable fncts.observable.Observable throttle
  */
 
-function throttle_1(fa, durationSelector, {
+function throttle_1(durationSelector, {
   leading,
   trailing
 } = defaultThrottleConfig) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let sendValue = tsplus_module_17.nothing();
-    let throttled = null;
-    let isComplete = false;
-
-    const endThrottling = () => {
-      throttled?.unsubscribe();
-      throttled = null;
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let sendValue = tsplus_module_17.nothing();
+      let throttled = null;
+      let isComplete = false;
+
+      const endThrottling = () => {
+        throttled?.unsubscribe();
+        throttled = null;
+
+        if (trailing) {
+          send();
+          isComplete && subscriber.complete();
+        }
+      };
 
-      if (trailing) {
-        send();
+      const cleanupThrottling = () => {
+        throttled = null;
         isComplete && subscriber.complete();
-      }
-    };
-
-    const cleanupThrottling = () => {
-      throttled = null;
-      isComplete && subscriber.complete();
-    };
+      };
 
-    const startThrottling = value => throttled = from_1(durationSelector(value)).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: endThrottling,
-      complete: cleanupThrottling
-    }));
+      const startThrottling = value => throttled = from_1(durationSelector(value)).provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: endThrottling,
+        complete: cleanupThrottling
+      }));
 
-    const send = () => {
-      if (tsplus_module_18.isJust(sendValue)) {
-        const {
-          value
-        } = sendValue;
-        sendValue = tsplus_module_17.nothing();
-        subscriber.next(value);
-        !isComplete && startThrottling(value);
-      }
-    };
+      const send = () => {
+        if (tsplus_module_18.isJust(sendValue)) {
+          const {
+            value
+          } = sendValue;
+          sendValue = tsplus_module_17.nothing();
+          subscriber.next(value);
+          !isComplete && startThrottling(value);
+        }
+      };
 
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        sendValue = tsplus_module_17.just(value);
-        !(throttled && !throttled.closed) && (leading ? send() : startThrottling(value));
-      },
-      complete: () => {
-        isComplete = true;
-        !(trailing && tsplus_module_18.isJust(sendValue) && throttled && !throttled.closed) && subscriber.complete();
-      }
-    }));
-  });
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          sendValue = tsplus_module_17.just(value);
+          !(throttled && !throttled.closed) && (leading ? send() : startThrottling(value));
+        },
+        complete: () => {
+          isComplete = true;
+          !(trailing && tsplus_module_18.isJust(sendValue) && throttled && !throttled.closed) && subscriber.complete();
+        }
+      }));
+    })(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.observable.Observable throttleTime
+ * @tsplus pipeable fncts.observable.Observable throttleTime
  */
 
 
-export function throttleTime_(fa, duration, scheduler = tsplus_module_5.asyncScheduler, config = defaultThrottleConfig) {
-  const duration$ = timer_1(duration, scheduler);
-  return throttle_1(fa, () => duration$, config);
+export function throttleTime(duration, scheduler = tsplus_module_5.asyncScheduler, config = defaultThrottleConfig) {
+  return fa => {
+    const duration$ = timer_1(duration, scheduler);
+    return throttle_1(() => duration$, config)(fa);
+  };
 }
 export class TimeoutError extends Error {
   constructor(info) {
@@ -2036,49 +2195,51 @@ export class TimeoutError extends Error {
   }
 
 }
-export function timeout_(fa, config) {
-  const {
-    first,
-    each,
-    with: _with = timeoutError,
-    scheduler = tsplus_module_5.asyncScheduler,
-    meta = null
-  } = config;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    // eslint-disable-next-line prefer-const
-    let originalSourceSubscription;
-    let timerSubscription;
-    let lastValue = tsplus_module_17.nothing();
-    let seen = 0;
-
-    const startTimer = delay => {
-      timerSubscription = caughtSchedule(subscriber, scheduler, () => {
-        originalSourceSubscription.unsubscribe();
-        from_1(_with({
-          meta,
-          lastValue,
-          seen
-        })).subscribe(subscriber);
-      }, delay);
-    };
-
-    originalSourceSubscription = source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        timerSubscription?.unsubscribe();
-        seen++;
-        lastValue = tsplus_module_17.just(value);
-        subscriber.next(value);
-        each > 0 && startTimer(each);
-      }
-    }, () => {
-      if (!timerSubscription?.closed) {
-        timerSubscription?.unsubscribe();
-      }
+export function timeout(config) {
+  return fa => {
+    const {
+      first,
+      each,
+      with: _with = timeoutError,
+      scheduler = tsplus_module_5.asyncScheduler,
+      meta = null
+    } = config;
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      // eslint-disable-next-line prefer-const
+      let originalSourceSubscription;
+      let timerSubscription;
+      let lastValue = tsplus_module_17.nothing();
+      let seen = 0;
+
+      const startTimer = delay => {
+        timerSubscription = caughtSchedule(subscriber, scheduler, () => {
+          originalSourceSubscription.unsubscribe();
+          from_1(_with({
+            meta,
+            lastValue,
+            seen
+          })).provideEnvironment(environment).subscribe(subscriber);
+        }, delay);
+      };
+
+      originalSourceSubscription = source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          timerSubscription?.unsubscribe();
+          seen++;
+          lastValue = tsplus_module_17.just(value);
+          subscriber.next(value);
+          each > 0 && startTimer(each);
+        }
+      }, () => {
+        if (!timerSubscription?.closed) {
+          timerSubscription?.unsubscribe();
+        }
 
-      lastValue = tsplus_module_17.nothing();
-    }));
-    startTimer(first != null ? typeof first === "number" ? first : +first - scheduler.now() : each);
-  });
+        lastValue = tsplus_module_17.nothing();
+      }));
+      startTimer(first != null ? typeof first === "number" ? first : +first - scheduler.now() : each);
+    })(fa);
+  };
 }
 
 function timeoutError(info) {
@@ -2094,60 +2255,66 @@ function toArrayAccumulator(arr, value) {
 
 
 function toArray_1(fa) {
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    foldLeft_1(source, [], toArrayAccumulator).subscribe(subscriber);
-  });
+  return tsplus_module_8.operate_((source, subscriber, environment) => {
+    foldLeft_1([], toArrayAccumulator)(source).provideEnvironment(environment).subscribe(subscriber);
+  })(fa);
 }
 /**
- * @tsplus fluent fncts.observable.Observable unique
+ * @tsplus pipeable fncts.observable.Observable unique
  */
 
 
-export function unique_(fa, toKey, flushes) {
-  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;
+export function unique(toKey, flushes) {
+  return fa => {
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let distinctKeys = tsplus_module_21.makeDefault();
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          const key = toKey ? toKey(value) : value;
 
-        if (!tsplus_module_21.has_(distinctKeys, key)) {
-          tsplus_module_21.add_(distinctKeys, key);
-          subscriber.next(value);
+          if (!tsplus_module_21.has(key)(distinctKeys)) {
+            tsplus_module_21.add(key)(distinctKeys);
+            subscriber.next(value);
+          }
         }
-      }
-    }));
-    flushes?.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: () => distinctKeys = tsplus_module_21.makeDefault(),
-      complete: tsplus_module_2.noop
-    }));
-  });
+      }));
+      flushes?.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: () => distinctKeys = tsplus_module_21.makeDefault(),
+        complete: tsplus_module_2.noop
+      }));
+    })(fa);
+  };
 }
 
-function uniqueUntilChanged_1(fa, E, keySelector = tsplus_module_13.identity) {
-  const compare = "equals" in E ? E.equals : E;
-  return tsplus_module_8.operate_(fa, (source, subscriber) => {
-    let previousKey;
-    let first = true;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
-      next: value => {
-        const currentKey = keySelector(value);
+function uniqueUntilChanged_1(E, keySelector = tsplus_module_13.identity) {
+  return fa => {
+    const compare = "equals" in E ? E.equals : E;
+    return tsplus_module_8.operate_((source, subscriber, environment) => {
+      let previousKey;
+      let first = true;
+      source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        next: value => {
+          const currentKey = keySelector(value);
 
-        if (first || !compare(previousKey, currentKey)) {
-          first = false;
-          previousKey = currentKey;
-          subscriber.next(value);
+          if (first || !compare(previousKey, currentKey)) {
+            first = false;
+            previousKey = currentKey;
+            subscriber.next(value);
+          }
         }
-      }
-    }));
-  });
+      }));
+    })(fa);
+  };
 }
 
-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]));
+export function uniqueUntilKeyChanged(key, equals) {
+  return fa => {
+    const compare = "equals" in equals ? equals.equals : equals;
+    return uniqueUntilChanged_1((x, y) => compare(x[key], y[key]))(fa);
+  };
 }
 
-function combineLatestInternal(subscriber, observables, scheduler, valueTransform = tsplus_module_13.identity) {
+function combineLatestInternal(subscriber, environment, observables, scheduler, valueTransform = tsplus_module_13.identity) {
   return maybeSchedule(subscriber, scheduler, () => {
     const {
       length
@@ -2158,9 +2325,9 @@ function combineLatestInternal(subscriber, observables, scheduler, valueTransfor
 
     for (let i = 0; i < length; i++) {
       maybeSchedule(subscriber, scheduler, () => {
-        const source = scheduler ? scheduled_1(observables[i], scheduler) : from_1(observables[i]);
+        const source = scheduler ? scheduled_1(scheduler)(observables[i]) : from_1(observables[i]);
         let hasFirstValue = false;
-        source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+        source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
           next: value => {
             values[i] = value;
 
@@ -2186,9 +2353,9 @@ function combineLatestInternal(subscriber, observables, scheduler, valueTransfor
 
 function findInternal(predicate, emit) {
   const findIndex = emit === "index";
-  return (source, subscriber) => {
+  return (source, subscriber, environment) => {
     let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const i = index++;
 
@@ -2206,7 +2373,7 @@ function findInternal(predicate, emit) {
 }
 
 export function joinAllInternal(fa, joiner) {
-  return mergeMap_1(toArray_1(fa), joiner);
+  return mergeMap_1(joiner)(toArray_1(fa));
 }
 
 function maybeSchedule(subscription, scheduler, execute) {
@@ -2217,7 +2384,7 @@ function maybeSchedule(subscription, scheduler, execute) {
   }
 }
 
-function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand, innerSubScheduler, additionalTeardown) {
+function mergeInternal(source, subscriber, environment, f, concurrent, onBeforeNext, expand, innerSubScheduler, additionalTeardown) {
   const buffer = [];
   let active = 0;
   let index = 0;
@@ -2235,7 +2402,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_8.OperatorSubscriber(subscriber, {
+    from_1(f(index++, a)).provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
       next: b => {
         onBeforeNext?.(b);
 
@@ -2266,7 +2433,7 @@ function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand,
     }));
   };
 
-  source.subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
+  source.provideEnvironment(environment).subscribe(new tsplus_module_8.OperatorSubscriber(subscriber, {
     next: outerNext,
     complete: () => {
       isComplete = true;
@@ -2279,11 +2446,11 @@ function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand,
 }
 
 export function scanInternal(f, initial, hasInitial, emitOnNext, emitBeforeComplete) {
-  return (source, subscriber) => {
+  return (source, subscriber, environment) => {
     let hasState = hasInitial;
     let state = initial;
     let index = 0;
-    source.subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
+    source.provideEnvironment(environment).subscribe(tsplus_module_8.operatorSubscriber(subscriber, {
       next: value => {
         const i = index++;
         state = hasState ? f(i, state, value) : (hasState = true, value);