@dereekb/util 11.0.21 → 11.1.1

package/index.cjs.js

@@ -1627,213 +1627,6 @@ $$h({ target: 'Array', proto: true, forced: FORCED$2 }, {
   }
 });
 
-// MARK: Functions
-/**
- * Converts the input value to an array containing itself, or returns itself if it is an array.
- *
- * @param arrayOrValue
- * @returns
- */
-function convertMaybeToArray(arrayOrValue) {
-  if (arrayOrValue != null) {
-    return convertToArray(arrayOrValue);
-  } else {
-    return [];
-  }
-}
-const asArray = convertMaybeToArray;
-/**
- * Converts the input value to an array containing itself, or returns itself if it is an array.
- *
- * @param arrayOrValue
- * @returns
- */
-function convertToArray(arrayOrValue) {
-  return Array.isArray(arrayOrValue) ? arrayOrValue : [arrayOrValue];
-}
-/**
- * Returns the first value from the array.
- */
-function firstValue(input) {
-  return valueAtIndex(input, 0);
-}
-/**
- * Returns the last value from the array.
- */
-function lastValue(input) {
-  if (Array.isArray(input)) {
-    return input[input.length - 1];
-  } else {
-    return input;
-  }
-}
-/**
- * Returns a tuple with the first and last value of the input.
- *
- * If the input is not an array, returns that value as the first and last value.
- *
- * @param input
- * @returns
- */
-function firstAndLastValue(input) {
-  const first = firstValue(input);
-  const last = lastValue(input);
-  return [first, last];
-}
-function valueAtIndex(input, index) {
-  if (Array.isArray(input)) {
-    return input[index];
-  } else {
-    return input;
-  }
-}
-/**
- * Concatinates the input arrays and filters out falsy values.
- */
-function concatArrays(...arrays) {
-  return flattenArray(arrays.filter(x => Boolean(x)));
-}
-/**
- * Flattens a two dimensional array into a single dimensional array. Any null/undefined values from the first dimension are filtered out.
- *
- * @param array
- * @returns
- */
-function flattenArray(array) {
-  const filteredValues = array.filter(x => Boolean(x));
-  // concat with spread is faster than a depth-one flat
-  return [].concat(...filteredValues);
-}
-/**
- * Flattens an array of ArrayOrValue values into a single array.
- *
- * @param array
- * @returns
- */
-function flattenArrayOrValueArray(array) {
-  return flattenArray(array.map(x => x ? convertToArray(x) : undefined));
-}
-function copyArray(input) {
-  return input != null ? Array.from(input) : [];
-}
-function pushElementOntoArray(target, element, times) {
-  for (let i = 0; i < times; i += 1) {
-    target.push(element);
-  }
-  return target;
-}
-/**
- * Merges all input arrays into a single array.
- *
- * @param arrays
- * @returns
- */
-function mergeArrays(arrays) {
-  return mergeArraysIntoArray([], ...arrays);
-}
-/**
- * Merges the input arrays into the target array by pushing each item from each array. Creates an empty array if the target is null/undefined.
- *
- * @param target
- * @param arrays
- * @returns
- */
-function mergeArraysIntoArray(target, ...arrays) {
-  if (target == null) {
-    target = [];
-  }
-  arrays.forEach(array => {
-    if (array != null) {
-      pushArrayItemsIntoArray(target, array);
-    }
-  });
-  return target;
-}
-/**
- * Pushes the input value into the target array if it is not an array. If it is an array, inserts all values from that array into the target array.
- *
- * @param target
- * @param value
- * @returns
- */
-function pushItemOrArrayItemsIntoArray(target, value) {
-  if (Array.isArray(value)) {
-    return pushArrayItemsIntoArray(target, value);
-  } else {
-    target.push(value);
-    return target;
-  }
-}
-/**
- * Merges all the values from the second array into the first using push.
- *
- * This is preferable in cases where immutability is not required.
- *
- * @param target
- * @param array
- */
-function pushArrayItemsIntoArray(target, array) {
-  Array.prototype.push.apply(target, array);
-  return target;
-}
-/**
- * Copies/takes the elements from the front of the array up to the max.
- *
- * @param values
- * @param maxToTake
- * @returns
- */
-function takeFront(values, maxToTake) {
-  return values.slice(0, maxToTake);
-}
-/**
- * Copies/takes as many elements as possible from the end.
- *
- * @param values Values to take from.
- * @param maxToTake Max number of values to take from the end of the input array.
- * @param keepFromFront Number of values to retain in the front of the array. These are not taken.
- * @returns New array with the subset of taken values.
- */
-function takeLast(values, maxToTake, keepFromFront = 0) {
-  let results;
-  if (maxToTake < keepFromFront) {
-    throw new Error('Cannot take more than keeping from front.');
-  } else if (keepFromFront === maxToTake) {
-    results = values.slice(0, keepFromFront);
-  } else {
-    const length = values.length;
-    const secondHalfStartIndex = Math.max(keepFromFront, length - (maxToTake - keepFromFront));
-    const secondHalfEndIndex = length;
-    results = [...values.slice(0, keepFromFront), ...values.slice(secondHalfStartIndex, secondHalfEndIndex)];
-  }
-  return results;
-}
-/**
- * Performs forEach with the input array and returns the array.
- *
- * @param array
- * @param forEach
- * @returns
- */
-function forEachWithArray(array, forEach) {
-  if (array) {
-    array = convertToArray(array);
-    array.forEach(forEach);
-  } else {
-    array = [];
-  }
-  return array;
-}
-/**
- * Counts all the values in a nested array.
- *
- * @param array
- * @returns
- */
-function countAllInNestedArray(array) {
-  return array.reduce((acc, curr) => acc + curr.length, 0);
-}
-
 var wellKnownSymbol$d = wellKnownSymbol$k;
 
 var TO_STRING_TAG$1 = wellKnownSymbol$d('toStringTag');
@@ -2113,66 +1906,288 @@ function existsInIterable(values, fn) {
       return true;
     }
   }
-  return false;
+  return false;
+}
+/**
+ * Filters values from the iterable using a DecisionFunction.
+ *
+ * @param values
+ * @param fn
+ * @returns
+ */
+function filterFromIterable(values, fn) {
+  const keep = [];
+  for (const value of values) {
+    if (fn(value)) {
+      keep.push(value);
+    }
+  }
+  return keep;
+}
+/**
+ * Wraps the input tuple values as an array. The tuples should all be the same length in order to wrap them properly, and the tuple value cannot consist of only arrays of the same length.
+ *
+ * This is used to prevent functions from treating the tuple itself as an array.
+ *
+ * @param input
+ */
+function wrapTuples(input) {
+  if (Array.isArray(input)) {
+    // check if the first item is an array. Tuples can contain arrays as the first value.
+    if (input.length > 0) {
+      const firstValueInPotentialTupleOrArray = input[0];
+      let inputIsSingleTuple = false;
+      if (Array.isArray(firstValueInPotentialTupleOrArray)) {
+        // if the first nested value is an array then the top-level value may be an array and not a tuple. Check the length of all the other values in the array to see if they have the same length.
+        const expectedLength = firstValueInPotentialTupleOrArray.length;
+        // if it is an array of tuples, all values should be the same length and be arrays. If not an array, then we're looking at a tuple.
+        const firstNonUniformTupleValueIndex = input.findIndex(x => {
+          if (Array.isArray(x)) {
+            return x.length !== expectedLength;
+          } else {
+            return true; // non-array value. The input is a tuple.
+          }
+        });
+
+        inputIsSingleTuple = firstNonUniformTupleValueIndex !== -1;
+      } else {
+        inputIsSingleTuple = true;
+        return [input];
+      }
+      // first value of the tuple could also be an array. If it is, check the other tuples all have the same length.
+      if (inputIsSingleTuple) {
+        return [input];
+      } else {
+        return input;
+      }
+    } else {
+      return input; // is an empty array.
+    }
+  } else {
+    throw new Error('Input is not an array/tuple...');
+  }
+}
+
+// MARK: Functions
+/**
+ * Converts the input value to an array containing itself, or returns itself if it is an array.
+ *
+ * @param arrayOrValue
+ * @returns
+ */
+function convertMaybeToArray(arrayOrValue) {
+  if (arrayOrValue != null) {
+    return convertToArray(arrayOrValue);
+  } else {
+    return [];
+  }
+}
+const asArray = convertMaybeToArray;
+/**
+ * Converts the input value to an array containing itself, or returns itself if it is an array.
+ *
+ * @param arrayOrValue
+ * @returns
+ */
+function convertToArray(arrayOrValue) {
+  return Array.isArray(arrayOrValue) ? arrayOrValue : [arrayOrValue];
+}
+/**
+ * Returns the first value from the array.
+ */
+function firstValue(input) {
+  return valueAtIndex(input, 0);
+}
+/**
+ * Returns the last value from the array.
+ */
+function lastValue(input) {
+  if (Array.isArray(input)) {
+    return input[input.length - 1];
+  } else {
+    return input;
+  }
+}
+/**
+ * Returns a tuple with the first and last value of the input.
+ *
+ * If the input is not an array, returns that value as the first and last value.
+ *
+ * @param input
+ * @returns
+ */
+function firstAndLastValue(input) {
+  const first = firstValue(input);
+  const last = lastValue(input);
+  return [first, last];
+}
+function valueAtIndex(input, index) {
+  if (Array.isArray(input)) {
+    return input[index];
+  } else {
+    return input;
+  }
+}
+/**
+ * Concatinates the input arrays and filters out falsy values.
+ */
+function concatArrays(...arrays) {
+  return flattenArray(arrays.filter(x => Boolean(x)));
+}
+/**
+ * Flattens a two dimensional array into a single dimensional array. Any null/undefined values from the first dimension are filtered out.
+ *
+ * @param array
+ * @returns
+ */
+function flattenArray(array) {
+  const filteredValues = array.filter(x => Boolean(x));
+  // concat with spread is faster than a depth-one flat
+  return [].concat(...filteredValues);
+}
+/**
+ * Flattens an array of ArrayOrValue values into a single array.
+ *
+ * @param array
+ * @returns
+ */
+function flattenArrayOrValueArray(array) {
+  return flattenArray(array.map(x => x ? convertToArray(x) : undefined));
+}
+function copyArray(input) {
+  return input != null ? Array.from(input) : [];
+}
+function pushElementOntoArray(target, element, times) {
+  for (let i = 0; i < times; i += 1) {
+    target.push(element);
+  }
+  return target;
+}
+/**
+ * Merges all input arrays into a single array.
+ *
+ * @param arrays
+ * @returns
+ */
+function mergeArrays(arrays) {
+  return mergeArraysIntoArray([], ...arrays);
+}
+/**
+ * Merges the input arrays into the target array by pushing each item from each array. Creates an empty array if the target is null/undefined.
+ *
+ * @param target
+ * @param arrays
+ * @returns
+ */
+function mergeArraysIntoArray(target, ...arrays) {
+  if (target == null) {
+    target = [];
+  }
+  arrays.forEach(array => {
+    if (array != null) {
+      pushArrayItemsIntoArray(target, array);
+    }
+  });
+  return target;
+}
+/**
+ * Pushes the input value into the target array if it is not an array. If it is an array, inserts all values from that array into the target array.
+ *
+ * @param target
+ * @param value
+ * @returns
+ */
+function pushItemOrArrayItemsIntoArray(target, value) {
+  if (Array.isArray(value)) {
+    return pushArrayItemsIntoArray(target, value);
+  } else {
+    target.push(value);
+    return target;
+  }
+}
+/**
+ * Merges all the values from the second array into the first using push.
+ *
+ * This is preferable in cases where immutability is not required.
+ *
+ * @param target
+ * @param array
+ */
+function pushArrayItemsIntoArray(target, array) {
+  Array.prototype.push.apply(target, array);
+  return target;
+}
+/**
+ * Copies/takes the elements from the front of the array up to the max.
+ *
+ * @param values
+ * @param maxToTake
+ * @returns
+ */
+function takeFront(values, maxToTake) {
+  return values.slice(0, maxToTake);
+}
+/**
+ * Copies/takes as many elements as possible from the end.
+ *
+ * @param values Values to take from.
+ * @param maxToTake Max number of values to take from the end of the input array.
+ * @param keepFromFront Number of values to retain in the front of the array. These are not taken.
+ * @returns New array with the subset of taken values.
+ */
+function takeLast(values, maxToTake, keepFromFront = 0) {
+  let results;
+  if (maxToTake < keepFromFront) {
+    throw new Error('Cannot take more than keeping from front.');
+  } else if (keepFromFront === maxToTake) {
+    results = values.slice(0, keepFromFront);
+  } else {
+    const length = values.length;
+    const secondHalfStartIndex = Math.max(keepFromFront, length - (maxToTake - keepFromFront));
+    const secondHalfEndIndex = length;
+    results = [...values.slice(0, keepFromFront), ...values.slice(secondHalfStartIndex, secondHalfEndIndex)];
+  }
+  return results;
+}
+/**
+ * Performs forEach with the input array and returns the array.
+ *
+ * @param array
+ * @param forEach
+ * @returns
+ */
+function forEachWithArray(array, forEach) {
+  if (array) {
+    array = convertToArray(array);
+    array.forEach(forEach);
+  } else {
+    array = [];
+  }
+  return array;
 }
 /**
- * Filters values from the iterable using a DecisionFunction.
+ * Counts all the values in a nested array.
  *
- * @param values
- * @param fn
+ * @param array
  * @returns
  */
-function filterFromIterable(values, fn) {
-  const keep = [];
-  for (const value of values) {
-    if (fn(value)) {
-      keep.push(value);
-    }
-  }
-  return keep;
+function countAllInNestedArray(array) {
+  return array.reduce((acc, curr) => acc + curr.length, 0);
 }
 /**
- * Wraps the input tuple values as an array. The tuples should all be the same length in order to wrap them properly, and the tuple value cannot consist of only arrays of the same length.
- *
- * This is used to prevent functions from treating the tuple itself as an array.
+ * Creates a copy of the array with the items at the specified indexes removed.
  *
- * @param input
+ * @param array
  */
-function wrapTuples(input) {
-  if (Array.isArray(input)) {
-    // check if the first item is an array. Tuples can contain arrays as the first value.
-    if (input.length > 0) {
-      const firstValueInPotentialTupleOrArray = input[0];
-      let inputIsSingleTuple = false;
-      if (Array.isArray(firstValueInPotentialTupleOrArray)) {
-        // if the first nested value is an array then the top-level value may be an array and not a tuple. Check the length of all the other values in the array to see if they have the same length.
-        const expectedLength = firstValueInPotentialTupleOrArray.length;
-        // if it is an array of tuples, all values should be the same length and be arrays. If not an array, then we're looking at a tuple.
-        const firstNonUniformTupleValueIndex = input.findIndex(x => {
-          if (Array.isArray(x)) {
-            return x.length !== expectedLength;
-          } else {
-            return true; // non-array value. The input is a tuple.
-          }
-        });
-
-        inputIsSingleTuple = firstNonUniformTupleValueIndex !== -1;
-      } else {
-        inputIsSingleTuple = true;
-        return [input];
-      }
-      // first value of the tuple could also be an array. If it is, check the other tuples all have the same length.
-      if (inputIsSingleTuple) {
-        return [input];
-      } else {
-        return input;
-      }
-    } else {
-      return input; // is an empty array.
+function removeValuesAtIndexesFromArrayCopy(array, removeIndexes) {
+  const result = [];
+  const ignoredIndexes = iterableToSet(removeIndexes);
+  array.forEach((value, index) => {
+    if (!ignoredIndexes.has(index)) {
+      result.push(value);
     }
-  } else {
-    throw new Error('Input is not an array/tuple...');
-  }
+  });
+  return result;
 }
 
 /**
@@ -2828,33 +2843,43 @@ function isSameNonNullValue(a, b) {
 function valuesAreBothNullishOrEquivalent(a, b) {
   return a != null && b != null ? a === b : a == b;
 }
+/**
+ * Updates "a" with "b".
+ *
+ * - If b is defined, then returns b
+ * - If b is undefined, then returns a
+ * - If b is null, then returns null
+ *
+ * @param a
+ * @param b
+ */
+function updateMaybeValue(a, b) {
+  return b === undefined ? a : b;
+}
 
+function filterMaybeArrayFunction(filterFn) {
+  return values => {
+    if (values != null) {
+      return values.filter(filterFn);
+    } else {
+      return [];
+    }
+  };
+}
 /**
  * Filters all maybe values from the input array. If a maybe value is input, returns an empty array.
  *
  * @param values
  * @returns
  */
-function filterMaybeValues(values) {
-  if (values != null) {
-    return values.filter(hasNonNullValue);
-  } else {
-    return [];
-  }
-}
+const filterMaybeArrayValues = filterMaybeArrayFunction(hasNonNullValue);
 /**
  * Filters all empty and maybe values from the input array. If a maybe value is input, returns an empty array.
  *
  * @param values
  * @returns
  */
-function filterEmptyValues(values) {
-  if (values != null) {
-    return values.filter(hasValueOrNotEmpty);
-  } else {
-    return [];
-  }
-}
+const filterEmptyArrayValues = filterMaybeArrayFunction(hasValueOrNotEmpty);
 /**
  * Checks whether or not all values are MaybeNot values.
  *
@@ -2873,6 +2898,25 @@ function allValuesAreMaybeNot(values) {
 function allValuesAreNotMaybe(values) {
   return values.findIndex(x => x == null) === -1;
 }
+// MARK: Compat
+/**
+ * Filters all maybe values from the input array. If a maybe value is input, returns an empty array.
+ *
+ * @param values
+ * @returns
+ *
+ * @deprecated use filterMaybeArrayValues instead.
+ */
+const filterMaybeValues = filterMaybeArrayValues;
+/**
+ * Filters all empty and maybe values from the input array. If a maybe value is input, returns an empty array.
+ *
+ * @param values
+ * @returns
+ *
+ * @deprecated use filterEmptyArrayValues instead.
+ */
+const filterEmptyValues = filterEmptyArrayValues;
 
 /**
  * Convenience function that is used to "build" an object of a specific type.
@@ -2952,7 +2996,7 @@ function mapFunctionOutput(output, input) {
  * @param fns
  */
 function chainMapSameFunctions(input) {
-  const fns = filterMaybeValues(asArray(input).filter(x => !isMapIdentityFunction(x))); // remove all identify functions too
+  const fns = filterMaybeArrayValues(asArray(input).filter(x => !isMapIdentityFunction(x))); // remove all identify functions too
   let fn;
   switch (fns.length) {
     case 0:
@@ -3000,7 +3044,7 @@ function unique(values, excludeInput) {
   return Array.from(unique);
 }
 function readKeysFromFilterUniqueFunctionAdditionalKeysInput(additionalKeysInput, readKey) {
-  return filterMaybeValues(additionalKeysInput != null ? Array.isArray(additionalKeysInput) ? additionalKeysInput : readKeysFromFilterUniqueFunctionAdditionalKeys(additionalKeysInput, readKey) : []);
+  return filterMaybeArrayValues(additionalKeysInput != null ? Array.isArray(additionalKeysInput) ? additionalKeysInput : readKeysFromFilterUniqueFunctionAdditionalKeys(additionalKeysInput, readKey) : []);
 }
 function readKeysFromFilterUniqueFunctionAdditionalKeys(input, readKey) {
   const keys = new Set(input.keys);
@@ -3020,7 +3064,7 @@ function filterUniqueFunction(readKey, additionalKeysInput) {
   const baseKeys = readKeysFromFilterUniqueFunctionAdditionalKeysInput(additionalKeysInput, readKey);
   function calculateExclude(excludeInput) {
     const newExcludeKeys = excludeInput ? Array.isArray(excludeInput) ? excludeInput.map(readKey) : readKeysFromFilterUniqueFunctionAdditionalKeys(excludeInput, readKey) : [];
-    return newExcludeKeys != null && newExcludeKeys.length ? mergeArrays([filterMaybeValues(newExcludeKeys), baseKeys]) : baseKeys;
+    return newExcludeKeys != null && newExcludeKeys.length ? mergeArrays([filterMaybeArrayValues(newExcludeKeys), baseKeys]) : baseKeys;
   }
   return (input, excludeInput) => {
     const exclude = calculateExclude(excludeInput);
@@ -5103,6 +5147,12 @@ function range(input, inputEnd) {
   return range;
 }
 
+/**
+ * The default index number when no index is set.
+ *
+ * Only applicable for non-negative indexes.
+ */
+const UNSET_INDEX_NUMBER = -1;
 /**
  * Convenience function for calling readKeysToMap() and keying the values by their index number.
  *
@@ -5186,6 +5236,20 @@ function computeNextFreeIndexFunction(readIndex, nextIndex) {
     }
   };
 }
+/**
+ * Creates a new ComputeNextFreeIndexFunction that assumes that the input values are sorted in ascending order, with the latest index at the end.
+ */
+function computeNextFreeIndexOnSortedValuesFunction(readIndex, nextIndex) {
+  const readNextIndex = nextIndex != null ? nextIndex : x => readIndex(x) + 1; //return the max index + 1 by default.
+  return sortedValues => {
+    const lastValueInSorted = lastValue(sortedValues);
+    if (lastValueInSorted != null) {
+      return readNextIndex(lastValueInSorted);
+    } else {
+      return 0;
+    }
+  };
+}
 /**
  * Returns a MinAndMaxIndexFunction.
  *
@@ -6557,6 +6621,34 @@ function repeatString(string, reapeat) {
   }
   return result;
 }
+const DEFAULT_CUT_STRING_END_TEXT = '...';
+function cutStringFunction(config) {
+  const {
+    maxLength: inputMaxLength,
+    maxLengthIncludesEndText,
+    endText: inputEndText
+  } = config;
+  const endText = inputEndText === undefined ? DEFAULT_CUT_STRING_END_TEXT : '';
+  const maxLength = maxLengthIncludesEndText !== false ? inputMaxLength - endText.length : inputMaxLength;
+  return input => {
+    let result = input;
+    if (input != null) {
+      const inputLength = input.length;
+      if (inputLength > inputMaxLength) {
+        result = input.substring(0, maxLength) + endText;
+      } else {
+        result = input;
+      }
+    }
+    return result;
+  };
+}
+function cutString(input, maxLength, endText) {
+  return cutStringFunction({
+    maxLength,
+    endText
+  })(input);
+}
 
 /**
  * map utility function for an iterable that maps and places the results into an array.
@@ -6997,7 +7089,7 @@ function authRolesSetHasRoles(authRolesSet, roles) {
  * @returns
  */
 function mergeFilterFunctions(...inputFilters) {
-  const filters = filterMaybeValues(inputFilters);
+  const filters = filterMaybeArrayValues(inputFilters);
   let filter;
   switch (filters.length) {
     case 0:
@@ -7257,7 +7349,7 @@ function mergeObjectsFunction(filter) {
     dynamic: true // no need to use cache, as cache won't be used.
   });
 
-  return objects => overrideFn(filterMaybeValues(objects))({});
+  return objects => overrideFn(filterMaybeArrayValues(objects))({});
 }
 // MARK: POJO
 /**
@@ -7408,8 +7500,9 @@ function filterFromPOJOFunction({
       delete object[key];
     }
   });
-  return obj => {
-    if (copy) {
+  return (obj, copyOverride) => {
+    const copyObj = typeof copyOverride === 'boolean' ? copyOverride : copy;
+    if (copyObj) {
       obj = Object.assign({}, obj);
     }
     forEachFn(obj);
@@ -7472,6 +7565,27 @@ function valuesFromPOJOFunction(filter = exports.KeyValueTypleValueFilter.UNDEFI
     return context.values;
   };
 }
+// MARK: Filter Keys
+/**
+ * Returns a FilterTuplesOnPOJOFunction that returns an object that contains only the input keys, or does not contain the input keys if invertFilter is true.
+ *
+ * @param keysToFilter
+ * @returns
+ */
+function filterKeysOnPOJOFunction(keysToFilter, invertFilter = false) {
+  const keysSet = new Set(keysToFilter);
+  const filterFn = invertBooleanReturnFunction(([key]) => keysSet.has(key), invertFilter);
+  return filterTuplesOnPOJOFunction(filterFn);
+}
+function filterTuplesOnPOJOFunction(filterTupleOnObject) {
+  return input => {
+    const result = {};
+    Object.entries(input).filter(filterTupleOnObject).forEach(tuple => {
+      result[tuple[0]] = tuple[1];
+    });
+    return result;
+  };
+}
 function forEachKeyValueOnPOJOFunction({
   forEach,
   filter
@@ -7483,60 +7597,6 @@ function forEachKeyValueOnPOJOFunction({
   };
 }
 
-/**
- * Converts an ObjectMap into a Map.
- *
- * @param object
- * @returns
- */
-function objectToMap(object) {
-  return new Map(objectToTuples(object));
-}
-/**
- * Converts an ObjectMap into tuples.
- *
- * @param object
- * @returns
- */
-function objectToTuples(object) {
-  const keys = Object.keys(object);
-  return keys.map(x => [x, object[x]]);
-}
-/**
- * Creates a MapObjectMapFunction that calls mapObjectMap().
- *
- * @param mapFn
- * @returns
- */
-function mapObjectMapFunction(mapFn) {
-  return object => mapObjectMap(object, mapFn);
-}
-/**
- * Maps the values of an ObjectMap from one type to another and returns an ObjectMap containing that type.
- *
- * @param object
- */
-function mapObjectMap(object, mapFn) {
-  const mappedObject = {};
-  return mapObjectToTargetObject(object, mappedObject, mapFn);
-}
-/**
- * Maps the values of an ObjectMap from one type to the target and return the target.
- *
- * @param object
- * @param target
- * @param mapFn
- * @returns
- */
-function mapObjectToTargetObject(object, target, mapFn) {
-  const keys = Object.keys(object);
-  keys.forEach(key => {
-    const value = object[key];
-    target[key] = mapFn(value, key);
-  });
-  return target;
-}
-
 /**
  * Determines whether the input values are "allowed" for the given AllowedSet.
  *
@@ -7694,7 +7754,7 @@ function authRoleClaimsService(config, defaults = {}) {
     return entry.roles != null;
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const tuples = objectToTuples(config).filter(([, entry]) => entry != null) // skip any ignored/null values
+  const tuples = Object.entries(config).filter(([, entry]) => entry != null) // skip any ignored/null values
   .map(x => {
     const inputEntry = x[1];
     let entry;
@@ -8657,9 +8717,9 @@ function unitedStatesAddressString(input, addLinebreaks = true) {
       parts.push(`${state} ${zip}`);
     }
   }
-  const nonEmptyParts = filterEmptyValues(parts);
+  const nonEmptyParts = filterEmptyArrayValues(parts);
   if (nonEmptyParts.length > 0) {
-    address = filterEmptyValues(nonEmptyParts.map(x => x.trim())).join(lineBreakLine);
+    address = filterEmptyArrayValues(nonEmptyParts.map(x => x.trim())).join(lineBreakLine);
   }
   return address;
 }
@@ -12618,7 +12678,7 @@ function primativeKeyDencoder(config) {
   const map = primativeKeyDencoderMap(config.values);
   const fn = input => {
     if (Array.isArray(input)) {
-      const values = filterMaybeValues(input.map(x => map.get(x)));
+      const values = filterMaybeArrayValues(input.map(x => map.get(x)));
       return values;
     } else {
       let value = map.get(input);
@@ -14382,10 +14442,21 @@ function isLogicalDateStringCode(logicalDate) {
  * Recursively compares Arrays, Objects, Maps, Sets, Primatives, and Dates.
  */
 function areEqualPOJOValues(a, b) {
+  return areEqualPOJOValuesUsingPojoFilter(a, b, MAP_IDENTITY);
+}
+/**
+ * Performs a deep comparison to check if all values on the input filters are equal. Each input is run through the pojo filter
+ *
+ * Recursively compares Arrays, Objects, Maps, Sets, Primatives, and Dates.
+ */
+function areEqualPOJOValuesUsingPojoFilter(a, b, pojoFilter) {
   // check self
   if (a === b) {
     return true;
   }
+  // run pojo filter before comparison
+  a = pojoFilter(a, true);
+  b = pojoFilter(b, true);
   // check one value is nullish and other is not
   if ((a == null || b == null) && (a || b)) {
     return false;
@@ -14400,7 +14471,7 @@ function areEqualPOJOValues(a, b) {
         }
         const firstInequalityIndex = a.findIndex((aValue, i) => {
           const bValue = b[i];
-          return !areEqualPOJOValues(aValue, bValue);
+          return !areEqualPOJOValuesUsingPojoFilter(aValue, bValue, pojoFilter);
         });
         return firstInequalityIndex === -1;
       } else if (a instanceof Set) {
@@ -14412,14 +14483,15 @@ function areEqualPOJOValues(a, b) {
         }
         const firstInequalityIndex = Array.from(a.entries()).findIndex(([key, aValue]) => {
           const bValue = bMap.get(key);
-          return !areEqualPOJOValues(aValue, bValue);
+          return !areEqualPOJOValuesUsingPojoFilter(aValue, bValue, pojoFilter);
         });
         return firstInequalityIndex === -1;
       }
     } else if (typeof b === 'object') {
+      var _a, _b;
       // check contructors/types
-      const firstType = a == null ? void 0 : a.constructor.name;
-      const secondType = b == null ? void 0 : b.constructor.name;
+      const firstType = (_a = a) == null ? void 0 : _a.constructor.name;
+      const secondType = (_b = b) == null ? void 0 : _b.constructor.name;
       if (firstType !== secondType) {
         return false; // false if not the same type
       }
@@ -14437,7 +14509,7 @@ function areEqualPOJOValues(a, b) {
         const firstInequalityIndex = aKeys.findIndex(key => {
           const aKeyValue = aObject[key];
           const bKeyValue = bObject[key];
-          return !areEqualPOJOValues(aKeyValue, bKeyValue);
+          return !areEqualPOJOValuesUsingPojoFilter(aKeyValue, bKeyValue, pojoFilter);
         });
         if (firstInequalityIndex === -1) {
           return true; // is equal if no non-matching key/value pair is found
@@ -14521,6 +14593,89 @@ function objectKeyEqualityComparatorFunction(readKey) {
   return safeEqualityComparatorFunction((a, b) => readKey(a) === readKey(b));
 }
 
+/**
+ * Converts an ObjectMap into a Map.
+ *
+ * @param object
+ * @returns
+ */
+function objectToMap(object) {
+  return new Map(Object.entries(object));
+}
+/**
+ * Creates a MapObjectMapFunction that calls mapObjectMap().
+ *
+ * @param mapFn
+ * @returns
+ */
+function mapObjectMapFunction(mapFn) {
+  return object => mapObjectMap(object, mapFn);
+}
+/**
+ * Maps the values of an ObjectMap from one type to another and returns an ObjectMap containing that type.
+ *
+ * @param object
+ */
+function mapObjectMap(object, mapFn) {
+  const mappedObject = {};
+  return mapObjectToTargetObject(object, mappedObject, mapFn);
+}
+/**
+ * Maps the values of an ObjectMap from one type to the target and return the target.
+ *
+ * @param object
+ * @param target
+ * @param mapFn
+ * @returns
+ */
+function mapObjectToTargetObject(object, target, mapFn) {
+  const keys = Object.keys(object);
+  keys.forEach(key => {
+    const value = object[key];
+    target[key] = mapFn(value, key);
+  });
+  return target;
+}
+/**
+ * Maps the keys of the input object to a new object with the mapped keys.
+ *
+ * @param object
+ */
+function mapObjectKeysFunction(mapKeyFn) {
+  return object => {
+    const target = {};
+    Object.entries(object).forEach(([key, value]) => {
+      const newKey = mapKeyFn(key, value);
+      target[newKey] = value;
+    });
+    return target;
+  };
+}
+/**
+ * Maps all the keys of an object to a new object with keys of the object mapped to lowercase.
+ *
+ * @param object
+ * @param target
+ * @param mapFn
+ */
+const mapObjectKeysToLowercase = mapObjectKeysFunction(key => {
+  let nextKey = key;
+  if (typeof key === 'string') {
+    nextKey = key.toLowerCase();
+  }
+  return nextKey;
+});
+// MARK: Compat
+/**
+ * Converts an ObjectMap into tuples.
+ *
+ * @deprecated use Object.entries instead.
+ *
+ * @param object
+ * @returns
+ */
+const objectToTuples = Object.entries;
+
 function makeCopyModelFieldFunction(key, inputConfig) {
   const config = inputConfig != null ? inputConfig : {};
   const hasDefault = objectHasKey(config, 'default');
@@ -14647,8 +14802,8 @@ function copyField(defaultOutput) {
 
 function maybeMergeModelModifiers(input) {
   const modifiers = asArray(input);
-  const allModifyData = filterMaybeValues(modifiers.map(x => x.modifyData));
-  const allModifyModel = filterMaybeValues(modifiers.map(x => x.modifyModel));
+  const allModifyData = filterMaybeArrayValues(modifiers.map(x => x.modifyData));
+  const allModifyModel = filterMaybeArrayValues(modifiers.map(x => x.modifyModel));
   const modifyData = maybeMergeModifiers(allModifyData);
   const modifyModel = maybeMergeModifiers(allModifyModel);
   return {
@@ -15633,7 +15788,7 @@ function makeHashDecodeMap(decodeValues, hashFn) {
 }
 function decodeHashedValuesWithDecodeMap(hashedValues, decodeMap) {
   const values = hashedValues.map(x => decodeMap.get(x));
-  return filterMaybeValues(values);
+  return filterMaybeArrayValues(values);
 }
 
 /**
@@ -16128,6 +16283,7 @@ exports.BooleanStringKeyArrayUtilityInstance = BooleanStringKeyArrayUtilityInsta
 exports.CATCH_ALL_HANDLE_RESULT_KEY = CATCH_ALL_HANDLE_RESULT_KEY;
 exports.CUT_VALUE_TO_ZERO_PRECISION = CUT_VALUE_TO_ZERO_PRECISION;
 exports.DATE_NOW_VALUE = DATE_NOW_VALUE;
+exports.DEFAULT_CUT_STRING_END_TEXT = DEFAULT_CUT_STRING_END_TEXT;
 exports.DEFAULT_LAT_LNG_STRING_VALUE = DEFAULT_LAT_LNG_STRING_VALUE;
 exports.DEFAULT_RANDOM_EMAIL_FACTORY_CONFIG = DEFAULT_RANDOM_EMAIL_FACTORY_CONFIG;
 exports.DEFAULT_RANDOM_PHONE_NUMBER_FACTORY_CONFIG = DEFAULT_RANDOM_PHONE_NUMBER_FACTORY_CONFIG;
@@ -16217,6 +16373,7 @@ exports.TimerCancelledError = TimerCancelledError;
 exports.TimerInstance = TimerInstance;
 exports.TypedServiceRegistryInstance = TypedServiceRegistryInstance;
 exports.UNLOADED_PAGE = UNLOADED_PAGE;
+exports.UNSET_INDEX_NUMBER = UNSET_INDEX_NUMBER;
 exports.US_STATE_CODE_STRING_REGEX = US_STATE_CODE_STRING_REGEX;
 exports.UTC_DATE_STRING_REGEX = UTC_DATE_STRING_REGEX;
 exports.UTC_TIMEZONE_STRING = UTC_TIMEZONE_STRING;
@@ -16252,6 +16409,7 @@ exports.applyToMultipleFields = applyToMultipleFields;
 exports.approximateTimerEndDate = approximateTimerEndDate;
 exports.areEqualContext = areEqualContext;
 exports.areEqualPOJOValues = areEqualPOJOValues;
+exports.areEqualPOJOValuesUsingPojoFilter = areEqualPOJOValuesUsingPojoFilter;
 exports.arrayContainsDuplicateValue = arrayContainsDuplicateValue;
 exports.arrayContentsDiffer = arrayContentsDiffer;
 exports.arrayDecision = arrayDecision;
@@ -16307,6 +16465,7 @@ exports.compareFnOrder = compareFnOrder;
 exports.compareWithMappedValuesFunction = compareWithMappedValuesFunction;
 exports.computeNextFractionalHour = computeNextFractionalHour;
 exports.computeNextFreeIndexFunction = computeNextFreeIndexFunction;
+exports.computeNextFreeIndexOnSortedValuesFunction = computeNextFreeIndexOnSortedValuesFunction;
 exports.concatArrays = concatArrays;
 exports.concatArraysUnique = concatArraysUnique;
 exports.containsAllStringsAnyCase = containsAllStringsAnyCase;
@@ -16332,6 +16491,8 @@ exports.countPOJOKeys = countPOJOKeys;
 exports.countPOJOKeysFunction = countPOJOKeysFunction;
 exports.cronExpressionRepeatingEveryNMinutes = cronExpressionRepeatingEveryNMinutes;
 exports.cssClassesSet = cssClassesSet;
+exports.cutString = cutString;
+exports.cutStringFunction = cutStringFunction;
 exports.cutToPrecision = cutToPrecision;
 exports.cutValueToInteger = cutValueToInteger;
 exports.cutValueToPrecision = cutValueToPrecision;
@@ -16379,6 +16540,7 @@ exports.expandTrees = expandTrees;
 exports.exponentialPromiseRateLimiter = exponentialPromiseRateLimiter;
 exports.extendLatLngBound = extendLatLngBound;
 exports.filterAndMapFunction = filterAndMapFunction;
+exports.filterEmptyArrayValues = filterEmptyArrayValues;
 exports.filterEmptyValues = filterEmptyValues;
 exports.filterFalsyAndEmptyValues = filterFalsyAndEmptyValues;
 exports.filterFromIterable = filterFromIterable;
@@ -16388,9 +16550,13 @@ exports.filterKeyValueTupleFunction = filterKeyValueTupleFunction;
 exports.filterKeyValueTuples = filterKeyValueTuples;
 exports.filterKeyValueTuplesFunction = filterKeyValueTuplesFunction;
 exports.filterKeyValueTuplesInputToFilter = filterKeyValueTuplesInputToFilter;
+exports.filterKeysOnPOJOFunction = filterKeysOnPOJOFunction;
+exports.filterMaybeArrayFunction = filterMaybeArrayFunction;
+exports.filterMaybeArrayValues = filterMaybeArrayValues;
 exports.filterMaybeValues = filterMaybeValues;
 exports.filterNullAndUndefinedValues = filterNullAndUndefinedValues;
 exports.filterOnlyUndefinedValues = filterOnlyUndefinedValues;
+exports.filterTuplesOnPOJOFunction = filterTuplesOnPOJOFunction;
 exports.filterUndefinedValues = filterUndefinedValues;
 exports.filterUniqueByIndex = filterUniqueByIndex;
 exports.filterUniqueCaseInsensitiveStrings = filterUniqueCaseInsensitiveStrings;
@@ -16648,6 +16814,8 @@ exports.mapIdentityFunction = mapIdentityFunction;
 exports.mapIterable = mapIterable;
 exports.mapKeysIntersectionObjectToArray = mapKeysIntersectionObjectToArray;
 exports.mapMaybeFunction = mapMaybeFunction;
+exports.mapObjectKeysFunction = mapObjectKeysFunction;
+exports.mapObjectKeysToLowercase = mapObjectKeysToLowercase;
 exports.mapObjectMap = mapObjectMap;
 exports.mapObjectMapFunction = mapObjectMapFunction;
 exports.mapObjectToTargetObject = mapObjectToTargetObject;
@@ -16804,6 +16972,7 @@ exports.removeModelsWithSameKey = removeModelsWithSameKey;
 exports.removeModifiers = removeModifiers;
 exports.removeTrailingFileTypeSeparators = removeTrailingFileTypeSeparators;
 exports.removeTrailingSlashes = removeTrailingSlashes;
+exports.removeValuesAtIndexesFromArrayCopy = removeValuesAtIndexesFromArrayCopy;
 exports.removeWebProtocolPrefix = removeWebProtocolPrefix;
 exports.repeatString = repeatString;
 exports.replaceCharacterAtIndexIf = replaceCharacterAtIndexIf;
@@ -16922,6 +17091,7 @@ exports.uniqueCaseInsensitiveStringsSet = uniqueCaseInsensitiveStringsSet;
 exports.uniqueKeys = uniqueKeys;
 exports.uniqueModels = uniqueModels;
 exports.unitedStatesAddressString = unitedStatesAddressString;
+exports.updateMaybeValue = updateMaybeValue;
 exports.urlWithoutParameters = urlWithoutParameters;
 exports.useAsync = useAsync;
 exports.useCallback = useCallback;