synstate 0.1.1 → 1.0.0

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,30 +28,34 @@ 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']],
  * ]);
  * ```
  */
 export declare const withBufferedFrom: <A, B>(observable: Observable<B>) => KeepInitialValueOperator<A, readonly [A, readonly B[]]>;
+/**
+ * Alias for `withBufferedFrom`.
+ * @see withBufferedFrom
+ */
 export declare const withBuffered: <A, B>(observable: Observable<B>) => KeepInitialValueOperator<A, readonly [A, readonly B[]]>;
 //# sourceMappingURL=with-buffered-from.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"with-buffered-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-buffered-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,EACnC,YAAY,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAMQ,CAAC;AAElE,eAAO,MAAM,YAAY,GAVQ,CAAC,EAAE,CAAC,cACvB,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAQb,CAAC"}
+{"version":3,"file":"with-buffered-from.d.mts","sourceRoot":"","sources":["../../../src/core/operators/with-buffered-from.mts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,UAAU,EAGhB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,EACnC,YAAY,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAMQ,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,YAAY,GAdQ,CAAC,EAAE,CAAC,cACvB,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAYb,CAAC"}

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

@@ -32,34 +32,38 @@ 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']],
  * ]);
  * ```
  */
 const withBufferedFrom = (observable) => 
 // eslint-disable-next-line total-functions/no-unsafe-type-assertion
 ((parentObservable) => new WithBufferedFromObservableClass(parentObservable, observable));
-const withBuffered = withBufferedFrom; // alias
+/**
+ * Alias for `withBufferedFrom`.
+ * @see withBufferedFrom
+ */
+const withBuffered = withBufferedFrom;
 class WithBufferedFromObservableClass extends SyncChildObservableClass {
     #mut_bufferedValues = [];
     constructor(parentObservable, observable) {
@@ -80,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;AAEE,MAAM,YAAY,GAAG,iBAAiB;AAE7C,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,32 +29,36 @@ 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],
  * ]);
  * ```
  */
 export declare const withCurrentValueFrom: <A, B>(observable: Observable<B>) => DropInitialValueOperator<A, readonly [A, B]>;
+/**
+ * Alias for `withCurrentValueFrom`.
+ * @see withCurrentValueFrom
+ */
 export declare const withLatestFrom: <A, B>(observable: Observable<B>) => DropInitialValueOperator<A, readonly [A, B]>;
 //# sourceMappingURL=with-current-value-from.d.mts.map

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,eAAO,MAAM,cAAc,GANxB,CAAC,EAAE,CAAC,cACS,UAAU,CAAC,CAAC,CAAC,KACxB,wBAAwB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAIE,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,34 +33,38 @@ 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],
  * ]);
  * ```
  */
 const withCurrentValueFrom = (observable) => (parentObservable) => new WithCurrentValueFromObservableClass(parentObservable, observable);
-const withLatestFrom = withCurrentValueFrom; // alias
+/**
+ * Alias for `withCurrentValueFrom`.
+ * @see withCurrentValueFrom
+ */
+const withLatestFrom = withCurrentValueFrom;
 class WithCurrentValueFromObservableClass extends SyncChildObservableClass {
     #observable;
     constructor(parentObservable, observable) {
@@ -75,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;AAEjE,MAAM,cAAc,GAAG,qBAAqB;AAEnD,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;;;;"}

package/dist/core/operators/with-initial-value.d.mts

@@ -27,21 +27,21 @@ import { type WithInitialValueOperator } from '../types/index.mjs';
  *
  * const initialized$ = num$.pipe(withInitialValue(0));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * initialized$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(valueHistory, [0]);
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(valueHistory, [0, 1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 2]);
+ * assert.deepStrictEqual(valueHistory, [0, 1, 2]);
  * ```
  */
 export declare const withInitialValue: <A, I = A>(initialValue: I) => WithInitialValueOperator<A, A | I>;

package/dist/core/operators/with-initial-value.mjs

@@ -30,21 +30,21 @@ import '../utils/id-maker.mjs';
  *
  * const initialized$ = num$.pipe(withInitialValue(0));
  *
- * const mut_history: number[] = [];
+ * const valueHistory: number[] = [];
  *
  * initialized$.subscribe((x) => {
- *   mut_history.push(x);
+ *   valueHistory.push(x);
  * });
  *
- * assert.deepStrictEqual(mut_history, [0]);
+ * assert.deepStrictEqual(valueHistory, [0]);
  *
  * num$.next(1); // logs: 1
  *
- * assert.deepStrictEqual(mut_history, [0, 1]);
+ * assert.deepStrictEqual(valueHistory, [0, 1]);
  *
  * num$.next(2); // logs: 2
  *
- * assert.deepStrictEqual(mut_history, [0, 1, 2]);
+ * assert.deepStrictEqual(valueHistory, [0, 1, 2]);
  * ```
  */
 const withInitialValue = (initialValue) => (parentObservable) => new WithInitialValueObservableClass(parentObservable, initialValue);
@@ -55,13 +55,13 @@ class WithInitialValueObservableClass extends InitializedSyncChildObservableClas
             initialValue: Optional.some(initialValue),
         });
     }
-    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/with-initial-value.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"with-initial-value.mjs","sources":["../../../src/core/operators/with-initial-value.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CG;AACI,MAAM,gBAAgB,GAC3B,CAAW,YAAe,KAC1B,CAAC,gBAAgB,KACf,IAAI,+BAA+B,CAAC,gBAAgB,EAAE,YAAY;AAEtE,MAAM,+BACJ,SAAQ,mCAAwD,CAAA;IAGhE,WAAA,CAAY,gBAA+B,EAAE,YAAe,EAAA;AAC1D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;AAC1C,SAAA,CAAC;;AAGK,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;;QAGT,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC;;AAExC;;;;"}
+{"version":3,"file":"with-initial-value.mjs","sources":["../../../src/core/operators/with-initial-value.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CG;AACI,MAAM,gBAAgB,GAC3B,CAAW,YAAe,KAC1B,CAAC,gBAAgB,KACf,IAAI,+BAA+B,CAAC,gBAAgB,EAAE,YAAY;AAEtE,MAAM,+BACJ,SAAQ,mCAAwD,CAAA;IAGhE,WAAA,CAAY,gBAA+B,EAAE,YAAe,EAAA;AAC1D,QAAA,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;AAC3B,YAAA,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;AAC1C,SAAA,CAAC;;AAGK,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;;QAGT,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC;;AAEtC;;;;"}

package/dist/core/predefined/index.d.mts

@@ -0,0 +1,2 @@
+export * from './operators/index.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/core/predefined/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/core/predefined/index.mts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/core/predefined/index.mjs

@@ -0,0 +1,12 @@
+export { attachIndex, withIndex } from './operators/attach-index.mjs';
+export { mapOptional } from './operators/map-optional.mjs';
+export { mapResultErr } from './operators/map-result-err.mjs';
+export { mapResultOk } from './operators/map-result-ok.mjs';
+export { mapTo } from './operators/map-to.mjs';
+export { getKey, pluck } from './operators/pluck.mjs';
+export { skip } from './operators/skip.mjs';
+export { take } from './operators/take.mjs';
+export { unwrapOptional } from './operators/unwrap-optional.mjs';
+export { unwrapResultErr } from './operators/unwrap-result-err.mjs';
+export { unwrapResultOk } from './operators/unwrap-result-ok.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/core/predefined/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/dist/core/predefined/operators/attach-index.d.mts

@@ -0,0 +1,57 @@
+import { type KeepInitialValueOperator } from '../../types/index.mjs';
+/**
+ * Attaches a sequential index to each emitted value, producing `[index, value]` tuples.
+ * Index starts at 0 and increments with each emission.
+ *
+ * @template A - The type of values from the source
+ * @returns An operator that emits `[index, value]` tuples
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  letter$    "A"      "B"      "C"
+ * //  indexed$   [0,"A"]  [1,"B"]  [2,"C"]
+ * //
+ * //  Explanation:
+ * //  - attachIndex attaches a sequential index to each emitted value
+ * //  - Produces [index, value] tuples
+ * //  - Index starts at 0 and increments with each emission
+ *
+ * const letter$ = source<string>();
+ *
+ * const indexed$ = letter$.pipe(attachIndex());
+ *
+ * const valueHistory: (readonly [number, string])[] = [];
+ *
+ * indexed$.subscribe(([i, letter]) => {
+ *   valueHistory.push([i, letter]);
+ * });
+ *
+ * letter$.next('A');
+ *
+ * assert.deepStrictEqual(valueHistory, [[0, 'A']]);
+ *
+ * letter$.next('B');
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   [0, 'A'],
+ *   [1, 'B'],
+ * ]);
+ *
+ * letter$.next('C');
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   [0, 'A'],
+ *   [1, 'B'],
+ *   [2, 'C'],
+ * ]);
+ * ```
+ */
+export declare const withIndex: <A>() => KeepInitialValueOperator<A, readonly [SafeUint | -1, A]>;
+/**
+ * Alias for `withIndex`.
+ * @see withIndex
+ */
+export declare const attachIndex: <A>() => KeepInitialValueOperator<A, readonly [SafeUint | -1, A]>;
+//# sourceMappingURL=attach-index.d.mts.map

package/dist/core/predefined/operators/attach-index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach-index.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,OAAM,wBAAwB,CACvD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CACM,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,WAAW,GATE,CAAC,OAAM,wBAAwB,CACvD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAOO,CAAC"}

package/dist/core/predefined/operators/attach-index.mjs

@@ -0,0 +1,62 @@
+import 'ts-data-forge';
+import '../../utils/id-maker.mjs';
+import { map } from '../../operators/map.mjs';
+
+/**
+ * Attaches a sequential index to each emitted value, producing `[index, value]` tuples.
+ * Index starts at 0 and increments with each emission.
+ *
+ * @template A - The type of values from the source
+ * @returns An operator that emits `[index, value]` tuples
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  letter$    "A"      "B"      "C"
+ * //  indexed$   [0,"A"]  [1,"B"]  [2,"C"]
+ * //
+ * //  Explanation:
+ * //  - attachIndex attaches a sequential index to each emitted value
+ * //  - Produces [index, value] tuples
+ * //  - Index starts at 0 and increments with each emission
+ *
+ * const letter$ = source<string>();
+ *
+ * const indexed$ = letter$.pipe(attachIndex());
+ *
+ * const valueHistory: (readonly [number, string])[] = [];
+ *
+ * indexed$.subscribe(([i, letter]) => {
+ *   valueHistory.push([i, letter]);
+ * });
+ *
+ * letter$.next('A');
+ *
+ * assert.deepStrictEqual(valueHistory, [[0, 'A']]);
+ *
+ * letter$.next('B');
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   [0, 'A'],
+ *   [1, 'B'],
+ * ]);
+ *
+ * letter$.next('C');
+ *
+ * assert.deepStrictEqual(valueHistory, [
+ *   [0, 'A'],
+ *   [1, 'B'],
+ *   [2, 'C'],
+ * ]);
+ * ```
+ */
+const withIndex = () => map((a, i) => [i, a]);
+/**
+ * Alias for `withIndex`.
+ * @see withIndex
+ */
+const attachIndex = withIndex;
+
+export { attachIndex, withIndex };
+//# sourceMappingURL=attach-index.mjs.map

package/dist/core/predefined/operators/attach-index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach-index.mjs","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDG;MACU,SAAS,GAAG,MAGpB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAU;AAElC;;;AAGG;AACI,MAAM,WAAW,GAAG;;;;"}