@augment-vir/common 29.3.0 → 30.0.1

package/dist/augments/number/digit.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A union of all single digits in base 10.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;

package/dist/augments/number/dimensions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A simple type for storing 2D dimensions.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Dimensions = {
+    width: number;
+    height: number;
+};
+/**
+ * A simple type for storing 3D dimensions.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Dimensions3d = {
+    width: number;
+    height: number;
+    depth: number;
+};

package/dist/augments/number/min-max.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type MinMax = {
+    min: number;
+    max: number;
+};
+/**
+ * Given a min and max, ensures that they are in correct order. Meaning, min is less than max. If
+ * that is not the case, values are swapped.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function ensureMinMax({ min, max }: MinMax): MinMax;

package/dist/augments/number/min-max.js

@@ -0,0 +1,16 @@
+/**
+ * Given a min and max, ensures that they are in correct order. Meaning, min is less than max. If
+ * that is not the case, values are swapped.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function ensureMinMax({ min, max }) {
+    if (min > max) {
+        return { min: max, max: min };
+    }
+    else {
+        return { min, max };
+    }
+}

package/dist/augments/number/number-conversion.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Converts the input into a number and returns `NaN` if the conversion fails. This handles more
+ * edge cases than just plain `Number(input)`.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @returns The converted number or `NaN`.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function toNumber(input: unknown): number;
+/**
+ * Converts the input into a number and throws an error if the conversion fails.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @returns The converted number
+ * @throws `TypeError` if the conversion resulted in `NaN`
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function toEnsuredNumber(input: unknown): number;
+/**
+ * Converts the input into a number and returns `undefined` if the conversion fails.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @returns The converted number or `undefined`.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function toMaybeNumber(input: unknown): number | undefined;

package/dist/augments/number/number-conversion.js

@@ -0,0 +1,56 @@
+import { removeCommas } from '../string/comma.js';
+/**
+ * Converts the input into a number and returns `NaN` if the conversion fails. This handles more
+ * edge cases than just plain `Number(input)`.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @returns The converted number or `NaN`.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function toNumber(input) {
+    if (typeof input === 'number') {
+        return input;
+    }
+    else if (typeof input === 'string') {
+        return Number(removeCommas(input));
+    }
+    else {
+        return Number(input);
+    }
+}
+/**
+ * Converts the input into a number and throws an error if the conversion fails.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @returns The converted number
+ * @throws `TypeError` if the conversion resulted in `NaN`
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function toEnsuredNumber(input) {
+    const maybeNumber = toMaybeNumber(input);
+    if (maybeNumber == undefined) {
+        throw new TypeError(`Cannot convert to a number: ${String(input)}`);
+    }
+    else {
+        return maybeNumber;
+    }
+}
+/**
+ * Converts the input into a number and returns `undefined` if the conversion fails.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @returns The converted number or `undefined`.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function toMaybeNumber(input) {
+    const numeric = toNumber(input);
+    if (isNaN(numeric)) {
+        return undefined;
+    }
+    else {
+        return numeric;
+    }
+}

package/dist/augments/number/round.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Round a value to the given number of decimal digits. If no decimal value is present, no rounding
+ * occurs.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {round} from '@augment-vir/common';
+ *
+ * // `result1` is `5.13`
+ * const result1 = round(5.125, {digits: 2});
+ * // `result2` is `5`
+ * const result2 = round(25, {digits: 2});
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function round(value: number, { digits }: {
+    digits: number;
+}): number;

package/dist/augments/number/round.js

@@ -0,0 +1,24 @@
+/**
+ * Round a value to the given number of decimal digits. If no decimal value is present, no rounding
+ * occurs.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {round} from '@augment-vir/common';
+ *
+ * // `result1` is `5.13`
+ * const result1 = round(5.125, {digits: 2});
+ * // `result2` is `5`
+ * const result2 = round(25, {digits: 2});
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function round(value, { digits }) {
+    const digitFactor = Math.pow(10, digits);
+    const multiplied = value * digitFactor;
+    return Number((Math.round(multiplied) / digitFactor).toFixed(digits));
+}

package/dist/augments/number/scientific.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Determines if the given number is so large that it requires scientific notation (`e`) when
+ * represented as a string.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {requiresScientificNotation} from '@augment-vir/common';
+ *
+ * requiresScientificNotation(5); // false
+ * requiresScientificNotation(999999999999999999999); // true
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function requiresScientificNotation(input: number): boolean;

package/dist/augments/number/scientific.js

@@ -0,0 +1,20 @@
+/**
+ * Determines if the given number is so large that it requires scientific notation (`e`) when
+ * represented as a string.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {requiresScientificNotation} from '@augment-vir/common';
+ *
+ * requiresScientificNotation(5); // false
+ * requiresScientificNotation(999999999999999999999); // true
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function requiresScientificNotation(input) {
+    return String(input).includes('e');
+}

package/dist/augments/number/truncate-number.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The default truncation prefixes for {@link truncateNumber}.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare const defaultTruncationSuffixes: readonly ["k", "M", "B", "T", "P", "E", "Z", "Y"];
+/**
+ * Truncates a number such that is will at a max have 6 (customizable) characters including suffix,
+ * decimal point, or comma.
+ *
+ * Default suffixes are in {@link defaultTruncationSuffixes}:
+ *
+ *     'k', // thousand
+ *     'M', // million
+ *     'B', // billion
+ *     'T', // trillion
+ *     'P', // peta-, quadrillion
+ *     'E', // exa- quintillion
+ *     'Z', // zetta- sextillion
+ *     'Y', // yotta- septillion
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {truncateNumber} from '@augment-vir/common';
+ *
+ * // `result` will be `'1M'`
+ * const result = truncateNumber(1_000_000);
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function truncateNumber(originalValue: Readonly<unknown>, { customSuffixes, maxLength, }?: Partial<{
+    customSuffixes: ReadonlyArray<string> | undefined;
+    maxLength: number | undefined;
+}>): string;

package/dist/{esm/augments → augments/number}/truncate-number.js

@@ -1,7 +1,16 @@
-import { addCommasToNumber, convertIntoNumber, doesRequireScientificNotation } from './common-number';
-import { typedSplit } from './common-string';
-import { safeMatch } from './regexp';
-const defaultTruncationSuffixes = [
+import { safeMatch } from '../regexp/match.js';
+import { addCommasToNumber } from '../string/comma.js';
+import { safeSplit } from '../string/split.js';
+import { toNumber } from './number-conversion.js';
+import { requiresScientificNotation } from './scientific.js';
+/**
+ * The default truncation prefixes for {@link truncateNumber}.
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export const defaultTruncationSuffixes = [
     'k', // thousand
     'M', // million
     'B', // billion
@@ -32,23 +41,22 @@ function combineBeforeAndAfterDot({ beforeDot, afterDot = '', maxLength, }) {
     return beforeDot;
 }
 function truncateBigNumber(numberAsString, suffixes, maxLength) {
-    const [beforeDot, afterDot,] = typedSplit(numberAsString, '.');
+    const [beforeDot, afterDot,] = safeSplit(numberAsString, '.');
     const withCommas = addCommasToNumber(beforeDot);
     const truncationDepth = safeMatch(withCommas, /,/g).length;
     const suffix = suffixes[truncationDepth - 1];
-    const [beforeComma, afterComma,] = typedSplit(withCommas, ',');
+    const [beforeComma, afterComma,] = safeSplit(withCommas, ',');
     const trailing = [
         afterComma,
         afterDot,
     ].join('');
     if (beforeComma.length + 1 > maxLength) {
         // will look like 0.9M
-        const minimumString = [
+        return [
             '0.',
             beforeComma[0],
             suffixes[truncationDepth],
         ].join('');
-        return minimumString;
     }
     else {
         const combined = combineBeforeAndAfterDot({
@@ -65,15 +73,16 @@ function truncateBigNumber(numberAsString, suffixes, maxLength) {
 const minScientificNotationLength = '1e+'.length;
 function truncateScientificNotation({ input, maxLength, }) {
     const valueString = String(input);
-    const [beforeExponent, rawExponent,] = typedSplit(valueString, 'e');
-    const exponent = rawExponent.replace(/^[\-\+]/, '');
+    const [beforeExponent, rawExponent,] = safeSplit(valueString, 'e');
+    const exponent = rawExponent.replace(/^[-+]/, '');
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const plusOrMinus = rawExponent[0];
     const eSuffix = [
         'e',
         plusOrMinus,
         exponent,
     ].join('');
-    const [beforeDot, afterDot,] = typedSplit(beforeExponent, '.');
+    const [beforeDot, afterDot,] = safeSplit(beforeExponent, '.');
     const minLength = exponent.length + minScientificNotationLength;
     if (minLength === maxLength) {
         // this will look like "4e+4" or "5e-234"
@@ -105,7 +114,7 @@ function truncateScientificNotation({ input, maxLength, }) {
     }
 }
 function handleSmallNumbers(numberAsString, maxLength) {
-    const [beforeDot, afterDot,] = typedSplit(addCommasToNumber(numberAsString), '.');
+    const [beforeDot, afterDot,] = safeSplit(addCommasToNumber(numberAsString), '.');
     if (beforeDot.length <= maxLength) {
         return combineBeforeAndAfterDot({
             beforeDot,
@@ -117,10 +126,10 @@ function handleSmallNumbers(numberAsString, maxLength) {
     return undefined;
 }
 /**
- * This truncates a number such that is will at a max have 6 characters including suffix, decimal
- * point, or comma.
+ * Truncates a number such that is will at a max have 6 (customizable) characters including suffix,
+ * decimal point, or comma.
  *
- * Default suffixes are:
+ * Default suffixes are in {@link defaultTruncationSuffixes}:
  *
  *     'k', // thousand
  *     'M', // million
@@ -130,15 +139,28 @@ function handleSmallNumbers(numberAsString, maxLength) {
  *     'E', // exa- quintillion
  *     'Z', // zetta- sextillion
  *     'Y', // yotta- septillion
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {truncateNumber} from '@augment-vir/common';
+ *
+ * // `result` will be `'1M'`
+ * const result = truncateNumber(1_000_000);
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
 export function truncateNumber(originalValue, { customSuffixes = defaultTruncationSuffixes, maxLength = 6, } = {}) {
-    const inputNumber = convertIntoNumber(originalValue);
+    const inputNumber = toNumber(originalValue);
     // handle edge cases
     if (isNaN(inputNumber) || inputNumber === Infinity) {
         return String(inputNumber);
     }
     // handle too big or too small edge cases
-    if (doesRequireScientificNotation(inputNumber)) {
+    if (requiresScientificNotation(inputNumber)) {
         return truncateScientificNotation({ input: inputNumber, maxLength });
     }
     const numberAsString = String(inputNumber);

package/dist/augments/number/wrap-number.d.ts

@@ -0,0 +1,19 @@
+import { MinMax } from './min-max.js';
+/**
+ * If the given value is outside the given min/max bounds, instead of clamping the number (as the
+ * {@link clamp} function does), this function wraps the value around to the next bound (inclusive).
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {wrapNumber} from '@augment-vir/common';
+ *
+ * wrapNumber({min: 0, max: 100, value: 101}); // 0
+ * wrapNumber({min: 0, max: 100, value: -1}); // 100
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function wrapNumber(value: number, minMax: Readonly<MinMax>): number;

package/dist/augments/number/wrap-number.js

@@ -0,0 +1,28 @@
+import { ensureMinMax } from './min-max.js';
+/**
+ * If the given value is outside the given min/max bounds, instead of clamping the number (as the
+ * {@link clamp} function does), this function wraps the value around to the next bound (inclusive).
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {wrapNumber} from '@augment-vir/common';
+ *
+ * wrapNumber({min: 0, max: 100, value: 101}); // 0
+ * wrapNumber({min: 0, max: 100, value: -1}); // 100
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function wrapNumber(value, minMax) {
+    const { min, max } = ensureMinMax(minMax);
+    if (value > max) {
+        return min;
+    }
+    else if (value < min) {
+        return max;
+    }
+    return value;
+}

package/dist/augments/object/diff.d.ts

@@ -0,0 +1,51 @@
+import { PartialDeep } from 'type-fest';
+/**
+ * Extract all nested object keys and values that are different between the two given objects.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @returns An empty tuple if the values are equal. Otherwise, the first tuple entry contains the
+ *   changes in the first value, second entry contains the changes in the second value.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function diffObjects<T0 extends Readonly<Record<PropertyKey, unknown>>, T1 extends Readonly<Record<PropertyKey, unknown>>>(object0: T0, object1: T1): [PartialDeep<T0>, PartialDeep<T1>] | [];
+/**
+ * Extract all entries in the given arrays that are not equal.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @returns An empty tuple if the values are equal. Otherwise, the first tuple entry contains the
+ *   changes in the first value, second entry contains the changes in the second value.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function diffArrays<T0, T1>(array0: ReadonlyArray<T0>, array1: ReadonlyArray<T1>): [Array<T0>, Array<T1>] | [];
+/**
+ * Callback for checking equality between two values that can be of different types.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type AreEqualCallback<T0, T1> = (value0: T0, value1: T1) => boolean;
+/**
+ * Simple diff check that is useful simply to return the same format as the other diff functions.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @returns An empty tuple if the values are equal. Otherwise, the first tuple entry contains the
+ *   changes in the first value, second entry contains the changes in the second value.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function diffBasic<T0, T1>(value0: T0, value1: T1, 
+/** A custom equality checker. Defaults to a strict equality check (`===`). */
+areEqual?: AreEqualCallback<T0, T1>): [T0, T1] | [];
+/**
+ * Diff any values. For diffing objects, use `diffObjects` to get better types.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @returns An empty tuple if the values are equal. Otherwise, the first tuple entry contains the
+ *   changes in the first value, second entry contains the changes in the second value.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function diffValues<T0, T1>(value0: T0, value1: T1): [T0, T1] | [];

package/dist/augments/object/diff.js

@@ -0,0 +1,149 @@
+import { check } from '@augment-vir/assert';
+import { getObjectTypedKeys } from '@augment-vir/core';
+/**
+ * Extract all nested object keys and values that are different between the two given objects.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @returns An empty tuple if the values are equal. Otherwise, the first tuple entry contains the
+ *   changes in the first value, second entry contains the changes in the second value.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function diffObjects(object0, object1) {
+    const allObjectKeys = Array.from(new Set([
+        ...getObjectTypedKeys(object0),
+        ...getObjectTypedKeys(object1),
+    ]));
+    const diffOutput = allObjectKeys.reduce((accum, objectKey) => {
+        const value0 = object0[objectKey];
+        const value1 = object1[objectKey];
+        const diffOutput = diffValues(value0, value1);
+        if (!diffOutput.length) {
+            return accum;
+        }
+        if (!(objectKey in object0)) {
+            accum[1][objectKey] = diffOutput[1];
+        }
+        else if (objectKey in object1) {
+            accum[0][objectKey] = diffOutput[0];
+            accum[1][objectKey] = diffOutput[1];
+        }
+        else {
+            accum[0][objectKey] = diffOutput[0];
+        }
+        return accum;
+    }, [
+        {},
+        {},
+    ]);
+    if (!Object.keys(diffOutput[0]).length && !Object.keys(diffOutput[1]).length) {
+        return [];
+    }
+    else {
+        return diffOutput;
+    }
+}
+/**
+ * Extract all entries in the given arrays that are not equal.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @returns An empty tuple if the values are equal. Otherwise, the first tuple entry contains the
+ *   changes in the first value, second entry contains the changes in the second value.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function diffArrays(array0, array1) {
+    const allArrayIndexes = Array.from(new Set([
+        ...Object.keys(array0),
+        ...Object.keys(array1),
+    ].map((index) => Number(index)))).sort();
+    const diffArrays = allArrayIndexes.reduce((accum, arrayIndex) => {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const value0 = array0[arrayIndex];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const value1 = array1[arrayIndex];
+        const diffOutput = diffValues(value0, value1);
+        if (diffOutput.length) {
+            if (arrayIndex in array0) {
+                accum[0].push(diffOutput[0]);
+            }
+            if (arrayIndex in array1) {
+                accum[1].push(diffOutput[1]);
+            }
+        }
+        return accum;
+    }, [
+        [],
+        [],
+    ]);
+    if (!diffArrays[0].length && !diffArrays[1].length) {
+        return [];
+    }
+    else {
+        return diffArrays;
+    }
+}
+/**
+ * Simple diff check that is useful simply to return the same format as the other diff functions.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @returns An empty tuple if the values are equal. Otherwise, the first tuple entry contains the
+ *   changes in the first value, second entry contains the changes in the second value.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function diffBasic(value0, value1, 
+/** A custom equality checker. Defaults to a strict equality check (`===`). */
+areEqual = (value0, value1) => value0 === value1) {
+    if (areEqual(value0, value1)) {
+        return [];
+    }
+    else {
+        return [
+            value0,
+            value1,
+        ];
+    }
+}
+const orderedValueDiffs = [
+    (value0, value1) => {
+        if (!check.isArray(value0) || !check.isArray(value1)) {
+            return undefined;
+        }
+        return diffArrays(value0, value1);
+    },
+    (value0, value1) => {
+        if (!check.instanceOf(value0, RegExp) || !check.instanceOf(value1, RegExp)) {
+            return undefined;
+        }
+        /** Special case RegExps because they should be checked for equality as strings. */
+        return diffBasic(value0, value1, (a, b) => String(a) === String(b));
+    },
+    (value0, value1) => {
+        if (!check.isObject(value0) || !check.isObject(value1)) {
+            return undefined;
+        }
+        return diffObjects(value0, value1);
+    },
+];
+/**
+ * Diff any values. For diffing objects, use `diffObjects` to get better types.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @returns An empty tuple if the values are equal. Otherwise, the first tuple entry contains the
+ *   changes in the first value, second entry contains the changes in the second value.
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function diffValues(value0, value1) {
+    let diffOutput = undefined;
+    orderedValueDiffs.some((differ) => {
+        diffOutput = differ(value0, value1);
+        return !!diffOutput;
+    });
+    if (diffOutput) {
+        return diffOutput;
+    }
+    /** Fallback to the basic diff. */
+    return diffBasic(value0, value1);
+}

package/dist/augments/object/empty.d.ts

@@ -0,0 +1,9 @@
+import { IsEmptyObject } from 'type-fest';
+/**
+ * Excludes empty objects from a union.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type ExcludeEmpty<T> = IsEmptyObject<T> extends true ? never : T;