@augment-vir/common 31.0.0 → 31.0.1

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

@@ -12,18 +12,9 @@ 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,18 +10,9 @@
  * ```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,13 +10,7 @@ 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,13 +14,7 @@ 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']}`
  * ```
  */
@@ -46,15 +40,9 @@ 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'}`
  * ```
  *
@@ -71,10 +59,7 @@ export function arrayToObject(inputArray, callback) {
                 return output;
             }
             else if (output) {
-                return [
-                    output.key,
-                    output.value,
-                ];
+                return [output.key, output.value];
             }
             else {
                 return undefined;
@@ -92,10 +77,7 @@ 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,18 +10,9 @@
  * ```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,18 +11,9 @@ 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,18 +12,9 @@
  * ```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,18 +13,9 @@ 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,18 +13,9 @@
  * ```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,18 +13,9 @@
  * ```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,17 +8,7 @@
  * ```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,17 +8,7 @@
  * ```ts
  * import {filterOutIndexes} from '@augment-vir/common';
  *
- * const result = filterOutIndexes(
- *     [
- *         'a',
- *         'b',
- *         '',
- *     ],
- *     [
- *         0,
- *         2,
- *     ],
- * );
+ * const result = filterOutIndexes(['a', 'b', ''], [0, 2]);
  * // result is `['b']`
  * ```
  *
@@ -43,11 +33,7 @@ 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,15 +9,7 @@
  * ```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};
@@ -42,13 +34,7 @@
  * 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,15 +9,7 @@
  * ```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};
@@ -42,13 +34,7 @@
  * 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,11 +9,7 @@
  * ```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,11 +9,7 @@
  * ```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,17 +13,7 @@ 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,17 +13,7 @@ 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,10 +12,7 @@
  * ```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,10 +14,7 @@ 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,17 +18,7 @@ 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,14 +16,8 @@ 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,14 +15,8 @@
  * // `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,14 +13,8 @@ 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,14 +13,8 @@ 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

@@ -91,67 +91,44 @@ export const logColors = await determineDefaultLogColors();
  */
 export const defaultLogColorConfig = {
     [LogColorKey.Bold]: {
-        colors: [
-            logColors.bold,
-        ],
+        colors: [logColors.bold],
         logType: LogOutputType.Standard,
     },
     [LogColorKey.Debug]: {
-        colors: [
-            logColors.debug,
-        ],
+        colors: [logColors.debug],
         logType: LogOutputType.Standard,
     },
     [LogColorKey.Faint]: {
-        colors: [
-            logColors.faint,
-        ],
+        colors: [logColors.faint],
         logType: LogOutputType.Standard,
     },
     [LogColorKey.Info]: {
-        colors: [
-            logColors.info,
-        ],
+        colors: [logColors.info],
         logType: LogOutputType.Standard,
     },
     [LogColorKey.Mutate]: {
-        colors: [
-            logColors.mutate,
-            logColors.bold,
-        ],
+        colors: [logColors.mutate, logColors.bold],
         logType: LogOutputType.Standard,
     },
     [LogColorKey.NormalWeight]: {
-        colors: [
-            logColors.normalWeight,
-        ],
+        colors: [logColors.normalWeight],
         logType: LogOutputType.Standard,
     },
     [LogColorKey.Plain]: { colors: [], logType: LogOutputType.Standard },
     [LogColorKey.Reset]: {
-        colors: [
-            logColors.reset,
-        ],
+        colors: [logColors.reset],
         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]: {
-        colors: [
-            logColors.warning,
-        ],
+        colors: [logColors.warning],
         logType: LogOutputType.Error,
     },
 };

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

@@ -32,31 +32,21 @@ 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({
@@ -64,32 +54,22 @@ 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
@@ -107,14 +87,11 @@ 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,10 +10,7 @@ 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];
@@ -32,10 +29,7 @@ export function diffObjects(object0, object1) {
             accum[0][objectKey] = diffOutput[0];
         }
         return accum;
-    }, [
-        {},
-        {},
-    ]);
+    }, [{}, {}]);
     if (!Object.keys(diffOutput[0]).length && !Object.keys(diffOutput[1]).length) {
         return [];
     }
@@ -53,10 +47,7 @@ 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];
@@ -72,10 +63,7 @@ export function diffArrays(array0, array1) {
             }
         }
         return accum;
-    }, [
-        [],
-        [],
-    ]);
+    }, [[], []]);
     if (!diffArrays[0].length && !diffArrays[1].length) {
         return [];
     }
@@ -99,10 +87,7 @@ areEqual = (value0, value1) => value0 === value1) {
         return [];
     }
     else {
-        return [
-            value0,
-            value1,
-        ];
+        return [value0, value1];
     }
 }
 const orderedValueDiffs = [

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

@@ -29,17 +29,14 @@ 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;
@@ -57,10 +54,7 @@ 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,16 +10,10 @@
  *
  * 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,16 +11,10 @@ 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']}`
  * ```
@@ -30,7 +24,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,10 +9,7 @@ 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,10 +17,7 @@ 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,16 +33,12 @@ 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.0.0",
+    "version": "31.0.1",
     "description": "A collection of augments, helpers types, functions, and classes for any JavaScript environment.",
     "keywords": [
         "augment",
@@ -39,8 +39,8 @@
         "test:web": "virmator --no-deps test web"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.0.0",
-        "@augment-vir/core": "^31.0.0",
+        "@augment-vir/assert": "^31.0.1",
+        "@augment-vir/core": "^31.0.1",
         "@date-vir/duration": "^7.0.1",
         "ansi-styles": "^6.2.1",
         "json5": "^2.2.3",