@augment-vir/common 29.3.0 → 30.0.1

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';
-}

package/dist/cjs/augments/error.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.combineErrors = combineErrors;
-exports.combineErrorMessages = combineErrorMessages;
-exports.extractErrorMessage = extractErrorMessage;
-exports.ensureError = ensureError;
-exports.ensureErrorAndPrependMessage = ensureErrorAndPrependMessage;
-const boolean_1 = require("./boolean");
-const typed_has_property_1 = require("./object/typed-has-property");
-function combineErrors(errors) {
-    if (!errors || errors.length === 0) {
-        return undefined;
-    }
-    const firstError = errors[0];
-    if (errors.length === 1 && firstError) {
-        return firstError;
-    }
-    return new Error(errors.map((error) => extractErrorMessage(error).trim()).join('\n'));
-}
-function combineErrorMessages(errors) {
-    if (!errors) {
-        return '';
-    }
-    return errors.map(extractErrorMessage).filter(boolean_1.isTruthy).join('\n');
-}
-function extractErrorMessage(maybeError) {
-    if (!maybeError) {
-        return '';
-    }
-    if (maybeError instanceof Error) {
-        return maybeError.message;
-    }
-    else if ((0, typed_has_property_1.typedHasProperty)(maybeError, 'message')) {
-        return String(maybeError.message);
-    }
-    else {
-        return String(maybeError);
-    }
-}
-function ensureError(maybeError) {
-    if (maybeError instanceof Error) {
-        return maybeError;
-    }
-    else {
-        return new Error(extractErrorMessage(maybeError));
-    }
-}
-function ensureErrorAndPrependMessage(maybeError, prependMessage) {
-    const error = ensureError(maybeError);
-    error.message = `${prependMessage}: ${error.message}`;
-    return error;
-}

package/dist/cjs/augments/esm-path.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEsmPath = getEsmPath;
-function getEsmPath(importMeta) {
-    const filePath = new URL('', importMeta.url).pathname;
-    const dirPath = new URL('.', importMeta.url).pathname;
-    return {
-        filePath,
-        dirPath,
-    };
-}

package/dist/cjs/augments/function.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/augments/json-compatible.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/augments/json.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJson = parseJson;
-exports.stringifyJson = stringifyJson;
-const wrap_in_try_1 = require("./wrap-in-try");
-function parseJson({ jsonString, errorHandler, }) {
-    try {
-        const parsedJson = JSON.parse(jsonString);
-        return parsedJson;
-    }
-    catch (error) {
-        if (errorHandler) {
-            return errorHandler(error);
-        }
-        else {
-            throw error;
-        }
-    }
-}
-function stringifyJson(jsonValue, { whitespace, ...tryOptions } = {}) {
-    const result = (0, wrap_in_try_1.wrapInTry)(() => JSON.stringify(jsonValue, undefined, whitespace), tryOptions);
-    if (result instanceof Error) {
-        throw result;
-    }
-    else {
-        return result;
-    }
-}

package/dist/cjs/augments/object/any-object.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/augments/object/enum.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnumTypedKeys = getEnumTypedKeys;
-exports.getEnumTypedValues = getEnumTypedValues;
-exports.isEnumValue = isEnumValue;
-exports.ensureEnum = ensureEnum;
-exports.filterToEnumValues = filterToEnumValues;
-const object_entries_1 = require("./object-entries");
-function getEnumTypedKeys(input) {
-    // enum keys are always strings
-    return (0, object_entries_1.getObjectTypedKeys)(input).filter((key) => isNaN(Number(key)));
-}
-function getEnumTypedValues(input) {
-    const keys = getEnumTypedKeys(input);
-    return keys.map((key) => input[key]);
-}
-/** Check if the given value is within the given enum. */
-function isEnumValue(input, checkEnum) {
-    return getEnumTypedValues(checkEnum).includes(input);
-}
-/** Interpret a primitive as an enum value with type safety. */
-function ensureEnum(value, checkEnum) {
-    if (isEnumValue(value, checkEnum)) {
-        return value;
-    }
-    else {
-        const enumValues = getEnumTypedValues(checkEnum);
-        throw new Error(`Given value '${value}' does not match given enum. Possible enum values: ${enumValues.join(',')}`);
-    }
-}
-function filterToEnumValues(inputs, checkEnum, caseInsensitive = false) {
-    if (caseInsensitive) {
-        return inputs.reduce((accum, currentInput) => {
-            const matchedEnumValue = getEnumTypedValues(checkEnum).find((actualEnumValue) => {
-                return String(actualEnumValue).toUpperCase() === String(currentInput).toUpperCase();
-            });
-            if (matchedEnumValue) {
-                return accum.concat(matchedEnumValue);
-            }
-            else {
-                return accum;
-            }
-        }, []);
-    }
-    else {
-        return inputs.filter((input) => isEnumValue(input, checkEnum));
-    }
-}

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

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterObject = filterObject;
-exports.omitObjectKeys = omitObjectKeys;
-exports.pickObjectKeys = pickObjectKeys;
-const object_entries_1 = require("./object-entries");
-function filterObject(inputObject, callback) {
-    const filteredKeys = (0, object_entries_1.getObjectTypedKeys)(inputObject).filter((key) => {
-        const value = inputObject[key];
-        return callback(key, value, inputObject);
-    });
-    return filteredKeys.reduce((accum, key) => {
-        accum[key] = inputObject[key];
-        return accum;
-    }, {});
-}
-function omitObjectKeys(inputObject, omitTheseKeys) {
-    return filterObject(inputObject, (currentKey) => {
-        return !omitTheseKeys.includes(currentKey);
-    });
-}
-function pickObjectKeys(inputObject, pickTheseKeys) {
-    return filterObject(inputObject, (currentKey) => {
-        return pickTheseKeys.includes(currentKey);
-    });
-}

package/dist/cjs/augments/object/get-or-set.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrSetFromMap = getOrSetFromMap;
-exports.getOrSet = getOrSet;
-const run_time_assertions_1 = require("run-time-assertions");
-function getOrSetFromMap(map, key, createNewValueCallback) {
-    const mapKey = key;
-    if (map.has(mapKey)) {
-        return map.get(mapKey);
-    }
-    else {
-        const newValue = createNewValueCallback();
-        map.set(mapKey, newValue);
-        return newValue;
-    }
-}
-function getOrSet(originalObject, key, createCallback) {
-    if (key in originalObject) {
-        return originalObject[key];
-    }
-    else {
-        const createdValue = createCallback();
-        if ((0, run_time_assertions_1.isPromise)(createdValue)) {
-            return new Promise(async (resolve, reject) => {
-                try {
-                    const awaitedValue = await createdValue;
-                    originalObject[key] = awaitedValue;
-                    resolve(awaitedValue);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        }
-        else {
-            originalObject[key] = createdValue;
-            return createdValue;
-        }
-    }
-}

package/dist/cjs/augments/object/has-key.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasKey = hasKey;
-function hasKey(parent, property) {
-    return property in parent;
-}

package/dist/cjs/augments/object/jsonify.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonify = jsonify;
-function jsonify(input) {
-    return JSON.parse(JSON.stringify(input));
-}

package/dist/cjs/augments/object/key-count.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapObjectValuesSync = mapObjectValuesSync;
-exports.mapObjectValues = mapObjectValues;
-const object_entries_1 = require("./object-entries");
-/**
- * Map an object's keys to new values synchronously. This is different from plain mapObjectValues in
- * that this will not wrap the return value in a promise if any of the new object values are
- * promises. This function also requires currying in order to get the types correct. This allows you
- * to explicitly state the return type.
- *
- * @example
- *     mapObjectValuesSync({objectToIterateOver: 'initial value'})(callback);
- */
-function mapObjectValuesSync(inputObject) {
-    function innerMap(mapCallback) {
-        const mappedObject = (0, object_entries_1.getObjectTypedKeys)(inputObject).reduce((accum, currentKey) => {
-            const mappedValue = mapCallback(currentKey, inputObject[currentKey], inputObject);
-            return {
-                ...accum,
-                [currentKey]: mappedValue,
-            };
-        }, {});
-        return mappedObject;
-    }
-    return innerMap;
-}
-/**
- * Creates a new object with the same properties as the input object, but with values set to the
- * result of mapCallback for each property.
- */
-function mapObjectValues(inputObject, mapCallback) {
-    let gotAPromise = false;
-    const mappedObject = (0, object_entries_1.getObjectTypedKeys)(inputObject).reduce((accum, currentKey) => {
-        const mappedValue = mapCallback(currentKey, inputObject[currentKey], inputObject);
-        if (mappedValue instanceof Promise) {
-            gotAPromise = true;
-        }
-        return {
-            ...accum,
-            [currentKey]: mappedValue,
-        };
-    }, {});
-    if (gotAPromise) {
-        return new Promise(async (resolve, reject) => {
-            try {
-                await Promise.all((0, object_entries_1.getObjectTypedKeys)(mappedObject).map(async (key) => {
-                    const value = await mappedObject[key];
-                    mappedObject[key] = value;
-                }));
-                resolve(mappedObject);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    else {
-        return mappedObject;
-    }
-}

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

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeDeep = mergeDeep;
-const run_time_assertions_1 = require("run-time-assertions");
-const tuple_1 = require("../tuple");
-/**
- * Accepts multiple objects and merges their key-value pairs recursively. Any values set to
- * undefined will be removed.
- *
- * Note that order matters! Each input object will overwrite the properties of the previous objects.
- */
-function mergeDeep(...inputs) {
-    if (!(0, tuple_1.isLengthAtLeast)(inputs, 1)) {
-        // nothing to merge if no inputs
-        return {};
-    }
-    if (inputs.length === 1) {
-        // nothing to merge if only one input
-        return inputs[0];
-    }
-    let result = undefined;
-    const mergeProps = {};
-    inputs.forEach((individualInput) => {
-        if (!(0, run_time_assertions_1.isRunTimeType)(individualInput, 'object')) {
-            /** If not an object, we can't merge. So overwrite instead. */
-            result = individualInput;
-            return;
-        }
-        else if (!(0, run_time_assertions_1.isRunTimeType)(result, 'object')) {
-            /** If result isn't an object then we need to make it into one. */
-            result = { ...individualInput };
-        }
-        Object.entries(individualInput).forEach(([key, value,]) => {
-            if (!mergeProps[key]) {
-                mergeProps[key] = [];
-            }
-            mergeProps[key].push(value);
-        });
-    });
-    if ((0, run_time_assertions_1.isRunTimeType)(result, 'object')) {
-        Object.entries(mergeProps).forEach(([key, mergeValues,]) => {
-            const newValue = mergeDeep(...mergeValues);
-            if (newValue === undefined && key in result) {
-                delete result[key];
-            }
-            else if (newValue !== undefined) {
-                result[key] = newValue;
-            }
-        });
-    }
-    return result;
-}

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

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergePropertyArrays = mergePropertyArrays;
-const get_or_set_1 = require("./get-or-set");
-function mergePropertyArrays(...inputs) {
-    const combined = {};
-    inputs.forEach((input) => {
-        Object.entries(input).forEach(([key, newArray,]) => {
-            const currentArray = (0, get_or_set_1.getOrSet)(combined, key, () => []);
-            currentArray.push(...newArray);
-        });
-    });
-    return combined;
-}