ts-data-forge 14.10.2 → 14.11.1

package/src/number/{num.test.mts → num/impl/num.test.mts}

@@ -1,8 +1,8 @@
 import type { FixedLengthTuple, NonZeroNumber } from 'ts-type-forge';
-import { expectType } from '../expect-type.mjs';
-import { pipe, Result } from '../functional/index.mjs';
-import { asNonZeroFiniteNumber } from './branded-types/index.mjs';
-import { Num } from './num.mjs';
+import { expectType } from '../../../expect-type.mjs';
+import { pipe, Result } from '../../../functional/index.mjs';
+import { asNonZeroFiniteNumber } from '../../branded-types/index.mjs';
+import * as Num from './num.mjs';
 
 const testClamp = (
   [a, b]: FixedLengthTuple<2, number>,

package/src/number/num/index.mts

@@ -0,0 +1,16 @@
+/**
+ * Namespace providing utility functions for number manipulation and validation.
+ *
+ * This namespace offers a comprehensive set of type-safe number utilities
+ * including:
+ *
+ * - Type conversion and validation
+ * - Type guards for numeric constraints (non-zero, non-negative, positive)
+ * - Range checking and clamping operations
+ * - Mathematical operations with type safety
+ * - Rounding utilities
+ *
+ * Many functions in this namespace leverage TypeScript's type system to provide
+ * compile-time guarantees about numeric constraints.
+ */
+export * as Num from './impl/index.mjs';

package/src/number/num-arithmetic.test.mts

@@ -12,7 +12,7 @@ import {
   asPositiveInt,
   asUint,
 } from './branded-types/index.mjs';
-import { Num } from './num.mjs';
+import { Num } from './num/index.mjs';
 
 describe('Num arithmetic (general / sign-aware)', () => {
   describe('Num.add', () => {

package/src/number/operators/finite-number.mts

@@ -0,0 +1,20 @@
+/**
+ * The operators of `FiniteNumber` other than `isFiniteNumber` and
+ * `asFiniteNumber`, which `../branded-types/finite-number.mts` reads. Generated
+ * by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { FiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { abs, add, div, is, max, min, mul, pow, random, sub } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
+    FiniteNumber,
+    number,
+    number
+  >({
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
+    typeNameInMessage: 'a finite number',
+  } as const);

package/src/number/operators/int.mts

@@ -0,0 +1,20 @@
+/**
+ * The operators of `Int` other than `isInt` and `asInt`, which
+ * `../branded-types/int.mts` reads. Generated by `gen:branded-number`;
+ * `renderModule` in `scripts/gen-branded-number/render.mts` says why they are
+ * in a module of their own.
+ */
+import type { Int } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { abs, add, div, is, max, min, mul, pow, random, sub } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+    Int,
+    number,
+    number
+  >({
+    integerOrSafeInteger: 'Integer',
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
+    typeNameInMessage: 'an integer',
+  } as const);

package/src/number/operators/int16.mts

@@ -0,0 +1,33 @@
+/**
+ * The operators of `Int16` other than `isInt16` and `asInt16`, which
+ * `../branded-types/int16.mts` reads. Generated by `gen:branded-number`;
+ * `renderModule` in `scripts/gen-branded-number/render.mts` says why they are
+ * in a module of their own.
+ */
+import type { Int16 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  abs,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  Int16,
+  number,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: -(2 ** 15),
+  MAX_VALUE: 2 ** 15 - 1,
+  typeNameInMessage: 'an integer in [-2^15, 2^15)',
+} as const);

package/src/number/operators/int32.mts

@@ -0,0 +1,33 @@
+/**
+ * The operators of `Int32` other than `isInt32` and `asInt32`, which
+ * `../branded-types/int32.mts` reads. Generated by `gen:branded-number`;
+ * `renderModule` in `scripts/gen-branded-number/render.mts` says why they are
+ * in a module of their own.
+ */
+import type { Int32 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  abs,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  Int32,
+  number,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: -(2 ** 31),
+  MAX_VALUE: 2 ** 31 - 1,
+  typeNameInMessage: 'an integer in [-2^31, 2^31)',
+} as const);

package/src/number/operators/int8.mts

@@ -0,0 +1,18 @@
+/**
+ * The operators of `Int8` other than `isInt8` and `asInt8`, which
+ * `../enum/int8.mts` reads. Generated by `gen:branded-number`; `renderModule`
+ * in `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { Int16 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { MAX_VALUE, MIN_VALUE, castType, fromNumber, is, random } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<Int16, -128, 127>(
+    {
+      integerOrSafeInteger: 'SafeInteger',
+      MIN_VALUE: -128,
+      MAX_VALUE: 127,
+      typeNameInMessage: 'an integer in [-128, 127]',
+    } as const,
+  );

package/src/number/operators/negative-finite-number.mts

@@ -0,0 +1,22 @@
+/**
+ * The operators of `NegativeFiniteNumber` other than `isNegativeFiniteNumber`
+ * and `asNegativeFiniteNumber`, which
+ * `../branded-types/negative-finite-number.mts` reads. Generated by
+ * `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NegativeFiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { MAX_VALUE, add, fromNumber, is, max, min, pow, random, sub } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
+    NegativeFiniteNumber,
+    number,
+    number
+  >({
+    nonZero: true,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: -Number.MIN_VALUE,
+    typeNameInMessage: 'a negative finite number',
+  } as const);

package/src/number/operators/negative-int.mts

@@ -0,0 +1,22 @@
+/**
+ * The operators of `NegativeInt` other than `isNegativeInt` and
+ * `asNegativeInt`, which `../branded-types/negative-int.mts` reads. Generated
+ * by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NegativeInt } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { MAX_VALUE, add, fromNumber, is, max, min, pow, random, sub } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+    NegativeInt,
+    number,
+    -1
+  >({
+    integerOrSafeInteger: 'Integer',
+    nonZero: true,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: -1,
+    typeNameInMessage: 'a negative integer',
+  } as const);

package/src/number/operators/negative-safe-int.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `NegativeSafeInt` other than `isNegativeSafeInt` and
+ * `asNegativeSafeInt`, which `../branded-types/negative-safe-int.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NegativeSafeInt } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  fromNumber,
+  is,
+  max,
+  min,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  NegativeSafeInt,
+  number,
+  -1
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  nonZero: true,
+  MIN_VALUE: Number.MIN_SAFE_INTEGER,
+  MAX_VALUE: -1,
+  typeNameInMessage: 'a negative safe integer',
+} as const);

package/src/number/operators/non-negative-finite-number.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `NonNegativeFiniteNumber` other than
+ * `isNonNegativeFiniteNumber` and `asNonNegativeFiniteNumber`, which
+ * `../branded-types/non-negative-finite-number.mts` reads. Generated by
+ * `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonNegativeFiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
+  NonNegativeFiniteNumber,
+  0,
+  number
+>({
+  MIN_VALUE: 0,
+  MAX_VALUE: Number.MAX_VALUE,
+  typeNameInMessage: 'a non-negative finite number',
+} as const);

package/src/number/operators/non-negative-int16.mts

@@ -0,0 +1,33 @@
+/**
+ * The operators of `NonNegativeInt16` other than `isNonNegativeInt16` and
+ * `asNonNegativeInt16`, which `../branded-types/non-negative-int16.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonNegativeInt16 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  NonNegativeInt16,
+  0,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 0,
+  MAX_VALUE: 2 ** 15 - 1,
+  typeNameInMessage: 'a non-negative integer in [0, 2^15)',
+} as const);

package/src/number/operators/non-negative-int32.mts

@@ -0,0 +1,33 @@
+/**
+ * The operators of `NonNegativeInt32` other than `isNonNegativeInt32` and
+ * `asNonNegativeInt32`, which `../branded-types/non-negative-int32.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonNegativeInt32 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  NonNegativeInt32,
+  0,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: 0,
+  MAX_VALUE: 2 ** 31 - 1,
+  typeNameInMessage: 'a non-negative integer in [0, 2^31)',
+} as const);

package/src/number/operators/non-positive-finite-number.mts

@@ -0,0 +1,21 @@
+/**
+ * The operators of `NonPositiveFiniteNumber` other than
+ * `isNonPositiveFiniteNumber` and `asNonPositiveFiniteNumber`, which
+ * `../branded-types/non-positive-finite-number.mts` reads. Generated by
+ * `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonPositiveFiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { MAX_VALUE, add, fromNumber, is, max, min, pow, random, sub } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
+    NonPositiveFiniteNumber,
+    number,
+    0
+  >({
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: 0,
+    typeNameInMessage: 'a non-positive finite number',
+  } as const);

package/src/number/operators/non-positive-int.mts

@@ -0,0 +1,21 @@
+/**
+ * The operators of `NonPositiveInt` other than `isNonPositiveInt` and
+ * `asNonPositiveInt`, which `../branded-types/non-positive-int.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonPositiveInt } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { MAX_VALUE, add, fromNumber, is, max, min, pow, random, sub } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+    NonPositiveInt,
+    number,
+    0
+  >({
+    integerOrSafeInteger: 'Integer',
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: 0,
+    typeNameInMessage: 'a non-positive integer',
+  } as const);

package/src/number/operators/non-positive-safe-int.mts

@@ -0,0 +1,31 @@
+/**
+ * The operators of `NonPositiveSafeInt` other than `isNonPositiveSafeInt` and
+ * `asNonPositiveSafeInt`, which `../branded-types/non-positive-safe-int.mts`
+ * reads. Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonPositiveSafeInt } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  fromNumber,
+  is,
+  max,
+  min,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  NonPositiveSafeInt,
+  number,
+  0
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  MIN_VALUE: Number.MIN_SAFE_INTEGER,
+  MAX_VALUE: 0,
+  typeNameInMessage: 'a non-positive safe integer',
+} as const);

package/src/number/operators/non-zero-finite-number.mts

@@ -0,0 +1,21 @@
+/**
+ * The operators of `NonZeroFiniteNumber` other than `isNonZeroFiniteNumber` and
+ * `asNonZeroFiniteNumber`, which `../branded-types/non-zero-finite-number.mts`
+ * reads. Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonZeroFiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { abs, div, is, max, min, mul, pow, randomNonZero } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
+    NonZeroFiniteNumber,
+    number,
+    number
+  >({
+    nonZero: true,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
+    typeNameInMessage: 'a non-zero finite number',
+  } as const);

package/src/number/operators/non-zero-int.mts

@@ -0,0 +1,22 @@
+/**
+ * The operators of `NonZeroInt` other than `isNonZeroInt` and `asNonZeroInt`,
+ * which `../branded-types/non-zero-int.mts` reads. Generated by
+ * `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonZeroInt } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const { abs, is, max, min, mul, pow, randomNonZero } =
+  TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+    NonZeroInt,
+    number,
+    number
+  >({
+    integerOrSafeInteger: 'Integer',
+    nonZero: true,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
+    typeNameInMessage: 'a non-zero integer',
+  } as const);

package/src/number/operators/non-zero-int16.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `NonZeroInt16` other than `isNonZeroInt16` and
+ * `asNonZeroInt16`, which `../branded-types/non-zero-int16.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonZeroInt16 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  abs,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  randomNonZero,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  NonZeroInt16,
+  number,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  nonZero: true,
+  MIN_VALUE: -(2 ** 15),
+  MAX_VALUE: 2 ** 15 - 1,
+  typeNameInMessage: 'a non-zero integer in [-2^15, 2^15)',
+} as const);

package/src/number/operators/non-zero-int32.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `NonZeroInt32` other than `isNonZeroInt32` and
+ * `asNonZeroInt32`, which `../branded-types/non-zero-int32.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonZeroInt32 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  abs,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  randomNonZero,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  NonZeroInt32,
+  number,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  nonZero: true,
+  MIN_VALUE: -(2 ** 31),
+  MAX_VALUE: 2 ** 31 - 1,
+  typeNameInMessage: 'a non-zero integer in [-2^31, 2^31)',
+} as const);

package/src/number/operators/non-zero-safe-int.mts

@@ -0,0 +1,34 @@
+/**
+ * The operators of `NonZeroSafeInt` other than `isNonZeroSafeInt` and
+ * `asNonZeroSafeInt`, which `../branded-types/non-zero-safe-int.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonZeroSafeInt, SafeInt, SafeUint } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  abs,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  randomNonZero,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  NonZeroSafeInt,
+  SafeInt,
+  SafeUint
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  nonZero: true,
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-min-safe-integer
+  MIN_VALUE: Number.MIN_SAFE_INTEGER as SafeInt,
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-max-safe-integer
+  MAX_VALUE: Number.MAX_SAFE_INTEGER as SafeUint,
+  typeNameInMessage: 'a non-zero safe integer',
+} as const);

package/src/number/operators/non-zero-uint16.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `NonZeroUint16` other than `isNonZeroUint16` and
+ * `asNonZeroUint16`, which `../branded-types/non-zero-uint16.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonZeroUint16 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  randomNonZero,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  NonZeroUint16,
+  1,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  nonZero: true,
+  MIN_VALUE: 1,
+  MAX_VALUE: 2 ** 16 - 1,
+  typeNameInMessage: 'a non-zero integer in [1, 2^16)',
+} as const);

package/src/number/operators/non-zero-uint32.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `NonZeroUint32` other than `isNonZeroUint32` and
+ * `asNonZeroUint32`, which `../branded-types/non-zero-uint32.mts` reads.
+ * Generated by `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { NonZeroUint32 } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MAX_VALUE,
+  MIN_VALUE,
+  add,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  randomNonZero,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+  NonZeroUint32,
+  1,
+  number
+>({
+  integerOrSafeInteger: 'SafeInteger',
+  nonZero: true,
+  MIN_VALUE: 1,
+  MAX_VALUE: 2 ** 32 - 1,
+  typeNameInMessage: 'a non-zero integer in [1, 2^32)',
+} as const);

package/src/number/operators/positive-finite-number.mts

@@ -0,0 +1,32 @@
+/**
+ * The operators of `PositiveFiniteNumber` other than `isPositiveFiniteNumber`
+ * and `asPositiveFiniteNumber`, which
+ * `../branded-types/positive-finite-number.mts` reads. Generated by
+ * `gen:branded-number`; `renderModule` in
+ * `scripts/gen-branded-number/render.mts` says why they are in a module of
+ * their own.
+ */
+import type { PositiveFiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+
+export const {
+  MIN_VALUE,
+  add,
+  div,
+  fromNumber,
+  is,
+  max,
+  min,
+  mul,
+  pow,
+  random,
+  sub,
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
+  PositiveFiniteNumber,
+  number,
+  number
+>({
+  MIN_VALUE: Number.MIN_VALUE,
+  MAX_VALUE: Number.MAX_VALUE,
+  typeNameInMessage: 'a positive finite number',
+} as const);