@design-edito/tools 0.4.23 → 0.5.0

package/agnostic/misc/outcome/index.d.ts

@@ -2,10 +2,10 @@
  * Represents a successful outcome.
  *
  * @template Payload - The type of the success payload.
- * @property {true} success - Always `true`.
- * @property {Payload} payload - The success value.
+ * @property success - Always `true`.
+ * @property payload - The success value.
  */
-export type Success<Payload = any> = {
+export type Success<Payload = unknown> = {
     success: true;
     payload: Payload;
 };
@@ -13,10 +13,10 @@ export type Success<Payload = any> = {
  * Represents a failed outcome.
  *
  * @template Error - The type of the error.
- * @property {false} success - Always `false`.
- * @property {Error} error - The error value.
+ * @property success - Always `false`.
+ * @property error - The error value.
  */
-export type Failure<Error = any> = {
+export type Failure<Error = unknown> = {
     success: false;
     error: Error;
 };
@@ -26,21 +26,21 @@ export type Failure<Error = any> = {
  * @template Payload - Type of success payload.
  * @template Error - Type of error.
  */
-export type Either<Payload = any, Error = any> = Success<Payload> | Failure<Error>;
+export type Either<Payload = unknown, Error = unknown> = Success<Payload> | Failure<Error>;
 /**
  * Creates a success outcome with the given payload.
  *
  * @template Payload
- * @param {Payload} payload - The success value.
- * @returns {Success<Payload>} A success outcome object.
+ * @param payload - The success value.
+ * @returns A success outcome object.
  */
 export declare function makeSuccess<Payload>(payload: Payload): Success<Payload>;
 /**
  * Creates a failure outcome with the given error.
  *
  * @template Error
- * @param {Error} error - The error value.
- * @returns {Failure<Error>} A failure outcome object.
+ * @param error - The error value.
+ * @returns A failure outcome object.
  */
 export declare function makeFailure<Error>(error: Error): Failure<Error>;
 /**
@@ -48,9 +48,9 @@ export declare function makeFailure<Error>(error: Error): Failure<Error>;
  *
  * @template Payload
  * @template Error
- * @param {boolean} success - `true` to create a success, `false` to create a failure.
- * @param {Payload | Error} payloadOrError - The payload if success, or the error if failure.
- * @returns {Either<Payload, Error>} The resulting outcome.
+ * @param success - `true` to create a success, `false` to create a failure.
+ * @param payloadOrError - The payload if success, or the error if failure.
+ * @returns The resulting outcome.
  */
 export declare function make<Payload>(success: true, payload: Payload): Success<Payload>;
 export declare function make<Error>(success: false, error: Error): Failure<Error>;

package/agnostic/misc/outcome/index.js

@@ -2,20 +2,22 @@
  * Creates a success outcome with the given payload.
  *
  * @template Payload
- * @param {Payload} payload - The success value.
- * @returns {Success<Payload>} A success outcome object.
+ * @param payload - The success value.
+ * @returns A success outcome object.
  */
 export function makeSuccess(payload) { return { success: true, payload }; }
 /**
  * Creates a failure outcome with the given error.
  *
  * @template Error
- * @param {Error} error - The error value.
- * @returns {Failure<Error>} A failure outcome object.
+ * @param error - The error value.
+ * @returns A failure outcome object.
  */
 export function makeFailure(error) { return { success: false, error }; }
 export function make(success, payloadOrError) {
     return success
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- guaranteed by the overload signatures above; the implementation signature can't express that link
         ? makeSuccess(payloadOrError)
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- guaranteed by the overload signatures above; the implementation signature can't express that link
         : makeFailure(payloadOrError);
 }

package/agnostic/numbers/absolute-modulo/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * Computes the modulo of a number, always returning a non-negative result.
  *
- * @param {number} nbr - The number to modulo.
- * @param {number} modulo - The modulus.
- * @returns {number} The non-negative remainder of `nbr` modulo `modulo`.
+ * @param nbr - The number to modulo.
+ * @param modulo - The modulus.
+ * @returns The non-negative remainder of `nbr` modulo `modulo`.
  */
 export declare function absoluteModulo(nbr: number, modulo: number): number;

package/agnostic/numbers/absolute-modulo/index.js

@@ -1,9 +1,9 @@
 /**
  * Computes the modulo of a number, always returning a non-negative result.
  *
- * @param {number} nbr - The number to modulo.
- * @param {number} modulo - The modulus.
- * @returns {number} The non-negative remainder of `nbr` modulo `modulo`.
+ * @param nbr - The number to modulo.
+ * @param modulo - The modulus.
+ * @returns The non-negative remainder of `nbr` modulo `modulo`.
  */
 export function absoluteModulo(nbr, modulo) {
     return ((nbr % modulo) + modulo) % modulo;

package/agnostic/numbers/approximate-rational/index.d.ts

@@ -4,9 +4,9 @@
  * Uses a naive algorithm that increments the numerator or denominator each round
  * to find the closest approximation. Stops early if an exact match is found.
  *
- * @param {number} target - The decimal number to approximate.
- * @param {number} maxRounds - The maximum number of iterations to perform.
- * @returns {[number, number]} A tuple `[numerator, denominator]` representing the rational approximation.
+ * @param target - The decimal number to approximate.
+ * @param maxRounds - The maximum number of iterations to perform.
+ * @returns A tuple `[numerator, denominator]` representing the rational approximation.
  */
 export declare function approximateRationalDumb(target: number, maxRounds: number): [number, number];
 /**
@@ -15,8 +15,8 @@ export declare function approximateRationalDumb(target: number, maxRounds: numbe
  * Uses the continued fractions algorithm to find the best rational approximation
  * of a decimal number within the specified maximum denominator limit.
  *
- * @param {number} target - The decimal number to approximate.
- * @param {number} [maxDenominator=1000] - The maximum allowed denominator value.
- * @returns {[number, number]} A tuple `[numerator, denominator]` representing the rational approximation.
+ * @param target - The decimal number to approximate.
+ * @param [maxDenominator=1000] - The maximum allowed denominator value.
+ * @returns A tuple `[numerator, denominator]` representing the rational approximation.
  */
 export declare function approximateRational(target: number, maxDenominator?: number): [number, number];

package/agnostic/numbers/approximate-rational/index.js

@@ -4,9 +4,9 @@
  * Uses a naive algorithm that increments the numerator or denominator each round
  * to find the closest approximation. Stops early if an exact match is found.
  *
- * @param {number} target - The decimal number to approximate.
- * @param {number} maxRounds - The maximum number of iterations to perform.
- * @returns {[number, number]} A tuple `[numerator, denominator]` representing the rational approximation.
+ * @param target - The decimal number to approximate.
+ * @param maxRounds - The maximum number of iterations to perform.
+ * @returns A tuple `[numerator, denominator]` representing the rational approximation.
  */
 export function approximateRationalDumb(target, maxRounds) {
     let numerator = 0;
@@ -20,7 +20,7 @@ export function approximateRationalDumb(target, maxRounds) {
     };
     const positiveTarget = Math.abs(target);
     while (currentRound < maxRounds && !foundExact) {
-        currentRound++;
+        currentRound = currentRound + 1;
         const roundResult = numerator / denominator;
         if (roundResult === positiveTarget) {
             closestFound.numerator = numerator;
@@ -37,10 +37,10 @@ export function approximateRationalDumb(target, maxRounds) {
                 closestFound.found = roundResult;
             }
             if (roundResult < positiveTarget) {
-                numerator++;
+                numerator = numerator + 1;
             }
             else {
-                denominator++;
+                denominator = denominator + 1;
             }
         }
     }
@@ -58,9 +58,9 @@ export function approximateRationalDumb(target, maxRounds) {
  * Uses the continued fractions algorithm to find the best rational approximation
  * of a decimal number within the specified maximum denominator limit.
  *
- * @param {number} target - The decimal number to approximate.
- * @param {number} [maxDenominator=1000] - The maximum allowed denominator value.
- * @returns {[number, number]} A tuple `[numerator, denominator]` representing the rational approximation.
+ * @param target - The decimal number to approximate.
+ * @param [maxDenominator=1000] - The maximum allowed denominator value.
+ * @returns A tuple `[numerator, denominator]` representing the rational approximation.
  */
 export function approximateRational(target, maxDenominator = 1000) {
     const sign = target < 0 ? -1 : 1;

package/agnostic/numbers/clamp/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * Restricts a number to lie within a specified range.
  *
- * @param {number} num - The number to clamp.
- * @param {number} bound1 - One end of the range.
- * @param {number} bound2 - The other end of the range.
- * @returns {number} The number constrained between the minimum and maximum of the two bounds.
+ * @param num - The number to clamp.
+ * @param bound1 - One end of the range.
+ * @param bound2 - The other end of the range.
+ * @returns The number constrained between the minimum and maximum of the two bounds.
  */
 export declare function clamp(num: number, bound1: number, bound2: number): number;

package/agnostic/numbers/clamp/index.js

@@ -1,10 +1,10 @@
 /**
  * Restricts a number to lie within a specified range.
  *
- * @param {number} num - The number to clamp.
- * @param {number} bound1 - One end of the range.
- * @param {number} bound2 - The other end of the range.
- * @returns {number} The number constrained between the minimum and maximum of the two bounds.
+ * @param num - The number to clamp.
+ * @param bound1 - One end of the range.
+ * @param bound2 - The other end of the range.
+ * @returns The number constrained between the minimum and maximum of the two bounds.
  */
 export function clamp(num, bound1, bound2) {
     const min = Math.min(bound1, bound2);

package/agnostic/numbers/geometric-progressions/index.d.ts

@@ -5,10 +5,10 @@
  * This function divides the range [min, max] multiplicatively (logarithmically)
  * across `steps` and returns the value corresponding to `level` (1-based).
  *
- * @param {number} min - The minimum value (must be non-zero).
- * @param {number} max - The maximum value.
- * @param {number} level - The current level (1-based, typically 1 ≤ level ≤ steps).
- * @param {number} steps - Total number of steps (must be ≥ 1).
- * @returns {number} The computed value at the specified level, or `NaN` if input is invalid.
+ * @param min - The minimum value (must be non-zero).
+ * @param max - The maximum value.
+ * @param level - The current level (1-based, typically 1 ≤ level ≤ steps).
+ * @param steps - Total number of steps (must be ≥ 1).
+ * @returns The computed value at the specified level, or `NaN` if input is invalid.
  */
 export declare function getGeometricStep(min: number, max: number, level: number, steps: number): number;

package/agnostic/numbers/geometric-progressions/index.js

@@ -5,18 +5,20 @@
  * This function divides the range [min, max] multiplicatively (logarithmically)
  * across `steps` and returns the value corresponding to `level` (1-based).
  *
- * @param {number} min - The minimum value (must be non-zero).
- * @param {number} max - The maximum value.
- * @param {number} level - The current level (1-based, typically 1 ≤ level ≤ steps).
- * @param {number} steps - Total number of steps (must be ≥ 1).
- * @returns {number} The computed value at the specified level, or `NaN` if input is invalid.
+ * @param min - The minimum value (must be non-zero).
+ * @param max - The maximum value.
+ * @param level - The current level (1-based, typically 1 ≤ level ≤ steps).
+ * @param steps - Total number of steps (must be ≥ 1).
+ * @returns The computed value at the specified level, or `NaN` if input is invalid.
  */
 export function getGeometricStep(min, max, level, steps) {
     if (min === 0) {
+        // eslint-disable-next-line no-console
         console.warn('Cannot generate values if min value is zero');
         return NaN;
     }
     if (steps < 1) {
+        // eslint-disable-next-line no-console
         console.warn('Cannot generate values if steps is lower than one');
         return NaN;
     }

package/agnostic/numbers/geometric-progressions/index.test.js

@@ -23,13 +23,13 @@ describe('getGeometricStep', () => {
         expect(values[4]).toBeCloseTo(16);
     });
     it('returns NaN if min is zero', () => {
-        const spy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const spy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
         expect(getGeometricStep(0, 10, 1, 5)).toBeNaN();
         expect(spy).toHaveBeenCalledWith('Cannot generate values if min value is zero');
         spy.mockRestore();
     });
     it('returns NaN if steps is less than 1', () => {
-        const spy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const spy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
         expect(getGeometricStep(1, 10, 1, 0)).toBeNaN();
         expect(spy).toHaveBeenCalledWith('Cannot generate values if steps is lower than one');
         spy.mockRestore();

package/agnostic/numbers/index.d.ts

@@ -1,6 +1,6 @@
 export * as absoluteModulo from './absolute-modulo/index.js'
 export * as approximateRational from './approximate-rational/index.js'
 export * as clamp from './clamp/index.js'
-export * as interpolate from './interpolate/index.js'
 export * as geometricProgressions from './geometric-progressions/index.js'
+export * as interpolate from './interpolate/index.js'
 export * as round from './round/index.js'

package/agnostic/numbers/index.js

@@ -1,6 +1,6 @@
 export * as absoluteModulo from './absolute-modulo/index.js'
 export * as approximateRational from './approximate-rational/index.js'
 export * as clamp from './clamp/index.js'
-export * as interpolate from './interpolate/index.js'
 export * as geometricProgressions from './geometric-progressions/index.js'
+export * as interpolate from './interpolate/index.js'
 export * as round from './round/index.js'

package/agnostic/numbers/interpolate/index.d.ts

@@ -1,10 +1,10 @@
 /**
  * Performs linear interpolation between two bounds based on a ratio.
  *
- * @param {number} ratio - The interpolation factor, typically between 0 and 1.
- * @param {number} bound1 - The start value.
- * @param {number} bound2 - The end value.
- * @returns {number} The interpolated value between `bound1` and `bound2`.
+ * @param ratio - The interpolation factor, typically between 0 and 1.
+ * @param bound1 - The start value.
+ * @param bound2 - The end value.
+ * @returns The interpolated value between `bound1` and `bound2`.
  */
 export declare function interpolate(ratio: number, bound1: number, bound2: number): number;
 /**
@@ -13,9 +13,9 @@ export declare function interpolate(ratio: number, bound1: number, bound2: numbe
  * If only `bound1` is provided, returns the ratio of `value / bound1`.
  * If both bounds are provided, returns the normalized position of `value` between `bound1` and `bound2`.
  *
- * @param {number} value - The value to normalize.
- * @param {number} bound1 - The lower bound (or single reference value if `bound2` is omitted).
- * @param {number} [bound2] - The upper bound (optional).
- * @returns {number} A ratio representing the relative position of `value`.
+ * @param value - The value to normalize.
+ * @param bound1 - The lower bound (or single reference value if `bound2` is omitted).
+ * @param [bound2] - The upper bound (optional).
+ * @returns A ratio representing the relative position of `value`.
  */
 export declare function unlerp(value: number, bound1: number, bound2?: number): number;

package/agnostic/numbers/interpolate/index.js

@@ -1,10 +1,10 @@
 /**
  * Performs linear interpolation between two bounds based on a ratio.
  *
- * @param {number} ratio - The interpolation factor, typically between 0 and 1.
- * @param {number} bound1 - The start value.
- * @param {number} bound2 - The end value.
- * @returns {number} The interpolated value between `bound1` and `bound2`.
+ * @param ratio - The interpolation factor, typically between 0 and 1.
+ * @param bound1 - The start value.
+ * @param bound2 - The end value.
+ * @returns The interpolated value between `bound1` and `bound2`.
  */
 export function interpolate(ratio, bound1, bound2) {
     return bound1 + ratio * (bound2 - bound1);
@@ -15,10 +15,10 @@ export function interpolate(ratio, bound1, bound2) {
  * If only `bound1` is provided, returns the ratio of `value / bound1`.
  * If both bounds are provided, returns the normalized position of `value` between `bound1` and `bound2`.
  *
- * @param {number} value - The value to normalize.
- * @param {number} bound1 - The lower bound (or single reference value if `bound2` is omitted).
- * @param {number} [bound2] - The upper bound (optional).
- * @returns {number} A ratio representing the relative position of `value`.
+ * @param value - The value to normalize.
+ * @param bound1 - The lower bound (or single reference value if `bound2` is omitted).
+ * @param [bound2] - The upper bound (optional).
+ * @returns A ratio representing the relative position of `value`.
  */
 export function unlerp(value, bound1, bound2) {
     if (bound2 === undefined)

package/agnostic/numbers/round/index.d.ts

@@ -1,24 +1,24 @@
 /**
  * Rounds a number to/down a specified number of decimal places.
  *
- * @param {number} number - The number to round.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The rounded number.
+ * @param number - The number to round.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The rounded number.
  */
 export declare function round(number: number, nbDecimals?: number): number;
 /**
  * Ceils a number up to a specified number of decimal places.
  *
- * @param {number} number - The number to round up.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The ceiled-up number.
+ * @param number - The number to round up.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The ceiled-up number.
  */
 export declare function ceil(number: number, nbDecimals?: number): number;
 /**
  * Floors a number down to a specified number of decimal places.
  *
- * @param {number} number - The number to round down.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The floored-down number.
+ * @param number - The number to round down.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The floored-down number.
  */
 export declare function floor(number: number, nbDecimals?: number): number;

package/agnostic/numbers/round/index.js

@@ -1,9 +1,9 @@
 /**
  * Rounds a number to/down a specified number of decimal places.
  *
- * @param {number} number - The number to round.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The rounded number.
+ * @param number - The number to round.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The rounded number.
  */
 export function round(number, nbDecimals = 0) {
     const multiplier = Math.pow(10, nbDecimals);
@@ -12,9 +12,9 @@ export function round(number, nbDecimals = 0) {
 /**
  * Ceils a number up to a specified number of decimal places.
  *
- * @param {number} number - The number to round up.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The ceiled-up number.
+ * @param number - The number to round up.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The ceiled-up number.
  */
 export function ceil(number, nbDecimals = 0) {
     const multiplier = Math.pow(10, nbDecimals);
@@ -23,9 +23,9 @@ export function ceil(number, nbDecimals = 0) {
 /**
  * Floors a number down to a specified number of decimal places.
  *
- * @param {number} number - The number to round down.
- * @param {number} nbDecimals - Number of decimal places. Defaults to 0
- * @returns {number} The floored-down number.
+ * @param number - The number to round down.
+ * @param nbDecimals - Number of decimal places. Defaults to 0
+ * @returns The floored-down number.
  */
 export function floor(number, nbDecimals = 0) {
     const multiplier = Math.pow(10, nbDecimals);

package/agnostic/objects/deep-get-property/index.d.ts

@@ -1,9 +1,9 @@
 /**
  * Safely retrieves a nested property from an object using a dot-separated path string.
  *
- * @param {unknown} anythingThatHasProperties - The object (or record) to traverse.
- * @param {string} pathString - Dot-separated path of the property to retrieve (e.g., `'a.b.c'`).
- * @returns {any} The value at the specified path.
+ * @param anythingThatHasProperties - The object (or record) to traverse.
+ * @param pathString - Dot-separated path of the property to retrieve (e.g., `'a.b.c'`).
+ * @returns The value at the specified path.
  * @throws {string} `'PROPERTY_UNREACHABLE'` if any part of the path is inaccessible or not an object.
  */
-export declare function deepGetProperty(anythingThatHasProperties: unknown, pathString: string): any;
+export declare function deepGetProperty(anythingThatHasProperties: unknown, pathString: string): unknown;

package/agnostic/objects/deep-get-property/index.js

@@ -2,9 +2,9 @@ import { isRecord } from '../is-record/index.js';
 /**
  * Safely retrieves a nested property from an object using a dot-separated path string.
  *
- * @param {unknown} anythingThatHasProperties - The object (or record) to traverse.
- * @param {string} pathString - Dot-separated path of the property to retrieve (e.g., `'a.b.c'`).
- * @returns {any} The value at the specified path.
+ * @param anythingThatHasProperties - The object (or record) to traverse.
+ * @param pathString - Dot-separated path of the property to retrieve (e.g., `'a.b.c'`).
+ * @returns The value at the specified path.
  * @throws {string} `'PROPERTY_UNREACHABLE'` if any part of the path is inaccessible or not an object.
  */
 export function deepGetProperty(anythingThatHasProperties, pathString) {

package/agnostic/objects/enums/is-in-enum/index.d.ts

@@ -4,8 +4,8 @@
  * Works with both string and numeric enums, ignoring reverse mappings in numeric enums.
  *
  * @template E - The enum type.
- * @param {E} enumObj - The enum object to check against.
- * @param {string | number} value - The value to test.
- * @returns {value is E[keyof E]} `true` if the value is a valid enum member, otherwise `false`.
+ * @param enumObj - The enum object to check against.
+ * @param value - The value to test.
+ * @returns `true` if the value is a valid enum member, otherwise `false`.
  */
 export declare function isInEnum<E extends Record<string, string | number>>(enumObj: E, value: string | number): value is E[keyof E];

package/agnostic/objects/enums/is-in-enum/index.js

@@ -4,9 +4,9 @@
  * Works with both string and numeric enums, ignoring reverse mappings in numeric enums.
  *
  * @template E - The enum type.
- * @param {E} enumObj - The enum object to check against.
- * @param {string | number} value - The value to test.
- * @returns {value is E[keyof E]} `true` if the value is a valid enum member, otherwise `false`.
+ * @param enumObj - The enum object to check against.
+ * @param value - The value to test.
+ * @returns `true` if the value is a valid enum member, otherwise `false`.
  */
 export function isInEnum(enumObj, value) {
     const keys = Object.keys(enumObj);

package/agnostic/objects/flatten-getters/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Returns a shallow copy of an object including values from its getter properties.
  *
- * @param {object} obj - The object to flatten.
- * @returns {Record<string, unknown>} A new object containing all own properties and evaluated getter values.
+ * @param obj - The object to flatten.
+ * @returns A new object containing all own properties and evaluated getter values.
  */
 export declare function flattenGetters(obj: object): Record<string, unknown>;

package/agnostic/objects/flatten-getters/index.js

@@ -1,14 +1,15 @@
 /**
  * Returns a shallow copy of an object including values from its getter properties.
  *
- * @param {object} obj - The object to flatten.
- * @returns {Record<string, unknown>} A new object containing all own properties and evaluated getter values.
+ * @param obj - The object to flatten.
+ * @returns A new object containing all own properties and evaluated getter values.
  */
 export function flattenGetters(obj) {
     const getters = Object.entries(Object.getOwnPropertyDescriptors(obj)).filter(([_, desc]) => (typeof desc.get === 'function'))
         .map(([key]) => key);
     const returned = { ...obj };
     getters.forEach(getter => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- getter came from Object.getOwnPropertyDescriptors(obj)'s own keys, so it's always a key of obj
         const key = getter;
         returned[getter] = obj[key];
     });

package/agnostic/objects/index.d.ts

@@ -1,9 +1,9 @@
 export * as deepGetProperty from './deep-get-property/index.js'
 export * as enums from './enums/index.js'
+export * as flattenGetters from './flatten-getters/index.js'
 export * as isObject from './is-object/index.js'
 export * as isRecord from './is-record/index.js'
 export * as recordFormat from './record-format/index.js'
-export * as flattenGetters from './flatten-getters/index.js'
-export * as sortKeys from './sort-keys/index.js'
 export * as recordMap from './record-map/index.js'
+export * as sortKeys from './sort-keys/index.js'
 export * as validation from './validation/index.js'

package/agnostic/objects/index.js

@@ -1,9 +1,9 @@
 export * as deepGetProperty from './deep-get-property/index.js'
 export * as enums from './enums/index.js'
+export * as flattenGetters from './flatten-getters/index.js'
 export * as isObject from './is-object/index.js'
 export * as isRecord from './is-record/index.js'
 export * as recordFormat from './record-format/index.js'
-export * as flattenGetters from './flatten-getters/index.js'
-export * as sortKeys from './sort-keys/index.js'
 export * as recordMap from './record-map/index.js'
+export * as sortKeys from './sort-keys/index.js'
 export * as validation from './validation/index.js'

package/agnostic/objects/is-object/index.d.ts

@@ -1,14 +1,14 @@
 /**
  * Checks if a value is of type "object", including `null`.
  *
- * @param {unknown} unk - The value to check.
- * @returns {unk is object | null} `true` if the value is an object or `null`, otherwise `false`.
+ * @param unk - The value to check.
+ * @returns `true` if the value is an object or `null`, otherwise `false`.
  */
 export declare function isObject(unk: unknown): unk is object | null;
 /**
  * Checks if a value is a non-null object.
  *
- * @param {unknown} unk - The value to check.
- * @returns {unk is object} `true` if the value is a non-null object, otherwise `false`.
+ * @param unk - The value to check.
+ * @returns `true` if the value is a non-null object, otherwise `false`.
  */
 export declare function isNonNullObject(unk: unknown): unk is object;

package/agnostic/objects/is-object/index.js

@@ -1,8 +1,8 @@
 /**
  * Checks if a value is of type "object", including `null`.
  *
- * @param {unknown} unk - The value to check.
- * @returns {unk is object | null} `true` if the value is an object or `null`, otherwise `false`.
+ * @param unk - The value to check.
+ * @returns `true` if the value is an object or `null`, otherwise `false`.
  */
 export function isObject(unk) {
     return typeof unk === 'object';
@@ -10,8 +10,8 @@ export function isObject(unk) {
 /**
  * Checks if a value is a non-null object.
  *
- * @param {unknown} unk - The value to check.
- * @returns {unk is object} `true` if the value is a non-null object, otherwise `false`.
+ * @param unk - The value to check.
+ * @returns `true` if the value is a non-null object, otherwise `false`.
  */
 export function isNonNullObject(unk) {
     return unk !== null && isObject(unk);

package/agnostic/objects/is-record/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Checks if a value is a plain object with string keys.
  *
- * @param {unknown} input - The value to check.
- * @returns {input is Record<string, unknown>} `true` if the value is an object with string keys, otherwise `false`.
+ * @param input - The value to check.
+ * @returns `true` if the value is an object with string keys, otherwise `false`.
  */
 export declare function isRecord(input: unknown): input is Record<string, unknown>;

package/agnostic/objects/is-record/index.js

@@ -1,8 +1,8 @@
 /**
  * Checks if a value is a plain object with string keys.
  *
- * @param {unknown} input - The value to check.
- * @returns {input is Record<string, unknown>} `true` if the value is an object with string keys, otherwise `false`.
+ * @param input - The value to check.
+ * @returns `true` if the value is an object with string keys, otherwise `false`.
  */
 export function isRecord(input) {
     if (typeof input !== 'object' || input === null)