appiq-solution 1.0.0

package/tools/installer/node_modules/rxjs/src/internal/operators/repeatWhen.ts

@@ -0,0 +1,125 @@
+import { Observable } from '../Observable';
+import { innerFrom } from '../observable/innerFrom';
+import { Subject } from '../Subject';
+import { Subscription } from '../Subscription';
+
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/**
+ * Returns an Observable that mirrors the source Observable with the exception of a `complete`. If the source
+ * Observable calls `complete`, this method will emit to the Observable returned from `notifier`. If that Observable
+ * calls `complete` or `error`, then this method will call `complete` or `error` on the child subscription. Otherwise
+ * this method will resubscribe to the source Observable.
+ *
+ * ![](repeatWhen.png)
+ *
+ * ## Example
+ *
+ * Repeat a message stream on click
+ *
+ * ```ts
+ * import { of, fromEvent, repeatWhen } from 'rxjs';
+ *
+ * const source = of('Repeat message');
+ * const documentClick$ = fromEvent(document, 'click');
+ *
+ * const result = source.pipe(repeatWhen(() => documentClick$));
+ *
+ * result.subscribe(data => console.log(data))
+ * ```
+ *
+ * @see {@link repeat}
+ * @see {@link retry}
+ * @see {@link retryWhen}
+ *
+ * @param notifier Function that receives an Observable of notifications with
+ * which a user can `complete` or `error`, aborting the repetition.
+ * @return A function that returns an Observable that mirrors the source
+ * Observable with the exception of a `complete`.
+ * @deprecated Will be removed in v9 or v10. Use {@link repeat}'s {@link RepeatConfig#delay delay} option instead.
+ * Instead of `repeatWhen(() => notify$)`, use: `repeat({ delay: () => notify$ })`.
+ */
+export function repeatWhen<T>(notifier: (notifications: Observable<void>) => ObservableInput<any>): MonoTypeOperatorFunction<T> {
+  return operate((source, subscriber) => {
+    let innerSub: Subscription | null;
+    let syncResub = false;
+    let completions$: Subject<void>;
+    let isNotifierComplete = false;
+    let isMainComplete = false;
+
+    /**
+     * Checks to see if we can complete the result, completes it, and returns `true` if it was completed.
+     */
+    const checkComplete = () => isMainComplete && isNotifierComplete && (subscriber.complete(), true);
+    /**
+     * Gets the subject to send errors through. If it doesn't exist,
+     * we know we need to setup the notifier.
+     */
+    const getCompletionSubject = () => {
+      if (!completions$) {
+        completions$ = new Subject();
+
+        // If the call to `notifier` throws, it will be caught by the OperatorSubscriber
+        // In the main subscription -- in `subscribeForRepeatWhen`.
+        innerFrom(notifier(completions$)).subscribe(
+          createOperatorSubscriber(
+            subscriber,
+            () => {
+              if (innerSub) {
+                subscribeForRepeatWhen();
+              } else {
+                // If we don't have an innerSub yet, that's because the inner subscription
+                // call hasn't even returned yet. We've arrived here synchronously.
+                // So we flag that we want to resub, such that we can ensure finalization
+                // happens before we resubscribe.
+                syncResub = true;
+              }
+            },
+            () => {
+              isNotifierComplete = true;
+              checkComplete();
+            }
+          )
+        );
+      }
+      return completions$;
+    };
+
+    const subscribeForRepeatWhen = () => {
+      isMainComplete = false;
+
+      innerSub = source.subscribe(
+        createOperatorSubscriber(subscriber, undefined, () => {
+          isMainComplete = true;
+          // Check to see if we are complete, and complete if so.
+          // If we are not complete. Get the subject. This calls the `notifier` function.
+          // If that function fails, it will throw and `.next()` will not be reached on this
+          // line. The thrown error is caught by the _complete handler in this
+          // `OperatorSubscriber` and handled appropriately.
+          !checkComplete() && getCompletionSubject().next();
+        })
+      );
+
+      if (syncResub) {
+        // Ensure that the inner subscription is torn down before
+        // moving on to the next subscription in the synchronous case.
+        // If we don't do this here, all inner subscriptions will not be
+        // torn down until the entire observable is done.
+        innerSub.unsubscribe();
+        // It is important to null this out. Not only to free up memory, but
+        // to make sure code above knows we are in a subscribing state to
+        // handle synchronous resubscription.
+        innerSub = null;
+        // We may need to do this multiple times, so reset the flags.
+        syncResub = false;
+        // Resubscribe
+        subscribeForRepeatWhen();
+      }
+    };
+
+    // Start the subscription
+    subscribeForRepeatWhen();
+  });
+}

package/tools/installer/node_modules/rxjs/src/internal/operators/retry.ts

@@ -0,0 +1,168 @@
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+import { operate } from '../util/lift';
+import { Subscription } from '../Subscription';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+import { identity } from '../util/identity';
+import { timer } from '../observable/timer';
+import { innerFrom } from '../observable/innerFrom';
+
+/**
+ * The {@link retry} operator configuration object. `retry` either accepts a `number`
+ * or an object described by this interface.
+ */
+export interface RetryConfig {
+  /**
+   * The maximum number of times to retry. If `count` is omitted, `retry` will try to
+   * resubscribe on errors infinite number of times.
+   */
+  count?: number;
+  /**
+   * The number of milliseconds to delay before retrying, OR a function to
+   * return a notifier for delaying. If a function is given, that function should
+   * return a notifier that, when it emits will retry the source. If the notifier
+   * completes _without_ emitting, the resulting observable will complete without error,
+   * if the notifier errors, the error will be pushed to the result.
+   */
+  delay?: number | ((error: any, retryCount: number) => ObservableInput<any>);
+  /**
+   * Whether or not to reset the retry counter when the retried subscription
+   * emits its first value.
+   */
+  resetOnSuccess?: boolean;
+}
+
+export function retry<T>(count?: number): MonoTypeOperatorFunction<T>;
+export function retry<T>(config: RetryConfig): MonoTypeOperatorFunction<T>;
+
+/**
+ * Returns an Observable that mirrors the source Observable with the exception of an `error`.
+ *
+ * If the source Observable calls `error`, this method will resubscribe to the source Observable for a maximum of
+ * `count` resubscriptions rather than propagating the `error` call.
+ *
+ * ![](retry.png)
+ *
+ * The number of retries is determined by the `count` parameter. It can be set either by passing a number to
+ * `retry` function or by setting `count` property when `retry` is configured using {@link RetryConfig}. If
+ * `count` is omitted, `retry` will try to resubscribe on errors infinite number of times.
+ *
+ * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those
+ * emitted during failed subscriptions. For example, if an Observable fails at first but emits `[1, 2]` then
+ * succeeds the second time and emits: `[1, 2, 3, 4, 5, complete]` then the complete stream of emissions and
+ * notifications would be: `[1, 2, 1, 2, 3, 4, 5, complete]`.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { interval, mergeMap, throwError, of, retry } from 'rxjs';
+ *
+ * const source = interval(1000);
+ * const result = source.pipe(
+ *   mergeMap(val => val > 5 ? throwError(() => 'Error!') : of(val)),
+ *   retry(2) // retry 2 times on error
+ * );
+ *
+ * result.subscribe({
+ *   next: value => console.log(value),
+ *   error: err => console.log(`${ err }: Retried 2 times then quit!`)
+ * });
+ *
+ * // Output:
+ * // 0..1..2..3..4..5..
+ * // 0..1..2..3..4..5..
+ * // 0..1..2..3..4..5..
+ * // 'Error!: Retried 2 times then quit!'
+ * ```
+ *
+ * @see {@link retryWhen}
+ *
+ * @param configOrCount Either number of retry attempts before failing or a
+ * {@link RetryConfig} object.
+ * @return A function that returns an Observable that will resubscribe to the
+ * source stream when the source stream errors, at most `count` times.
+ */
+export function retry<T>(configOrCount: number | RetryConfig = Infinity): MonoTypeOperatorFunction<T> {
+  let config: RetryConfig;
+  if (configOrCount && typeof configOrCount === 'object') {
+    config = configOrCount;
+  } else {
+    config = {
+      count: configOrCount as number,
+    };
+  }
+  const { count = Infinity, delay, resetOnSuccess: resetOnSuccess = false } = config;
+
+  return count <= 0
+    ? identity
+    : operate((source, subscriber) => {
+        let soFar = 0;
+        let innerSub: Subscription | null;
+        const subscribeForRetry = () => {
+          let syncUnsub = false;
+          innerSub = source.subscribe(
+            createOperatorSubscriber(
+              subscriber,
+              (value) => {
+                // If we're resetting on success
+                if (resetOnSuccess) {
+                  soFar = 0;
+                }
+                subscriber.next(value);
+              },
+              // Completions are passed through to consumer.
+              undefined,
+              (err) => {
+                if (soFar++ < count) {
+                  // We are still under our retry count
+                  const resub = () => {
+                    if (innerSub) {
+                      innerSub.unsubscribe();
+                      innerSub = null;
+                      subscribeForRetry();
+                    } else {
+                      syncUnsub = true;
+                    }
+                  };
+
+                  if (delay != null) {
+                    // The user specified a retry delay.
+                    // They gave us a number, use a timer, otherwise, it's a function,
+                    // and we're going to call it to get a notifier.
+                    const notifier = typeof delay === 'number' ? timer(delay) : innerFrom(delay(err, soFar));
+                    const notifierSubscriber = createOperatorSubscriber(
+                      subscriber,
+                      () => {
+                        // After we get the first notification, we
+                        // unsubscribe from the notifier, because we don't want anymore
+                        // and we resubscribe to the source.
+                        notifierSubscriber.unsubscribe();
+                        resub();
+                      },
+                      () => {
+                        // The notifier completed without emitting.
+                        // The author is telling us they want to complete.
+                        subscriber.complete();
+                      }
+                    );
+                    notifier.subscribe(notifierSubscriber);
+                  } else {
+                    // There was no notifier given. Just resub immediately.
+                    resub();
+                  }
+                } else {
+                  // We're past our maximum number of retries.
+                  // Just send along the error.
+                  subscriber.error(err);
+                }
+              }
+            )
+          );
+          if (syncUnsub) {
+            innerSub.unsubscribe();
+            innerSub = null;
+            subscribeForRetry();
+          }
+        };
+        subscribeForRetry();
+      });
+}

package/tools/installer/node_modules/rxjs/src/internal/operators/retryWhen.ts

@@ -0,0 +1,113 @@
+import { Observable } from '../Observable';
+import { innerFrom } from '../observable/innerFrom';
+import { Subject } from '../Subject';
+import { Subscription } from '../Subscription';
+
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/**
+ * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable
+ * calls `error`, this method will emit the Throwable that caused the error to the `ObservableInput` returned from `notifier`.
+ * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child
+ * subscription. Otherwise this method will resubscribe to the source Observable.
+ *
+ * ![](retryWhen.png)
+ *
+ * Retry an observable sequence on error based on custom criteria.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { interval, map, retryWhen, tap, delayWhen, timer } from 'rxjs';
+ *
+ * const source = interval(1000);
+ * const result = source.pipe(
+ *   map(value => {
+ *     if (value > 5) {
+ *       // error will be picked up by retryWhen
+ *       throw value;
+ *     }
+ *     return value;
+ *   }),
+ *   retryWhen(errors =>
+ *     errors.pipe(
+ *       // log error message
+ *       tap(value => console.log(`Value ${ value } was too high!`)),
+ *       // restart in 5 seconds
+ *       delayWhen(value => timer(value * 1000))
+ *     )
+ *   )
+ * );
+ *
+ * result.subscribe(value => console.log(value));
+ *
+ * // results:
+ * // 0
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * // 5
+ * // 'Value 6 was too high!'
+ * // - Wait 5 seconds then repeat
+ * ```
+ *
+ * @see {@link retry}
+ *
+ * @param notifier Function that receives an Observable of notifications with which a
+ * user can `complete` or `error`, aborting the retry.
+ * @return A function that returns an Observable that mirrors the source
+ * Observable with the exception of an `error`.
+ * @deprecated Will be removed in v9 or v10, use {@link retry}'s `delay` option instead.
+ * Will be removed in v9 or v10. Use {@link retry}'s {@link RetryConfig#delay delay} option instead.
+ * Instead of `retryWhen(() => notify$)`, use: `retry({ delay: () => notify$ })`.
+ */
+export function retryWhen<T>(notifier: (errors: Observable<any>) => ObservableInput<any>): MonoTypeOperatorFunction<T> {
+  return operate((source, subscriber) => {
+    let innerSub: Subscription | null;
+    let syncResub = false;
+    let errors$: Subject<any>;
+
+    const subscribeForRetryWhen = () => {
+      innerSub = source.subscribe(
+        createOperatorSubscriber(subscriber, undefined, undefined, (err) => {
+          if (!errors$) {
+            errors$ = new Subject();
+            innerFrom(notifier(errors$)).subscribe(
+              createOperatorSubscriber(subscriber, () =>
+                // If we have an innerSub, this was an asynchronous call, kick off the retry.
+                // Otherwise, if we don't have an innerSub yet, that's because the inner subscription
+                // call hasn't even returned yet. We've arrived here synchronously.
+                // So we flag that we want to resub, such that we can ensure finalization
+                // happens before we resubscribe.
+                innerSub ? subscribeForRetryWhen() : (syncResub = true)
+              )
+            );
+          }
+          if (errors$) {
+            // We have set up the notifier without error.
+            errors$.next(err);
+          }
+        })
+      );
+
+      if (syncResub) {
+        // Ensure that the inner subscription is torn down before
+        // moving on to the next subscription in the synchronous case.
+        // If we don't do this here, all inner subscriptions will not be
+        // torn down until the entire observable is done.
+        innerSub.unsubscribe();
+        innerSub = null;
+        // We may need to do this multiple times, so reset the flag.
+        syncResub = false;
+        // Resubscribe
+        subscribeForRetryWhen();
+      }
+    };
+
+    // Start the subscription
+    subscribeForRetryWhen();
+  });
+}

package/tools/installer/node_modules/rxjs/src/internal/operators/sample.ts

@@ -0,0 +1,72 @@
+import { innerFrom } from '../observable/innerFrom';
+import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+import { operate } from '../util/lift';
+import { noop } from '../util/noop';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/**
+ * Emits the most recently emitted value from the source Observable whenever
+ * another Observable, the `notifier`, emits.
+ *
+ * <span class="informal">It's like {@link sampleTime}, but samples whenever
+ * the `notifier` `ObservableInput` emits something.</span>
+ *
+ * ![](sample.png)
+ *
+ * Whenever the `notifier` `ObservableInput` emits a value, `sample`
+ * looks at the source Observable and emits whichever value it has most recently
+ * emitted since the previous sampling, unless the source has not emitted
+ * anything since the previous sampling. The `notifier` is subscribed to as soon
+ * as the output Observable is subscribed.
+ *
+ * ## Example
+ *
+ * On every click, sample the most recent `seconds` timer
+ *
+ * ```ts
+ * import { fromEvent, interval, sample } from 'rxjs';
+ *
+ * const seconds = interval(1000);
+ * const clicks = fromEvent(document, 'click');
+ * const result = seconds.pipe(sample(clicks));
+ *
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link audit}
+ * @see {@link debounce}
+ * @see {@link sampleTime}
+ * @see {@link throttle}
+ *
+ * @param notifier The `ObservableInput` to use for sampling the
+ * source Observable.
+ * @return A function that returns an Observable that emits the results of
+ * sampling the values emitted by the source Observable whenever the notifier
+ * Observable emits value or completes.
+ */
+export function sample<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T> {
+  return operate((source, subscriber) => {
+    let hasValue = false;
+    let lastValue: T | null = null;
+    source.subscribe(
+      createOperatorSubscriber(subscriber, (value) => {
+        hasValue = true;
+        lastValue = value;
+      })
+    );
+    innerFrom(notifier).subscribe(
+      createOperatorSubscriber(
+        subscriber,
+        () => {
+          if (hasValue) {
+            hasValue = false;
+            const value = lastValue!;
+            lastValue = null;
+            subscriber.next(value);
+          }
+        },
+        noop
+      )
+    );
+  });
+}

package/tools/installer/node_modules/rxjs/src/internal/operators/sampleTime.ts

@@ -0,0 +1,51 @@
+import { asyncScheduler } from '../scheduler/async';
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+import { sample } from './sample';
+import { interval } from '../observable/interval';
+
+/**
+ * Emits the most recently emitted value from the source Observable within
+ * periodic time intervals.
+ *
+ * <span class="informal">Samples the source Observable at periodic time
+ * intervals, emitting what it samples.</span>
+ *
+ * ![](sampleTime.png)
+ *
+ * `sampleTime` periodically looks at the source Observable and emits whichever
+ * value it has most recently emitted since the previous sampling, unless the
+ * source has not emitted anything since the previous sampling. The sampling
+ * happens periodically in time every `period` milliseconds (or the time unit
+ * defined by the optional `scheduler` argument). The sampling starts as soon as
+ * the output Observable is subscribed.
+ *
+ * ## Example
+ *
+ * Every second, emit the most recent click at most once
+ *
+ * ```ts
+ * import { fromEvent, sampleTime } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(sampleTime(1000));
+ *
+ * result.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link auditTime}
+ * @see {@link debounceTime}
+ * @see {@link delay}
+ * @see {@link sample}
+ * @see {@link throttleTime}
+ *
+ * @param period The sampling period expressed in milliseconds or the time unit
+ * determined internally by the optional `scheduler`.
+ * @param scheduler The {@link SchedulerLike} to use for managing the timers
+ * that handle the sampling.
+ * @return A function that returns an Observable that emits the results of
+ * sampling the values emitted by the source Observable at the specified time
+ * interval.
+ */
+export function sampleTime<T>(period: number, scheduler: SchedulerLike = asyncScheduler): MonoTypeOperatorFunction<T> {
+  return sample(interval(period, scheduler));
+}

package/tools/installer/node_modules/rxjs/src/internal/operators/scan.ts

@@ -0,0 +1,95 @@
+import { OperatorFunction } from '../types';
+import { operate } from '../util/lift';
+import { scanInternals } from './scanInternals';
+
+export function scan<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>;
+export function scan<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
+export function scan<V, A, S>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
+
+// TODO: link to a "redux pattern" section in the guide (location TBD)
+
+/**
+ * Useful for encapsulating and managing state. Applies an accumulator (or "reducer function")
+ * to each value from the source after an initial state is established -- either via
+ * a `seed` value (second argument), or from the first value from the source.
+ *
+ * <span class="informal">It's like {@link reduce}, but emits the current
+ * accumulation state after each update</span>
+ *
+ * ![](scan.png)
+ *
+ * This operator maintains an internal state and emits it after processing each value as follows:
+ *
+ * 1. First value arrives
+ *   - If a `seed` value was supplied (as the second argument to `scan`), let `state = seed` and `value = firstValue`.
+ *   - If NO `seed` value was supplied (no second argument), let `state = firstValue` and go to 3.
+ * 2. Let `state = accumulator(state, value)`.
+ *   - If an error is thrown by `accumulator`, notify the consumer of an error. The process ends.
+ * 3. Emit `state`.
+ * 4. Next value arrives, let `value = nextValue`, go to 2.
+ *
+ * ## Examples
+ *
+ * An average of previous numbers. This example shows how
+ * not providing a `seed` can prime the stream with the
+ * first value from the source.
+ *
+ * ```ts
+ * import { of, scan, map } from 'rxjs';
+ *
+ * const numbers$ = of(1, 2, 3);
+ *
+ * numbers$
+ *   .pipe(
+ *     // Get the sum of the numbers coming in.
+ *     scan((total, n) => total + n),
+ *     // Get the average by dividing the sum by the total number
+ *     // received so far (which is 1 more than the zero-based index).
+ *     map((sum, index) => sum / (index + 1))
+ *   )
+ *   .subscribe(console.log);
+ * ```
+ *
+ * The Fibonacci sequence. This example shows how you can use
+ * a seed to prime accumulation process. Also... you know... Fibonacci.
+ * So important to like, computers and stuff that its whiteboarded
+ * in job interviews. Now you can show them the Rx version! (Please don't, haha)
+ *
+ * ```ts
+ * import { interval, scan, map, startWith } from 'rxjs';
+ *
+ * const firstTwoFibs = [0, 1];
+ * // An endless stream of Fibonacci numbers.
+ * const fibonacci$ = interval(1000).pipe(
+ *   // Scan to get the fibonacci numbers (after 0, 1)
+ *   scan(([a, b]) => [b, a + b], firstTwoFibs),
+ *   // Get the second number in the tuple, it's the one you calculated
+ *   map(([, n]) => n),
+ *   // Start with our first two digits :)
+ *   startWith(...firstTwoFibs)
+ * );
+ *
+ * fibonacci$.subscribe(console.log);
+ * ```
+ *
+ * @see {@link expand}
+ * @see {@link mergeScan}
+ * @see {@link reduce}
+ * @see {@link switchScan}
+ *
+ * @param accumulator A "reducer function". This will be called for each value after an initial state is
+ * acquired.
+ * @param seed The initial state. If this is not provided, the first value from the source will
+ * be used as the initial state, and emitted without going through the accumulator. All subsequent values
+ * will be processed by the accumulator function. If this is provided, all values will go through
+ * the accumulator function.
+ * @return A function that returns an Observable of the accumulated values.
+ */
+export function scan<V, A, S>(accumulator: (acc: V | A | S, value: V, index: number) => A, seed?: S): OperatorFunction<V, V | A> {
+  // providing a seed of `undefined` *should* be valid and trigger
+  // hasSeed! so don't use `seed !== undefined` checks!
+  // For this reason, we have to check it here at the original call site
+  // otherwise inside Operator/Subscriber we won't know if `undefined`
+  // means they didn't provide anything or if they literally provided `undefined`
+  return operate(scanInternals(accumulator, seed as S, arguments.length >= 2, true));
+}

package/tools/installer/node_modules/rxjs/src/internal/operators/scanInternals.ts

@@ -0,0 +1,62 @@
+import { Observable } from '../Observable';
+import { Subscriber } from '../Subscriber';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/**
+ * A basic scan operation. This is used for `scan` and `reduce`.
+ * @param accumulator The accumulator to use
+ * @param seed The seed value for the state to accumulate
+ * @param hasSeed Whether or not a seed was provided
+ * @param emitOnNext Whether or not to emit the state on next
+ * @param emitBeforeComplete Whether or not to emit the before completion
+ */
+
+export function scanInternals<V, A, S>(
+  accumulator: (acc: V | A | S, value: V, index: number) => A,
+  seed: S,
+  hasSeed: boolean,
+  emitOnNext: boolean,
+  emitBeforeComplete?: undefined | true
+) {
+  return (source: Observable<V>, subscriber: Subscriber<any>) => {
+    // Whether or not we have state yet. This will only be
+    // false before the first value arrives if we didn't get
+    // a seed value.
+    let hasState = hasSeed;
+    // The state that we're tracking, starting with the seed,
+    // if there is one, and then updated by the return value
+    // from the accumulator on each emission.
+    let state: any = seed;
+    // An index to pass to the accumulator function.
+    let index = 0;
+
+    // Subscribe to our source. All errors and completions are passed through.
+    source.subscribe(
+      createOperatorSubscriber(
+        subscriber,
+        (value) => {
+          // Always increment the index.
+          const i = index++;
+          // Set the state
+          state = hasState
+            ? // We already have state, so we can get the new state from the accumulator
+              accumulator(state, value, i)
+            : // We didn't have state yet, a seed value was not provided, so
+
+              // we set the state to the first value, and mark that we have state now
+              ((hasState = true), value);
+
+          // Maybe send it to the consumer.
+          emitOnNext && subscriber.next(state);
+        },
+        // If an onComplete was given, call it, otherwise
+        // just pass through the complete notification to the consumer.
+        emitBeforeComplete &&
+          (() => {
+            hasState && subscriber.next(state);
+            subscriber.complete();
+          })
+      )
+    );
+  };
+}