ts-data-forge 7.0.1 → 7.1.1

package/dist/array/impl/array-utils-creation.d.mts

@@ -47,13 +47,13 @@ export declare const seq: <N extends SizeType.ArgArr>(len: N) => N extends Small
  * assert.deepStrictEqual(emptyStrings, []);
  * ```
  */
-export declare const create: <const V, N extends SizeType.ArgArr>(len: N, init: V) => N extends SmallUint ? ArrayOfLength<N, V> : N extends SizeType.ArgArrPositive ? NonEmptyArray<V> : readonly V[];
+export declare const create: <N extends SizeType.ArgArr, const V>(len: N, init: V) => N extends SmallUint ? ArrayOfLength<N, V> : N extends SizeType.ArgArrPositive ? NonEmptyArray<V> : readonly V[];
 /**
  * Alias for `create`.
  *
  * @see {@link create}
  */
-export declare const newArray: <const V, N extends SizeType.ArgArr>(len: N, init: V) => N extends SmallUint ? ArrayOfLength<N, V> : N extends SizeType.ArgArrPositive ? NonEmptyArray<V> : readonly V[];
+export declare const newArray: <N extends SizeType.ArgArr, const V>(len: N, init: V) => N extends SmallUint ? ArrayOfLength<N, V> : N extends SizeType.ArgArrPositive ? NonEmptyArray<V> : readonly V[];
 /**
  * Generates an array from a generator function.
  *

package/dist/array/impl/array-utils-creation.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-creation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-creation.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-creation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-creation.mts"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-validation.d.mts

@@ -1,4 +1,4 @@
-import { type ArrayAtLeastLen, type ArrayOfLength, type BoolOr, type NonEmptyArray, type TypeEq } from 'ts-type-forge';
+import { type ArrayAtLeastLen, type ArrayAtMostLen, type ArrayBoundedLen, type ArrayOfLength, type BoolOr, type NonEmptyArray, type TypeEq } from 'ts-type-forge';
 import { type ArrayIndex, type SizeType } from '../../types.mjs';
 /**
  * Type guard that checks if a value is an array.
@@ -102,6 +102,46 @@ export declare const isArrayOfLength: <E, N extends SizeType.ArgArr>(array: read
  * ```
  */
 export declare const isArrayAtLeastLength: <E, N extends SizeType.ArgArr>(array: readonly E[], len: N) => array is ArrayAtLeastLen<N, E>;
+/**
+ * Checks if an array has at most a specific length.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const triple: readonly number[] = [1, 2, 3] as const;
+ *
+ * assert.isTrue(Arr.isArrayAtMostLength(pair, 2));
+ *
+ * assert.isFalse(Arr.isArrayAtMostLength(triple, 2));
+ *
+ * if (Arr.isArrayAtMostLength(pair, 2)) {
+ *   assert.isTrue(pair.length <= 2);
+ * }
+ * ```
+ */
+export declare const isArrayAtMostLength: <E, N extends SizeType.ArgArr>(array: readonly E[], len: N) => array is ArrayAtMostLen<N, E>;
+/**
+ * Checks if an array's length is within a specific inclusive range.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const quad: readonly number[] = [1, 2, 3, 4] as const;
+ *
+ * assert.isTrue(Arr.isArrayBoundedLength(pair, 1, 3));
+ *
+ * assert.isFalse(Arr.isArrayBoundedLength(quad, 1, 3));
+ *
+ * if (Arr.isArrayBoundedLength(pair, 1, 3)) {
+ *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
+ * }
+ * ```
+ */
+export declare const isArrayBoundedLength: <E, Min extends SizeType.ArgArr, Max extends SizeType.ArgArr>(array: readonly E[], min: Min, max: Max) => array is ArrayBoundedLen<Min, Max, E>;
 /**
  * Tests whether all elements in an array pass a test implemented by a predicate.
  *

package/dist/array/impl/array-utils-validation.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-validation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-validation.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,MAAM,EACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAG,OAAO,CAAC,KAAG,KAAK,IAAI,WAAW,CAAC,CAAC,CACvC,CAAC;AAEvB,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAE7B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,SAAS,IAAI,GACrD,IAAI,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,CAAC,GAC3B,CAAC,SAAS,SAAS,OAAO,EAAE,GAC1B,CAAC,GACD,KAAK,GACT,KAAK,CAAC;AAEV,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAI1C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAG,OAAO,SAAS,CAAC,EAAE,KAAG,KAAK,IAAI,SAAS,EAChD,CAAC;AAErB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAC1B,OAAO,SAAS,CAAC,EAAE,KAClB,KAAK,IAAI,aAAa,CAAC,CAAC,CAAqB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,SAAS,QAAQ,CAAC,MAAM,EAC1D,OAAO,SAAS,CAAC,EAAE,EACnB,KAAK,CAAC,KACL,KAAK,IAAI,aAAa,CAAC,CAAC,EAAE,CAAC,CAAyB,CAAC;AAExD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,CAAC,SAAS,QAAQ,CAAC,MAAM,EAC/D,OAAO,SAAS,CAAC,EAAE,EACnB,KAAK,CAAC,KACL,KAAK,IAAI,eAAe,CAAC,CAAC,EAAE,CAAC,CAAwB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,GAC/C,KAAK,IAAI,SAAS,CAAC,EAAE,CAAC;AAEzB,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EAClC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,GAC/C,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,KAAK,IAAI,SAAS,CAAC,EAAE,CAAC;AAGlD,wBAAgB,KAAK,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACvD,KAAK,EAAE,EAAE,EACT,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,OAAO,GAC3D,OAAO,CAAC;AAEX,wBAAgB,KAAK,CAAC,CAAC,EACrB,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,KAAK,OAAO,GAChD,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,CAAC;AAyBpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACtD,KAAK,EAAE,EAAE,EACT,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,OAAO,GAC3D,OAAO,CAAC;AAEX,wBAAgB,IAAI,CAAC,CAAC,EACpB,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,KAAK,OAAO,GAChD,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,CAAC;AAyBpC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAC9B,OAAO,SAAS,CAAC,EAAE,EACnB,OAAO,QAAQ,CAAC,MAAM,KACrB,OAAgD,CAAC"}
+{"version":3,"file":"array-utils-validation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-validation.mts"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-validation.mjs

@@ -136,6 +136,46 @@ const isArrayOfLength = (array, len) => array.length === len;
  * ```
  */
 const isArrayAtLeastLength = (array, len) => array.length >= len;
+/**
+ * Checks if an array has at most a specific length.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const triple: readonly number[] = [1, 2, 3] as const;
+ *
+ * assert.isTrue(Arr.isArrayAtMostLength(pair, 2));
+ *
+ * assert.isFalse(Arr.isArrayAtMostLength(triple, 2));
+ *
+ * if (Arr.isArrayAtMostLength(pair, 2)) {
+ *   assert.isTrue(pair.length <= 2);
+ * }
+ * ```
+ */
+const isArrayAtMostLength = (array, len) => array.length <= len;
+/**
+ * Checks if an array's length is within a specific inclusive range.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const quad: readonly number[] = [1, 2, 3, 4] as const;
+ *
+ * assert.isTrue(Arr.isArrayBoundedLength(pair, 1, 3));
+ *
+ * assert.isFalse(Arr.isArrayBoundedLength(quad, 1, 3));
+ *
+ * if (Arr.isArrayBoundedLength(pair, 1, 3)) {
+ *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
+ * }
+ * ```
+ */
+const isArrayBoundedLength = (array, min, max) => array.length >= min && array.length <= max;
 function every(...args) {
     switch (args.length) {
         case 2: {
@@ -179,5 +219,5 @@ function some(...args) {
  */
 const indexIsInRange = (array, index) => Num.isInRange(0, array.length)(index);
 
-export { every, indexIsInRange, isArray, isArrayAtLeastLength, isArrayOfLength, isEmpty, isNonEmpty, some };
+export { every, indexIsInRange, isArray, isArrayAtLeastLength, isArrayAtMostLength, isArrayBoundedLength, isArrayOfLength, isEmpty, isNonEmpty, some };
 //# sourceMappingURL=array-utils-validation.mjs.map

package/dist/array/impl/array-utils-validation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-validation.mjs","sources":["../../../src/array/impl/array-utils-validation.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,OAAO,GAAG,CAAK,KAAQ,KAClC,KAAK,CAAC,OAAO,CAAC,KAAK;AAarB;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,OAAO,GAAG,CAAK,KAAmB,KAC7C,KAAK,CAAC,MAAM,KAAK;AAEnB;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,UAAU,GAAG,CACxB,KAAmB,KACW,KAAK,CAAC,MAAM,GAAG;AAE/C;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,eAAe,GAAG,CAC7B,KAAmB,EACnB,GAAM,KAC2B,KAAK,CAAC,MAAM,KAAK;AAEpD;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAClC,KAAmB,EACnB,GAAM,KAC6B,KAAK,CAAC,MAAM,IAAI;AAyC/C,SAAU,KAAK,CACnB,GAAG,IAK6D,EAAA;AAEhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,IAAI;YAE/B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,EAAE,SAAS,CAAC;QAC3C;;AAEJ;AA8BM,SAAU,IAAI,CAClB,GAAG,IAK6D,EAAA;AAEhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,IAAI;YAE/B,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC;QAC1C;;AAEJ;AAEA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,cAAc,GAAG,CAC5B,KAAmB,EACnB,KAAsB,KACV,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK;;;;"}
+{"version":3,"file":"array-utils-validation.mjs","sources":["../../../src/array/impl/array-utils-validation.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,OAAO,GAAG,CAAK,KAAQ,KAClC,KAAK,CAAC,OAAO,CAAC,KAAK;AAarB;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,OAAO,GAAG,CAAK,KAAmB,KAC7C,KAAK,CAAC,MAAM,KAAK;AAEnB;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,UAAU,GAAG,CACxB,KAAmB,KACW,KAAK,CAAC,MAAM,GAAG;AAE/C;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,eAAe,GAAG,CAC7B,KAAmB,EACnB,GAAM,KAC2B,KAAK,CAAC,MAAM,KAAK;AAEpD;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAClC,KAAmB,EACnB,GAAM,KAC6B,KAAK,CAAC,MAAM,IAAI;AAErD;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,mBAAmB,GAAG,CACjC,KAAmB,EACnB,GAAM,KAC4B,KAAK,CAAC,MAAM,IAAI;AAEpD;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAKlC,KAAmB,EACnB,GAAQ,EACR,GAAQ,KAER,KAAK,CAAC,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,MAAM,IAAI;AAyCnC,SAAU,KAAK,CACnB,GAAG,IAK6D,EAAA;AAEhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,IAAI;YAE/B,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,EAAE,SAAS,CAAC;QAC3C;;AAEJ;AA8BM,SAAU,IAAI,CAClB,GAAG,IAK6D,EAAA;AAEhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,IAAI;YAE/B,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YAExB,OAAO,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC;QAC1C;;AAEJ;AAEA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,cAAc,GAAG,CAC5B,KAAmB,EACnB,KAAsB,KACV,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK;;;;"}

package/dist/array/impl/index.mjs

@@ -9,5 +9,5 @@ export { length, size } from './array-utils-size.mjs';
 export { sliceClamped } from './array-utils-slice-clamped.mjs';
 export { butLast, drop, rest, skip, skipLast, tail, take, takeLast } from './array-utils-slicing.mjs';
 export { cartesianProduct, chunk, concat, filter, filterNot, flat, flatMap, groupBy, map, partition, scan, toReversed, toSorted, toSortedBy, uniq, uniqBy, zip } from './array-utils-transformation.mjs';
-export { every, indexIsInRange, isArray, isArrayAtLeastLength, isArrayOfLength, isEmpty, isNonEmpty, some } from './array-utils-validation.mjs';
+export { every, indexIsInRange, isArray, isArrayAtLeastLength, isArrayAtMostLength, isArrayBoundedLength, isArrayOfLength, isEmpty, isNonEmpty, some } from './array-utils-validation.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/functional/optional/impl/optional-expect-to-be.d.mts

@@ -13,7 +13,7 @@ import { type Unwrap } from './types.mjs';
  *   Optional.expectToBe(optionalValue, 'value expected') === 'data',
  * );
  *
- * const expectValue = Optional.expectToBe<string>('missing optional');
+ * const expectValue = Optional.expectToBe('missing optional');
  *
  * const throwTest = (): void => {
  *   expectValue(Optional.none);
@@ -33,5 +33,5 @@ import { type Unwrap } from './types.mjs';
  *   `None`.
  */
 export declare function expectToBe<O extends UnknownOptional>(optional: O, message: string): Unwrap<O>;
-export declare function expectToBe<S>(message: string): (optional: Optional<S>) => S;
+export declare function expectToBe(message: string): <O>(optional: Optional<O>) => O;
 //# sourceMappingURL=optional-expect-to-be.d.mts.map

package/dist/functional/optional/impl/optional-expect-to-be.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional-expect-to-be.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-expect-to-be.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGtE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,eAAe,EAClD,QAAQ,EAAE,CAAC,EACX,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,CAAC,CAAC,CAAC;AAGb,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC"}
+{"version":3,"file":"optional-expect-to-be.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-expect-to-be.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGtE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,eAAe,EAClD,QAAQ,EAAE,CAAC,EACX,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,CAAC,CAAC,CAAC;AAGb,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC"}

package/dist/functional/optional/impl/optional-or-else.d.mts

@@ -39,5 +39,5 @@ import { type Optional, type UnknownOptional } from '../optional.mjs';
  * @returns The first `Optional` if `Some`, otherwise the alternative.
  */
 export declare function orElse<O extends UnknownOptional, const O2 extends UnknownOptional>(optional: O, alternative: O2): O | O2;
-export declare function orElse<S, S2>(alternative: Optional<S2>): (optional: Optional<S>) => Optional<S> | Optional<S2>;
+export declare function orElse<O2>(alternative: Optional<O2>): <O>(optional: Optional<O>) => Optional<O> | Optional<O2>;
 //# sourceMappingURL=optional-or-else.d.mts.map

package/dist/functional/optional/impl/optional-or-else.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional-or-else.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-or-else.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAItE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,MAAM,CACpB,CAAC,SAAS,eAAe,EACzB,KAAK,CAAC,EAAE,SAAS,eAAe,EAChC,QAAQ,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;AAGxC,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAC1B,WAAW,EAAE,QAAQ,CAAC,EAAE,CAAC,GACxB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC"}
+{"version":3,"file":"optional-or-else.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-or-else.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAItE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,MAAM,CACpB,CAAC,SAAS,eAAe,EACzB,KAAK,CAAC,EAAE,SAAS,eAAe,EAChC,QAAQ,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;AAGxC,wBAAgB,MAAM,CAAC,EAAE,EACvB,WAAW,EAAE,QAAQ,CAAC,EAAE,CAAC,GACxB,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC"}

package/dist/functional/optional/impl/optional-unwrap-or.d.mts

@@ -33,5 +33,5 @@ import { type Unwrap } from './types.mjs';
  * @returns The contained value if `Some`, otherwise `defaultValue`.
  */
 export declare function unwrapOr<O extends UnknownOptional, D>(optional: O, defaultValue: D): D | Unwrap<O>;
-export declare function unwrapOr<S, D>(defaultValue: D): (optional: Optional<S>) => D | S;
+export declare function unwrapOr<D>(defaultValue: D): <O>(optional: Optional<O>) => D | O;
 //# sourceMappingURL=optional-unwrap-or.d.mts.map

package/dist/functional/optional/impl/optional-unwrap-or.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional-unwrap-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-unwrap-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEtE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,eAAe,EAAE,CAAC,EACnD,QAAQ,EAAE,CAAC,EACX,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AAGjB,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,YAAY,EAAE,CAAC,GACd,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}
+{"version":3,"file":"optional-unwrap-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-unwrap-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEtE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,eAAe,EAAE,CAAC,EACnD,QAAQ,EAAE,CAAC,EACX,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AAGjB,wBAAgB,QAAQ,CAAC,CAAC,EACxB,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}

package/dist/functional/result/impl/result-expect-to-be.d.mts

@@ -1,4 +1,4 @@
-import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnknownResult } from '../result.mjs';
 import { type UnwrapOk } from './types.mjs';
 /**
  * Unwraps a `Result`, returning the success value or throwing an error with
@@ -11,7 +11,7 @@ import { type UnwrapOk } from './types.mjs';
  *
  * assert.isTrue(Result.expectToBe(okValue, 'should have value') === 'data');
  *
- * const expectResult = Result.expectToBe<string>('missing result');
+ * const expectResult = Result.expectToBe('missing result');
  *
  * const throwTest = (): void => {
  *   expectResult(Result.err('boom'));
@@ -29,5 +29,5 @@ import { type UnwrapOk } from './types.mjs';
  * @throws Error with the provided message if the `Result` is `Result.Err`.
  */
 export declare function expectToBe<R extends UnknownResult>(result: R, message: string): UnwrapOk<R>;
-export declare function expectToBe<S>(message: string): <E>(result: Result<S, E>) => S;
+export declare function expectToBe(message: string): <R extends UnknownResult>(result: R) => UnwrapOk<R>;
 //# sourceMappingURL=result-expect-to-be.d.mts.map

package/dist/functional/result/impl/result-expect-to-be.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-expect-to-be.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGhE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,aAAa,EAChD,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,MAAM,GACd,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGf,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC"}
+{"version":3,"file":"result-expect-to-be.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,aAAa,EAChD,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,MAAM,GACd,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGf,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,GACd,CAAC,CAAC,SAAS,aAAa,EAAE,MAAM,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC"}

package/dist/functional/result/impl/result-expect-to-be.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-expect-to-be.mjs","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAyCM,SAAU,UAAU,CACxB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;AAE9B,YAAA,OAAO,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC;QACxC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI;YAEtB,OAAO,CAAC,MAAS,KAAkB,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC;QACpE;;AAEJ;AAEA,MAAM,cAAc,GAAG,CACrB,MAAS,EACT,OAAe,KACA;AACf,IAAA,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE;AAChB,QAAA,OAAO,QAAQ,CAAC,MAAM,CAAC;IACzB;AAEA,IAAA,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC;AAC1B,CAAC;;;;"}
+{"version":3,"file":"result-expect-to-be.mjs","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AA2CM,SAAU,UAAU,CACxB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;AAE9B,YAAA,OAAO,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC;QACxC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI;YAEtB,OAAO,CAAC,MAAS,KAAkB,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC;QACpE;;AAEJ;AAEA,MAAM,cAAc,GAAG,CACrB,MAAS,EACT,OAAe,KACA;AACf,IAAA,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE;AAChB,QAAA,OAAO,QAAQ,CAAC,MAAM,CAAC;IACzB;AAEA,IAAA,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC;AAC1B,CAAC;;;;"}

package/dist/functional/result/impl/result-or-else.d.mts

@@ -1,4 +1,4 @@
-import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnknownResult } from '../result.mjs';
 import { type NarrowToOk } from './types.mjs';
 /**
  * Returns the `Result` if it is `Ok`, otherwise returns the alternative.
@@ -36,5 +36,5 @@ import { type NarrowToOk } from './types.mjs';
  * @returns The first `Result` if `Ok`, otherwise the alternative.
  */
 export declare function orElse<R extends UnknownResult, R2 extends UnknownResult>(result: R, alternative: R2): NarrowToOk<R> | R2;
-export declare function orElse<S, E, S2, E2>(alternative: Result<S2, E2>): (result: Result<S, E>) => Result<S, E> | Result<S2, E2>;
+export declare function orElse<R2 extends UnknownResult>(alternative: R2): <R extends UnknownResult>(result: R) => NarrowToOk<R> | R2;
 //# sourceMappingURL=result-or-else.d.mts.map

package/dist/functional/result/impl/result-or-else.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-or-else.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-or-else.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,SAAS,aAAa,EACtE,MAAM,EAAE,CAAC,EACT,WAAW,EAAE,EAAE,GACd,UAAU,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAGtB,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjC,WAAW,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAC1B,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC"}
+{"version":3,"file":"result-or-else.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-or-else.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,SAAS,aAAa,EACtE,MAAM,EAAE,CAAC,EACT,WAAW,EAAE,EAAE,GACd,UAAU,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAGtB,wBAAgB,MAAM,CAAC,EAAE,SAAS,aAAa,EAC7C,WAAW,EAAE,EAAE,GACd,CAAC,CAAC,SAAS,aAAa,EAAE,MAAM,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC"}

package/dist/functional/result/impl/result-unwrap-err-or.d.mts

@@ -1,4 +1,4 @@
-import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnknownResult } from '../result.mjs';
 import { type UnwrapErr } from './types.mjs';
 /**
  * Unwraps a `Result`, returning the error value or a default value if it is
@@ -29,5 +29,5 @@ import { type UnwrapErr } from './types.mjs';
  * @returns The error value if `Result.Err`, otherwise `defaultValue`.
  */
 export declare function unwrapErrOr<R extends UnknownResult, D>(result: R, defaultValue: D): D | UnwrapErr<R>;
-export declare function unwrapErrOr<D>(defaultValue: D): <S, E>(result: Result<S, E>) => D | E;
+export declare function unwrapErrOr<D>(defaultValue: D): <R extends UnknownResult>(result: R) => D | UnwrapErr<R>;
 //# sourceMappingURL=result-unwrap-err-or.d.mts.map

package/dist/functional/result/impl/result-unwrap-err-or.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-err-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,EACpD,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;AAGpB,wBAAgB,WAAW,CAAC,CAAC,EAC3B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}
+{"version":3,"file":"result-unwrap-err-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,EACpD,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;AAGpB,wBAAgB,WAAW,CAAC,CAAC,EAC3B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,SAAS,aAAa,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC"}

package/dist/functional/result/impl/result-unwrap-ok-or.d.mts

@@ -1,4 +1,4 @@
-import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnknownResult } from '../result.mjs';
 import { type UnwrapOk } from './types.mjs';
 /**
  * Unwraps a `Result`, returning the success value or a default value if it is
@@ -29,5 +29,5 @@ import { type UnwrapOk } from './types.mjs';
  * @returns The success value if `Result.Ok`, otherwise `defaultValue`.
  */
 export declare function unwrapOkOr<R extends UnknownResult, D>(result: R, defaultValue: D): D | UnwrapOk<R>;
-export declare function unwrapOkOr<S, D>(defaultValue: D): <E>(result: Result<S, E>) => D | S;
+export declare function unwrapOkOr<D>(defaultValue: D): <R extends UnknownResult>(result: R) => D | UnwrapOk<R>;
 //# sourceMappingURL=result-unwrap-ok-or.d.mts.map

package/dist/functional/result/impl/result-unwrap-ok-or.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-ok-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-ok-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,EACnD,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGnB,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}
+{"version":3,"file":"result-unwrap-ok-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-ok-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,EACnD,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGnB,wBAAgB,UAAU,CAAC,CAAC,EAC1B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,SAAS,aAAa,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-expect-to-be.d.mts

@@ -10,7 +10,7 @@ import { type UnwrapOk } from './types.mjs';
  *
  * assert.strictEqual(TernaryResult.expectToBe(okValue, 'missing'), 'ready');
  *
- * const expectResult = TernaryResult.expectToBe<string>('needs value');
+ * const expectResult = TernaryResult.expectToBe('needs value');
  *
  * const throwTest = (): void => {
  *   expectResult(TernaryResult.err('oops'));
@@ -20,5 +20,5 @@ import { type UnwrapOk } from './types.mjs';
  * ```
  */
 export declare function expectToBe<R extends UnknownTernaryResult>(result: R, message: string): UnwrapOk<R>;
-export declare function expectToBe<S>(message: string): <W, E>(result: TernaryResult<S, E, W>) => S;
+export declare function expectToBe(message: string): <S, W, E>(result: TernaryResult<S, E, W>) => S;
 //# sourceMappingURL=ternary-result-expect-to-be.d.mts.map

package/dist/functional/ternary-result/impl/ternary-result-expect-to-be.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-expect-to-be.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-expect-to-be.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAC1B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,oBAAoB,EACvD,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,MAAM,GACd,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGf,wBAAgB,UAAU,CAAC,CAAC,EAC1B,OAAO,EAAE,MAAM,GACd,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC"}
+{"version":3,"file":"ternary-result-expect-to-be.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-expect-to-be.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAC1B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,oBAAoB,EACvD,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,MAAM,GACd,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGf,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,GACd,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-or-else.d.mts

@@ -1,4 +1,4 @@
-import { type TernaryResult, type UnknownTernaryResult } from '../ternary-result.mjs';
+import { type UnknownTernaryResult } from '../ternary-result.mjs';
 import { type NarrowToOk, type NarrowToWarn } from './types.mjs';
 /**
  * Returns the original result if it is Ok, otherwise the provided fallback.
@@ -25,5 +25,5 @@ import { type NarrowToOk, type NarrowToWarn } from './types.mjs';
  * ```
  */
 export declare function orElse<R extends UnknownTernaryResult, R2 extends UnknownTernaryResult>(result: R, alternative: R2): NarrowToOk<R> | NarrowToWarn<R> | R2;
-export declare function orElse<S, W, E, S2, W2, E2>(alternative: TernaryResult<S2, E2, W2>): (result: TernaryResult<S, E, W>) => TernaryResult<S, E, W> | TernaryResult<S2, E2, W2>;
+export declare function orElse<R2 extends UnknownTernaryResult>(alternative: R2): <R extends UnknownTernaryResult>(result: R) => NarrowToOk<R> | NarrowToWarn<R> | R2;
 //# sourceMappingURL=ternary-result-or-else.d.mts.map

package/dist/functional/ternary-result/impl/ternary-result-or-else.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-or-else.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-or-else.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAC1B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CACpB,CAAC,SAAS,oBAAoB,EAC9B,EAAE,SAAS,oBAAoB,EAC/B,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAGpE,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EACxC,WAAW,EAAE,aAAa,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GACrC,CACD,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC3B,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC"}
+{"version":3,"file":"ternary-result-or-else.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-or-else.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAGlE,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CACpB,CAAC,SAAS,oBAAoB,EAC9B,EAAE,SAAS,oBAAoB,EAC/B,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAGpE,wBAAgB,MAAM,CAAC,EAAE,SAAS,oBAAoB,EACpD,WAAW,EAAE,EAAE,GACd,CAAC,CAAC,SAAS,oBAAoB,EAChC,MAAM,EAAE,CAAC,KACN,UAAU,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-or-else.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-or-else.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-or-else.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AA4CM,SAAU,MAAM,CAIpB,GAAG,IAAwE,EAAA;AAI3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI;AAElC,YAAA,OAAO,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC;QACxC;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI;YAE1B,OAAO,CAAC,MAAS,KAAK,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC;QACvD;;AAEJ;AAEA,MAAM,UAAU,GAAG,CAIjB,MAAS,EACT,WAAe,KAEf,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,WAAW;;;;"}
+{"version":3,"file":"ternary-result-or-else.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-or-else.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAyCM,SAAU,MAAM,CAIpB,GAAG,IAAwE,EAAA;AAI3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI;AAElC,YAAA,OAAO,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC;QACxC;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI;YAE1B,OAAO,CAAC,MAAS,KAAK,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC;QACvD;;AAEJ;AAEA,MAAM,UAAU,GAAG,CAIjB,MAAS,EACT,WAAe,KAEf,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,WAAW;;;;"}

package/dist/functional/ternary-result/impl/ternary-result-unwrap-err-or.d.mts

@@ -1,4 +1,4 @@
-import { type TernaryResult, type UnknownTernaryResult } from '../ternary-result.mjs';
+import { type UnknownTernaryResult } from '../ternary-result.mjs';
 import { type UnwrapErr } from './types.mjs';
 /**
  * Returns the Err value or the provided default.
@@ -24,5 +24,5 @@ import { type UnwrapErr } from './types.mjs';
  * ```
  */
 export declare function unwrapErrOr<R extends UnknownTernaryResult, D>(result: R, defaultValue: D): D | UnwrapErr<R>;
-export declare function unwrapErrOr<E, D>(defaultValue: D): <S, W>(result: TernaryResult<S, E, W>) => D | E;
+export declare function unwrapErrOr<D>(defaultValue: D): <R extends UnknownTernaryResult>(result: R) => D | UnwrapErr<R>;
 //# sourceMappingURL=ternary-result-unwrap-err-or.d.mts.map

package/dist/functional/ternary-result/impl/ternary-result-unwrap-err-or.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-unwrap-err-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-err-or.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,oBAAoB,EAAE,CAAC,EAC3D,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;AAGpB,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAC9B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}
+{"version":3,"file":"ternary-result-unwrap-err-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-err-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,oBAAoB,EAAE,CAAC,EAC3D,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;AAGpB,wBAAgB,WAAW,CAAC,CAAC,EAC3B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,SAAS,oBAAoB,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-unwrap-err-or.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-unwrap-err-or.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-err-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAwCM,SAAU,WAAW,CACzB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AAEnC,YAAA,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,YAAY;QAC1C;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAE3B,OAAO,CAAC,MAAS,KAAK,SAAS,CAAC,MAAM,CAAC,IAAI,YAAY;QACzD;;AAEJ;;;;"}
+{"version":3,"file":"ternary-result-unwrap-err-or.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-err-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAqCM,SAAU,WAAW,CACzB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AAEnC,YAAA,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,YAAY;QAC1C;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAE3B,OAAO,CAAC,MAAS,KAAK,SAAS,CAAC,MAAM,CAAC,IAAI,YAAY;QACzD;;AAEJ;;;;"}

package/dist/functional/ternary-result/impl/ternary-result-unwrap-ok-or.d.mts

@@ -1,4 +1,4 @@
-import { type TernaryResult, type UnknownTernaryResult } from '../ternary-result.mjs';
+import { type UnknownTernaryResult } from '../ternary-result.mjs';
 import { type UnwrapOk } from './types.mjs';
 /**
  * Returns the Ok value or the provided default.
@@ -21,5 +21,5 @@ import { type UnwrapOk } from './types.mjs';
  * ```
  */
 export declare function unwrapOkOr<R extends UnknownTernaryResult, D>(result: R, defaultValue: D): D | UnwrapOk<R>;
-export declare function unwrapOkOr<S, D>(defaultValue: D): <W, E>(result: TernaryResult<S, E, W>) => D | S;
+export declare function unwrapOkOr<D>(defaultValue: D): <R extends UnknownTernaryResult>(result: R) => D | UnwrapOk<R>;
 //# sourceMappingURL=ternary-result-unwrap-ok-or.d.mts.map

package/dist/functional/ternary-result/impl/ternary-result-unwrap-ok-or.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-unwrap-ok-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-ok-or.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,oBAAoB,EAAE,CAAC,EAC1D,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGnB,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}
+{"version":3,"file":"ternary-result-unwrap-ok-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-ok-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,oBAAoB,EAAE,CAAC,EAC1D,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGnB,wBAAgB,UAAU,CAAC,CAAC,EAC1B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,SAAS,oBAAoB,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-unwrap-ok-or.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-unwrap-ok-or.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-ok-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAqCM,SAAU,UAAU,CACxB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AAEnC,YAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,YAAY;QACzC;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAE3B,OAAO,CAAC,MAAS,KAAK,QAAQ,CAAC,MAAM,CAAC,IAAI,YAAY;QACxD;;AAEJ;;;;"}
+{"version":3,"file":"ternary-result-unwrap-ok-or.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-ok-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAkCM,SAAU,UAAU,CACxB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AAEnC,YAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,YAAY;QACzC;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAE3B,OAAO,CAAC,MAAS,KAAK,QAAQ,CAAC,MAAM,CAAC,IAAI,YAAY;QACxD;;AAEJ;;;;"}

package/dist/functional/ternary-result/impl/ternary-result-unwrap-warn-or.d.mts

@@ -1,4 +1,4 @@
-import { type TernaryResult, type UnknownTernaryResult } from '../ternary-result.mjs';
+import { type UnknownTernaryResult } from '../ternary-result.mjs';
 import { type UnwrapWarn } from './types.mjs';
 /**
  * Returns the Warn value or the provided default.
@@ -18,5 +18,5 @@ import { type UnwrapWarn } from './types.mjs';
  * ```
  */
 export declare function unwrapWarnOr<R extends UnknownTernaryResult, D>(result: R, defaultValue: D): D | UnwrapWarn<R>;
-export declare function unwrapWarnOr<W, D>(defaultValue: D): <S, E>(result: TernaryResult<S, E, W>) => D | W;
+export declare function unwrapWarnOr<D>(defaultValue: D): <R extends UnknownTernaryResult>(result: R) => D | UnwrapWarn<R>;
 //# sourceMappingURL=ternary-result-unwrap-warn-or.d.mts.map

package/dist/functional/ternary-result/impl/ternary-result-unwrap-warn-or.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-unwrap-warn-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-warn-or.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,oBAAoB,EAAE,CAAC,EAC5D,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AAGrB,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}
+{"version":3,"file":"ternary-result-unwrap-warn-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-warn-or.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,oBAAoB,EAAE,CAAC,EAC5D,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AAGrB,wBAAgB,YAAY,CAAC,CAAC,EAC5B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,SAAS,oBAAoB,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-unwrap-warn-or.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-unwrap-warn-or.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-warn-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAkCM,SAAU,YAAY,CAC1B,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AAEnC,YAAA,OAAO,UAAU,CAAC,MAAM,CAAC,IAAI,YAAY;QAC3C;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAE3B,OAAO,CAAC,MAAS,KAAK,UAAU,CAAC,MAAM,CAAC,IAAI,YAAY;QAC1D;;AAEJ;;;;"}
+{"version":3,"file":"ternary-result-unwrap-warn-or.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-warn-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AA+BM,SAAU,YAAY,CAC1B,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AAEnC,YAAA,OAAO,UAAU,CAAC,MAAM,CAAC,IAAI,YAAY;QAC3C;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAE3B,OAAO,CAAC,MAAS,KAAK,UAAU,CAAC,MAAM,CAAC,IAAI,YAAY;QAC1D;;AAEJ;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "7.0.1",
+  "version": "7.1.1",
   "private": false,
   "keywords": [
     "typescript",

package/src/array/impl/array-utils-creation.mts

@@ -85,7 +85,7 @@ export const seq = <N extends SizeType.ArgArr>(
  * assert.deepStrictEqual(emptyStrings, []);
  * ```
  */
-export const create = <const V, N extends SizeType.ArgArr>(
+export const create = <N extends SizeType.ArgArr, const V>(
   len: N,
   init: V,
 ): N extends SmallUint

package/src/array/impl/array-utils-transformation.mts

@@ -143,7 +143,7 @@ export function scan<E, S>(
       const [array, reducer, init] = args;
 
       const mut_result: MutableNonEmptyArray<S> = castMutable(
-        newArray<S, PositiveUint32>(asPositiveUint32(array.length + 1), init),
+        newArray<PositiveUint32, S>(asPositiveUint32(array.length + 1), init),
       );
 
       let mut_acc = init;

package/src/array/impl/array-utils-validation.mts

@@ -1,5 +1,7 @@
 import {
   type ArrayAtLeastLen,
+  type ArrayAtMostLen,
+  type ArrayBoundedLen,
   type ArrayOfLength,
   type BoolOr,
   type NonEmptyArray,
@@ -136,6 +138,60 @@ export const isArrayAtLeastLength = <E, N extends SizeType.ArgArr>(
   len: N,
 ): array is ArrayAtLeastLen<N, E> => array.length >= len;
 
+/**
+ * Checks if an array has at most a specific length.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const triple: readonly number[] = [1, 2, 3] as const;
+ *
+ * assert.isTrue(Arr.isArrayAtMostLength(pair, 2));
+ *
+ * assert.isFalse(Arr.isArrayAtMostLength(triple, 2));
+ *
+ * if (Arr.isArrayAtMostLength(pair, 2)) {
+ *   assert.isTrue(pair.length <= 2);
+ * }
+ * ```
+ */
+export const isArrayAtMostLength = <E, N extends SizeType.ArgArr>(
+  array: readonly E[],
+  len: N,
+): array is ArrayAtMostLen<N, E> => array.length <= len;
+
+/**
+ * Checks if an array's length is within a specific inclusive range.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const quad: readonly number[] = [1, 2, 3, 4] as const;
+ *
+ * assert.isTrue(Arr.isArrayBoundedLength(pair, 1, 3));
+ *
+ * assert.isFalse(Arr.isArrayBoundedLength(quad, 1, 3));
+ *
+ * if (Arr.isArrayBoundedLength(pair, 1, 3)) {
+ *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
+ * }
+ * ```
+ */
+export const isArrayBoundedLength = <
+  E,
+  Min extends SizeType.ArgArr,
+  Max extends SizeType.ArgArr,
+>(
+  array: readonly E[],
+  min: Min,
+  max: Max,
+): array is ArrayBoundedLen<Min, Max, E> =>
+  array.length >= min && array.length <= max;
+
 /**
  * Tests whether all elements in an array pass a test implemented by a predicate.
  *

package/src/array/impl/array-utils-validation.test.mts

@@ -1,10 +1,17 @@
-import { type ArrayAtLeastLen, type ArrayOfLength } from 'ts-type-forge';
+import {
+  type ArrayAtLeastLen,
+  type ArrayAtMostLen,
+  type ArrayBoundedLen,
+  type ArrayOfLength,
+} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
   every,
   indexIsInRange,
   isArray,
   isArrayAtLeastLength,
+  isArrayAtMostLength,
+  isArrayBoundedLength,
   isArrayOfLength,
   isEmpty,
   isNonEmpty,
@@ -584,6 +591,158 @@ describe('Arr validations', () => {
     });
   });
 
+  describe(isArrayAtMostLength, () => {
+    test('should return true if array length is less than or equal to specified length', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isTrue(isArrayAtMostLength(arr, 3));
+
+      if (isArrayAtMostLength(arr, 3)) {
+        expectType<typeof arr, readonly [1, 2, 3]>('=');
+      }
+
+      assert.isTrue(isArrayAtMostLength(arr, 4));
+
+      if (isArrayAtMostLength(arr, 4)) {
+        expectType<typeof arr, readonly [1, 2, 3]>('=');
+      }
+    });
+
+    test('should return false if array length is greater than specified length', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isFalse(isArrayAtMostLength(arr, 2));
+    });
+
+    test('should return true for empty array and length 0', () => {
+      const arr = [] as const;
+
+      assert.isTrue(isArrayAtMostLength(arr, 0));
+
+      if (isArrayAtMostLength(arr, 0)) {
+        expectType<typeof arr, readonly []>('=');
+      }
+    });
+
+    test('should return false for non-empty array and length 0', () => {
+      const arr = [1] as const;
+
+      assert.isFalse(isArrayAtMostLength(arr, 0));
+    });
+
+    test('should work with unknown array type', () => {
+      const mut_arr: number[] = [1, 2];
+
+      assert.isTrue(isArrayAtMostLength(mut_arr, 2));
+
+      // transformer-ignore-next-line
+      expectType<typeof mut_arr, number[] & ArrayAtMostLen<2, number>>('=');
+
+      assert.isFalse(isArrayAtMostLength(mut_arr, 1));
+    });
+
+    test('should return true for arrays of at most specified length (additional)', () => {
+      assert.isTrue(isArrayAtMostLength([1, 2, 3], 3));
+
+      assert.isTrue(isArrayAtMostLength([1, 2, 3], 4));
+
+      assert.isTrue(isArrayAtMostLength([], 0));
+    });
+
+    test('should return false for arrays longer than specified length (additional)', () => {
+      assert.isFalse(isArrayAtMostLength([1, 2, 3], 2));
+
+      assert.isFalse(isArrayAtMostLength([1, 2, 3], 0));
+    });
+
+    test('should work as type guard for at most length (additional)', () => {
+      const array: readonly number[] = [1, 2] as const;
+
+      if (isArrayAtMostLength(array, 3)) {
+        expectType<typeof array, ArrayAtMostLen<3, number>>('=');
+
+        expect(array.length).toBeLessThanOrEqual(3);
+      }
+    });
+  });
+
+  describe(isArrayBoundedLength, () => {
+    test('should return true if array length is within the specified range', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isTrue(isArrayBoundedLength(arr, 1, 3));
+
+      if (isArrayBoundedLength(arr, 1, 3)) {
+        expectType<typeof arr, readonly [1, 2, 3]>('=');
+      }
+
+      assert.isTrue(isArrayBoundedLength(arr, 3, 5));
+
+      if (isArrayBoundedLength(arr, 3, 5)) {
+        expectType<typeof arr, readonly [1, 2, 3]>('=');
+      }
+    });
+
+    test('should return false if array length is below the specified range', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isFalse(isArrayBoundedLength(arr, 4, 5));
+    });
+
+    test('should return false if array length is above the specified range', () => {
+      const arr = [1, 2, 3] as const;
+
+      assert.isFalse(isArrayBoundedLength(arr, 0, 2));
+    });
+
+    test('should return true for empty array and range including 0', () => {
+      const arr = [] as const;
+
+      assert.isTrue(isArrayBoundedLength(arr, 0, 2));
+
+      if (isArrayBoundedLength(arr, 0, 2)) {
+        expectType<typeof arr, readonly []>('=');
+      }
+    });
+
+    test('should work with unknown array type', () => {
+      const mut_arr: number[] = [1, 2];
+
+      assert.isTrue(isArrayBoundedLength(mut_arr, 1, 3));
+
+      // transformer-ignore-next-line
+      expectType<typeof mut_arr, number[] & ArrayBoundedLen<1, 3, number>>('=');
+
+      assert.isFalse(isArrayBoundedLength(mut_arr, 3, 5));
+    });
+
+    test('should return true for arrays within specified range (additional)', () => {
+      assert.isTrue(isArrayBoundedLength([1, 2, 3], 1, 3));
+
+      assert.isTrue(isArrayBoundedLength([1, 2, 3], 3, 3));
+
+      assert.isTrue(isArrayBoundedLength([], 0, 0));
+    });
+
+    test('should return false for arrays outside specified range (additional)', () => {
+      assert.isFalse(isArrayBoundedLength([1, 2, 3], 4, 5));
+
+      assert.isFalse(isArrayBoundedLength([1, 2, 3], 0, 2));
+    });
+
+    test('should work as type guard for bounded length (additional)', () => {
+      const array: readonly number[] = [1, 2] as const;
+
+      if (isArrayBoundedLength(array, 1, 3)) {
+        expectType<typeof array, ArrayBoundedLen<1, 3, number>>('=');
+
+        expect(array.length).toBeGreaterThanOrEqual(1);
+
+        expect(array.length).toBeLessThanOrEqual(3);
+      }
+    });
+  });
+
   describe(every, () => {
     test('should return true when all elements satisfy predicate', () => {
       const evens = [2, 4, 6, 8] as const;

package/src/functional/optional/impl/optional-expect-to-be.mts

@@ -16,7 +16,7 @@ import { type Unwrap } from './types.mjs';
  *   Optional.expectToBe(optionalValue, 'value expected') === 'data',
  * );
  *
- * const expectValue = Optional.expectToBe<string>('missing optional');
+ * const expectValue = Optional.expectToBe('missing optional');
  *
  * const throwTest = (): void => {
  *   expectValue(Optional.none);
@@ -41,7 +41,7 @@ export function expectToBe<O extends UnknownOptional>(
 ): Unwrap<O>;
 
 // Curried version
-export function expectToBe<S>(message: string): (optional: Optional<S>) => S;
+export function expectToBe(message: string): <O>(optional: Optional<O>) => O;
 
 export function expectToBe<O extends UnknownOptional>(
   ...args: readonly [optional: O, message: string] | readonly [message: string]

package/src/functional/optional/impl/optional-or-else.mts

@@ -47,9 +47,9 @@ export function orElse<
 >(optional: O, alternative: O2): O | O2;
 
 // Curried version
-export function orElse<S, S2>(
-  alternative: Optional<S2>,
-): (optional: Optional<S>) => Optional<S> | Optional<S2>;
+export function orElse<O2>(
+  alternative: Optional<O2>,
+): <O>(optional: Optional<O>) => Optional<O> | Optional<O2>;
 
 export function orElse<
   O extends UnknownOptional,

package/src/functional/optional/impl/optional-unwrap-or.mts

@@ -40,9 +40,9 @@ export function unwrapOr<O extends UnknownOptional, D>(
 ): D | Unwrap<O>;
 
 // Curried version
-export function unwrapOr<S, D>(
+export function unwrapOr<D>(
   defaultValue: D,
-): (optional: Optional<S>) => D | S;
+): <O>(optional: Optional<O>) => D | O;
 
 export function unwrapOr<O extends UnknownOptional, D>(
   ...args: readonly [optional: O, defaultValue: D] | readonly [defaultValue: D]

package/src/functional/optional.test.mts

@@ -295,19 +295,19 @@ describe('Optional test', () => {
 
   describe('expectToBe', () => {
     test('should return the value for Some', () => {
-      const expectNumber = Optional.expectToBe<number>('Expected a number');
+      const expectNumber = Optional.expectToBe('Expected a number');
 
       expect(expectNumber(Optional.some(42))).toBe(42);
     });
 
     test('should throw with custom message for None', () => {
-      const expectNumber = Optional.expectToBe<number>('Expected a number');
+      const expectNumber = Optional.expectToBe('Expected a number');
 
       expect(() => expectNumber(Optional.none)).toThrow('Expected a number');
     });
 
     test('should be curried', () => {
-      const expectValidId = Optional.expectToBe<string>('ID is required');
+      const expectValidId = Optional.expectToBe('ID is required');
 
       const id1 = Optional.some('user-123');
 

package/src/functional/result/impl/result-expect-to-be.mts

@@ -1,4 +1,4 @@
-import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnknownResult } from '../result.mjs';
 import { isOk } from './result-is-ok.mjs';
 import { unwrapOk } from './result-unwrap-ok.mjs';
 import { type UnwrapOk } from './types.mjs';
@@ -14,7 +14,7 @@ import { type UnwrapOk } from './types.mjs';
  *
  * assert.isTrue(Result.expectToBe(okValue, 'should have value') === 'data');
  *
- * const expectResult = Result.expectToBe<string>('missing result');
+ * const expectResult = Result.expectToBe('missing result');
  *
  * const throwTest = (): void => {
  *   expectResult(Result.err('boom'));
@@ -37,7 +37,9 @@ export function expectToBe<R extends UnknownResult>(
 ): UnwrapOk<R>;
 
 // Curried version
-export function expectToBe<S>(message: string): <E>(result: Result<S, E>) => S;
+export function expectToBe(
+  message: string,
+): <R extends UnknownResult>(result: R) => UnwrapOk<R>;
 
 export function expectToBe<R extends UnknownResult>(
   ...args: readonly [result: R, message: string] | readonly [message: string]

package/src/functional/result/impl/result-or-else.mts

@@ -1,4 +1,4 @@
-import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnknownResult } from '../result.mjs';
 import { isOk } from './result-is-ok.mjs';
 import { type NarrowToOk } from './types.mjs';
 
@@ -43,9 +43,9 @@ export function orElse<R extends UnknownResult, R2 extends UnknownResult>(
 ): NarrowToOk<R> | R2;
 
 // Curried version
-export function orElse<S, E, S2, E2>(
-  alternative: Result<S2, E2>,
-): (result: Result<S, E>) => Result<S, E> | Result<S2, E2>;
+export function orElse<R2 extends UnknownResult>(
+  alternative: R2,
+): <R extends UnknownResult>(result: R) => NarrowToOk<R> | R2;
 
 export function orElse<R extends UnknownResult, R2 extends UnknownResult>(
   ...args: readonly [result: R, alternative: R2] | readonly [alternative: R2]

package/src/functional/result/impl/result-unwrap-err-or.mts

@@ -1,4 +1,4 @@
-import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnknownResult } from '../result.mjs';
 import { unwrapErr } from './result-unwrap-err.mjs';
 import { type UnwrapErr } from './types.mjs';
 
@@ -38,7 +38,7 @@ export function unwrapErrOr<R extends UnknownResult, D>(
 // Curried version
 export function unwrapErrOr<D>(
   defaultValue: D,
-): <S, E>(result: Result<S, E>) => D | E;
+): <R extends UnknownResult>(result: R) => D | UnwrapErr<R>;
 
 export function unwrapErrOr<R extends UnknownResult, D>(
   ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]

package/src/functional/result/impl/result-unwrap-ok-or.mts

@@ -1,4 +1,4 @@
-import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnknownResult } from '../result.mjs';
 import { unwrapOk } from './result-unwrap-ok.mjs';
 import { type UnwrapOk } from './types.mjs';
 
@@ -36,9 +36,9 @@ export function unwrapOkOr<R extends UnknownResult, D>(
 ): D | UnwrapOk<R>;
 
 // Curried version
-export function unwrapOkOr<S, D>(
+export function unwrapOkOr<D>(
   defaultValue: D,
-): <E>(result: Result<S, E>) => D | S;
+): <R extends UnknownResult>(result: R) => D | UnwrapOk<R>;
 
 export function unwrapOkOr<R extends UnknownResult, D>(
   ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]

package/src/functional/ternary-result/impl/ternary-result-expect-to-be.mts

@@ -16,7 +16,7 @@ import { type UnwrapOk } from './types.mjs';
  *
  * assert.strictEqual(TernaryResult.expectToBe(okValue, 'missing'), 'ready');
  *
- * const expectResult = TernaryResult.expectToBe<string>('needs value');
+ * const expectResult = TernaryResult.expectToBe('needs value');
  *
  * const throwTest = (): void => {
  *   expectResult(TernaryResult.err('oops'));
@@ -31,9 +31,9 @@ export function expectToBe<R extends UnknownTernaryResult>(
 ): UnwrapOk<R>;
 
 // Curried version
-export function expectToBe<S>(
+export function expectToBe(
   message: string,
-): <W, E>(result: TernaryResult<S, E, W>) => S;
+): <S, W, E>(result: TernaryResult<S, E, W>) => S;
 
 export function expectToBe<R extends UnknownTernaryResult>(
   ...args: readonly [result: R, message: string] | readonly [message: string]

package/src/functional/ternary-result/impl/ternary-result-or-else.mts

@@ -1,7 +1,4 @@
-import {
-  type TernaryResult,
-  type UnknownTernaryResult,
-} from '../ternary-result.mjs';
+import { type UnknownTernaryResult } from '../ternary-result.mjs';
 import { isOk } from './ternary-result-is-ok.mjs';
 import { isWarn } from './ternary-result-is-warn.mjs';
 import { type NarrowToOk, type NarrowToWarn } from './types.mjs';
@@ -36,11 +33,11 @@ export function orElse<
 >(result: R, alternative: R2): NarrowToOk<R> | NarrowToWarn<R> | R2;
 
 // Curried version
-export function orElse<S, W, E, S2, W2, E2>(
-  alternative: TernaryResult<S2, E2, W2>,
-): (
-  result: TernaryResult<S, E, W>,
-) => TernaryResult<S, E, W> | TernaryResult<S2, E2, W2>;
+export function orElse<R2 extends UnknownTernaryResult>(
+  alternative: R2,
+): <R extends UnknownTernaryResult>(
+  result: R,
+) => NarrowToOk<R> | NarrowToWarn<R> | R2;
 
 export function orElse<
   R extends UnknownTernaryResult,

package/src/functional/ternary-result/impl/ternary-result-unwrap-err-or.mts

@@ -1,7 +1,4 @@
-import {
-  type TernaryResult,
-  type UnknownTernaryResult,
-} from '../ternary-result.mjs';
+import { type UnknownTernaryResult } from '../ternary-result.mjs';
 import { unwrapErr } from './ternary-result-unwrap-err.mjs';
 import { type UnwrapErr } from './types.mjs';
 
@@ -34,9 +31,9 @@ export function unwrapErrOr<R extends UnknownTernaryResult, D>(
 ): D | UnwrapErr<R>;
 
 // Curried version
-export function unwrapErrOr<E, D>(
+export function unwrapErrOr<D>(
   defaultValue: D,
-): <S, W>(result: TernaryResult<S, E, W>) => D | E;
+): <R extends UnknownTernaryResult>(result: R) => D | UnwrapErr<R>;
 
 export function unwrapErrOr<R extends UnknownTernaryResult, D>(
   ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]

package/src/functional/ternary-result/impl/ternary-result-unwrap-ok-or.mts

@@ -1,7 +1,4 @@
-import {
-  type TernaryResult,
-  type UnknownTernaryResult,
-} from '../ternary-result.mjs';
+import { type UnknownTernaryResult } from '../ternary-result.mjs';
 import { unwrapOk } from './ternary-result-unwrap-ok.mjs';
 import { type UnwrapOk } from './types.mjs';
 
@@ -31,9 +28,9 @@ export function unwrapOkOr<R extends UnknownTernaryResult, D>(
 ): D | UnwrapOk<R>;
 
 // Curried version
-export function unwrapOkOr<S, D>(
+export function unwrapOkOr<D>(
   defaultValue: D,
-): <W, E>(result: TernaryResult<S, E, W>) => D | S;
+): <R extends UnknownTernaryResult>(result: R) => D | UnwrapOk<R>;
 
 export function unwrapOkOr<R extends UnknownTernaryResult, D>(
   ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]

package/src/functional/ternary-result/impl/ternary-result-unwrap-warn-or.mts

@@ -1,7 +1,4 @@
-import {
-  type TernaryResult,
-  type UnknownTernaryResult,
-} from '../ternary-result.mjs';
+import { type UnknownTernaryResult } from '../ternary-result.mjs';
 import { unwrapWarn } from './ternary-result-unwrap-warn.mjs';
 import { type UnwrapWarn } from './types.mjs';
 
@@ -28,9 +25,9 @@ export function unwrapWarnOr<R extends UnknownTernaryResult, D>(
 ): D | UnwrapWarn<R>;
 
 // Curried version
-export function unwrapWarnOr<W, D>(
+export function unwrapWarnOr<D>(
   defaultValue: D,
-): <S, E>(result: TernaryResult<S, E, W>) => D | W;
+): <R extends UnknownTernaryResult>(result: R) => D | UnwrapWarn<R>;
 
 export function unwrapWarnOr<R extends UnknownTernaryResult, D>(
   ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]