ts-data-forge 1.0.0 → 1.0.1

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

@@ -0,0 +1,257 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a positive integer';
+const { MIN_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'Integer',
+    MIN_VALUE: 1,
+    MAX_VALUE: undefined,
+    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.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a positive integer, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isPositiveInt(5);    // true
+ * isPositiveInt(1);    // true
+ * isPositiveInt(0);    // false (zero is not positive)
+ * isPositiveInt(-1);   // false (negative)
+ * isPositiveInt(5.5);  // false (not an integer)
+ * isPositiveInt(NaN);  // false
+ * ```
+ */
+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.
+ *
+ * @param value - The value to cast
+ * @returns The value as a PositiveInt branded type
+ * @throws {TypeError} If the value is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * const count = asPositiveInt(5);      // PositiveInt
+ * const length = asPositiveInt(100);   // PositiveInt
+ * const one = asPositiveInt(1);        // PositiveInt (minimum valid)
+ *
+ * // These throw TypeError:
+ * // asPositiveInt(0);                 // Zero is not positive
+ * // asPositiveInt(-1);                // Negative numbers not allowed
+ * // asPositiveInt(5.5);               // Not an integer
+ * // asPositiveInt(Infinity);          // Not finite
+ * ```
+ */
+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
+ *
+ * @example
+ * ```typescript
+ * // Type validation
+ * PositiveInt.is(5);    // true
+ * PositiveInt.is(1);    // true (minimum value)
+ * PositiveInt.is(0);    // false
+ * PositiveInt.is(-1);   // false
+ *
+ * // Automatic clamping in operations
+ * const a = asPositiveInt(10);
+ * const b = asPositiveInt(3);
+ *
+ * const sum = PositiveInt.add(a, b);          // PositiveInt (13)
+ * const diff1 = PositiveInt.sub(a, b);        // PositiveInt (7)
+ * const diff2 = PositiveInt.sub(b, a);        // PositiveInt (1) - clamped!
+ * const product = PositiveInt.mul(a, b);      // PositiveInt (30)
+ * const quotient = PositiveInt.div(a, b);     // PositiveInt (3)
+ *
+ * // Edge case: division that would be < 1
+ * const small = PositiveInt.div(asPositiveInt(2), asPositiveInt(3)); // PositiveInt (1)
+ *
+ * // Range operations
+ * const minimum = PositiveInt.min(a, b);      // PositiveInt (3)
+ * const maximum = PositiveInt.max(a, b);      // PositiveInt (10)
+ *
+ * // Random generation
+ * const dice = PositiveInt.random(asPositiveInt(1), asPositiveInt(6)); // 1-6
+ * const id = PositiveInt.random(asPositiveInt(1000), asPositiveInt(9999)); // 4-digit ID
+ * ```
+ */
+const PositiveInt = {
+    /**
+     * Type guard that checks if a value is a positive integer.
+     *
+     * @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.
+     *
+     * @param values - The positive integers to compare (at least one required)
+     * @returns The smallest value as a PositiveInt
+     *
+     * @example
+     * ```typescript
+     * PositiveInt.min(asPositiveInt(5), asPositiveInt(3));    // PositiveInt (3)
+     * PositiveInt.min(asPositiveInt(10), asPositiveInt(1), asPositiveInt(7)); // PositiveInt (1)
+     * ```
+     */
+    min: min_,
+    /**
+     * Returns the maximum value from a list of positive integers.
+     *
+     * @param values - The positive integers to compare (at least one required)
+     * @returns The largest value as a PositiveInt
+     *
+     * @example
+     * ```typescript
+     * PositiveInt.max(asPositiveInt(5), asPositiveInt(3));    // PositiveInt (5)
+     * PositiveInt.max(asPositiveInt(10), asPositiveInt(1), asPositiveInt(7)); // PositiveInt (10)
+     * ```
+     */
+    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.
+     *
+     * @param value - The number to clamp
+     * @returns The value clamped to >= 1 as a PositiveInt
+     *
+     * @example
+     * ```typescript
+     * PositiveInt.clamp(5);    // PositiveInt (5)
+     * PositiveInt.clamp(0);    // PositiveInt (1) - clamped to minimum
+     * PositiveInt.clamp(-10);  // PositiveInt (1) - clamped to minimum
+     * PositiveInt.clamp(100);  // PositiveInt (100)
+     * ```
+     */
+    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.
+     *
+     * @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]
+     *
+     * @example
+     * ```typescript
+     * // Dice roll
+     * const d6 = PositiveInt.random(asPositiveInt(1), asPositiveInt(6));
+     *
+     * // Random user ID
+     * const userId = PositiveInt.random(asPositiveInt(1000), asPositiveInt(9999));
+     *
+     * // Random page count
+     * const pages = PositiveInt.random(asPositiveInt(50), asPositiveInt(500));
+     * ```
+     */
+    random,
+    /**
+     * Raises a positive integer to a power, ensuring the result is never less than 1.
+     * @param a - The base positive integer
+     * @param b - The exponent positive integer
+     * @returns `a ** b` as a PositiveInt, but never less than 1
+     * @example
+     * ```typescript
+     * PositiveInt.pow(asPositiveInt(2), asPositiveInt(3)); // PositiveInt (8)
+     * ```
+     */
+    pow,
+    /**
+     * Adds two positive integers, ensuring the result is never less than 1.
+     * @param a - First positive integer
+     * @param b - Second positive integer
+     * @returns `a + b` as a PositiveInt, but never less than 1
+     * @example
+     * ```typescript
+     * PositiveInt.add(asPositiveInt(5), asPositiveInt(3)); // PositiveInt (8)
+     * ```
+     */
+    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.
+     *
+     * @param a - The minuend (positive integer)
+     * @param b - The subtrahend (positive integer)
+     * @returns `max(1, a - b)` as a PositiveInt
+     *
+     * @example
+     * ```typescript
+     * PositiveInt.sub(asPositiveInt(8), asPositiveInt(3));  // PositiveInt (5)
+     * PositiveInt.sub(asPositiveInt(3), asPositiveInt(8));  // PositiveInt (1) - clamped
+     * PositiveInt.sub(asPositiveInt(5), asPositiveInt(5));  // PositiveInt (1) - clamped
+     * ```
+     */
+    sub,
+    /**
+     * Multiplies two positive integers, ensuring the result is never less than 1.
+     * @param a - First positive integer
+     * @param b - Second positive integer
+     * @returns `a * b` as a PositiveInt, but never less than 1
+     * @example
+     * ```typescript
+     * PositiveInt.mul(asPositiveInt(4), asPositiveInt(3)); // PositiveInt (12)
+     * ```
+     */
+    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.
+     *
+     * @param a - The dividend (positive integer)
+     * @param b - The divisor (positive integer, guaranteed non-zero)
+     * @returns `max(1, ⌊a / b⌋)` as a PositiveInt
+     *
+     * @example
+     * ```typescript
+     * PositiveInt.div(asPositiveInt(10), asPositiveInt(3)); // PositiveInt (3)
+     * PositiveInt.div(asPositiveInt(9), asPositiveInt(3));  // PositiveInt (3)
+     * PositiveInt.div(asPositiveInt(2), asPositiveInt(3));  // PositiveInt (1) - clamped
+     * PositiveInt.div(asPositiveInt(1), asPositiveInt(5));  // PositiveInt (1) - clamped
+     * ```
+     */
+    div,
+};
+
+export { PositiveInt, asPositiveInt, isPositiveInt };
+//# sourceMappingURL=positive-int.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive-int.mjs","sources":["../../../src/number/branded-types/positive-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,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,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACI,MAAM,WAAW,GAAG;AACzB;;;;;;;AAOG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;AAgBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;AAiBG;IACH,GAAG;;;;;"}

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

@@ -0,0 +1,162 @@
+/**
+ * Checks if a number is a PositiveInt16 (16-bit positive signed integer in the range [1, 2^15)).
+ * @param value The value to check.
+ * @returns `true` if the value is a PositiveInt16, `false` otherwise.
+ */
+export declare const isPositiveInt16: (a: number) => a is PositiveInt16;
+/**
+ * Casts a number to a PositiveInt16 type.
+ * @param value The value to cast.
+ * @returns The value as a PositiveInt16 type.
+ * @throws {TypeError} If the value is not a positive integer in [1, 2^15).
+ * @example
+ * ```typescript
+ * const x = asPositiveInt16(1000); // PositiveInt16
+ * const y = asPositiveInt16(32767); // PositiveInt16
+ * // asPositiveInt16(0); // throws TypeError
+ * // asPositiveInt16(-1); // throws TypeError
+ * // asPositiveInt16(32768); // throws TypeError
+ * ```
+ */
+export declare const asPositiveInt16: <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^15": true;
+    readonly "< 2^16": 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 16-bit positive integers.
+ *
+ * All operations automatically clamp results to the valid PositiveInt16 range [1, 32767].
+ * This ensures that all arithmetic maintains the 16-bit positive integer constraint,
+ * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asPositiveInt16(30000);
+ * const b = asPositiveInt16(5000);
+ *
+ * // Arithmetic operations with automatic clamping
+ * const sum = PositiveInt16.add(a, b);       // PositiveInt16 (32767 - clamped to MAX_VALUE)
+ * const diff = PositiveInt16.sub(a, b);      // PositiveInt16 (25000)
+ * const reverseDiff = PositiveInt16.sub(b, a); // PositiveInt16 (1 - clamped to MIN_VALUE)
+ * const product = PositiveInt16.mul(a, b);   // PositiveInt16 (32767 - clamped due to overflow)
+ *
+ * // Range operations
+ * const clamped = PositiveInt16.clamp(0);        // PositiveInt16 (1)
+ * const minimum = PositiveInt16.min(a, b);       // PositiveInt16 (5000)
+ * const maximum = PositiveInt16.max(a, b);       // PositiveInt16 (30000)
+ *
+ * // Utility operations
+ * const random = PositiveInt16.random();         // PositiveInt16 (random value in [1, 32767])
+ * const power = PositiveInt16.pow(asPositiveInt16(2), asPositiveInt16(10)); // PositiveInt16 (1024)
+ * ```
+ */
+export declare const PositiveInt16: {
+    /**
+     * Type guard to check if a value is a PositiveInt16.
+     * @param value The value to check.
+     * @returns `true` if the value is a 16-bit positive integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is PositiveInt16;
+    /**
+     * The minimum value for a 16-bit positive integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: 1;
+    /**
+     * The maximum value for a 16-bit positive integer.
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the smaller of two PositiveInt16 values.
+     * @param a The first PositiveInt16.
+     * @param b The second PositiveInt16.
+     * @returns The minimum value as a PositiveInt16.
+     */
+    readonly min: (...values: readonly WithSmallInt<PositiveInt16, 40>[]) => PositiveInt16;
+    /**
+     * Returns the larger of two PositiveInt16 values.
+     * @param a The first PositiveInt16.
+     * @param b The second PositiveInt16.
+     * @returns The maximum value as a PositiveInt16.
+     */
+    readonly max: (...values: readonly WithSmallInt<PositiveInt16, 40>[]) => PositiveInt16;
+    /**
+     * Clamps a number to the PositiveInt16 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [1, 32767] as a PositiveInt16.
+     */
+    readonly clamp: (x: number) => PositiveInt16;
+    /**
+     * Generates a random PositiveInt16 value within the valid range.
+     * @returns A random PositiveInt16 between 1 and 32767.
+     */
+    readonly random: (min: WithSmallInt<PositiveInt16, 40>, max: WithSmallInt<PositiveInt16, 40>) => PositiveInt16;
+    /**
+     * Raises a PositiveInt16 to the power of another PositiveInt16.
+     * @param a The base PositiveInt16.
+     * @param b The exponent PositiveInt16.
+     * @returns `a ** b` clamped to [1, 32767] as a PositiveInt16.
+     */
+    readonly pow: (x: WithSmallInt<PositiveInt16, 40>, y: WithSmallInt<PositiveInt16, 40>) => PositiveInt16;
+    /**
+     * Adds two PositiveInt16 values.
+     * @param a The first PositiveInt16.
+     * @param b The second PositiveInt16.
+     * @returns `a + b` clamped to [1, 32767] as a PositiveInt16.
+     */
+    readonly add: (x: WithSmallInt<PositiveInt16, 40>, y: WithSmallInt<PositiveInt16, 40>) => PositiveInt16;
+    /**
+     * Subtracts one PositiveInt16 from another.
+     * @param a The minuend PositiveInt16.
+     * @param b The subtrahend PositiveInt16.
+     * @returns `a - b` clamped to [1, 32767] as a PositiveInt16 (minimum 1).
+     */
+    readonly sub: (x: WithSmallInt<PositiveInt16, 40>, y: WithSmallInt<PositiveInt16, 40>) => PositiveInt16;
+    /**
+     * Multiplies two PositiveInt16 values.
+     * @param a The first PositiveInt16.
+     * @param b The second PositiveInt16.
+     * @returns `a * b` clamped to [1, 32767] as a PositiveInt16.
+     */
+    readonly mul: (x: WithSmallInt<PositiveInt16, 40>, y: WithSmallInt<PositiveInt16, 40>) => PositiveInt16;
+    /**
+     * Divides one PositiveInt16 by another using floor division.
+     * @param a The dividend PositiveInt16.
+     * @param b The divisor PositiveInt16.
+     * @returns `⌊a / b⌋` clamped to [1, 32767] as a PositiveInt16.
+     */
+    readonly div: (x: WithSmallInt<PositiveInt16, 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^15": true;
+        readonly "< 2^16": 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;
+    }>>) => PositiveInt16;
+};
+//# sourceMappingURL=positive-int16.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int16.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-int16.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"positive-int16.mjs","sources":["../../../src/number/branded-types/positive-int16.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;;;;;"}