@fncts/observable 0.0.1

package/_mjs/Observable/api.mjs

@@ -0,0 +1,2291 @@
+const fileName_1 = "(@fncts/observable) src/Observable/api.ts";
+import * as tsplus_module_1 from "@fncts/observable/Observable";
+import * as tsplus_module_2 from "@fncts/base/data/Cause/api";
+import * as tsplus_module_3 from "@fncts/observable/internal/util";
+import * as tsplus_module_4 from "@fncts/base/util/predicates";
+import * as tsplus_module_5 from "@fncts/io/IO";
+import * as tsplus_module_6 from "@fncts/observable/AsyncScheduler";
+import * as tsplus_module_7 from "@fncts/observable/Subscription";
+import * as tsplus_module_8 from "@fncts/observable/Scheduler";
+import * as tsplus_module_9 from "@fncts/observable/Operator";
+import * as tsplus_module_10 from "@fncts/io/IO/runtime";
+import * as tsplus_module_11 from "@fncts/base/data/Exit/api";
+import * as tsplus_module_12 from "@fncts/io/Fiber/api/interrupt";
+import * as tsplus_module_13 from "@fncts/base/data/function/api";
+import * as tsplus_module_14 from "@fncts/base/data/Either/destructors";
+import * as tsplus_module_15 from "@fncts/base/data/Maybe/destructors";
+import * as tsplus_module_16 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_17 from "@fncts/base/data/Maybe/definition";
+import * as tsplus_module_18 from "@fncts/base/data/Either/constructors";
+import * as tsplus_module_19 from "@fncts/observable/Notification";
+import * as tsplus_module_20 from "@fncts/base/collection/immutable/HashSet/api";
+export const defer = defer_1;
+export const empty = empty_1;
+export const fail = fail_1;
+export const from = from_1;
+export const fromSubscribable = fromSubscribable_1;
+export const interval = interval_1;
+export const single = single_1;
+export const scheduled = scheduled_1;
+export const timer = timer_1;
+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 filterMapWithIndex = filterMapWithIndex_1;
+export const partitionWithIndex = partitionWithIndex_1;
+export const partitionMapWithIndex_ = partitionMapWithIndex_1;
+export const mergeMapWithIndex = mergeMapWithIndex_1;
+export const mergeMap_ = mergeMap_1;
+export const foldLeftWithIndex = foldLeftWithIndex_1;
+export const foldLeft = foldLeft_1;
+export const audit_ = audit_1;
+export const bufferWhen_ = bufferWhen_1;
+export const catchAllCause = catchAllCause_1;
+export const concatAll = concatAll_1;
+export const concat_ = concat_1;
+export const countWithIndex = countWithIndex_1;
+export const combineLatest_ = combineLatest_1;
+export const delayWithIndex = delayWithIndex_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 mergeScanWithIndex = mergeScanWithIndex_1;
+export const onEmpty_ = onEmpty_1;
+export const sample_ = sample_1;
+export const scanLeftWithIndex = scanLeftWithIndex_1;
+export const switchMapWithIndex = switchMapWithIndex_1;
+export const switchMap_ = switchMap_1;
+export const switchScanWithIndex = switchScanWithIndex_1;
+export const take_ = take_1;
+export const takeWhileWithIndex = takeWhileWithIndex_1;
+export const throttle_ = throttle_1;
+export const toArray = toArray_1;
+export const uniqueUntilChanged_ = uniqueUntilChanged_1;
+import { popNumber } from "@fncts/observable/internal/args";
+import { arrayOrObject, arrayRemove, readableStreamToAsyncGenerator } from "@fncts/observable/internal/util";
+import { EMPTY } from "@fncts/observable/Observable/definition";
+import { caughtSchedule } from "@fncts/observable/Scheduler";
+/*
+ * -------------------------------------------------------------------------------------------------
+ * constructors
+ * -------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @tsplus static fncts.observable.ObservableOps halt
+ */
+
+export function halt(defect) {
+  return new tsplus_module_1.Observable(s => s.error(tsplus_module_2.halt(defect)));
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps defer
+ */
+
+function defer_1(observable) {
+  return new tsplus_module_1.Observable(s => {
+    from_1(observable()).subscribe(s);
+  });
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps empty
+ */
+
+
+function empty_1() {
+  return EMPTY;
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps failCause
+ */
+
+
+export function failCause(cause) {
+  return new tsplus_module_1.Observable(s => s.error(cause));
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps fail
+ */
+
+function fail_1(e) {
+  return new tsplus_module_1.Observable(s => s.error(tsplus_module_2.fail(e)));
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps from
+ */
+
+
+function from_1(input) {
+  if (input instanceof tsplus_module_1.Observable) {
+    return input;
+  }
+
+  if (tsplus_module_3.isArrayLike(input)) {
+    return fromArrayLike(input);
+  }
+
+  if (tsplus_module_3.isPromiseLike(input)) {
+    return fromPromise(input);
+  }
+
+  if (tsplus_module_3.isAsyncIterable(input)) {
+    return fromAsyncIterable(input);
+  }
+
+  if (tsplus_module_4.isIterable(input)) {
+    return fromIterable(input);
+  }
+
+  if (tsplus_module_3.isReadableStream(input)) {
+    return fromReadableStreamLike(input);
+  }
+
+  if (tsplus_module_5.isIO(input)) {
+    return fromIO_1(input);
+  }
+
+  if ("subscribe" in input) {
+    return fromSubscribable_1(input);
+  }
+
+  throw new TypeError("Invalid Observable input");
+}
+
+export function fromArrayLike(input) {
+  return new tsplus_module_1.Observable(s => {
+    for (let i = 0; i < input.length && !s.closed; i++) {
+      s.next(input[i]);
+    }
+
+    s.complete();
+  });
+}
+export function fromAsyncIterable(asyncIterable) {
+  return new tsplus_module_1.Observable(s => {
+    process(asyncIterable, s).catch(err => s.error(tsplus_module_2.halt(err)));
+  });
+}
+export function fromIterable(iterable) {
+  return new tsplus_module_1.Observable(s => {
+    for (const value of iterable) {
+      s.next(value);
+
+      if (s.closed) {
+        return;
+      }
+    }
+
+    s.complete();
+  });
+}
+export function fromPromise(promise) {
+  return new tsplus_module_1.Observable(s => {
+    promise.then(value => {
+      if (!s.closed) {
+        s.next(value);
+        s.complete();
+      }
+    }, err => s.error(tsplus_module_2.halt(err))).then(null, tsplus_module_3.reportUnhandledError);
+  });
+}
+export function fromReadableStreamLike(readableStream) {
+  return fromAsyncIterable(readableStreamToAsyncGenerator(readableStream));
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps fromSubscribable
+ */
+
+function fromSubscribable_1(subscribable) {
+  return new tsplus_module_1.Observable(subscriber => subscribable.subscribe(subscriber));
+}
+
+export function fromInterop(subscribable) {
+  return new tsplus_module_1.Observable(subscriber => subscribable.subscribe({
+    next: value => subscriber.next(value),
+    error: err => subscriber.error(tsplus_module_2.halt(err)),
+    complete: () => subscriber.complete()
+  }));
+}
+
+function _if(condition, onTrue, onFalse) {
+  return defer_1(() => condition() ? onTrue : onFalse);
+}
+
+export { _if as if };
+export function iterate(options) {
+  const {
+    initialState,
+    cont,
+    iterate,
+    scheduler
+  } = options;
+
+  function* gen() {
+    for (let state = initialState; !cont || cont(state); state = iterate(state)) {
+      yield state;
+    }
+  }
+
+  return defer_1(scheduler ? () => scheduleIterable(gen(), scheduler) : gen);
+}
+
+async function process(asyncIterable, subscriber) {
+  for await (const value of asyncIterable) {
+    subscriber.next(value);
+
+    if (subscriber.closed) {
+      return;
+    }
+  }
+
+  subscriber.complete();
+}
+/**
+ * @tsplus static fncts.obervable.ObservableOps interval
+ */
+
+
+function interval_1(period = 0, scheduler = tsplus_module_6.asyncScheduler) {
+  if (period < 0) {
+    // eslint-disable-next-line no-param-reassign
+    period = 0;
+  }
+
+  return timer_1(period, period, scheduler);
+}
+
+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);
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps of
+ */
+
+export function of(...items) {
+  return fromArrayLike(items);
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps single
+ */
+
+function single_1(a) {
+  return new tsplus_module_1.Observable(s => {
+    s.next(a);
+    s.complete();
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable scheduled
+ * @tsplus static fncts.observable.ObservableOps scheduled
+ */
+
+
+function scheduled_1(input, scheduler) {
+  if (tsplus_module_3.isArrayLike(input)) {
+    return scheduleArray(input, scheduler);
+  }
+
+  if (tsplus_module_3.isPromiseLike(input)) {
+    return schedulePromise(input, scheduler);
+  }
+
+  if (tsplus_module_4.isIterable(input)) {
+    return scheduleIterable(input, scheduler);
+  }
+
+  if (tsplus_module_3.isAsyncIterable(input)) {
+    return scheduleAsyncIterable(input, scheduler);
+  }
+
+  if (tsplus_module_3.isReadableStream(input)) {
+    return scheduleReadableStreamLike(input, scheduler);
+  }
+
+  return scheduleObservable(from_1(input), scheduler);
+}
+
+export function scheduleArray(input, scheduler) {
+  return new tsplus_module_1.Observable(s => {
+    let i = 0;
+    return scheduler.schedule(function () {
+      if (i === input.length) {
+        s.complete();
+      } else {
+        s.next(input[i++]);
+
+        if (!s.closed) {
+          this.schedule();
+        }
+      }
+    });
+  });
+}
+export function scheduleAsyncIterable(input, scheduler) {
+  return new tsplus_module_1.Observable(subscriber => {
+    const sub = new tsplus_module_7.Subscription();
+    sub.add(scheduler.schedule(() => {
+      const iterator = input[Symbol.asyncIterator]();
+      sub.add(scheduler.schedule(function () {
+        iterator.next().then(result => {
+          if (result.done) {
+            subscriber.complete();
+          } else {
+            subscriber.next(result.value);
+            this.schedule();
+          }
+        });
+      }));
+    }));
+    return sub;
+  });
+}
+export function scheduleIterable(input, scheduler) {
+  return new tsplus_module_1.Observable(s => {
+    let iterator;
+    s.add(scheduler.schedule(() => {
+      iterator = input[Symbol.iterator]();
+      caughtSchedule(s, scheduler, function () {
+        const {
+          value,
+          done
+        } = iterator.next();
+
+        if (done) {
+          s.complete();
+        } else {
+          s.next(value);
+          this.schedule();
+        }
+      });
+    }));
+    return () => tsplus_module_4.isFunction(iterator?.return) && iterator.return();
+  });
+}
+export function scheduleObservable(input, scheduler) {
+  return new tsplus_module_1.Observable(subscriber => {
+    const sub = new tsplus_module_7.Subscription();
+    sub.add(scheduler.schedule(() => {
+      sub.add(input.subscribe({
+        next: value => {
+          sub.add(scheduler.schedule(() => subscriber.next(value)));
+        },
+        error: err => {
+          sub.add(scheduler.schedule(() => subscriber.error(err)));
+        },
+        complete: () => {
+          sub.add(scheduler.schedule(() => subscriber.complete()));
+        }
+      }));
+    }));
+  });
+}
+export function schedulePromise(input, scheduler) {
+  return new tsplus_module_1.Observable(subscriber => {
+    return scheduler.schedule(() => {
+      input.then(value => {
+        subscriber.add(scheduler.schedule(() => {
+          subscriber.next(value);
+          subscriber.add(scheduler.schedule(() => subscriber.complete()));
+        }));
+      }, err => {
+        subscriber.add(scheduler.schedule(() => subscriber.error(tsplus_module_2.halt(err))));
+      });
+    });
+  });
+}
+export function scheduleReadableStreamLike(input, scheduler) {
+  return scheduleAsyncIterable(readableStreamToAsyncGenerator(input), scheduler);
+}
+
+function timer_1(time = 0, intervalOrScheduler, scheduler = tsplus_module_6.asyncScheduler) {
+  let intervalDuration = -1;
+
+  if (intervalOrScheduler != null) {
+    if (tsplus_module_8.isScheduler(intervalOrScheduler)) {
+      // eslint-disable-next-line no-param-reassign
+      scheduler = intervalOrScheduler;
+    } else {
+      intervalDuration = intervalOrScheduler;
+    }
+  }
+
+  return new tsplus_module_1.Observable(s => {
+    let due = tsplus_module_3.isValidDate(time) ? +time - scheduler.now() : time;
+
+    if (due < 0) {
+      due = 0;
+    }
+
+    let n = 0;
+    return scheduler.schedule(function () {
+      if (!s.closed) {
+        s.next(n++);
+
+        if (0 <= intervalDuration) {
+          this.schedule(undefined, intervalDuration);
+        } else {
+          s.complete();
+        }
+      }
+    }, due);
+  });
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps zip
+ */
+
+
+export function makeZip(...sources) {
+  return sources.length ? new tsplus_module_1.Observable(subscriber => {
+    let buffers = sources.map(() => []);
+    let completed = sources.map(() => false);
+    subscriber.add(() => {
+      buffers = completed = null;
+    });
+
+    for (let sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) {
+      from_1(sources[sourceIndex]).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+        next: value => {
+          buffers[sourceIndex].push(value);
+
+          if (buffers.every(buffer => buffer.length)) {
+            const result = buffers.map(buffer => buffer.shift());
+            subscriber.next(result);
+
+            if (buffers.some((buffer, i) => !buffer.length && completed[i])) {
+              subscriber.complete();
+            }
+          }
+        },
+        complete: () => {
+          completed[sourceIndex] = true;
+          !buffers[sourceIndex].length && subscriber.complete();
+        }
+      }));
+    }
+
+    return () => {
+      buffers = completed = null;
+    };
+  }) : empty_1();
+}
+/**
+ * @tsplus static fncts.observable.ObservableOps fromIO
+ */
+
+function fromIO_1(io, scheduler = tsplus_module_6.asyncScheduler) {
+  return new tsplus_module_1.Observable(s => {
+    let fiber;
+    const scheduled = scheduler.schedule(() => {
+      fiber = tsplus_module_10.unsafeRunFiber(io, fileName_1 + ":473:32");
+      fiber.unsafeOnDone(exit => {
+        if (!s.closed) {
+          tsplus_module_11.match_(tsplus_module_11.flatten(exit), cause => s.error(cause), a => s.next(a));
+          s.complete();
+        }
+      });
+    });
+    return () => {
+      scheduled.unsubscribe();
+      fiber && tsplus_module_10.unsafeRunAsync(tsplus_module_12.interrupt(fiber), fileName_1 + ":486:46");
+    };
+  });
+}
+/*
+ * -------------------------------------------------------------------------------------------------
+ * Applicative
+ * -------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @tsplus static fncts.observable.ObservableOps unit
+ */
+
+
+export const unit = /*#__PURE__*/single_1(undefined);
+/*
+ * -------------------------------------------------------------------------------------------------
+ * Apply
+ * -------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @tsplus fluent fncts.observable.Observable zipWith
+ */
+
+function zipWith_1(fa, fb, f) {
+  return mergeMap_1(fa, a => map_1(fb, b => f(a, b)));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable zip
+ */
+
+
+export function zip(fa, fb) {
+  return zipWith_1(fa, fb, tsplus_module_13.tuple);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable ap
+ */
+
+export function ap(fab, fa) {
+  return zipWith_1(fab, fa, (f, a) => f(a));
+}
+/*
+ * -------------------------------------------------------------------------------------------------
+ * Functor
+ * -------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @tsplus fluent fncts.observable.Observable mapWithIndex
+ */
+
+function mapWithIndex_1(fa, f) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let i = 0;
+    source.subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+      next: value => {
+        subscriber.next(f(i++, value));
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable map
+ */
+
+
+function map_1(fa, f) {
+  return mapWithIndex_1(fa, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable as
+ */
+
+
+function as_1(fa, b) {
+  return map_1(fa, b);
+}
+/*
+ * -------------------------------------------------------------------------------------------------
+ * Bifunctor
+ * -------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @tsplus fluent fncts.observable.Observable mapError
+ */
+
+
+export function mapError_(fa, f) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    source.subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+      error: err => {
+        subscriber.error(tsplus_module_2.map_(err, f));
+      }
+    }));
+  });
+}
+/**
+ * @tsplus getter fncts.observable.Observable swap
+ */
+
+export function swap(fa) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    source.subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+      next: value => {
+        subscriber.error(tsplus_module_2.fail(value));
+      },
+      error: err => {
+        tsplus_module_14.match_(tsplus_module_2.failureOrCause(err), e => {
+          subscriber.next(e);
+        }, cause => {
+          subscriber.error(cause);
+        });
+      }
+    }));
+  });
+}
+
+function filterWithIndex_1(fa, predicate) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let index = 0;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => predicate(index++, value) && subscriber.next(value)
+    }));
+  });
+}
+
+export function filter_(fa, predicate) {
+  return filterWithIndex_1(fa, (_, a) => predicate(a));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable filterMapWithIndex
+ */
+
+function filterMapWithIndex_1(fa, f) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let index = 0;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => tsplus_module_15.match_(f(index++, value), () => tsplus_module_3.noop, b => subscriber.next(b))
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable filterMap
+ */
+
+
+export function filterMap_(fa, f) {
+  return filterMapWithIndex_1(fa, (_, a) => f(a));
+}
+
+function partitionWithIndex_1(fa, predicate) {
+  return [filterWithIndex_1(fa, (i, a) => !predicate(i, a)), filterWithIndex_1(fa, predicate)];
+}
+
+export function partition_(fa, predicate) {
+  return partitionWithIndex_1(fa, (_, a) => predicate(a));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable partitionMapWithIndex
+ */
+
+function partitionMapWithIndex_1(fa, f) {
+  return [tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let index = 0;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        tsplus_module_14.match_(f(index++, value), b => subscriber.next(b), tsplus_module_3.noop);
+      }
+    }));
+  }), tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let index = 0;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        tsplus_module_14.match_(f(index++, value), tsplus_module_3.noop, c => subscriber.next(c));
+      }
+    }));
+  })];
+}
+/**
+ * @tsplus fluent fncts.observable.Observable partitionMap
+ */
+
+
+export function partitionMap_(fa, f) {
+  return partitionMapWithIndex_1(fa, (_, a) => f(a));
+}
+/*
+ * -------------------------------------------------------------------------------------------------
+ * Monad
+ * -------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @tsplus fluent fncts.observable.Observable mergeMapWithIndex
+ */
+
+function mergeMapWithIndex_1(ma, f, concurrent = Infinity) {
+  return tsplus_module_9.operate_(ma, (source, sub) => mergeInternal(source, sub, f, concurrent));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable mergeMap
+ */
+
+
+function mergeMap_1(ma, f, concurrent = Infinity) {
+  return mergeMapWithIndex_1(ma, (_, a) => f(a), concurrent);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable concatMapWithIndex
+ */
+
+
+export function concatMapWithIndex(ma, f) {
+  return mergeMapWithIndex_1(ma, f, 1);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable concatMap
+ */
+
+export function concatMap_(ma, f) {
+  return mergeMapWithIndex_1(ma, (_, a) => f(a), 1);
+}
+/**
+ * @tsplus getter fncts.observable.Observable flatten
+ */
+
+export function flatten(mma) {
+  return concatAll_1(mma);
+}
+/*
+ * -------------------------------------------------------------------------------------------------
+ * Foldable
+ * -------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @tsplus fluent fncts.observable.Observable foldLeftWithIndex
+ */
+
+function foldLeftWithIndex_1(fa, initial, f) {
+  return tsplus_module_9.operate_(fa, scanInternal(f, initial, true, false, true));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable foldLeft
+ */
+
+
+function foldLeft_1(fa, initial, f) {
+  return foldLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+}
+/*
+ * -------------------------------------------------------------------------------------------------
+ * combinators
+ * -------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @tsplus fluent fncts.observable.Observable at
+ */
+
+
+export function at_(fa, index) {
+  return onEmpty_1(map_1(take_1(filterWithIndex_1(fa, i => i === index), 1), tsplus_module_16.just), () => tsplus_module_16.nothing());
+}
+/**
+ * @tsplus fluent fncts.observable.Observable audit
+ */
+
+function audit_1(fa, durationSelector) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let lastValue = tsplus_module_16.nothing();
+    let durationSubscriber = null;
+    let isComplete = false;
+
+    const endDuration = () => {
+      durationSubscriber?.unsubscribe();
+      durationSubscriber = null;
+
+      if (tsplus_module_17.isJust(lastValue)) {
+        const {
+          value
+        } = lastValue;
+        lastValue = tsplus_module_16.nothing();
+        subscriber.next(value);
+      }
+
+      isComplete && subscriber.complete();
+    };
+
+    const cleanupDuration = () => {
+      durationSubscriber = null;
+      isComplete && subscriber.complete();
+    };
+
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        lastValue = tsplus_module_16.just(value);
+
+        if (!durationSubscriber) {
+          from_1(durationSelector(value)).subscribe(durationSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+            next: endDuration,
+            complete: cleanupDuration
+          }));
+        }
+      },
+      complete: () => {
+        isComplete = true;
+        (tsplus_module_17.isNothing(lastValue) || !durationSubscriber || durationSubscriber.closed) && subscriber.complete();
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable auditTime
+ */
+
+
+export function auditTime_(fa, duration, scheduler = tsplus_module_6.asyncScheduler) {
+  return audit_1(fa, () => timer_1(duration, scheduler));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable buffer
+ */
+
+export function buffer_(fa, closingNotifier) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let buffer = [];
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => buffer.push(value),
+      complete: () => {
+        subscriber.next(buffer);
+        subscriber.complete();
+      }
+    }));
+    closingNotifier.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: () => {
+        const b = buffer;
+        buffer = [];
+        subscriber.next(b);
+      },
+      complete: tsplus_module_3.noop
+    }));
+    return () => {
+      buffer = null;
+    };
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable bufferCount
+ */
+
+export function bufferCount_(fa, bufferSize, startBufferEvery) {
+  // eslint-disable-next-line no-param-reassign
+  startBufferEvery = startBufferEvery ?? bufferSize;
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let buffers = [];
+    let count = 0;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        let toEmit = null;
+
+        if (count++ % startBufferEvery === 0) {
+          buffers.push([]);
+        }
+
+        for (const buffer of buffers) {
+          buffer.push(value);
+
+          if (bufferSize <= buffer.length) {
+            toEmit = toEmit ?? [];
+            toEmit.push(buffer);
+          }
+        }
+
+        if (toEmit) {
+          for (const buffer of toEmit) {
+            arrayRemove(buffers, buffer);
+            subscriber.next(buffer);
+          }
+        }
+      },
+      complete: () => {
+        for (const buffer of buffers) {
+          subscriber.next(buffer);
+        }
+
+        subscriber.complete();
+      }
+    }, () => {
+      buffers = null;
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable bufferTime
+ */
+
+export function bufferTime_(fa, config) {
+  const {
+    bufferTimeSpan,
+    bufferCreationInterval = null,
+    maxBufferSize = Infinity,
+    scheduler = tsplus_module_6.asyncScheduler
+  } = config;
+  return tsplus_module_9.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_7.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 () {
+      startBuffer();
+      !this.closed && subscriber.add(this.schedule(null, bufferCreationInterval));
+    }, bufferCreationInterval)) : restartOnEmit = true;
+    startBuffer();
+    const bufferTimeSubscriber = tsplus_module_9.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);
+        }
+
+        bufferTimeSubscriber?.unsubscribe();
+        subscriber.complete();
+        subscriber.unsubscribe();
+      }
+    }, () => bufferRecords = null);
+    source.subscribe(bufferTimeSubscriber);
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable bufferToggle
+ */
+
+export function bufferToggle_(fa, openings, closingSelector) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    const buffers = [];
+    from_1(openings).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: openValue => {
+        const buffer = [];
+        buffers.push(buffer);
+        const closingSubscription = new tsplus_module_7.Subscription();
+
+        const emitBuffer = () => {
+          arrayRemove(buffers, buffer);
+          subscriber.next(buffer);
+          closingSubscription.unsubscribe();
+        };
+
+        closingSubscription.add(from_1(closingSelector(openValue)).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+          next: emitBuffer,
+          complete: tsplus_module_3.noop
+        })));
+      },
+      complete: tsplus_module_3.noop
+    }));
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        for (const buffer of buffers) {
+          buffer.push(value);
+        }
+      },
+      complete: () => {
+        while (buffers.length > 0) {
+          subscriber.next(buffers.shift());
+        }
+
+        subscriber.complete();
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable bufferWhen
+ */
+
+function bufferWhen_1(fa, closingSelector) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    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_9.operatorSubscriber(subscriber, {
+        next: openBuffer,
+        complete: tsplus_module_3.noop
+      }));
+    };
+
+    openBuffer();
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => buffer?.push(value),
+      complete: () => {
+        buffer && subscriber.next(buffer);
+        subscriber.complete();
+      }
+    }, () => buffer = closingSubscriber = null));
+  });
+}
+
+export function bufferWhen(closingSelector) {
+  return fa => bufferWhen_1(fa, closingSelector);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable catchAllCause
+ */
+
+function catchAllCause_1(self, f) {
+  return tsplus_module_9.operate_(self, (source, subscriber) => {
+    let innerSub = null;
+    let syncUnsub = false;
+    let handledResult;
+    innerSub = source.subscribe(tsplus_module_9.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;
+        }
+      }
+    }));
+
+    if (syncUnsub) {
+      innerSub.unsubscribe();
+      innerSub = null;
+      handledResult.subscribe(subscriber);
+    }
+  });
+}
+/**
+ * @tsplus getter fncts.observable.Observable concatAll
+ */
+
+
+function concatAll_1(ffa) {
+  return mergeAll_1(ffa, 1);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable concat
+ */
+
+
+function concat_1(fa, ...sources) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    concatAll_1(fromArrayLike([source, ...sources])).subscribe(subscriber);
+  });
+}
+/**
+ * @tsplus getter fncts.observable.Observable count
+ */
+
+
+export function count(fa) {
+  return foldLeft_1(fa, 0, (total, _) => total + 1);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable countWithIndex
+ */
+
+function countWithIndex_1(fa, predicate) {
+  return foldLeftWithIndex_1(fa, 0, (i, total, v) => predicate(i, v) ? total + 1 : total);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable countWith
+ */
+
+
+export function countWith_(fa, predicate) {
+  return countWithIndex_1(fa, (_, a) => predicate(a));
+}
+/**
+ * @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)));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable combineLatest
+ */
+
+function combineLatest_1(self, ...sources) {
+  if (!sources.length) {
+    return from_1(self);
+  }
+
+  return tsplus_module_9.operate_(from_1(self), (source, subscriber) => {
+    combineLatestInternal(subscriber, [source, ...sources]);
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable debounceWith
+ */
+
+
+export function debounceWith_(fa, durationSelector) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let lastValue = tsplus_module_16.nothing();
+    let durationSubscriber = null;
+
+    const emit = () => {
+      durationSubscriber?.unsubscribe();
+      durationSubscriber = null;
+
+      if (tsplus_module_17.isJust(lastValue)) {
+        const {
+          value
+        } = lastValue;
+        lastValue = tsplus_module_16.nothing();
+        subscriber.next(value);
+      }
+    };
+
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        durationSubscriber?.unsubscribe();
+        lastValue = tsplus_module_16.just(value);
+        durationSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+          next: emit,
+          complete: tsplus_module_3.noop
+        });
+        from_1(durationSelector(value)).subscribe(durationSubscriber);
+      },
+      complete: () => {
+        emit();
+        subscriber.complete();
+      }
+    }, () => {
+      lastValue = durationSubscriber = null;
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable debounce
+ */
+
+export function debounce_(fa, dueTime, scheduler = tsplus_module_6.asyncScheduler) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let activeTask = null;
+    let lastValue = null;
+    let lastTime = null;
+
+    const emit = () => {
+      if (activeTask) {
+        activeTask.unsubscribe();
+        activeTask = null;
+        const value = lastValue;
+        lastValue = null;
+        subscriber.next(value);
+      }
+    };
+
+    function emitWhenIdle() {
+      const targetTime = lastTime + dueTime;
+      const now = scheduler.now();
+
+      if (now < targetTime) {
+        activeTask = this.schedule(undefined, targetTime - now);
+        subscriber.add(activeTask);
+        return;
+      }
+
+      emit();
+    }
+
+    source.subscribe(tsplus_module_9.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;
+    }));
+  });
+}
+/**
+ * @tsplus getter fncts.observable.Observable either
+ */
+
+export function either(fa) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        subscriber.next(tsplus_module_18.right(value));
+      },
+      error: error => {
+        tsplus_module_14.match_(tsplus_module_2.failureOrCause(error), e => subscriber.next(tsplus_module_18.left(e)), cause => subscriber.error(cause));
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable delayWithIndex
+ */
+
+function delayWithIndex_1(fa, f) {
+  return mergeMapWithIndex_1(fa, (i, a) => as_1(take_1(f(i, a), 1), () => a));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable delayWith
+ */
+
+
+function delayWith_1(fa, f) {
+  return delayWithIndex_1(fa, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable delay
+ */
+
+
+export function delay_(fa, due, scheduler = tsplus_module_6.asyncScheduler) {
+  const duration = timer_1(due, scheduler);
+  return delayWith_1(fa, () => duration);
+}
+/**
+ * @tsplus getter fncts.observable.Observable dematerialize
+ */
+
+export function dematerialize(fa) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: notification => tsplus_module_19.observe_(notification, subscriber)
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable ensuring
+ */
+
+export function ensuring_(fa, finalizer) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    source.subscribe(subscriber);
+    subscriber.add(finalizer);
+  });
+}
+/**
+ * @tsplus getter fncts.observable.Observable exhaustAll
+ */
+
+export function exhaustAll(ffa) {
+  return tsplus_module_9.operate_(ffa, (source, subscriber) => {
+    let isComplete = false;
+    let innerSub = null;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: inner => {
+        if (!innerSub) {
+          innerSub = from_1(inner).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+            complete: () => {
+              innerSub = null;
+              isComplete && subscriber.complete();
+            }
+          }));
+        }
+      },
+      complete: () => {
+        isComplete = true;
+        !innerSub && subscriber.complete();
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable exhaustMapWithIndex
+ */
+
+function exhaustMapWithIndex_1(self, f) {
+  return tsplus_module_9.operate_(self, (source, subscriber) => {
+    let index = 0;
+    let innerSub = null;
+    let isComplete = false;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: outerValue => {
+        if (!innerSub) {
+          innerSub = tsplus_module_9.operatorSubscriber(subscriber, {
+            complete: () => {
+              innerSub = null;
+              isComplete && subscriber.complete();
+            }
+          });
+          from_1(f(index++, outerValue)).subscribe(innerSub);
+        }
+      },
+      complete: () => {
+        isComplete = true;
+        !innerSub && subscriber.complete();
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable exhaustMap
+ */
+
+
+export function exhaustMap_(self, f) {
+  return exhaustMapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent 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_9.operate_(fa, (source, subscriber) => mergeInternal(source, subscriber, f, concurrent, undefined, true));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable expand
+ */
+
+
+export function expand_(fa, f, concurrent = Infinity) {
+  return expandWithIndex_1(fa, (_, a) => f(a), concurrent);
+}
+
+function findWithIndex_1(fa, predicate) {
+  return tsplus_module_9.operate_(fa, findInternal(predicate, "value"));
+}
+
+export function find_(fa, predicate) {
+  return findWithIndex_1(fa, (_, a) => predicate(a));
+}
+
+function findIndexWithIndex_1(fa, predicate) {
+  return tsplus_module_9.operate_(fa, findInternal(predicate, "index"));
+}
+
+export function findIndex_(fa, predicate) {
+  return findIndexWithIndex_1(fa, (_, a) => predicate(a));
+}
+export function forkJoin(...args) {
+  const {
+    args: sources,
+    keys
+  } = arrayOrObject(args);
+  return new tsplus_module_1.Observable(s => {
+    const length = sources.length;
+
+    if (!length) {
+      s.complete();
+      return;
+    }
+
+    const values = new Array(length);
+    let remainingCompletions = length;
+    let remainingEmissions = length;
+
+    for (let sourceIndex = 0; sourceIndex < length; sourceIndex++) {
+      let hasValue = false;
+      from_1(sources[sourceIndex]).subscribe(tsplus_module_9.operatorSubscriber(s, {
+        next: value => {
+          if (!hasValue) {
+            hasValue = true;
+            remainingEmissions--;
+          }
+
+          values[sourceIndex] = value;
+        },
+        complete: () => {
+          if (! --remainingCompletions || !hasValue) {
+            if (!remainingEmissions) {
+              s.next(keys ? keys.reduce((b, k, i) => {
+                b[k] = values[i];
+                return b;
+              }, {}) : values);
+            }
+
+            s.complete();
+          }
+        }
+      }));
+    }
+  });
+}
+/**
+ * @tsplus getter fncts.observable.Observable ignore
+ */
+
+export function ignore(fa) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: tsplus_module_3.noop
+    }));
+  });
+}
+/**
+ * @tsplus getter fncts.observable.Observable isEmpty
+ */
+
+export function isEmpty(fa) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: () => {
+        subscriber.next(false);
+        subscriber.complete();
+      },
+      complete: () => {
+        subscriber.next(true);
+        subscriber.complete();
+      }
+    }));
+  });
+}
+/**
+ * @tsplus getter fncts.observable.Observable materialize
+ */
+
+export function materialize(fa) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        subscriber.next(tsplus_module_19.next(value));
+      },
+      error: error => {
+        subscriber.next(tsplus_module_19.error(error));
+      },
+      complete: () => {
+        subscriber.next(tsplus_module_19.complete());
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable mergeAll
+ */
+
+function mergeAll_1(self, concurrent = Infinity) {
+  return mergeMap_1(self, tsplus_module_13.identity, concurrent);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable mergeScanWithIndex
+ */
+
+
+function mergeScanWithIndex_1(fa, initial, f, concurrent = Infinity) {
+  return tsplus_module_9.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);
+  });
+}
+/**
+ * @tsplus fluent 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 onErrorResumeNext(fa, ...sources) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    const remaining = [source, ...sources];
+
+    const subscribeNext = () => {
+      if (!subscriber.closed) {
+        if (remaining.length > 0) {
+          let nextSource;
+
+          try {
+            nextSource = from_1(remaining.shift());
+          } catch (err) {
+            subscribeNext();
+            return;
+          }
+
+          const innerSub = tsplus_module_9.operatorSubscriber(subscriber, {
+            error: tsplus_module_3.noop,
+            complete: tsplus_module_3.noop
+          });
+          subscriber.add(nextSource.subscribe(innerSub));
+          innerSub.add(subscribeNext);
+        } else {
+          subscriber.complete();
+        }
+      }
+    };
+
+    subscribeNext();
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable onEmpty
+ */
+
+function onEmpty_1(fa, f) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let hasValue = false;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        hasValue = true;
+        subscriber.next(value);
+      },
+      complete: () => {
+        if (!hasValue) {
+          subscriber.next(f());
+        }
+
+        subscriber.complete();
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable repeat
+ */
+
+
+export function repeat_(fa, count = Infinity) {
+  return count <= 0 ? empty_1() : tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let repeats = 0;
+    let innerSub;
+
+    const loop = () => {
+      let syncUnsub = false;
+      innerSub = source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+        complete: () => {
+          if (++repeats < count) {
+            if (innerSub) {
+              innerSub.unsubscribe();
+              innerSub = null;
+              loop();
+            } else {
+              syncUnsub = true;
+            }
+          } else {
+            subscriber.complete;
+          }
+        }
+      }));
+
+      if (syncUnsub) {
+        innerSub.unsubscribe();
+        innerSub = null;
+        loop();
+      }
+    };
+
+    loop();
+  });
+}
+export function retry_(fa, configOrCount = Infinity) {
+  let config;
+
+  if (configOrCount && typeof configOrCount === "object") {
+    config = configOrCount;
+  } else {
+    config = {
+      count: configOrCount
+    };
+  }
+
+  const {
+    count,
+    resetOnSuccess = false
+  } = config;
+  return count <= 0 ? fa : tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let retries = 0;
+    let innerSub;
+
+    const loop = () => {
+      let syncUnsub = false;
+      innerSub = source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+        next: value => {
+          if (resetOnSuccess) {
+            retries = 0;
+          }
+
+          subscriber.next(value);
+        },
+        error: err => {
+          if (retries++ < count) {
+            if (innerSub) {
+              innerSub.unsubscribe();
+              innerSub = null;
+              loop();
+            } else {
+              syncUnsub = true;
+            }
+          } else {
+            subscriber.error(err);
+          }
+        }
+      }));
+
+      if (syncUnsub) {
+        innerSub.unsubscribe();
+        innerSub = null;
+        loop();
+      }
+    };
+
+    loop();
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable sample
+ */
+
+function sample_1(fa, notifier) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let hasValue = false;
+    let lastValue = null;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        hasValue = true;
+        lastValue = value;
+      }
+    }));
+
+    const emit = () => {
+      if (hasValue) {
+        hasValue = false;
+        const value = lastValue;
+        lastValue = null;
+        subscriber.next(value);
+      }
+    };
+
+    notifier.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: emit,
+      complete: tsplus_module_3.noop
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable sampleTime
+ */
+
+
+export function sampleTime_(fa, period, scheduler = tsplus_module_6.asyncScheduler) {
+  return sample_1(fa, interval_1(period, scheduler));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable scanLeftWithIndex
+ */
+
+function scanLeftWithIndex_1(fa, initial, f) {
+  return tsplus_module_9.operate_(fa, scanInternal(f, initial, true, true));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable scanLeft
+ */
+
+
+export function scanLeft(fa, initial, f) {
+  return scanLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable skip
+ */
+
+export function skip_(fa, count) {
+  return filterWithIndex_1(fa, (index, _) => count <= index);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable skipLast
+ */
+
+export function skipLast_(fa, skipCount) {
+  return skipCount <= 0 ? fa : tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let ring = new Array(skipCount);
+    let seen = 0;
+    source.subscribe(tsplus_module_9.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);
+        }
+      }
+    }));
+    return () => {
+      ring = null;
+    };
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable skipUntil
+ */
+
+export function skipUntil_(fa, notifier) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let taking = false;
+    const skipSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+      next: () => {
+        skipSubscriber?.unsubscribe();
+        taking = true;
+      },
+      complete: tsplus_module_3.noop
+    });
+    from_1(notifier).subscribe(skipSubscriber);
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => taking && subscriber.next(value)
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable skipWhile
+ */
+
+export function skipWhile_(fa, predicate) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let taking = false;
+    let index = 0;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => (taking || (taking = !predicate(index++, value))) && subscriber.next(value)
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable startWith
+ */
+
+export function startWith_(fa, ...values) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    // @ts-expect-error
+    concat_1(source, values).subscribe(subscriber);
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable subscribeOn
+ */
+
+export function subscribeOn_(fa, scheduler, delay = 0) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay));
+  });
+}
+/**
+ * @tsplus getter fncts.observable.Observable switchAll
+ */
+
+export function switchAll(ffa) {
+  return switchMap_1(ffa, tsplus_module_13.identity);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable switchMapWithIndex
+ */
+
+function switchMapWithIndex_1(fa, f) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let innerSubscriber = null;
+    let index = 0;
+    let isComplete = false;
+
+    const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
+
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        innerSubscriber?.unsubscribe();
+        const outerIndex = index++;
+        from_1(f(outerIndex, value)).subscribe(innerSubscriber = tsplus_module_9.operatorSubscriber(subscriber, {
+          next: innerValue => subscriber.next(innerValue),
+          complete: () => {
+            innerSubscriber = null;
+            checkComplete();
+          }
+        }));
+      }
+    }, () => {
+      isComplete = true;
+      checkComplete();
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable switchMap
+ */
+
+
+function switchMap_1(fa, f) {
+  return switchMapWithIndex_1(fa, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable switchScanWithIndex
+ */
+
+
+function switchScanWithIndex_1(fa, initial, f) {
+  return tsplus_module_9.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;
+    };
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable switchScan
+ */
+
+
+export function switchScan_(fa, initial, f) {
+  return switchScanWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+}
+/**
+ * @tsplus fluent fncts.observable.Observable take
+ */
+
+function take_1(fa, count) {
+  return count <= 0 ? empty_1() : tsplus_module_9.operate_(fa, (source, sub) => {
+    let seen = 0;
+    source.subscribe(new tsplus_module_9.OperatorSubscriber(sub, {
+      next: value => {
+        if (++seen <= count) {
+          sub.next(value);
+
+          if (count <= seen) {
+            sub.complete();
+          }
+        }
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable takeLast
+ */
+
+
+export function takeLast_(fa, count) {
+  return count <= 0 ? empty_1() : tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let buffer = [];
+    source.subscribe(tsplus_module_9.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;
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable takeUntil
+ */
+
+export function takeUntil_(fa, notifier) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    from_1(notifier).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: () => subscriber.complete(),
+      complete: tsplus_module_3.noop
+    }));
+    !subscriber.closed && source.subscribe(subscriber);
+  });
+}
+
+function takeWhileWithIndex_1(fa, predicate, inclusive) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let index = 0;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        const result = predicate(index++, value);
+        (result || inclusive) && subscriber.next(value);
+        !result && subscriber.complete();
+      }
+    }));
+  });
+}
+
+export function takeWhile_(fa, predicate, inclusive) {
+  return takeWhileWithIndex_1(fa, (_, a) => predicate(a), inclusive);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable tap
+ */
+
+export function tap_(fa, observer) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        observer.next?.(value);
+        subscriber.next(value);
+      },
+      error: err => {
+        observer.error?.(err);
+        subscriber.error(err);
+      },
+      complete: () => {
+        observer.complete?.();
+        subscriber.complete();
+      }
+    }));
+  });
+}
+export const defaultThrottleConfig = {
+  leading: true,
+  trailing: false
+};
+/**
+ * @tsplus fluent fncts.observable.Observable throttle
+ */
+
+function throttle_1(fa, durationSelector, {
+  leading,
+  trailing
+} = defaultThrottleConfig) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let sendValue = tsplus_module_16.nothing();
+    let throttled = null;
+    let isComplete = false;
+
+    const endThrottling = () => {
+      throttled?.unsubscribe();
+      throttled = null;
+
+      if (trailing) {
+        send();
+        isComplete && subscriber.complete();
+      }
+    };
+
+    const cleanupThrottling = () => {
+      throttled = null;
+      isComplete && subscriber.complete();
+    };
+
+    const startThrottling = value => throttled = from_1(durationSelector(value)).subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: endThrottling,
+      complete: cleanupThrottling
+    }));
+
+    const send = () => {
+      if (tsplus_module_17.isJust(sendValue)) {
+        const {
+          value
+        } = sendValue;
+        sendValue = tsplus_module_16.nothing();
+        subscriber.next(value);
+        !isComplete && startThrottling(value);
+      }
+    };
+
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        sendValue = tsplus_module_16.just(value);
+        !(throttled && !throttled.closed) && (leading ? send() : startThrottling(value));
+      },
+      complete: () => {
+        isComplete = true;
+        !(trailing && tsplus_module_17.isJust(sendValue) && throttled && !throttled.closed) && subscriber.complete();
+      }
+    }));
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable throttleTime
+ */
+
+
+export function throttleTime_(fa, duration, scheduler = tsplus_module_6.asyncScheduler, config = defaultThrottleConfig) {
+  const duration$ = timer_1(duration, scheduler);
+  return throttle_1(fa, () => duration$, config);
+}
+export class TimeoutError extends Error {
+  constructor(info) {
+    super("Timeout has occurred");
+    this.info = info;
+    this.name = "TimeoutError";
+  }
+
+}
+export function timeout_(fa, config) {
+  const {
+    first,
+    each,
+    with: _with = timeoutError,
+    scheduler = tsplus_module_6.asyncScheduler,
+    meta = null
+  } = config;
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    // eslint-disable-next-line prefer-const
+    let originalSourceSubscription;
+    let timerSubscription;
+    let lastValue = tsplus_module_16.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_9.operatorSubscriber(subscriber, {
+      next: value => {
+        timerSubscription?.unsubscribe();
+        seen++;
+        lastValue = tsplus_module_16.just(value);
+        subscriber.next(value);
+        each > 0 && startTimer(each);
+      }
+    }, () => {
+      if (!timerSubscription?.closed) {
+        timerSubscription?.unsubscribe();
+      }
+
+      lastValue = tsplus_module_16.nothing();
+    }));
+    startTimer(first != null ? typeof first === "number" ? first : +first - scheduler.now() : each);
+  });
+}
+
+function timeoutError(info) {
+  return fail_1(new TimeoutError(info));
+}
+
+function toArrayAccumulator(arr, value) {
+  return arr.push(value), arr;
+}
+/**
+ * @tsplus getter fncts.observable.Observable toArray
+ */
+
+
+function toArray_1(fa) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    foldLeft_1(source, [], toArrayAccumulator).subscribe(subscriber);
+  });
+}
+/**
+ * @tsplus fluent fncts.observable.Observable unique
+ */
+
+
+export function unique_(fa, toKey, flushes) {
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let distinctKeys = tsplus_module_20.makeDefault();
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        const key = toKey ? toKey(value) : value;
+
+        if (!tsplus_module_20.has_(distinctKeys, key)) {
+          tsplus_module_20.add_(distinctKeys, key);
+          subscriber.next(value);
+        }
+      }
+    }));
+    flushes?.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: () => distinctKeys = tsplus_module_20.makeDefault(),
+      complete: tsplus_module_3.noop
+    }));
+  });
+}
+
+function uniqueUntilChanged_1(fa, E, keySelector = tsplus_module_13.identity) {
+  const compare = "equals" in E ? E.equals : E;
+  return tsplus_module_9.operate_(fa, (source, subscriber) => {
+    let previousKey;
+    let first = true;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        const currentKey = keySelector(value);
+
+        if (first || !compare(previousKey, currentKey)) {
+          first = false;
+          previousKey = currentKey;
+          subscriber.next(value);
+        }
+      }
+    }));
+  });
+}
+
+export function uniqueUntilKeyChanged_(fa, key, equals) {
+  const compare = "equals" in equals ? equals.equals : equals;
+  return uniqueUntilChanged_1(fa, (x, y) => compare(x[key], y[key]));
+}
+/*
+ * -------------------------------------------------------------------------------------------------
+ * internal
+ * -------------------------------------------------------------------------------------------------
+ */
+
+function combineLatestInternal(subscriber, observables, scheduler, valueTransform = tsplus_module_13.identity) {
+  return maybeSchedule(subscriber, scheduler, () => {
+    const {
+      length
+    } = observables;
+    const values = new Array(length);
+    let active = length;
+    let remainingFirstValues = length;
+
+    for (let i = 0; i < length; i++) {
+      maybeSchedule(subscriber, scheduler, () => {
+        const source = scheduler ? scheduled_1(observables[i], scheduler) : from_1(observables[i]);
+        let hasFirstValue = false;
+        source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+          next: value => {
+            values[i] = value;
+
+            if (!hasFirstValue) {
+              hasFirstValue = true;
+              remainingFirstValues--;
+            }
+
+            if (!remainingFirstValues) {
+              subscriber.next(valueTransform(values.slice()));
+            }
+          },
+          complete: () => {
+            if (! --active) {
+              subscriber.complete();
+            }
+          }
+        }));
+      });
+    }
+  });
+}
+
+function findInternal(predicate, emit) {
+  const findIndex = emit === "index";
+  return (source, subscriber) => {
+    let index = 0;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        const i = index++;
+
+        if (predicate(index++, value)) {
+          subscriber.next(findIndex ? i : tsplus_module_16.just(value));
+          subscriber.complete();
+        }
+      },
+      complete: () => {
+        subscriber.next(findIndex ? -1 : tsplus_module_16.nothing());
+        subscriber.complete();
+      }
+    }));
+  };
+}
+
+export function joinAllInternal(fa, joiner) {
+  return mergeMap_1(toArray_1(fa), joiner);
+}
+
+function maybeSchedule(subscription, scheduler, execute) {
+  if (scheduler) {
+    subscription.add(scheduler.schedule(execute));
+  } else {
+    execute();
+  }
+}
+
+function mergeInternal(source, subscriber, f, concurrent, onBeforeNext, expand, innerSubScheduler, additionalTeardown) {
+  const buffer = [];
+  let active = 0;
+  let index = 0;
+  let isComplete = false;
+
+  const checkComplete = () => {
+    if (isComplete && !buffer.length && !active) {
+      subscriber.complete();
+    }
+  };
+
+  const outerNext = a => active < concurrent ? doInnerSub(a) : buffer.push(a);
+
+  const doInnerSub = a => {
+    expand && subscriber.next(a);
+    active++;
+    let innerComplete = false;
+    from_1(f(index++, a)).subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+      next: b => {
+        onBeforeNext?.(b);
+
+        if (expand) {
+          outerNext(b);
+        } else {
+          subscriber.next(b);
+        }
+      },
+      complete: () => {
+        innerComplete = true;
+      }
+    }, () => {
+      if (innerComplete) {
+        try {
+          active--;
+
+          while (buffer.length && active < concurrent) {
+            const bufferedValue = buffer.shift();
+            innerSubScheduler ? subscriber.add(innerSubScheduler.schedule(() => doInnerSub(bufferedValue))) : doInnerSub(bufferedValue);
+          }
+
+          checkComplete();
+        } catch (err) {
+          subscriber.error(tsplus_module_2.halt(err));
+        }
+      }
+    }));
+  };
+
+  source.subscribe(new tsplus_module_9.OperatorSubscriber(subscriber, {
+    next: outerNext,
+    complete: () => {
+      isComplete = true;
+      checkComplete();
+    }
+  }));
+  return () => {
+    additionalTeardown?.();
+  };
+}
+
+export function scanInternal(f, initial, hasInitial, emitOnNext, emitBeforeComplete) {
+  return (source, subscriber) => {
+    let hasState = hasInitial;
+    let state = initial;
+    let index = 0;
+    source.subscribe(tsplus_module_9.operatorSubscriber(subscriber, {
+      next: value => {
+        const i = index++;
+        state = hasState ? f(i, state, value) : (hasState = true, value);
+        emitOnNext && subscriber.next(state);
+      },
+      complete: emitBeforeComplete && (() => {
+        hasState && subscriber.next(state);
+        subscriber.complete();
+      })
+    }));
+  };
+}
+//# sourceMappingURL=api.mjs.map