ts-data-forge 1.0.0 → 1.0.1

package/dist/number/branded-types/positive-int32.d.mts

@@ -0,0 +1,158 @@
+/**
+ * Checks if a number is a PositiveInt32 (32-bit positive signed integer in the range [1, 2^31)).
+ * @param value The value to check.
+ * @returns `true` if the value is a PositiveInt32, `false` otherwise.
+ */
+export declare const isPositiveInt32: (a: number) => a is PositiveInt32;
+/**
+ * Casts a number to a PositiveInt32 type.
+ * @param value The value to cast.
+ * @returns The value as a PositiveInt32 type.
+ * @throws {TypeError} If the value is not a positive integer in [1, 2^31).
+ * @example
+ * ```typescript
+ * const x = asPositiveInt32(1000); // PositiveInt32
+ * const y = asPositiveInt32(2147483647); // PositiveInt32
+ * // asPositiveInt32(0); // throws TypeError
+ * // asPositiveInt32(-1); // throws TypeError
+ * // asPositiveInt32(2147483648); // throws TypeError
+ * ```
+ */
+export declare const asPositiveInt32: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly "!=0": true;
+    readonly "> -2^16": true;
+    readonly "> -2^32": true;
+    readonly ">= -2^15": true;
+    readonly ">= -2^31": true;
+    readonly ">=0": true;
+    readonly "< 2^31": true;
+    readonly "< 2^32": true;
+    readonly Finite: true;
+    readonly Int: true;
+    readonly SafeInt: true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for 32-bit positive integers.
+ *
+ * All operations automatically clamp results to the valid PositiveInt32 range [1, 2147483647].
+ * This ensures that all arithmetic maintains the 32-bit positive integer constraint,
+ * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asPositiveInt32(2000000000);
+ * const b = asPositiveInt32(500000000);
+ *
+ * // Arithmetic operations with automatic clamping and positive constraint
+ * const sum = PositiveInt32.add(a, b);       // PositiveInt32 (2147483647 - clamped to MAX_VALUE)
+ * const diff = PositiveInt32.sub(a, b);      // PositiveInt32 (1500000000)
+ * const reverseDiff = PositiveInt32.sub(b, a); // PositiveInt32 (1 - clamped to MIN_VALUE)
+ * const product = PositiveInt32.mul(a, b);   // PositiveInt32 (2147483647 - clamped due to overflow)
+ *
+ * // Range operations (maintaining positive constraint)
+ * const clamped = PositiveInt32.clamp(-1000);     // PositiveInt32 (1)
+ * const minimum = PositiveInt32.min(a, b);        // PositiveInt32 (500000000)
+ * const maximum = PositiveInt32.max(a, b);        // PositiveInt32 (2000000000)
+ *
+ * // Utility operations
+ * const random = PositiveInt32.random();          // PositiveInt32 (random value in [1, 2147483647])
+ * const power = PositiveInt32.pow(asPositiveInt32(2), asPositiveInt32(20)); // PositiveInt32 (1048576)
+ * ```
+ */
+export declare const PositiveInt32: {
+    /**
+     * Type guard to check if a value is a PositiveInt32.
+     * @param value The value to check.
+     * @returns `true` if the value is a 32-bit positive integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is PositiveInt32;
+    /**
+     * The minimum value for a 32-bit positive integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: 1;
+    /**
+     * The maximum value for a 32-bit positive integer.
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the smaller of two PositiveInt32 values.
+     * @param a The first PositiveInt32.
+     * @param b The second PositiveInt32.
+     * @returns The minimum value as a PositiveInt32.
+     */
+    readonly min: (...values: readonly WithSmallInt<PositiveInt32, 40>[]) => PositiveInt32;
+    /**
+     * Returns the larger of two PositiveInt32 values.
+     * @param a The first PositiveInt32.
+     * @param b The second PositiveInt32.
+     * @returns The maximum value as a PositiveInt32.
+     */
+    readonly max: (...values: readonly WithSmallInt<PositiveInt32, 40>[]) => PositiveInt32;
+    /**
+     * Clamps a number to the PositiveInt32 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    readonly clamp: (x: number) => PositiveInt32;
+    /**
+     * Generates a random PositiveInt32 value within the valid range.
+     * @returns A random PositiveInt32 between 1 and 2147483647.
+     */
+    readonly random: (min: WithSmallInt<PositiveInt32, 40>, max: WithSmallInt<PositiveInt32, 40>) => PositiveInt32;
+    /**
+     * Raises a PositiveInt32 to the power of another PositiveInt32.
+     * @param a The base PositiveInt32.
+     * @param b The exponent PositiveInt32.
+     * @returns `a ** b` clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    readonly pow: (x: WithSmallInt<PositiveInt32, 40>, y: WithSmallInt<PositiveInt32, 40>) => PositiveInt32;
+    /**
+     * Adds two PositiveInt32 values.
+     * @param a The first PositiveInt32.
+     * @param b The second PositiveInt32.
+     * @returns `a + b` clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    readonly add: (x: WithSmallInt<PositiveInt32, 40>, y: WithSmallInt<PositiveInt32, 40>) => PositiveInt32;
+    /**
+     * Subtracts one PositiveInt32 from another.
+     * @param a The minuend PositiveInt32.
+     * @param b The subtrahend PositiveInt32.
+     * @returns `a - b` clamped to [1, 2147483647] as a PositiveInt32 (minimum 1).
+     */
+    readonly sub: (x: WithSmallInt<PositiveInt32, 40>, y: WithSmallInt<PositiveInt32, 40>) => PositiveInt32;
+    /**
+     * Multiplies two PositiveInt32 values.
+     * @param a The first PositiveInt32.
+     * @param b The second PositiveInt32.
+     * @returns `a * b` clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    readonly mul: (x: WithSmallInt<PositiveInt32, 40>, y: WithSmallInt<PositiveInt32, 40>) => PositiveInt32;
+    /**
+     * Divides one PositiveInt32 by another using floor division.
+     * @param a The dividend PositiveInt32.
+     * @param b The divisor PositiveInt32.
+     * @returns `⌊a / b⌋` clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    readonly div: (x: WithSmallInt<PositiveInt32, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | NormalizeBrandUnion<number & {
+        readonly NaNValue: false;
+        readonly "!=0": true;
+        readonly "> -2^16": true;
+        readonly "> -2^32": true;
+        readonly ">= -2^15": true;
+        readonly ">= -2^31": true;
+        readonly ">=0": true;
+        readonly "< 2^31": true;
+        readonly "< 2^32": true;
+        readonly Finite: true;
+        readonly Int: true;
+        readonly SafeInt: true;
+    } & Readonly<{
+        'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+    }>>) => PositiveInt32;
+};
+//# sourceMappingURL=positive-int32.d.mts.map

package/dist/number/branded-types/positive-int32.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positive-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int32.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,eAAe,mCAAK,CAAC;AAElC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,aAAa;IACxB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/positive-int32.mjs

@@ -0,0 +1,139 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a positive integer in [1, 2^31)';
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'SafeInteger',
+    MIN_VALUE: 1,
+    MAX_VALUE: 2 ** 31 - 1,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a PositiveInt32 (32-bit positive signed integer in the range [1, 2^31)).
+ * @param value The value to check.
+ * @returns `true` if the value is a PositiveInt32, `false` otherwise.
+ */
+const isPositiveInt32 = is;
+/**
+ * Casts a number to a PositiveInt32 type.
+ * @param value The value to cast.
+ * @returns The value as a PositiveInt32 type.
+ * @throws {TypeError} If the value is not a positive integer in [1, 2^31).
+ * @example
+ * ```typescript
+ * const x = asPositiveInt32(1000); // PositiveInt32
+ * const y = asPositiveInt32(2147483647); // PositiveInt32
+ * // asPositiveInt32(0); // throws TypeError
+ * // asPositiveInt32(-1); // throws TypeError
+ * // asPositiveInt32(2147483648); // throws TypeError
+ * ```
+ */
+const asPositiveInt32 = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for 32-bit positive integers.
+ *
+ * All operations automatically clamp results to the valid PositiveInt32 range [1, 2147483647].
+ * This ensures that all arithmetic maintains the 32-bit positive integer constraint,
+ * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asPositiveInt32(2000000000);
+ * const b = asPositiveInt32(500000000);
+ *
+ * // Arithmetic operations with automatic clamping and positive constraint
+ * const sum = PositiveInt32.add(a, b);       // PositiveInt32 (2147483647 - clamped to MAX_VALUE)
+ * const diff = PositiveInt32.sub(a, b);      // PositiveInt32 (1500000000)
+ * const reverseDiff = PositiveInt32.sub(b, a); // PositiveInt32 (1 - clamped to MIN_VALUE)
+ * const product = PositiveInt32.mul(a, b);   // PositiveInt32 (2147483647 - clamped due to overflow)
+ *
+ * // Range operations (maintaining positive constraint)
+ * const clamped = PositiveInt32.clamp(-1000);     // PositiveInt32 (1)
+ * const minimum = PositiveInt32.min(a, b);        // PositiveInt32 (500000000)
+ * const maximum = PositiveInt32.max(a, b);        // PositiveInt32 (2000000000)
+ *
+ * // Utility operations
+ * const random = PositiveInt32.random();          // PositiveInt32 (random value in [1, 2147483647])
+ * const power = PositiveInt32.pow(asPositiveInt32(2), asPositiveInt32(20)); // PositiveInt32 (1048576)
+ * ```
+ */
+const PositiveInt32 = {
+    /**
+     * Type guard to check if a value is a PositiveInt32.
+     * @param value The value to check.
+     * @returns `true` if the value is a 32-bit positive integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a 32-bit positive integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum value for a 32-bit positive integer.
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the smaller of two PositiveInt32 values.
+     * @param a The first PositiveInt32.
+     * @param b The second PositiveInt32.
+     * @returns The minimum value as a PositiveInt32.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two PositiveInt32 values.
+     * @param a The first PositiveInt32.
+     * @param b The second PositiveInt32.
+     * @returns The maximum value as a PositiveInt32.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the PositiveInt32 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    clamp,
+    /**
+     * Generates a random PositiveInt32 value within the valid range.
+     * @returns A random PositiveInt32 between 1 and 2147483647.
+     */
+    random,
+    /**
+     * Raises a PositiveInt32 to the power of another PositiveInt32.
+     * @param a The base PositiveInt32.
+     * @param b The exponent PositiveInt32.
+     * @returns `a ** b` clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    pow,
+    /**
+     * Adds two PositiveInt32 values.
+     * @param a The first PositiveInt32.
+     * @param b The second PositiveInt32.
+     * @returns `a + b` clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    add,
+    /**
+     * Subtracts one PositiveInt32 from another.
+     * @param a The minuend PositiveInt32.
+     * @param b The subtrahend PositiveInt32.
+     * @returns `a - b` clamped to [1, 2147483647] as a PositiveInt32 (minimum 1).
+     */
+    sub,
+    /**
+     * Multiplies two PositiveInt32 values.
+     * @param a The first PositiveInt32.
+     * @param b The second PositiveInt32.
+     * @returns `a * b` clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    mul,
+    /**
+     * Divides one PositiveInt32 by another using floor division.
+     * @param a The dividend PositiveInt32.
+     * @param b The divisor PositiveInt32.
+     * @returns `⌊a / b⌋` clamped to [1, 2147483647] as a PositiveInt32.
+     */
+    div,
+};
+
+export { PositiveInt32, asPositiveInt32, isPositiveInt32 };
+//# sourceMappingURL=positive-int32.mjs.map

package/dist/number/branded-types/positive-int32.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"positive-int32.mjs","sources":["../../../src/number/branded-types/positive-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iCAAiC;AAE3D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;;;;;;;;AAaG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,aAAa,GAAG;AAC3B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -0,0 +1,152 @@
+/**
+ * Checks if a number is a PositiveSafeInt (a positive safe integer in the range [1, MAX_SAFE_INTEGER]).
+ * @param value The value to check.
+ * @returns `true` if the value is a PositiveSafeInt, `false` otherwise.
+ */
+export declare const isPositiveSafeInt: (a: number) => a is PositiveSafeInt;
+/**
+ * Casts a number to a PositiveSafeInt type.
+ * @param value The value to cast.
+ * @returns The value as a PositiveSafeInt type.
+ * @throws {TypeError} If the value is not a positive safe integer.
+ * @example
+ * ```typescript
+ * const x = asPositiveSafeInt(5); // PositiveSafeInt
+ * const y = asPositiveSafeInt(1000); // PositiveSafeInt
+ * // asPositiveSafeInt(0); // throws TypeError
+ * // asPositiveSafeInt(-1); // throws TypeError
+ * ```
+ */
+export declare const asPositiveSafeInt: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly "!=0": true;
+    readonly "> -2^16": true;
+    readonly "> -2^32": true;
+    readonly ">= -2^15": true;
+    readonly ">= -2^31": true;
+    readonly ">=0": true;
+    readonly Finite: true;
+    readonly Int: true;
+    readonly SafeInt: true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for positive safe integers.
+ *
+ * All operations automatically clamp results to the positive safe integer range [1, MAX_SAFE_INTEGER].
+ * This ensures that all arithmetic maintains both the positive constraint and IEEE 754 precision guarantees,
+ * preventing precision loss and ensuring results are always positive.
+ *
+ * @example
+ * ```typescript
+ * const a = asPositiveSafeInt(1000000);
+ * const b = asPositiveSafeInt(2000000);
+ *
+ * // Arithmetic operations with positive safe range clamping
+ * const sum = PositiveSafeInt.add(a, b);          // PositiveSafeInt (3000000)
+ * const diff = PositiveSafeInt.sub(a, b);         // PositiveSafeInt (1 - clamped to MIN_VALUE)
+ * const product = PositiveSafeInt.mul(a, b);      // PositiveSafeInt (2000000000000)
+ *
+ * // Range operations
+ * const clamped = PositiveSafeInt.clamp(0);           // PositiveSafeInt (1)
+ * const minimum = PositiveSafeInt.min(a, b);          // PositiveSafeInt (1000000)
+ * const maximum = PositiveSafeInt.max(a, b);          // PositiveSafeInt (2000000)
+ *
+ * // Utility operations
+ * const random = PositiveSafeInt.random();            // PositiveSafeInt (random positive safe integer)
+ * const power = PositiveSafeInt.pow(asPositiveSafeInt(2), asPositiveSafeInt(10)); // PositiveSafeInt (1024)
+ * ```
+ */
+export declare const PositiveSafeInt: {
+    /**
+     * Type guard to check if a value is a PositiveSafeInt.
+     * @param value The value to check.
+     * @returns `true` if the value is a positive safe integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is PositiveSafeInt;
+    /**
+     * The minimum value for a positive safe integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: 1;
+    /**
+     * The maximum safe integer value (2^53 - 1).
+     * @readonly
+     */
+    readonly MAX_VALUE: SafeUint;
+    /**
+     * Returns the smaller of two PositiveSafeInt values.
+     * @param a The first PositiveSafeInt.
+     * @param b The second PositiveSafeInt.
+     * @returns The minimum value as a PositiveSafeInt.
+     */
+    readonly min: (...values: readonly WithSmallInt<PositiveSafeInt, 40>[]) => PositiveSafeInt;
+    /**
+     * Returns the larger of two PositiveSafeInt values.
+     * @param a The first PositiveSafeInt.
+     * @param b The second PositiveSafeInt.
+     * @returns The maximum value as a PositiveSafeInt.
+     */
+    readonly max: (...values: readonly WithSmallInt<PositiveSafeInt, 40>[]) => PositiveSafeInt;
+    /**
+     * Clamps a number to the positive safe integer range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    readonly clamp: (x: number) => PositiveSafeInt;
+    /**
+     * Generates a random PositiveSafeInt value within the valid range.
+     * @returns A random PositiveSafeInt between 1 and MAX_SAFE_INTEGER.
+     */
+    readonly random: (min: WithSmallInt<PositiveSafeInt, 40>, max: WithSmallInt<PositiveSafeInt, 40>) => PositiveSafeInt;
+    /**
+     * Raises a PositiveSafeInt to the power of another PositiveSafeInt.
+     * @param a The base PositiveSafeInt.
+     * @param b The exponent PositiveSafeInt.
+     * @returns `a ** b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    readonly pow: (x: WithSmallInt<PositiveSafeInt, 40>, y: WithSmallInt<PositiveSafeInt, 40>) => PositiveSafeInt;
+    /**
+     * Adds two PositiveSafeInt values.
+     * @param a The first PositiveSafeInt.
+     * @param b The second PositiveSafeInt.
+     * @returns `a + b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    readonly add: (x: WithSmallInt<PositiveSafeInt, 40>, y: WithSmallInt<PositiveSafeInt, 40>) => PositiveSafeInt;
+    /**
+     * Subtracts one PositiveSafeInt from another.
+     * @param a The minuend PositiveSafeInt.
+     * @param b The subtrahend PositiveSafeInt.
+     * @returns `a - b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt (minimum 1).
+     */
+    readonly sub: (x: WithSmallInt<PositiveSafeInt, 40>, y: WithSmallInt<PositiveSafeInt, 40>) => PositiveSafeInt;
+    /**
+     * Multiplies two PositiveSafeInt values.
+     * @param a The first PositiveSafeInt.
+     * @param b The second PositiveSafeInt.
+     * @returns `a * b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    readonly mul: (x: WithSmallInt<PositiveSafeInt, 40>, y: WithSmallInt<PositiveSafeInt, 40>) => PositiveSafeInt;
+    /**
+     * Divides one PositiveSafeInt by another using floor division.
+     * @param a The dividend PositiveSafeInt.
+     * @param b The divisor PositiveSafeInt.
+     * @returns `⌊a / b⌋` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    readonly div: (x: WithSmallInt<PositiveSafeInt, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | NormalizeBrandUnion<number & {
+        readonly NaNValue: false;
+        readonly "!=0": true;
+        readonly "> -2^16": true;
+        readonly "> -2^32": true;
+        readonly ">= -2^15": true;
+        readonly ">= -2^31": true;
+        readonly ">=0": true;
+        readonly Finite: true;
+        readonly Int: true;
+        readonly SafeInt: true;
+    } & Readonly<{
+        'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+    }>>) => PositiveSafeInt;
+};
+//# sourceMappingURL=positive-safe-int.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,qCAAK,CAAC;AAEpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -0,0 +1,138 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a positive safe integer';
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'SafeInteger',
+    MIN_VALUE: 1,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    MAX_VALUE: Number.MAX_SAFE_INTEGER,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a PositiveSafeInt (a positive safe integer in the range [1, MAX_SAFE_INTEGER]).
+ * @param value The value to check.
+ * @returns `true` if the value is a PositiveSafeInt, `false` otherwise.
+ */
+const isPositiveSafeInt = is;
+/**
+ * Casts a number to a PositiveSafeInt type.
+ * @param value The value to cast.
+ * @returns The value as a PositiveSafeInt type.
+ * @throws {TypeError} If the value is not a positive safe integer.
+ * @example
+ * ```typescript
+ * const x = asPositiveSafeInt(5); // PositiveSafeInt
+ * const y = asPositiveSafeInt(1000); // PositiveSafeInt
+ * // asPositiveSafeInt(0); // throws TypeError
+ * // asPositiveSafeInt(-1); // throws TypeError
+ * ```
+ */
+const asPositiveSafeInt = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for positive safe integers.
+ *
+ * All operations automatically clamp results to the positive safe integer range [1, MAX_SAFE_INTEGER].
+ * This ensures that all arithmetic maintains both the positive constraint and IEEE 754 precision guarantees,
+ * preventing precision loss and ensuring results are always positive.
+ *
+ * @example
+ * ```typescript
+ * const a = asPositiveSafeInt(1000000);
+ * const b = asPositiveSafeInt(2000000);
+ *
+ * // Arithmetic operations with positive safe range clamping
+ * const sum = PositiveSafeInt.add(a, b);          // PositiveSafeInt (3000000)
+ * const diff = PositiveSafeInt.sub(a, b);         // PositiveSafeInt (1 - clamped to MIN_VALUE)
+ * const product = PositiveSafeInt.mul(a, b);      // PositiveSafeInt (2000000000000)
+ *
+ * // Range operations
+ * const clamped = PositiveSafeInt.clamp(0);           // PositiveSafeInt (1)
+ * const minimum = PositiveSafeInt.min(a, b);          // PositiveSafeInt (1000000)
+ * const maximum = PositiveSafeInt.max(a, b);          // PositiveSafeInt (2000000)
+ *
+ * // Utility operations
+ * const random = PositiveSafeInt.random();            // PositiveSafeInt (random positive safe integer)
+ * const power = PositiveSafeInt.pow(asPositiveSafeInt(2), asPositiveSafeInt(10)); // PositiveSafeInt (1024)
+ * ```
+ */
+const PositiveSafeInt = {
+    /**
+     * Type guard to check if a value is a PositiveSafeInt.
+     * @param value The value to check.
+     * @returns `true` if the value is a positive safe integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a positive safe integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum safe integer value (2^53 - 1).
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the smaller of two PositiveSafeInt values.
+     * @param a The first PositiveSafeInt.
+     * @param b The second PositiveSafeInt.
+     * @returns The minimum value as a PositiveSafeInt.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two PositiveSafeInt values.
+     * @param a The first PositiveSafeInt.
+     * @param b The second PositiveSafeInt.
+     * @returns The maximum value as a PositiveSafeInt.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the positive safe integer range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    clamp,
+    /**
+     * Generates a random PositiveSafeInt value within the valid range.
+     * @returns A random PositiveSafeInt between 1 and MAX_SAFE_INTEGER.
+     */
+    random,
+    /**
+     * Raises a PositiveSafeInt to the power of another PositiveSafeInt.
+     * @param a The base PositiveSafeInt.
+     * @param b The exponent PositiveSafeInt.
+     * @returns `a ** b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    pow,
+    /**
+     * Adds two PositiveSafeInt values.
+     * @param a The first PositiveSafeInt.
+     * @param b The second PositiveSafeInt.
+     * @returns `a + b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    add,
+    /**
+     * Subtracts one PositiveSafeInt from another.
+     * @param a The minuend PositiveSafeInt.
+     * @param b The subtrahend PositiveSafeInt.
+     * @returns `a - b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt (minimum 1).
+     */
+    sub,
+    /**
+     * Multiplies two PositiveSafeInt values.
+     * @param a The first PositiveSafeInt.
+     * @param b The second PositiveSafeInt.
+     * @returns `a * b` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    mul,
+    /**
+     * Divides one PositiveSafeInt by another using floor division.
+     * @param a The dividend PositiveSafeInt.
+     * @param b The divisor PositiveSafeInt.
+     * @returns `⌊a / b⌋` clamped to [1, MAX_SAFE_INTEGER] as a PositiveSafeInt.
+     */
+    div,
+};
+
+export { PositiveSafeInt, asPositiveSafeInt, isPositiveSafeInt };
+//# sourceMappingURL=positive-safe-int.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive-safe-int.mjs","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,yBAAyB;AAEnD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;;IAEZ,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;;;;;AAYG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,eAAe,GAAG;AAC7B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}