@augment-vir/common 29.2.0 → 30.0.0

package/package.json

@@ -1,35 +1,53 @@
 {
     "name": "@augment-vir/common",
-    "version": "29.2.0",
-    "homepage": "https://github.com/electrovir/augment-vir/tree/main/packages/common",
+    "version": "30.0.0",
+    "homepage": "https://github.com/electrovir/augment-vir",
     "bugs": {
         "url": "https://github.com/electrovir/augment-vir/issues"
     },
     "repository": {
         "type": "git",
-        "url": "https://github.com/electrovir/augment-vir"
+        "url": "git+https://github.com/electrovir/augment-vir.git"
     },
-    "license": "MIT",
+    "license": "(MIT or CC0 1.0)",
     "author": {
         "name": "electrovir",
         "url": "https://github.com/electrovir"
     },
-    "main": "dist/cjs/index.js",
-    "module": "dist/esm/index.js",
-    "types": "dist/types/index.d.ts",
+    "type": "module",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
     "scripts": {
-        "compile": "rm -rf dist && tsc --project tsconfig.json && tsc --project tsconfig.cjs.json",
-        "test": "echo \"use common-test to run tests\" && exit 0",
-        "test:coverage": "npm test",
-        "test:types": "tsc --noEmit"
+        "compile": "virmator compile",
+        "docs": "virmator docs",
+        "test": "concurrently --colors --kill-others-on-fail -c red,blue --names node,web \"npm run test:node\" \"npm run test:web\"",
+        "test:coverage": "virmator --no-deps test web coverage",
+        "test:docs": "virmator docs check",
+        "test:node": "virmator --no-deps test node",
+        "test:update": "npm test",
+        "test:web": "virmator --no-deps test web"
     },
     "dependencies": {
-        "browser-or-node": "^3.0.0",
-        "run-time-assertions": "^1.5.1",
-        "type-fest": "^4.21.0"
+        "@augment-vir/assert": "^30.0.0",
+        "@augment-vir/core": "^30.0.0",
+        "@date-vir/duration": "^6.0.0",
+        "ansi-styles": "^6.2.1",
+        "json5": "^2.2.3",
+        "type-fest": "^4.25.0"
     },
     "devDependencies": {
-        "typescript": "5.5.2"
+        "@web/dev-server-esbuild": "^1.0.2",
+        "@web/test-runner": "^0.18.3",
+        "@web/test-runner-commands": "^0.9.0",
+        "@web/test-runner-playwright": "^0.11.0",
+        "@web/test-runner-visual-regression": "^0.9.0",
+        "concurrently": "^8.2.2",
+        "execute-in-browser": "^1.0.3",
+        "istanbul-smart-text-reporter": "^1.1.4"
+    },
+    "engines": {
+        "node": ">=22"
     },
     "publishConfig": {
         "access": "public"

package/README.md

@@ -1,7 +0,0 @@
-# @augment-vir/common
-
-`augment-vir` is a collection of small helper functions that I constantly use across all my JavaScript and TypeScript repos. I call these functions `augments`. These are functions, constants, and types typically placed within a "util", or "helpers", etc. directory.
-
-This `common` package is for environment-agnostic augments. Everything in here will work in Node.js or the browser with identical results.
-
-Note that the `random*` functions exported by this package will not work in Node.js < v19.0.0.

package/dist/cjs/augments/ansi.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ansiRegex = void 0;
-// 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=><~]))',
-];
-exports.ansiRegex = new RegExp(patterns.join('|'), 'g');

package/dist/cjs/augments/array/array.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterOutIndexes = filterOutIndexes;
-exports.flatten2dArray = flatten2dArray;
-exports.trimArrayStrings = trimArrayStrings;
-exports.typedArrayIncludes = typedArrayIncludes;
-exports.typedMap = typedMap;
-exports.repeatArray = repeatArray;
-exports.groupArrayBy = groupArrayBy;
-exports.arrayToObject = arrayToObject;
-exports.filterMap = filterMap;
-const get_or_set_1 = require("../object/get-or-set");
-const object_entries_1 = require("../object/object-entries");
-function filterOutIndexes(array, indexes) {
-    return array.filter((_, index) => !indexes.includes(index));
-}
-function flatten2dArray(array2d) {
-    const flattened = array2d.reduce((accum, row) => accum.concat(row), []);
-    return flattened;
-}
-function trimArrayStrings(input) {
-    return input.map((line) => line.trim()).filter((line) => line !== '');
-}
-function typedArrayIncludes(array, input) {
-    return array.includes(input);
-}
-/** Preserves tuple types. */
-function typedMap(arrayToMap, mapCallback) {
-    return arrayToMap.map(mapCallback);
-}
-function repeatArray(repeatCount, array) {
-    return Array.from({ length: repeatCount }, () => [...array]).flat();
-}
-/**
- * Polyfill for `Object.groupBy`:
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/groupBy
- */
-function groupArrayBy(inputArray, callback) {
-    return inputArray.reduce((accum, entry, index, originalArray) => {
-        const key = callback(entry, index, originalArray);
-        const entryArray = (0, get_or_set_1.getOrSet)(accum, key, () => []);
-        entryArray.push(entry);
-        return accum;
-    }, {});
-}
-/**
- * Like `groupArrayBy` but maps array entries to a single key. Meaning, the resulting object does
- * not have an array of elements (unless the original array itself contains arrays).
- */
-function arrayToObject(inputArray, callback) {
-    return (0, object_entries_1.typedObjectFromEntries)(inputArray.map((entry, index, originalArray) => {
-        const key = callback(entry, index, originalArray);
-        return [
-            key,
-            entry,
-        ];
-    }));
-}
-function filterMap(inputArray, mapCallback, filterCallback) {
-    return inputArray.reduce((accum, entry, index, originalArray) => {
-        const mapOutput = mapCallback(entry, index, originalArray);
-        const filterOutput = filterCallback(mapOutput, entry, index, originalArray);
-        if (filterOutput) {
-            accum.push(mapOutput);
-        }
-        return accum;
-    }, []);
-}

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeDuplicates = removeDuplicates;
-function removeDuplicates(originalArray, calculateUniqueIdCallback) {
-    const grouped = new Map();
-    return originalArray.filter((entry) => {
-        const uniqueId = calculateUniqueIdCallback(entry);
-        if (grouped.get(uniqueId)) {
-            return false;
-        }
-        else {
-            grouped.set(uniqueId, entry);
-            return true;
-        }
-    });
-}

package/dist/cjs/augments/async.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.awaitedForEach = awaitedForEach;
-exports.awaitedBlockingMap = awaitedBlockingMap;
-exports.awaitedFilter = awaitedFilter;
-/**
- * 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);
-}
-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;
-}
-async function awaitedFilter(arrayInput, filterCallback, options) {
-    const callbackResults = options?.blocking
-        ? await awaitedBlockingMap(arrayInput, filterCallback)
-        : await Promise.all(arrayInput.map(filterCallback));
-    return arrayInput.filter((originalValue, index) => !!callbackResults[index]);
-}

package/dist/cjs/augments/boolean.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTruthy = isTruthy;
-exports.isFalsy = isFalsy;
-exports.ifTruthy = ifTruthy;
-function isTruthy(input) {
-    return !!input;
-}
-function isFalsy(input) {
-    return !input;
-}
-function ifTruthy(checkThis, ifTruthyCallback, ifFalsyCallback) {
-    if (isTruthy(checkThis)) {
-        return ifTruthyCallback(checkThis);
-    }
-    else {
-        return ifFalsyCallback(checkThis);
-    }
-}

package/dist/cjs/augments/common-number.js

@@ -1,112 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertIntoNumber = exports.NaNString = void 0;
-exports.addCommasToNumber = addCommasToNumber;
-exports.doesRequireScientificNotation = doesRequireScientificNotation;
-exports.ensureMinAndMax = ensureMinAndMax;
-exports.toNumber = toNumber;
-exports.toEnsuredNumber = toEnsuredNumber;
-exports.toMaybeNumber = toMaybeNumber;
-exports.wrapNumber = wrapNumber;
-exports.round = round;
-exports.clamp = clamp;
-const common_string_1 = require("./common-string");
-const regexp_1 = require("./regexp");
-exports.NaNString = String(NaN);
-function addCommasToNumber(input) {
-    if (typeof input === 'string' && isNaN(Number(input))) {
-        return exports.NaNString;
-    }
-    const numericValue = Number(input);
-    const isNegative = numericValue < 0;
-    const stringValue = String(Math.abs(numericValue));
-    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 valueWithCommas = separated.join(',');
-    const negativeMarker = isNegative ? '-' : '';
-    return [
-        negativeMarker,
-        valueWithCommas,
-        decimalString,
-    ].join('');
-}
-function doesRequireScientificNotation(input) {
-    return String(input).includes('e');
-}
-/**
- * Given a min and max, ensures that they are in correct order. Meaning, min is less than max. If
- * that is not the case, the returned value is the given min and max values swapped.
- */
-function ensureMinAndMax({ min, max }) {
-    if (min > max) {
-        return { min: max, max: min };
-    }
-    else {
-        return { min, max };
-    }
-}
-/**
- * Tries to convert the input into a number. Handles strings with commas. Note: this might return
- * `NaN`.
- */
-function toNumber(input) {
-    if (typeof input === 'number') {
-        return input;
-    }
-    else if (typeof input === 'string') {
-        return Number((0, common_string_1.removeCommasFromNumberString)(input));
-    }
-    else {
-        return Number(input);
-    }
-}
-/** @deprecated Use {@link toNumber} instead. */
-exports.convertIntoNumber = toNumber;
-/** Tries to convert the input into a number and throws an error if `NaN` is created. */
-function toEnsuredNumber(input) {
-    const numeric = toMaybeNumber(input);
-    if (numeric == undefined) {
-        throw new Error(`Cannot convert to a number: ${input}`);
-    }
-    else {
-        return numeric;
-    }
-}
-/** Tries to convert the input into a number and returns `undefined` if `NaN` is created. */
-function toMaybeNumber(input) {
-    const numeric = toNumber(input);
-    if (isNaN(numeric)) {
-        return undefined;
-    }
-    else {
-        return numeric;
-    }
-}
-/**
- * If the given value is outside the given min/max bounds, instead of clamping the number (as the
- * `clamp` function does), this function wraps the value around to the next bound.
- *
- * @example
- *     wrapNumber({min: 0, max: 100, value: 101}) == 0;
- */
-function wrapNumber({ max, min, value }) {
-    if (value > max) {
-        return min;
-    }
-    else if (value < min) {
-        return max;
-    }
-    return value;
-}
-function round(inputs) {
-    const digitFactor = Math.pow(10, inputs.digits);
-    const multiplied = inputs.number * digitFactor;
-    return Number((Math.round(multiplied) / digitFactor).toFixed(inputs.digits));
-}
-/** Clamp's the given value to within the min and max bounds, inclusive. */
-function clamp({ value, min, max }) {
-    return Math.min(Math.max(value, min), max);
-}

package/dist/cjs/augments/common-string.js

@@ -1,245 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringCaseEnum = exports.removeColor = void 0;
-exports.joinWithFinalConjunction = joinWithFinalConjunction;
-exports.wrapString = wrapString;
-exports.removeAnsiEscapeCodes = removeAnsiEscapeCodes;
-exports.removeCommasFromNumberString = removeCommasFromNumberString;
-exports.collapseWhiteSpace = collapseWhiteSpace;
-exports.splitIncludeSplit = splitIncludeSplit;
-exports.capitalizeFirstLetter = capitalizeFirstLetter;
-exports.kebabCaseToCamelCase = kebabCaseToCamelCase;
-exports.hasCase = hasCase;
-exports.isCase = isCase;
-exports.camelCaseToKebabCase = camelCaseToKebabCase;
-exports.replaceStringAtIndex = replaceStringAtIndex;
-exports.escapeStringForRegExp = escapeStringForRegExp;
-exports.getAllIndexesOf = getAllIndexesOf;
-exports.typedSplit = typedSplit;
-const ansi_1 = require("./ansi");
-const regexp_1 = require("./regexp");
-/**
- * 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
- * only of length 2, then no commas are added.
- *
- * @param list Array of items to be converted into strings. Works best if these are simply strings
- *   to begin with.
- * @param conjunction Defaults to 'and'. The conjunction to be used before the final element.
- */
-function joinWithFinalConjunction(list, conjunction = 'and') {
-    if (list.length < 2) {
-        /**
-         * If there are not multiple things in the list to join, just turn the list into a string
-         * for an empty list, this will be '', for a single item list, this will just be the first
-         * item as a string.
-         */
-        return list.join('');
-    }
-    /** When there are only two items in the list, we don't want any commas. */
-    const commaSep = list.length > 2 ? ', ' : ' ';
-    const commaJoined = list.slice(0, -1).join(commaSep);
-    const fullyJoined = `${commaJoined}${commaSep}${conjunction} ${list[list.length - 1]}`;
-    return fullyJoined;
-}
-/** Wraps `value` on both sides with `wrapper`. */
-function wrapString({ value, wrapper }) {
-    return [
-        wrapper,
-        wrapper,
-    ].join(value);
-}
-function removeAnsiEscapeCodes(input) {
-    return input.replace(ansi_1.ansiRegex, '');
-}
-exports.removeColor = removeAnsiEscapeCodes;
-function removeCommasFromNumberString(numberString) {
-    return numberString.replace(/,/g, '');
-}
-/** Collapse all consecutive white space into just one space and trim surrounding whitespace. */
-function collapseWhiteSpace(input, { keepNewLines } = {}) {
-    const newLineReplacement = keepNewLines
-        ? input.replace(/[\s\n]*\n+[\s\n]*/g, '\n')
-        : // sometimes \n isn't included in \s
-            input.replace(/\n/g, ' ');
-    return newLineReplacement
-        .trim()
-        .replace(/[^\S\r\n]/g, ' ')
-        .replace(/\s{2,}/g, ' ');
-}
-/** Same as String.prototype.split but includes the delimiter to split by in the output array. */
-function splitIncludeSplit(original, splitterInput, caseSensitive) {
-    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) => {
-        // this will be undefined on the last index
-        const splitterLength = indexLengths[index];
-        const includeCurrent = accum.concat(current);
-        if (splitterLength) {
-            const splitterMatch = original.slice(splitterLength.index, splitterLength.index + splitterLength.length);
-            return includeCurrent.concat(splitterMatch);
-        }
-        else {
-            return includeCurrent;
-        }
-    }, []);
-    return splitterIncluded;
-}
-const defaultCasingOptions = {
-    capitalizeFirstLetter: false,
-};
-function capitalizeFirstLetter(input) {
-    if (!input.length) {
-        return '';
-    }
-    const firstLetter = input[0];
-    return (firstLetter.toUpperCase() + input.slice(1));
-}
-function maybeCapitalize(input, casingOptions) {
-    return casingOptions.capitalizeFirstLetter ? capitalizeFirstLetter(input) : input;
-}
-function kebabCaseToCamelCase(rawKebabCase, casingOptions = defaultCasingOptions) {
-    const kebabCase = rawKebabCase.toLowerCase();
-    if (!kebabCase.length) {
-        return '';
-    }
-    const camelCase = kebabCase
-        .replace(/^-+/, '')
-        .replace(/-{2,}/g, '-')
-        .replace(/-(?:.|$)/g, (dashMatch) => {
-        const letter = dashMatch[1];
-        if (letter) {
-            return letter.toUpperCase();
-        }
-        else {
-            return '';
-        }
-    });
-    return maybeCapitalize(camelCase, casingOptions);
-}
-var StringCaseEnum;
-(function (StringCaseEnum) {
-    StringCaseEnum["Upper"] = "upper";
-    StringCaseEnum["Lower"] = "lower";
-})(StringCaseEnum || (exports.StringCaseEnum = StringCaseEnum = {}));
-/** Indicates whether the given string has different lower and upper case variants. */
-function hasCase(input) {
-    return input.toLowerCase() !== input.toUpperCase();
-}
-/**
- * Checks if the given string is exclusively of the specific case.
- *
- * Note that some characters have no casing, such as punctuation (they have no difference between
- * upper and lower casings). By default, those letters always return `true` for this function,
- * regardless of which `caseType` is provided. To instead return `false` for any such characters,
- * pass in an options object and set blockNoCaseCharacters to true.
- */
-function isCase(input, caseType, options) {
-    if (!input && options?.blockNoCaseCharacters) {
-        return false;
-    }
-    for (let letterIndex = 0; letterIndex < input.length; letterIndex++) {
-        const letter = input[letterIndex] || '';
-        if (!hasCase(letter)) {
-            if (options?.blockNoCaseCharacters) {
-                return false;
-            }
-            else {
-                continue;
-            }
-        }
-        if (caseType === StringCaseEnum.Upper && letter !== letter.toUpperCase()) {
-            return false;
-        }
-        else if (caseType === StringCaseEnum.Lower && letter !== letter.toLowerCase()) {
-            return false;
-        }
-    }
-    return true;
-}
-function camelCaseToKebabCase(rawCamelCase) {
-    const kebabCase = rawCamelCase
-        .split('')
-        .reduce((accum, currentLetter, index, originalString) => {
-        const previousLetter = index > 0 ? originalString[index - 1] || '' : '';
-        const nextLetter = index < originalString.length - 1 ? originalString[index + 1] || '' : '';
-        const possibleWordBoundary = isCase(previousLetter, StringCaseEnum.Lower, { blockNoCaseCharacters: true }) ||
-            isCase(nextLetter, StringCaseEnum.Lower, { blockNoCaseCharacters: true });
-        if (currentLetter === currentLetter.toLowerCase() ||
-            index === 0 ||
-            !possibleWordBoundary) {
-            accum += currentLetter;
-        }
-        else {
-            accum += `-${currentLetter.toLowerCase()}`;
-        }
-        return accum;
-    }, '')
-        .toLowerCase();
-    return kebabCase;
-}
-function replaceStringAtIndex(originalString, start, newString, length = newString.length) {
-    const before = originalString.substring(0, start);
-    const after = originalString.substring(start + length);
-    return `${before}${newString}${after}`;
-}
-/**
- * Escapes characters from the given string so that it can be used within a RegExp without being
- * parsed as RegExp syntax.
- */
-function escapeStringForRegExp(input) {
-    return input.replace(/[\^$\\.*+?()[\]{}|]/g, '\\$&');
-}
-function makeCaseInsensitiveRegExp(searchForInput, caseSensitive) {
-    const regExpFlags = `g${!caseSensitive && typeof searchForInput === 'string' ? 'i' : ''}`;
-    const searchFor = searchForInput instanceof RegExp
-        ? new RegExp(searchForInput.source, (0, regexp_1.deDupeRegExFlags)(`${searchForInput.flags}${regExpFlags}`))
-        : new RegExp(escapeStringForRegExp(searchForInput), regExpFlags);
-    return searchFor;
-}
-function getAllIndexesOf({ searchIn, searchFor, caseSensitive, includeLength, }) {
-    const searchRegExp = makeCaseInsensitiveRegExp(searchFor, caseSensitive);
-    const indexes = [];
-    const indexesAndLengths = [];
-    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 "${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 "${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.
-         */
-        return originalMatch;
-    });
-    return (includeLength ? indexesAndLengths : indexes);
-}
-function typedSplit(input, splitString) {
-    return input.split(splitString);
-}

package/dist/cjs/augments/debounce.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DebounceStyle = void 0;
-exports.createDebounce = createDebounce;
-var DebounceStyle;
-(function (DebounceStyle) {
-    /**
-     * Fires on the first call, then waits the given amount of milliseconds until a subsequent call
-     * can be made.
-     */
-    DebounceStyle["FirstThenWait"] = "first-then-wait";
-    /**
-     * Waits the given amount of milliseconds after the first call and then fires the latest
-     * assigned callback.
-     */
-    DebounceStyle["AfterWait"] = "after-wait";
-})(DebounceStyle || (exports.DebounceStyle = DebounceStyle = {}));
-function createDebounce(debounceStyle, debounceDuration) {
-    let nextCallTimestamp = 0;
-    let latestCallback = undefined;
-    return (callback) => {
-        latestCallback = callback;
-        const now = Date.now();
-        if (nextCallTimestamp > now) {
-            return;
-        }
-        if (debounceStyle === DebounceStyle.FirstThenWait) {
-            latestCallback();
-        }
-        else if (debounceStyle === DebounceStyle.AfterWait) {
-            setTimeout(() => {
-                /** Use whatever the latest latestCallback is. */
-                latestCallback?.();
-            }, debounceDuration.milliseconds);
-        }
-        nextCallTimestamp = now + debounceDuration.milliseconds;
-    };
-}

package/dist/cjs/augments/environment.js

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