synstate 1.0.1 → 2.0.0

package/dist/core/predefined/operators/map-result-err.mjs

@@ -2,54 +2,7 @@ import { Result } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Transforms the error value (`Err`) of a `Result` type emitted by the source.
- * If the value is `Err`, the mapping function is applied; if `Ok`, it remains unchanged.
- *
- * @template R - The Result type from the source
- * @template E2 - The type of the mapped error value
- * @param mapFn - A function to transform the Err value
- * @returns An operator that maps the Err side of Result emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  result$   Ok(1)    Err("bad")      Err("fail")
- * //  mapped$   Ok(1)    Err("BAD")      Err("FAIL")
- * //
- * //  Explanation:
- * //  - mapResultErr transforms the Err value of Result emissions
- * //  - Ok values pass through unchanged
- *
- * const result$ = source<Result<number, string>>();
- *
- * const mapped$ = result$.pipe(mapResultErr((e) => e.toUpperCase()));
- *
- * const valueHistory: Result<number, string>[] = [];
- *
- * mapped$.subscribe((v) => {
- *   valueHistory.push(v);
- * });
- *
- * result$.next(Result.ok(1));
- *
- * assert.deepStrictEqual(valueHistory, [Result.ok(1)]);
- *
- * result$.next(Result.err('bad'));
- *
- * assert.deepStrictEqual(valueHistory, [Result.ok(1), Result.err('BAD')]);
- *
- * result$.next(Result.err('fail'));
- *
- * assert.deepStrictEqual(valueHistory, [
- *   Result.ok(1),
- *   Result.err('BAD'),
- *   Result.err('FAIL'),
- * ]);
- * ```
- */
-const mapResultErr = (mapFn) => map((a) => Result.mapErr(a, mapFn));
+const mapResultErr = (mapFn) => map(Result.mapErr(mapFn));
 
 export { mapResultErr };
 //# sourceMappingURL=map-result-err.mjs.map

package/dist/core/predefined/operators/map-result-err.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-result-err.mjs","sources":["../../../../src/core/predefined/operators/map-result-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,YAAY,GAAG,CAC1B,KAAqC,KAErC,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC;;;;"}
+{"version":3,"file":"map-result-err.mjs","sources":["../../../../src/core/predefined/operators/map-result-err.mts"],"sourcesContent":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Transforms the error value (`Err`) of a `Result` type emitted by the source.\n * If the value is `Err`, the mapping function is applied; if `Ok`, it remains unchanged.\n *\n * @template R - The Result type from the source\n * @template E2 - The type of the mapped error value\n * @param mapFn - A function to transform the Err value\n * @returns An operator that maps the Err side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$   Ok(1)    Err(\"bad\")      Err(\"fail\")\n * //  mapped$   Ok(1)    Err(\"BAD\")      Err(\"FAIL\")\n * //\n * //  Explanation:\n * //  - mapResultErr transforms the Err value of Result emissions\n * //  - Ok values pass through unchanged\n *\n * const result$ = source<Result<number, string>>();\n *\n * const mapped$ = result$.pipe(mapResultErr((e) => e.toUpperCase()));\n *\n * const valueHistory: Result<number, string>[] = [];\n *\n * mapped$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(1));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(1)]);\n *\n * result$.next(Result.err('bad'));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(1), Result.err('BAD')]);\n *\n * result$.next(Result.err('fail'));\n *\n * assert.deepStrictEqual(valueHistory, [\n *   Result.ok(1),\n *   Result.err('BAD'),\n *   Result.err('FAIL'),\n * ]);\n * ```\n */\nexport const mapResultErr = <R extends UnknownResult, E2>(\n  mapFn: (x: Result.UnwrapErr<R>) => E2,\n): KeepInitialValueOperator<R, Result<Result.UnwrapOk<R>, E2>> =>\n  map(Result.mapErr(mapFn));\n"],"names":[],"mappings":";;;;AAmDO,MAAM,eAAe,CAC1B,KAAA,KAEA,IAAI,MAAA,CAAO,MAAA,CAAO,KAAK,CAAC;;;;"}

package/dist/core/predefined/operators/map-result-ok.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"map-result-ok.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-result-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,aAAa,EAAE,EAAE,EACrD,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,KACnC,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAC5B,CAAC"}
+{"version":3,"file":"map-result-ok.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-result-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,aAAa,EAAE,EAAE,SAC9C,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,KACnC,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CACtC,CAAC"}

package/dist/core/predefined/operators/map-result-ok.mjs

@@ -2,54 +2,7 @@ import { Result } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Transforms the success value (`Ok`) of a `Result` type emitted by the source.
- * If the value is `Ok`, the mapping function is applied; if `Err`, it remains unchanged.
- *
- * @template R - The Result type from the source
- * @template S2 - The type of the mapped success value
- * @param mapFn - A function to transform the Ok value
- * @returns An operator that maps the Ok side of Result emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  result$   Ok(2)      Err("e")   Ok(5)
- * //  doubled$  Ok(4)      Err("e")   Ok(10)
- * //
- * //  Explanation:
- * //  - mapResultOk transforms the Ok value of Result emissions
- * //  - Err values pass through unchanged
- *
- * const result$ = source<Result<number, string>>();
- *
- * const doubled$ = result$.pipe(mapResultOk((x) => x * 2));
- *
- * const valueHistory: Result<number, string>[] = [];
- *
- * doubled$.subscribe((v) => {
- *   valueHistory.push(v);
- * });
- *
- * result$.next(Result.ok(2));
- *
- * assert.deepStrictEqual(valueHistory, [Result.ok(4)]);
- *
- * result$.next(Result.err('e'));
- *
- * assert.deepStrictEqual(valueHistory, [Result.ok(4), Result.err('e')]);
- *
- * result$.next(Result.ok(5));
- *
- * assert.deepStrictEqual(valueHistory, [
- *   Result.ok(4),
- *   Result.err('e'),
- *   Result.ok(10),
- * ]);
- * ```
- */
-const mapResultOk = (mapFn) => map((a) => Result.map(a, mapFn));
+const mapResultOk = (mapFn) => map(Result.map(mapFn));
 
 export { mapResultOk };
 //# sourceMappingURL=map-result-ok.mjs.map

package/dist/core/predefined/operators/map-result-ok.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-result-ok.mjs","sources":["../../../../src/core/predefined/operators/map-result-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,WAAW,GAAG,CACzB,KAAoC,KAEpC,GAAG,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC;;;;"}
+{"version":3,"file":"map-result-ok.mjs","sources":["../../../../src/core/predefined/operators/map-result-ok.mts"],"sourcesContent":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Transforms the success value (`Ok`) of a `Result` type emitted by the source.\n * If the value is `Ok`, the mapping function is applied; if `Err`, it remains unchanged.\n *\n * @template R - The Result type from the source\n * @template S2 - The type of the mapped success value\n * @param mapFn - A function to transform the Ok value\n * @returns An operator that maps the Ok side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$   Ok(2)      Err(\"e\")   Ok(5)\n * //  doubled$  Ok(4)      Err(\"e\")   Ok(10)\n * //\n * //  Explanation:\n * //  - mapResultOk transforms the Ok value of Result emissions\n * //  - Err values pass through unchanged\n *\n * const result$ = source<Result<number, string>>();\n *\n * const doubled$ = result$.pipe(mapResultOk((x) => x * 2));\n *\n * const valueHistory: Result<number, string>[] = [];\n *\n * doubled$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(2));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(4)]);\n *\n * result$.next(Result.err('e'));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(4), Result.err('e')]);\n *\n * result$.next(Result.ok(5));\n *\n * assert.deepStrictEqual(valueHistory, [\n *   Result.ok(4),\n *   Result.err('e'),\n *   Result.ok(10),\n * ]);\n * ```\n */\nexport const mapResultOk = <R extends UnknownResult, S2>(\n  mapFn: (x: Result.UnwrapOk<R>) => S2,\n): KeepInitialValueOperator<R, Result<S2, Result.UnwrapErr<R>>> =>\n  map(Result.map(mapFn));\n"],"names":[],"mappings":";;;;AAmDO,MAAM,cAAc,CACzB,KAAA,KAEA,IAAI,MAAA,CAAO,GAAA,CAAI,KAAK,CAAC;;;;"}

package/dist/core/predefined/operators/map-to.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"map-to.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-to.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAClD,CAAC"}
+{"version":3,"file":"map-to.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-to.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAClD,CAAC"}

package/dist/core/predefined/operators/map-to.mjs

@@ -2,46 +2,6 @@ import 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Maps all emitted values to a constant value, ignoring the source values.
- * Equivalent to `map(() => value)`.
- *
- * @template A - The type of values from the source
- * @template B - The type of the constant value
- * @param value - The constant value to emit
- * @returns An operator that always emits the given constant
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  click$    MouseEvent   MouseEvent   MouseEvent
- * //  count$    1            1            1
- * //
- * //  Explanation:
- * //  - mapTo maps all emitted values to a constant value
- * //  - Ignores the source values entirely
- * //  - Useful for converting events to signals
- *
- * const click$ = source<string>();
- *
- * const one$ = click$.pipe(mapTo(1));
- *
- * const valueHistory: number[] = [];
- *
- * one$.subscribe((value) => {
- *   valueHistory.push(value);
- * });
- *
- * click$.next('click1');
- *
- * click$.next('click2');
- *
- * click$.next('click3');
- *
- * assert.deepStrictEqual(valueHistory, [1, 1, 1]);
- * ```
- */
 const mapTo = (value) => map(() => value);
 
 export { mapTo };

package/dist/core/predefined/operators/map-to.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-to.mjs","sources":["../../../../src/core/predefined/operators/map-to.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACI,MAAM,KAAK,GAAG,CAAO,KAAQ,KAClC,GAAG,CAAC,MAAM,KAAK;;;;"}
+{"version":3,"file":"map-to.mjs","sources":["../../../../src/core/predefined/operators/map-to.mts"],"sourcesContent":["import { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Maps all emitted values to a constant value, ignoring the source values.\n * Equivalent to `map(() => value)`.\n *\n * @template A - The type of values from the source\n * @template B - The type of the constant value\n * @param value - The constant value to emit\n * @returns An operator that always emits the given constant\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  click$    MouseEvent   MouseEvent   MouseEvent\n * //  count$    1            1            1\n * //\n * //  Explanation:\n * //  - mapTo maps all emitted values to a constant value\n * //  - Ignores the source values entirely\n * //  - Useful for converting events to signals\n *\n * const click$ = source<string>();\n *\n * const one$ = click$.pipe(mapTo(1));\n *\n * const valueHistory: number[] = [];\n *\n * one$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * click$.next('click1');\n *\n * click$.next('click2');\n *\n * click$.next('click3');\n *\n * assert.deepStrictEqual(valueHistory, [1, 1, 1]);\n * ```\n */\nexport const mapTo = <A, B>(value: B): KeepInitialValueOperator<A, B> =>\n  map(() => value);\n"],"names":[],"mappings":";;;;AA2CO,MAAM,KAAA,GAAQ,CAAO,KAAA,KAC1B,GAAA,CAAI,MAAM,KAAK;;;;"}

package/dist/core/predefined/operators/pluck.d.mts

@@ -43,5 +43,5 @@ export declare const pluck: <A, K extends keyof A>(key: K) => KeepInitialValueOp
  * Alias for `pluck`.
  * @see pluck
  */
-export declare const getKey: <A, K extends keyof A>(key: K) => KeepInitialValueOperator<A, A[K]>;
+export declare const getKey: typeof pluck;
 //# sourceMappingURL=pluck.d.mts.map

package/dist/core/predefined/operators/pluck.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pluck.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/pluck.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EACxC,KAAK,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAuB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,MAAM,GARG,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,OACnC,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAMR,CAAC"}
+{"version":3,"file":"pluck.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/pluck.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,OACnC,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAuB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,MAAM,cAAQ,CAAC"}

package/dist/core/predefined/operators/pluck.mjs

@@ -2,50 +2,7 @@ import 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Extracts a property value from each emitted object by key.
- * Equivalent to `map(value => value[key])`.
- *
- * @template A - The type of the emitted object
- * @template K - The key to extract
- * @param key - The property key to pluck
- * @returns An operator that emits the property value
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  user$   { name: "Alice", age: 25 }   { name: "Bob", age: 30 }
- * //  name$   "Alice"                       "Bob"
- * //
- * //  Explanation:
- * //  - getKey extracts a property value from each emitted object
- * //  - Equivalent to map(value => value[key])
- *
- * const user$ = source<Readonly<{ name: string; age: number }>>();
- *
- * const name$ = user$.pipe(getKey('name'));
- *
- * const valueHistory: string[] = [];
- *
- * name$.subscribe((n) => {
- *   valueHistory.push(n);
- * });
- *
- * user$.next({ name: 'Alice', age: 25 });
- *
- * assert.deepStrictEqual(valueHistory, ['Alice']);
- *
- * user$.next({ name: 'Bob', age: 30 });
- *
- * assert.deepStrictEqual(valueHistory, ['Alice', 'Bob']);
- * ```
- */
 const pluck = (key) => map((a) => a[key]);
-/**
- * Alias for `pluck`.
- * @see pluck
- */
 const getKey = pluck;
 
 export { getKey, pluck };

package/dist/core/predefined/operators/pluck.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pluck.mjs","sources":["../../../../src/core/predefined/operators/pluck.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;MACU,KAAK,GAAG,CACnB,GAAM,KACgC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC;AAEzD;;;AAGG;AACI,MAAM,MAAM,GAAG;;;;"}
+{"version":3,"file":"pluck.mjs","sources":["../../../../src/core/predefined/operators/pluck.mts"],"sourcesContent":["import { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Extracts a property value from each emitted object by key.\n * Equivalent to `map(value => value[key])`.\n *\n * @template A - The type of the emitted object\n * @template K - The key to extract\n * @param key - The property key to pluck\n * @returns An operator that emits the property value\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  user$   { name: \"Alice\", age: 25 }   { name: \"Bob\", age: 30 }\n * //  name$   \"Alice\"                       \"Bob\"\n * //\n * //  Explanation:\n * //  - getKey extracts a property value from each emitted object\n * //  - Equivalent to map(value => value[key])\n *\n * const user$ = source<Readonly<{ name: string; age: number }>>();\n *\n * const name$ = user$.pipe(getKey('name'));\n *\n * const valueHistory: string[] = [];\n *\n * name$.subscribe((n) => {\n *   valueHistory.push(n);\n * });\n *\n * user$.next({ name: 'Alice', age: 25 });\n *\n * assert.deepStrictEqual(valueHistory, ['Alice']);\n *\n * user$.next({ name: 'Bob', age: 30 });\n *\n * assert.deepStrictEqual(valueHistory, ['Alice', 'Bob']);\n * ```\n */\nexport const pluck = <A, K extends keyof A>(\n  key: K,\n): KeepInitialValueOperator<A, A[K]> => map((a) => a[key]);\n\n/**\n * Alias for `pluck`.\n * @see pluck\n */\nexport const getKey = pluck;\n"],"names":[],"mappings":";;;;AA0CO,MAAM,KAAA,GAAQ,CACnB,GAAA,KACsC,GAAA,CAAI,CAAC,CAAA,KAAM,CAAA,CAAE,GAAG,CAAC;AAMlD,MAAM,MAAA,GAAS;;;;"}

package/dist/core/predefined/operators/skip.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"skip.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/skip.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EACpB,GAAG,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CACyC,CAAC"}
+{"version":3,"file":"skip.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/skip.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,KACjB,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CACyC,CAAC"}

package/dist/core/predefined/operators/skip.mjs

@@ -2,53 +2,6 @@ import { PositiveSafeInt } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { skipWhile } from '../../operators/skip-while.mjs';
 
-/**
- * Skips the first `n` emissions from the source observable.
- * After `n` values are skipped, all subsequent values pass through.
- *
- * @template A - The type of values from the source
- * @param n - The number of values to skip
- * @returns An operator that skips the first n emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$      1     2     3     4     5
- * //  skipped$              3     4     5
- * //            |skip 2|
- * //
- * //  Explanation:
- * //  - skip ignores the first n emissions from the source
- * //  - After n values are skipped, all subsequent values pass through
- *
- * const num$ = source<number>();
- *
- * const skipped$ = num$.pipe(skip(2));
- *
- * const valueHistory: number[] = [];
- *
- * skipped$.subscribe((x) => {
- *   valueHistory.push(x);
- * });
- *
- * num$.next(1); // skipped
- *
- * num$.next(2); // skipped
- *
- * assert.deepStrictEqual(valueHistory, []);
- *
- * num$.next(3); // logs: 3
- *
- * assert.deepStrictEqual(valueHistory, [3]);
- *
- * num$.next(4); // logs: 4
- *
- * num$.next(5); // logs: 5
- *
- * assert.deepStrictEqual(valueHistory, [3, 4, 5]);
- * ```
- */
 const skip = (n) => !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
 const idFn = (value) => value;
 

package/dist/core/predefined/operators/skip.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"skip.mjs","sources":["../../../../src/core/predefined/operators/skip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,IAAI,GAAG,CAClB,CAA8B,KAE9B,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,GAAG,CAAC,IAAI,CAAC;AAExE,MAAM,IAAI,GAAG,CAAK,KAAQ,KAAQ,KAAK;;;;"}
+{"version":3,"file":"skip.mjs","sources":["../../../../src/core/predefined/operators/skip.mts"],"sourcesContent":["import { PositiveSafeInt } from 'ts-data-forge';\nimport { type PositiveSafeIntWithSmallInt } from 'ts-type-forge';\nimport { skipWhile } from '../../operators/index.mjs';\nimport { type DropInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Skips the first `n` emissions from the source observable.\n * After `n` values are skipped, all subsequent values pass through.\n *\n * @template A - The type of values from the source\n * @param n - The number of values to skip\n * @returns An operator that skips the first n emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     2     3     4     5\n * //  skipped$              3     4     5\n * //            |skip 2|\n * //\n * //  Explanation:\n * //  - skip ignores the first n emissions from the source\n * //  - After n values are skipped, all subsequent values pass through\n *\n * const num$ = source<number>();\n *\n * const skipped$ = num$.pipe(skip(2));\n *\n * const valueHistory: number[] = [];\n *\n * skipped$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // skipped\n *\n * num$.next(2); // skipped\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * num$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * num$.next(4); // logs: 4\n *\n * num$.next(5); // logs: 5\n *\n * assert.deepStrictEqual(valueHistory, [3, 4, 5]);\n * ```\n */\nexport const skip = <A,>(\n  n: PositiveSafeIntWithSmallInt,\n): DropInitialValueOperator<A, A> =>\n  !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);\n\nconst idFn = <T,>(value: T): T => value;\n"],"names":[],"mappings":";;;;AAoDO,MAAM,IAAA,GAAO,CAClB,CAAA,KAEA,CAAC,gBAAgB,EAAA,CAAG,CAAC,CAAA,GAAI,IAAA,GAAO,UAAU,CAAC,CAAA,EAAG,KAAA,KAAU,KAAA,GAAQ,KAAK,CAAC;AAExE,MAAM,IAAA,GAAO,CAAK,KAAA,KAAgB,KAAA;;;;"}

package/dist/core/predefined/operators/take.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"take.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/take.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EACpB,GAAG,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}
+{"version":3,"file":"take.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/take.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,KACjB,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}

package/dist/core/predefined/operators/take.mjs

@@ -2,47 +2,6 @@ import 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { takeWhile } from '../../operators/take-while.mjs';
 
-/**
- * Takes only the first `n` emissions from the source observable, then completes.
- *
- * @template A - The type of values from the source
- * @param n - The number of values to take
- * @returns An operator that takes the first n emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  num$    1     2     3     4 (ignored)
- * //  taken$  1     2     3     | (completes)
- * //
- * //  Explanation:
- * //  - take emits only the first n values, then completes
- * //  - Subsequent emissions from the source are ignored
- *
- * const num$ = source<number>();
- *
- * const taken$ = num$.pipe(take(3));
- *
- * const valueHistory: number[] = [];
- *
- * taken$.subscribe((x) => {
- *   valueHistory.push(x);
- * });
- *
- * num$.next(1);
- *
- * num$.next(2);
- *
- * num$.next(3);
- *
- * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
- *
- * num$.next(4); // ignored (already completed)
- *
- * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
- * ```
- */
 const take = (n) => takeWhile((_, index) => index + 1 <= n);
 
 export { take };

package/dist/core/predefined/operators/take.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"take.mjs","sources":["../../../../src/core/predefined/operators/take.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCG;AACI,MAAM,IAAI,GAAG,CAClB,CAA8B,KACK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,GAAG,CAAC,IAAI,CAAC;;;;"}
+{"version":3,"file":"take.mjs","sources":["../../../../src/core/predefined/operators/take.mts"],"sourcesContent":["import { type PositiveSafeIntWithSmallInt } from 'ts-type-forge';\nimport { takeWhile } from '../../operators/index.mjs';\nimport { type DropInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Takes only the first `n` emissions from the source observable, then completes.\n *\n * @template A - The type of values from the source\n * @param n - The number of values to take\n * @returns An operator that takes the first n emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$    1     2     3     4 (ignored)\n * //  taken$  1     2     3     | (completes)\n * //\n * //  Explanation:\n * //  - take emits only the first n values, then completes\n * //  - Subsequent emissions from the source are ignored\n *\n * const num$ = source<number>();\n *\n * const taken$ = num$.pipe(take(3));\n *\n * const valueHistory: number[] = [];\n *\n * taken$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1);\n *\n * num$.next(2);\n *\n * num$.next(3);\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n *\n * num$.next(4); // ignored (already completed)\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport const take = <A,>(\n  n: PositiveSafeIntWithSmallInt,\n): DropInitialValueOperator<A, A> => takeWhile((_, index) => index + 1 <= n);\n"],"names":[],"mappings":";;;;AA6CO,MAAM,IAAA,GAAO,CAClB,CAAA,KACmC,SAAA,CAAU,CAAC,CAAA,EAAG,KAAA,KAAU,KAAA,GAAQ,CAAA,IAAK,CAAC;;;;"}

package/dist/core/predefined/operators/unwrap-optional.mjs

@@ -2,49 +2,10 @@ import { Optional } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Unwraps `Optional` values, converting `Some(value)` to `value` and `None` to `undefined`.
- *
- * @template O - The Optional type from the source
- * @returns An operator that unwraps Optional emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  opt$        Some(42)    None        Some(7)
- * //  unwrapped$  42          undefined   7
- * //
- * //  Explanation:
- * //  - unwrapOptional converts Some(value) to value, and None to undefined
- * //  - Useful for extracting raw values from Optional streams
- *
- * const opt$ = source<Optional<number>>();
- *
- * const unwrapped$ = opt$.pipe(unwrapOptional());
- *
- * const valueHistory: (number | undefined)[] = [];
- *
- * unwrapped$.subscribe((v) => {
- *   valueHistory.push(v);
- * });
- *
- * opt$.next(Optional.some(42));
- *
- * assert.deepStrictEqual(valueHistory, [42]);
- *
- * opt$.next(Optional.none);
- *
- * assert.deepStrictEqual(valueHistory, [42, undefined]);
- *
- * opt$.next(Optional.some(7));
- *
- * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);
- * ```
- */
-const unwrapOptional = () => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-map(Optional.unwrap);
+const unwrapOptional = () => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  map(Optional.unwrap)
+);
 
 export { unwrapOptional };
 //# sourceMappingURL=unwrap-optional.mjs.map

package/dist/core/predefined/operators/unwrap-optional.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-optional.mjs","sources":["../../../../src/core/predefined/operators/unwrap-optional.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACI,MAAM,cAAc,GAAG;AAG5B;AACA,GAAG,CAAC,QAAQ,CAAC,MAA+C;;;;"}
+{"version":3,"file":"unwrap-optional.mjs","sources":["../../../../src/core/predefined/operators/unwrap-optional.mts"],"sourcesContent":["import { Optional, type UnknownOptional } from 'ts-data-forge';\nimport { type Fn } from 'ts-type-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Unwraps `Optional` values, converting `Some(value)` to `value` and `None` to `undefined`.\n *\n * @template O - The Optional type from the source\n * @returns An operator that unwraps Optional emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  opt$        Some(42)    None        Some(7)\n * //  unwrapped$  42          undefined   7\n * //\n * //  Explanation:\n * //  - unwrapOptional converts Some(value) to value, and None to undefined\n * //  - Useful for extracting raw values from Optional streams\n *\n * const opt$ = source<Optional<number>>();\n *\n * const unwrapped$ = opt$.pipe(unwrapOptional());\n *\n * const valueHistory: (number | undefined)[] = [];\n *\n * unwrapped$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * opt$.next(Optional.some(42));\n *\n * assert.deepStrictEqual(valueHistory, [42]);\n *\n * opt$.next(Optional.none);\n *\n * assert.deepStrictEqual(valueHistory, [42, undefined]);\n *\n * opt$.next(Optional.some(7));\n *\n * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);\n * ```\n */\nexport const unwrapOptional = <\n  O extends UnknownOptional,\n>(): KeepInitialValueOperator<O, Optional.Unwrap<O> | undefined> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  map(Optional.unwrap as Fn<O, Optional.Unwrap<O> | undefined>);\n"],"names":[],"mappings":";;;;AA6CO,MAAM,cAAA,GAAiB;AAAA;AAAA,EAI5B,GAAA,CAAI,SAAS,MAA+C;AAAA;;;;"}

package/dist/core/predefined/operators/unwrap-result-err.mjs

@@ -2,46 +2,6 @@ import { Result } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Unwraps the error value from a `Result`, converting `Err(error)` to `error` and `Ok` to `undefined`.
- *
- * @template R - The Result type from the source
- * @returns An operator that unwraps the Err side of Result emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  result$     Ok(1)      Err("fail")   Ok(2)
- * //  unwrapped$  undefined  "fail"        undefined
- * //
- * //  Explanation:
- * //  - unwrapResultErr converts Err(error) to error, and Ok to undefined
- * //  - Useful for extracting error values from Result streams
- *
- * const result$ = source<Result<number, string>>();
- *
- * const unwrapped$ = result$.pipe(unwrapResultErr());
- *
- * const valueHistory: (string | undefined)[] = [];
- *
- * unwrapped$.subscribe((v) => {
- *   valueHistory.push(v);
- * });
- *
- * result$.next(Result.ok(1));
- *
- * assert.deepStrictEqual(valueHistory, [undefined]);
- *
- * result$.next(Result.err('fail'));
- *
- * assert.deepStrictEqual(valueHistory, [undefined, 'fail']);
- *
- * result$.next(Result.ok(2));
- *
- * assert.deepStrictEqual(valueHistory, [undefined, 'fail', undefined]);
- * ```
- */
 const unwrapResultErr = () => map(Result.unwrapErr);
 
 export { unwrapResultErr };

package/dist/core/predefined/operators/unwrap-result-err.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-result-err.mjs","sources":["../../../../src/core/predefined/operators/unwrap-result-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACI,MAAM,eAAe,GAAG,MAG7B,GAAG,CAAC,MAAM,CAAC,SAAmD;;;;"}
+{"version":3,"file":"unwrap-result-err.mjs","sources":["../../../../src/core/predefined/operators/unwrap-result-err.mts"],"sourcesContent":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { type Fn } from 'ts-type-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Unwraps the error value from a `Result`, converting `Err(error)` to `error` and `Ok` to `undefined`.\n *\n * @template R - The Result type from the source\n * @returns An operator that unwraps the Err side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$     Ok(1)      Err(\"fail\")   Ok(2)\n * //  unwrapped$  undefined  \"fail\"        undefined\n * //\n * //  Explanation:\n * //  - unwrapResultErr converts Err(error) to error, and Ok to undefined\n * //  - Useful for extracting error values from Result streams\n *\n * const result$ = source<Result<number, string>>();\n *\n * const unwrapped$ = result$.pipe(unwrapResultErr());\n *\n * const valueHistory: (string | undefined)[] = [];\n *\n * unwrapped$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(1));\n *\n * assert.deepStrictEqual(valueHistory, [undefined]);\n *\n * result$.next(Result.err('fail'));\n *\n * assert.deepStrictEqual(valueHistory, [undefined, 'fail']);\n *\n * result$.next(Result.ok(2));\n *\n * assert.deepStrictEqual(valueHistory, [undefined, 'fail', undefined]);\n * ```\n */\nexport const unwrapResultErr = <\n  R extends UnknownResult,\n>(): KeepInitialValueOperator<R, Result.UnwrapErr<R> | undefined> =>\n  map(Result.unwrapErr as Fn<R, Result.UnwrapErr<R> | undefined>);\n"],"names":[],"mappings":";;;;AA6CO,MAAM,eAAA,GAAkB,MAG7B,GAAA,CAAI,MAAA,CAAO,SAAmD;;;;"}

package/dist/core/predefined/operators/unwrap-result-ok.mjs

@@ -2,49 +2,10 @@ import { Result } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { map } from '../../operators/map.mjs';
 
-/**
- * Unwraps the success value from a `Result`, converting `Ok(value)` to `value` and `Err` to `undefined`.
- *
- * @template R - The Result type from the source
- * @returns An operator that unwraps the Ok side of Result emissions
- *
- * @example
- * ```ts
- * //  Timeline:
- * //
- * //  result$     Ok(42)    Err("e")    Ok(7)
- * //  unwrapped$  42        undefined   7
- * //
- * //  Explanation:
- * //  - unwrapResultOk converts Ok(value) to value, and Err to undefined
- * //  - Useful for extracting success values from Result streams
- *
- * const result$ = source<Result<number, string>>();
- *
- * const unwrapped$ = result$.pipe(unwrapResultOk());
- *
- * const valueHistory: (number | undefined)[] = [];
- *
- * unwrapped$.subscribe((v) => {
- *   valueHistory.push(v);
- * });
- *
- * result$.next(Result.ok(42));
- *
- * assert.deepStrictEqual(valueHistory, [42]);
- *
- * result$.next(Result.err('e'));
- *
- * assert.deepStrictEqual(valueHistory, [42, undefined]);
- *
- * result$.next(Result.ok(7));
- *
- * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);
- * ```
- */
-const unwrapResultOk = () => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-map(Result.unwrapOk);
+const unwrapResultOk = () => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  map(Result.unwrapOk)
+);
 
 export { unwrapResultOk };
 //# sourceMappingURL=unwrap-result-ok.mjs.map

package/dist/core/predefined/operators/unwrap-result-ok.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-result-ok.mjs","sources":["../../../../src/core/predefined/operators/unwrap-result-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACI,MAAM,cAAc,GAAG;AAG5B;AACA,GAAG,CAAC,MAAM,CAAC,QAAiD;;;;"}
+{"version":3,"file":"unwrap-result-ok.mjs","sources":["../../../../src/core/predefined/operators/unwrap-result-ok.mts"],"sourcesContent":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { type Fn } from 'ts-type-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Unwraps the success value from a `Result`, converting `Ok(value)` to `value` and `Err` to `undefined`.\n *\n * @template R - The Result type from the source\n * @returns An operator that unwraps the Ok side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$     Ok(42)    Err(\"e\")    Ok(7)\n * //  unwrapped$  42        undefined   7\n * //\n * //  Explanation:\n * //  - unwrapResultOk converts Ok(value) to value, and Err to undefined\n * //  - Useful for extracting success values from Result streams\n *\n * const result$ = source<Result<number, string>>();\n *\n * const unwrapped$ = result$.pipe(unwrapResultOk());\n *\n * const valueHistory: (number | undefined)[] = [];\n *\n * unwrapped$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(42));\n *\n * assert.deepStrictEqual(valueHistory, [42]);\n *\n * result$.next(Result.err('e'));\n *\n * assert.deepStrictEqual(valueHistory, [42, undefined]);\n *\n * result$.next(Result.ok(7));\n *\n * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);\n * ```\n */\nexport const unwrapResultOk = <\n  R extends UnknownResult,\n>(): KeepInitialValueOperator<R, Result.UnwrapOk<R> | undefined> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  map(Result.unwrapOk as Fn<R, Result.UnwrapOk<R> | undefined>);\n"],"names":[],"mappings":";;;;AA6CO,MAAM,cAAA,GAAiB;AAAA;AAAA,EAI5B,GAAA,CAAI,OAAO,QAAiD;AAAA;;;;"}

package/dist/core/types/observable-family.d.mts

@@ -1,5 +1,5 @@
 import { type Result } from 'ts-data-forge';
-import { type ArrayElement, type NonEmptyArray, type SafeUint } from 'ts-type-forge';
+import { type ArrayElement, type FixedLengthTuple, type NonEmptyTuple, type SafeUint } from 'ts-type-forge';
 import { type AsyncChildObservable, type InitializedObservable, type InitializedRootObservable, type InitializedSyncChildObservable, type Observable, type RootObservable, type SyncChildObservable, type Unwrap } from './observable.mjs';
 import { type NonEmptyUnknownList } from './types.mjs';
 export type InitializedSourceObservable<A> = Readonly<{
@@ -20,33 +20,33 @@ export type WithInitialValueOperatorObservable<A, I = A> = InitializedSyncChildO
 export type ScanOperatorObservable<A, B> = InitializedSyncChildObservable<B, readonly [A]>;
 declare namespace SynStateInternals {
     type Cast<A> = A extends NonEmptyUnknownList ? A : never;
-    type EveryInitialized<OS extends NonEmptyArray<Observable<unknown>>> = OS extends NonEmptyArray<InitializedObservable<unknown>> ? true : false;
+    type EveryInitialized<OS extends NonEmptyTuple<Observable<unknown>>> = OS extends NonEmptyTuple<InitializedObservable<unknown>> ? true : false;
     type IsInitialized<O> = readonly [O] extends readonly [
         InitializedObservable<unknown>
     ] ? true : false;
     /** Evaluates true | false as true instead of boolean */
     type LogicalValue<B extends boolean> = readonly [B] extends readonly [true] ? true : readonly [B] extends readonly [false] ? false : true;
     type SomeInitializedImpl<OS extends Observable<unknown>> = LogicalValue<OS extends OS ? IsInitialized<OS> : never>;
-    type SomeInitialized<OS extends NonEmptyArray<Observable<unknown>>> = SomeInitializedImpl<OS[number]>;
+    type SomeInitialized<OS extends NonEmptyTuple<Observable<unknown>>> = SomeInitializedImpl<OS[number]>;
     type InitializedCombineObservableImpl<A extends NonEmptyUnknownList> = InitializedSyncChildObservable<A, A>;
     export type CombineObservableImpl<A extends NonEmptyUnknownList> = SyncChildObservable<A, A>;
-    export type CombineObservableRefinedImpl<OS extends NonEmptyArray<Observable<unknown>>> = EveryInitialized<OS> extends true ? InitializedCombineObservableImpl<Cast<Unwrap<OS>>> : CombineObservableImpl<Unwrap<OS>>;
+    export type CombineObservableRefinedImpl<OS extends NonEmptyTuple<Observable<unknown>>> = EveryInitialized<OS> extends true ? InitializedCombineObservableImpl<Cast<Unwrap<OS>>> : CombineObservableImpl<Unwrap<OS>>;
     type InitializedZipObservableImpl<A extends NonEmptyUnknownList> = InitializedSyncChildObservable<A, A>;
     export type ZipObservableImpl<A extends NonEmptyUnknownList> = SyncChildObservable<A, A>;
-    export type ZipObservableRefinedImpl<OS extends NonEmptyArray<Observable<unknown>>> = EveryInitialized<OS> extends true ? InitializedZipObservableImpl<Cast<Unwrap<OS>>> : ZipObservableImpl<Unwrap<OS>>;
+    export type ZipObservableRefinedImpl<OS extends NonEmptyTuple<Observable<unknown>>> = EveryInitialized<OS> extends true ? InitializedZipObservableImpl<Cast<Unwrap<OS>>> : ZipObservableImpl<Unwrap<OS>>;
     type InitializedMergeObservableImpl<P extends NonEmptyUnknownList> = InitializedSyncChildObservable<ArrayElement<P>, P>;
     export type MergeObservableImpl<P extends NonEmptyUnknownList> = SyncChildObservable<ArrayElement<P>, P>;
-    export type MergeObservableRefinedImpl<OS extends NonEmptyArray<Observable<unknown>>> = SomeInitialized<OS> extends true ? InitializedMergeObservableImpl<Cast<Unwrap<OS>>> : MergeObservableImpl<Unwrap<OS>>;
+    export type MergeObservableRefinedImpl<OS extends NonEmptyTuple<Observable<unknown>>> = SomeInitialized<OS> extends true ? InitializedMergeObservableImpl<Cast<Unwrap<OS>>> : MergeObservableImpl<Unwrap<OS>>;
     export {};
 }
 export type CombineObservable<A extends NonEmptyUnknownList> = SynStateInternals.CombineObservableImpl<A>;
-export type CombineObservableRefined<OS extends NonEmptyArray<Observable<unknown>>> = SynStateInternals.CombineObservableRefinedImpl<OS>;
+export type CombineObservableRefined<OS extends NonEmptyTuple<Observable<unknown>>> = SynStateInternals.CombineObservableRefinedImpl<OS>;
 export type ZipObservable<A extends NonEmptyUnknownList> = SynStateInternals.ZipObservableImpl<A>;
-export type ZipObservableRefined<OS extends NonEmptyArray<Observable<unknown>>> = SynStateInternals.ZipObservableRefinedImpl<OS>;
+export type ZipObservableRefined<OS extends NonEmptyTuple<Observable<unknown>>> = SynStateInternals.ZipObservableRefinedImpl<OS>;
 export type MergeObservable<A extends NonEmptyUnknownList> = SynStateInternals.MergeObservableImpl<A>;
-export type MergeObservableRefined<OS extends NonEmptyArray<Observable<unknown>>> = SynStateInternals.MergeObservableRefinedImpl<OS>;
+export type MergeObservableRefined<OS extends NonEmptyTuple<Observable<unknown>>> = SynStateInternals.MergeObservableRefinedImpl<OS>;
 export type MapOperatorObservable<A, B> = SyncChildObservable<B, readonly [A]>;
-export type PairwiseOperatorObservable<A> = SyncChildObservable<readonly [A, A], readonly [A]>;
+export type PairwiseOperatorObservable<A> = SyncChildObservable<FixedLengthTuple<2, A>, readonly [A]>;
 export type TakeWhileOperatorObservable<A> = SyncChildObservable<A, readonly [A]>;
 export type TakeUntilOperatorObservable<A> = SyncChildObservable<A, readonly [A]>;
 export type SkipWhileOperatorObservable<A> = SyncChildObservable<A, readonly [A]>;