ts-data-forge 6.13.1 → 7.0.1

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":"AAAA,OAAO,EAAE,KAAK,GAAG,IAAI,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,GAAG,GAAG,eAAe,CAAC;AA6BlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,qCAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,IAAI,eAAe,EAAE,MAAM,eAAe,CAAC;AAI5D,MAAM,MAAM,GAAG,GAAG,eAAe,CAAC;AA6BlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,qCAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}

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

@@ -1,5 +1,4 @@
 import { type Int16 as TtfImported_Int16 } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type Int16 = TtfImported_Int16;
 /**
  * Checks if a number is an Int16 (16-bit signed integer in the range [-2^15,
@@ -66,7 +65,7 @@ export declare const Int16: {
      * @param a The Int16 value.
      * @returns The absolute value as an Int16, clamped to valid range.
      */
-    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_Int16>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>) => import("ts-type-forge").IntersectBrand<TtfImported_Int16, import("ts-type-forge").NonNegativeNumber>;
     /**
      * Returns the smaller of two Int16 values.
      *
@@ -139,11 +138,11 @@ export declare const Int16: {
         readonly NaNValue: false;
         readonly Finite: true;
         readonly Int: true;
-        readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
         readonly ">= -2^15": true;
         readonly ">= -2^31": true;
+        readonly "!=0": true;
         readonly "< 2^15": true;
         readonly "< 2^16": true;
         readonly "< 2^31": true;

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":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIhE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,5 +1,4 @@
 import { type Int32 as TtfImported_Int32 } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type Int32 = TtfImported_Int32;
 /**
  * Checks if a number is an Int32 (32-bit signed integer in the range [-2^31,
@@ -62,7 +61,7 @@ export declare const Int32: {
      * @param a The Int32 value.
      * @returns The absolute value as an Int32, clamped to valid range.
      */
-    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_Int32>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>) => import("ts-type-forge").IntersectBrand<TtfImported_Int32, import("ts-type-forge").NonNegativeNumber>;
     /**
      * Returns the smaller of two Int32 values.
      *
@@ -135,9 +134,9 @@ export declare const Int32: {
         readonly NaNValue: false;
         readonly Finite: true;
         readonly Int: true;
-        readonly "!=0": true;
         readonly "> -2^32": true;
         readonly ">= -2^31": true;
+        readonly "!=0": true;
         readonly "< 2^31": true;
         readonly "< 2^32": true;
         readonly SafeInt: true;

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

@@ -1 +1 @@
-{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIhE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -0,0 +1,143 @@
+import { type NegativeFiniteNumber as TtfImported_NegativeFiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { PositiveFiniteNumber } from './positive-finite-number.mjs';
+export type NegativeFiniteNumber = TtfImported_NegativeFiniteNumber;
+type ElementType = NegativeFiniteNumber;
+/**
+ * Checks if a number is a NegativeFiniteNumber (a finite number `< 0`).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NegativeFiniteNumber, `false` otherwise.
+ */
+export declare const isNegativeFiniteNumber: (a: number) => a is TtfImported_NegativeFiniteNumber;
+/**
+ * Casts a number to a NegativeFiniteNumber type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NegativeFiniteNumber type.
+ * @throws {TypeError} If the value is not a negative finite number.
+ */
+export declare const asNegativeFiniteNumber: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly Finite: true;
+    readonly ">=0": false;
+    readonly "!=0": true;
+    readonly "<=0": true;
+    readonly "< 2^15": true;
+    readonly "< 2^16": true;
+    readonly "< 2^31": true;
+    readonly "< 2^32": true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for negative finite
+ * numbers.
+ *
+ * All operations keep results finite (excluding NaN and Infinity). Operations
+ * that stay within the negative finite numbers clamp their results to the valid
+ * range, while operations whose result leaves the set (`mul`, `div`, `abs`) are
+ * typed to reflect the actual sign of the result.
+ */
+export declare const NegativeFiniteNumber: {
+    /**
+     * Type guard to check if a value is a NegativeFiniteNumber.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a negative finite number, `false`
+     *   otherwise.
+     */
+    readonly is: (a: number) => a is TtfImported_NegativeFiniteNumber;
+    /**
+     * The maximum value for a negative finite number.
+     *
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the absolute value of a negative finite number.
+     *
+     * @param a The negative finite number.
+     * @returns The absolute value as a PositiveFiniteNumber.
+     */
+    readonly abs: (x: ElementType) => PositiveFiniteNumber;
+    /**
+     * Returns the smaller of two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns The minimum value as a NegativeFiniteNumber.
+     */
+    readonly min: (...values: readonly TtfImported_NegativeFiniteNumber[]) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Returns the larger of two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns The maximum value as a NegativeFiniteNumber.
+     */
+    readonly max: (...values: readonly TtfImported_NegativeFiniteNumber[]) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Clamps a number to the negative finite range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    readonly clamp: (x: number) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Rounds down a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round down.
+     * @returns The floor value as a NegativeInt (always `<= -1`).
+     */
+    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    /**
+     * Rounds up a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round up.
+     * @returns The ceiling value as a NonPositiveInt (can be 0).
+     */
+    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    /**
+     * Rounds a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round.
+     * @returns The rounded value as a NonPositiveInt (can be 0 if x > -0.5).
+     */
+    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    /**
+     * Generates a random NegativeFiniteNumber value.
+     *
+     * @returns A random negative finite number.
+     */
+    readonly random: (min?: TtfImported_NegativeFiniteNumber | undefined, max?: TtfImported_NegativeFiniteNumber | undefined) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Raises a NegativeFiniteNumber to the power of another NegativeFiniteNumber.
+     *
+     * @param a The base NegativeFiniteNumber.
+     * @param b The exponent NegativeFiniteNumber.
+     * @returns `a ** b` clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    readonly pow: (x: TtfImported_NegativeFiniteNumber, y: TtfImported_NegativeFiniteNumber) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Adds two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns `a + b` as a NegativeFiniteNumber.
+     */
+    readonly add: (x: TtfImported_NegativeFiniteNumber, y: TtfImported_NegativeFiniteNumber) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Subtracts one NegativeFiniteNumber from another.
+     *
+     * The mathematical result can be positive, so it is clamped to the negative
+     * finite range (maximum `-Number.MIN_VALUE`).
+     *
+     * @param a The minuend NegativeFiniteNumber.
+     * @param b The subtrahend NegativeFiniteNumber.
+     * @returns `a - b` clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    readonly sub: (x: TtfImported_NegativeFiniteNumber, y: TtfImported_NegativeFiniteNumber) => TtfImported_NegativeFiniteNumber;
+};
+export {};
+//# sourceMappingURL=negative-finite-number.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,IAAI,gCAAgC,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAkExC;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;sBA/EW,WAAW,KAAG,oBAAoB;IAkFhD;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;wBA7GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA+G3D;;;;;OAKG;uBA/GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA+GC;;;;;OAKG;wBA7GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA6GC;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;;OASG;;CAEK,CAAC"}

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

@@ -0,0 +1,156 @@
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { PositiveFiniteNumber } from './positive-finite-number.mjs';
+
+const typeNameInMessage = 'a negative finite number';
+const { MAX_VALUE, add, castType, clamp, is, max: max_, min: min_, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
+    nonZero: true,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: -Number.MIN_VALUE,
+    typeNameInMessage,
+});
+/**
+ * Returns the absolute value of a negative finite number.
+ *
+ * The absolute value of a negative finite number is always a positive finite
+ * number, so the result is typed as a {@link PositiveFiniteNumber}.
+ *
+ * @param x - The negative finite number.
+ * @returns `|x|` as a PositiveFiniteNumber.
+ */
+const abs = (x) => PositiveFiniteNumber.clamp(Math.abs(x));
+const floor = (x) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+Math.floor(x);
+const ceil = (x) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+Math.ceil(x);
+const round = (x) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+Math.round(x);
+/**
+ * Checks if a number is a NegativeFiniteNumber (a finite number `< 0`).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NegativeFiniteNumber, `false` otherwise.
+ */
+const isNegativeFiniteNumber = is;
+/**
+ * Casts a number to a NegativeFiniteNumber type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NegativeFiniteNumber type.
+ * @throws {TypeError} If the value is not a negative finite number.
+ */
+const asNegativeFiniteNumber = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for negative finite
+ * numbers.
+ *
+ * All operations keep results finite (excluding NaN and Infinity). Operations
+ * that stay within the negative finite numbers clamp their results to the valid
+ * range, while operations whose result leaves the set (`mul`, `div`, `abs`) are
+ * typed to reflect the actual sign of the result.
+ */
+const NegativeFiniteNumber = {
+    /**
+     * Type guard to check if a value is a NegativeFiniteNumber.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a negative finite number, `false`
+     *   otherwise.
+     */
+    is,
+    /**
+     * The maximum value for a negative finite number.
+     *
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the absolute value of a negative finite number.
+     *
+     * @param a The negative finite number.
+     * @returns The absolute value as a PositiveFiniteNumber.
+     */
+    abs,
+    /**
+     * Returns the smaller of two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns The minimum value as a NegativeFiniteNumber.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns The maximum value as a NegativeFiniteNumber.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the negative finite range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    clamp,
+    /**
+     * Rounds down a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round down.
+     * @returns The floor value as a NegativeInt (always `<= -1`).
+     */
+    floor,
+    /**
+     * Rounds up a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round up.
+     * @returns The ceiling value as a NonPositiveInt (can be 0).
+     */
+    ceil,
+    /**
+     * Rounds a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round.
+     * @returns The rounded value as a NonPositiveInt (can be 0 if x > -0.5).
+     */
+    round,
+    /**
+     * Generates a random NegativeFiniteNumber value.
+     *
+     * @returns A random negative finite number.
+     */
+    random,
+    /**
+     * Raises a NegativeFiniteNumber to the power of another NegativeFiniteNumber.
+     *
+     * @param a The base NegativeFiniteNumber.
+     * @param b The exponent NegativeFiniteNumber.
+     * @returns `a ** b` clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    pow,
+    /**
+     * Adds two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns `a + b` as a NegativeFiniteNumber.
+     */
+    add,
+    /**
+     * Subtracts one NegativeFiniteNumber from another.
+     *
+     * The mathematical result can be positive, so it is clamped to the negative
+     * finite range (maximum `-Number.MIN_VALUE`).
+     *
+     * @param a The minuend NegativeFiniteNumber.
+     * @param b The subtrahend NegativeFiniteNumber.
+     * @returns `a - b` clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    sub,
+};
+
+export { NegativeFiniteNumber, asNegativeFiniteNumber, isNegativeFiniteNumber };
+//# sourceMappingURL=negative-finite-number.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"negative-finite-number.mjs","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;AAC5B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;AAQG;AACH,MAAM,GAAG,GAAG,CAAC,CAAc,KACzB,oBAAoB,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAEzC,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAId;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAEV;AAEH,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAEH;;;;;AAKG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;AAMG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;;;AAQG;AACI,MAAM,oBAAoB,GAAG;AAClC;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;;;;;"}

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

@@ -0,0 +1,120 @@
+import { type NegativeInt as TtfImported_NegativeInt, type WithSmallInt } from 'ts-type-forge';
+import { PositiveInt } from './positive-int.mjs';
+export type NegativeInt = TtfImported_NegativeInt;
+type ElementType = NegativeInt;
+/**
+ * Checks if a number is a NegativeInt (a negative integer `<= -1`).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NegativeInt, `false` otherwise.
+ */
+export declare const isNegativeInt: (a: number) => a is TtfImported_NegativeInt;
+/**
+ * Casts a number to a NegativeInt type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NegativeInt type.
+ * @throws {TypeError} If the value is not a negative integer.
+ */
+export declare const asNegativeInt: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
+    readonly ">=0": false;
+    readonly "!=0": true;
+    readonly "<=0": true;
+    readonly "< 2^15": true;
+    readonly "< 2^16": true;
+    readonly "< 2^31": true;
+    readonly "< 2^32": true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for negative integers.
+ *
+ * NegativeInt represents integers that are strictly less than zero (`<= -1`).
+ * Operations that stay within the negative integers (such as `add`) clamp their
+ * results to the valid range, while operations whose result leaves the set
+ * (`mul`, `div`, `abs`) are typed to reflect the actual sign of the result.
+ */
+export declare const NegativeInt: {
+    /**
+     * Type guard to check if a value is a NegativeInt.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a negative integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is TtfImported_NegativeInt;
+    /**
+     * The maximum value for a negative integer.
+     *
+     * @readonly
+     */
+    readonly MAX_VALUE: -1;
+    /**
+     * Returns the absolute value of a negative integer.
+     *
+     * @param a The negative integer.
+     * @returns The absolute value as a PositiveInt.
+     */
+    readonly abs: (x: WithSmallInt<ElementType>) => PositiveInt;
+    /**
+     * Returns the smaller of two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns The minimum value as a NegativeInt.
+     */
+    readonly min: (...values: readonly WithSmallInt<TtfImported_NegativeInt>[]) => TtfImported_NegativeInt;
+    /**
+     * Returns the larger of two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns The maximum value as a NegativeInt.
+     */
+    readonly max: (...values: readonly WithSmallInt<TtfImported_NegativeInt>[]) => TtfImported_NegativeInt;
+    /**
+     * Clamps a number to the negative integer range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `[-∞, -1]` as a NegativeInt.
+     */
+    readonly clamp: (x: number) => TtfImported_NegativeInt;
+    /**
+     * Generates a random NegativeInt value within the valid range.
+     *
+     * @returns A random negative integer.
+     */
+    readonly random: (min?: WithSmallInt<TtfImported_NegativeInt> | undefined, max?: WithSmallInt<TtfImported_NegativeInt> | undefined) => TtfImported_NegativeInt;
+    /**
+     * Raises a negative integer to the power of another negative integer.
+     *
+     * @param a The base negative integer.
+     * @param b The exponent negative integer.
+     * @returns `a ** b` clamped to the negative integer range.
+     */
+    readonly pow: (x: WithSmallInt<TtfImported_NegativeInt>, y: WithSmallInt<TtfImported_NegativeInt>) => TtfImported_NegativeInt;
+    /**
+     * Adds two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns `a + b` as a NegativeInt.
+     */
+    readonly add: (x: WithSmallInt<TtfImported_NegativeInt>, y: WithSmallInt<TtfImported_NegativeInt>) => TtfImported_NegativeInt;
+    /**
+     * Subtracts one negative integer from another.
+     *
+     * The mathematical result can be positive, so it is clamped to the negative
+     * integer range (maximum `-1`).
+     *
+     * @param a The minuend negative integer.
+     * @param b The subtrahend negative integer.
+     * @returns `a - b` clamped to the negative integer range.
+     */
+    readonly sub: (x: WithSmallInt<TtfImported_NegativeInt>, y: WithSmallInt<TtfImported_NegativeInt>) => TtfImported_NegativeInt;
+};
+export {};
+//# sourceMappingURL=negative-int.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"negative-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,IAAI,uBAAuB,EAC3C,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AAElD,KAAK,WAAW,GAAG,WAAW,CAAC;AAuC/B;;;;;GAKG;AACH,eAAO,MAAM,aAAa,6CAAK,CAAC;AAEhC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;sBAjDW,YAAY,CAAC,WAAW,CAAC,KAAG,WAAW;IAoDrD;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;;OASG;;CAEK,CAAC"}

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

@@ -0,0 +1,125 @@
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { PositiveInt } from './positive-int.mjs';
+
+const typeNameInMessage = 'a negative integer';
+const { MAX_VALUE, add, castType, clamp, is, max: max_, min: min_, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'Integer',
+    nonZero: true,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: -1,
+    typeNameInMessage,
+});
+/**
+ * Returns the absolute value of a negative integer.
+ *
+ * The absolute value of a negative integer is always a positive integer
+ * (`>= 1`), so the result is typed as a {@link PositiveInt}.
+ *
+ * @param x - The negative integer.
+ * @returns `|x|` as a PositiveInt.
+ */
+const abs = (x) => PositiveInt.clamp(Math.abs(x));
+/**
+ * Checks if a number is a NegativeInt (a negative integer `<= -1`).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NegativeInt, `false` otherwise.
+ */
+const isNegativeInt = is;
+/**
+ * Casts a number to a NegativeInt type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NegativeInt type.
+ * @throws {TypeError} If the value is not a negative integer.
+ */
+const asNegativeInt = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for negative integers.
+ *
+ * NegativeInt represents integers that are strictly less than zero (`<= -1`).
+ * Operations that stay within the negative integers (such as `add`) clamp their
+ * results to the valid range, while operations whose result leaves the set
+ * (`mul`, `div`, `abs`) are typed to reflect the actual sign of the result.
+ */
+const NegativeInt = {
+    /**
+     * Type guard to check if a value is a NegativeInt.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a negative integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The maximum value for a negative integer.
+     *
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the absolute value of a negative integer.
+     *
+     * @param a The negative integer.
+     * @returns The absolute value as a PositiveInt.
+     */
+    abs,
+    /**
+     * Returns the smaller of two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns The minimum value as a NegativeInt.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns The maximum value as a NegativeInt.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the negative integer range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `[-∞, -1]` as a NegativeInt.
+     */
+    clamp,
+    /**
+     * Generates a random NegativeInt value within the valid range.
+     *
+     * @returns A random negative integer.
+     */
+    random,
+    /**
+     * Raises a negative integer to the power of another negative integer.
+     *
+     * @param a The base negative integer.
+     * @param b The exponent negative integer.
+     * @returns `a ** b` clamped to the negative integer range.
+     */
+    pow,
+    /**
+     * Adds two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns `a + b` as a NegativeInt.
+     */
+    add,
+    /**
+     * Subtracts one negative integer from another.
+     *
+     * The mathematical result can be positive, so it is clamped to the negative
+     * integer range (maximum `-1`).
+     *
+     * @param a The minuend negative integer.
+     * @param b The subtrahend negative integer.
+     * @returns `a - b` clamped to the negative integer range.
+     */
+    sub,
+};
+
+export { NegativeInt, asNegativeInt, isNegativeInt };
+//# sourceMappingURL=negative-int.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"negative-int.mjs","sources":["../../../src/number/branded-types/negative-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAWA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,EAAE;IACb,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;AAQG;AACH,MAAM,GAAG,GAAG,CAAC,CAA4B,KACvC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAEhC;;;;;AAKG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;AAMG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;AAOG;AACI,MAAM,WAAW,GAAG;AACzB;;;;;AAKG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;;;;;"}