From e4fa1e69e7ebfb627c7198fd1a9881e9327ec4d4 Mon Sep 17 00:00:00 2001
From: Pinapelz <yukais@pinapelz.com>
Date: Sat, 28 Jun 2025 17:26:46 -0700
Subject: initial commit: scaffolding

---
 .../rxjs/src/internal/operators/startWith.ts       | 67 ++++++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 node_modules/rxjs/src/internal/operators/startWith.ts

(limited to 'node_modules/rxjs/src/internal/operators/startWith.ts')

diff --git a/node_modules/rxjs/src/internal/operators/startWith.ts b/node_modules/rxjs/src/internal/operators/startWith.ts
new file mode 100644
index 0000000..8c11ddb
--- /dev/null
+++ b/node_modules/rxjs/src/internal/operators/startWith.ts
@@ -0,0 +1,67 @@
+import { concat } from '../observable/concat';
+import { OperatorFunction, SchedulerLike, ValueFromArray } from '../types';
+import { popScheduler } from '../util/args';
+import { operate } from '../util/lift';
+
+// Devs are more likely to pass null or undefined than they are a scheduler
+// without accompanying values. To make things easier for (naughty) devs who
+// use the `strictNullChecks: false` TypeScript compiler option, these
+// overloads with explicit null and undefined values are included.
+
+export function startWith<T>(value: null): OperatorFunction<T, T | null>;
+export function startWith<T>(value: undefined): OperatorFunction<T, T | undefined>;
+
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export function startWith<T, A extends readonly unknown[] = T[]>(
+  ...valuesAndScheduler: [...A, SchedulerLike]
+): OperatorFunction<T, T | ValueFromArray<A>>;
+export function startWith<T, A extends readonly unknown[] = T[]>(...values: A): OperatorFunction<T, T | ValueFromArray<A>>;
+
+/**
+ * Returns an observable that, at the moment of subscription, will synchronously emit all
+ * values provided to this operator, then subscribe to the source and mirror all of its emissions
+ * to subscribers.
+ *
+ * This is a useful way to know when subscription has occurred on an existing observable.
+ *
+ * <span class="informal">First emits its arguments in order, and then any
+ * emissions from the source.</span>
+ *
+ * ![](startWith.png)
+ *
+ * ## Examples
+ *
+ * Emit a value when a timer starts.
+ *
+ * ```ts
+ * import { timer, map, startWith } from 'rxjs';
+ *
+ * timer(1000)
+ *   .pipe(
+ *     map(() => 'timer emit'),
+ *     startWith('timer start')
+ *   )
+ *   .subscribe(x => console.log(x));
+ *
+ * // results:
+ * // 'timer start'
+ * // 'timer emit'
+ * ```
+ *
+ * @param values Items you want the modified Observable to emit first.
+ * @return A function that returns an Observable that synchronously emits
+ * provided values before subscribing to the source Observable.
+ *
+ * @see {@link endWith}
+ * @see {@link finalize}
+ * @see {@link concat}
+ */
+export function startWith<T, D>(...values: D[]): OperatorFunction<T, T | D> {
+  const scheduler = popScheduler(values);
+  return operate((source, subscriber) => {
+    // Here we can't pass `undefined` as a scheduler, because if we did, the
+    // code inside of `concat` would be confused by the `undefined`, and treat it
+    // like an invalid observable. So we have to split it two different ways.
+    (scheduler ? concat(values, source, scheduler) : concat(values, source)).subscribe(subscriber);
+  });
+}
-- 
cgit v1.2.3