synstate 0.1.2 → 1.0.0

package/dist/core/operators/take-until.mjs

@@ -29,25 +29,25 @@ import '../utils/id-maker.mjs';
  *
  * const limited$ = num$.pipe(takeUntil(stopNotifier));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * limited$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2]);
  *
  * stop_();
  *
  * num$.next(3); // nothing logged (completed)
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2]);
  * ```
  */
 const takeUntil = (notifier) => 
@@ -65,13 +65,13 @@ class TakeUntilObservableClass extends SyncChildObservableClass {
             this.complete();
         });
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
             return; // skip update
         }
-        this.setNext(sn.value, updaterSymbol);
+        this.setNext(sn.value, updateToken);
     }
 }
 

package/dist/core/operators/take-until.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"take-until.mjs","sources":["../../../src/core/operators/take-until.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;AACI,MAAM,SAAS,GAAG,CACvB,QAA6B;AAE7B;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,wBAAwB,CAC1B,gBAAgB,EAChB,QAAQ,CACT;AAEL,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;IAGjD,WAAA,CAAY,gBAA+B,EAAE,QAA6B,EAAA;AACxE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;AAEF,QAAA,QAAQ,CAAC,SAAS,CAChB,MAAK;YACH,IAAI,CAAC,QAAQ,EAAE;QACjB,CAAC,EACD,MAAK;YACH,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,CACF;IACH;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;QAEA,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;IACvC;AACD;;;;"}
+{"version":3,"file":"take-until.mjs","sources":["../../../src/core/operators/take-until.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;AACI,MAAM,SAAS,GAAG,CACvB,QAA6B;AAE7B;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,wBAAwB,CAC1B,gBAAgB,EAChB,QAAQ,CACT;AAEL,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;IAGjD,WAAA,CAAY,gBAA+B,EAAE,QAA6B,EAAA;AACxE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;AAEF,QAAA,QAAQ,CAAC,SAAS,CAChB,MAAK;YACH,IAAI,CAAC,QAAQ,EAAE;QACjB,CAAC,EACD,MAAK;YACH,IAAI,CAAC,QAAQ,EAAE;AACjB,QAAA,CAAC,CACF;IACH;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;QAEA,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;IACrC;AACD;;;;"}

package/dist/core/operators/take-while.d.mts

@@ -11,7 +11,7 @@ import { type DropInitialValueOperator } from '../types/index.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  num$      1     2     3     4     5     6 (ignored)
+ * //  num$      1     2     3     4     5     6     1     2 (ignored)
  * //  taken$    1     2     3     4     | (completes)
  * //
  * //  Explanation:
@@ -23,27 +23,35 @@ import { type DropInitialValueOperator } from '../types/index.mjs';
  *
  * const taken$ = num$.pipe(takeWhile((x) => x < 5));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * taken$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * num$.next(3); // logs: 3
+ *
+ * num$.next(4); // logs: 4
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  *
  * num$.next(5); // nothing logged (completes)
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  *
  * num$.next(6); // nothing logged (already completed)
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
+ *
+ * num$.next(1); // logs: 1
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  * ```
  */
 export declare const takeWhile: <A>(predicate: (value: A, index: SafeUint | -1) => boolean) => DropInitialValueOperator<A, A>;

package/dist/core/operators/take-while.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"take-while.d.mts","sourceRoot":"","sources":["../../../src/core/operators/take-while.mts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,wBAAwB,EAK9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EACA,WAAW,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,KACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAE2B,CAAC"}
+{"version":3,"file":"take-while.d.mts","sourceRoot":"","sources":["../../../src/core/operators/take-while.mts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,wBAAwB,EAK9B,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,SAAS,GACnB,CAAC,EACA,WAAW,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,OAAO,KACrD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAE2B,CAAC"}

package/dist/core/operators/take-while.mjs

@@ -14,7 +14,7 @@ import '../utils/id-maker.mjs';
  * ```ts
  * //  Timeline:
  * //
- * //  num$      1     2     3     4     5     6 (ignored)
+ * //  num$      1     2     3     4     5     6     1     2 (ignored)
  * //  taken$    1     2     3     4     | (completes)
  * //
  * //  Explanation:
@@ -26,27 +26,35 @@ import '../utils/id-maker.mjs';
  *
  * const taken$ = num$.pipe(takeWhile((x) => x < 5));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * taken$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [1]);
+ * assert.deepStrictEqual(valueHistory, [1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * num$.next(3); // logs: 3
+ *
+ * num$.next(4); // logs: 4
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  *
  * num$.next(5); // nothing logged (completes)
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  *
  * num$.next(6); // nothing logged (already completed)
  *
- * assert.deepStrictEqual(mut_history, [1, 2]);
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
+ *
+ * num$.next(1); // logs: 1
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3, 4]);
  * ```
  */
 const takeWhile = (predicate) => (parentObservable) => new TakeWhileObservableClass(parentObservable, predicate);
@@ -66,16 +74,16 @@ class TakeWhileObservableClass extends SyncChildObservableClass {
         this.#mut_index = -1;
         this.#predicate = predicate;
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
             return; // skip update
         }
         this.#mut_index =
             this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
         if (this.#predicate(sn.value, this.#mut_index)) {
-            this.setNext(sn.value, updaterSymbol);
+            this.setNext(sn.value, updateToken);
         }
         else {
             this.complete();

package/dist/core/operators/take-while.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"take-while.mjs","sources":["../../../src/core/operators/take-while.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,SAAS,GACpB,CACE,SAAsD,KAExD,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,SAAS;AAE5D;AAEA,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,UAAU;AACnB,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,SAAsD,EAAA;AAEtD,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KACzD,QAAQ,CAAC,MAAM,CAAC,GAAG;kBACf,QAAQ,CAAC;kBACT,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE;AACvB,sBAAE;AACF,sBAAE,QAAQ,CAAC,IAAI,CACpB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;;AAGpB,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;;AAGT,QAAA,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;AAE3E,QAAA,IAAI,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YAC9C,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;;aAChC;YACL,IAAI,CAAC,QAAQ,EAAE;;;AAGpB;;;;"}
+{"version":3,"file":"take-while.mjs","sources":["../../../src/core/operators/take-while.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDG;AACI,MAAM,SAAS,GACpB,CACE,SAAsD,KAExD,CAAC,gBAAgB,KACf,IAAI,wBAAwB,CAAC,gBAAgB,EAAE,SAAS;AAE5D;AAEA,MAAM,wBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,UAAU;AACnB,IAAA,UAAU;IAEV,WAAA,CACE,gBAA+B,EAC/B,SAAsD,EAAA;AAEtD,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KACzD,QAAQ,CAAC,MAAM,CAAC,GAAG;kBACf,QAAQ,CAAC;kBACT,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE;AACvB,sBAAE;AACF,sBAAE,QAAQ,CAAC,IAAI,CACpB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,UAAU,GAAG,EAAE;AAEpB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS;;AAGpB,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;;AAGT,QAAA,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;AAE3E,QAAA,IAAI,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YAC9C,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;;aAC9B;YACL,IAAI,CAAC,QAAQ,EAAE;;;AAGpB;;;;"}

package/dist/core/operators/throttle.d.mts

@@ -0,0 +1,81 @@
+import { type KeepInitialValueOperator } from '../types/index.mjs';
+/**
+ * Emits the first value, then ignores subsequent values for a specified duration.
+ * After the duration, the next emission is allowed through.
+ *
+ * @template A - The type of values from the source
+ * @param milliSeconds - The throttle duration in milliseconds
+ * @returns An operator that throttles emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline (250ms throttle):
+ * //
+ * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
+ * //
+ * //  input$       0       2   3                   9   10  11  12  13  14
+ * //               |- 250ms -> |- 250ms ->         |- 250ms ->    |- 250ms ->
+ * //  throttled$   0           3                   9          12           (emitted at start of window)
+ * //
+ * //  Explanation:
+ * //  - throttle emits the FIRST value received, then ignores subsequent values
+ * //    for the specified duration (250ms)
+ * //  - Unlike audit (which emits the LAST value), throttle emits the FIRST
+ * //  - Useful for rate-limiting scroll/resize events
+ *
+ * const input$ = source<number>();
+ *
+ * const throttled$ = input$.pipe(throttle(250));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * throttled$.subscribe((value) => {
+ *   valueHistory.push(value);
+ * });
+ *
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
+ *
+ * input$.next(0);
+ *
+ * assert.deepStrictEqual(valueHistory, [0]);
+ *
+ * await sleep(200);
+ *
+ * input$.next(2);
+ *
+ * assert.deepStrictEqual(valueHistory, [0]);
+ *
+ * await sleep(100);
+ *
+ * input$.next(3);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3]);
+ *
+ * await sleep(300);
+ *
+ * input$.next(9);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3, 9]);
+ *
+ * await sleep(100);
+ *
+ * input$.next(10);
+ *
+ * await sleep(100);
+ *
+ * input$.next(11);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3, 9]);
+ *
+ * await sleep(100);
+ *
+ * input$.next(12);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3, 9, 12]);
+ * ```
+ */
+export declare const throttle: <A>(milliSeconds: number) => KeepInitialValueOperator<A, A>;
+//# sourceMappingURL=throttle.d.mts.map

package/dist/core/operators/throttle.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.mts","sourceRoot":"","sources":["../../../src/core/operators/throttle.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAK9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,cAAc,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/throttle.mjs

@@ -0,0 +1,126 @@
+import { Optional } from 'ts-data-forge';
+import { SyncChildObservableClass } from '../class/child-observable-class.mjs';
+import '../utils/id-maker.mjs';
+
+/**
+ * Emits the first value, then ignores subsequent values for a specified duration.
+ * After the duration, the next emission is allowed through.
+ *
+ * @template A - The type of values from the source
+ * @param milliSeconds - The throttle duration in milliseconds
+ * @returns An operator that throttles emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline (250ms throttle):
+ * //
+ * //  Time(x50ms)  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
+ * //
+ * //  input$       0       2   3                   9   10  11  12  13  14
+ * //               |- 250ms -> |- 250ms ->         |- 250ms ->    |- 250ms ->
+ * //  throttled$   0           3                   9          12           (emitted at start of window)
+ * //
+ * //  Explanation:
+ * //  - throttle emits the FIRST value received, then ignores subsequent values
+ * //    for the specified duration (250ms)
+ * //  - Unlike audit (which emits the LAST value), throttle emits the FIRST
+ * //  - Useful for rate-limiting scroll/resize events
+ *
+ * const input$ = source<number>();
+ *
+ * const throttled$ = input$.pipe(throttle(250));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * throttled$.subscribe((value) => {
+ *   valueHistory.push(value);
+ * });
+ *
+ * const sleep = (ms: number): Promise<void> =>
+ *   new Promise((resolve) => {
+ *     setTimeout(resolve, ms);
+ *   });
+ *
+ * input$.next(0);
+ *
+ * assert.deepStrictEqual(valueHistory, [0]);
+ *
+ * await sleep(200);
+ *
+ * input$.next(2);
+ *
+ * assert.deepStrictEqual(valueHistory, [0]);
+ *
+ * await sleep(100);
+ *
+ * input$.next(3);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3]);
+ *
+ * await sleep(300);
+ *
+ * input$.next(9);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3, 9]);
+ *
+ * await sleep(100);
+ *
+ * input$.next(10);
+ *
+ * await sleep(100);
+ *
+ * input$.next(11);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3, 9]);
+ *
+ * await sleep(100);
+ *
+ * input$.next(12);
+ *
+ * assert.deepStrictEqual(valueHistory, [0, 3, 9, 12]);
+ * ```
+ */
+const throttle = (milliSeconds) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+((parentObservable) => new ThrottleObservableClass(parentObservable, milliSeconds));
+class ThrottleObservableClass extends SyncChildObservableClass {
+    #milliSeconds;
+    #mut_timerId;
+    #mut_isSkipping;
+    constructor(parentObservable, milliSeconds) {
+        super({
+            parents: [parentObservable],
+            initialValue: parentObservable.getSnapshot(),
+        });
+        this.#mut_timerId = undefined;
+        this.#mut_isSkipping = false;
+        this.#milliSeconds = milliSeconds;
+    }
+    tryUpdate(updateToken) {
+        const par = this.parents[0];
+        const sn = par.getSnapshot();
+        if (par.updateToken !== updateToken ||
+            Optional.isNone(sn) ||
+            this.#mut_isSkipping) {
+            return; // skip update
+        }
+        this.setNext(sn.value, updateToken);
+        this.#mut_isSkipping = true;
+        // set timer
+        this.#mut_timerId = setTimeout(() => {
+            this.#mut_isSkipping = false;
+        }, this.#milliSeconds);
+    }
+    #resetTimer() {
+        if (this.#mut_timerId !== undefined) {
+            clearTimeout(this.#mut_timerId);
+        }
+    }
+    complete() {
+        this.#resetTimer();
+        super.complete();
+    }
+}
+
+export { throttle };
+//# sourceMappingURL=throttle.mjs.map

package/dist/core/operators/throttle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.mjs","sources":["../../../src/core/operators/throttle.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EG;AACI,MAAM,QAAQ,GAAG,CACtB,YAAoB;AAEpB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,uBAAuB,CACzB,gBAAgB,EAChB,YAAY,CACb;AAEL,MAAM,uBACJ,SAAQ,wBAAyC,CAAA;AAGxC,IAAA,aAAa;AACtB,IAAA,YAAY;AACZ,IAAA,eAAe;IAEf,WAAA,CAAY,gBAA+B,EAAE,YAAoB,EAAA;AAC/D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;AAC7C,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,YAAY,GAAG,SAAS;AAE7B,QAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAE5B,QAAA,IAAI,CAAC,aAAa,GAAG,YAAY;IACnC;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IACE,GAAG,CAAC,WAAW,KAAK,WAAW;AAC/B,YAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACnB,IAAI,CAAC,eAAe,EACpB;AACA,YAAA,OAAO;QACT;QAEA,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;AAEnC,QAAA,IAAI,CAAC,eAAe,GAAG,IAAI;;AAG3B,QAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;AAClC,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK;AAC9B,QAAA,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;IACxB;IAEA,WAAW,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;AACnC,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC;QACjC;IACF;IAES,QAAQ,GAAA;QACf,IAAI,CAAC,WAAW,EAAE;QAElB,KAAK,CAAC,QAAQ,EAAE;IAClB;AACD;;;;"}

package/dist/core/operators/with-buffered-from.d.mts

@@ -28,27 +28,27 @@ import { type KeepInitialValueOperator, type Observable } from '../types/index.m
  *
  * const result$ = trigger$.pipe(withBufferedFrom(data$));
  *
- * const mut_history: (readonly [number, readonly string[]])[] = [];
+ * const valueHistory: (readonly [number, readonly string[]])[] = [];
  *
  * result$.subscribe(([triggerValue, bufferedData]) => {
- *   mut_history.push([triggerValue, bufferedData]);
+ *   valueHistory.push([triggerValue, bufferedData]);
  * });
  *
- * data$.next('a');
+ * data$.next('A');
  *
- * data$.next('b');
+ * data$.next('B');
  *
  * trigger$.next(1);
  *
- * assert.deepStrictEqual(mut_history, [[1, ['a', 'b']]]);
+ * assert.deepStrictEqual(valueHistory, [[1, ['A', 'B']]]);
  *
- * data$.next('c');
+ * data$.next('C');
  *
  * trigger$.next(2);
  *
- * assert.deepStrictEqual(mut_history, [
- *   [1, ['a', 'b']],
- *   [2, ['c']],
+ * assert.deepStrictEqual(valueHistory, [
+ *   [1, ['A', 'B']],
+ *   [2, ['C']],
  * ]);
  * ```
  */

package/dist/core/operators/with-buffered-from.mjs

@@ -32,27 +32,27 @@ import { maxDepth } from '../utils/max-depth.mjs';
  *
  * const result$ = trigger$.pipe(withBufferedFrom(data$));
  *
- * const mut_history: (readonly [number, readonly string[]])[] = [];
+ * const valueHistory: (readonly [number, readonly string[]])[] = [];
  *
  * result$.subscribe(([triggerValue, bufferedData]) => {
- *   mut_history.push([triggerValue, bufferedData]);
+ *   valueHistory.push([triggerValue, bufferedData]);
  * });
  *
- * data$.next('a');
+ * data$.next('A');
  *
- * data$.next('b');
+ * data$.next('B');
  *
  * trigger$.next(1);
  *
- * assert.deepStrictEqual(mut_history, [[1, ['a', 'b']]]);
+ * assert.deepStrictEqual(valueHistory, [[1, ['A', 'B']]]);
  *
- * data$.next('c');
+ * data$.next('C');
  *
  * trigger$.next(2);
  *
- * assert.deepStrictEqual(mut_history, [
- *   [1, ['a', 'b']],
- *   [2, ['c']],
+ * assert.deepStrictEqual(valueHistory, [
+ *   [1, ['A', 'B']],
+ *   [2, ['C']],
  * ]);
  * ```
  */
@@ -84,13 +84,13 @@ class WithBufferedFromObservableClass extends SyncChildObservableClass {
             this.#mut_bufferedValues = Arr.toPushed(this.#mut_bufferedValues, value);
         });
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const sn = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(sn)) {
+        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
             return; // skip update
         }
-        this.setNext([sn.value, this.#mut_bufferedValues], updaterSymbol);
+        this.setNext([sn.value, this.#mut_bufferedValues], updateToken);
         this.#clearBuffer();
     }
     #clearBuffer() {

package/dist/core/operators/with-buffered-from.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;AACI,MAAM,gBAAgB,GAAG,CAC9B,UAAyB;AAEzB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,+BAA+B,CACjC,gBAAgB,EAChB,UAAU,CACX;AAEL;;;AAGG;AACI,MAAM,YAAY,GAAG;AAE5B,MAAM,+BACJ,SAAQ,wBAAkE,CAAA;IAG1E,mBAAmB,GAAiB,EAAE;IAEtC,WAAA,CAAY,gBAA+B,EAAE,UAAyB,EAAA;AACpE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YACnD,YAAY,EAAE,IAAI,CAAC;AACjB,gBAAA,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;AACnC,gBAAA,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;AAC7B,aAAA,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,KACjB,QAAQ,CAAC,MAAM,CAAC,GAAG;kBACf,QAAQ,CAAC;AACX,kBAAE,QAAQ,CAAC,IAAI,CAAC;AACZ,oBAAA,GAAG,CAAC,KAAK;AACT,oBAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC;iBAC7B,CAAC,CAChB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,UAAU,CAAC,SAAS,CAAC,CAAC,KAAK,KAAI;AAC7B,YAAA,IAAI,CAAC,mBAAmB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,KAAK,CAAC;AAC1E,QAAA,CAAC,CAAC;IACJ;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC;QAEjE,IAAI,CAAC,YAAY,EAAE;IACrB;IAEA,YAAY,GAAA;AACV,QAAA,IAAI,CAAC,mBAAmB,GAAG,EAAE;IAC/B;AACD;;;;"}
+{"version":3,"file":"with-buffered-from.mjs","sources":["../../../src/core/operators/with-buffered-from.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDG;AACI,MAAM,gBAAgB,GAAG,CAC9B,UAAyB;AAEzB;AACA,CAAC,CAAC,gBAAgB,KAChB,IAAI,+BAA+B,CACjC,gBAAgB,EAChB,UAAU,CACX;AAEL;;;AAGG;AACI,MAAM,YAAY,GAAG;AAE5B,MAAM,+BACJ,SAAQ,wBAAkE,CAAA;IAG1E,mBAAmB,GAAiB,EAAE;IAEtC,WAAA,CAAY,gBAA+B,EAAE,UAAyB,EAAA;AACpE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YACnD,YAAY,EAAE,IAAI,CAAC;AACjB,gBAAA,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;AACnC,gBAAA,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;AAC7B,aAAA,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,KACjB,QAAQ,CAAC,MAAM,CAAC,GAAG;kBACf,QAAQ,CAAC;AACX,kBAAE,QAAQ,CAAC,IAAI,CAAC;AACZ,oBAAA,GAAG,CAAC,KAAK;AACT,oBAAA,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC;iBAC7B,CAAC,CAChB,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,UAAU,CAAC,SAAS,CAAC,CAAC,KAAK,KAAI;AAC7B,YAAA,IAAI,CAAC,mBAAmB,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,KAAK,CAAC;AAC1E,QAAA,CAAC,CAAC;IACJ;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;AAEA,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,CAAC,EAAE,WAAW,CAAC;QAE/D,IAAI,CAAC,YAAY,EAAE;IACrB;IAEA,YAAY,GAAA;AACV,QAAA,IAAI,CAAC,mBAAmB,GAAG,EAAE;IAC/B;AACD;;;;"}

package/dist/core/operators/with-current-value-from.d.mts

@@ -13,14 +13,15 @@ import { type DropInitialValueOperator, type Observable } from '../types/index.m
  * //  Timeline:
  * //
  * //  name$     "Alice"           "Bob"               "Charlie"
- * //  age$                25              30      35              40
- * //  result$             ["Alice",25]  ["Bob",30]  ["Bob",35]  ["Charlie",40]
+ * //  age$                25              30
+ * //  result$   (skip)          ["Bob",25]           ["Charlie",30]
  * //
  * //  Explanation:
  * //  - withCurrentValueFrom samples the current value from another observable
- * //  - Emits a tuple [sourceValue, sampledValue] each time the source emits
+ * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits
+ * //  - Does NOT emit when the sampled observable (age$) emits
  * //  - Does not emit until both observables have emitted at least once
- * //  - Similar to combine, but only emits when the source (not the sampled) emits
+ * //  - "Alice" is skipped because age$ hasn't emitted yet
  *
  * const name$ = source<string>();
  *
@@ -28,27 +29,27 @@ import { type DropInitialValueOperator, type Observable } from '../types/index.m
  *
  * const result$ = name$.pipe(withCurrentValueFrom(age$));
  *
- * const mut_history: (readonly [string, number])[] = [];
+ * const valueHistory: (readonly [string, number])[] = [];
  *
  * result$.subscribe(([name_, currentAge]) => {
- *   mut_history.push([name_, currentAge]);
+ *   valueHistory.push([name_, currentAge]);
  * });
  *
  * name$.next('Alice'); // nothing logged (age$ hasn't emitted)
  *
- * assert.deepStrictEqual(mut_history, []);
+ * assert.deepStrictEqual(valueHistory, []);
  *
  * age$.next(25);
  *
  * name$.next('Bob'); // logs: Bob is 25 years old
  *
- * assert.deepStrictEqual(mut_history, [['Bob', 25]]);
+ * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);
  *
  * age$.next(30);
  *
  * name$.next('Charlie'); // logs: Charlie is 30 years old
  *
- * assert.deepStrictEqual(mut_history, [
+ * assert.deepStrictEqual(valueHistory, [
  *   ['Bob', 25],
  *   ['Charlie', 30],
  * ]);

package/dist/core/operators/with-current-value-from.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-current-value-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-current-value-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,oBAAoB,GAC9B,CAAC,EAAE,CAAC,EACH,YAAY,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAEyB,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc,GAVxB,CAAC,EAAE,CAAC,cACS,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAQE,CAAC"}
+{"version":3,"file":"with-current-value-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-current-value-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,oBAAoB,GAC9B,CAAC,EAAE,CAAC,EACH,YAAY,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAEyB,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,cAAc,GAVxB,CAAC,EAAE,CAAC,cACS,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAQE,CAAC"}

package/dist/core/operators/with-current-value-from.mjs

@@ -17,14 +17,15 @@ import { maxDepth } from '../utils/max-depth.mjs';
  * //  Timeline:
  * //
  * //  name$     "Alice"           "Bob"               "Charlie"
- * //  age$                25              30      35              40
- * //  result$             ["Alice",25]  ["Bob",30]  ["Bob",35]  ["Charlie",40]
+ * //  age$                25              30
+ * //  result$   (skip)          ["Bob",25]           ["Charlie",30]
  * //
  * //  Explanation:
  * //  - withCurrentValueFrom samples the current value from another observable
- * //  - Emits a tuple [sourceValue, sampledValue] each time the source emits
+ * //  - Emits a tuple [sourceValue, sampledValue] each time the SOURCE emits
+ * //  - Does NOT emit when the sampled observable (age$) emits
  * //  - Does not emit until both observables have emitted at least once
- * //  - Similar to combine, but only emits when the source (not the sampled) emits
+ * //  - "Alice" is skipped because age$ hasn't emitted yet
  *
  * const name$ = source<string>();
  *
@@ -32,27 +33,27 @@ import { maxDepth } from '../utils/max-depth.mjs';
  *
  * const result$ = name$.pipe(withCurrentValueFrom(age$));
  *
- * const mut_history: (readonly [string, number])[] = [];
+ * const valueHistory: (readonly [string, number])[] = [];
  *
  * result$.subscribe(([name_, currentAge]) => {
- *   mut_history.push([name_, currentAge]);
+ *   valueHistory.push([name_, currentAge]);
  * });
  *
  * name$.next('Alice'); // nothing logged (age$ hasn't emitted)
  *
- * assert.deepStrictEqual(mut_history, []);
+ * assert.deepStrictEqual(valueHistory, []);
  *
  * age$.next(25);
  *
  * name$.next('Bob'); // logs: Bob is 25 years old
  *
- * assert.deepStrictEqual(mut_history, [['Bob', 25]]);
+ * assert.deepStrictEqual(valueHistory, [['Bob', 25]]);
  *
  * age$.next(30);
  *
  * name$.next('Charlie'); // logs: Charlie is 30 years old
  *
- * assert.deepStrictEqual(mut_history, [
+ * assert.deepStrictEqual(valueHistory, [
  *   ['Bob', 25],
  *   ['Charlie', 30],
  * ]);
@@ -79,16 +80,16 @@ class WithCurrentValueFromObservableClass extends SyncChildObservableClass {
         });
         this.#observable = observable;
     }
-    tryUpdate(updaterSymbol) {
+    tryUpdate(updateToken) {
         const par = this.parents[0];
         const ps = par.getSnapshot();
-        if (par.updaterSymbol !== updaterSymbol || Optional.isNone(ps)) {
+        if (par.updateToken !== updateToken || Optional.isNone(ps)) {
             return; // skip update
         }
         const curr = this.#observable.getSnapshot();
         if (Optional.isNone(curr))
             return; // skip update
-        this.setNext([ps.value, curr.value], updaterSymbol);
+        this.setNext([ps.value, curr.value], updateToken);
     }
 }
 

package/dist/core/operators/with-current-value-from.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-current-value-from.mjs","sources":["../../../src/core/operators/with-current-value-from.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDG;MACU,oBAAoB,GAC/B,CACE,UAAyB,KAE3B,CAAC,gBAAgB,KACf,IAAI,mCAAmC,CAAC,gBAAgB,EAAE,UAAU;AAExE;;;AAGG;AACI,MAAM,cAAc,GAAG;AAE9B,MAAM,mCACJ,SAAQ,wBAAuD,CAAA;AAGtD,IAAA,WAAW;IAEpB,WAAA,CAAY,gBAA+B,EAAE,UAAyB,EAAA;AACpE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YACnD,YAAY,EAAE,IAAI,CAAC;AACjB,gBAAA,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;AACnC,gBAAA,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;aAC7B,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,KACjB,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;kBACtC,QAAQ,CAAC;AACX,kBAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAU,CAAC,CAClD,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,WAAW,GAAG,UAAU;IAC/B;AAES,IAAA,SAAS,CAAC,aAA4B,EAAA;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC9D,YAAA,OAAO;QACT;QAEA,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE;AAE3C,QAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC;AAAE,YAAA,OAAO;AAElC,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;IACrD;AACD;;;;"}
+{"version":3,"file":"with-current-value-from.mjs","sources":["../../../src/core/operators/with-current-value-from.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDG;MACU,oBAAoB,GAC/B,CACE,UAAyB,KAE3B,CAAC,gBAAgB,KACf,IAAI,mCAAmC,CAAC,gBAAgB,EAAE,UAAU;AAExE;;;AAGG;AACI,MAAM,cAAc,GAAG;AAE9B,MAAM,mCACJ,SAAQ,wBAAuD,CAAA;AAGtD,IAAA,WAAW;IAEpB,WAAA,CAAY,gBAA+B,EAAE,UAAyB,EAAA;AACpE,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;YACnD,YAAY,EAAE,IAAI,CAAC;AACjB,gBAAA,GAAG,EAAE,gBAAgB,CAAC,WAAW,EAAE;AACnC,gBAAA,EAAE,EAAE,UAAU,CAAC,WAAW,EAAE;aAC7B,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,KACjB,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;kBACtC,QAAQ,CAAC;AACX,kBAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAU,CAAC,CAClD,CAAC,KAAK;AACR,SAAA,CAAC;AAEF,QAAA,IAAI,CAAC,WAAW,GAAG,UAAU;IAC/B;AAES,IAAA,SAAS,CAAC,WAAwB,EAAA;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAE3B,QAAA,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE;AAE5B,QAAA,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;AAC1D,YAAA,OAAO;QACT;QAEA,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE;AAE3C,QAAA,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC;AAAE,YAAA,OAAO;AAElC,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IACnD;AACD;;;;"}