synstate 2.0.2 → 3.0.1

package/dist/core/create/source.mjs

@@ -1,21 +1,16 @@
-import { Optional, Arr } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-function source(...args) {
-  return new SourceObservableClass(...args);
+import { Arr, Optional } from 'ts-data-forge';
+import { createRootObservable } from '../base/index.mjs';
+export function source(...args) {
+    return createRootObservable({
+        initialValue: Arr.isNonEmpty(args)
+            ? Optional.some(args[0])
+            : Optional.none,
+    }, ({ startUpdate, isCompleted }) => ({
+        next: (nextValue) => {
+            if (isCompleted())
+                return;
+            startUpdate(nextValue);
+        },
+    }));
 }
-class SourceObservableClass extends RootObservableClass {
-  constructor(...args) {
-    super({
-      initialValue: Arr.isNonEmpty(args) ? Optional.some(args[0]) : Optional.none
-    });
-  }
-  next(nextValue) {
-    if (this.isCompleted) return;
-    this.startUpdate(nextValue);
-  }
-}
-
-export { source };
-//# sourceMappingURL=source.mjs.map
+//# sourceMappingURL=source.mjs.map

package/dist/core/create/source.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"source.mjs","sources":["../../../src/core/create/source.mts"],"sourcesContent":["import { Arr, Optional } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport {\n  type InitializedSourceObservable,\n  type SourceObservable,\n} from '../types/index.mjs';\n\n/**\n * Creates a new Observable source that can manually emit values.\n * This is the primary way to create root observables that start reactive chains.\n *\n * @template A - The type of values emitted by the source\n * @returns A SourceObservable that can emit values via `.next()` method\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  count$    1     2     3     ...\n * //\n * //  Explanation:\n * //  - source creates a new observable that you can manually emit values to\n * //  - Use .next() to emit values\n * //  - Foundation for building custom observables\n *\n * const count$ = source<number>();\n *\n * const valueHistory: number[] = [];\n *\n * count$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * count$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * count$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2]);\n *\n * count$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport function source<const A>(\n  initialValue: A,\n): InitializedSourceObservable<A>;\n\nexport function source<const A>(): SourceObservable<A>;\n\nexport function source<const A>(...args: readonly A[]): SourceObservable<A> {\n  return new SourceObservableClass<A>(...args);\n}\n\nclass SourceObservableClass<A>\n  extends RootObservableClass<A>\n  implements SourceObservable<A>\n{\n  constructor(...args: readonly A[]) {\n    super({\n      initialValue: Arr.isNonEmpty(args)\n        ? Optional.some(args[0])\n        : Optional.none,\n    });\n  }\n\n  next(nextValue: A): void {\n    if (this.isCompleted) return;\n\n    this.startUpdate(nextValue);\n  }\n}\n"],"names":[],"mappings":";;;;AAoDO,SAAS,UAAmB,IAAA,EAAyC;AAC1E,EAAA,OAAO,IAAI,qBAAA,CAAyB,GAAG,IAAI,CAAA;AAC7C;AAEA,MAAM,8BACI,mBAAA,CAEV;AAAA,EACE,eAAe,IAAA,EAAoB;AACjC,IAAA,KAAA,CAAM;AAAA,MACJ,YAAA,EAAc,GAAA,CAAI,UAAA,CAAW,IAAI,CAAA,GAC7B,QAAA,CAAS,IAAA,CAAK,IAAA,CAAK,CAAC,CAAC,CAAA,GACrB,QAAA,CAAS;AAAA,KACd,CAAA;AAAA,EACH;AAAA,EAEA,KAAK,SAAA,EAAoB;AACvB,IAAA,IAAI,KAAK,WAAA,EAAa;AAEtB,IAAA,IAAA,CAAK,YAAY,SAAS,CAAA;AAAA,EAC5B;AACF;;;;"}
+{"version":3,"file":"source.mjs","sourceRoot":"","sources":["../../../src/core/create/source.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAmDzD,MAAM,UAAU,MAAM,CAAU,GAAG,IAAkB;IACnD,OAAO,oBAAoB,CACzB;QACE,YAAY,EAAE,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC;YAChC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACxB,CAAC,CAAC,QAAQ,CAAC,IAAI;KAClB,EACD,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC;QACjC,IAAI,EAAE,CAAC,SAAY,EAAE,EAAE;YACrB,IAAI,WAAW,EAAE;gBAAE,OAAO;YAE1B,WAAW,CAAC,SAAS,CAAC,CAAC;QACzB,CAAC;KACF,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/core/create/timer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"timer.d.mts","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,iBACF,MAAM,YACV,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,eACsE,CAAC"}
+{"version":3,"file":"timer.d.mts","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,KAAK,iBACF,MAAM,YACV,QAAQ,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,KACD,eA2CF,CAAC"}

package/dist/core/create/timer.mjs

@@ -1,46 +1,69 @@
 import { Optional } from 'ts-data-forge';
-import '../utils/id-maker.mjs';
-import { RootObservableClass } from '../class/root-observable-class.mjs';
-
-const timer = (milliSeconds, options) => new TimerObservableClass(milliSeconds, options?.startManually ?? false);
-class TimerObservableClass extends RootObservableClass {
-  #milliSeconds;
-  #mut_timerId;
-  #mut_isStarted;
-  constructor(milliSeconds, startManually) {
-    super({ initialValue: Optional.none });
-    this.#milliSeconds = milliSeconds;
-    this.#mut_timerId = void 0;
-    this.#mut_isStarted = false;
-    if (!startManually) {
-      this.start();
-    }
-  }
-  #resetTimer() {
-    if (this.#mut_timerId !== void 0) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-  start() {
-    if (this.#mut_isStarted) {
-      console.warn("cannot start twice");
-      return;
-    }
-    this.#mut_isStarted = true;
-    if (this.isCompleted) {
-      console.warn("cannot restart stopped TimerObservable");
-      return;
+import { createRootObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const timer = (milliSeconds, options) => {
+    let mut_timerId = undefined;
+    let mut_isStarted = false;
+    const resetTimer = () => {
+        if (mut_timerId !== undefined) {
+            clearTimeout(mut_timerId);
+        }
+    };
+    const observable = createRootObservable({ initialValue: Optional.none, onComplete: resetTimer }, ({ startUpdate, isCompleted, complete }) => ({
+        start: () => {
+            if (mut_isStarted) {
+                console.warn('cannot start twice');
+                return;
+            }
+            mut_isStarted = true;
+            if (isCompleted()) {
+                console.warn('cannot restart stopped TimerObservable');
+                return;
+            }
+            mut_timerId = setTimeout(() => {
+                startUpdate(0);
+                complete();
+            }, milliSeconds);
+        },
+    }));
+    if (!(options?.startManually ?? false)) {
+        observable.start();
     }
-    this.#mut_timerId = setTimeout(() => {
-      this.startUpdate(0);
-      this.complete();
-    }, this.#milliSeconds);
-  }
-  complete() {
-    this.#resetTimer();
-    super.complete();
-  }
-}
-
-export { timer };
-//# sourceMappingURL=timer.mjs.map
+    return observable;
+};
+//# sourceMappingURL=timer.mjs.map

package/dist/core/create/timer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"timer.mjs","sources":["../../../src/core/create/timer.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { RootObservableClass } from '../class/index.mjs';\nimport { type TimerId, type TimerObservable } from '../types/index.mjs';\n\n/**\n * Creates an observable that emits 0 after a specified delay and then completes.\n *\n * @param milliSeconds - The delay in milliseconds before emission\n * @param startManually - If true, waits for manual start (default: false)\n * @returns An observable that emits after delay\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  Time(ms)  0     ...   1000\n * //  delayed$                X (emits and completes)\n * //\n * //  Explanation:\n * //  - timer emits once after the specified delay, then completes\n * //  - Useful for delayed actions or timeouts\n *\n * const delayed$ = timer(100);\n *\n * const valueHistory: number[] = [];\n *\n * await new Promise<void>((resolve) => {\n *   delayed$.subscribe(\n *     () => {\n *       valueHistory.push(1);\n *     },\n *     () => {\n *       resolve();\n *     },\n *   );\n * });\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n * ```\n */\nexport const timer = (\n  milliSeconds: number,\n  options?: Readonly<{\n    startManually?: boolean;\n  }>,\n): TimerObservable =>\n  new TimerObservableClass(milliSeconds, options?.startManually ?? false);\n\nclass TimerObservableClass\n  extends RootObservableClass<0>\n  implements TimerObservable\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n  #mut_isStarted: boolean;\n\n  constructor(milliSeconds: number, startManually: boolean) {\n    super({ initialValue: Optional.none });\n\n    this.#milliSeconds = milliSeconds;\n\n    this.#mut_timerId = undefined;\n\n    this.#mut_isStarted = false;\n\n    if (!startManually) {\n      this.start();\n    }\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\n  }\n\n  start(): void {\n    if (this.#mut_isStarted) {\n      console.warn('cannot start twice');\n\n      return;\n    }\n\n    this.#mut_isStarted = true;\n\n    if (this.isCompleted) {\n      console.warn('cannot restart stopped TimerObservable');\n\n      return;\n    }\n\n    this.#mut_timerId = setTimeout(() => {\n      this.startUpdate(0);\n\n      this.complete();\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AAwCO,MAAM,KAAA,GAAQ,CACnB,YAAA,EACA,OAAA,KAIA,IAAI,oBAAA,CAAqB,YAAA,EAAc,OAAA,EAAS,aAAA,IAAiB,KAAK;AAExE,MAAM,6BACI,mBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EACA,cAAA;AAAA,EAEA,WAAA,CAAY,cAAsB,aAAA,EAAwB;AACxD,IAAA,KAAA,CAAM,EAAE,YAAA,EAAc,QAAA,CAAS,IAAA,EAAM,CAAA;AAErC,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAErB,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,cAAA,GAAiB,KAAA;AAEtB,IAAA,IAAI,CAAC,aAAA,EAAe;AAClB,MAAA,IAAA,CAAK,KAAA,EAAM;AAAA,IACb;AAAA,EACF;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;AAAA,EAEA,KAAA,GAAc;AACZ,IAAA,IAAI,KAAK,cAAA,EAAgB;AACvB,MAAA,OAAA,CAAQ,KAAK,oBAAoB,CAAA;AAEjC,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,cAAA,GAAiB,IAAA;AAEtB,IAAA,IAAI,KAAK,WAAA,EAAa;AACpB,MAAA,OAAA,CAAQ,KAAK,wCAAwC,CAAA;AAErD,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,IAAA,CAAK,YAAY,CAAC,CAAA;AAElB,MAAA,IAAA,CAAK,QAAA,EAAS;AAAA,IAChB,CAAA,EAAG,KAAK,aAAa,CAAA;AAAA,EACvB;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"timer.mjs","sourceRoot":"","sources":["../../../src/core/create/timer.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,YAAoB,EACpB,OAEE,EACe,EAAE;IACnB,IAAI,WAAW,GAAwB,SAAS,CAAC;IAEjD,IAAI,aAAa,GAAG,KAAK,CAAC;IAE1B,MAAM,UAAU,GAAG,GAAS,EAAE;QAC5B,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,YAAY,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,UAAU,GAAG,oBAAoB,CACrC,EAAE,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,EACvD,CAAC,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;QAC3C,KAAK,EAAE,GAAG,EAAE;YACV,IAAI,aAAa,EAAE,CAAC;gBAClB,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBAEnC,OAAO;YACT,CAAC;YAED,aAAa,GAAG,IAAI,CAAC;YAErB,IAAI,WAAW,EAAE,EAAE,CAAC;gBAClB,OAAO,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;gBAEvD,OAAO;YACT,CAAC;YAED,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC5B,WAAW,CAAC,CAAC,CAAC,CAAC;gBAEf,QAAQ,EAAE,CAAC;YACb,CAAC,EAAE,YAAY,CAAC,CAAC;QACnB,CAAC;KACF,CAAC,CACH,CAAC;IAEF,IAAI,CAAC,CAAC,OAAO,EAAE,aAAa,IAAI,KAAK,CAAC,EAAE,CAAC;QACvC,UAAU,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC"}

package/dist/core/index.d.mts

@@ -1,4 +1,3 @@
-export * from './class/index.mjs';
 export * from './combine/index.mjs';
 export * from './create/index.mjs';
 export * from './operators/index.mjs';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/core/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/core/index.mts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}

package/dist/core/index.mjs

@@ -1,44 +1,6 @@
-export { AsyncChildObservableClass, InitializedSyncChildObservableClass, SyncChildObservableClass } from './class/child-observable-class.mjs';
-export { ObservableBaseClass } from './class/observable-base-class.mjs';
-export { RootObservableClass } from './class/root-observable-class.mjs';
-export { combine, combineLatest } from './combine/combine.mjs';
-export { merge } from './combine/merge.mjs';
-export { zip } from './combine/zip.mjs';
-export { counter } from './create/counter.mjs';
-export { fromAbortablePromise } from './create/from-abortable-promise.mjs';
-export { fromPromise } from './create/from-promise.mjs';
-export { fromSubscribable } from './create/from-subscribable.mjs';
-export { just } from './create/just.mjs';
-export { source } from './create/source.mjs';
-export { timer } from './create/timer.mjs';
-export { audit } from './operators/audit.mjs';
-export { debounce } from './operators/debounce.mjs';
-export { filter } from './operators/filter.mjs';
-export { map } from './operators/map.mjs';
-export { flatMap, mergeMap } from './operators/merge-map.mjs';
-export { pairwise } from './operators/pairwise.mjs';
-export { scan } from './operators/scan.mjs';
-export { distinctUntilChanged, skipIfNoChange } from './operators/skip-if-no-change.mjs';
-export { skipUntil } from './operators/skip-until.mjs';
-export { skipWhile } from './operators/skip-while.mjs';
-export { switchMap } from './operators/switch-map.mjs';
-export { takeUntil } from './operators/take-until.mjs';
-export { takeWhile } from './operators/take-while.mjs';
-export { throttle } from './operators/throttle.mjs';
-export { withBuffered, withBufferedFrom } from './operators/with-buffered-from.mjs';
-export { withCurrentValueFrom, withLatestFrom } from './operators/with-current-value-from.mjs';
-export { withInitialValue } from './operators/with-initial-value.mjs';
-export { attachIndex, withIndex } from './predefined/operators/attach-index.mjs';
-export { mapOptional } from './predefined/operators/map-optional.mjs';
-export { mapResultErr } from './predefined/operators/map-result-err.mjs';
-export { mapResultOk } from './predefined/operators/map-result-ok.mjs';
-export { mapTo } from './predefined/operators/map-to.mjs';
-export { getKey, pluck } from './predefined/operators/pluck.mjs';
-export { skip } from './predefined/operators/skip.mjs';
-export { take } from './predefined/operators/take.mjs';
-export { unwrapOptional } from './predefined/operators/unwrap-optional.mjs';
-export { unwrapResultErr } from './predefined/operators/unwrap-result-err.mjs';
-export { unwrapResultOk } from './predefined/operators/unwrap-result-ok.mjs';
-import 'ts-data-forge';
-export { isChildObservable, isManagerObservable, isRootObservable } from './types/observable.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './combine/index.mjs';
+export * from './create/index.mjs';
+export * from './operators/index.mjs';
+export * from './predefined/index.mjs';
+export * from './types/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/core/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/core/index.mts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"audit.d.mts","sourceRoot":"","sources":["../../../src/core/operators/audit.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,gBACP,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}
+{"version":3,"file":"audit.d.mts","sourceRoot":"","sources":["../../../src/core/operators/audit.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAG9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,gBACP,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/audit.mjs

@@ -1,50 +1,129 @@
 import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
-import '../utils/id-maker.mjs';
-
-const audit = (milliSeconds) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) => new AuditObservableClass(
-    parentObservable,
-    milliSeconds
-  ))
-);
-class AuditObservableClass extends AsyncChildObservableClass {
-  #milliSeconds;
-  #mut_timerId;
-  #mut_isSkipping;
-  constructor(parentObservable, milliSeconds) {
-    super({
-      parents: [parentObservable],
-      initialValue: parentObservable.getSnapshot()
+import { createAsyncChildObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const audit = (milliSeconds) => 
+
+((parentObservable) => createAuditObservable(parentObservable, milliSeconds));
+const createAuditObservable = (parentObservable, milliSeconds) => {
+    let mut_timerId = undefined;
+    let mut_isSkipping = false;
+    const resetTimer = () => {
+        if (mut_timerId !== undefined) {
+            clearTimeout(mut_timerId);
+        }
+    };
+    return createAsyncChildObservable({
+        parents: [parentObservable],
+        initialValue: parentObservable.getSnapshot(),
+        onComplete: resetTimer,
+    }, ({ startUpdate }) => (updateToken) => {
+        if (mut_isSkipping ||
+            parentObservable.updateToken !== updateToken ||
+            Optional.isNone(parentObservable.getSnapshot())) {
+            return;
+        }
+
+        mut_isSkipping = true;
+        mut_timerId = setTimeout(() => {
+            const sn = parentObservable.getSnapshot();
+            if (Optional.isNone(sn))
+                return;
+            startUpdate(sn.value);
+            mut_isSkipping = false;
+        }, milliSeconds);
     });
-    this.#mut_isSkipping = false;
-    this.#mut_timerId = void 0;
-    this.#milliSeconds = milliSeconds;
-  }
-  #resetTimer() {
-    if (this.#mut_timerId !== void 0) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    if (par.updateToken !== updateToken || Optional.isNone(par.getSnapshot()) || this.#mut_isSkipping) {
-      return;
-    }
-    this.#mut_isSkipping = true;
-    this.#mut_timerId = setTimeout(() => {
-      const sn = par.getSnapshot();
-      if (Optional.isNone(sn)) return;
-      this.startUpdate(sn.value);
-      this.#mut_isSkipping = false;
-    }, this.#milliSeconds);
-  }
-  complete() {
-    this.#resetTimer();
-    super.complete();
-  }
-}
-
-export { audit };
-//# sourceMappingURL=audit.mjs.map
+};
+//# sourceMappingURL=audit.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"audit.mjs","sources":["../../../src/core/operators/audit.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { AsyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type AuditOperatorObservable,\n  type KeepInitialValueOperator,\n  type Observable,\n  type TimerId,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Ignores source values for duration milliseconds, then emits the most recent value from the source Observable, then repeats this process.\n *\n * Unlike `throttle` which emits the first value, `audit` emits the last value.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The audit time window in milliseconds\n * @returns An operator that audits emissions from the observable\n *\n * @example\n * ```ts\n * //  Timeline (250ms audit):\n * //\n * //  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\n * //\n * //  input$       0       2   3                   9   10  11  12  13  14\n * //               |- 250ms -> |- 250ms ->         |- 250ms -> |- 250ms ->\n * //  audited$               2           3                   11          14   (emitted at end of window)\n * //\n * //  Explanation:\n * //  - audit emits the LAST value received during each time window\n * //  - Unlike throttle (which emits the FIRST value), audit emits the LAST\n * //  - Useful when you want the most recent value after a burst of events\n *\n * const input$ = source<number>();\n *\n * const audited$ = input$.pipe(audit(250));\n *\n * const valueHistory: number[] = [];\n *\n * audited$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * const sleep = (ms: number): Promise<void> =>\n *   new Promise((resolve) => {\n *     setTimeout(resolve, ms);\n *   });\n *\n * input$.next(0);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2]);\n *\n * input$.next(3);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * await sleep(100);\n *\n * input$.next(10);\n *\n * await sleep(100);\n *\n * input$.next(11);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3]);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * input$.next(12);\n *\n * await sleep(100);\n *\n * input$.next(13);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * await sleep(100);\n *\n * input$.next(14);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11]);\n *\n * await sleep(100);\n *\n * assert.deepStrictEqual(valueHistory, [2, 3, 11, 14]);\n * ```\n */\nexport const audit = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new AuditObservableClass(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nclass AuditObservableClass<A>\n  extends AsyncChildObservableClass<A, readonly [A]>\n  implements AuditOperatorObservable<A>\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n  #mut_isSkipping: boolean;\n\n  constructor(parentObservable: Observable<A>, milliSeconds: number) {\n    super({\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    });\n\n    this.#mut_isSkipping = false;\n\n    this.#mut_timerId = undefined;\n\n    this.#milliSeconds = milliSeconds;\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    if (\n      par.updateToken !== updateToken ||\n      Optional.isNone(par.getSnapshot()) ||\n      this.#mut_isSkipping\n    ) {\n      return; // skip update\n    }\n\n    // set timer\n    this.#mut_isSkipping = true;\n\n    this.#mut_timerId = setTimeout(() => {\n      const sn = par.getSnapshot();\n\n      if (Optional.isNone(sn)) return;\n\n      this.startUpdate(sn.value);\n\n      this.#mut_isSkipping = false;\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AAwGO,MAAM,QAAQ,CACnB,YAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,oBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,6BACI,yBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EACA,eAAA;AAAA,EAEA,WAAA,CAAY,kBAAiC,YAAA,EAAsB;AACjE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC5C,CAAA;AAED,IAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAEvB,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAAA,EACvB;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,IACE,GAAA,CAAI,WAAA,KAAgB,WAAA,IACpB,QAAA,CAAS,MAAA,CAAO,IAAI,WAAA,EAAa,CAAA,IACjC,IAAA,CAAK,eAAA,EACL;AACA,MAAA;AAAA,IACF;AAGA,IAAA,IAAA,CAAK,eAAA,GAAkB,IAAA;AAEvB,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,MAAA,IAAI,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAEzB,MAAA,IAAA,CAAK,WAAA,CAAY,GAAG,KAAK,CAAA;AAEzB,MAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AAAA,IACzB,CAAA,EAAG,KAAK,aAAa,CAAA;AAAA,EACvB;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"audit.mjs","sourceRoot":"","sources":["../../../src/core/operators/audit.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAQ/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,YAAoB,EACY,EAAE;AAClC,oEAAoE;AACpE,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,qBAAqB,CACnB,gBAAgB,EAChB,YAAY,CACb,CAAmC,CAAC;AAEzC,MAAM,qBAAqB,GAAG,CAC5B,gBAA+B,EAC/B,YAAoB,EACQ,EAAE;IAC9B,IAAI,WAAW,GAAwB,SAAS,CAAC;IAEjD,IAAI,cAAc,GAAG,KAAK,CAAC;IAE3B,MAAM,UAAU,GAAG,GAAS,EAAE;QAC5B,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,YAAY,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC,CAAC;IAEF,OAAO,0BAA0B,CAC/B;QACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;QAC3B,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;QAC5C,UAAU,EAAE,UAAU;KACvB,EACD,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAClB,CAAC,WAAW,EAAE,EAAE;QACd,IACE,cAAc;YACd,gBAAgB,CAAC,WAAW,KAAK,WAAW;YAC5C,QAAQ,CAAC,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,EAC/C,CAAC;YACD,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,YAAY;QACZ,cAAc,GAAG,IAAI,CAAC;QAEtB,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;YAE1C,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE,OAAO;YAEhC,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;YAEtB,cAAc,GAAG,KAAK,CAAC;QACzB,CAAC,EAAE,YAAY,CAAC,CAAC;IACnB,CAAC,CACJ,CAAC;AACJ,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"debounce.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAI9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,gBACV,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}
+{"version":3,"file":"debounce.d.mts","sourceRoot":"","sources":["../../../src/core/operators/debounce.mts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,wBAAwB,EAG9B,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,gBACV,MAAM,KACnB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/debounce.mjs

@@ -1,47 +1,117 @@
 import { Optional } from 'ts-data-forge';
-import { AsyncChildObservableClass } from '../class/child-observable-class.mjs';
-import '../utils/id-maker.mjs';
-
-const debounce = (milliSeconds) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) => new DebounceObservableClass(
-    parentObservable,
-    milliSeconds
-  ))
-);
-class DebounceObservableClass extends AsyncChildObservableClass {
-  #milliSeconds;
-  #mut_timerId;
-  constructor(parentObservable, milliSeconds) {
-    super({
-      parents: [parentObservable],
-      initialValue: parentObservable.getSnapshot()
+import { createAsyncChildObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const debounce = (milliSeconds) => 
+
+((parentObservable) => createDebounceObservable(parentObservable, milliSeconds));
+const createDebounceObservable = (parentObservable, milliSeconds) => {
+    let mut_timerId = undefined;
+    const resetTimer = () => {
+        if (mut_timerId !== undefined) {
+            clearTimeout(mut_timerId);
+        }
+    };
+    return createAsyncChildObservable({
+        parents: [parentObservable],
+        initialValue: parentObservable.getSnapshot(),
+        onComplete: resetTimer,
+    }, ({ startUpdate }) => (updateToken) => {
+        const sn = parentObservable.getSnapshot();
+        if (parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
+        }
+        resetTimer();
+
+        mut_timerId = setTimeout(() => {
+            if (Optional.isNone(sn))
+                return;
+            startUpdate(sn.value);
+        }, milliSeconds);
     });
-    this.#mut_timerId = void 0;
-    this.#milliSeconds = milliSeconds;
-  }
-  #resetTimer() {
-    if (this.#mut_timerId !== void 0) {
-      clearTimeout(this.#mut_timerId);
-    }
-  }
-  tryUpdate(updateToken) {
-    const par = this.parents[0];
-    const sn = par.getSnapshot();
-    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
-      return;
-    }
-    this.#resetTimer();
-    this.#mut_timerId = setTimeout(() => {
-      if (Optional.isNone(sn)) return;
-      this.startUpdate(sn.value);
-    }, this.#milliSeconds);
-  }
-  complete() {
-    this.#resetTimer();
-    super.complete();
-  }
-}
-
-export { debounce };
-//# sourceMappingURL=debounce.mjs.map
+};
+//# sourceMappingURL=debounce.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"debounce.mjs","sources":["../../../src/core/operators/debounce.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { AsyncChildObservableClass } from '../class/index.mjs';\nimport {\n  type DebounceOperatorObservable,\n  type KeepInitialValueOperator,\n  type Observable,\n  type TimerId,\n  type UpdateToken,\n} from '../types/index.mjs';\n\n/**\n * Delays emissions from the source observable until a specified time has passed without another emission.\n * Useful for handling user input events like typing or scrolling.\n *\n * @template A - The type of values from the source\n * @param milliSeconds - The debounce duration in milliseconds\n * @returns An operator that debounces the observable\n *\n * @example\n * ```ts\n * //  Timeline (250ms debounce):\n * //\n * //  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\n * //\n * //  input$       0       2   3                   9   10  11  12  13  14\n * //                               |- 250ms ->                         |- 250ms ->\n * //  debounced$                   3                                             14   (emitted after 250ms silence)\n * //\n * //  Explanation:\n * //  - debounce emits the latest value AFTER a quiet period with no new emissions\n * //  - Unlike audit (which uses a fixed window), debounce resets the timer on every emission\n * //  - Useful for search-as-you-type and form validation\n *\n * const input$ = source<number>();\n *\n * const debounced$ = input$.pipe(debounce(250));\n *\n * const valueHistory: number[] = [];\n *\n * debounced$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * const sleep = (ms: number): Promise<void> =>\n *   new Promise((resolve) => {\n *     setTimeout(resolve, ms);\n *   });\n *\n * input$.next(0);\n *\n * await sleep(200);\n *\n * input$.next(2);\n *\n * await sleep(100);\n *\n * input$.next(3);\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * await sleep(300);\n *\n * input$.next(9);\n *\n * await sleep(100);\n *\n * input$.next(10);\n *\n * await sleep(100);\n *\n * input$.next(11);\n *\n * await sleep(100);\n *\n * input$.next(12);\n *\n * await sleep(100);\n *\n * input$.next(13);\n *\n * await sleep(100);\n *\n * input$.next(14);\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * await sleep(300);\n *\n * assert.deepStrictEqual(valueHistory, [3, 14]);\n * ```\n */\nexport const debounce = <A,>(\n  milliSeconds: number,\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    new DebounceObservableClass(\n      parentObservable,\n      milliSeconds,\n    )) as KeepInitialValueOperator<A, A>;\n\nclass DebounceObservableClass<A>\n  extends AsyncChildObservableClass<A, readonly [A]>\n  implements DebounceOperatorObservable<A>\n{\n  readonly #milliSeconds: number;\n  #mut_timerId: TimerId | undefined;\n\n  constructor(parentObservable: Observable<A>, milliSeconds: number) {\n    super({\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    });\n\n    this.#mut_timerId = undefined;\n\n    this.#milliSeconds = milliSeconds;\n  }\n\n  #resetTimer(): void {\n    if (this.#mut_timerId !== undefined) {\n      clearTimeout(this.#mut_timerId);\n    }\n  }\n\n  override tryUpdate(updateToken: UpdateToken): void {\n    const par = this.parents[0];\n\n    const sn = par.getSnapshot();\n\n    if (par.updateToken !== updateToken || Optional.isNone(sn)) {\n      return; // skip update\n    }\n\n    this.#resetTimer();\n\n    // set timer\n    this.#mut_timerId = setTimeout(() => {\n      if (Optional.isNone(sn)) return;\n\n      this.startUpdate(sn.value);\n    }, this.#milliSeconds);\n  }\n\n  override complete(): void {\n    this.#resetTimer();\n\n    super.complete();\n  }\n}\n"],"names":[],"mappings":";;;;AA+FO,MAAM,WAAW,CACtB,YAAA;AAAA;AAAA,GAGC,CAAC,qBACA,IAAI,uBAAA;AAAA,IACF,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAEJ,MAAM,gCACI,yBAAA,CAEV;AAAA,EACW,aAAA;AAAA,EACT,YAAA;AAAA,EAEA,WAAA,CAAY,kBAAiC,YAAA,EAAsB;AACjE,IAAA,KAAA,CAAM;AAAA,MACJ,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,KAC5C,CAAA;AAED,IAAA,IAAA,CAAK,YAAA,GAAe,MAAA;AAEpB,IAAA,IAAA,CAAK,aAAA,GAAgB,YAAA;AAAA,EACvB;AAAA,EAEA,WAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,YAAA,CAAa,KAAK,YAAY,CAAA;AAAA,IAChC;AAAA,EACF;AAAA,EAES,UAAU,WAAA,EAAgC;AACjD,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,OAAA,CAAQ,CAAC,CAAA;AAE1B,IAAA,MAAM,EAAA,GAAK,IAAI,WAAA,EAAY;AAE3B,IAAA,IAAI,IAAI,WAAA,KAAgB,WAAA,IAAe,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAC1D,MAAA;AAAA,IACF;AAEA,IAAA,IAAA,CAAK,WAAA,EAAY;AAGjB,IAAA,IAAA,CAAK,YAAA,GAAe,WAAW,MAAM;AACnC,MAAA,IAAI,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAAG;AAEzB,MAAA,IAAA,CAAK,WAAA,CAAY,GAAG,KAAK,CAAA;AAAA,IAC3B,CAAA,EAAG,KAAK,aAAa,CAAA;AAAA,EACvB;AAAA,EAES,QAAA,GAAiB;AACxB,IAAA,IAAA,CAAK,WAAA,EAAY;AAEjB,IAAA,KAAA,CAAM,QAAA,EAAS;AAAA,EACjB;AACF;;;;"}
+{"version":3,"file":"debounce.mjs","sourceRoot":"","sources":["../../../src/core/operators/debounce.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAQ/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,YAAoB,EACY,EAAE;AAClC,oEAAoE;AACpE,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,wBAAwB,CACtB,gBAAgB,EAChB,YAAY,CACb,CAAmC,CAAC;AAEzC,MAAM,wBAAwB,GAAG,CAC/B,gBAA+B,EAC/B,YAAoB,EACW,EAAE;IACjC,IAAI,WAAW,GAAwB,SAAS,CAAC;IAEjD,MAAM,UAAU,GAAG,GAAS,EAAE;QAC5B,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,YAAY,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC,CAAC;IAEF,OAAO,0BAA0B,CAC/B;QACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;QAC3B,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;QAC5C,UAAU,EAAE,UAAU;KACvB,EACD,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAClB,CAAC,WAAW,EAAE,EAAE;QACd,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAE1C,IACE,gBAAgB,CAAC,WAAW,KAAK,WAAW;YAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;YACD,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,UAAU,EAAE,CAAC;QAEb,YAAY;QACZ,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAAE,OAAO;YAEhC,WAAW,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC,EAAE,YAAY,CAAC,CAAC;IACnB,CAAC,CACJ,CAAC;AACJ,CAAC,CAAC"}