@augment-vir/common 4.6.1 → 5.0.1

package/dist/{augments → cjs/augments}/array.d.ts

@@ -4,14 +4,7 @@ export declare function filterOutIndexes<T>(array: ReadonlyArray<T>, indexes: Re
 export declare function flatten2dArray<T>(array2d: ReadonlyArray<ReadonlyArray<T>>): T[];
 export declare type AtLeastOneEntryArray<ArrayGeneric extends ReadonlyArray<any>> = AtLeastTuple<ArrayElement<ArrayGeneric>, 1>;
 export declare function trimArrayStrings(input: ReadonlyArray<string>): string[];
-/**
- * Acts like calling Array.prototype.forEach in that all elements are executed upon in order, and
- * each execution is blocking. Meaning, the callback won't be called on element 2 until the callback
- * has finished its call on element 1.
- */
-export declare function awaitedForEach<OriginalGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => void | PromiseLike<void>): Promise<void>;
-export declare function awaitedBlockingMap<OriginalGeneric, MappedGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => MappedGeneric | PromiseLike<MappedGeneric>): Promise<Awaited<MappedGeneric>[]>;
-export declare function isInTypedArray<T>(array: ReadonlyArray<T>, input: any): input is T;
+export declare function typedArrayIncludes<T>(array: ReadonlyArray<T>, input: unknown): input is T;
 declare type MapCallbackType<ArrayType extends ReadonlyArray<any>, OutputType> = (value: ArrayElement<ArrayType>, index: number, array: ArrayType) => OutputType;
 /** Preserves tuple types. */
 export declare function typedMap<InputArrayGeneric extends ReadonlyArray<any>, OutputType>(arrayToMap: InputArrayGeneric, mapCallback: MapCallbackType<InputArrayGeneric, OutputType>): {

package/dist/cjs/augments/array.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedMap = exports.typedArrayIncludes = exports.trimArrayStrings = exports.flatten2dArray = exports.filterOutIndexes = void 0;
+function filterOutIndexes(array, indexes) {
+    return array.filter((_, index) => !indexes.includes(index));
+}
+exports.filterOutIndexes = filterOutIndexes;
+function flatten2dArray(array2d) {
+    const flattened = array2d.reduce((accum, row) => accum.concat(row), []);
+    return flattened;
+}
+exports.flatten2dArray = flatten2dArray;
+function trimArrayStrings(input) {
+    return input.map((line) => line.trim()).filter((line) => line !== '');
+}
+exports.trimArrayStrings = trimArrayStrings;
+function typedArrayIncludes(array, input) {
+    return array.includes(input);
+}
+exports.typedArrayIncludes = typedArrayIncludes;
+/** Preserves tuple types. */
+function typedMap(arrayToMap, mapCallback) {
+    return arrayToMap.map(mapCallback);
+}
+exports.typedMap = typedMap;

package/dist/cjs/augments/async.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Acts like calling Array.prototype.forEach in that all elements are executed upon in order, and
+ * each execution is blocking. Meaning, the callback won't be called on element 2 until the callback
+ * has finished its call on element 1.
+ */
+export declare function awaitedForEach<OriginalGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => void | PromiseLike<void>): Promise<void>;
+export declare function awaitedBlockingMap<OriginalGeneric, MappedGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => MappedGeneric | PromiseLike<MappedGeneric>): Promise<Awaited<MappedGeneric>[]>;
+export declare function awaitedFilter<OriginalGeneric>(arrayInput: ReadonlyArray<OriginalGeneric>, filterCallback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => Promise<unknown>, options?: {
+    /**
+     * Each call to the filter callback is blocking, meaning the next one won't start until the
+     * current one finishes. By default this is false.
+     */
+    blocking?: boolean | undefined;
+}): Promise<OriginalGeneric[]>;

package/dist/cjs/augments/async.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awaitedFilter = exports.awaitedBlockingMap = exports.awaitedForEach = void 0;
+/**
+ * Acts like calling Array.prototype.forEach in that all elements are executed upon in order, and
+ * each execution is blocking. Meaning, the callback won't be called on element 2 until the callback
+ * has finished its call on element 1.
+ */
+async function awaitedForEach(input, callback) {
+    await awaitedBlockingMap(input, callback);
+}
+exports.awaitedForEach = awaitedForEach;
+async function awaitedBlockingMap(input, callback) {
+    const mappedValues = await input.reduce(async (accumPromise, currentElement, index, wholeArray) => {
+        const accum = await accumPromise;
+        const mappedValue = await callback(currentElement, index, wholeArray);
+        accum.push(mappedValue);
+        return accum;
+    }, Promise.resolve([]));
+    return mappedValues;
+}
+exports.awaitedBlockingMap = awaitedBlockingMap;
+async function awaitedFilter(arrayInput, filterCallback, options) {
+    const callbackResults = (options === null || options === void 0 ? void 0 : options.blocking)
+        ? await awaitedBlockingMap(arrayInput, filterCallback)
+        : await Promise.all(arrayInput.map(filterCallback));
+    return arrayInput.filter((originalValue, index) => !!callbackResults[index]);
+}
+exports.awaitedFilter = awaitedFilter;

package/dist/{augments/number.d.ts → cjs/augments/common-number.d.ts}

@@ -1,3 +1,4 @@
+export declare function addCommasToNumber(input: number): string;
 export declare function clamp(
 /**
  * This uses a destructured object so that consumers cannot get confused as to which input is
@@ -9,8 +10,8 @@ export declare function clamp(
     max: number;
 }): number;
 /**
- * This truncates a number such that is will never use commas and will at a max have 6 characters
- * including suffix and decimal point.
+ * This truncates a number such that is will at a max have 6 characters including suffix, decimal
+ * point, or comma.
  *
  * Default suffixes are:
  *
@@ -24,4 +25,8 @@ export declare function clamp(
  *     'Z', // zetta- sextillion
  *     'Y', // yotta- septillion
  */
-export declare function truncateNumber(originalValue: unknown, suffixes?: ReadonlyArray<string>): string;
+export declare function truncateNumber(originalValue: unknown, { customSuffixes, suppressErrorLogging, customErrorLogCallback, }?: {
+    customSuffixes?: ReadonlyArray<string>;
+    suppressErrorLogging?: boolean;
+    customErrorLogCallback?: (...args: any) => void;
+}): string;

package/dist/{augments/number.js → cjs/augments/common-number.js}

@@ -1,6 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.truncateNumber = exports.clamp = void 0;
+exports.truncateNumber = exports.clamp = exports.addCommasToNumber = void 0;
+const common_string_1 = require("./common-string");
+const regexp_1 = require("./regexp");
+function addCommasToNumber(input) {
+    const stringValue = String(input);
+    const [digits, decimalValues,] = stringValue.split('.');
+    const decimalString = decimalValues ? `.${decimalValues}` : '';
+    const separated = (0, regexp_1.safeMatch)(digits.split('').reverse().join(''), /.{1,3}/g)
+        .reverse()
+        .map((entry) => entry.split('').reverse().join(''));
+    const withCommas = separated.join(',');
+    return `${withCommas}${decimalString}`;
+}
+exports.addCommasToNumber = addCommasToNumber;
 function clamp(
 /**
  * This uses a destructured object so that consumers cannot get confused as to which input is
@@ -22,16 +35,16 @@ const defaultTruncationSuffixes = [
     'Y', // yotta- septillion
 ];
 function recursiveTruncation(value, recursionDepth = 0, decimalValues = '') {
-    var _a, _b;
+    var _a;
     if (value.includes('e+')) {
         throw new Error(`Number is too large, it cannot be truncated: ${value}`);
     }
     else if (value.includes('e-')) {
         throw new Error(`Number is too small, it cannot be truncated: ${value}`);
     }
-    const split = value.split('.');
+    const split = (0, common_string_1.typedSplit)(value, '.');
     decimalValues = (_a = split[1]) !== null && _a !== void 0 ? _a : decimalValues;
-    const amount = (_b = split[0]) !== null && _b !== void 0 ? _b : '';
+    const amount = split[0];
     if (amount.length > 3) {
         decimalValues = amount.slice(-3);
         return recursiveTruncation(amount.slice(0, -3), recursionDepth + 1, decimalValues);
@@ -44,8 +57,8 @@ function recursiveTruncation(value, recursionDepth = 0, decimalValues = '') {
 }
 const maxDecimals = 4;
 /**
- * This truncates a number such that is will never use commas and will at a max have 6 characters
- * including suffix and decimal point.
+ * This truncates a number such that is will at a max have 6 characters including suffix, decimal
+ * point, or comma.
  *
  * Default suffixes are:
  *
@@ -59,13 +72,19 @@ const maxDecimals = 4;
  *     'Z', // zetta- sextillion
  *     'Y', // yotta- septillion
  */
-function truncateNumber(originalValue, suffixes = defaultTruncationSuffixes) {
+function truncateNumber(originalValue, { customSuffixes, suppressErrorLogging, customErrorLogCallback, } = {}) {
     try {
-        const value = typeof originalValue === 'number' ? originalValue : Number(originalValue);
+        const value = typeof originalValue === 'number'
+            ? originalValue
+            : typeof originalValue === 'string'
+                ? Number((0, common_string_1.removeCommasFromNumberString)(originalValue))
+                : Number(originalValue);
         if (isNaN(value)) {
             throw new Error(`${originalValue} could not be converted into a number.`);
         }
-        const results = recursiveTruncation(String(value));
+        const stringValue = String(value);
+        const results = recursiveTruncation(stringValue);
+        const suffixes = customSuffixes !== null && customSuffixes !== void 0 ? customSuffixes : defaultTruncationSuffixes;
         const suffix = suffixes[results.recursionDepth];
         if (suffix === undefined) {
             throw new Error(`Number is too large, could not truncate: ${value}`);
@@ -73,10 +92,19 @@ function truncateNumber(originalValue, suffixes = defaultTruncationSuffixes) {
         const decimalPlaces = maxDecimals - (results.value.length - 1) - suffix.length;
         const decimalValues = results.decimalValues.replace(/0+$/, '').slice(0, decimalPlaces);
         const withDecimal = decimalValues.length ? `.${decimalValues}` : '';
-        return `${results.value}${withDecimal}${suffix}`;
+        const combined = `${results.value}${withDecimal}${suffix}`;
+        if (combined.length > stringValue.length + 1) {
+            return addCommasToNumber(value);
+        }
+        else {
+            return combined;
+        }
     }
     catch (error) {
-        console.error(error);
+        const errorCallback = customErrorLogCallback ? customErrorLogCallback : console.error;
+        if (!suppressErrorLogging) {
+            errorCallback(error);
+        }
         return String(originalValue);
     }
 }

package/dist/{augments/string.d.ts → cjs/augments/common-string.d.ts}

@@ -1,3 +1,4 @@
+import { AtLeastTuple } from './tuple';
 /**
  * Join elements into a string with commas separating each value. Add a conjunction before the final
  * item in the list. If the array has a length < 2, the conjunction is not added. If the list is
@@ -18,7 +19,7 @@ export declare function splitIncludeSplit(original: string, splitterInput: strin
 export declare type CasingOptions = {
     capitalizeFirstLetter: boolean;
 };
-export declare function capitalizeFirstLetter(input: string): string;
+export declare function capitalizeFirstLetter<InputGeneric extends string>(input: InputGeneric): Capitalize<InputGeneric>;
 export declare function kebabCaseToCamelCase(rawKebabCase: string, casingOptions?: Partial<CasingOptions> | undefined): string;
 export declare function camelCaseToKebabCase(rawCamelCase: string): string;
 export declare function replaceStringAtIndex(originalString: string, start: number, newString: string, length?: number): string;
@@ -27,8 +28,17 @@ export declare function replaceStringAtIndex(originalString: string, start: numb
  * parsed as RegExp syntax.
  */
 export declare function escapeStringForRegExp(input: string): string;
-export declare function getAllIndexesOf(searchIn: string, searchForInput: string | RegExp, caseSensitive: boolean, includeLength: true): {
+export declare function getAllIndexesOf<IncludeLength extends boolean | undefined>({ searchIn, searchFor, caseSensitive, includeLength, }: {
+    searchIn: string;
+    searchFor: string | RegExp;
+    /**
+     * CaseSensitive only applies when the input is a string. Otherwise, the RegExp's "i" flag is
+     * used to determine case sensitivity.
+     */
+    caseSensitive: boolean;
+    includeLength?: IncludeLength;
+}): IncludeLength extends true ? {
     index: number;
     length: number;
-}[];
-export declare function getAllIndexesOf(searchIn: string, searchForInput: string | RegExp, caseSensitive: boolean, includeLength?: false | undefined): number[];
+}[] : number[];
+export declare function typedSplit(input: string, splitString: string): AtLeastTuple<string, 1>;

package/dist/{augments/string.js → cjs/augments/common-string.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllIndexesOf = exports.escapeStringForRegExp = exports.replaceStringAtIndex = exports.camelCaseToKebabCase = exports.kebabCaseToCamelCase = exports.capitalizeFirstLetter = exports.splitIncludeSplit = exports.collapseWhiteSpace = exports.removeCommasFromNumberString = exports.removeColor = exports.removeAnsiEscapeCodes = exports.joinWithFinalConjunction = void 0;
+exports.typedSplit = exports.getAllIndexesOf = exports.escapeStringForRegExp = exports.replaceStringAtIndex = exports.camelCaseToKebabCase = exports.kebabCaseToCamelCase = exports.capitalizeFirstLetter = exports.splitIncludeSplit = exports.collapseWhiteSpace = exports.removeCommasFromNumberString = exports.removeColor = exports.removeAnsiEscapeCodes = exports.joinWithFinalConjunction = void 0;
 const ansi_1 = require("./ansi");
 const regexp_1 = require("./regexp");
 /**
@@ -48,7 +48,12 @@ function collapseWhiteSpace(input) {
 exports.collapseWhiteSpace = collapseWhiteSpace;
 /** Same as String.prototype.split but includes the delimiter to split by in the output array. */
 function splitIncludeSplit(original, splitterInput, caseSensitive) {
-    const indexLengths = getAllIndexesOf(original, splitterInput, caseSensitive, true);
+    const indexLengths = getAllIndexesOf({
+        searchIn: original,
+        searchFor: splitterInput,
+        caseSensitive,
+        includeLength: true,
+    });
     const splitter = makeCaseInsensitiveRegExp(splitterInput, caseSensitive);
     const splits = original.split(splitter);
     const splitterIncluded = splits.reduce((accum, current, index) => {
@@ -70,15 +75,14 @@ const defaultCasingOptions = {
     capitalizeFirstLetter: false,
 };
 function capitalizeFirstLetter(input) {
-    var _a;
     if (!input.length) {
         return '';
     }
-    const firstLetter = (_a = input[0]) !== null && _a !== void 0 ? _a : '';
-    return firstLetter.toUpperCase() + input.slice(1);
+    const firstLetter = input[0];
+    return (firstLetter.toUpperCase() + input.slice(1));
 }
 exports.capitalizeFirstLetter = capitalizeFirstLetter;
-function maybeCapitalize(input, casingOptions = defaultCasingOptions) {
+function maybeCapitalize(input, casingOptions) {
     return casingOptions.capitalizeFirstLetter ? capitalizeFirstLetter(input) : input;
 }
 function kebabCaseToCamelCase(rawKebabCase, casingOptions = defaultCasingOptions) {
@@ -109,9 +113,8 @@ function camelCaseToKebabCase(rawCamelCase) {
     const kebabCase = rawCamelCase
         .split('')
         .reduce((accum, currentLetter, index, originalString) => {
-        var _a, _b;
-        const previousLetter = index > 0 ? (_a = originalString[index - 1]) !== null && _a !== void 0 ? _a : '' : '';
-        const nextLetter = index < originalString.length ? (_b = originalString[index + 1]) !== null && _b !== void 0 ? _b : '' : '';
+        const previousLetter = index > 0 ? originalString[index - 1] : '';
+        const nextLetter = index < originalString.length - 1 ? originalString[index + 1] : '';
         const possibleWordBoundary = isLowerCase(previousLetter) || isLowerCase(nextLetter);
         if (currentLetter === currentLetter.toLowerCase() ||
             index === 0 ||
@@ -148,45 +151,45 @@ function makeCaseInsensitiveRegExp(searchForInput, caseSensitive) {
         : new RegExp(escapeStringForRegExp(searchForInput), regExpFlags);
     return searchFor;
 }
-function getAllIndexesOf(searchIn, searchForInput, 
-/**
- * CaseSensitive only applies when the input is a string. Otherwise, the RegExp's "i" flag is
- * used to determine case sensitivity.
- */
-caseSensitive, includeLength = false) {
-    const searchFor = makeCaseInsensitiveRegExp(searchForInput, caseSensitive);
+function getAllIndexesOf({ searchIn, searchFor, caseSensitive, includeLength, }) {
+    const searchRegExp = makeCaseInsensitiveRegExp(searchFor, caseSensitive);
     const indexes = [];
     const indexesAndLengths = [];
-    searchIn.replace(searchFor, (...matchResults) => {
+    searchIn.replace(searchRegExp, (...matchResults) => {
         /**
          * Grabbing the second to last entry in the array (rather than the second) takes capture
          * groups into account.
          */
         const matchIndex = matchResults[matchResults.length - 2];
+        // this is used as a type safety catch and cannot actually be triggered on purpose
+        // istanbul ignore next
         if (typeof matchIndex !== 'number') {
-            throw new Error(`Match index "${matchIndex}" is not a number. Searching for "${searchForInput}" in "${searchIn}".`);
+            throw new Error(`Match index "${matchIndex}" is not a number. Searching for "${searchFor}" in "${searchIn}".`);
         }
         const regExpMatch = matchResults[0];
+        // this is used as a type safety catch and cannot actually be triggered on purpose
+        // istanbul ignore next
         if (typeof regExpMatch !== 'string') {
             throw new Error(`regExpMatch should've been a string but was ${typeof regExpMatch}!`);
         }
         indexesAndLengths.push({ index: matchIndex, length: regExpMatch.length });
         indexes.push(matchIndex);
         const originalMatch = matchResults[0];
+        // this is used as a type safety catch and cannot actually be triggered on purpose
+        // istanbul ignore next
         if (typeof originalMatch !== 'string') {
-            throw new Error(`Original match when searching for "${searchForInput}" in "${searchIn}" at index ${matchIndex} is not a string.`);
+            throw new Error(`Original match when searching for "${searchFor}" in "${searchIn}" at index ${matchIndex} is not a string.`);
         }
         /**
-         * Don't actually change any text. What we do here doesn't matter because we're not using
-         * the output of the .replace method, we're just producing side effects.
+         * Don't actually change any text. What we do here doesn't matter because we're not
+         * using the output of the .replace method, we're just producing side effects.
          */
         return originalMatch;
     });
-    if (includeLength) {
-        return indexesAndLengths;
-    }
-    else {
-        return indexes;
-    }
+    return (includeLength ? indexesAndLengths : indexes);
 }
 exports.getAllIndexesOf = getAllIndexesOf;
+function typedSplit(input, splitString) {
+    return input.split(splitString);
+}
+exports.typedSplit = typedSplit;

package/dist/{augments → cjs/augments}/date.d.ts

@@ -15,7 +15,7 @@ export declare function createDateFromSlashFormat(slashFormatString: string, yea
 /**
  * @param commaFormatString Should be at string of the form "monthName dayNumber, fullYear" Example:
  *   "May 19, 2005"
- * @param ignoreInvalidMonth Set to true to ignore invalid months
+ * @param ignoreInvalidMonth Set to true to ignore invalid months and just use the current UTC month
  */
 export declare function createDateFromNamedCommaFormat(commaFormatString: string, ignoreInvalidMonth?: boolean): Date;
 /**

package/dist/{augments → cjs/augments}/date.js

@@ -44,7 +44,7 @@ exports.createDateFromSlashFormat = createDateFromSlashFormat;
 /**
  * @param commaFormatString Should be at string of the form "monthName dayNumber, fullYear" Example:
  *   "May 19, 2005"
- * @param ignoreInvalidMonth Set to true to ignore invalid months
+ * @param ignoreInvalidMonth Set to true to ignore invalid months and just use the current UTC month
  */
 function createDateFromNamedCommaFormat(commaFormatString, ignoreInvalidMonth = false) {
     const [monthName, dayNumber, fullYear,] = commaFormatString.replace(',', '').split(' ');
@@ -56,7 +56,7 @@ function createDateFromNamedCommaFormat(commaFormatString, ignoreInvalidMonth =
     let monthIndex = longMonthIndex === -1 ? shortMonthIndex : longMonthIndex;
     if (monthIndex === -1) {
         if (ignoreInvalidMonth) {
-            monthIndex = 4;
+            monthIndex = new Date().getUTCMonth();
         }
         else {
             throw new InvalidDateError(`Month name ${monthName} was not found.`);

package/dist/cjs/augments/environment.d.ts

@@ -0,0 +1 @@
+export declare function isBrowser(): boolean;

package/dist/cjs/augments/environment.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowser = void 0;
+function isBrowser() {
+    return typeof window !== 'undefined';
+}
+exports.isBrowser = isBrowser;

package/dist/{augments → cjs/augments}/type-of.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTypeOfWithArray = exports.typeOfWithArray = void 0;
+// this function is not used at run time, it's only here for types
+// istanbul ignore next
 function getTypeOf(x) {
     return typeof x;
 }

package/dist/{index.d.ts → cjs/index.d.ts}

@@ -1,14 +1,15 @@
 export * from './augments/ansi';
 export * from './augments/array';
+export * from './augments/async';
+export * from './augments/common-number';
+export * from './augments/common-string';
 export * from './augments/date';
+export * from './augments/environment';
 export * from './augments/error';
 export * from './augments/function';
-export * from './augments/number';
 export * from './augments/object';
 export * from './augments/promise';
 export * from './augments/regexp';
-export * from './augments/string';
 export * from './augments/tuple';
 export * from './augments/type';
 export * from './augments/type-of';
-export * from './augments/type-test';

package/dist/{index.js → cjs/index.js}

@@ -16,15 +16,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./augments/ansi"), exports);
 __exportStar(require("./augments/array"), exports);
+__exportStar(require("./augments/async"), exports);
+__exportStar(require("./augments/common-number"), exports);
+__exportStar(require("./augments/common-string"), exports);
 __exportStar(require("./augments/date"), exports);
+__exportStar(require("./augments/environment"), exports);
 __exportStar(require("./augments/error"), exports);
 __exportStar(require("./augments/function"), exports);
-__exportStar(require("./augments/number"), exports);
 __exportStar(require("./augments/object"), exports);
 __exportStar(require("./augments/promise"), exports);
 __exportStar(require("./augments/regexp"), exports);
-__exportStar(require("./augments/string"), exports);
 __exportStar(require("./augments/tuple"), exports);
 __exportStar(require("./augments/type"), exports);
 __exportStar(require("./augments/type-of"), exports);
-__exportStar(require("./augments/type-test"), exports);

package/dist/esm/augments/ansi.d.ts

@@ -0,0 +1 @@
+export declare const ansiRegex: RegExp;

package/dist/esm/augments/ansi.js

@@ -0,0 +1,24 @@
+// cspell:disable
+/*
+Copied from
+https://github.com/chalk/ansi-regex/blob/1b337add136eb520764634a328e2f6354398eee5/index.js
+because the published ansi-regex package exports this in a manner that Jest can't handle and the
+latest version of the package that doesn't do that has a security vulnerability. The package has
+the following license from
+https://github.com/chalk/ansi-regex/blob/1b337add136eb520764634a328e2f6354398eee5/license
+
+MIT License
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+// cspell:enable
+const patterns = [
+    '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+    '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))',
+];
+export const ansiRegex = new RegExp(patterns.join('|'), 'g');

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

@@ -0,0 +1,13 @@
+import { AtLeastTuple } from './tuple';
+import { ArrayElement } from './type';
+export declare function filterOutIndexes<T>(array: ReadonlyArray<T>, indexes: ReadonlyArray<number>): T[];
+export declare function flatten2dArray<T>(array2d: ReadonlyArray<ReadonlyArray<T>>): T[];
+export declare type AtLeastOneEntryArray<ArrayGeneric extends ReadonlyArray<any>> = AtLeastTuple<ArrayElement<ArrayGeneric>, 1>;
+export declare function trimArrayStrings(input: ReadonlyArray<string>): string[];
+export declare function typedArrayIncludes<T>(array: ReadonlyArray<T>, input: unknown): input is T;
+declare type MapCallbackType<ArrayType extends ReadonlyArray<any>, OutputType> = (value: ArrayElement<ArrayType>, index: number, array: ArrayType) => OutputType;
+/** Preserves tuple types. */
+export declare function typedMap<InputArrayGeneric extends ReadonlyArray<any>, OutputType>(arrayToMap: InputArrayGeneric, mapCallback: MapCallbackType<InputArrayGeneric, OutputType>): {
+    [Index in keyof InputArrayGeneric]: OutputType;
+};
+export {};

package/dist/esm/augments/array.js

@@ -0,0 +1,17 @@
+export function filterOutIndexes(array, indexes) {
+    return array.filter((_, index) => !indexes.includes(index));
+}
+export function flatten2dArray(array2d) {
+    const flattened = array2d.reduce((accum, row) => accum.concat(row), []);
+    return flattened;
+}
+export function trimArrayStrings(input) {
+    return input.map((line) => line.trim()).filter((line) => line !== '');
+}
+export function typedArrayIncludes(array, input) {
+    return array.includes(input);
+}
+/** Preserves tuple types. */
+export function typedMap(arrayToMap, mapCallback) {
+    return arrayToMap.map(mapCallback);
+}

package/dist/esm/augments/async.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Acts like calling Array.prototype.forEach in that all elements are executed upon in order, and
+ * each execution is blocking. Meaning, the callback won't be called on element 2 until the callback
+ * has finished its call on element 1.
+ */
+export declare function awaitedForEach<OriginalGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => void | PromiseLike<void>): Promise<void>;
+export declare function awaitedBlockingMap<OriginalGeneric, MappedGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => MappedGeneric | PromiseLike<MappedGeneric>): Promise<Awaited<MappedGeneric>[]>;
+export declare function awaitedFilter<OriginalGeneric>(arrayInput: ReadonlyArray<OriginalGeneric>, filterCallback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => Promise<unknown>, options?: {
+    /**
+     * Each call to the filter callback is blocking, meaning the next one won't start until the
+     * current one finishes. By default this is false.
+     */
+    blocking?: boolean | undefined;
+}): Promise<OriginalGeneric[]>;

package/dist/esm/augments/async.js

@@ -0,0 +1,23 @@
+/**
+ * Acts like calling Array.prototype.forEach in that all elements are executed upon in order, and
+ * each execution is blocking. Meaning, the callback won't be called on element 2 until the callback
+ * has finished its call on element 1.
+ */
+export async function awaitedForEach(input, callback) {
+    await awaitedBlockingMap(input, callback);
+}
+export async function awaitedBlockingMap(input, callback) {
+    const mappedValues = await input.reduce(async (accumPromise, currentElement, index, wholeArray) => {
+        const accum = await accumPromise;
+        const mappedValue = await callback(currentElement, index, wholeArray);
+        accum.push(mappedValue);
+        return accum;
+    }, Promise.resolve([]));
+    return mappedValues;
+}
+export async function awaitedFilter(arrayInput, filterCallback, options) {
+    const callbackResults = (options === null || options === void 0 ? void 0 : options.blocking)
+        ? await awaitedBlockingMap(arrayInput, filterCallback)
+        : await Promise.all(arrayInput.map(filterCallback));
+    return arrayInput.filter((originalValue, index) => !!callbackResults[index]);
+}

package/dist/esm/augments/common-number.d.ts

@@ -0,0 +1,32 @@
+export declare function addCommasToNumber(input: number): string;
+export declare function clamp(
+/**
+ * This uses a destructured object so that consumers cannot get confused as to which input is
+ * which (which would be easy to do since they're all of the same type).
+ */
+{ value, min, max, }: {
+    value: number;
+    min: number;
+    max: number;
+}): number;
+/**
+ * This truncates a number such that is will at a max have 6 characters including suffix, decimal
+ * point, or comma.
+ *
+ * Default suffixes are:
+ *
+ *     '', // no suffix, numbers below 1000
+ *     'k', // thousand
+ *     'M', // million
+ *     'B', // billion
+ *     'T', // trillion
+ *     'P', // peta-, quadrillion
+ *     'E', // exa- quintillion
+ *     'Z', // zetta- sextillion
+ *     'Y', // yotta- septillion
+ */
+export declare function truncateNumber(originalValue: unknown, { customSuffixes, suppressErrorLogging, customErrorLogCallback, }?: {
+    customSuffixes?: ReadonlyArray<string>;
+    suppressErrorLogging?: boolean;
+    customErrorLogCallback?: (...args: any) => void;
+}): string;