ts-data-forge 1.1.0 → 1.3.0

package/README.md

@@ -139,6 +139,7 @@ expectType<{ x: number }, { x: number }>('=');
 // The following would cause a compile-time error:
 // expectType<User, Admin>("="); // Error: Type 'User' is not strictly equal to type 'Admin'.
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 expectType<User, any>('!='); // Error: Comparisons with `any` are also strictly checked.
 ```
 
@@ -147,55 +148,53 @@ expectType<User, any>('!='); // Error: Comparisons with `any` are also strictly
 Handle nullable values and error-prone operations safely.
 
 ```typescript
-import { Optional, Result, pipe, match } from 'ts-data-forge';
+import { match, Optional, pipe, Result } from 'ts-data-forge';
 
 // Optional for nullable values
 const maybeValue = Optional.some(42);
-const nothing = Optional.none;
 
 const doubled = Optional.map(maybeValue, (x) => x * 2);
-console.log(Optional.unwrapOr(doubled, 0)); // 84
+
+assert.strictEqual(Optional.unwrapOr(doubled, 0), 84);
 
 // Result for error handling
 const success = Result.ok(42);
-const failure = Result.err('Something went wrong');
 
 const mapped = Result.map(success, (x) => x * 2);
-if (Result.isOk(mapped)) {
-    console.log(mapped.value); // 84
-}
+
+assert.deepStrictEqual(mapped, Result.ok(84));
 
 // Advanced pipe usage
-const processNumber = (input: number) =>
+const processNumber = (input: number): Optional<number> =>
     pipe(input)
         .map((x) => x * 2) // Regular transformation
         .map((x) => x + 10) // Chain transformations
-        .map((x) => (x > 50 ? Optional.some(x) : Optional.none)) // Convert to Optional
-        .mapOptional((x) => x / 2).value; // Continue with Optional chain and get final Optional<number>
+        .map((x) => (x > 50 ? Optional.some(x / 2) : Optional.none)).value; // Get the result
+
+assert.deepStrictEqual(processNumber(30), Optional.some(35));
 
-console.log(processNumber(30)); // Optional.some(35)
-console.log(processNumber(10)); // Optional.none
+assert.deepStrictEqual(processNumber(10), Optional.none);
 
 // Pattern matching with match
 type Status = 'loading' | 'success' | 'error';
 
-const handleStatus = (status: Status, data?: string) =>
+const handleStatus = (status: Status, data?: string): string =>
     match(status, {
         loading: 'Please wait...',
         success: `Data: ${data ?? 'No data'}`,
         error: 'An error occurred',
     });
 
-console.log(handleStatus('loading')); // 'Please wait...'
-console.log(handleStatus('success', 'Hello')); // 'Data: Hello'
-console.log(handleStatus('error')); // 'An error occurred'
+assert.strictEqual(handleStatus('loading'), 'Please wait...');
+assert.strictEqual(handleStatus('success', 'Hello'), 'Data: Hello');
+assert.strictEqual(handleStatus('error'), 'An error occurred');
 
 // Pattern matching with Result
-const processResult = (result: Result<number, string>) =>
+const processResult = (result: Result<number, string>): string =>
     Result.isOk(result) ? `Success: ${result.value}` : `Error: ${result.value}`;
 
-console.log(processResult(Result.ok(42))); // 'Success: 42'
-console.log(processResult(Result.err('Failed'))); // 'Error: Failed'
+assert.strictEqual(processResult(Result.ok(42)), 'Success: 42');
+assert.strictEqual(processResult(Result.err('Failed')), 'Error: Failed');
 ```
 
 ### 3. Number Utilities with `Num` and Branded Number Types
@@ -206,32 +205,35 @@ The `Num` object provides safe and convenient functions for numerical operations
 import { Num } from 'ts-data-forge';
 
 // Basic conversions
-const num = Num.from('123'); // 123
-const invalid = Num.from('abc'); // NaN
+assert.strictEqual(Num.from('123'), 123);
+assert.strictEqual(Number.isNaN(Num.from('abc')), true);
 
 // Range checking
 const inRange = Num.isInRange(0, 10);
-console.log(inRange(5)); // true
-console.log(inRange(0)); // true (inclusive lower bound)
-console.log(inRange(10)); // false (exclusive upper bound)
+
+assert.strictEqual(inRange(5), true);
+assert.strictEqual(inRange(0), true); // (inclusive lower bound)
+assert.strictEqual(inRange(10), false); // (exclusive upper bound)
 
 // Clamping values
 const clamp = Num.clamp(0, 100);
-console.log(clamp(150)); // 100
-console.log(clamp(-10)); // 0
+
+assert.strictEqual(clamp(150), 100);
+assert.strictEqual(clamp(-10), 0);
 
 // Rounding utilities
 const round2 = Num.round(2);
-console.log(round2(3.14159)); // 3.14
 
-console.log(Num.roundAt(3.14159, 3)); // 3.142
-console.log(Num.roundToInt(3.7) satisfies Int); // 4
+assert.strictEqual(round2(3.14159), 3.14);
+assert.strictEqual(Num.roundAt(3.14159, 3), 3.142);
+assert.strictEqual(Num.roundToInt(3.7), 4);
 
 // Type guards
-declare const value: number;
+const value = 5; // example value
 if (Num.isNonZero(value)) {
     // value is guaranteed to be non-zero
     const result = Num.div(10, value); // Safe division
+    assert.strictEqual(result, 2);
 }
 ```
 
@@ -241,22 +243,16 @@ if (Num.isNonZero(value)) {
 
 ```typescript
 import {
-    asInt,
-    asUint,
     asFiniteNumber,
-    asSafeInt,
+    asInt,
     asInt16,
-    asUint32,
     asNonZeroInt,
     asPositiveInt,
-    Int,
-    Uint,
-    FiniteNumber,
-    SafeInt,
+    asSafeInt,
+    asUint,
+    asUint32,
     Int16,
-    Uint32,
     NonZeroInt,
-    PositiveInt,
 } from 'ts-data-forge';
 
 // Basic branded types
@@ -265,25 +261,42 @@ const unsigned = asUint(42); // Uint - non-negative integer
 const finite = asFiniteNumber(3.14); // FiniteNumber - finite floating-point
 const safeInt = asSafeInt(42); // SafeInt - integer in safe range
 
-const nonInteger = asInt(3.14); // This line causes a runtime error
+assert.strictEqual(integer, 42);
+assert.strictEqual(unsigned, 42);
+assert.strictEqual(finite, 3.14);
+assert.strictEqual(safeInt, 42);
+
+// This line would cause a runtime error:
+assert.throw(() => {
+    asInt(3.14);
+});
 
 // Range-constrained types (16-bit, 32-bit)
 const int16 = asInt16(1000); // Int16: [-32768, 32767]
 const uint32 = asUint32(3000000000); // Uint32: [0, 4294967295]
+assert.strictEqual(int16, 1000);
+assert.strictEqual(uint32, 3000000000);
 
 // Non-zero and positive variants
 const nonZeroInt = asNonZeroInt(5); // NonZeroInt - excludes zero
 const positiveInt = asPositiveInt(10); // PositiveInt - excludes zero and negatives
+assert.strictEqual(nonZeroInt, 5);
+assert.strictEqual(positiveInt, 10);
 
 // Type-safe arithmetic with automatic clamping
 const sum = Int16.add(int16, asInt16(2000)); // Int16 (3000)
 const clamped = Int16.clamp(100000); // Int16 (32767 - clamped to MAX_VALUE)
+assert.strictEqual(sum, 3000);
+assert.strictEqual(clamped, 32767);
 
 // Safe division with non-zero types
 const ratio = NonZeroInt.div(asNonZeroInt(10), nonZeroInt); // No division by zero risk
+assert.strictEqual(ratio, 2);
 
 // Random generation within type constraints
 const randomInt16 = Int16.random(); // Int16 (random value in valid range)
+assert.strictEqual(-32768 <= randomInt16, true);
+assert.strictEqual(randomInt16 <= 32767, true);
 ```
 
 ### 4. Array Utilities with `Arr`
@@ -291,39 +304,54 @@ const randomInt16 = Int16.random(); // Int16 (random value in valid range)
 The `Arr` object provides a rich set of functions for array manipulation.
 
 ```typescript
-import { Arr } from 'ts-data-forge';
+import { Arr, expectType, Optional } from 'ts-data-forge';
 
 const numbers: readonly number[] = [1, 2, 3, 4, 5, 2, 3];
-const people = [
-    { name: 'Alice', age: 30 },
-    { name: 'Bob', age: 25 },
-    { name: 'Charlie', age: 35 },
-] as const;
 
 // Reduction
 const sum = Arr.sum(numbers);
-console.log(sum); // 20
 
-// Array creation
-const zeros: readonly [0, 0, 0, 0, 0] = Arr.zeros(5); // [0, 0, 0, 0, 0]
-const range: readonly [1, 2, 3] = Arr.range(1, 4); // [1, 2, 3]
+assert.strictEqual(sum, 20);
 
 // Type-safe length checking
 if (Arr.isArrayAtLeastLength(numbers, 2)) {
-    // numbers is now guaranteed to have at least 3 elements
+    // numbers is now guaranteed to have at least 2 elements
     expectType<typeof numbers, readonly [number, number, ...number[]]>('=');
-    console.log(numbers[1]); // Safe access to index 2
+    assert.strictEqual(numbers[1], 2); // Safe access to index 1
 }
 
 // Take first n elements
-const firstThree = Arr.take(numbers, 3); // [1, 2, 3]
+const firstThree = Arr.take(numbers, 3);
 
-// Find maximum by property
-const oldestPerson = Arr.maxBy(people, (person) => person.age);
-console.log(oldestPerson?.name); // 'Charlie'
+assert.deepStrictEqual(firstThree, [1, 2, 3]);
 
 // Remove duplicates
-const unique = Arr.uniq(numbers); // [1, 2, 3, 4, 5]
+const unique = Arr.uniq(numbers);
+
+assert.deepStrictEqual(unique, [1, 2, 3, 4, 5]);
+
+// Array creation
+const zeros: readonly [0, 0, 0, 0, 0] = Arr.zeros(5);
+assert.deepStrictEqual(zeros, [0, 0, 0, 0, 0]);
+
+const range: readonly [1, 2, 3] = Arr.range(1, 4);
+assert.deepStrictEqual(range, [1, 2, 3]);
+
+const people = [
+    { name: 'Alice', age: 30 },
+    { name: 'Bob', age: 25 },
+    { name: 'Charlie', age: 35 },
+] as const;
+
+// Find maximum by property
+const oldestPerson = Arr.maxBy(people, (person) => person.age);
+assert.deepStrictEqual(
+    oldestPerson,
+    Optional.some({ name: 'Charlie', age: 35 } as const),
+);
+if (Optional.isSome(oldestPerson)) {
+    assert.strictEqual(oldestPerson.value.name, 'Charlie');
+}
 ```
 
 ### 5. Immutable Collections: `IMap` and `ISet`
@@ -331,7 +359,7 @@ const unique = Arr.uniq(numbers); // [1, 2, 3, 4, 5]
 Type-safe, immutable data structures.
 
 ```typescript
-import { IMap, ISet, pipe } from 'ts-data-forge';
+import { Arr, IMap, ISet, Optional } from 'ts-data-forge';
 
 // IMap usage - immutable operations
 const originalMap = IMap.create<string, number>([]);
@@ -339,34 +367,37 @@ const mapWithOne = originalMap.set('one', 1);
 const mapWithTwo = mapWithOne.set('two', 2);
 
 // Original map is unchanged
-console.log(originalMap.size); // 0
-console.log(mapWithTwo.get('one')); // Optional.some(1)
-console.log(mapWithTwo.has('three')); // false
+assert.strictEqual(originalMap.size, 0);
+assert.deepStrictEqual(mapWithTwo.get('one'), Optional.some(1));
+
+assert.strictEqual(mapWithTwo.has('three'), false);
 
 // Using pipe for fluent updates
-const idMap = pipe(Arr.seq(10))
-    .map(Arr.map<number>(i => [i, i.toString()])
-     .map(Arr.skip(1)) // [ [1, "1"], ..., [9, "9"]]
-    .map(IMap.create<number, string>).value;
+const sequence = Arr.seq(10); // [0, 1, 2, ..., 9]
+const pairs = sequence.map(
+    (i) => [i, i.toString()] as readonly [number, string],
+);
+const skipped = Arr.skip(pairs, 1); // [[1, "1"], ..., [9, "9"]]
+const idMap = IMap.create<number, string>(skipped);
 
-console.log(idMap.size); // 9
+assert.strictEqual(idMap.size, 9);
 
 // Efficient batch updates with withMutations
 const idMapUpdated = idMap.withMutations([
-    { type: 'set', key: 99, value: "99" },
-    { type: 'update', key: 5, value: "five" },
+    { type: 'set', key: 99, value: '99' },
+    { type: 'update', key: 5, updater: () => 'five' },
     { type: 'delete', key: 4 },
 ]);
 
-console.log(idMapUpdated.size); // 9
+assert.strictEqual(idMapUpdated.size, 9);
 
 // ISet usage
 const originalSet = ISet.create<number>([]);
 const setWithItems = originalSet.add(1).add(2).add(1); // Duplicate ignored
 
-console.log(originalSet.size); // 0 (unchanged)
-console.log(setWithItems.has(1)); // true
-console.log(setWithItems.size); // 2
+assert.strictEqual(originalSet.size, 0); // (unchanged)
+assert.strictEqual(setWithItems.has(1), true);
+assert.strictEqual(setWithItems.size, 2);
 ```
 
 ### 6. Type Guards
@@ -374,9 +405,9 @@ console.log(setWithItems.size); // 2
 Safe type narrowing with comprehensive type guards.
 
 ```typescript
-import { isNonNullObject, isRecord, hasKey } from 'ts-data-forge';
+import { hasKey, isNonNullObject, isRecord } from 'ts-data-forge';
 
-function processData(data: unknown) {
+const processData = (data: unknown): string | undefined => {
     if (isRecord(data)) {
         // data is now UnknownRecord (= Readonly<Record<string, unknown>>)
         if (
@@ -384,17 +415,24 @@ function processData(data: unknown) {
             // data is now ReadonlyRecord<"name", unknown> & UnknownRecord
             typeof data.name === 'string'
         ) {
-            console.log(`Hello, ${data.name}!`);
+            return `Hello, ${data.name}!`;
         }
     }
-}
+    return undefined;
+};
 
 // Non-null object checking
-declare const value: unknown;
+const value: unknown = { key: 'value' };
+
 if (isNonNullObject(value)) {
     // value is guaranteed to be a non-null object
-    console.log(Object.keys(value));
+    assert.deepStrictEqual(Object.keys(value), ['key']);
 }
+
+// Example usage
+assert.strictEqual(processData({ name: 'Alice' }), 'Hello, Alice!');
+assert.strictEqual(processData({ age: 30 }), undefined);
+assert.strictEqual(processData('not an object'), undefined);
 ```
 
 ### 7. Iteration with `range`
@@ -405,18 +443,27 @@ Generate ranges for iteration and array creation.
 import { range } from 'ts-data-forge';
 
 // Traditional for loop using range
+const values: number[] = [];
 for (const i of range(0, 5)) {
-    console.log(i); // 0, 1, 2, 3, 4
+    values.push(i);
 }
 
+assert.deepStrictEqual(values, [0, 1, 2, 3, 4]);
+
 // Create arrays from ranges
-const numbers = Array.from(range(1, 4)); // [1, 2, 3]
-const squares = Array.from(range(1, 6), (x) => x * x); // [1, 4, 9, 16, 25]
+const numbers = Array.from(range(1, 4));
+const squares = Array.from(range(1, 6), (x) => x * x);
+
+assert.deepStrictEqual(numbers, [1, 2, 3]);
+assert.deepStrictEqual(squares, [1, 4, 9, 16, 25]);
 
 // Step ranges
+const stepValues: number[] = [];
 for (const i of range(0, 10, 2)) {
-    console.log(i); // 0, 2, 4, 6, 8
+    stepValues.push(i);
 }
+
+assert.deepStrictEqual(stepValues, [0, 2, 4, 6, 8]);
 ```
 
 ### 8. Mutability Utilities with `castMutable`
@@ -424,23 +471,23 @@ for (const i of range(0, 10, 2)) {
 Safely work with readonly types when interfacing with mutable APIs.
 
 ```tsx
-import { Autocomplete } from '@mui/material';
 import { castMutable } from 'ts-data-forge';
 
-const readonlyOptions: readonly string[] = ['Option 1', 'Option 2', 'Option 3'];
+// Example: Material-UI Autocomplete
+import { Autocomplete, TextField } from '@mui/material';
 
-const SomeComponent: React.FC = () => {
-    // Component implementation
-    return (
-        <Autocomplete
-            // Use castMutable to safely pass readonly array to mutable API. This is safer than casting with `as`, as it simply changes type `readonly T[]` to `T[]`.
-            options={castMutable(readonlyOptions)}
-            // ...
-        />
-    );
-};
+export const SomeComponent: React.FC = () => (
+    <Autocomplete
+        options={castMutable(readonlyOptions)}
+        renderInput={(params) => (
+            <TextField {...params} placeholder="Select an option" />
+        )}
+    />
+);
+
+const readonlyOptions: readonly string[] = ['Option 1', 'Option 2', 'Option 3'];
 
-// Immer.js example - draft properties need mutable types
+// Immer.js example
 import { produce } from 'immer';
 
 type State = Readonly<{
@@ -458,7 +505,8 @@ const updatedState = produce(initialState, (draft) => {
     draft.items = castMutable(newItems); // Safe cast for assignment
 });
 
-console.log(updatedState.items); // ['newItem1', 'newItem2']
+assert.deepStrictEqual(initialState.items, ['item1', 'item2']);
+assert.deepStrictEqual(updatedState.items, ['newItem1', 'newItem2']);
 ```
 
 ## Modules Overview

package/dist/index.d.mts

@@ -8,4 +8,5 @@ export * from './json/index.mjs';
 export * from './number/index.mjs';
 export * from './object/index.mjs';
 export * from './others/index.mjs';
+export * from './promise/index.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/index.mjs

@@ -49,7 +49,7 @@ export { Uint32, asUint32, isUint32 } from './number/branded-types/uint32.mjs';
 export { Int8, asInt8, isInt8 } from './number/enum/int8.mjs';
 export { Uint8, asUint8, isUint8 } from './number/enum/uint8.mjs';
 export { Num } from './number/num.mjs';
-export { TsVerifiedInternals } from './number/refined-number-utils.mjs';
+export { TsDataForgeInternals } from './number/refined-number-utils.mjs';
 export { Obj } from './object/object.mjs';
 export { castDeepMutable, castMutable } from './others/cast-mutable.mjs';
 export { castDeepReadonly, castReadonly } from './others/cast-readonly.mjs';
@@ -58,4 +58,5 @@ export { mapNullable } from './others/map-nullable.mjs';
 export { memoizeFunction } from './others/memoize-function.mjs';
 export { tp } from './others/tuple.mjs';
 export { unknownToString } from './others/unknown-to-string.mjs';
+export { createPromise } from './promise/promise.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

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

package/dist/number/branded-types/finite-number.d.mts

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 type ElementType = FiniteNumber;
 /**
  * Type guard that checks if a value is a finite number.
@@ -115,7 +115,7 @@ export declare const FiniteNumber: {
      * FiniteNumber.abs(asFiniteNumber(3.2)); // FiniteNumber (3.2)
      * ```
      */
-    readonly abs: (x: FiniteNumber) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<FiniteNumber>;
+    readonly abs: (x: FiniteNumber) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<FiniteNumber>;
     /**
      * Returns the minimum value from a list of finite numbers.
      *
@@ -160,7 +160,7 @@ export declare const FiniteNumber: {
      * FiniteNumber.floor(asFiniteNumber(-5.2)); // Int (-6)
      * ```
      */
-    readonly floor: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Returns the smallest integer greater than or equal to the given finite number.
      * @param x - The finite number to ceil
@@ -171,7 +171,7 @@ export declare const FiniteNumber: {
      * FiniteNumber.ceil(asFiniteNumber(-5.8)); // Int (-5)
      * ```
      */
-    readonly ceil: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds a finite number to the nearest integer.
      * @param x - The finite number to round
@@ -183,7 +183,7 @@ export declare const FiniteNumber: {
      * FiniteNumber.round(asFiniteNumber(5.5)); // Int (6)
      * ```
      */
-    readonly round: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Generates a random finite number within the specified range.
      *
@@ -209,7 +209,7 @@ export declare const FiniteNumber: {
      * );
      * ```
      */
-    readonly random: (min: FiniteNumber, max: FiniteNumber) => FiniteNumber;
+    readonly random: (min?: FiniteNumber | undefined, max?: FiniteNumber | undefined) => FiniteNumber;
     /**
      * Raises a finite number to a power.
      * @param a - The base finite number

package/dist/number/branded-types/finite-number.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,KAAK,WAAW,GAAG,YAAY,CAAC;AA8ChC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;OAOG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;OASG;wBAnLA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqL1D;;;;;;;;;OASG;uBAzLA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA2L1D;;;;;;;;;;OAUG;wBAhMA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAkM1D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,YAAY,CAAC;AAgDhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;OAOG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;OASG;wBArLA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAuL3D;;;;;;;;;OASG;uBA3LA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA6L3D;;;;;;;;;;OAUG;wBAlMA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAoM3D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/finite-number.mjs

@@ -1,9 +1,9 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a finite number';
-const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForFloat({
-    MIN_VALUE: undefined,
-    MAX_VALUE: undefined,
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
     typeNameInMessage,
 });
 const floor = (x) => 

package/dist/number/branded-types/finite-number.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"finite-number.mjs","sources":["../../../src/number/branded-types/finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iBAAiB;AAE3C,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,iBAAiB,CAI1D;AACA,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAE5E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA8D;AAE3E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAI5E;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;AASG;IACH,KAAK;AAEL;;;;;;;;;AASG;IACH,IAAI;AAEJ;;;;;;;;;;AAUG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"finite-number.mjs","sources":["../../../src/number/branded-types/finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iBAAiB;AAE3C,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAM7E;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;AASG;IACH,KAAK;AAEL;;;;;;;;;AASG;IACH,IAAI;AAEJ;;;;;;;;;;AAUG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/int.d.mts

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Type guard that checks if a value is an integer.
  *
@@ -114,7 +114,7 @@ export declare const Int: {
      * Int.abs(asInt(-0));  // Int (0)
      * ```
      */
-    readonly abs: (x: WithSmallInt<Int, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<Int>;
+    readonly abs: (x: WithSmallInt<Int, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int>;
     /**
      * Returns the minimum value from a list of integers.
      *
@@ -163,7 +163,7 @@ export declare const Int: {
      * const temp = Int.random(asInt(-10), asInt(10));
      * ```
      */
-    readonly random: (min: WithSmallInt<Int, 40>, max: WithSmallInt<Int, 40>) => Int;
+    readonly random: (min?: WithSmallInt<Int, 40> | undefined, max?: WithSmallInt<Int, 40> | undefined) => Int;
     /**
      * Raises an integer to a power.
      * @param a - The base integer

package/dist/number/branded-types/int.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AA6BlE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,yBAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;OAOG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA6BnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,yBAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;OAOG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/int.mjs

@@ -1,10 +1,10 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'an integer';
-const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'Integer',
-    MIN_VALUE: undefined,
-    MAX_VALUE: undefined,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
     typeNameInMessage,
 });
 /**

package/dist/number/branded-types/int.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/int16.d.mts

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Checks if a number is an Int16 (16-bit signed integer in the range [-2^15, 2^15)).
  * @param value The value to check.
@@ -81,7 +81,7 @@ export declare const Int16: {
      * @param a The Int16 value.
      * @returns The absolute value as an Int16, clamped to valid range.
      */
-    readonly abs: (x: WithSmallInt<Int16, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<Int16>;
+    readonly abs: (x: WithSmallInt<Int16, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int16>;
     /**
      * Returns the smaller of two Int16 values.
      * @param a The first Int16.
@@ -106,7 +106,7 @@ export declare const Int16: {
      * Generates a random Int16 value within the valid range.
      * @returns A random Int16 between MIN_VALUE and MAX_VALUE.
      */
-    readonly random: (min: WithSmallInt<Int16, 40>, max: WithSmallInt<Int16, 40>) => Int16;
+    readonly random: (min?: WithSmallInt<Int16, 40> | undefined, max?: WithSmallInt<Int16, 40> | undefined) => Int16;
     /**
      * Raises an Int16 to the power of another Int16.
      * @param a The base Int16.

package/dist/number/branded-types/int16.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAgClE;;;;GAIG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,KAAK;IAChB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgCnE;;;;GAIG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,KAAK;IAChB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}