ts-data-forge 9.0.0 → 9.0.1

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

@@ -1,280 +1,237 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
-const typeNameInMessage = 'a positive integer';
-const { MIN_VALUE, add, castType, clamp, div, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'Integer',
-    MIN_VALUE: 1,
-    MAX_VALUE: Number.MAX_VALUE,
-    typeNameInMessage,
+const typeNameInMessage = "a positive integer";
+const {
+  MIN_VALUE,
+  add,
+  castType,
+  clamp,
+  div,
+  is,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  random,
+  sub
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
+  integerOrSafeInteger: "Integer",
+  MIN_VALUE: 1,
+  MAX_VALUE: Number.MAX_VALUE,
+  typeNameInMessage
 });
-/**
- * Type guard that checks if a value is a positive integer.
- *
- * A positive integer is any integer greater than zero (>= 1). This excludes
- * zero, negative numbers, and non-integers.
- *
- * @example
- *
- * ```ts
- * assert.isTrue(isPositiveInt(5));
- *
- * assert.isFalse(isPositiveInt(0));
- *
- * assert.isTrue(PositiveInt.is(10));
- * ```
- *
- * @param value - The value to check
- * @returns `true` if the value is a positive integer, `false` otherwise
- */
 const isPositiveInt = is;
-/**
- * Casts a number to a PositiveInt branded type.
- *
- * This function validates that the input is a positive integer (>= 1) and
- * returns it with the PositiveInt brand. This ensures type safety for
- * operations that require strictly positive integer values.
- *
- * @example
- *
- * ```ts
- * const branded = asPositiveInt(7);
- *
- * assert.isTrue(branded === 7);
- *
- * assert.isTrue(PositiveInt.is(branded));
- * ```
- *
- * @param value - The value to cast
- * @returns The value as a PositiveInt branded type
- * @throws {TypeError} If the value is not a positive integer
- */
 const asPositiveInt = castType;
-/**
- * Namespace providing type-safe operations for PositiveInt branded types.
- *
- * PositiveInt represents integers that are strictly greater than zero (>= 1).
- * All operations automatically clamp results to maintain the positive
- * constraint, ensuring that arithmetic operations never produce zero or
- * negative values.
- *
- * This type is essential for:
- *
- * - Array lengths and sizes (length >= 1)
- * - Counts and quantities that must be positive
- * - Denominators in division operations
- * - Loop counters and iteration counts
- * - Database primary keys and IDs
- */
 const PositiveInt = {
-    /**
-     * Type guard that checks if a value is a positive integer.
-     *
-     * @example
-     *
-     * ```ts
-     * assert.isTrue(isPositiveInt(5));
-     *
-     * assert.isFalse(isPositiveInt(0));
-     *
-     * assert.isTrue(PositiveInt.is(10));
-     * ```
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a positive integer, `false` otherwise
-     * @see {@link isPositiveInt} for usage examples
-     */
-    is,
-    /**
-     * The minimum value for a PositiveInt.
-     *
-     * @readonly
-     */
-    MIN_VALUE,
-    /**
-     * Returns the minimum value from a list of positive integers.
-     *
-     * Since all inputs are guaranteed to be >= 1, the result is also guaranteed
-     * to be a positive integer.
-     *
-     * @example
-     *
-     * ```ts
-     * const smallest = PositiveInt.min(
-     *   asPositiveInt(9),
-     *   asPositiveInt(3),
-     *   asPositiveInt(12),
-     * );
-     *
-     * assert.isTrue(smallest === 3);
-     * ```
-     *
-     * @param values - The positive integers to compare (at least one required)
-     * @returns The smallest value as a PositiveInt
-     */
-    min: min_,
-    /**
-     * Returns the maximum value from a list of positive integers.
-     *
-     * @example
-     *
-     * ```ts
-     * const largest = PositiveInt.max(
-     *   asPositiveInt(9),
-     *   asPositiveInt(3),
-     *   asPositiveInt(12),
-     * );
-     *
-     * assert.isTrue(largest === 12);
-     * ```
-     *
-     * @param values - The positive integers to compare (at least one required)
-     * @returns The largest value as a PositiveInt
-     */
-    max: max_,
-    /**
-     * Clamps a number to the positive integer range.
-     *
-     * Since PositiveInt has a minimum value of 1, this function ensures that any
-     * input less than 1 is clamped to 1.
-     *
-     * @example
-     *
-     * ```ts
-     * const belowRange = PositiveInt.clamp(0);
-     *
-     * const withinRange = PositiveInt.clamp(10);
-     *
-     * assert.isTrue(belowRange === 1);
-     *
-     * assert.isTrue(withinRange === 10);
-     * ```
-     *
-     * @param value - The number to clamp
-     * @returns The value clamped to >= 1 as a PositiveInt
-     */
-    clamp,
-    /**
-     * Generates a random positive integer within the specified range (inclusive).
-     *
-     * Both bounds are inclusive, and both min and max must be positive integers.
-     * If min > max, they are automatically swapped.
-     *
-     * @example
-     *
-     * ```ts
-     * const min = asPositiveInt(3);
-     *
-     * const max = asPositiveInt(6);
-     *
-     * const randomValue = PositiveInt.random(min, max);
-     *
-     * assert.isTrue(PositiveInt.is(randomValue));
-     *
-     * assert.isTrue(randomValue >= 3 && randomValue <= 6);
-     * ```
-     *
-     * @param min - The minimum value (inclusive, must be >= 1)
-     * @param max - The maximum value (inclusive, must be >= min)
-     * @returns A random PositiveInt in the range [min, max]
-     */
-    random,
-    /**
-     * Raises a positive integer to a power, ensuring the result is never less
-     * than 1.
-     *
-     * @example
-     *
-     * ```ts
-     * const base = asPositiveInt(2);
-     *
-     * const exponent = asPositiveInt(4);
-     *
-     * const power = PositiveInt.pow(base, exponent);
-     *
-     * assert.isTrue(power === 16);
-     * ```
-     *
-     * @param a - The base positive integer
-     * @param b - The exponent positive integer
-     * @returns `a ** b` as a PositiveInt, but never less than 1
-     */
-    pow,
-    /**
-     * Adds two positive integers, ensuring the result is never less than 1.
-     *
-     * @example
-     *
-     * ```ts
-     * const sum = PositiveInt.add(asPositiveInt(4), asPositiveInt(5));
-     *
-     * assert.isTrue(sum === 9);
-     * ```
-     *
-     * @param a - First positive integer
-     * @param b - Second positive integer
-     * @returns `a + b` as a PositiveInt, but never less than 1
-     */
-    add,
-    /**
-     * Subtracts two positive integers, clamping the result to remain positive.
-     *
-     * If the mathematical result would be <= 0, it is clamped to 1 to maintain
-     * the positive integer constraint.
-     *
-     * @example
-     *
-     * ```ts
-     * const difference = PositiveInt.sub(asPositiveInt(5), asPositiveInt(7));
-     *
-     * assert.isTrue(difference === 1);
-     * ```
-     *
-     * @param a - The minuend (positive integer)
-     * @param b - The subtrahend (positive integer)
-     * @returns `max(1, a - b)` as a PositiveInt
-     */
-    sub,
-    /**
-     * Multiplies two positive integers, ensuring the result is never less than 1.
-     *
-     * @example
-     *
-     * ```ts
-     * const product = PositiveInt.mul(asPositiveInt(3), asPositiveInt(7));
-     *
-     * assert.isTrue(product === 21);
-     * ```
-     *
-     * @param a - First positive integer
-     * @param b - Second positive integer
-     * @returns `a * b` as a PositiveInt, but never less than 1
-     */
-    mul,
-    /**
-     * Divides two positive integers using floor division, clamping to remain
-     * positive.
-     *
-     * Performs mathematical floor division: `⌊a / b⌋`. If the result would be 0
-     * (when a < b), it is clamped to 1 to maintain the positive integer
-     * constraint.
-     *
-     * @example
-     *
-     * ```ts
-     * const quotient = PositiveInt.div(asPositiveInt(9), asPositiveInt(2));
-     *
-     * const clamped = PositiveInt.div(asPositiveInt(3), asPositiveInt(10));
-     *
-     * assert.isTrue(quotient === 4);
-     *
-     * assert.isTrue(clamped === 1);
-     * ```
-     *
-     * @param a - The dividend (positive integer)
-     * @param b - The divisor (positive integer, guaranteed non-zero)
-     * @returns `max(1, ⌊a / b⌋)` as a PositiveInt
-     */
-    div,
+  /**
+   * Type guard that checks if a value is a positive integer.
+   *
+   * @example
+   *
+   * ```ts
+   * assert.isTrue(isPositiveInt(5));
+   *
+   * assert.isFalse(isPositiveInt(0));
+   *
+   * assert.isTrue(PositiveInt.is(10));
+   * ```
+   *
+   * @param value - The value to check
+   * @returns `true` if the value is a positive integer, `false` otherwise
+   * @see {@link isPositiveInt} for usage examples
+   */
+  is,
+  /**
+   * The minimum value for a PositiveInt.
+   *
+   * @readonly
+   */
+  MIN_VALUE,
+  /**
+   * Returns the minimum value from a list of positive integers.
+   *
+   * Since all inputs are guaranteed to be >= 1, the result is also guaranteed
+   * to be a positive integer.
+   *
+   * @example
+   *
+   * ```ts
+   * const smallest = PositiveInt.min(
+   *   asPositiveInt(9),
+   *   asPositiveInt(3),
+   *   asPositiveInt(12),
+   * );
+   *
+   * assert.isTrue(smallest === 3);
+   * ```
+   *
+   * @param values - The positive integers to compare (at least one required)
+   * @returns The smallest value as a PositiveInt
+   */
+  min: min_,
+  /**
+   * Returns the maximum value from a list of positive integers.
+   *
+   * @example
+   *
+   * ```ts
+   * const largest = PositiveInt.max(
+   *   asPositiveInt(9),
+   *   asPositiveInt(3),
+   *   asPositiveInt(12),
+   * );
+   *
+   * assert.isTrue(largest === 12);
+   * ```
+   *
+   * @param values - The positive integers to compare (at least one required)
+   * @returns The largest value as a PositiveInt
+   */
+  max: max_,
+  /**
+   * Clamps a number to the positive integer range.
+   *
+   * Since PositiveInt has a minimum value of 1, this function ensures that any
+   * input less than 1 is clamped to 1.
+   *
+   * @example
+   *
+   * ```ts
+   * const belowRange = PositiveInt.clamp(0);
+   *
+   * const withinRange = PositiveInt.clamp(10);
+   *
+   * assert.isTrue(belowRange === 1);
+   *
+   * assert.isTrue(withinRange === 10);
+   * ```
+   *
+   * @param value - The number to clamp
+   * @returns The value clamped to >= 1 as a PositiveInt
+   */
+  clamp,
+  /**
+   * Generates a random positive integer within the specified range (inclusive).
+   *
+   * Both bounds are inclusive, and both min and max must be positive integers.
+   * If min > max, they are automatically swapped.
+   *
+   * @example
+   *
+   * ```ts
+   * const min = asPositiveInt(3);
+   *
+   * const max = asPositiveInt(6);
+   *
+   * const randomValue = PositiveInt.random(min, max);
+   *
+   * assert.isTrue(PositiveInt.is(randomValue));
+   *
+   * assert.isTrue(randomValue >= 3 && randomValue <= 6);
+   * ```
+   *
+   * @param min - The minimum value (inclusive, must be >= 1)
+   * @param max - The maximum value (inclusive, must be >= min)
+   * @returns A random PositiveInt in the range [min, max]
+   */
+  random,
+  /**
+   * Raises a positive integer to a power, ensuring the result is never less
+   * than 1.
+   *
+   * @example
+   *
+   * ```ts
+   * const base = asPositiveInt(2);
+   *
+   * const exponent = asPositiveInt(4);
+   *
+   * const power = PositiveInt.pow(base, exponent);
+   *
+   * assert.isTrue(power === 16);
+   * ```
+   *
+   * @param a - The base positive integer
+   * @param b - The exponent positive integer
+   * @returns `a ** b` as a PositiveInt, but never less than 1
+   */
+  pow,
+  /**
+   * Adds two positive integers, ensuring the result is never less than 1.
+   *
+   * @example
+   *
+   * ```ts
+   * const sum = PositiveInt.add(asPositiveInt(4), asPositiveInt(5));
+   *
+   * assert.isTrue(sum === 9);
+   * ```
+   *
+   * @param a - First positive integer
+   * @param b - Second positive integer
+   * @returns `a + b` as a PositiveInt, but never less than 1
+   */
+  add,
+  /**
+   * Subtracts two positive integers, clamping the result to remain positive.
+   *
+   * If the mathematical result would be <= 0, it is clamped to 1 to maintain
+   * the positive integer constraint.
+   *
+   * @example
+   *
+   * ```ts
+   * const difference = PositiveInt.sub(asPositiveInt(5), asPositiveInt(7));
+   *
+   * assert.isTrue(difference === 1);
+   * ```
+   *
+   * @param a - The minuend (positive integer)
+   * @param b - The subtrahend (positive integer)
+   * @returns `max(1, a - b)` as a PositiveInt
+   */
+  sub,
+  /**
+   * Multiplies two positive integers, ensuring the result is never less than 1.
+   *
+   * @example
+   *
+   * ```ts
+   * const product = PositiveInt.mul(asPositiveInt(3), asPositiveInt(7));
+   *
+   * assert.isTrue(product === 21);
+   * ```
+   *
+   * @param a - First positive integer
+   * @param b - Second positive integer
+   * @returns `a * b` as a PositiveInt, but never less than 1
+   */
+  mul,
+  /**
+   * Divides two positive integers using floor division, clamping to remain
+   * positive.
+   *
+   * Performs mathematical floor division: `⌊a / b⌋`. If the result would be 0
+   * (when a < b), it is clamped to 1 to maintain the positive integer
+   * constraint.
+   *
+   * @example
+   *
+   * ```ts
+   * const quotient = PositiveInt.div(asPositiveInt(9), asPositiveInt(2));
+   *
+   * const clamped = PositiveInt.div(asPositiveInt(3), asPositiveInt(10));
+   *
+   * assert.isTrue(quotient === 4);
+   *
+   * assert.isTrue(clamped === 1);
+   * ```
+   *
+   * @param a - The dividend (positive integer)
+   * @param b - The divisor (positive integer, guaranteed non-zero)
+   * @returns `max(1, ⌊a / b⌋)` as a PositiveInt
+   */
+  div
 };
 
 export { PositiveInt, asPositiveInt, isPositiveInt };

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int.mjs","sources":["../../../src/number/branded-types/positive-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;AAeG;AACI,MAAM,WAAW,GAAG;AACzB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;AAiBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"positive-int.mjs","sources":["../../../src/number/branded-types/positive-int.mts"],"sourcesContent":["import { type PositiveInt as TtfImported_PositiveInt } from 'ts-type-forge';\nimport { expectType } from '../../expect-type.mjs';\nimport { TsDataForgeInternals } from '../refined-number-utils.mjs';\n\nexport type PositiveInt = TtfImported_PositiveInt;\n\ntype ElementType = PositiveInt;\n\nconst typeNameInMessage = 'a positive integer';\n\nconst {\n  MIN_VALUE,\n  add,\n  castType,\n  clamp,\n  div,\n  is,\n  max: max_,\n  min: min_,\n  mul,\n  pow,\n  random,\n  sub,\n} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<\n  ElementType,\n  1,\n  number\n>({\n  integerOrSafeInteger: 'Integer',\n  MIN_VALUE: 1,\n  MAX_VALUE: Number.MAX_VALUE,\n  typeNameInMessage,\n} as const);\n\n/**\n * Type guard that checks if a value is a positive integer.\n *\n * A positive integer is any integer greater than zero (>= 1). This excludes\n * zero, negative numbers, and non-integers.\n *\n * @example\n *\n * ```ts\n * assert.isTrue(isPositiveInt(5));\n *\n * assert.isFalse(isPositiveInt(0));\n *\n * assert.isTrue(PositiveInt.is(10));\n * ```\n *\n * @param value - The value to check\n * @returns `true` if the value is a positive integer, `false` otherwise\n */\nexport const isPositiveInt = is;\n\n/**\n * Casts a number to a PositiveInt branded type.\n *\n * This function validates that the input is a positive integer (>= 1) and\n * returns it with the PositiveInt brand. This ensures type safety for\n * operations that require strictly positive integer values.\n *\n * @example\n *\n * ```ts\n * const branded = asPositiveInt(7);\n *\n * assert.isTrue(branded === 7);\n *\n * assert.isTrue(PositiveInt.is(branded));\n * ```\n *\n * @param value - The value to cast\n * @returns The value as a PositiveInt branded type\n * @throws {TypeError} If the value is not a positive integer\n */\nexport const asPositiveInt = castType;\n\n/**\n * Namespace providing type-safe operations for PositiveInt branded types.\n *\n * PositiveInt represents integers that are strictly greater than zero (>= 1).\n * All operations automatically clamp results to maintain the positive\n * constraint, ensuring that arithmetic operations never produce zero or\n * negative values.\n *\n * This type is essential for:\n *\n * - Array lengths and sizes (length >= 1)\n * - Counts and quantities that must be positive\n * - Denominators in division operations\n * - Loop counters and iteration counts\n * - Database primary keys and IDs\n */\nexport const PositiveInt = {\n  /**\n   * Type guard that checks if a value is a positive integer.\n   *\n   * @example\n   *\n   * ```ts\n   * assert.isTrue(isPositiveInt(5));\n   *\n   * assert.isFalse(isPositiveInt(0));\n   *\n   * assert.isTrue(PositiveInt.is(10));\n   * ```\n   *\n   * @param value - The value to check\n   * @returns `true` if the value is a positive integer, `false` otherwise\n   * @see {@link isPositiveInt} for usage examples\n   */\n  is,\n\n  /**\n   * The minimum value for a PositiveInt.\n   *\n   * @readonly\n   */\n  MIN_VALUE,\n\n  /**\n   * Returns the minimum value from a list of positive integers.\n   *\n   * Since all inputs are guaranteed to be >= 1, the result is also guaranteed\n   * to be a positive integer.\n   *\n   * @example\n   *\n   * ```ts\n   * const smallest = PositiveInt.min(\n   *   asPositiveInt(9),\n   *   asPositiveInt(3),\n   *   asPositiveInt(12),\n   * );\n   *\n   * assert.isTrue(smallest === 3);\n   * ```\n   *\n   * @param values - The positive integers to compare (at least one required)\n   * @returns The smallest value as a PositiveInt\n   */\n  min: min_,\n\n  /**\n   * Returns the maximum value from a list of positive integers.\n   *\n   * @example\n   *\n   * ```ts\n   * const largest = PositiveInt.max(\n   *   asPositiveInt(9),\n   *   asPositiveInt(3),\n   *   asPositiveInt(12),\n   * );\n   *\n   * assert.isTrue(largest === 12);\n   * ```\n   *\n   * @param values - The positive integers to compare (at least one required)\n   * @returns The largest value as a PositiveInt\n   */\n  max: max_,\n\n  /**\n   * Clamps a number to the positive integer range.\n   *\n   * Since PositiveInt has a minimum value of 1, this function ensures that any\n   * input less than 1 is clamped to 1.\n   *\n   * @example\n   *\n   * ```ts\n   * const belowRange = PositiveInt.clamp(0);\n   *\n   * const withinRange = PositiveInt.clamp(10);\n   *\n   * assert.isTrue(belowRange === 1);\n   *\n   * assert.isTrue(withinRange === 10);\n   * ```\n   *\n   * @param value - The number to clamp\n   * @returns The value clamped to >= 1 as a PositiveInt\n   */\n  clamp,\n\n  /**\n   * Generates a random positive integer within the specified range (inclusive).\n   *\n   * Both bounds are inclusive, and both min and max must be positive integers.\n   * If min > max, they are automatically swapped.\n   *\n   * @example\n   *\n   * ```ts\n   * const min = asPositiveInt(3);\n   *\n   * const max = asPositiveInt(6);\n   *\n   * const randomValue = PositiveInt.random(min, max);\n   *\n   * assert.isTrue(PositiveInt.is(randomValue));\n   *\n   * assert.isTrue(randomValue >= 3 && randomValue <= 6);\n   * ```\n   *\n   * @param min - The minimum value (inclusive, must be >= 1)\n   * @param max - The maximum value (inclusive, must be >= min)\n   * @returns A random PositiveInt in the range [min, max]\n   */\n  random,\n\n  /**\n   * Raises a positive integer to a power, ensuring the result is never less\n   * than 1.\n   *\n   * @example\n   *\n   * ```ts\n   * const base = asPositiveInt(2);\n   *\n   * const exponent = asPositiveInt(4);\n   *\n   * const power = PositiveInt.pow(base, exponent);\n   *\n   * assert.isTrue(power === 16);\n   * ```\n   *\n   * @param a - The base positive integer\n   * @param b - The exponent positive integer\n   * @returns `a ** b` as a PositiveInt, but never less than 1\n   */\n  pow,\n\n  /**\n   * Adds two positive integers, ensuring the result is never less than 1.\n   *\n   * @example\n   *\n   * ```ts\n   * const sum = PositiveInt.add(asPositiveInt(4), asPositiveInt(5));\n   *\n   * assert.isTrue(sum === 9);\n   * ```\n   *\n   * @param a - First positive integer\n   * @param b - Second positive integer\n   * @returns `a + b` as a PositiveInt, but never less than 1\n   */\n  add,\n\n  /**\n   * Subtracts two positive integers, clamping the result to remain positive.\n   *\n   * If the mathematical result would be <= 0, it is clamped to 1 to maintain\n   * the positive integer constraint.\n   *\n   * @example\n   *\n   * ```ts\n   * const difference = PositiveInt.sub(asPositiveInt(5), asPositiveInt(7));\n   *\n   * assert.isTrue(difference === 1);\n   * ```\n   *\n   * @param a - The minuend (positive integer)\n   * @param b - The subtrahend (positive integer)\n   * @returns `max(1, a - b)` as a PositiveInt\n   */\n  sub,\n\n  /**\n   * Multiplies two positive integers, ensuring the result is never less than 1.\n   *\n   * @example\n   *\n   * ```ts\n   * const product = PositiveInt.mul(asPositiveInt(3), asPositiveInt(7));\n   *\n   * assert.isTrue(product === 21);\n   * ```\n   *\n   * @param a - First positive integer\n   * @param b - Second positive integer\n   * @returns `a * b` as a PositiveInt, but never less than 1\n   */\n  mul,\n\n  /**\n   * Divides two positive integers using floor division, clamping to remain\n   * positive.\n   *\n   * Performs mathematical floor division: `⌊a / b⌋`. If the result would be 0\n   * (when a < b), it is clamped to 1 to maintain the positive integer\n   * constraint.\n   *\n   * @example\n   *\n   * ```ts\n   * const quotient = PositiveInt.div(asPositiveInt(9), asPositiveInt(2));\n   *\n   * const clamped = PositiveInt.div(asPositiveInt(3), asPositiveInt(10));\n   *\n   * assert.isTrue(quotient === 4);\n   *\n   * assert.isTrue(clamped === 1);\n   * ```\n   *\n   * @param a - The dividend (positive integer)\n   * @param b - The divisor (positive integer, guaranteed non-zero)\n   * @returns `max(1, ⌊a / b⌋)` as a PositiveInt\n   */\n  div,\n} as const;\n\nexpectType<\n  keyof typeof PositiveInt,\n  keyof TsDataForgeInternals.RefinedNumberUtils.NumberClass<\n    ElementType,\n    'int' | 'positive'\n  >\n>('=');\n\nexpectType<\n  typeof PositiveInt,\n  TsDataForgeInternals.RefinedNumberUtils.NumberClass<\n    ElementType,\n    'int' | 'positive'\n  >\n>('<=');\n"],"names":[],"mappings":";;AAQA,MAAM,iBAAA,GAAoB,oBAAA;AAE1B,MAAM;AAAA,EACJ,SAAA;AAAA,EACA,GAAA;AAAA,EACA,QAAA;AAAA,EACA,KAAA;AAAA,EACA,GAAA;AAAA,EACA,EAAA;AAAA,EACA,GAAA,EAAK,IAAA;AAAA,EACL,GAAA,EAAK,IAAA;AAAA,EACL,GAAA;AAAA,EACA,GAAA;AAAA,EACA,MAAA;AAAA,EACA;AACF,CAAA,GAAI,oBAAA,CAAqB,mBAAmB,mBAAA,CAI1C;AAAA,EACA,oBAAA,EAAsB,SAAA;AAAA,EACtB,SAAA,EAAW,CAAA;AAAA,EACX,WAAW,MAAA,CAAO,SAAA;AAAA,EAClB;AACF,CAAU,CAAA;AAqBH,MAAM,aAAA,GAAgB;AAuBtB,MAAM,aAAA,GAAgB;AAkBtB,MAAM,WAAA,GAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBzB,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBA,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBL,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBL,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA0BA,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA0BA;AACF;;;;"}

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

@@ -16,20 +16,20 @@ export declare const isPositiveInt16: (a: number) => a is TtfImported_PositiveIn
  * @throws {TypeError} If the value is not a positive integer in [1, 2^15).
  */
 export declare const asPositiveInt16: <N extends number>(x: N) => number & {
-    readonly NaNValue: false;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly "> -2^16": true;
-    readonly "> -2^32": true;
-    readonly ">= -2^15": true;
-    readonly ">= -2^31": true;
-    readonly ">=0": true;
     readonly "!=0": true;
-    readonly "<=0": false;
     readonly "< 2^15": true;
     readonly "< 2^16": true;
     readonly "< 2^31": true;
     readonly "< 2^32": true;
+    readonly "<=0": false;
+    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 NaNValue: false;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
@@ -132,21 +132,21 @@ export declare const PositiveInt16: {
      * @param b The divisor PositiveInt16.
      * @returns `⌊a / b⌋` clamped to [1, 32767] as a PositiveInt16.
      */
-    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>, y: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 20 | 30 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | import("ts-type-forge").NormalizeBrandUnion<number & {
-        readonly NaNValue: false;
-        readonly Finite: true;
-        readonly Int: true;
-        readonly "> -2^16": true;
-        readonly "> -2^32": true;
-        readonly ">= -2^15": true;
-        readonly ">= -2^31": true;
-        readonly ">=0": true;
+    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_PositiveInt16>, y: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | import("ts-type-forge").NormalizeBrandUnion<number & {
         readonly "!=0": true;
-        readonly "<=0": false;
         readonly "< 2^15": true;
         readonly "< 2^16": true;
         readonly "< 2^31": true;
         readonly "< 2^32": true;
+        readonly "<=0": false;
+        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 NaNValue: false;
         readonly SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;