@augment-vir/common 31.9.1 → 31.9.2

package/dist/augments/array/array-map.d.ts

@@ -12,9 +12,18 @@ import { Writable } from '../type/writable.js';
  * ```ts
  * import {typedMap} from '@augment-vir/common';
  *
- * const result = await typedMap([1, 2, 3, 4, 5], (value) => {
- *     return value + 1;
- * });
+ * const result = await typedMap(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         4,
+ *         5,
+ *     ],
+ *     (value) => {
+ *         return value + 1;
+ *     },
+ * );
  * ```
  *
  * @returns A new array (does not mutate).

package/dist/augments/array/array-map.js

@@ -10,9 +10,18 @@
  * ```ts
  * import {typedMap} from '@augment-vir/common';
  *
- * const result = await typedMap([1, 2, 3, 4, 5], (value) => {
- *     return value + 1;
- * });
+ * const result = await typedMap(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         4,
+ *         5,
+ *     ],
+ *     (value) => {
+ *         return value + 1;
+ *     },
+ * );
  * ```
  *
  * @returns A new array (does not mutate).

package/dist/augments/array/array-to-object.d.ts

@@ -10,7 +10,13 @@ import { type MaybePromise } from '@augment-vir/core';
  * ```ts
  * import {arrayToObject} from '@augment-vir/common';
  *
- * const result = arrayToObject(['a', 'b'], (value) => `key-${value}`);
+ * const result = arrayToObject(
+ *     [
+ *         'a',
+ *         'b',
+ *     ],
+ *     (value) => `key-${value}`,
+ * );
  * // result is `{key-a: ['a'], key-b: ['b']}`
  * ```
  */

package/dist/augments/array/array-to-object.js

@@ -14,7 +14,13 @@ import { filterMap } from './filter.js';
  * ```ts
  * import {arrayToObject} from '@augment-vir/common';
  *
- * const result = arrayToObject(['a', 'b'], (value) => `key-${value}`);
+ * const result = arrayToObject(
+ *     [
+ *         'a',
+ *         'b',
+ *     ],
+ *     (value) => `key-${value}`,
+ * );
  * // result is `{key-a: ['a'], key-b: ['b']}`
  * ```
  */
@@ -40,9 +46,15 @@ export function groupArrayBy(inputArray, callback) {
  * ```ts
  * import {arrayToObject} from '@augment-vir/common';
  *
- * const result = arrayToObject(['a', 'b'], (value) => {
- *     return {key: `key-${value}`, value};
- * });
+ * const result = arrayToObject(
+ *     [
+ *         'a',
+ *         'b',
+ *     ],
+ *     (value) => {
+ *         return {key: `key-${value}`, value};
+ *     },
+ * );
  * // result is `{key-a: 'a', key-b: 'b'}`
  * ```
  *
@@ -59,7 +71,10 @@ export function arrayToObject(inputArray, callback) {
                 return output;
             }
             else if (output) {
-                return [output.key, output.value];
+                return [
+                    output.key,
+                    output.value,
+                ];
             }
             else {
                 return undefined;
@@ -77,7 +92,10 @@ export function arrayToObject(inputArray, callback) {
                             return entry;
                         }
                         else {
-                            return [entry.key, entry.value];
+                            return [
+                                entry.key,
+                                entry.value,
+                            ];
                         }
                     }, check.isTruthy);
                     resolve(typedObjectFromEntries(entries));

package/dist/augments/array/awaited/awaited-filter.d.ts

@@ -10,9 +10,18 @@
  * ```ts
  * import {awaitedFilter} from '@augment-vir/common';
  *
- * const result = await awaitedFilter([1, 2, 3, 4, 5], async (value) => {
- *     return await Promise.resolve(value > 2);
- * });
+ * const result = await awaitedFilter(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         4,
+ *         5,
+ *     ],
+ *     async (value) => {
+ *         return await Promise.resolve(value > 2);
+ *     },
+ * );
  * ```
  *
  * @returns A new array (does not mutate).

package/dist/augments/array/awaited/awaited-filter.js

@@ -11,9 +11,18 @@ import { awaitedBlockingMap } from './awaited-map.js';
  * ```ts
  * import {awaitedFilter} from '@augment-vir/common';
  *
- * const result = await awaitedFilter([1, 2, 3, 4, 5], async (value) => {
- *     return await Promise.resolve(value > 2);
- * });
+ * const result = await awaitedFilter(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         4,
+ *         5,
+ *     ],
+ *     async (value) => {
+ *         return await Promise.resolve(value > 2);
+ *     },
+ * );
  * ```
  *
  * @returns A new array (does not mutate).

package/dist/augments/array/awaited/awaited-for-each.d.ts

@@ -12,9 +12,18 @@
  * ```ts
  * import {awaitedForEach} from '@augment-vir/common';
  *
- * await awaitedForEach([1, 2, 3, 4, 5], async (value) => {
- *     await Promise.resolve(value);
- * });
+ * await awaitedForEach(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         4,
+ *         5,
+ *     ],
+ *     async (value) => {
+ *         await Promise.resolve(value);
+ *     },
+ * );
  * ```
  *
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)

package/dist/augments/array/awaited/awaited-for-each.js

@@ -13,9 +13,18 @@ import { awaitedBlockingMap } from './awaited-map.js';
  * ```ts
  * import {awaitedForEach} from '@augment-vir/common';
  *
- * await awaitedForEach([1, 2, 3, 4, 5], async (value) => {
- *     await Promise.resolve(value);
- * });
+ * await awaitedForEach(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         4,
+ *         5,
+ *     ],
+ *     async (value) => {
+ *         await Promise.resolve(value);
+ *     },
+ * );
  * ```
  *
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)

package/dist/augments/array/awaited/awaited-map.d.ts

@@ -13,9 +13,18 @@
  * ```ts
  * import {awaitedBlockingMap} from '@augment-vir/common';
  *
- * const result = await awaitedBlockingMap([1, 2, 3, 4, 5], async (value) => {
- *     return await Promise.resolve(value);
- * });
+ * const result = await awaitedBlockingMap(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         4,
+ *         5,
+ *     ],
+ *     async (value) => {
+ *         return await Promise.resolve(value);
+ *     },
+ * );
  * ```
  *
  * @returns A new array (does not mutate).

package/dist/augments/array/awaited/awaited-map.js

@@ -13,9 +13,18 @@
  * ```ts
  * import {awaitedBlockingMap} from '@augment-vir/common';
  *
- * const result = await awaitedBlockingMap([1, 2, 3, 4, 5], async (value) => {
- *     return await Promise.resolve(value);
- * });
+ * const result = await awaitedBlockingMap(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         4,
+ *         5,
+ *     ],
+ *     async (value) => {
+ *         return await Promise.resolve(value);
+ *     },
+ * );
  * ```
  *
  * @returns A new array (does not mutate).

package/dist/augments/array/filter.d.ts

@@ -8,7 +8,17 @@
  * ```ts
  * import {filterOutIndexes} from '@augment-vir/common';
  *
- * const result = filterOutIndexes(['a', 'b', ''], [0, 2]);
+ * const result = filterOutIndexes(
+ *     [
+ *         'a',
+ *         'b',
+ *         '',
+ *     ],
+ *     [
+ *         0,
+ *         2,
+ *     ],
+ * );
  * // result is `['b']`
  * ```
  *

package/dist/augments/array/filter.js

@@ -8,7 +8,17 @@
  * ```ts
  * import {filterOutIndexes} from '@augment-vir/common';
  *
- * const result = filterOutIndexes(['a', 'b', ''], [0, 2]);
+ * const result = filterOutIndexes(
+ *     [
+ *         'a',
+ *         'b',
+ *         '',
+ *     ],
+ *     [
+ *         0,
+ *         2,
+ *     ],
+ * );
  * // result is `['b']`
  * ```
  *
@@ -33,7 +43,11 @@ export function filterOutIndexes(array, indexes) {
  * import {filterMap} from '@augment-vir/common';
  *
  * const result = filterMap(
- *     ['a', 'b', ''],
+ *     [
+ *         'a',
+ *         'b',
+ *         '',
+ *     ],
  *     // map callback
  *     (value) => {
  *         return `value-${value}`;

package/dist/augments/array/remove-duplicates.d.ts

@@ -9,7 +9,15 @@
  * ```ts
  * import {removeDuplicates} from '@augment-vir/common';
  *
- * const result = removeDuplicates([1, 1, 1, 1, 1, 2, 4]);
+ * const result = removeDuplicates([
+ *     1,
+ *     1,
+ *     1,
+ *     1,
+ *     1,
+ *     2,
+ *     4,
+ * ]);
  * // result is `[1, 2, 4]`
  *
  * const exampleEntry = {id: 5};
@@ -34,7 +42,13 @@
  * const exampleEntry = {id: 5};
  *
  * const result2 = removeDuplicates(
- *     [{id: 1}, {id: 1}, exampleEntry, exampleEntry, {id: 4}],
+ *     [
+ *         {id: 1},
+ *         {id: 1},
+ *         exampleEntry,
+ *         exampleEntry,
+ *         {id: 4},
+ *     ],
  *     (entry) => entry.id,
  * );
  * // result2 is `[{id: 1}, exampleEntry, {id: 4}]`

package/dist/augments/array/remove-duplicates.js

@@ -9,7 +9,15 @@
  * ```ts
  * import {removeDuplicates} from '@augment-vir/common';
  *
- * const result = removeDuplicates([1, 1, 1, 1, 1, 2, 4]);
+ * const result = removeDuplicates([
+ *     1,
+ *     1,
+ *     1,
+ *     1,
+ *     1,
+ *     2,
+ *     4,
+ * ]);
  * // result is `[1, 2, 4]`
  *
  * const exampleEntry = {id: 5};
@@ -34,7 +42,13 @@
  * const exampleEntry = {id: 5};
  *
  * const result2 = removeDuplicates(
- *     [{id: 1}, {id: 1}, exampleEntry, exampleEntry, {id: 4}],
+ *     [
+ *         {id: 1},
+ *         {id: 1},
+ *         exampleEntry,
+ *         exampleEntry,
+ *         {id: 4},
+ *     ],
  *     (entry) => entry.id,
  * );
  * // result2 is `[{id: 1}, exampleEntry, {id: 4}]`

package/dist/augments/array/repeat-array.d.ts

@@ -9,7 +9,11 @@
  * ```ts
  * import {repeatArray} from '@augment-vir/common';
  *
- * const result = repeatArray(3, ['a', 'b', 'c']);
+ * const result = repeatArray(3, [
+ *     'a',
+ *     'b',
+ *     'c',
+ * ]);
  * // result is `['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']`
  * ```
  *

package/dist/augments/array/repeat-array.js

@@ -9,7 +9,11 @@
  * ```ts
  * import {repeatArray} from '@augment-vir/common';
  *
- * const result = repeatArray(3, ['a', 'b', 'c']);
+ * const result = repeatArray(3, [
+ *     'a',
+ *     'b',
+ *     'c',
+ * ]);
  * // result is `['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']`
  * ```
  *

package/dist/augments/enum/enum-value-check.d.ts

@@ -13,7 +13,17 @@ import type { EnumBaseType } from '@augment-vir/core';
  *     B = 'b',
  * }
  *
- * const result = filterToEnumValues([1, 2, 3, 'a', 'b', MyEnum.A], MyEnum); // result is `[MyEnum.A, MyEnum.B, MyEnum.A]`
+ * const result = filterToEnumValues(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         'a',
+ *         'b',
+ *         MyEnum.A,
+ *     ],
+ *     MyEnum,
+ * ); // result is `[MyEnum.A, MyEnum.B, MyEnum.A]`
  * ```
  *
  * @returns A new array (does not mutate).

package/dist/augments/enum/enum-value-check.js

@@ -13,7 +13,17 @@ import { check } from '@augment-vir/assert';
  *     B = 'b',
  * }
  *
- * const result = filterToEnumValues([1, 2, 3, 'a', 'b', MyEnum.A], MyEnum); // result is `[MyEnum.A, MyEnum.B, MyEnum.A]`
+ * const result = filterToEnumValues(
+ *     [
+ *         1,
+ *         2,
+ *         3,
+ *         'a',
+ *         'b',
+ *         MyEnum.A,
+ *     ],
+ *     MyEnum,
+ * ); // result is `[MyEnum.A, MyEnum.B, MyEnum.A]`
  * ```
  *
  * @returns A new array (does not mutate).

package/dist/augments/error/combine-errors.d.ts

@@ -12,7 +12,10 @@
  * ```ts
  * import {combineErrors} from '@augment-vir/common';
  *
- * const result1 = combineErrors([new Error('message 1'), new Error('message 2')]); // result1 is a single error with the message 'message 1\nmessage 2'
+ * const result1 = combineErrors([
+ *     new Error('message 1'),
+ *     new Error('message 2'),
+ * ]); // result1 is a single error with the message 'message 1\nmessage 2'
  * ```
  *
  * @returns A single error.

package/dist/augments/error/combine-errors.js

@@ -14,7 +14,10 @@ import { extractErrorMessage } from '@augment-vir/core';
  * ```ts
  * import {combineErrors} from '@augment-vir/common';
  *
- * const result1 = combineErrors([new Error('message 1'), new Error('message 2')]); // result1 is a single error with the message 'message 1\nmessage 2'
+ * const result1 = combineErrors([
+ *     new Error('message 1'),
+ *     new Error('message 2'),
+ * ]); // result1 is a single error with the message 'message 1\nmessage 2'
  * ```
  *
  * @returns A single error.

package/dist/augments/json/append-json.js

@@ -18,7 +18,17 @@ import { copyThroughJson } from './copy-through-json.js';
  * // `result2` will be `[{a: 'a'}, {b: 'b'}, {a: 'q'}, 'r']`
  * const result2 = appendJson([{a: 'a'}], {b: 'b'}, {a: 'q'}, 'r');
  * // `result3` will be `['a', ['b', 'c'], 'd', 'e']`
- * const result3 = appendJson(['a'], [['b', 'c']], ['d'], 'e');
+ * const result3 = appendJson(
+ *     ['a'],
+ *     [
+ *         [
+ *             'b',
+ *             'c',
+ *         ],
+ *     ],
+ *     ['d'],
+ *     'e',
+ * );
  * ```
  *
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)

package/dist/augments/json/copy-through-json.d.ts

@@ -16,8 +16,14 @@ import { Jsonify, Writable } from 'type-fest';
  * // `copy2` will be `{map: {}, b: 'b'}`
  * const copy2 = copyThroughJson({
  *     map: new Map([
- *         ['q', 'r'],
- *         ['s', 't'],
+ *         [
+ *             'q',
+ *             'r',
+ *         ],
+ *         [
+ *             's',
+ *             't',
+ *         ],
  *     ]),
  *     b: 'b',
  * });

package/dist/augments/json/copy-through-json.js

@@ -15,8 +15,14 @@
  * // `copy2` will be `{map: {}, b: 'b'}`
  * const copy2 = copyThroughJson({
  *     map: new Map([
- *         ['q', 'r'],
- *         ['s', 't'],
+ *         [
+ *             'q',
+ *             'r',
+ *         ],
+ *         [
+ *             's',
+ *             't',
+ *         ],
  *     ]),
  *     b: 'b',
  * });

package/dist/augments/json/jsonify.d.ts

@@ -13,8 +13,14 @@ import { Jsonify } from 'type-fest';
  * // `result` is `{b: 'b'}`
  * const result = jsonify({
  *     map: new Map([
- *         ['q', 'r'],
- *         ['s', 't'],
+ *         [
+ *             'q',
+ *             'r',
+ *         ],
+ *         [
+ *             's',
+ *             't',
+ *         ],
  *     ]),
  *     b: 'b',
  * });

package/dist/augments/json/jsonify.js

@@ -13,8 +13,14 @@ import JSON5 from 'json5';
  * // `result` is `{b: 'b'}`
  * const result = jsonify({
  *     map: new Map([
- *         ['q', 'r'],
- *         ['s', 't'],
+ *         [
+ *             'q',
+ *             'r',
+ *         ],
+ *         [
+ *             's',
+ *             't',
+ *         ],
  *     ]),
  *     b: 'b',
  * });

package/dist/augments/log/log-colors.js

@@ -107,7 +107,10 @@ export const defaultLogColorConfig = {
         logType: LogOutputType.Standard,
     },
     [LogColorKey.Mutate]: {
-        colors: [logColors.mutate, logColors.bold],
+        colors: [
+            logColors.mutate,
+            logColors.bold,
+        ],
         logType: LogOutputType.Standard,
     },
     [LogColorKey.NormalWeight]: {
@@ -120,11 +123,17 @@ export const defaultLogColorConfig = {
         logType: LogOutputType.Standard,
     },
     [LogColorKey.Success]: {
-        colors: [logColors.success, logColors.bold],
+        colors: [
+            logColors.success,
+            logColors.bold,
+        ],
         logType: LogOutputType.Standard,
     },
     [LogColorKey.Error]: {
-        colors: [logColors.error, logColors.bold],
+        colors: [
+            logColors.error,
+            logColors.bold,
+        ],
         logType: LogOutputType.Error,
     },
     [LogColorKey.Warning]: {

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

@@ -32,21 +32,31 @@ function combineBeforeAndAfterDot({ beforeDot, afterDot = '', maxLength, }) {
             if (!Number(slicedAfterDot)) {
                 return beforeDot;
             }
-            return [beforeDot, slicedAfterDot].join('.');
+            return [
+                beforeDot,
+                slicedAfterDot,
+            ].join('.');
         }
     }
     return beforeDot;
 }
 function truncateBigNumber(numberAsString, suffixes, maxLength) {
-    const [beforeDot, afterDot] = safeSplit(numberAsString, '.');
+    const [beforeDot, afterDot,] = safeSplit(numberAsString, '.');
     const withCommas = addCommasToNumber(beforeDot);
     const truncationDepth = safeMatch(withCommas, /,/g).length;
     const suffix = suffixes[truncationDepth - 1];
-    const [beforeComma, afterComma] = safeSplit(withCommas, ',');
-    const trailing = [afterComma, afterDot].join('');
+    const [beforeComma, afterComma,] = safeSplit(withCommas, ',');
+    const trailing = [
+        afterComma,
+        afterDot,
+    ].join('');
     if (beforeComma.length + 1 > maxLength) {
         // will look like 0.9M
-        return ['0.', beforeComma[0], suffixes[truncationDepth]].join('');
+        return [
+            '0.',
+            beforeComma[0],
+            suffixes[truncationDepth],
+        ].join('');
     }
     else {
         const combined = combineBeforeAndAfterDot({
@@ -54,22 +64,32 @@ function truncateBigNumber(numberAsString, suffixes, maxLength) {
             afterDot: trailing,
             maxLength: maxLength - 1 /* -1 to account for the suffix*/,
         });
-        return [combined, suffix].join('');
+        return [
+            combined,
+            suffix,
+        ].join('');
     }
 }
 const minScientificNotationLength = '1e+'.length;
 function truncateScientificNotation({ input, maxLength, }) {
     const valueString = String(input);
-    const [beforeExponent, rawExponent] = safeSplit(valueString, 'e');
+    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] = safeSplit(beforeExponent, '.');
+    const eSuffix = [
+        'e',
+        plusOrMinus,
+        exponent,
+    ].join('');
+    const [beforeDot, afterDot,] = safeSplit(beforeExponent, '.');
     const minLength = exponent.length + minScientificNotationLength;
     if (minLength === maxLength) {
         // this will look like "4e+4" or "5e-234"
-        return [beforeDot, eSuffix].join('');
+        return [
+            beforeDot,
+            eSuffix,
+        ].join('');
     }
     else if (minLength > maxLength) {
         // in this case the number is either way too big or way to small for its exponent to fit within the max length so we just jump to 0 or Infinity
@@ -87,11 +107,14 @@ function truncateScientificNotation({ input, maxLength, }) {
             beforeDot,
             maxLength: maxLength - exponent.length + minScientificNotationLength,
         });
-        return [beforeE, eSuffix].join('');
+        return [
+            beforeE,
+            eSuffix,
+        ].join('');
     }
 }
 function handleSmallNumbers(numberAsString, maxLength) {
-    const [beforeDot, afterDot] = safeSplit(addCommasToNumber(numberAsString), '.');
+    const [beforeDot, afterDot,] = safeSplit(addCommasToNumber(numberAsString), '.');
     if (beforeDot.length <= maxLength) {
         return combineBeforeAndAfterDot({
             beforeDot,

package/dist/augments/object/diff.js

@@ -10,7 +10,10 @@ import { getObjectTypedKeys } from '@augment-vir/core';
  * @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 allObjectKeys = Array.from(new Set([
+        ...getObjectTypedKeys(object0),
+        ...getObjectTypedKeys(object1),
+    ]));
     const diffOutput = allObjectKeys.reduce((accum, objectKey) => {
         const value0 = object0[objectKey];
         const value1 = object1[objectKey];
@@ -29,7 +32,10 @@ export function diffObjects(object0, object1) {
             accum[0][objectKey] = diffOutput[0];
         }
         return accum;
-    }, [{}, {}]);
+    }, [
+        {},
+        {},
+    ]);
     if (!Object.keys(diffOutput[0]).length && !Object.keys(diffOutput[1]).length) {
         return [];
     }
@@ -47,7 +53,10 @@ export function diffObjects(object0, object1) {
  * @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 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];
@@ -63,7 +72,10 @@ export function diffArrays(array0, array1) {
             }
         }
         return accum;
-    }, [[], []]);
+    }, [
+        [],
+        [],
+    ]);
     if (!diffArrays[0].length && !diffArrays[1].length) {
         return [];
     }
@@ -87,7 +99,10 @@ areEqual = (value0, value1) => value0 === value1) {
         return [];
     }
     else {
-        return [value0, value1];
+        return [
+            value0,
+            value1,
+        ];
     }
 }
 const orderedValueDiffs = [

package/dist/augments/object/map-entries.js

@@ -29,14 +29,17 @@ export function mapObject(originalObject, mapCallback) {
     try {
         let gotAPromise = false;
         const mappedEntries = getObjectTypedEntries(originalObject)
-            .map(([originalKey, originalValue]) => {
+            .map(([originalKey, originalValue,]) => {
             const output = mapCallback(originalKey, originalValue, originalObject);
             if (output instanceof Promise) {
                 gotAPromise = true;
                 return output;
             }
             else if (output) {
-                return [output.key, output.value];
+                return [
+                    output.key,
+                    output.value,
+                ];
             }
             else {
                 return undefined;
@@ -54,7 +57,10 @@ export function mapObject(originalObject, mapCallback) {
                             return entry;
                         }
                         else {
-                            return [entry.key, entry.value];
+                            return [
+                                entry.key,
+                                entry.value,
+                            ];
                         }
                     }, check.isTruthy);
                     resolve(typedObjectFromEntries(entries));

package/dist/augments/object/merge-deep.js

@@ -30,7 +30,7 @@ export function mergeDeep(...inputs) {
             /** If result isn't an object then we need to make it into one. */
             result = { ...individualInput };
         }
-        Object.entries(individualInput).forEach(([key, value]) => {
+        Object.entries(individualInput).forEach(([key, value,]) => {
             if (!mergeProps[key]) {
                 mergeProps[key] = [];
             }
@@ -38,7 +38,7 @@ export function mergeDeep(...inputs) {
         });
     });
     if (check.isObject(result)) {
-        Object.entries(mergeProps).forEach(([key, mergeValues]) => {
+        Object.entries(mergeProps).forEach(([key, mergeValues,]) => {
             const newValue = mergeDeep(...mergeValues);
             if (newValue === undefined && key in result) {
                 delete result[key];

package/dist/augments/object/merge-defined-properties.js

@@ -22,7 +22,7 @@ export function mergeDefinedProperties(original, ...overrides) {
         if (!entry) {
             return;
         }
-        getObjectTypedEntries(entry).forEach(([key, value]) => {
+        getObjectTypedEntries(entry).forEach(([key, value,]) => {
             if (value != undefined) {
                 finalObject[key] = value;
             }

package/dist/augments/object/merge-property-arrays.d.ts

@@ -10,10 +10,16 @@
  *
  * mergePropertyArrays(
  *     {
- *         a: ['a', 'b'],
+ *         a: [
+ *             'a',
+ *             'b',
+ *         ],
  *     },
  *     {
- *         a: ['c', 'd'],
+ *         a: [
+ *             'c',
+ *             'd',
+ *         ],
  *     },
  * ); // output is `{a: ['a', 'b', 'c', 'd']}`
  * ```

package/dist/augments/object/merge-property-arrays.js

@@ -11,10 +11,16 @@ import { getOrSet } from './get-or-set.js';
  *
  * mergePropertyArrays(
  *     {
- *         a: ['a', 'b'],
+ *         a: [
+ *             'a',
+ *             'b',
+ *         ],
  *     },
  *     {
- *         a: ['c', 'd'],
+ *         a: [
+ *             'c',
+ *             'd',
+ *         ],
  *     },
  * ); // output is `{a: ['a', 'b', 'c', 'd']}`
  * ```
@@ -24,7 +30,7 @@ import { getOrSet } from './get-or-set.js';
 export function mergePropertyArrays(...inputs) {
     const combined = {};
     inputs.forEach((input) => {
-        Object.entries(input).forEach(([key, newArray]) => {
+        Object.entries(input).forEach(([key, newArray,]) => {
             const currentArray = getOrSet(combined, key, () => []);
             currentArray.push(...newArray);
         });

package/dist/augments/object/object-entries.js

@@ -9,7 +9,10 @@ import { getObjectTypedKeys } from '@augment-vir/core';
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
 export function getObjectTypedEntries(input) {
-    return getObjectTypedKeys(input).map((key) => [key, input[key]]);
+    return getObjectTypedKeys(input).map((key) => [
+        key,
+        input[key],
+    ]);
 }
 /**
  * Create an object from an array of entries. This is the same as

package/dist/augments/object/object-filter.js

@@ -20,7 +20,7 @@ import { getObjectTypedEntries, typedObjectFromEntries } from './object-entries.
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
 export function filterObject(inputObject, callback) {
-    const filteredEntries = getObjectTypedEntries(inputObject).filter(([key, value]) => {
+    const filteredEntries = getObjectTypedEntries(inputObject).filter(([key, value,]) => {
         return callback(key, value, inputObject);
     });
     return typedObjectFromEntries(filteredEntries);

package/dist/augments/regexp/regexp-flags.js

@@ -17,7 +17,10 @@ import { escapeStringForRegExp } from './regexp-string.js';
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
 export function addRegExpFlags(originalRegExpOrString, flags) {
-    const allFlags = removeDuplicateCharacters([typeof originalRegExpOrString === 'string' ? '' : originalRegExpOrString.flags, flags]
+    const allFlags = removeDuplicateCharacters([
+        typeof originalRegExpOrString === 'string' ? '' : originalRegExpOrString.flags,
+        flags,
+    ]
         .join('')
         .toLowerCase());
     return setRegExpFlags(originalRegExpOrString, allFlags);

package/dist/augments/string/comma.js

@@ -33,12 +33,16 @@ export function addCommasToNumber(input) {
     const numericValue = Number(input);
     const isNegative = numericValue < 0;
     const stringValue = String(Math.abs(numericValue));
-    const [digits = '', decimalValues] = stringValue.split('.');
+    const [digits = '', decimalValues,] = stringValue.split('.');
     const decimalString = decimalValues ? `.${decimalValues}` : '';
     const separated = safeMatch(digits.split('').reverse().join(''), /.{1,3}/g)
         .reverse()
         .map((entry) => entry.split('').reverse().join(''));
     const valueWithCommas = separated.join(',');
     const negativeMarker = isNegative ? '-' : '';
-    return [negativeMarker, valueWithCommas, decimalString].join('');
+    return [
+        negativeMarker,
+        valueWithCommas,
+        decimalString,
+    ].join('');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/common",
-    "version": "31.9.1",
+    "version": "31.9.2",
     "description": "A collection of augments, helpers types, functions, and classes for any JavaScript environment.",
     "keywords": [
         "augment",
@@ -39,24 +39,24 @@
         "test:web": "virmator --no-deps test web"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.9.1",
-        "@augment-vir/core": "^31.9.1",
-        "@date-vir/duration": "^7.1.2",
+        "@augment-vir/assert": "^31.9.2",
+        "@augment-vir/core": "^31.9.2",
+        "@date-vir/duration": "^7.2.0",
         "ansi-styles": "^6.2.1",
         "json5": "^2.2.3",
-        "type-fest": "^4.33.0",
+        "type-fest": "^4.35.0",
         "typed-event-target": "^4.0.2"
     },
     "devDependencies": {
-        "@web/dev-server-esbuild": "^1.0.3",
-        "@web/test-runner": "^0.19.0",
+        "@web/dev-server-esbuild": "^1.0.4",
+        "@web/test-runner": "^0.20.0",
         "@web/test-runner-commands": "^0.9.0",
         "@web/test-runner-playwright": "^0.11.0",
         "@web/test-runner-visual-regression": "^0.10.0",
         "concurrently": "^9.1.2",
         "execute-in-browser": "^1.0.4",
         "istanbul-smart-text-reporter": "^1.1.5",
-        "typescript": "^5.7.2"
+        "typescript": "^5.7.3"
     },
     "engines": {
         "node": ">=22"