synstate 3.0.0 → 3.0.1

package/dist/core/operators/pairwise.mjs

@@ -1,30 +1,80 @@
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 
-const pairwise = () => f;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const pairwise = () => f;
 const f = (parentObservable) => createPairwiseObservable(parentObservable);
-const createPairwiseObservable = (parentObservable) => createSyncChildObservable(
-  {
+const createPairwiseObservable = (parentObservable) => createSyncChildObservable({
     parents: [parentObservable],
-    initialValue: Optional.none
-  },
-  ({ setNext }) => {
+    initialValue: Optional.none,
+}, ({ setNext }) => {
+
+
     let mut_previousValue = parentObservable.getSnapshot();
     return (updateToken) => {
-      const sn = parentObservable.getSnapshot();
-      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
-        return;
-      }
-      const prev = mut_previousValue;
-      const cond = !Optional.isNone(prev);
-      mut_previousValue = parentObservable.getSnapshot();
-      if (cond) {
-        setNext([prev.value, sn.value], updateToken);
-      }
-    };
-  }
-);
+        const sn = parentObservable.getSnapshot();
+        if (parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
+        }
+        const prev = mut_previousValue;
+        const cond = !Optional.isNone(prev);
 
-export { pairwise };
-//# sourceMappingURL=pairwise.mjs.map
+        mut_previousValue = parentObservable.getSnapshot();
+        if (cond) {
+            setNext([prev.value, sn.value], updateToken);
+        }
+    };
+});
+//# sourceMappingURL=pairwise.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"pairwise.mjs","sources":["../../../src/core/operators/pairwise.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { type FixedLengthTuple } from 'ts-type-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type PairwiseOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Emits the previous and current values as a pair.\n * Does not emit until the source has emitted at least twice.\n *\n * @template A - The type of values from the source\n * @returns An operator that pairs consecutive values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     2     3     4\n * //  pairs$          [1,2] [2,3] [3,4]\n * //\n * //  Explanation:\n * //  - pairwise emits the current and previous values as a tuple\n * //  - Nothing is emitted for the first value (no previous value yet)\n * //  - Useful for tracking changes between consecutive values\n *\n * const num$ = source<number>();\n *\n * const pairs$ = num$.pipe(pairwise());\n *\n * const valueHistory: FixedLengthTuple<2, number>[] = [];\n *\n * pairs$.subscribe(([prev, curr]) => {\n *   valueHistory.push([prev, curr]);\n * });\n *\n * num$.next(1); // nothing logged\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * num$.next(2); // logs: 1, 2\n *\n * assert.deepStrictEqual(valueHistory, [[1, 2]]);\n *\n * num$.next(3); // logs: 2, 3\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, 2],\n *   [2, 3],\n * ]);\n *\n * num$.next(4); // logs: 3, 4\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [1, 2],\n *   [2, 3],\n *   [3, 4],\n * ]);\n * ```\n */\nexport const pairwise = <A,>(): DropInitialValueOperator<\n  A,\n  FixedLengthTuple<2, A>\n> => f;\n\nconst f = <A,>(\n  parentObservable: Observable<A>,\n): Observable<FixedLengthTuple<2, A>> =>\n  createPairwiseObservable(parentObservable);\n\nconst createPairwiseObservable = <A,>(\n  parentObservable: Observable<A>,\n): PairwiseOperatorObservable<A> =>\n  createSyncChildObservable<FixedLengthTuple<2, A>, readonly [A]>(\n    {\n      parents: [parentObservable],\n      initialValue: Optional.none,\n    },\n    ({ setNext }) => {\n      // parentObservable.snapshot has value\n      // if parentObservable is InitializedObservable\n      let mut_previousValue: Optional<A> = parentObservable.getSnapshot();\n\n      return (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        const prev = mut_previousValue;\n\n        const cond = !Optional.isNone(prev);\n\n        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively\n        mut_previousValue = parentObservable.getSnapshot();\n\n        if (cond) {\n          setNext([prev.value, sn.value], updateToken);\n        }\n      };\n    },\n  );\n"],"names":[],"mappings":";;;;AA8DO,MAAM,WAAW,MAGnB;AAEL,MAAM,CAAA,GAAI,CACR,gBAAA,KAEA,wBAAA,CAAyB,gBAAgB,CAAA;AAE3C,MAAM,wBAAA,GAA2B,CAC/B,gBAAA,KAEA,yBAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,cAAc,QAAA,CAAS;AAAA,GACzB;AAAA,EACA,CAAC,EAAE,OAAA,EAAQ,KAAM;AAGf,IAAA,IAAI,iBAAA,GAAiC,iBAAiB,WAAA,EAAY;AAElE,IAAA,OAAO,CAAC,WAAA,KAAgB;AACtB,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,MAAM,IAAA,GAAO,iBAAA;AAEb,MAAA,MAAM,IAAA,GAAO,CAAC,QAAA,CAAS,MAAA,CAAO,IAAI,CAAA;AAGlC,MAAA,iBAAA,GAAoB,iBAAiB,WAAA,EAAY;AAEjD,MAAA,IAAI,IAAA,EAAM;AACR,QAAA,OAAA,CAAQ,CAAC,IAAA,CAAK,KAAA,EAAO,EAAA,CAAG,KAAK,GAAG,WAAW,CAAA;AAAA,MAC7C;AAAA,IACF,CAAA;AAAA,EACF;AACF,CAAA;;;;"}
+{"version":3,"file":"pairwise.mjs","sourceRoot":"","sources":["../../../src/core/operators/pairwise.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAO9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,GAGtB,EAAE,CAAC,CAAC,CAAC;AAEP,MAAM,CAAC,GAAG,CACR,gBAA+B,EACK,EAAE,CACtC,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;AAE7C,MAAM,wBAAwB,GAAG,CAC/B,gBAA+B,EACA,EAAE,CACjC,yBAAyB,CACvB;IACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;CAC5B,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;IACd,sCAAsC;IACtC,+CAA+C;IAC/C,IAAI,iBAAiB,GAAgB,gBAAgB,CAAC,WAAW,EAAE,CAAC;IAEpE,OAAO,CAAC,WAAW,EAAE,EAAE;QACrB,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,MAAM,IAAI,GAAG,iBAAiB,CAAC;QAE/B,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAEpC,wHAAwH;QACxH,iBAAiB,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAEnD,IAAI,IAAI,EAAE,CAAC;YACT,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CACF,CAAC"}

package/dist/core/operators/scan.mjs

@@ -1,22 +1,66 @@
 import { Optional } from 'ts-data-forge';
-import { createInitializedSyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
+import { createInitializedSyncChildObservable } from '../base/index.mjs';
 
-const scan = (reducer, initialValue) => (parentObservable) => createScanObservable(parentObservable, reducer, initialValue);
-const createScanObservable = (parentObservable, reducer, initialValue) => createInitializedSyncChildObservable(
-  {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const scan = (reducer, initialValue) => (parentObservable) => createScanObservable(parentObservable, reducer, initialValue);
+const createScanObservable = (parentObservable, reducer, initialValue) => createInitializedSyncChildObservable({
     parents: [parentObservable],
-    initialValue: Optional.some(initialValue)
-  },
-  ({ setNext, getSnapshot }) => (updateToken) => {
+    initialValue: Optional.some(initialValue),
+}, ({ setNext, getSnapshot }) => (updateToken) => {
     const psn = parentObservable.getSnapshot();
     const sn = getSnapshot();
-    if (parentObservable.updateToken !== updateToken || Optional.isNone(psn) || Optional.isNone(sn)) {
-      return;
+    if (parentObservable.updateToken !== updateToken ||
+        Optional.isNone(psn) ||
+        Optional.isNone(sn)) {
+        return;
     }
     setNext(reducer(sn.value, psn.value), updateToken);
-  }
-);
-
-export { scan };
-//# sourceMappingURL=scan.mjs.map
+});
+//# sourceMappingURL=scan.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"scan.mjs","sources":["../../../src/core/operators/scan.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createInitializedSyncChildObservable } from '../base/index.mjs';\nimport {\n  type Observable,\n  type ScanOperatorObservable,\n  type WithInitialValueOperator,\n} from '../types/index.mjs';\n\n/**\n * Applies an accumulator function over the source observable and emits each intermediate result.\n * Similar to Array.reduce but emits accumulated value after each source emission.\n *\n * @template A - The type of values from the source\n * @template B - The type of the accumulated value\n * @param reducer - The accumulator function\n * @param initialValue - The initial accumulated value (seed)\n * @returns An operator that accumulates values\n *\n * @example\n * ```ts\n * //  Timeline (accumulating sum):\n * //\n * //  num$    1     2     3     4     5\n * //  sum$    1     3     6     10    15\n * //          |     |     |     |     |\n * //          0+1   1+2   3+3   6+4   10+5\n * //\n * //  Explanation:\n * //  - scan accumulates values over time using a reducer function\n * //  - Starting with seed value 0, each emission adds to the accumulator\n * //  - Similar to Array.reduce, but for streams\n *\n * const num$ = source<number>();\n *\n * const sum$ = num$.pipe(scan((acc, curr) => acc + curr, 0));\n *\n * const valueHistory: number[] = [];\n *\n * sum$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * assert.deepStrictEqual(valueHistory, [0]);\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [0, 1]);\n *\n * num$.next(2); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [0, 1, 3]);\n *\n * num$.next(3); // logs: 6\n *\n * assert.deepStrictEqual(valueHistory, [0, 1, 3, 6]);\n * ```\n */\nexport const scan =\n  <A, B>(\n    reducer: (acc: B, curr: A) => B,\n    initialValue: B,\n  ): WithInitialValueOperator<A, B> =>\n  (parentObservable) =>\n    createScanObservable(parentObservable, reducer, initialValue);\n\nconst createScanObservable = <A, B>(\n  parentObservable: Observable<A>,\n  reducer: (acc: B, curr: A) => B,\n  initialValue: B,\n): ScanOperatorObservable<A, B> =>\n  createInitializedSyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: Optional.some(initialValue),\n    },\n    ({ setNext, getSnapshot }) =>\n      (updateToken) => {\n        const psn = parentObservable.getSnapshot();\n\n        const sn = getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(psn) ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        setNext(reducer(sn.value, psn.value), updateToken);\n      },\n  );\n"],"names":[],"mappings":";;;;AAyDO,MAAM,IAAA,GACX,CACE,OAAA,EACA,YAAA,KAEF,CAAC,gBAAA,KACC,oBAAA,CAAqB,gBAAA,EAAkB,OAAA,EAAS,YAAY;AAEhE,MAAM,oBAAA,GAAuB,CAC3B,gBAAA,EACA,OAAA,EACA,YAAA,KAEA,oCAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,YAAA,EAAc,QAAA,CAAS,IAAA,CAAK,YAAY;AAAA,GAC1C;AAAA,EACA,CAAC,EAAE,OAAA,EAAS,WAAA,EAAY,KACtB,CAAC,WAAA,KAAgB;AACf,IAAA,MAAM,GAAA,GAAM,iBAAiB,WAAA,EAAY;AAEzC,IAAA,MAAM,KAAK,WAAA,EAAY;AAEvB,IAAA,IACE,gBAAA,CAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,GAAG,CAAA,IACnB,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,MAAA;AAAA,IACF;AAEA,IAAA,OAAA,CAAQ,QAAQ,EAAA,CAAG,KAAA,EAAO,GAAA,CAAI,KAAK,GAAG,WAAW,CAAA;AAAA,EACnD;AACJ,CAAA;;;;"}
+{"version":3,"file":"scan.mjs","sourceRoot":"","sources":["../../../src/core/operators/scan.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,oCAAoC,EAAE,MAAM,mBAAmB,CAAC;AAOzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,CAAC,MAAM,IAAI,GACf,CACE,OAA+B,EAC/B,YAAe,EACiB,EAAE,CACpC,CAAC,gBAAgB,EAAE,EAAE,CACnB,oBAAoB,CAAC,gBAAgB,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;AAElE,MAAM,oBAAoB,GAAG,CAC3B,gBAA+B,EAC/B,OAA+B,EAC/B,YAAe,EACe,EAAE,CAChC,oCAAoC,CAClC;IACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;CAC1C,EACD,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,EAAE,CAC3B,CAAC,WAAW,EAAE,EAAE;IACd,MAAM,GAAG,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;IAE3C,MAAM,EAAE,GAAG,WAAW,EAAE,CAAC;IAEzB,IACE,gBAAgB,CAAC,WAAW,KAAK,WAAW;QAC5C,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;QACpB,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;QACD,OAAO,CAAC,cAAc;IACxB,CAAC;IAED,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;AACrD,CAAC,CACJ,CAAC"}

package/dist/core/operators/skip-if-no-change.mjs

@@ -1,36 +1,94 @@
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
-
-const skipIfNoChange = (eq = (x, y) => Object.is(x, y)) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ((parentObservable) => createSkipIfNoChangeObservable(
-    parentObservable,
-    eq
-  ))
-);
-const distinctUntilChanged = skipIfNoChange;
-const createSkipIfNoChangeObservable = (parentObservable, eq) => createSyncChildObservable(
-  {
+import { createSyncChildObservable } from '../base/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const skipIfNoChange = (eq = (x, y) => Object.is(x, y)) => 
+
+((parentObservable) => createSkipIfNoChangeObservable(parentObservable, eq));
+
+
+
+
+export const distinctUntilChanged = skipIfNoChange;
+const createSkipIfNoChangeObservable = (parentObservable, eq) => createSyncChildObservable({
     parents: [parentObservable],
-    initialValue: parentObservable.getSnapshot()
-  },
-  ({ setNext }) => {
+    initialValue: parentObservable.getSnapshot(),
+}, ({ setNext }) => {
+
+
     let mut_previousValue = parentObservable.getSnapshot();
     return (updateToken) => {
-      const sn = parentObservable.getSnapshot();
-      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
-        return;
-      }
-      const prev = mut_previousValue;
-      const cond = Optional.isNone(prev) || !eq(prev.value, sn.value);
-      mut_previousValue = sn;
-      if (cond) {
-        setNext(sn.value, updateToken);
-      }
-    };
-  }
-);
+        const sn = parentObservable.getSnapshot();
+        if (parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
+        }
+        const prev = mut_previousValue;
+        const cond = Optional.isNone(prev) || !eq(prev.value, sn.value);
 
-export { distinctUntilChanged, skipIfNoChange };
-//# sourceMappingURL=skip-if-no-change.mjs.map
+        mut_previousValue = sn;
+        if (cond) {
+            setNext(sn.value, updateToken);
+        }
+    };
+});
+//# sourceMappingURL=skip-if-no-change.mjs.map

package/dist/core/operators/skip-if-no-change.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"skip-if-no-change.mjs","sources":["../../../src/core/operators/skip-if-no-change.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type KeepInitialValueOperator,\n  type Observable,\n  type SkipIfNoChangeOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Skips emissions if the value hasn't changed from the previous emission.\n * Uses a custom equality function or Object.is by default.\n *\n * @template A - The type of values from the source\n * @param eq - Equality comparison function (default: Object.is)\n * @returns An operator that skips duplicate consecutive values\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     1     2     2     1     2     3     2\n * //  distinct$ 1           2           1     2     3     2\n * //\n * //  Explanation:\n * //  - skipIfNoChange filters out consecutive duplicate values\n * //  - Uses strict equality (===) for comparison\n * //  - Only emits when the value actually changes\n *\n * const num$ = source<number>();\n *\n * const distinct$ = num$.pipe(skipIfNoChange());\n *\n * const valueHistory: number[] = [];\n *\n * distinct$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * num$.next(1); // nothing logged\n *\n * assert.deepStrictEqual(valueHistory, [1]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2]);\n *\n * num$.next(2); // nothing logged\n *\n * num$.next(1); // logs: 1\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2]);\n *\n * num$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2, 3]);\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 1, 2, 3, 2]);\n * ```\n */\nexport const skipIfNoChange = <A,>(\n  eq: (x: A, y: A) => boolean = (x, y) => Object.is(x, y),\n): KeepInitialValueOperator<A, A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ((parentObservable) =>\n    createSkipIfNoChangeObservable(\n      parentObservable,\n      eq,\n    )) as KeepInitialValueOperator<A, A>;\n\n/**\n * Alias for `skipIfNoChange`.\n * @see skipIfNoChange\n */\nexport const distinctUntilChanged = skipIfNoChange;\n\nconst createSkipIfNoChangeObservable = <A,>(\n  parentObservable: Observable<A>,\n  eq: (x: A, y: A) => boolean,\n): SkipIfNoChangeOperatorObservable<A> =>\n  createSyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: parentObservable.getSnapshot(),\n    },\n    ({ setNext }) => {\n      // parentObservable.snapshot has value\n      // if parentObservable is InitializedObservable\n      let mut_previousValue: Optional<A> = parentObservable.getSnapshot();\n\n      return (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        const prev = mut_previousValue;\n\n        const cond = Optional.isNone(prev) || !eq(prev.value, sn.value);\n\n        // NOTE: Must update before setNext, otherwise Optional.isNone(prev) remains true when tryUpdate is called consecutively\n        mut_previousValue = sn;\n\n        if (cond) {\n          setNext(sn.value, updateToken);\n        }\n      };\n    },\n  );\n"],"names":[],"mappings":";;;;AAqEO,MAAM,cAAA,GAAiB,CAC5B,EAAA,GAA8B,CAAC,GAAG,CAAA,KAAM,MAAA,CAAO,EAAA,CAAG,CAAA,EAAG,CAAC,CAAA;AAAA;AAAA,GAGrD,CAAC,gBAAA,KACA,8BAAA;AAAA,IACE,gBAAA;AAAA,IACA;AAAA,GACF;AAAA;AAMG,MAAM,oBAAA,GAAuB;AAEpC,MAAM,8BAAA,GAAiC,CACrC,gBAAA,EACA,EAAA,KAEA,yBAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,YAAA,EAAc,iBAAiB,WAAA;AAAY,GAC7C;AAAA,EACA,CAAC,EAAE,OAAA,EAAQ,KAAM;AAGf,IAAA,IAAI,iBAAA,GAAiC,iBAAiB,WAAA,EAAY;AAElE,IAAA,OAAO,CAAC,WAAA,KAAgB;AACtB,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,MAAM,IAAA,GAAO,iBAAA;AAEb,MAAA,MAAM,IAAA,GAAO,QAAA,CAAS,MAAA,CAAO,IAAI,CAAA,IAAK,CAAC,EAAA,CAAG,IAAA,CAAK,KAAA,EAAO,EAAA,CAAG,KAAK,CAAA;AAG9D,MAAA,iBAAA,GAAoB,EAAA;AAEpB,MAAA,IAAI,IAAA,EAAM;AACR,QAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAAA,MAC/B;AAAA,IACF,CAAA;AAAA,EACF;AACF,CAAA;;;;"}
+{"version":3,"file":"skip-if-no-change.mjs","sourceRoot":"","sources":["../../../src/core/operators/skip-if-no-change.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAO9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,EAAE,GAA4B,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EACvB,EAAE;AAClC,oEAAoE;AACpE,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,8BAA8B,CAC5B,gBAAgB,EAChB,EAAE,CACH,CAAmC,CAAC;AAEzC;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,cAAc,CAAC;AAEnD,MAAM,8BAA8B,GAAG,CACrC,gBAA+B,EAC/B,EAA2B,EACU,EAAE,CACvC,yBAAyB,CACvB;IACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;CAC7C,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;IACd,sCAAsC;IACtC,+CAA+C;IAC/C,IAAI,iBAAiB,GAAgB,gBAAgB,CAAC,WAAW,EAAE,CAAC;IAEpE,OAAO,CAAC,WAAW,EAAE,EAAE;QACrB,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,MAAM,IAAI,GAAG,iBAAiB,CAAC;QAE/B,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;QAEhE,wHAAwH;QACxH,iBAAiB,GAAG,EAAE,CAAC;QAEvB,IAAI,IAAI,EAAE,CAAC;YACT,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QACjC,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CACF,CAAC"}

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

@@ -1,33 +1,75 @@
 import { Optional } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
+import { createSyncChildObservable } from '../base/index.mjs';
 
-const skipUntil = (notifier) => (parentObservable) => createSkipUntilObservable(parentObservable, notifier);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const skipUntil = (notifier) => (parentObservable) => createSkipUntilObservable(parentObservable, notifier);
 const createSkipUntilObservable = (parentObservable, notifier) => {
-  let mut_isSkipping = true;
-  const observable = createSyncChildObservable(
-    {
-      parents: [parentObservable],
-      initialValue: Optional.none
-    },
-    ({ setNext }) => (updateToken) => {
-      const sn = parentObservable.getSnapshot();
-      if (mut_isSkipping || parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
-        return;
-      }
-      setNext(sn.value, updateToken);
-    }
-  );
-  notifier.subscribe(
-    () => {
-      mut_isSkipping = false;
-    },
-    () => {
-      mut_isSkipping = false;
-    }
-  );
-  return observable;
+    let mut_isSkipping = true;
+    const observable = createSyncChildObservable({
+        parents: [parentObservable],
+        initialValue: Optional.none,
+    }, ({ setNext }) => (updateToken) => {
+        const sn = parentObservable.getSnapshot();
+        if (mut_isSkipping ||
+            parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
+        }
+        setNext(sn.value, updateToken);
+    });
+    notifier.subscribe(() => {
+        mut_isSkipping = false;
+    }, () => {
+        mut_isSkipping = false;
+    });
+    return observable;
 };
-
-export { skipUntil };
-//# sourceMappingURL=skip-until.mjs.map
+//# sourceMappingURL=skip-until.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"skip-until.mjs","sources":["../../../src/core/operators/skip-until.mts"],"sourcesContent":["import { Optional } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type SkipUntilOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Skips all values from the source observable until the notifier observable emits.\n *\n * @template A - The type of values from the source\n * @param notifier - An observable that signals when to start emitting\n * @returns An operator that skips values until the notifier emits\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$          1     2     3     start   4     5     6\n * //  startNotifier                   X\n * //  skipped$                                4     5     6\n * //                |------ skipped -------|\n * //\n * //  Explanation:\n * //  - skipUntil ignores all values until the notifier emits\n * //  - After the notifier emits, all subsequent values are passed through\n * //  - Opposite of takeUntil (which completes when notifier emits)\n *\n * const num$ = source<number>();\n *\n * const [startNotifier, start_] = createEventEmitter();\n *\n * const skipped$ = num$.pipe(skipUntil(startNotifier));\n *\n * const valueHistory: number[] = [];\n *\n * skipped$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // nothing logged\n *\n * num$.next(2); // nothing logged\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * start_();\n *\n * num$.next(4); // logs: 4\n *\n * assert.deepStrictEqual(valueHistory, [4]);\n *\n * num$.next(5); // logs: 5\n *\n * assert.deepStrictEqual(valueHistory, [4, 5]);\n * ```\n */\nexport const skipUntil =\n  <A,>(notifier: Observable<unknown>): DropInitialValueOperator<A, A> =>\n  (parentObservable) =>\n    createSkipUntilObservable(parentObservable, notifier);\n\nconst createSkipUntilObservable = <A,>(\n  parentObservable: Observable<A>,\n  notifier: Observable<unknown>,\n): SkipUntilOperatorObservable<A> => {\n  let mut_isSkipping = true;\n\n  const observable = createSyncChildObservable<A, readonly [A]>(\n    {\n      parents: [parentObservable],\n      initialValue: Optional.none,\n    },\n    ({ setNext }) =>\n      (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          mut_isSkipping ||\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        setNext(sn.value, updateToken);\n      },\n  );\n\n  notifier.subscribe(\n    () => {\n      mut_isSkipping = false;\n    },\n    () => {\n      mut_isSkipping = false;\n    },\n  );\n\n  return observable;\n};\n"],"names":[],"mappings":";;;;AA0DO,MAAM,YACX,CAAK,QAAA,KACL,CAAC,gBAAA,KACC,yBAAA,CAA0B,kBAAkB,QAAQ;AAExD,MAAM,yBAAA,GAA4B,CAChC,gBAAA,EACA,QAAA,KACmC;AACnC,EAAA,IAAI,cAAA,GAAiB,IAAA;AAErB,EAAA,MAAM,UAAA,GAAa,yBAAA;AAAA,IACjB;AAAA,MACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,MAC1B,cAAc,QAAA,CAAS;AAAA,KACzB;AAAA,IACA,CAAC,EAAE,OAAA,EAAQ,KACT,CAAC,WAAA,KAAgB;AACf,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,kBACA,gBAAA,CAAiB,WAAA,KAAgB,eACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAAA,IAC/B;AAAA,GACJ;AAEA,EAAA,QAAA,CAAS,SAAA;AAAA,IACP,MAAM;AACJ,MAAA,cAAA,GAAiB,KAAA;AAAA,IACnB,CAAA;AAAA,IACA,MAAM;AACJ,MAAA,cAAA,GAAiB,KAAA;AAAA,IACnB;AAAA,GACF;AAEA,EAAA,OAAO,UAAA;AACT,CAAA;;;;"}
+{"version":3,"file":"skip-until.mjs","sourceRoot":"","sources":["../../../src/core/operators/skip-until.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAO9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,CAAC,MAAM,SAAS,GACpB,CAAK,QAA6B,EAAkC,EAAE,CACtE,CAAC,gBAAgB,EAAE,EAAE,CACnB,yBAAyB,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;AAE1D,MAAM,yBAAyB,GAAG,CAChC,gBAA+B,EAC/B,QAA6B,EACG,EAAE;IAClC,IAAI,cAAc,GAAG,IAAI,CAAC;IAE1B,MAAM,UAAU,GAAG,yBAAyB,CAC1C;QACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;QAC3B,YAAY,EAAE,QAAQ,CAAC,IAAI;KAC5B,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CACd,CAAC,WAAW,EAAE,EAAE;QACd,MAAM,EAAE,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAE1C,IACE,cAAc;YACd,gBAAgB,CAAC,WAAW,KAAK,WAAW;YAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EACnB,CAAC;YACD,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACjC,CAAC,CACJ,CAAC;IAEF,QAAQ,CAAC,SAAS,CAChB,GAAG,EAAE;QACH,cAAc,GAAG,KAAK,CAAC;IACzB,CAAC,EACD,GAAG,EAAE;QACH,cAAc,GAAG,KAAK,CAAC;IACzB,CAAC,CACF,CAAC;IAEF,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC"}

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

@@ -1,33 +1,85 @@
-import { Optional, asSafeUint, SafeUint, pipe } from 'ts-data-forge';
-import { createSyncChildObservable } from '../base/create-child-observable.mjs';
-import '../utils/id-maker.mjs';
+import { Optional, SafeUint, asSafeUint, pipe } from 'ts-data-forge';
+import { createSyncChildObservable } from '../base/index.mjs';
 
-const skipWhile = (predicate) => (parentObservable) => createSkipWhileObservable(parentObservable, predicate);
-const createSkipWhileObservable = (parentObservable, predicate) => createSyncChildObservable(
-  {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const skipWhile = (predicate) => (parentObservable) => createSkipWhileObservable(parentObservable, predicate);
+
+const createSkipWhileObservable = (parentObservable, predicate) => createSyncChildObservable({
     parents: [parentObservable],
-    initialValue: pipe(parentObservable.getSnapshot()).map(
-      (sn) => Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn
-    ).value
-  },
-  ({ setNext }) => {
+    initialValue: pipe(parentObservable.getSnapshot()).map((sn) => Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn).value,
+}, ({ setNext }) => {
     let mut_index = -1;
     let mut_skipping = true;
     return (updateToken) => {
-      const sn = parentObservable.getSnapshot();
-      if (parentObservable.updateToken !== updateToken || Optional.isNone(sn)) {
-        return;
-      }
-      mut_index = mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);
-      if (!predicate(sn.value, mut_index)) {
-        mut_skipping = false;
-      }
-      if (!mut_skipping) {
-        setNext(sn.value, updateToken);
-      }
+        const sn = parentObservable.getSnapshot();
+        if (parentObservable.updateToken !== updateToken ||
+            Optional.isNone(sn)) {
+            return;
+        }
+        mut_index =
+            mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);
+        if (!predicate(sn.value, mut_index)) {
+            mut_skipping = false;
+        }
+        if (!mut_skipping) {
+            setNext(sn.value, updateToken);
+        }
     };
-  }
-);
-
-export { skipWhile };
-//# sourceMappingURL=skip-while.mjs.map
+});
+//# sourceMappingURL=skip-while.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"skip-while.mjs","sources":["../../../src/core/operators/skip-while.mts"],"sourcesContent":["import { Optional, SafeUint, asSafeUint, pipe } from 'ts-data-forge';\nimport { createSyncChildObservable } from '../base/index.mjs';\nimport {\n  type DropInitialValueOperator,\n  type Observable,\n  type SkipWhileOperatorObservable,\n} from '../types/index.mjs';\n\n/**\n * Skips values from the source observable while the predicate returns true.\n * Once the predicate returns false, all subsequent values pass through.\n *\n * @template A - The type of values from the source\n * @param predicate - Function to test each value\n * @returns An operator that skips values while the predicate is true\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$        1     2     3     4     5     6     7     1     2\n * //  skipped$                            5     6     7     1     2\n * //              |-------- skip --------|\n * //\n * //  Explanation:\n * //  - skipWhile skips values while the predicate returns true\n * //  - Once the predicate returns false, all subsequent values pass through\n * //  - Unlike filter, the predicate is never checked again after the first false\n *\n * const num$ = source<number>();\n *\n * const skipped$ = num$.pipe(skipWhile((x) => x < 5));\n *\n * const valueHistory: number[] = [];\n *\n * skipped$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // nothing logged\n *\n * num$.next(2); // nothing logged\n *\n * num$.next(3); // nothing logged\n *\n * num$.next(4); // nothing logged\n *\n * num$.next(5); // logs: 5\n *\n * assert.deepStrictEqual(valueHistory, [5]);\n *\n * num$.next(6); // logs: 6\n *\n * assert.deepStrictEqual(valueHistory, [5, 6]);\n *\n * num$.next(7); // logs: 7\n *\n * assert.deepStrictEqual(valueHistory, [5, 6, 7]);\n *\n * num$.next(1); // logs: 1\n *\n * num$.next(2); // logs: 2\n *\n * assert.deepStrictEqual(valueHistory, [5, 6, 7, 1, 2]);\n * ```\n */\nexport const skipWhile =\n  <A,>(\n    predicate: (value: A, index: SafeUint | -1) => boolean,\n  ): DropInitialValueOperator<A, A> =>\n  (parentObservable) =>\n    createSkipWhileObservable(parentObservable, predicate);\n\n/* implementation */\n\nconst createSkipWhileObservable = <A,>(\n  parentObservable: Observable<A>,\n  predicate: (value: A, index: SafeUint | -1) => boolean,\n): SkipWhileOperatorObservable<A> =>\n  createSyncChildObservable(\n    {\n      parents: [parentObservable],\n      initialValue: pipe(parentObservable.getSnapshot()).map((sn) =>\n        Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn,\n      ).value,\n    },\n    ({ setNext }) => {\n      let mut_index: SafeUint | -1 = -1;\n\n      let mut_skipping = true;\n\n      return (updateToken) => {\n        const sn = parentObservable.getSnapshot();\n\n        if (\n          parentObservable.updateToken !== updateToken ||\n          Optional.isNone(sn)\n        ) {\n          return; // skip update\n        }\n\n        mut_index =\n          mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, mut_index);\n\n        if (!predicate(sn.value, mut_index)) {\n          mut_skipping = false;\n        }\n\n        if (!mut_skipping) {\n          setNext(sn.value, updateToken);\n        }\n      };\n    },\n  );\n"],"names":[],"mappings":";;;;AAkEO,MAAM,YACX,CACE,SAAA,KAEF,CAAC,gBAAA,KACC,yBAAA,CAA0B,kBAAkB,SAAS;AAIzD,MAAM,yBAAA,GAA4B,CAChC,gBAAA,EACA,SAAA,KAEA,yBAAA;AAAA,EACE;AAAA,IACE,OAAA,EAAS,CAAC,gBAAgB,CAAA;AAAA,IAC1B,YAAA,EAAc,IAAA,CAAK,gBAAA,CAAiB,WAAA,EAAa,CAAA,CAAE,GAAA;AAAA,MAAI,CAAC,EAAA,KACtD,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,IAAK,SAAA,CAAU,EAAA,CAAG,KAAA,EAAO,EAAE,CAAA,GAAI,QAAA,CAAS,IAAA,GAAO;AAAA,KACnE,CAAE;AAAA,GACJ;AAAA,EACA,CAAC,EAAE,OAAA,EAAQ,KAAM;AACf,IAAA,IAAI,SAAA,GAA2B,EAAA;AAE/B,IAAA,IAAI,YAAA,GAAe,IAAA;AAEnB,IAAA,OAAO,CAAC,WAAA,KAAgB;AACtB,MAAA,MAAM,EAAA,GAAK,iBAAiB,WAAA,EAAY;AAExC,MAAA,IACE,iBAAiB,WAAA,KAAgB,WAAA,IACjC,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA,EAClB;AACA,QAAA;AAAA,MACF;AAEA,MAAA,SAAA,GACE,SAAA,KAAc,KAAK,UAAA,CAAW,CAAC,IAAI,QAAA,CAAS,GAAA,CAAI,GAAG,SAAS,CAAA;AAE9D,MAAA,IAAI,CAAC,SAAA,CAAU,EAAA,CAAG,KAAA,EAAO,SAAS,CAAA,EAAG;AACnC,QAAA,YAAA,GAAe,KAAA;AAAA,MACjB;AAEA,MAAA,IAAI,CAAC,YAAA,EAAc;AACjB,QAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,WAAW,CAAA;AAAA,MAC/B;AAAA,IACF,CAAA;AAAA,EACF;AACF,CAAA;;;;"}
+{"version":3,"file":"skip-while.mjs","sourceRoot":"","sources":["../../../src/core/operators/skip-while.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAO9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,CAAC,MAAM,SAAS,GACpB,CACE,SAAsD,EACtB,EAAE,CACpC,CAAC,gBAAgB,EAAE,EAAE,CACnB,yBAAyB,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;AAE3D,oBAAoB;AAEpB,MAAM,yBAAyB,GAAG,CAChC,gBAA+B,EAC/B,SAAsD,EACtB,EAAE,CAClC,yBAAyB,CACvB;IACE,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,YAAY,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAC5D,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CACpE,CAAC,KAAK;CACR,EACD,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE;IACd,IAAI,SAAS,GAAkB,CAAC,CAAC,CAAC;IAElC,IAAI,YAAY,GAAG,IAAI,CAAC;IAExB,OAAO,CAAC,WAAW,EAAE,EAAE;QACrB,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,SAAS;YACP,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAEhE,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;YACpC,YAAY,GAAG,KAAK,CAAC;QACvB,CAAC;QAED,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QACjC,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CACF,CAAC"}