@dereekb/util 13.11.13 → 13.11.15

package/src/lib/value/bound.d.ts

@@ -27,31 +27,31 @@ export type LatLngBoundOrPoint = LatLngBound | LatLngPoint;
 /**
  * Type guard that checks whether the input is a {@link LatLngBound} by testing for the presence of `sw` and `ne` properties.
  *
- * @param input - value to test
- * @returns `true` if the input has `sw` and `ne` properties, indicating a bound
+ * @param input - Value to test.
+ * @returns `true` if the input has `sw` and `ne` properties, indicating a bound.
  */
 export declare function isLatLngBound(input: LatLngBound | unknown): input is LatLngBound;
 /**
  * Creates a deep copy of the bound so that mutations to the copy do not affect the original.
  *
- * @param input - bound to copy
- * @returns a new bound with copied corner points
+ * @param input - Bound to copy.
+ * @returns A new bound with copied corner points.
  */
 export declare function copyLatLngBound(input: LatLngBound): LatLngBound;
 /**
  * Checks whether two bounds are identical by comparing both corner points.
  *
- * @param a - first bound
- * @param b - second bound
- * @returns `true` if both the `sw` and `ne` corners are the same
+ * @param a - First bound.
+ * @param b - Second bound.
+ * @returns `true` if both the `sw` and `ne` corners are the same.
  */
 export declare function isSameLatLngBound(a: LatLngBound, b: LatLngBound): boolean;
 /**
  * Computes the difference between the `ne` and `sw` corner points of a bound, giving the span in latitude and longitude.
  *
- * @param bounds - bound to measure
- * @param wrap - whether to wrap the difference across the antimeridian
- * @returns a point whose `lat`/`lng` represent the span of the bound
+ * @param bounds - Bound to measure.
+ * @param wrap - Whether to wrap the difference across the antimeridian.
+ * @returns A point whose `lat`/`lng` represent the span of the bound.
  */
 export declare function diffLatLngBoundPoints(bounds: LatLngBound, wrap?: boolean): LatLngPoint;
 /**
@@ -60,59 +60,59 @@ export declare function diffLatLngBoundPoints(bounds: LatLngBound, wrap?: boolea
  * A bound "wraps" when it crosses the antimeridian (longitude +/-180), requiring special handling
  * for containment and overlap checks.
  *
- * @param bound - bound to check
- * @returns `true` if the bound wraps the map in either sense
+ * @param bound - Bound to check.
+ * @returns `true` if the bound wraps the map in either sense.
  */
 export declare function latLngBoundWrapsMap(bound: LatLngBound): boolean;
 /**
  * Returns true if the input LatLngBound's sw corner comes after the ne corner longitudinally,
  * indicating the bound crosses the antimeridian.
  *
- * @param bound - bound to check
- * @returns `true` if the sw longitude is greater than the ne longitude
+ * @param bound - Bound to check.
+ * @returns `true` if the sw longitude is greater than the ne longitude.
  */
 export declare function latLngBoundStrictlyWrapsMap(bound: LatLngBound): boolean;
 /**
  * Returns true if the LatLngBound's longitudinal span exceeds the total longitude range (360 degrees),
  * meaning the bound covers the entire map horizontally.
  *
- * @param bound - bound to check
- * @returns `true` if the absolute longitude difference exceeds the total longitude range
+ * @param bound - Bound to check.
+ * @returns `true` if the absolute longitude difference exceeds the total longitude range.
  */
 export declare function latLngBoundFullyWrapsMap(bound: LatLngBound): boolean;
 /**
  * Returns the north-east corner point of the bound.
  *
- * @param bound - bound to read
- * @returns the `ne` corner point
+ * @param bound - Bound to read.
+ * @returns The `ne` corner point.
  */
 export declare function latLngBoundNorthEastPoint(bound: LatLngBound): LatLngPoint;
 /**
  * Derives the north-west corner point from the bound's `ne` latitude and `sw` longitude.
  *
- * @param bound - bound to read
- * @returns the computed north-west corner point
+ * @param bound - Bound to read.
+ * @returns The computed north-west corner point.
  */
 export declare function latLngBoundNorthWestPoint(bound: LatLngBound): LatLngPoint;
 /**
  * Derives the south-east corner point from the bound's `sw` latitude and `ne` longitude.
  *
- * @param bound - bound to read
- * @returns the computed south-east corner point
+ * @param bound - Bound to read.
+ * @returns The computed south-east corner point.
  */
 export declare function latLngBoundSouthEastPoint(bound: LatLngBound): LatLngPoint;
 /**
  * Returns the south-west corner point of the bound.
  *
- * @param bound - bound to read
- * @returns the `sw` corner point
+ * @param bound - Bound to read.
+ * @returns The `sw` corner point.
  */
 export declare function latLngBoundSouthWestPoint(bound: LatLngBound): LatLngPoint;
 /**
  * Computes the geographic center of the bound by averaging the corner coordinates.
  *
- * @param bound - bound to compute the center of
- * @returns the center point
+ * @param bound - Bound to compute the center of.
+ * @returns The center point.
  *
  * @example
  * ```ts
@@ -125,29 +125,29 @@ export declare function latLngBoundCenterPoint(bound: LatLngBound): LatLngPoint;
 /**
  * Returns the northern latitude boundary (the `ne` latitude).
  *
- * @param bound - bound to read
- * @returns the latitude of the north edge
+ * @param bound - Bound to read.
+ * @returns The latitude of the north edge.
  */
 export declare function latLngBoundNorthBound(bound: LatLngBound): number;
 /**
  * Returns the southern latitude boundary (the `sw` latitude).
  *
- * @param bound - bound to read
- * @returns the latitude of the south edge
+ * @param bound - Bound to read.
+ * @returns The latitude of the south edge.
  */
 export declare function latLngBoundSouthBound(bound: LatLngBound): number;
 /**
  * Returns the eastern longitude boundary (the `ne` longitude).
  *
- * @param bound - bound to read
- * @returns the longitude of the east edge
+ * @param bound - Bound to read.
+ * @returns The longitude of the east edge.
  */
 export declare function latLngBoundEastBound(bound: LatLngBound): number;
 /**
  * Returns the western longitude boundary (the `sw` longitude).
  *
- * @param bound - bound to read
- * @returns the longitude of the west edge
+ * @param bound - Bound to read.
+ * @returns The longitude of the west edge.
  */
 export declare function latLngBoundWestBound(bound: LatLngBound): number;
 /**
@@ -165,9 +165,9 @@ export type LatLngBoundInput = LatLngBound | LatLngBoundTuple | LatLngBoundTuple
 /**
  * Convenience function that creates a {@link LatLngBoundTuple} using the default configuration.
  *
- * @param input - a sw point or any bound input
- * @param inputNe - optional ne point when providing two separate points
- * @returns a tuple of `[sw, ne]` points
+ * @param input - A sw point or any bound input.
+ * @param inputNe - Optional ne point when providing two separate points.
+ * @returns A tuple of `[sw, ne]` points.
  */
 export declare function latLngBoundTuple(input: LatLngBoundSouthWestPoint | LatLngBoundInput, inputNe?: LatLngBoundNothEastPoint): LatLngBoundTuple;
 /**
@@ -179,23 +179,24 @@ export type LatLngBoundTupleFunctionConfig = LatLngBoundFunctionConfig;
  * Creates a {@link LatLngBoundTupleFunction} that converts various bound inputs into a `[sw, ne]` tuple,
  * applying optional precision to the resulting points.
  *
+ * @param config - Optional configuration for point precision.
+ * @returns Produces bound tuples from flexible inputs.
+ *
  * @dbxUtil
  * @dbxUtilCategory value
  * @dbxUtilKind factory
  * @dbxUtilTags value, lat-lng, bound, tuple, factory, geographic
  * @dbxUtilRelated lat-lng-bound-function, lat-lng-bound
  *
- * @param config - optional configuration for point precision
- * @returns a function that produces bound tuples from flexible inputs
  * @__NO_SIDE_EFFECTS__
  */
 export declare function latLngBoundTupleFunction(config?: LatLngBoundTupleFunctionConfig): LatLngBoundTupleFunction;
 /**
  * Convenience function that creates a {@link LatLngBound} using the default configuration.
  *
- * @param input - a sw point or any bound input
- * @param inputNe - optional ne point when providing two separate points
- * @returns a bound object
+ * @param input - A sw point or any bound input.
+ * @param inputNe - Optional ne point when providing two separate points.
+ * @returns A bound object.
  *
  * @example
  * ```ts
@@ -215,11 +216,11 @@ export interface LatLngBoundFunctionConfig {
     /**
      * Point function to use for calculations.
      */
-    pointFunction?: LatLngPointFunction;
+    readonly pointFunction?: LatLngPointFunction;
     /**
      * LatLngPrecision to use if pointFunction is not provided.
      */
-    precision?: LatLngPrecision;
+    readonly precision?: LatLngPrecision;
 }
 /**
  * Creates a {@link LatLngBoundFunction} that normalizes various bound input formats into a {@link LatLngBound}.
@@ -227,9 +228,9 @@ export interface LatLngBoundFunctionConfig {
  * Supports creating bounds from: two separate points, a `[sw, ne]` tuple, a four-point tuple (computes min/max extents),
  * or a pre-existing bound object.
  *
- * @param config - optional configuration for point precision and custom point functions
- * @returns a function that produces bounds from flexible inputs
- * @throws {Error} when the input cannot be parsed into a valid bound
+ * @param config - Optional configuration for point precision and custom point functions.
+ * @returns Produces bounds from flexible inputs.
+ * @throws {Error} When the input cannot be parsed into a valid bound.
  *
  * @dbxUtil
  * @dbxUtilCategory value
@@ -243,6 +244,7 @@ export interface LatLngBoundFunctionConfig {
  * const result = fn([{ lat: 20, lng: 20 }, { lat: 30, lng: 30 }]);
  * // result.sw.lat === 20, result.ne.lat === 30
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function latLngBoundFunction(config?: LatLngBoundFunctionConfig): LatLngBoundFunction;
@@ -255,8 +257,8 @@ export type ExtendLatLngBoundInput = ArrayOrValue<LatLngBoundOrPoint>;
  *
  * When given an array, the first element seeds the initial bound and subsequent elements extend it.
  *
- * @param input - one or more points/bounds to derive the bounding box from
- * @returns the computed bound, or `undefined` if the input is empty
+ * @param input - One or more points/bounds to derive the bounding box from.
+ * @returns The computed bound, or `undefined` if the input is empty.
  *
  * @example
  * ```ts
@@ -273,9 +275,9 @@ export declare function latLngBoundFromInput(input: ExtendLatLngBoundInput): May
  *
  * The returned bound's `sw` corner uses the minimum lat/lng encountered, and its `ne` corner uses the maximum.
  *
- * @param bound - the starting bound to extend
- * @param extendWith - one or more points/bounds to include
- * @returns a new bound that encompasses the original and all extensions
+ * @param bound - The starting bound to extend.
+ * @param extendWith - One or more points/bounds to include.
+ * @returns A new bound that encompasses the original and all extensions.
  */
 export declare function extendLatLngBound(bound: LatLngBound, extendWith: ExtendLatLngBoundInput): LatLngBound;
 /**
@@ -295,22 +297,23 @@ export type IsWithinLatLngBoundFunction = LatLngBoundCheckFunction & {
  * falls entirely within the specified bound. Points are checked directly; bounds require
  * both corners to be within.
  *
+ * @param bound - The reference bound to check containment against.
+ * @returns Returns `true` if the input is within the reference bound.
+ *
  * @dbxUtil
  * @dbxUtilCategory value
  * @dbxUtilKind factory
  * @dbxUtilTags value, lat-lng, bound, contains, decision, factory, geographic
  * @dbxUtilRelated overlaps-lat-lng-bound-function, is-lat-lng-point-within-lat-lng-bound
  *
- * @param bound - the reference bound to check containment against
- * @returns a function that returns `true` if the input is within the reference bound
  * @__NO_SIDE_EFFECTS__
  */
 export declare function isWithinLatLngBoundFunction(bound: LatLngBound): IsWithinLatLngBoundFunction;
 /**
  * Checks whether one bound is entirely contained within another by verifying both its corners are within the outer bound.
  *
- * @param bound - the inner bound to test
- * @param within - the outer bound to test against
+ * @param bound - The inner bound to test.
+ * @param within - The outer bound to test against.
  * @returns `true` if both corners of `bound` are within `within`
  */
 export declare function isLatLngBoundWithinLatLngBound(bound: LatLngBound, within: LatLngBound): boolean;
@@ -318,9 +321,9 @@ export declare function isLatLngBoundWithinLatLngBound(bound: LatLngBound, withi
  * Checks whether a point lies within a bound. Handles bounds that wrap the antimeridian by checking
  * if the longitude falls on either side of the wrap.
  *
- * @param point - the point to test
- * @param within - the bound to test against
- * @returns `true` if the point is within the bound
+ * @param point - The point to test.
+ * @param within - The bound to test against.
+ * @returns `true` if the point is within the bound.
  *
  * @example
  * ```ts
@@ -341,9 +344,9 @@ export type OverlapsLatLngBoundFunction = LatLngBoundCheckFunction & {
 /**
  * Checks whether two bounds overlap each other.
  *
- * @param a - the first bound
- * @param b - the second bound
- * @returns `true` if the bounds overlap
+ * @param a - The first bound.
+ * @param b - The second bound.
+ * @returns `true` if the bounds overlap.
  */
 export declare function latLngBoundOverlapsLatLngBound(a: LatLngBound, b: LatLngBound): boolean;
 /**
@@ -351,14 +354,15 @@ export declare function latLngBoundOverlapsLatLngBound(a: LatLngBound, b: LatLng
  * overlaps the reference bound. Internally converts bounds to rectangles for overlap detection,
  * handling antimeridian wrapping.
  *
+ * @param bound - The reference bound to check overlap against.
+ * @returns Returns `true` if the input overlaps the reference bound.
+ *
  * @dbxUtil
  * @dbxUtilCategory value
  * @dbxUtilKind factory
  * @dbxUtilTags value, lat-lng, bound, overlap, decision, factory, geographic
  * @dbxUtilRelated is-within-lat-lng-bound-function, lat-lng-bound-overlaps-lat-lng-bound
  *
- * @param bound - the reference bound to check overlap against
- * @returns a function that returns `true` if the input overlaps the reference bound
  * @__NO_SIDE_EFFECTS__
  */
 export declare function overlapsLatLngBoundFunction(bound: LatLngBound): OverlapsLatLngBoundFunction;
@@ -371,7 +375,7 @@ export declare const TOTAL_SPAN_OF_LONGITUDE = 360;
  * where the left edge (-180 longitude) begins at x=360. This allows safe rectangle-based
  * overlap comparisons without worrying about antimeridian wrapping.
  *
- * @param bound - the geographic bound to convert
- * @returns a rectangle suitable for overlap calculations
+ * @param bound - The geographic bound to convert.
+ * @returns A rectangle suitable for overlap calculations.
  */
 export declare function boundToRectangle(bound: LatLngBound): Rectangle;

package/src/lib/value/build.d.ts

@@ -16,21 +16,21 @@ export interface BuildConfig<T extends object> {
     /**
      * Optional pre-existing partial object to build upon. If omitted, an empty object is used.
      */
-    base?: Building<T>;
+    readonly base?: Building<T>;
     /**
      * Function that mutates the base to populate it with the desired values.
      */
-    build: BuildFunction<T>;
+    readonly build: BuildFunction<T>;
 }
 /**
  * Convenience function for imperatively constructing an object of a specific type by mutating a base object via a build function.
  *
  * This is useful when building objects whose type is normally read-only, allowing incremental property assignment during construction.
  *
- * @param config - the build configuration containing the base object and build function
- * @param config.base - optional pre-existing partial object to build upon; defaults to an empty object
- * @param config.build - function that mutates the base object to populate it with desired values
- * @returns the fully constructed object of type T
+ * @param config - The build configuration containing the base object and build function.
+ * @param config.base - Optional pre-existing partial object to build upon; defaults to an empty object.
+ * @param config.build - Function that mutates the base object to populate it with desired values.
+ * @returns The fully constructed object of type T.
  *
  * @dbxUtil
  * @dbxUtilCategory value

package/src/lib/value/comparator.d.ts

@@ -11,8 +11,8 @@ export type EqualityComparatorFunction<T> = (a: T, b: T) => boolean;
  * When both are nullish, it uses strict equality (`===`), so `null === null` is `true`
  * but `null === undefined` is `false`.
  *
- * @param compare - the comparator to wrap
- * @returns a new comparator that handles nullish values safely before delegating to the wrapped comparator
+ * @param compare - The comparator to wrap.
+ * @returns A new comparator that handles nullish values safely before delegating to the wrapped comparator.
  *
  * @dbxUtil
  * @dbxUtilCategory value
@@ -27,6 +27,7 @@ export type EqualityComparatorFunction<T> = (a: T, b: T) => boolean;
  * safeCompare(null, null);  // true
  * safeCompare(null, undefined); // false
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function safeEqualityComparatorFunction<T>(compare: EqualityComparatorFunction<T>): EqualityComparatorFunction<Maybe<T>>;
@@ -36,10 +37,10 @@ export declare function safeEqualityComparatorFunction<T>(compare: EqualityCompa
  * Delegates to {@link safeEqualityComparatorFunction} internally, so nullish values are handled
  * without invoking the comparator.
  *
- * @param a - first value to compare
- * @param b - second value to compare
- * @param compare - the equality comparator for non-nullish values
- * @returns `true` if the values are considered equal
+ * @param a - First value to compare.
+ * @param b - Second value to compare.
+ * @param compare - The equality comparator for non-nullish values.
+ * @returns `true` if the values are considered equal.
  *
  * @dbxUtil
  * @dbxUtilCategory value
@@ -79,15 +80,16 @@ export type CompareEqualityWithValueFromItemsFunction<I, V> = ((a: Maybe<I>, b:
  * This is a convenience wrapper around {@link compareEqualityWithValueFromItemsFunctionFactory} that
  * accepts both the value reader and comparator in a single call.
  *
+ * @param readValues - Extracts the comparable value from each item.
+ * @param equalityComparator - Compares the extracted values for equality.
+ * @returns Compares two items by their extracted values.
+ *
  * @dbxUtil
  * @dbxUtilCategory value
  * @dbxUtilKind factory
  * @dbxUtilTags value, comparator, equality, factory, read
  * @dbxUtilRelated compare-equality-with-value-from-items-function-factory, safe-equality-comparator-function
  *
- * @param readValues - extracts the comparable value from each item
- * @param equalityComparator - compares the extracted values for equality
- * @returns a function that compares two items by their extracted values
  * @__NO_SIDE_EFFECTS__
  */
 export declare function compareEqualityWithValueFromItemsFunction<I, V>(readValues: ReadValueFunction<I, V>, equalityComparator: EqualityComparatorFunction<V>): CompareEqualityWithValueFromItemsFunction<I, V>;
@@ -101,8 +103,14 @@ export type CompareEqualityWithValueFromItemsFunctionFactory<I, V> = ((equalityC
  * The returned factory accepts different equality comparators, allowing reuse of the same value extraction logic
  * with varying comparison strategies.
  *
- * @param readValues - extracts the comparable value from each item
- * @returns a factory function that accepts an equality comparator and produces a comparison function
+ * @param readValues - Extracts the comparable value from each item.
+ * @returns A factory function that accepts an equality comparator and produces a comparison function.
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, comparator, equality, factory, read, reuse
+ * @dbxUtilRelated compare-equality-with-value-from-items-function, safe-equality-comparator-function
  *
  * @example
  * ```ts
@@ -115,12 +123,6 @@ export type CompareEqualityWithValueFromItemsFunctionFactory<I, V> = ((equalityC
  * fn(0, 1);           // false
  * ```
  *
- * @dbxUtil
- * @dbxUtilCategory value
- * @dbxUtilKind factory
- * @dbxUtilTags value, comparator, equality, factory, read, reuse
- * @dbxUtilRelated compare-equality-with-value-from-items-function, safe-equality-comparator-function
- *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function compareEqualityWithValueFromItemsFunctionFactory<I, V>(readValues: ReadValueFunction<I, V>): CompareEqualityWithValueFromItemsFunctionFactory<I, V>;

package/src/lib/value/cron.d.ts

@@ -14,8 +14,8 @@ export type CronExpression = string;
  * For values of 60 or more, the expression is split into hours and minutes (e.g., 90 minutes becomes
  * every 1 hour at minute 30), which means intervals won't be exactly N minutes apart.
  *
- * @param inputMinutes - interval in minutes between executions
- * @returns a cron expression string that approximates the requested interval
+ * @param inputMinutes - Interval in minutes between executions.
+ * @returns A cron expression string that approximates the requested interval.
  *
  * @example
  * ```ts

package/src/lib/value/decision.d.ts

@@ -18,8 +18,8 @@ export type DecisionFunctionFactory<C, I> = FactoryWithRequiredInput<DecisionFun
  *
  * Useful for providing a constant decision where a function is expected.
  *
- * @param decision - the constant boolean value to return
- * @returns a decision function that always returns the given boolean
+ * @param decision - The constant boolean value to return.
+ * @returns A decision function that always returns the given boolean.
  *
  * @dbxUtil
  * @dbxUtilCategory value
@@ -32,6 +32,7 @@ export type DecisionFunctionFactory<C, I> = FactoryWithRequiredInput<DecisionFun
  * const alwaysTrue = decisionFunction(true);
  * alwaysTrue('anything'); // true
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function decisionFunction<I>(decision: boolean): DecisionFunction<I>;
@@ -56,9 +57,9 @@ export declare const invertDecision: <F extends DecisionFunction<any>>(fn: F, in
  *
  * If the input is undefined, falls back to a constant function returning `defaultIfUndefined`.
  *
- * @param valueOrFunction - a boolean, decision function, or undefined
- * @param defaultIfUndefined - fallback boolean when the input is nullish (defaults to true)
- * @returns a {@link DecisionFunction} derived from the input
+ * @param valueOrFunction - Boolean constant, {@link DecisionFunction}, or undefined to use the default.
+ * @param defaultIfUndefined - Fallback boolean when the input is nullish (defaults to true)
+ * @returns A {@link DecisionFunction} derived from the input.
  *
  * @dbxUtil
  * @dbxUtilCategory value

package/src/lib/value/equal.d.ts

@@ -14,9 +14,9 @@ export type AreEqualContext<T = unknown> = (x: IterableOrValue<T>) => boolean;
  * Creates an {@link IsEqualContext} that captures a reference value and uses the provided comparator
  * to check whether subsequent values are equal to it.
  *
- * @param contextValue - the reference value to compare against
- * @param fn - the equality comparator
- * @returns a function that checks whether a given value equals the captured reference
+ * @param contextValue - The reference value to compare against.
+ * @param fn - The equality comparator.
+ * @returns Checks whether a given value equals the captured reference.
  *
  * @dbxUtil
  * @dbxUtilCategory value
@@ -32,6 +32,7 @@ export type AreEqualContext<T = unknown> = (x: IterableOrValue<T>) => boolean;
  * context(0);  // true
  * context(10); // false
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function isEqualContext<T>(contextValue: T, fn: EqualityComparatorFunction<T>): IsEqualContext<T>;
@@ -41,9 +42,9 @@ export declare function isEqualContext<T>(contextValue: T, fn: EqualityComparato
  *
  * Returns `true` only if every value in the input matches the context value according to the comparator.
  *
- * @param contextValue - the reference value to compare against
- * @param fn - the equality comparator
- * @returns a function that checks whether all input values equal the captured reference
+ * @param contextValue - The reference value to compare against.
+ * @param fn - The equality comparator.
+ * @returns Checks whether all input values equal the captured reference.
  *
  * @dbxUtil
  * @dbxUtilCategory value
@@ -59,6 +60,7 @@ export declare function isEqualContext<T>(contextValue: T, fn: EqualityComparato
  * context([0, 0, 0]); // true
  * context([0, 1, 2]); // false
  * ```
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function areEqualContext<T>(contextValue: T, fn: EqualityComparatorFunction<T>): AreEqualContext<T>;
@@ -68,9 +70,9 @@ export declare function areEqualContext<T>(contextValue: T, fn: EqualityComparat
  * Empty iterables and single-value inputs return `true` by default, since there is nothing to contradict equality.
  * Uses the first value as the reference and checks all remaining values against it.
  *
- * @param values - the values to compare
- * @param fn - the equality comparator
- * @returns `true` if all values are equal to each other, or if fewer than two values are provided
+ * @param values - The values to compare.
+ * @param fn - The equality comparator.
+ * @returns `true` if all values are equal to each other, or if fewer than two values are provided.
  *
  * @dbxUtil
  * @dbxUtilCategory value