appiq-solution 1.0.0

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

@@ -0,0 +1,54 @@
+import { reduce } from './reduce';
+import { MonoTypeOperatorFunction } from '../types';
+import { isFunction } from '../util/isFunction';
+
+/**
+ * The `min` operator operates on an Observable that emits numbers (or items that
+ * can be compared with a provided function), and when source Observable completes
+ * it emits a single item: the item with the smallest value.
+ *
+ * ![](min.png)
+ *
+ * ## Examples
+ *
+ * Get the minimal value of a series of numbers
+ *
+ * ```ts
+ * import { of, min } from 'rxjs';
+ *
+ * of(5, 4, 7, 2, 8)
+ *   .pipe(min())
+ *   .subscribe(x => console.log(x));
+ *
+ * // Outputs
+ * // 2
+ * ```
+ *
+ * Use a comparer function to get the minimal item
+ *
+ * ```ts
+ * import { of, min } from 'rxjs';
+ *
+ * of(
+ *   { age: 7, name: 'Foo' },
+ *   { age: 5, name: 'Bar' },
+ *   { age: 9, name: 'Beer' }
+ * ).pipe(
+ *   min((a, b) => a.age < b.age ? -1 : 1)
+ * )
+ * .subscribe(x => console.log(x.name));
+ *
+ * // Outputs
+ * // 'Bar'
+ * ```
+ *
+ * @see {@link max}
+ *
+ * @param comparer Optional comparer function that it will use instead of its
+ * default to compare the value of two items.
+ * @return A function that returns an Observable that emits item with the
+ * smallest value.
+ */
+export function min<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T> {
+  return reduce(isFunction(comparer) ? (x, y) => (comparer(x, y) < 0 ? x : y) : (x, y) => (x < y ? x : y));
+}

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

@@ -0,0 +1,98 @@
+import { Subject } from '../Subject';
+import { Observable } from '../Observable';
+import { ConnectableObservable } from '../observable/ConnectableObservable';
+import { OperatorFunction, UnaryFunction, ObservedValueOf, ObservableInput } from '../types';
+import { isFunction } from '../util/isFunction';
+import { connect } from './connect';
+
+/**
+ * An operator that creates a {@link ConnectableObservable}, that when connected,
+ * with the `connect` method, will use the provided subject to multicast the values
+ * from the source to all consumers.
+ *
+ * @param subject The subject to multicast through.
+ * @return A function that returns a {@link ConnectableObservable}
+ * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}.
+ * If you're using {@link refCount} after `multicast`, use the {@link share} operator instead.
+ * `multicast(subject), refCount()` is equivalent to
+ * `share({ connector: () => subject, resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export function multicast<T>(subject: Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
+
+/**
+ * Because this is deprecated in favor of the {@link connect} operator, and was otherwise poorly documented,
+ * rather than duplicate the effort of documenting the same behavior, please see documentation for the
+ * {@link connect} operator.
+ *
+ * @param subject The subject used to multicast.
+ * @param selector A setup function to setup the multicast
+ * @return A function that returns an observable that mirrors the observable returned by the selector.
+ * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
+ * `multicast(subject, selector)` is equivalent to
+ * `connect(selector, { connector: () => subject })`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export function multicast<T, O extends ObservableInput<any>>(
+  subject: Subject<T>,
+  selector: (shared: Observable<T>) => O
+): OperatorFunction<T, ObservedValueOf<O>>;
+
+/**
+ * An operator that creates a {@link ConnectableObservable}, that when connected,
+ * with the `connect` method, will use the provided subject to multicast the values
+ * from the source to all consumers.
+ *
+ * @param subjectFactory A factory that will be called to create the subject. Passing a function here
+ * will cause the underlying subject to be "reset" on error, completion, or refCounted unsubscription of
+ * the source.
+ * @return A function that returns a {@link ConnectableObservable}
+ * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}.
+ * If you're using {@link refCount} after `multicast`, use the {@link share} operator instead.
+ * `multicast(() => new BehaviorSubject('test')), refCount()` is equivalent to
+ * `share({ connector: () => new BehaviorSubject('test') })`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export function multicast<T>(subjectFactory: () => Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
+
+/**
+ * Because this is deprecated in favor of the {@link connect} operator, and was otherwise poorly documented,
+ * rather than duplicate the effort of documenting the same behavior, please see documentation for the
+ * {@link connect} operator.
+ *
+ * @param subjectFactory A factory that creates the subject used to multicast.
+ * @param selector A function to setup the multicast and select the output.
+ * @return A function that returns an observable that mirrors the observable returned by the selector.
+ * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
+ * `multicast(subjectFactory, selector)` is equivalent to
+ * `connect(selector, { connector: subjectFactory })`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export function multicast<T, O extends ObservableInput<any>>(
+  subjectFactory: () => Subject<T>,
+  selector: (shared: Observable<T>) => O
+): OperatorFunction<T, ObservedValueOf<O>>;
+
+/**
+ * @deprecated Will be removed in v8. Use the {@link connectable} observable, the {@link connect} operator or the
+ * {@link share} operator instead. See the overloads below for equivalent replacement examples of this operator's
+ * behaviors.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export function multicast<T, R>(
+  subjectOrSubjectFactory: Subject<T> | (() => Subject<T>),
+  selector?: (source: Observable<T>) => Observable<R>
+): OperatorFunction<T, R> {
+  const subjectFactory = isFunction(subjectOrSubjectFactory) ? subjectOrSubjectFactory : () => subjectOrSubjectFactory;
+
+  if (isFunction(selector)) {
+    // If a selector function is provided, then we're a "normal" operator that isn't
+    // going to return a ConnectableObservable. We can use `connect` to do what we
+    // need to do.
+    return connect(selector, {
+      connector: subjectFactory,
+    });
+  }
+
+  return (source: Observable<T>) => new ConnectableObservable<any>(source, subjectFactory);
+}

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

@@ -0,0 +1,70 @@
+/** @prettier */
+import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
+import { executeSchedule } from '../util/executeSchedule';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/**
+ * Re-emits all notifications from source Observable with specified scheduler.
+ *
+ * <span class="informal">Ensure a specific scheduler is used, from outside of an Observable.</span>
+ *
+ * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule
+ * notifications emitted by the source Observable. It might be useful, if you do not have control over
+ * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless.
+ *
+ * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable,
+ * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal
+ * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits
+ * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`.
+ * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split
+ * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source
+ * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a
+ * little bit more, to ensure that they are emitted at expected moments.
+ *
+ * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications
+ * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn`
+ * will delay all notifications - including error notifications - while `delay` will pass through error
+ * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator
+ * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used
+ * for notification emissions in general.
+ *
+ * ## Example
+ *
+ * Ensure values in subscribe are called just before browser repaint
+ *
+ * ```ts
+ * import { interval, observeOn, animationFrameScheduler } from 'rxjs';
+ *
+ * const someDiv = document.createElement('div');
+ * someDiv.style.cssText = 'width: 200px;background: #09c';
+ * document.body.appendChild(someDiv);
+ * const intervals = interval(10);      // Intervals are scheduled
+ *                                      // with async scheduler by default...
+ * intervals.pipe(
+ *   observeOn(animationFrameScheduler) // ...but we will observe on animationFrame
+ * )                                    // scheduler to ensure smooth animation.
+ * .subscribe(val => {
+ *   someDiv.style.height = val + 'px';
+ * });
+ * ```
+ *
+ * @see {@link delay}
+ *
+ * @param scheduler Scheduler that will be used to reschedule notifications from source Observable.
+ * @param delay Number of milliseconds that states with what delay every notification should be rescheduled.
+ * @return A function that returns an Observable that emits the same
+ * notifications as the source Observable, but with provided scheduler.
+ */
+export function observeOn<T>(scheduler: SchedulerLike, delay = 0): MonoTypeOperatorFunction<T> {
+  return operate((source, subscriber) => {
+    source.subscribe(
+      createOperatorSubscriber(
+        subscriber,
+        (value) => executeSchedule(subscriber, scheduler, () => subscriber.next(value), delay),
+        () => executeSchedule(subscriber, scheduler, () => subscriber.complete(), delay),
+        (err) => executeSchedule(subscriber, scheduler, () => subscriber.error(err), delay)
+      )
+    );
+  });
+}

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

@@ -0,0 +1,99 @@
+import { ObservableInputTuple, OperatorFunction } from '../types';
+import { argsOrArgArray } from '../util/argsOrArgArray';
+import { onErrorResumeNext as oERNCreate } from '../observable/onErrorResumeNext';
+
+export function onErrorResumeNextWith<T, A extends readonly unknown[]>(
+  sources: [...ObservableInputTuple<A>]
+): OperatorFunction<T, T | A[number]>;
+export function onErrorResumeNextWith<T, A extends readonly unknown[]>(
+  ...sources: [...ObservableInputTuple<A>]
+): OperatorFunction<T, T | A[number]>;
+
+/**
+ * When any of the provided Observable emits an complete or error notification, it immediately subscribes to the next one
+ * that was passed.
+ *
+ * <span class="informal">Execute series of Observables, subscribes to next one on error or complete.</span>
+ *
+ * ![](onErrorResumeNext.png)
+ *
+ * `onErrorResumeNext` is an operator that accepts a series of Observables, provided either directly as
+ * arguments or as an array. If no single Observable is provided, returned Observable will simply behave the same
+ * as the source.
+ *
+ * `onErrorResumeNext` returns an Observable that starts by subscribing and re-emitting values from the source Observable.
+ * When its stream of values ends - no matter if Observable completed or emitted an error - `onErrorResumeNext`
+ * will subscribe to the first Observable that was passed as an argument to the method. It will start re-emitting
+ * its values as well and - again - when that stream ends, `onErrorResumeNext` will proceed to subscribing yet another
+ * Observable in provided series, no matter if previous Observable completed or ended with an error. This will
+ * be happening until there is no more Observables left in the series, at which point returned Observable will
+ * complete - even if the last subscribed stream ended with an error.
+ *
+ * `onErrorResumeNext` can be therefore thought of as version of {@link concat} operator, which is more permissive
+ * when it comes to the errors emitted by its input Observables. While `concat` subscribes to the next Observable
+ * in series only if previous one successfully completed, `onErrorResumeNext` subscribes even if it ended with
+ * an error.
+ *
+ * Note that you do not get any access to errors emitted by the Observables. In particular do not
+ * expect these errors to appear in error callback passed to {@link Observable#subscribe}. If you want to take
+ * specific actions based on what error was emitted by an Observable, you should try out {@link catchError} instead.
+ *
+ *
+ * ## Example
+ *
+ * Subscribe to the next Observable after map fails
+ *
+ * ```ts
+ * import { of, onErrorResumeNext, map } from 'rxjs';
+ *
+ * of(1, 2, 3, 0)
+ *   .pipe(
+ *     map(x => {
+ *       if (x === 0) {
+ *         throw Error();
+ *       }
+ *
+ *       return 10 / x;
+ *     }),
+ *     onErrorResumeNext(of(1, 2, 3))
+ *   )
+ *   .subscribe({
+ *     next: val => console.log(val),
+ *     error: err => console.log(err),          // Will never be called.
+ *     complete: () => console.log('that\'s it!')
+ *   });
+ *
+ * // Logs:
+ * // 10
+ * // 5
+ * // 3.3333333333333335
+ * // 1
+ * // 2
+ * // 3
+ * // 'that's it!'
+ * ```
+ *
+ * @see {@link concat}
+ * @see {@link catchError}
+ *
+ * @param sources `ObservableInput`s passed either directly or as an array.
+ * @return A function that returns an Observable that emits values from source
+ * Observable, but - if it errors - subscribes to the next passed Observable
+ * and so on, until it completes or runs out of Observables.
+ */
+export function onErrorResumeNextWith<T, A extends readonly unknown[]>(
+  ...sources: [[...ObservableInputTuple<A>]] | [...ObservableInputTuple<A>]
+): OperatorFunction<T, T | A[number]> {
+  // For some reason, TS 4.1 RC gets the inference wrong here and infers the
+  // result to be `A[number][]` - completely dropping the ObservableInput part
+  // of the type. This makes no sense whatsoever. As a workaround, the type is
+  // asserted explicitly.
+  const nextSources = argsOrArgArray(sources) as unknown as ObservableInputTuple<A>;
+
+  return (source) => oERNCreate(source, ...nextSources);
+}
+
+/**
+ * @deprecated Renamed. Use {@link onErrorResumeNextWith} instead. Will be removed in v8.
+ */
+export const onErrorResumeNext = onErrorResumeNextWith;

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

@@ -0,0 +1,61 @@
+import { OperatorFunction } from '../types';
+import { operate } from '../util/lift';
+import { createOperatorSubscriber } from './OperatorSubscriber';
+
+/**
+ * Groups pairs of consecutive emissions together and emits them as an array of
+ * two values.
+ *
+ * <span class="informal">Puts the current value and previous value together as
+ * an array, and emits that.</span>
+ *
+ * ![](pairwise.png)
+ *
+ * The Nth emission from the source Observable will cause the output Observable
+ * to emit an array [(N-1)th, Nth] of the previous and the current value, as a
+ * pair. For this reason, `pairwise` emits on the second and subsequent
+ * emissions from the source Observable, but not on the first emission, because
+ * there is no previous value in that case.
+ *
+ * ## Example
+ *
+ * On every click (starting from the second), emit the relative distance to the previous click
+ *
+ * ```ts
+ * import { fromEvent, pairwise, map } from 'rxjs';
+ *
+ * const clicks = fromEvent<PointerEvent>(document, 'click');
+ * const pairs = clicks.pipe(pairwise());
+ * const distance = pairs.pipe(
+ *   map(([first, second]) => {
+ *     const x0 = first.clientX;
+ *     const y0 = first.clientY;
+ *     const x1 = second.clientX;
+ *     const y1 = second.clientY;
+ *     return Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));
+ *   })
+ * );
+ *
+ * distance.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link buffer}
+ * @see {@link bufferCount}
+ *
+ * @return A function that returns an Observable of pairs (as arrays) of
+ * consecutive values from the source Observable.
+ */
+export function pairwise<T>(): OperatorFunction<T, [T, T]> {
+  return operate((source, subscriber) => {
+    let prev: T;
+    let hasPrev = false;
+    source.subscribe(
+      createOperatorSubscriber(subscriber, (value) => {
+        const p = prev;
+        prev = value;
+        hasPrev && subscriber.next([p, value]);
+        hasPrev = true;
+      })
+    );
+  });
+}

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

@@ -0,0 +1,62 @@
+import { not } from '../util/not';
+import { filter } from './filter';
+import { Observable } from '../Observable';
+import { UnaryFunction } from '../types';
+
+/**
+ * Splits the source Observable into two, one with values that satisfy a
+ * predicate, and another with values that don't satisfy the predicate.
+ *
+ * <span class="informal">It's like {@link filter}, but returns two Observables:
+ * one like the output of {@link filter}, and the other with values that did not
+ * pass the condition.</span>
+ *
+ * ![](partition.png)
+ *
+ * `partition` outputs an array with two Observables that partition the values
+ * from the source Observable through the given `predicate` function. The first
+ * Observable in that array emits source values for which the predicate argument
+ * returns true. The second Observable emits source values for which the
+ * predicate returns false. The first behaves like {@link filter} and the second
+ * behaves like {@link filter} with the predicate negated.
+ *
+ * ## Example
+ *
+ * Partition click events into those on DIV elements and those elsewhere
+ *
+ * ```ts
+ * import { fromEvent } from 'rxjs';
+ * import { partition } from 'rxjs/operators';
+ *
+ * const div = document.createElement('div');
+ * div.style.cssText = 'width: 200px; height: 200px; background: #09c;';
+ * document.body.appendChild(div);
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const [clicksOnDivs, clicksElsewhere] = clicks.pipe(partition(ev => (<HTMLElement>ev.target).tagName === 'DIV'));
+ *
+ * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));
+ * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));
+ * ```
+ *
+ * @see {@link filter}
+ *
+ * @param predicate A function that evaluates each value emitted by the source
+ * Observable. If it returns `true`, the value is emitted on the first Observable
+ * in the returned array, if `false` the value is emitted on the second Observable
+ * in the array. The `index` parameter is the number `i` for the i-th source
+ * emission that has happened since the subscription, starting from the number `0`.
+ * @param thisArg An optional argument to determine the value of `this` in the
+ * `predicate` function.
+ * @return A function that returns an array with two Observables: one with
+ * values that passed the predicate, and another with values that did not pass
+ * the predicate.
+ * @deprecated Replaced with the {@link partition} static creation function. Will be removed in v8.
+ */
+export function partition<T>(
+  predicate: (value: T, index: number) => boolean,
+  thisArg?: any
+): UnaryFunction<Observable<T>, [Observable<T>, Observable<T>]> {
+  return (source: Observable<T>) =>
+    [filter(predicate, thisArg)(source), filter(not(predicate, thisArg))(source)] as [Observable<T>, Observable<T>];
+}

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

@@ -0,0 +1,106 @@
+import { map } from './map';
+import { OperatorFunction } from '../types';
+
+/* tslint:disable:max-line-length */
+/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
+export function pluck<T, K1 extends keyof T>(k1: K1): OperatorFunction<T, T[K1]>;
+/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
+export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1]>(k1: K1, k2: K2): OperatorFunction<T, T[K1][K2]>;
+/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
+export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(
+  k1: K1,
+  k2: K2,
+  k3: K3
+): OperatorFunction<T, T[K1][K2][K3]>;
+/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
+export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>(
+  k1: K1,
+  k2: K2,
+  k3: K3,
+  k4: K4
+): OperatorFunction<T, T[K1][K2][K3][K4]>;
+/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
+export function pluck<
+  T,
+  K1 extends keyof T,
+  K2 extends keyof T[K1],
+  K3 extends keyof T[K1][K2],
+  K4 extends keyof T[K1][K2][K3],
+  K5 extends keyof T[K1][K2][K3][K4]
+>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): OperatorFunction<T, T[K1][K2][K3][K4][K5]>;
+/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
+export function pluck<
+  T,
+  K1 extends keyof T,
+  K2 extends keyof T[K1],
+  K3 extends keyof T[K1][K2],
+  K4 extends keyof T[K1][K2][K3],
+  K5 extends keyof T[K1][K2][K3][K4],
+  K6 extends keyof T[K1][K2][K3][K4][K5]
+>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): OperatorFunction<T, T[K1][K2][K3][K4][K5][K6]>;
+/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
+export function pluck<
+  T,
+  K1 extends keyof T,
+  K2 extends keyof T[K1],
+  K3 extends keyof T[K1][K2],
+  K4 extends keyof T[K1][K2][K3],
+  K5 extends keyof T[K1][K2][K3][K4],
+  K6 extends keyof T[K1][K2][K3][K4][K5]
+>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6, ...rest: string[]): OperatorFunction<T, unknown>;
+/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */
+export function pluck<T>(...properties: string[]): OperatorFunction<T, unknown>;
+/* tslint:enable:max-line-length */
+
+/**
+ * Maps each source value to its specified nested property.
+ *
+ * <span class="informal">Like {@link map}, but meant only for picking one of
+ * the nested properties of every emitted value.</span>
+ *
+ * ![](pluck.png)
+ *
+ * Given a list of strings or numbers describing a path to a property, retrieves
+ * the value of a specified nested property from all values in the source
+ * Observable. If a property can't be resolved, it will return `undefined` for
+ * that value.
+ *
+ * ## Example
+ *
+ * Map every click to the tagName of the clicked target element
+ *
+ * ```ts
+ * import { fromEvent, pluck } from 'rxjs';
+ *
+ * const clicks = fromEvent(document, 'click');
+ * const tagNames = clicks.pipe(pluck('target', 'tagName'));
+ *
+ * tagNames.subscribe(x => console.log(x));
+ * ```
+ *
+ * @see {@link map}
+ *
+ * @param properties The nested properties to pluck from each source
+ * value.
+ * @return A function that returns an Observable of property values from the
+ * source values.
+ * @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8.
+ */
+export function pluck<T, R>(...properties: Array<string | number | symbol>): OperatorFunction<T, R> {
+  const length = properties.length;
+  if (length === 0) {
+    throw new Error('list of properties cannot be empty.');
+  }
+  return map((x) => {
+    let currentProp: any = x;
+    for (let i = 0; i < length; i++) {
+      const p = currentProp?.[properties[i]];
+      if (typeof p !== 'undefined') {
+        currentProp = p;
+      } else {
+        return undefined;
+      }
+    }
+    return currentProp;
+  });
+}

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

@@ -0,0 +1,93 @@
+import { Observable } from '../Observable';
+import { Subject } from '../Subject';
+import { multicast } from './multicast';
+import { ConnectableObservable } from '../observable/ConnectableObservable';
+import { MonoTypeOperatorFunction, OperatorFunction, UnaryFunction, ObservableInput, ObservedValueOf } from '../types';
+import { connect } from './connect';
+
+/**
+ * Returns a connectable observable that, when connected, will multicast
+ * all values through a single underlying {@link Subject} instance.
+ *
+ * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}.
+ * `source.pipe(publish())` is equivalent to
+ * `connectable(source, { connector: () => new Subject(), resetOnDisconnect: false })`.
+ * If you're using {@link refCount} after `publish`, use {@link share} operator instead.
+ * `source.pipe(publish(), refCount())` is equivalent to
+ * `source.pipe(share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }))`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export function publish<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
+
+/**
+ * Returns an observable, that when subscribed to, creates an underlying {@link Subject},
+ * provides an observable view of it to a `selector` function, takes the observable result of
+ * that selector function and subscribes to it, sending its values to the consumer, _then_ connects
+ * the subject to the original source.
+ *
+ * @param selector A function used to setup multicasting prior to automatic connection.
+ *
+ * @deprecated Will be removed in v8. Use the {@link connect} operator instead.
+ * `publish(selector)` is equivalent to `connect(selector)`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export function publish<T, O extends ObservableInput<any>>(selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>;
+
+/**
+ * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called
+ * before it begins emitting items to those Observers that have subscribed to it.
+ *
+ * <span class="informal">Makes a cold Observable hot</span>
+ *
+ * ![](publish.png)
+ *
+ * ## Examples
+ *
+ * Make `source$` hot by applying `publish` operator, then merge each inner observable into a single one
+ * and subscribe
+ *
+ * ```ts
+ * import { zip, interval, of, map, publish, merge, tap } from 'rxjs';
+ *
+ * const source$ = zip(interval(2000), of(1, 2, 3, 4, 5, 6, 7, 8, 9))
+ *   .pipe(map(([, number]) => number));
+ *
+ * source$
+ *   .pipe(
+ *     publish(multicasted$ =>
+ *       merge(
+ *         multicasted$.pipe(tap(x => console.log('Stream 1:', x))),
+ *         multicasted$.pipe(tap(x => console.log('Stream 2:', x))),
+ *         multicasted$.pipe(tap(x => console.log('Stream 3:', x)))
+ *       )
+ *     )
+ *   )
+ *   .subscribe();
+ *
+ * // Results every two seconds
+ * // Stream 1: 1
+ * // Stream 2: 1
+ * // Stream 3: 1
+ * // ...
+ * // Stream 1: 9
+ * // Stream 2: 9
+ * // Stream 3: 9
+ * ```
+ *
+ * @see {@link publishLast}
+ * @see {@link publishReplay}
+ * @see {@link publishBehavior}
+ *
+ * @param selector Optional selector function which can use the multicasted source sequence as many times
+ * as needed, without causing multiple subscriptions to the source sequence.
+ * Subscribers to the given source will receive all notifications of the source from the time of the subscription on.
+ * @return A function that returns a ConnectableObservable that upon connection
+ * causes the source Observable to emit items to its Observers.
+ * @deprecated Will be removed in v8. Use the {@link connectable} observable, the {@link connect} operator or the
+ * {@link share} operator instead. See the overloads below for equivalent replacement examples of this operator's
+ * behaviors.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export function publish<T, R>(selector?: OperatorFunction<T, R>): MonoTypeOperatorFunction<T> | OperatorFunction<T, R> {
+  return selector ? (source) => connect(selector)(source) : (source) => multicast(new Subject<T>())(source);
+}

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

@@ -0,0 +1,26 @@
+import { Observable } from '../Observable';
+import { BehaviorSubject } from '../BehaviorSubject';
+import { ConnectableObservable } from '../observable/ConnectableObservable';
+import { UnaryFunction } from '../types';
+
+/**
+ * Creates a {@link ConnectableObservable} that utilizes a {@link BehaviorSubject}.
+ *
+ * @param initialValue The initial value passed to the {@link BehaviorSubject}.
+ * @return A function that returns a {@link ConnectableObservable}
+ * @deprecated Will be removed in v8. To create a connectable observable that uses a
+ * {@link BehaviorSubject} under the hood, use {@link connectable}.
+ * `source.pipe(publishBehavior(initValue))` is equivalent to
+ * `connectable(source, { connector: () => new BehaviorSubject(initValue), resetOnDisconnect: false })`.
+ * If you're using {@link refCount} after `publishBehavior`, use the {@link share} operator instead.
+ * `source.pipe(publishBehavior(initValue), refCount())` is equivalent to
+ * `source.pipe(share({ connector: () => new BehaviorSubject(initValue), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false  }))`.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export function publishBehavior<T>(initialValue: T): UnaryFunction<Observable<T>, ConnectableObservable<T>> {
+  // Note that this has *never* supported the selector function.
+  return (source) => {
+    const subject = new BehaviorSubject<T>(initialValue);
+    return new ConnectableObservable(source, () => subject);
+  };
+}