@dereekb/util 13.11.1 → 13.11.3

package/index.esm.js

@@ -787,6 +787,14 @@ function _unsupported_iterable_to_array$A(o, minLen) {
  * const fn = readKeysFunction<string>((x) => x);
  * fn(['a', 'b', 'c']); // ['a', 'b', 'c']
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags key, read, factory, array, primitive
+ * @dbxUtilRelated read-keys-set-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function readKeysFunction(readKey) {
     return function(values) {
         var result;
@@ -824,6 +832,14 @@ function _unsupported_iterable_to_array$A(o, minLen) {
  * const fn = readKeysSetFunction<string>((x) => x);
  * fn(['a', 'b', 'a']); // Set { 'a', 'b' }
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags key, read, set, factory, dedupe, primitive
+ * @dbxUtilRelated read-keys-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function readKeysSetFunction(readKey) {
     return function(values) {
         var result;
@@ -1190,9 +1206,16 @@ function _unsupported_iterable_to_array$z(o, minLen) {
 /**
  * Creates a {@link SetHasValueFunction} from an {@link IterableOrValue} by first converting it to a Set.
  *
+ * @dbxUtil
+ * @dbxUtilCategory set
+ * @dbxUtilKind factory
+ * @dbxUtilTags set, has, decision, factory, membership, exclude
+ * @dbxUtilRelated set-has-value-function, set-includes-function
+ *
  * @param iterable - The values to create a set from.
  * @param exclude - If true, the returned function returns true for values NOT in the set.
  * @returns A function that tests membership.
+ * @__NO_SIDE_EFFECTS__
  */ function hasValueFunction(iterable) {
     var exclude = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
     var set = asSet(iterable);
@@ -1201,9 +1224,16 @@ function _unsupported_iterable_to_array$z(o, minLen) {
 /**
  * Creates a {@link SetHasValueFunction} for the given set. When `exclude` is true, returns the inverse (true for values not in the set).
  *
+ * @dbxUtil
+ * @dbxUtilCategory set
+ * @dbxUtilKind factory
+ * @dbxUtilTags set, has, decision, factory, membership, exclude
+ * @dbxUtilRelated has-value-function, set-includes-function
+ *
  * @param set - The set to check against.
  * @param exclude - If true, returns true for values NOT in the set.
  * @returns A function that tests membership.
+ * @__NO_SIDE_EFFECTS__
  */ function setHasValueFunction(set, exclude) {
     var hasValueFunction;
     if (exclude) {
@@ -1242,10 +1272,17 @@ function _unsupported_iterable_to_array$z(o, minLen) {
 /**
  * Creates a {@link SetIncludesFunction} that checks whether the set includes given values using the specified mode.
  *
+ * @dbxUtil
+ * @dbxUtilCategory set
+ * @dbxUtilKind factory
+ * @dbxUtilTags set, includes, decision, factory, all, any, mode
+ * @dbxUtilRelated has-value-function, set-has-value-function
+ *
  * @param valuesSet - The reference set.
  * @param mode - Whether to require 'all' values or 'any' value to be present. Defaults to 'all'.
  * @param emptyValuesToFindArrayResult - The result when the values to find are empty.
  * @returns A function that tests inclusion against the set.
+ * @__NO_SIDE_EFFECTS__
  */ function setIncludesFunction(valuesSet) {
     var mode = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'all', emptyValuesToFindArrayResult = arguments.length > 2 ? arguments[2] : void 0;
     var fn;
@@ -1418,9 +1455,16 @@ function _unsupported_iterable_to_array$y(o, minLen) {
 /**
  * Inverts the output of an arbitrary boolean-returning function.
  *
+ * @dbxUtil
+ * @dbxUtilCategory function
+ * @dbxUtilKind factory
+ * @dbxUtilTags function, boolean, invert, predicate, factory
+ * @dbxUtilRelated decision-function, filter-function
+ *
  * @param decisionFn - The function whose boolean return value to invert
  * @param invert - Whether to apply the inversion (defaults to true)
  * @returns The inverted function, or the original if invert is false
+ * @__NO_SIDE_EFFECTS__
  */ function invertBooleanReturnFunction(decisionFn) {
     var invert = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
     return invert ? function() {
@@ -1450,6 +1494,7 @@ function _unsupported_iterable_to_array$y(o, minLen) {
  * @param decision - Predicate used to test individual elements.
  * @param mode - Whether all or any elements must satisfy the predicate.
  * @returns A function that evaluates an array against the configured decision criteria.
+ * @__NO_SIDE_EFFECTS__
  */ function arrayDecisionFunction(decision, mode) {
     var findFn = mode === 'all' ? invertBooleanReturnFunction(decision) : decision;
     return invertBooleanReturnFunction(function(values) {
@@ -1761,8 +1806,15 @@ function _type_of$l(obj) {
 /**
  * Creates a {@link FilterMaybeArrayFunction} that filters maybe values from an array using the provided filter function.
  *
+ * @dbxUtil
+ * @dbxUtilCategory array
+ * @dbxUtilKind factory
+ * @dbxUtilTags array, filter, maybe, factory, predicate
+ * @dbxUtilRelated filter-maybe-array-values
+ *
  * @param filterFn - Filter predicate used to determine which values to keep.
  * @returns A function that filters maybe values from an optional input array.
+ * @__NO_SIDE_EFFECTS__
  */ function filterMaybeArrayFunction(filterFn) {
     return function(values) {
         var result;
@@ -1872,6 +1924,7 @@ function _type_of$l(obj) {
  * maybeDouble(undefined); // undefined
  * maybeDouble(null);      // null
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function mapMaybeFunction(mapFunction) {
     return function(input) {
         var output = isMaybeNot(input) ? input : mapFunction(input);
@@ -1889,6 +1942,7 @@ function _type_of$l(obj) {
  *
  * @param mapFunction - per-element transformation
  * @returns a function that maps entire arrays
+ * @__NO_SIDE_EFFECTS__
  */ function mapArrayFunction(mapFunction) {
     return function(input) {
         return input.map(mapFunction);
@@ -1914,15 +1968,27 @@ function _type_of$l(obj) {
 /**
  * Returns the shared {@link MAP_IDENTITY} function cast to the requested type, useful for providing a typed no-op transformation.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilTags map, identity, no-op, typed
+ * @dbxUtilRelated map-identity, is-map-identity-function
+ *
  * @returns the singleton identity function typed as `MapFunction<T, T>`
+ * @__NO_SIDE_EFFECTS__
  */ function mapIdentityFunction() {
     return MAP_IDENTITY;
 }
 /**
  * Checks whether the given function is the singleton {@link MAP_IDENTITY} reference.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilTags map, identity, type-guard, sentinel
+ * @dbxUtilRelated map-identity, map-identity-function
+ *
  * @param fn - the function to check
  * @returns `true` if the function is the identity singleton
+ * @__NO_SIDE_EFFECTS__
  */ function isMapIdentityFunction(fn) {
     return fn === MAP_IDENTITY;
 }
@@ -1990,6 +2056,8 @@ function _type_of$l(obj) {
  * const result = fnChain('aaaab');
  * // result === 'aaaab'
  * ```
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function chainMapSameFunctions(input) {
     var fns = filterMaybeArrayValues(asArray(input).filter(function(x) {
         return !isMapIdentityFunction(x);
@@ -2127,6 +2195,7 @@ function _unsupported_iterable_to_array$x(o, minLen) {
  * @param readKey - Function to extract a unique key from each item.
  * @param additionalKeysInput - Optional keys or values to pre-seed as already seen, causing them to be excluded.
  * @returns A reusable filter function that removes duplicate items from arrays.
+ * @__NO_SIDE_EFFECTS__
  */ function filterUniqueFunction(readKey, additionalKeysInput) {
     var baseKeys = readKeysFromFilterUniqueFunctionAdditionalKeysInput(additionalKeysInput, readKey);
     function calculateExclude(excludeInput) {
@@ -2177,6 +2246,7 @@ function _unsupported_iterable_to_array$x(o, minLen) {
  *
  * @param readKey - Function to extract a unique key from each item.
  * @returns A decision function that returns true if all items have distinct keys.
+ * @__NO_SIDE_EFFECTS__
  */ function isUniqueKeyedFunction(readKey) {
     return function(input) {
         var keys = new Set();
@@ -2302,9 +2372,15 @@ function makeModelMap(input, read) {
  *
  * If multiple models share the same relation key, the last one wins for that key.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilTags model, map, key, multi, relation, index, lookup
+ * @dbxUtilRelated make-model-map, read-model-key
+ *
  * @param input - Array of models to index
  * @param read - Function that returns an array of relation keys for each model
  * @returns Map from relation key to model
+ * @__NO_SIDE_EFFECTS__
  */ function makeMultiModelKeyMap(input, read) {
     var map = new Map();
     input.forEach(function(x) {
@@ -2456,9 +2532,16 @@ function readModelKey(input) {
  *
  * Falls back to the provided default type if the type reader returns a nullish value.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, type, pair, factory, wrap
+ * @dbxUtilRelated read-model-key, encode-model-key-type-pair
+ *
  * @param typeReader - Function to extract the model type from input data
  * @param defaultType - Fallback type string when the reader returns nullish
  * @returns Factory function that produces ModelTypeDataPair values
+ * @__NO_SIDE_EFFECTS__
  */ function modelTypeDataPairFactory(typeReader) {
     var defaultType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_UNKNOWN_MODEL_TYPE_STRING;
     return function(data) {
@@ -2937,6 +3020,7 @@ function reverseCompareFn(compareFn) {
  * [{ name: 'Bob' }, { name: 'Alice' }].sort(byName);
  * // [{ name: 'Alice' }, { name: 'Bob' }]
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function compareWithMappedValuesFunction(mapValue, comparesFunction) {
     return function(a, b) {
         var vA = mapValue(a);
@@ -3002,12 +3086,19 @@ function reverseCompareFn(compareFn) {
  * @param compareFn - Ascending sort comparison function used to determine min/max.
  * @returns A function that returns `{ min, max }` or `null` for empty iterables.
  *
+ * @dbxUtil
+ * @dbxUtilCategory sort
+ * @dbxUtilKind factory
+ * @dbxUtilTags sort, min, max, factory, iterable, compare
+ * @dbxUtilRelated min-and-max-index-items-function, sort-by-number-function
+ *
  * @example
  * ```ts
  * const fn = minAndMaxFunction<number>((a, b) => a - b);
  * fn([3, 1, 4, 1, 5]); // { min: 1, max: 5 }
  * fn([]);               // null
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function minAndMaxFunction(compareFn) {
     return function(values) {
         var _firstValueFromIterable;
@@ -3301,9 +3392,15 @@ function _unsupported_iterable_to_array$t(o, minLen) {
 /**
  * Creates an array of `[key, value]` tuples by extracting a key from each value.
  *
+ * @dbxUtil
+ * @dbxUtilCategory grouping
+ * @dbxUtilTags grouping, key, pairs, tuple, array
+ * @dbxUtilRelated group-values, make-values-group-map
+ *
  * @param values - Values to create key pairs from.
  * @param keyFn - Extracts the key from each value.
  * @returns An array of `[key, value]` tuples.
+ * @__NO_SIDE_EFFECTS__
  */ function makeKeyPairs(values, keyFn) {
     return values.map(function(x) {
         return [
@@ -3469,8 +3566,15 @@ function _unsupported_iterable_to_array$s(o, minLen) {
 /**
  * Creates a KeyValueMapFactory that maps values by their key using a ReadKeyFunction.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags map, key, factory, lookup, index
+ * @dbxUtilRelated multi-key-value-map-factory, read-keys-to-map
+ *
  * @param read - Function that extracts a key from each value
  * @returns A factory that creates Maps from arrays of values
+ * @__NO_SIDE_EFFECTS__
  */ function keyValueMapFactory(read) {
     return function(values) {
         var map = new Map();
@@ -3496,8 +3600,15 @@ function _unsupported_iterable_to_array$s(o, minLen) {
  * Creates a KeyValueMapFactory that maps values by multiple keys using a ReadMultipleKeysFunction.
  * Each value can appear under multiple keys.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags map, key, multi, factory, lookup, index
+ * @dbxUtilRelated key-value-map-factory, read-multiple-keys-to-map
+ *
  * @param read - Function that extracts multiple keys from each value
  * @returns A factory that creates Maps from arrays of values
+ * @__NO_SIDE_EFFECTS__
  */ function multiKeyValueMapFactory(read) {
     return function(values) {
         var map = new Map();
@@ -3613,8 +3724,15 @@ function _unsupported_iterable_to_array$s(o, minLen) {
  * Creates an {@link IsSelectedDecisionFunctionFactory} that produces decision functions
  * checking whether a value's key is included in a set of selected values.
  *
+ * @dbxUtil
+ * @dbxUtilCategory set
+ * @dbxUtilKind factory
+ * @dbxUtilTags set, selection, decision, predicate, factory, key
+ * @dbxUtilRelated is-in-set-decision-function
+ *
  * @param config - Configuration with the key reader and default behavior.
  * @returns A factory that creates decision functions from a set of selected keys.
+ * @__NO_SIDE_EFFECTS__
  */ function isSelectedDecisionFunctionFactory(config) {
     var readKey = config.readKey, _config_defaultIfKeyNull = config.defaultIfKeyNull, defaultIfKeyNull = _config_defaultIfKeyNull === void 0 ? false : _config_defaultIfKeyNull;
     return function(selectedValues) {
@@ -3772,6 +3890,7 @@ function _unsupported_iterable_to_array$s(o, minLen) {
  *
  * @param x - The value to check.
  * @returns Whether the value is a non-class function.
+ * @__NO_SIDE_EFFECTS__
  */ // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 function isNonClassFunction(x) {
     var type = getFunctionType(x);
@@ -3825,6 +3944,7 @@ function getValueFromGetter(input, args) {
  * @param value - The object to copy
  * @param copyFunction - Optional custom copy function (defaults to copyObject)
  * @returns A factory that produces copies of the value
+ * @__NO_SIDE_EFFECTS__
  */ function objectCopyFactory(value) {
     var copyFunction = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : copyObject;
     return function() {
@@ -3835,17 +3955,31 @@ function getValueFromGetter(input, args) {
  * Converts the input to an ObjectCopyFactory. If the input is an object, wraps it with objectCopyFactory.
  * If it's already a function (Getter), it's returned directly.
  *
+ * @dbxUtil
+ * @dbxUtilCategory getter
+ * @dbxUtilKind factory
+ * @dbxUtilTags getter, factory, copy, clone, object, normalize
+ * @dbxUtilRelated object-copy-factory, as-getter
+ *
  * @param input - An object value or a getter function
  * @param copyFunction - Optional custom copy function
  * @returns An ObjectCopyFactory for the input
+ * @__NO_SIDE_EFFECTS__
  */ function asObjectCopyFactory(input, copyFunction) {
     return (typeof input === "undefined" ? "undefined" : _type_of$j(input)) === 'object' ? objectCopyFactory(input, copyFunction) : asGetter(input);
 }
 /**
  * Wraps the input value in a Getter function that always returns it.
  *
+ * @dbxUtil
+ * @dbxUtilCategory getter
+ * @dbxUtilKind factory
+ * @dbxUtilTags getter, factory, wrap, constant
+ * @dbxUtilRelated as-getter, get-value-from-getter
+ *
  * @param input - The value to wrap
  * @returns A Getter that returns the input value
+ * @__NO_SIDE_EFFECTS__
  */ function makeGetter(input) {
     return function() {
         return input;
@@ -3854,9 +3988,15 @@ function getValueFromGetter(input, args) {
 /**
  * Calls a factory function the specified number of times and returns the results as an array.
  *
+ * @dbxUtil
+ * @dbxUtilCategory getter
+ * @dbxUtilTags getter, factory, generate, array, count
+ * @dbxUtilRelated make-with-factory-input, array-factory
+ *
  * @param factory - The factory function to call (receives the current index as argument)
  * @param count - The number of items to create
  * @returns An array of produced values
+ * @__NO_SIDE_EFFECTS__
  */ function makeWithFactory(factory, count) {
     var results = [];
     for(var i = 0; i < count; i += 1){
@@ -3873,8 +4013,15 @@ function makeWithFactoryInput(factory, input) {
  * Wraps a factory so that no arguments are forwarded when it's called.
  * Useful for protecting a factory from accidentally receiving arguments.
  *
+ * @dbxUtil
+ * @dbxUtilCategory getter
+ * @dbxUtilKind factory
+ * @dbxUtilTags getter, factory, protect, wrap, no-args
+ * @dbxUtilRelated as-getter, make-getter
+ *
  * @param factory - The factory to wrap
  * @returns A new factory that calls the original with no arguments
+ * @__NO_SIDE_EFFECTS__
  */ function protectedFactory(factory) {
     return function() {
         return factory();
@@ -3887,6 +4034,12 @@ function makeWithFactoryInput(factory, input) {
  * @param config - Configuration with optional `startAt` (default 0) and `increaseBy` (default 1)
  * @returns A factory function that returns the next number in the sequence on each call
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, factory, increment, sequence, counter
+ * @dbxUtilRelated random-number-factory
+ *
  * @example
  * ```ts
  * const factory = incrementingNumberFactory({ startAt: 10, increaseBy: 5 });
@@ -3894,6 +4047,7 @@ function makeWithFactoryInput(factory, input) {
  * factory(); // 15
  * factory(); // 20
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function incrementingNumberFactory() {
     var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     var initial = config.startAt, inputIncreaseBy = config.increaseBy;
@@ -3927,6 +4081,7 @@ function makeWithFactoryInput(factory, input) {
  * @param bounds - The min/max bounds to test against
  * @returns A function that returns `true` if the input number is within bounds
  * @throws Error if the bounds are invalid (min > max)
+ * @__NO_SIDE_EFFECTS__
  */ function isInNumberBoundFunction(bounds) {
     var min = bounds.min, max = bounds.max;
     if (!isValidNumberBound(bounds)) {
@@ -3949,6 +4104,7 @@ function makeWithFactoryInput(factory, input) {
  *
  * @param wrapNumberFunctionConfig - Configuration with min, max, and optional fence post behavior
  * @returns A function that wraps input numbers into the bounded range
+ * @__NO_SIDE_EFFECTS__
  */ function wrapNumberFunction(wrapNumberFunctionConfig) {
     var min = wrapNumberFunctionConfig.min, max = wrapNumberFunctionConfig.max, _wrapNumberFunctionConfig_fencePosts = wrapNumberFunctionConfig.fencePosts, fencePosts = _wrapNumberFunctionConfig_fencePosts === void 0 ? false : _wrapNumberFunctionConfig_fencePosts;
     var distance = max - min;
@@ -3980,6 +4136,7 @@ function makeWithFactoryInput(factory, input) {
  *
  * @param boundNumberFunctionConfig - Configuration with min, max, and optional wrap behavior
  * @returns A function that bounds input numbers into the configured range
+ * @__NO_SIDE_EFFECTS__
  */ function boundNumberFunction(boundNumberFunctionConfig) {
     var min = boundNumberFunctionConfig.min, max = boundNumberFunctionConfig.max, wrap = boundNumberFunctionConfig.wrap;
     return wrap ? wrapNumberFunction(boundNumberFunctionConfig) : function(input) {
@@ -4203,6 +4360,7 @@ function _type_of$h(obj) {
  *
  * @param type - The rounding strategy: 'floor', 'ceil', 'round', or 'none'
  * @returns The corresponding Math function, or an identity function for 'none'
+ * @__NO_SIDE_EFFECTS__
  */ function roundingFunction(type) {
     var fn;
     switch(type){
@@ -4259,9 +4417,16 @@ function _type_of$h(obj) {
 /**
  * Creates a {@link CutValueToPrecisionFunction} that truncates values to the configured precision.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, precision, cut, truncate, factory, round
+ * @dbxUtilRelated round-to-precision-function, cut-to-precision
+ *
  * @param precision - Number of decimal places to retain
  * @param roundingType - Rounding strategy; defaults to 'cut' (truncation)
  * @returns A function that accepts a number or string and returns the truncated number
+ * @__NO_SIDE_EFFECTS__
  */ function cutValueToPrecisionFunction(precision) {
     var roundingType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'cut';
     var roundFn = roundToPrecisionFunction(precision, roundingType);
@@ -4274,9 +4439,16 @@ function _type_of$h(obj) {
 /**
  * Creates a function that rounds numbers to the specified precision using a configurable rounding strategy.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, round, precision, factory, decimals
+ * @dbxUtilRelated cut-value-to-precision-function, round-to-precision, cut-to-precision
+ *
  * @param precision - Number of decimal places
  * @param roundFn - Rounding strategy; defaults to 'round'. Use 'cut' for truncation.
  * @returns A function that rounds numbers to the configured precision
+ * @__NO_SIDE_EFFECTS__
  */ function roundToPrecisionFunction(precision) {
     var roundFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'round';
     var result;
@@ -4329,9 +4501,16 @@ function _type_of$h(obj) {
  *
  * Accepts either a step number (uses 'ceil' rounding) or a full config with step, rounding type, and origin.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, round, step, factory, multiple, origin
+ * @dbxUtilRelated round-number-up-to-step, round-to-precision-function
+ *
  * @param input - Step size or full configuration
  * @returns A function that rounds input numbers to the nearest step
  * @throws Error if step is 0 or undefined
+ * @__NO_SIDE_EFFECTS__
  */ function roundNumberToStepFunction(input) {
     var config = typeof input === 'number' ? {
         step: input,
@@ -4383,8 +4562,15 @@ var DOLLAR_AMOUNT_STRING_REGEX = /^\$?(\d+)\.?(\d\d)$/;
 /**
  * Creates a function that formats dollar amounts as strings with a unit prefix (e.g., "$12.50").
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, dollar, currency, format, factory, unit
+ * @dbxUtilRelated dollar-amount-string
+ *
  * @param unit - The unit prefix to prepend; defaults to "$"
  * @returns A function that formats dollar amounts with the configured unit
+ * @__NO_SIDE_EFFECTS__
  */ function dollarAmountStringWithUnitFunction() {
     var unit = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : '$';
     var fn = function fn(amount) {
@@ -4408,6 +4594,7 @@ var DOLLAR_AMOUNT_STRING_REGEX = /^\$?(\d+)\.?(\d\d)$/;
  * @param maxOrArgs - Maximum value (exclusive) or full configuration object
  * @param roundingInput - Optional rounding mode override
  * @returns A factory function that produces random numbers within the range
+ * @__NO_SIDE_EFFECTS__
  */ function randomNumberFactory(maxOrArgs, roundingInput) {
     var config = typeof maxOrArgs === 'number' ? {
         min: 0,
@@ -4453,8 +4640,15 @@ var DOLLAR_AMOUNT_STRING_REGEX = /^\$?(\d+)\.?(\d\d)$/;
 /**
  * Creates a {@link SortCompareFunction} that sorts values in ascending order by a numeric property.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, sort, compare, ascending, factory
+ * @dbxUtilRelated sort-numbers-ascending-function, sort-by-string-function
+ *
  * @param readNumberFn - Function that extracts the numeric value from each item
  * @returns A sort comparator function for ascending numeric order
+ * @__NO_SIDE_EFFECTS__
  */ function sortByNumberFunction(readNumberFn) {
     return function(a, b) {
         var as = readNumberFn(a);
@@ -4485,8 +4679,15 @@ var DOLLAR_AMOUNT_STRING_REGEX = /^\$?(\d+)\.?(\d\d)$/;
  *
  * Chains the configured operations in order: custom transform, step rounding, precision cut, then bounds clamping.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, transform, factory, round, precision, bounds, chain
+ * @dbxUtilRelated transform-string-function, round-number-to-step-function
+ *
  * @param config - Configuration with optional transform, roundToStep, precision, and bounds
  * @returns A single function that applies all configured transformations in sequence
+ * @__NO_SIDE_EFFECTS__
  */ function transformNumberFunction(config) {
     var transformFunctions = [
         config.transform
@@ -4714,12 +4915,19 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  *
  * @returns a compare function suitable for Array.sort()
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, sort, ascending, factory, ref
+ * @dbxUtilRelated sort-by-index-ascending-compare-function, sort-by-index-range-ascending-compare-function
+ *
  * @example
  * ```ts
  * const items = [{ i: 4 }, { i: 0 }, { i: 2 }];
  * items.sort(sortAscendingIndexNumberRefFunction());
  * // items[0].i === 0
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function sortAscendingIndexNumberRefFunction() {
     return function(a, b) {
         return a.i - b.i;
@@ -4741,6 +4949,12 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  * @param readIndex - reads an item's index, returning null/undefined for unindexed items
  * @returns a function that groups items by their index state
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, delta, group, factory, classify
+ * @dbxUtilRelated separate-values, compute-next-free-index-function
+ *
  * @example
  * ```ts
  * const groupFn = indexDeltaGroupFunction<{ x: string; i?: number }>((x) => x.i);
@@ -4749,6 +4963,7 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  * // result.newItems.length === 1     (item without an index)
  * // result.currentItems.length === 2 (items with indexes)
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function indexDeltaGroupFunction(readIndex) {
     return function(inputItems, previousItems) {
         var _separateValues = separateValues(inputItems, function(x) {
@@ -4786,8 +5001,15 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
 /**
  * Creates a SortCompareFunction that sorts items in ascending order using a custom index reader.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, sort, ascending, factory, compare
+ * @dbxUtilRelated sort-ascending-index-number-ref-function, sort-by-index-range-ascending-compare-function
+ *
  * @param readIndex - extracts the index number from each item
  * @returns a compare function suitable for Array.sort()
+ * @__NO_SIDE_EFFECTS__
  */ function sortByIndexAscendingCompareFunction(readIndex) {
     return function(a, b) {
         return readIndex(a) - readIndex(b);
@@ -4801,12 +5023,19 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  * @param nextIndex - optional custom function to compute the next index from the max item; defaults to max + 1
  * @returns a function that computes the next free index for a given array
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, free, next, factory, max
+ * @dbxUtilRelated compute-next-free-index-on-sorted-values-function, min-and-max-index-function
+ *
  * @example
  * ```ts
  * const fn = computeNextFreeIndexFunction<IndexRef>((x) => x.i);
  * const nextIndex = fn([{ i: 0 }, { i: 1 }, { i: 5 }]);
  * // nextIndex === 6
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function computeNextFreeIndexFunction(readIndex, nextIndex) {
     var findMinMax = minAndMaxIndexItemsFunction(readIndex);
     var readNextIndex = nextIndex !== null && nextIndex !== void 0 ? nextIndex : function(x) {
@@ -4822,9 +5051,16 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  * Creates a {@link ComputeNextFreeIndexFunction} optimized for pre-sorted input arrays.
  * Instead of scanning all items for the maximum, it reads only the last element.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, free, next, sorted, factory, optimized
+ * @dbxUtilRelated compute-next-free-index-function
+ *
  * @param readIndex - extracts the index number from each item
  * @param nextIndex - optional custom function to compute the next index from the last item; defaults to last + 1
  * @returns a function that computes the next free index from sorted arrays
+ * @__NO_SIDE_EFFECTS__
  */ function computeNextFreeIndexOnSortedValuesFunction(readIndex, nextIndex) {
     var readNextIndex = nextIndex !== null && nextIndex !== void 0 ? nextIndex : function(x) {
         return readIndex(x) + 1;
@@ -4840,12 +5076,19 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  * @param readIndex - extracts the index number from each item
  * @returns a function returning the min/max indexes, or null for empty input
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, min, max, factory, range
+ * @dbxUtilRelated min-and-max-index, min-and-max-index-items-function
+ *
  * @example
  * ```ts
  * const fn = minAndMaxIndexFunction<IndexRef>((x) => x.i);
  * const result = fn([{ i: 3 }, { i: 0 }, { i: 5 }]);
  * // result?.min === 0, result?.max === 5
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function minAndMaxIndexFunction(readIndex) {
     var minAndMaxItems = minAndMaxIndexItemsFunction(readIndex);
     var fn = function fn(values) {
@@ -4871,8 +5114,15 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  * Creates a {@link MinAndMaxIndexItemsFunction} that returns the actual items (not just index numbers)
  * with the minimum and maximum index values.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, min, max, items, factory
+ * @dbxUtilRelated min-and-max-index-function, min-and-max-function
+ *
  * @param readIndex - extracts the index number from each item
  * @returns a function returning the min/max items, or null for empty input
+ * @__NO_SIDE_EFFECTS__
  */ function minAndMaxIndexItemsFunction(readIndex) {
     var fn = minAndMaxFunction(readIndex);
     fn._readIndex = readIndex;
@@ -4927,6 +5177,14 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  * fn({ i: 6 });  // returns { i: 5 }
  * fn({ i: 11 }); // returns { i: 10 }
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, match, find, factory, lookup
+ * @dbxUtilRelated find-best-index-match, safe-find-best-index-match
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function findBestIndexMatchFunction(items) {
     // reverse the order so we can return the first item that is less than or equal to the input i
     var bestMatchArray = iterableToArray(items, false).sort(reverseCompareFn(sortAscendingIndexNumberRefFunction()));
@@ -4977,8 +5235,15 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  * Creates a SortCompareFunction that sorts items by their IndexRange in ascending order.
  * Sorts by minIndex first, then by maxIndex for items with equal minIndex values.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index-range, sort, ascending, factory, compare
+ * @dbxUtilRelated sort-by-index-ascending-compare-function, index-range-reader-pair-factory
+ *
  * @param readIndexRange - extracts the IndexRange from each item
  * @returns a compare function suitable for Array.sort()
+ * @__NO_SIDE_EFFECTS__
  */ function sortByIndexRangeAscendingCompareFunction(readIndexRange) {
     return function(a, b) {
         var ra = readIndexRange(a);
@@ -4990,8 +5255,15 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
 /**
  * Creates a new {@link IndexRangeReaderPairFactory} that pairs each value with its computed IndexRange.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index-range, pair, factory, reader
+ * @dbxUtilRelated sort-by-index-range-ascending-compare-function
+ *
  * @param reader - reads the IndexRange from the input value
  * @returns a factory that creates IndexRangeReaderPair instances
+ * @__NO_SIDE_EFFECTS__
  */ function indexRangeReaderPairFactory(reader) {
     return function(value) {
         var range = reader(value);
@@ -5016,8 +5288,15 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
 /**
  * Creates a {@link FitToIndexRangeFunction} that clamps index numbers to the given range boundaries.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, clamp, range, factory, fit
+ * @dbxUtilRelated wrap-index-range-function, bound-number-function
+ *
  * @param input - the range to clamp to
  * @returns a function that clamps any index to the range
+ * @__NO_SIDE_EFFECTS__
  */ function fitToIndexRangeFunction(input) {
     var min = input.minIndex, maxIndex = input.maxIndex;
     var max = maxIndex - 1;
@@ -5035,12 +5314,19 @@ function reduceNumbersFn(reduceFn, emptyArrayValue) {
  * @param fencePosts - whether to use fencepost semantics (maxIndex is exclusive); defaults to true
  * @returns a function that wraps any index into the range
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, wrap, range, factory, modular
+ * @dbxUtilRelated fit-to-index-range-function, wrap-number-function
+ *
  * @example
  * ```ts
  * const wrap = wrapIndexRangeFunction({ minIndex: 0, maxIndex: 6 });
  * wrap(6);  // 0 (wraps from positive side)
  * wrap(-1); // 5 (wraps from negative side)
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function wrapIndexRangeFunction(input) {
     var fencePosts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
     var min = input.minIndex, maxIndex = input.maxIndex;
@@ -5088,8 +5374,15 @@ function indexRangeCheckFunctionConfigToIndexRange(param) {
  * Creates an {@link IndexRangeCheckFunction} that tests whether an index number falls within the configured range.
  * The min is inclusive and the max is exclusive by default unless `inclusiveMaxIndex` is set.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, range, check, factory, predicate
+ * @dbxUtilRelated index-range-check-reader-function, is-index-number-in-index-range-function
+ *
  * @param input - the range or range config to check against
  * @returns a predicate function for index numbers
+ * @__NO_SIDE_EFFECTS__
  */ function indexRangeCheckFunction(input) {
     var _indexRangeCheckFunctionConfigToIndexRange = indexRangeCheckFunctionConfigToIndexRange(asIndexRangeCheckFunctionConfig(input)), minIndex = _indexRangeCheckFunctionConfigToIndexRange.minIndex, maxIndex = _indexRangeCheckFunctionConfigToIndexRange.maxIndex;
     return function(i) {
@@ -5113,8 +5406,15 @@ function indexRangeCheckFunctionConfigToIndexRange(param) {
 /**
  * Creates an {@link IsIndexNumberInIndexRangeFunction} bound to the given range configuration.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, range, check, factory, predicate
+ * @dbxUtilRelated is-index-number-in-index-range, index-range-check-function
+ *
  * @param input - the range or range config to bind
  * @returns a predicate that tests index numbers against the bound range
+ * @__NO_SIDE_EFFECTS__
  */ function isIndexNumberInIndexRangeFunction(input) {
     var _indexRangeCheckFunctionConfigToIndexRange = indexRangeCheckFunctionConfigToIndexRange(asIndexRangeCheckFunctionConfig(input)), minIndex = _indexRangeCheckFunctionConfigToIndexRange.minIndex, maxIndex = _indexRangeCheckFunctionConfigToIndexRange.maxIndex;
     return function(index) {
@@ -5133,8 +5433,15 @@ function indexRangeCheckFunctionConfigToIndexRange(param) {
 /**
  * Creates an {@link IsIndexRangeInIndexRangeFunction} bound to the given range configuration.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index-range, contains, decision, factory, predicate
+ * @dbxUtilRelated is-index-range-in-index-range, index-range-overlaps-index-range-function
+ *
  * @param input - the bounding range or range config to bind
  * @returns a predicate that tests whether index ranges are fully contained
+ * @__NO_SIDE_EFFECTS__
  */ function isIndexRangeInIndexRangeFunction(input) {
     var _indexRangeCheckFunctionConfigToIndexRange = indexRangeCheckFunctionConfigToIndexRange(asIndexRangeCheckFunctionConfig(input)), minIndex = _indexRangeCheckFunctionConfigToIndexRange.minIndex, maxIndex = _indexRangeCheckFunctionConfigToIndexRange.maxIndex;
     return function(input) {
@@ -5153,8 +5460,15 @@ function indexRangeCheckFunctionConfigToIndexRange(param) {
 /**
  * Creates an {@link IndexRangeOverlapsIndexRangeFunction} bound to the given range configuration.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index-range, overlap, decision, factory, predicate
+ * @dbxUtilRelated is-index-range-in-index-range-function, index-range-check-function
+ *
  * @param input - the reference range or range config to bind
  * @returns a predicate that tests for overlap with the bound range
+ * @__NO_SIDE_EFFECTS__
  */ function indexRangeOverlapsIndexRangeFunction(input) {
     var _indexRangeCheckFunctionConfigToIndexRange = indexRangeCheckFunctionConfigToIndexRange(asIndexRangeCheckFunctionConfig(input)), minIndex = _indexRangeCheckFunctionConfigToIndexRange.minIndex, maxIndex = _indexRangeCheckFunctionConfigToIndexRange.maxIndex;
     return function(input) {
@@ -5173,8 +5487,15 @@ function indexRangeCheckFunctionConfigToIndexRange(param) {
  * Creates a {@link StepsFromIndexFunction} that computes the next index after stepping from a start position.
  * Returns undefined when the result falls outside the range (unless wrapping or fitting is enabled).
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, index, step, range, factory, wrap, navigation
+ * @dbxUtilRelated wrap-index-range-function, fit-to-index-range-function
+ *
  * @param config - stepping behavior configuration
  * @returns a function that computes the stepped index
+ * @__NO_SIDE_EFFECTS__
  */ function stepsFromIndexFunction(config) {
     var range = config.range, _config_fitToRange = config.fitToRange, fitToRange = _config_fitToRange === void 0 ? false : _config_fitToRange, _config_fencePosts = config.fencePosts, fencePosts = _config_fencePosts === void 0 ? true : _config_fencePosts, tmp = config.wrapAround, defaultWrapAround = tmp === void 0 ? false : tmp, tmp1 = config.steps, defaultStep = tmp1 === void 0 ? 1 : tmp1;
     var wrapNumber = wrapIndexRangeFunction(range, fencePosts);
@@ -5314,8 +5635,15 @@ function stepsFromIndex(range, startIndex) {
 /**
  * Creates a {@link SliceIndexRangeFunction} that slices the specified index range from any input array.
  *
+ * @dbxUtil
+ * @dbxUtilCategory array
+ * @dbxUtilKind factory
+ * @dbxUtilTags array, slice, index, range, factory
+ * @dbxUtilRelated index-range, find-to-index-set
+ *
  * @param inputRange - the index range configuration to use for slicing
  * @returns a function that slices the configured range from an input array
+ * @__NO_SIDE_EFFECTS__
  */ function sliceIndexRangeFunction(inputRange) {
     var range = indexRange(inputRange);
     return function(input) {
@@ -5327,15 +5655,39 @@ function stepsFromIndex(range, startIndex) {
  * Filters the input values by distance while maintaining the original order of elements.
  * Values that are too close to each other (based on the minDistance parameter) will be filtered out.
  *
+ * Items whose extracted value is null are excluded from the result.
+ *
  * If order is irrelevant, use filterValuesByDistanceNoOrder() instead.
  *
- * @param _input - The array of values to filter
- * @param _minDistance - The minimum distance required between values
- * @param _getValue - Function that extracts a numeric value from each item for distance comparison
- * @returns A filtered array with only values that are at least minDistance apart
- */ function filterValuesByDistance(_input, _minDistance, _getValue) {
-    // TODO(FUTURE): Implement if needed.
-    throw new Error('Incomplete implementation!');
+ * @param input - The array of values to filter
+ * @param minDistance - The minimum distance required between values (inclusive)
+ * @param getValue - Function that extracts a numeric value from each item for distance comparison
+ * @returns A filtered array with only values that are at least minDistance apart, in their original input order
+ */ function filterValuesByDistance(input, minDistance, getValue) {
+    // Tag each non-null value with its original index so we can restore order after the distance filter.
+    var tagged = [];
+    for(var i = 0, n = input.length; i < n; i += 1){
+        var item = input[i];
+        var value = getValue(item);
+        if (value != null) {
+            tagged.push([
+                {
+                    item: item,
+                    index: i
+                },
+                value
+            ]);
+        }
+    }
+    var kept = _filterValuesByDistance(tagged, minDistance, function(x) {
+        return x[0];
+    });
+    kept.sort(function(a, b) {
+        return a.index - b.index;
+    });
+    return kept.map(function(x) {
+        return x.item;
+    });
 }
 /**
  * Filters the input values by an arbitrary "distance"/difference from each other and returns the values sorted by their determined distance.
@@ -5399,14 +5751,17 @@ function stepsFromIndex(range, startIndex) {
 /**
  * Same as applyBestFit, but returns a new array, rather than modifying the existing array.
  *
- * @param input - The array to filter for the best fit
- * @param filter - Function that determines which items are candidates for the best fit
- * @param compare - AscendingSortCompareFunction to compare two values to determine which is the best fit
- * @param updateNonBestFit - Function that transforms non-best-fit items
- * @returns A new array with only the best fit item and transformed non-best-fit items
- */ // eslint-disable-next-line @typescript-eslint/max-params
-function makeBestFit(input, filter, compare, updateNonBestFit) {
-    return applyBestFit(copyArray(input), filter, compare, updateNonBestFit);
+ * @dbxUtil
+ * @dbxUtilCategory array
+ * @dbxUtilTags array, best-fit, filter, sort, immutable
+ * @dbxUtilRelated apply-best-fit, find-best-index-set-pair
+ *
+ * @param input - The array to filter for the best fit.
+ * @param config - The best-fit strategy ({@link BestFitConfig}).
+ * @returns A new array with only the best fit item and transformed non-best-fit items.
+ * @__NO_SIDE_EFFECTS__
+ */ function makeBestFit(input, config) {
+    return applyBestFit(copyArray(input), config);
 }
 /**
  * Used for updating an array so that a single element becomes the "best fit" in whatever context is provided.
@@ -5414,13 +5769,16 @@ function makeBestFit(input, filter, compare, updateNonBestFit) {
  * For instance, if two items are selected but only one can be selected by design, this function can be used to
  * pick the best fit, and update the input array.
  *
- * @param input - The array to modify in-place
- * @param filter - Function that determines which items are candidates for the best fit
- * @param compare - AscendingSortCompareFunction to compare two values to determine which is the best fit
- * @param updateNonBestFit - Function that transforms non-best-fit items
- * @returns The modified input array with only the best fit item and transformed non-best-fit items
- */ // eslint-disable-next-line @typescript-eslint/max-params
-function applyBestFit(input, filter, compare, updateNonBestFit) {
+ * @dbxUtil
+ * @dbxUtilCategory array
+ * @dbxUtilTags array, best-fit, filter, sort, mutable, in-place
+ * @dbxUtilRelated make-best-fit, find-best-index-set-pair
+ *
+ * @param input - The array to modify in-place.
+ * @param config - The best-fit strategy ({@link BestFitConfig}).
+ * @returns The modified input array with only the best fit item and transformed non-best-fit items.
+ */ function applyBestFit(input, config) {
+    var filter = config.filter, compare = config.compare, updateNonBestFit = config.updateNonBestFit;
     var matchIndexSet = findToIndexSet(input, filter);
     if (matchIndexSet.length > 1) {
         var expansion = expandIndexSet(input, matchIndexSet);
@@ -5438,9 +5796,16 @@ function applyBestFit(input, filter, compare, updateNonBestFit) {
  * Creates a function that filters the input values and maps all matching values to a new value.
  * This is a higher-order function that combines filtering and mapping operations.
  *
+ * @dbxUtil
+ * @dbxUtilCategory array
+ * @dbxUtilKind factory
+ * @dbxUtilTags array, filter, map, transform, factory, iterable
+ * @dbxUtilRelated array-decision-function
+ *
  * @param decisionFunction - Function that determines which items to include in the result
  * @param mapFunction - Function that transforms each included item
  * @returns A function that takes an iterable of input values and returns an array of transformed values
+ * @__NO_SIDE_EFFECTS__
  */ function filterAndMapFunction(decisionFunction, mapFunction) {
     return function(values) {
         var result = [];
@@ -5464,6 +5829,7 @@ function applyBestFit(input, filter, compare, updateNonBestFit) {
  *
  * @param factory - The factory function used to generate each item
  * @returns A function that takes a count parameter and returns an array of generated items
+ * @__NO_SIDE_EFFECTS__
  */ function arrayFactory(factory) {
     return function(count) {
         return makeWithFactory(factory, count);
@@ -5480,6 +5846,7 @@ function applyBestFit(input, filter, compare, updateNonBestFit) {
  *
  * @param factory - The factory function used to transform each input value
  * @returns A function that takes an array of input values and returns an array of output values
+ * @__NO_SIDE_EFFECTS__
  */ function arrayInputFactory(factory) {
     return function(input) {
         return makeWithFactoryInput(factory, input);
@@ -5564,8 +5931,15 @@ function getArrayNextIndex(array, index) {
  *
  * Each accessor maps an index to the value whose range contains that index, or undefined if no range matches.
  *
+ * @dbxUtil
+ * @dbxUtilCategory array
+ * @dbxUtilKind factory
+ * @dbxUtilTags array, indexed, range, accessor, factory, lookup
+ * @dbxUtilRelated indexed-values-array-accessor-factory, ranged-indexed-values-array-accessor-info-factory
+ *
  * @param readIndexRange - Function that reads the index range from each value.
  * @returns A factory that creates ranged accessors from arrays of values.
+ * @__NO_SIDE_EFFECTS__
  */ function rangedIndexedValuesArrayAccessorFactory(readIndexRange) {
     var readInfoFactory = rangedIndexedValuesArrayAccessorInfoFactory({
         readIndexRange: readIndexRange
@@ -5584,9 +5958,16 @@ function getArrayNextIndex(array, index) {
  * Each accessor maps an index to the matching value, falling back to the previous value, then the next value.
  * This guarantees a value is always returned.
  *
+ * @dbxUtil
+ * @dbxUtilCategory array
+ * @dbxUtilKind factory
+ * @dbxUtilTags array, indexed, range, accessor, factory, fallback
+ * @dbxUtilRelated ranged-indexed-values-array-accessor-factory, ranged-indexed-values-array-accessor-info-factory
+ *
  * @param readIndexRange - Function that reads the index range from each value.
  * @returns A factory that creates indexed accessors from arrays of values.
  * @throws Error if the provided values array is empty.
+ * @__NO_SIDE_EFFECTS__
  */ function indexedValuesArrayAccessorFactory(readIndexRange) {
     var readInfoFactory = rangedIndexedValuesArrayAccessorInfoFactory({
         readIndexRange: readIndexRange
@@ -5610,8 +5991,15 @@ function getArrayNextIndex(array, index) {
  * Each accessor sorts the values by their index ranges in ascending order, then for a given index
  * returns the matching value along with its previous and next neighbors.
  *
+ * @dbxUtil
+ * @dbxUtilCategory array
+ * @dbxUtilKind factory
+ * @dbxUtilTags array, indexed, range, accessor, info, factory, neighbors
+ * @dbxUtilRelated ranged-indexed-values-array-accessor-factory, indexed-values-array-accessor-factory
+ *
  * @param config - Configuration containing the index range reader function.
  * @returns A factory that creates ranged info accessors from arrays of values.
+ * @__NO_SIDE_EFFECTS__
  */ function rangedIndexedValuesArrayAccessorInfoFactory(config) {
     var pairFactory = indexRangeReaderPairFactory(config.readIndexRange);
     return function(values) {
@@ -5677,8 +6065,15 @@ function limitArray(array, inputConfig) {
 /**
  * Creates a factory function that generates arrays of a random length populated with items from a make function.
  *
+ * @dbxUtil
+ * @dbxUtilCategory array
+ * @dbxUtilKind factory
+ * @dbxUtilTags array, random, factory, generate, make
+ * @dbxUtilRelated array-factory, random-number-factory
+ *
  * @param config - configuration containing the make function and random number source
  * @returns a factory that produces arrays of random length, optionally accepting a specific count override
+ * @__NO_SIDE_EFFECTS__
  */ function randomArrayFactory(config) {
     var randomFn = typeof config.random === 'function' ? config.random : randomNumberFactory(config.random);
     var nextRandomCount = function nextRandomCount() {
@@ -5745,6 +6140,7 @@ function generateIfDoesNotExist(keys, existing, readKey, generateFn) {
  * @param values - array of values to randomly pick from
  * @returns a callable factory that returns a random value from the array on each invocation
  * @throws Error if the input array is empty
+ * @__NO_SIDE_EFFECTS__
  */ function randomPickFactory(values) {
     if (values.length === 0) {
         throw new Error('randomPickFactory() cannot use an empty array.');
@@ -6054,6 +6450,7 @@ function caseInsensitiveString(input) {
  *
  * @param config - configuration controlling max length and end text behavior
  * @returns a reusable function that truncates input strings
+ * @__NO_SIDE_EFFECTS__
  */ function cutStringFunction(config) {
     var inputMaxLength = config.maxLength, maxLengthIncludesEndText = config.maxLengthIncludesEndText, inputEndText = config.endText;
     var endText = inputEndText === undefined ? DEFAULT_CUT_STRING_END_TEXT : '';
@@ -6170,24 +6567,42 @@ function caseInsensitiveString(input) {
 /**
  * Trims leading and trailing whitespace from a string.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilTags string, trim, whitespace, transform
+ * @dbxUtilRelated transform-string-function
+ *
  * @param input The string to trim.
  * @returns The trimmed string.
+ * @__NO_SIDE_EFFECTS__
  */ function stringTrimFunction(input) {
     return input.trim();
 }
 /**
  * Converts a string to uppercase.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilTags string, uppercase, case, transform
+ * @dbxUtilRelated string-to-lowercase-function, transform-string-function
+ *
  * @param input The string to convert.
  * @returns The uppercase string.
+ * @__NO_SIDE_EFFECTS__
  */ function stringToUppercaseFunction(input) {
     return input.toUpperCase();
 }
 /**
  * Converts a string to lowercase.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilTags string, lowercase, case, transform
+ * @dbxUtilRelated string-to-uppercase-function, transform-string-function
+ *
  * @param input The string to convert.
  * @returns The lowercase string.
+ * @__NO_SIDE_EFFECTS__
  */ function stringToLowercaseFunction(input) {
     return input.toLowerCase();
 }
@@ -6214,9 +6629,16 @@ function caseInsensitiveString(input) {
  * 4. Lowercase conversion (if `config.toLowercase` is true and no `config.transform` or `config.toUppercase`).
  * If no transformations are specified, the identity function is returned.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, transform, trim, case, slice, factory
+ * @dbxUtilRelated string-trim-function, string-to-uppercase-function, string-to-lowercase-function, slice-string-function
+ *
  * @template S The specific string type, defaults to `string`.
  * @param config The `TransformStringFunctionConfig` detailing the transformations.
  * @returns A `TransformStringFunction` that applies the configured transformations.
+ * @__NO_SIDE_EFFECTS__
  */ function transformStringFunction(config) {
     var baseTransform;
     if (config.transform) {
@@ -6262,8 +6684,15 @@ function caseInsensitiveString(input) {
 /**
  * Creates a function that adds a configured prefix to the input string if it does not exist on that string.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, prefix, add, factory
+ * @dbxUtilRelated add-prefix, add-suffix-function
+ *
  * @param prefix The prefix to add.
  * @returns A function that adds the prefix to a string.
+ * @__NO_SIDE_EFFECTS__
  */ function addPrefixFunction(prefix) {
     return function(input) {
         return input.startsWith(prefix) ? input : prefix + input;
@@ -6281,8 +6710,15 @@ function caseInsensitiveString(input) {
 /**
  * Creates a function that adds a configured suffix to the input string if it does not exist on that string.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, suffix, add, factory
+ * @dbxUtilRelated add-suffix, add-prefix-function
+ *
  * @param suffix The suffix to add.
  * @returns A function that adds the suffix to a string.
+ * @__NO_SIDE_EFFECTS__
  */ function addSuffixFunction(suffix) {
     return function(input) {
         return input.endsWith(suffix) ? input : input + suffix;
@@ -6291,9 +6727,16 @@ function caseInsensitiveString(input) {
 /**
  * Pads the start of a string to a minimum length.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, pad, start, factory, minimum-length
+ * @dbxUtilRelated transform-string-function
+ *
  * @param minLength The minimum length of the string.
  * @param padCharacter The character to use for padding.
  * @returns A function that pads the start of a string.
+ * @__NO_SIDE_EFFECTS__
  */ function padStartFunction(minLength, padCharacter) {
     return function(input) {
         return input.padStart(minLength, padCharacter);
@@ -6302,8 +6745,15 @@ function caseInsensitiveString(input) {
 /**
  * Creates a function that slices and concats parts of a string based on the configuration.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, slice, take, factory, from-start, from-end
+ * @dbxUtilRelated transform-string-function
+ *
  * @param config The configuration for the slice function.
  * @returns A SliceStringFunction.
+ * @__NO_SIDE_EFFECTS__
  */ function sliceStringFunction(config) {
     var fromStart = config.fromStart, fromEnd = config.fromEnd;
     var takeFromStart = Math.abs(fromStart !== null && fromStart !== void 0 ? fromStart : 0);
@@ -6851,8 +7301,15 @@ function _object_spread$f(target) {
  * The merged function returns true only if all individual filters pass (AND logic).
  * Null/undefined filters are ignored.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags filter, merge, compose, factory, and
+ * @dbxUtilRelated invert-filter, invert-boolean-return-function
+ *
  * @param inputFilters - The filter functions to merge
  * @returns A single FilterFunction that applies all filters
+ * @__NO_SIDE_EFFECTS__
  */ function mergeFilterFunctions() {
     for(var _len = arguments.length, inputFilters = new Array(_len), _key = 0; _key < _len; _key++){
         inputFilters[_key] = arguments[_key];
@@ -6989,6 +7446,14 @@ function _unsupported_iterable_to_array$r(o, minLen) {
  * const tuples = getDefinedTuples({ a: 1, b: undefined, c: 'hello' });
  * // tuples: [['a', 1], ['c', 'hello']]
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, tuples, filter, factory, key-value
+ * @dbxUtilRelated filter-key-value-tuple-function, for-each-key-value
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function filterKeyValueTuplesFunction(filter) {
     var result;
     if (filter != null) {
@@ -7073,6 +7538,14 @@ function _unsupported_iterable_to_array$r(o, minLen) {
  * isNotNull(['a', 1], 0);    // true
  * isNotNull(['b', null], 0); // false
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, tuple, filter, predicate, factory, key-value
+ * @dbxUtilRelated filter-key-value-tuples-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function filterKeyValueTupleFunction(inputFilter) {
     var filter = filterKeyValueTuplesInputToFilter(inputFilter);
     var tmp = filter.valueFilter, type = tmp === void 0 ? KeyValueTypleValueFilter.UNDEFINED : tmp, tmp1 = filter.invertFilter, inverseFilter = tmp1 === void 0 ? false : tmp1, keysFilter = filter.keysFilter;
@@ -7143,8 +7616,15 @@ function _unsupported_iterable_to_array$r(o, minLen) {
 /**
  * Creates a factory that returns a random element from the given array on each call.
  *
+ * @dbxUtil
+ * @dbxUtilCategory getter
+ * @dbxUtilKind factory
+ * @dbxUtilTags getter, factory, random, array, sample
+ * @dbxUtilRelated random-number-factory, random-array-factory
+ *
  * @param values - The array of values to randomly select from
  * @returns A factory that returns a random element from the array
+ * @__NO_SIDE_EFFECTS__
  */ function randomFromArrayFactory(values) {
     var randomIndex = randomNumberFactory({
         min: 0,
@@ -7196,8 +7676,15 @@ function cachedGetter(factory) {
 /**
  * Creates a factory that wraps Getters with a mapping function.
  *
+ * @dbxUtil
+ * @dbxUtilCategory getter
+ * @dbxUtilKind factory
+ * @dbxUtilTags getter, map, transform, factory
+ * @dbxUtilRelated map-getter
+ *
  * @param mapFn - The mapping function to apply
  * @returns A factory that transforms Getters of type I to Getters of type O
+ * @__NO_SIDE_EFFECTS__
  */ function mapGetterFactory(mapFn) {
     return function(getter) {
         return function() {
@@ -7295,12 +7782,19 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * @param copy - When true (default), the returned function shallow-copies the input before filtering instead of mutating it.
  * @returns A function that returns the stripped object, or `undefined` when filtering removed every key.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, strip, filter, factory, undefined, empty
+ * @dbxUtilRelated strip-object, filter-from-pojo-function
+ *
  * @example
  * ```ts
  * const stripUndef = stripObjectFunction(KeyValueTypleValueFilter.UNDEFINED);
  * stripUndef({ a: 1, b: undefined });  // { a: 1 }
  * stripUndef({ a: undefined });        // undefined
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function stripObjectFunction(filter) {
     var copy = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
     var filterFn = filterFromPOJOFunction({
@@ -7389,6 +7883,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * const result = overrideFn({ color: 'blue', size: 5 });
  * // result is { color: 'red', size: 10 } (a new copy)
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, override, factory, merge, template, cached
+ * @dbxUtilRelated override-in-object, merge-objects-function, filter-from-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function overrideInObjectFunctionFactory(param) {
     var filter = param.filter, copy = param.copy, _param_dynamic = param.dynamic, dynamic = _param_dynamic === void 0 ? false : _param_dynamic;
     var filterToRelevantValuesObject = filter != null ? filterFromPOJOFunction({
@@ -7458,6 +7960,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * // With null filter to also exclude null values:
  * const mergeNoNulls = mergeObjectsFunction(KeyValueTypleValueFilter.NULL);
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, merge, factory, filter
+ * @dbxUtilRelated merge-objects, override-in-object-function-factory
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function mergeObjectsFunction(filter) {
     var overrideFn = overrideInObjectFunctionFactory({
         filter: filter,
@@ -7622,6 +8132,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * findDefinedKeys({ a: 1, b: undefined, c: 'hello' });
  * // ['a', 'c']
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, keys, find, factory, filter
+ * @dbxUtilRelated find-pojo-keys, count-pojo-keys-function, for-each-key-value-on-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function findPOJOKeysFunction(filter) {
     var findEachMatchingKeyOnTarget = forEachKeyValueOnPOJOFunction({
         filter: filter,
@@ -7675,6 +8193,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * countDefined({ a: 1, b: undefined, c: 'test' });
  * // 2
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, keys, count, factory, filter
+ * @dbxUtilRelated count-pojo-keys, find-pojo-keys-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function countPOJOKeysFunction() {
     var filter = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : KeyValueTypleValueFilter.UNDEFINED;
     var countEachMatchingKeyOnTarget = forEachKeyValueOnPOJOFunction({
@@ -7741,6 +8267,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * const result = filterNulls({ a: 1, b: null, c: undefined });
  * // result is { a: 1 }, original is unchanged
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, filter, factory, remove, copy
+ * @dbxUtilRelated filter-from-pojo, strip-object-function, assign-values-to-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function filterFromPOJOFunction() {
     var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_copy = _ref.copy, copy = _ref_copy === void 0 ? false : _ref_copy, tmp = _ref.filter, inputFilter = tmp === void 0 ? {
         valueFilter: KeyValueTypleValueFilter.UNDEFINED
@@ -7818,6 +8352,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * // With NULL filter and no copy:
  * const assignNoNulls = assignValuesToPOJOFunction({ valueFilter: KeyValueTypleValueFilter.NULL, copy: false });
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, assign, factory, filter, copy
+ * @dbxUtilRelated assign-values-to-pojo, filter-from-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function assignValuesToPOJOFunction() {
     var input = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : KeyValueTypleValueFilter.UNDEFINED;
     var _ref;
@@ -7883,6 +8425,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * getNonNullValues({ a: 1, b: null, c: undefined });
  * // [1]
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, values, factory, filter, extract
+ * @dbxUtilRelated values-from-pojo, find-pojo-keys-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function valuesFromPOJOFunction() {
     var filter = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : KeyValueTypleValueFilter.UNDEFINED;
     var addValuesFromObjectToContext = forEachKeyValueOnPOJOFunction({
@@ -7922,6 +8472,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * omitAB({ a: 1, b: 2, c: 3 });
  * // { c: 3 }
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, keys, filter, pick, omit, factory
+ * @dbxUtilRelated filter-tuples-on-pojo-function, filter-from-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function filterKeysOnPOJOFunction(keysToFilter) {
     var invertFilter = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
     var keysSet = new Set(keysToFilter);
@@ -7946,6 +8504,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * keepStrings({ a: 'hello', b: 42, c: 'world' });
  * // { a: 'hello', c: 'world' }
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, tuples, filter, predicate, factory
+ * @dbxUtilRelated filter-keys-on-pojo-function, filter-from-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function filterTuplesOnPOJOFunction(filterTupleOnObject) {
     return function(input) {
         var result = {};
@@ -7980,6 +8546,14 @@ function _unsupported_iterable_to_array$q(o, minLen) {
  * logDefined({ a: 1, b: undefined, c: 'test' });
  * // logs: 'a' 1, 'c' 'test'
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, for-each, iterate, factory, callback
+ * @dbxUtilRelated find-pojo-keys-function, count-pojo-keys-function, filter-key-value-tuples-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function forEachKeyValueOnPOJOFunction(param) {
     var forEach = param.forEach, filter = param.filter;
     var filterKeyValues = filterKeyValueTuplesFunction(filter);
@@ -8039,8 +8613,15 @@ function isInSetDecisionFunction(set, inputReadValue) {
  * Creates a {@link SetDeltaFunction} that computes the differences between two iterables,
  * identifying which items were added, removed, or unchanged.
  *
+ * @dbxUtil
+ * @dbxUtilCategory set
+ * @dbxUtilKind factory
+ * @dbxUtilTags set, delta, diff, factory, change, added, removed
+ * @dbxUtilRelated index-delta-group-function, set-has-value-function
+ *
  * @param config - Configuration with the key reader and optional modification detector.
  * @returns A function that compares two iterables and returns an array of change pairs.
+ * @__NO_SIDE_EFFECTS__
  */ function setDeltaFunction(config) {
     var readKey = config.readKey, _config_isModifiedFunction = config.isModifiedFunction, isModifiedFunction = _config_isModifiedFunction === void 0 ? function() {
         return undefined;
@@ -8187,9 +8768,16 @@ var AUTH_ROLE_CLAIMS_DEFAULT_EMPTY_VALUE = null;
  * Each key in the config maps a claim key to role(s). Simple entries map a claim value to one or more roles,
  * while encode/decode entries allow custom bidirectional conversion logic.
  *
+ * @dbxUtil
+ * @dbxUtilCategory auth
+ * @dbxUtilKind factory
+ * @dbxUtilTags auth, role, claims, jwt, factory, bidirectional
+ * @dbxUtilRelated auth-role
+ *
  * @param config - Mapping of claim keys to their role configuration entries (or null to ignore)
  * @param defaults - Optional default values for claim presence and absence
  * @returns A service with `toClaims` and `toRoles` conversion functions
+ * @__NO_SIDE_EFFECTS__
  */ function authRoleClaimsService(config) {
     var defaults = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
     var _ref, _ref1;
@@ -9897,9 +10485,16 @@ function _unsupported_iterable_to_array$o(o, minLen) {
  * Creates a function that replaces the last character of a string with the replacement string
  * if that character matches any of the specified values.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, replace, last, character, conditional, factory
+ * @dbxUtilRelated replace-last-character-if, replace-character-at-index-if
+ *
  * @param replacement - string to substitute for the last character
  * @param is - character(s) that trigger the replacement
  * @returns a function that conditionally replaces the last character
+ * @__NO_SIDE_EFFECTS__
  */ function replaceLastCharacterIfIsFunction(replacement, is) {
     var matches = new Set(is);
     return function(input) {
@@ -10069,8 +10664,15 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Creates a function that replaces all occurrences of the configured target strings with a replacement value.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, replace, regex, substitute, factory
+ * @dbxUtilRelated find-strings-regex-string, escape-string-for-regex
+ *
  * @param config - Configuration specifying strings to find and the replacement value.
  * @returns A function that performs the configured replacements on an input string.
+ * @__NO_SIDE_EFFECTS__
  */ function replaceStringsFunction(config) {
     var replaceInput = config.replace, replaceWith = config.replaceWith;
     var replaceRegexString = findStringsRegexString(replaceInput);
@@ -10103,6 +10705,11 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Creates an escaped regex string that matches any of the input values, joined with the OR (`|`) operator.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilTags string, regex, escape, alternation, pattern
+ * @dbxUtilRelated escape-string-for-regex, replace-strings-function
+ *
  * @param find - One or more strings to create a matching regex pattern for.
  * @returns A regex-compatible string with special characters escaped and values joined by `|`.
  */ function findStringsRegexString(find) {
@@ -10113,8 +10720,15 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Creates an {@link EscapeStringCharactersFunction} that escapes specific characters in a string using the configured escape strategy.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, escape, characters, factory, transform
+ * @dbxUtilRelated escape-string-for-regex, find-all-character-occurences-function
+ *
  * @param config - Configuration specifying which characters to escape and how to escape them.
  * @returns A function that escapes the configured characters in any input string.
+ * @__NO_SIDE_EFFECTS__
  */ function escapeStringCharactersFunction(config) {
     var inputEscapeTargets = config.escapeTargets, escapeCharacter = config.escapeCharacter;
     var escapeTargets = _instanceof$3(inputEscapeTargets, Set) ? inputEscapeTargets : new Set(inputEscapeTargets);
@@ -10162,6 +10776,12 @@ function _unsupported_iterable_to_array$n(o, minLen) {
  *
  * For instance, `'hello.world'` will be escaped to `'hello\\.world'`.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind const
+ * @dbxUtilTags string, regex, escape, sanitize, pattern
+ * @dbxUtilRelated escape-string-characters-function, find-strings-regex-string
+ *
  * @param input - The string to escape for regex use.
  * @returns The escaped string with all regex special characters prefixed with a backslash.
  */ var escapeStringForRegex = escapeStringCharactersFunction({
@@ -10173,8 +10793,15 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Creates a {@link FindAllCharacterOccurencesFunction} that searches for characters from the given set.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, search, characters, indices, factory, occurrences
+ * @dbxUtilRelated find-all-character-occurences, find-first-character-occurence
+ *
  * @param characterSet - The set of characters to search for.
  * @returns A function that finds all occurrences of the configured characters in an input string.
+ * @__NO_SIDE_EFFECTS__
  */ function findAllCharacterOccurencesFunction(characterSet) {
     return function(input, maxToReturn) {
         var max = maxToReturn !== null && maxToReturn !== void 0 ? maxToReturn : Number.MAX_SAFE_INTEGER;
@@ -10211,6 +10838,11 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Finds all indices of characters from the set that appear in the input string.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilTags string, search, characters, indices, occurrences
+ * @dbxUtilRelated find-all-character-occurences-function, find-first-character-occurence
+ *
  * @param set - The set of characters to search for.
  * @param input - The string to search through.
  * @param max - Optional maximum number of occurrences to return.
@@ -10221,6 +10853,11 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Finds the index of the first occurrence of any character from the set in the input string.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilTags string, search, characters, first, index, occurrence
+ * @dbxUtilRelated find-all-character-occurences, find-all-character-occurences-function
+ *
  * @param set - The set of characters to search for.
  * @param input - The string to search through.
  * @returns The zero-based index of the first matching character, or `undefined` if none found.
@@ -10230,8 +10867,15 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Creates a function that splits a string into two parts at the first occurrence of any character in the configured set.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, split, characters, occurrence, factory
+ * @dbxUtilRelated split-string-at-first-character-occurence, keep-characters-after-first-character-occurence-function
+ *
  * @param splitAt - A single character or set of characters to split on.
  * @returns A function that splits input strings at the first matching character.
+ * @__NO_SIDE_EFFECTS__
  */ function splitStringAtFirstCharacterOccurenceFunction(splitAt) {
     return function(input) {
         var splitSet = typeof splitAt === 'string' ? new Set([
@@ -10253,6 +10897,11 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Splits the input string into two parts at the first occurrence of any character in the split set.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilTags string, split, characters, occurrence, tuple
+ * @dbxUtilRelated split-string-at-first-character-occurence-function, find-first-character-occurence
+ *
  * @param input - The string to split.
  * @param splitAt - A single character or set of characters to split on.
  * @returns A tuple of [before, after], where `after` is `undefined` if no split character was found.
@@ -10262,8 +10911,15 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Creates a function that returns only the characters after the first occurrence of any character in the configured set.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, keep, after, occurrence, factory, suffix
+ * @dbxUtilRelated keep-characters-after-first-character-occurence, remove-characters-after-first-character-occurence-function
+ *
  * @param findCharacters - A single character or set of characters to search for.
  * @returns A function that extracts the substring after the first matching character, or an empty string if none found.
+ * @__NO_SIDE_EFFECTS__
  */ function keepCharactersAfterFirstCharacterOccurenceFunction(findCharacters) {
     var splitStringAtFirstCharacterOccurence = splitStringAtFirstCharacterOccurenceFunction(findCharacters);
     return function(input) {
@@ -10274,6 +10930,11 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Returns only the characters after the first occurrence of any character from the find set.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilTags string, keep, after, occurrence, suffix
+ * @dbxUtilRelated keep-characters-after-first-character-occurence-function, remove-characters-after-first-character-occurence
+ *
  * @param input - The string to search through.
  * @param findCharacters - A single character or set of characters to search for.
  * @returns The substring after the first matching character, or an empty string if none found.
@@ -10283,8 +10944,15 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Creates a function that removes all characters after (and including) the first occurrence of any character in the configured set.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, remove, truncate, occurrence, factory, prefix
+ * @dbxUtilRelated remove-characters-after-first-character-occurence, keep-characters-after-first-character-occurence-function
+ *
  * @param findCharacters - A single character or set of characters to search for.
  * @returns A function that truncates input strings at the first matching character.
+ * @__NO_SIDE_EFFECTS__
  */ function removeCharactersAfterFirstCharacterOccurenceFunction(findCharacters) {
     var splitStringAtFirstCharacterOccurence = splitStringAtFirstCharacterOccurenceFunction(findCharacters);
     return function(input) {
@@ -10294,6 +10962,11 @@ function _unsupported_iterable_to_array$n(o, minLen) {
 /**
  * Removes all characters after (and including) the first occurrence of any character from the find set.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilTags string, remove, truncate, occurrence, prefix
+ * @dbxUtilRelated remove-characters-after-first-character-occurence-function, keep-characters-after-first-character-occurence
+ *
  * @param input - The string to truncate.
  * @param findCharacters - A single character or set of characters to search for.
  * @returns The substring before the first matching character, or the full string if none found.
@@ -10443,6 +11116,7 @@ function _unsupported_iterable_to_array$n(o, minLen) {
  * const alwaysTrue = decisionFunction(true);
  * alwaysTrue('anything'); // true
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function decisionFunction(decision) {
     return function() {
         return decision;
@@ -10485,6 +11159,8 @@ function _unsupported_iterable_to_array$n(o, minLen) {
  * const fn2 = asDecisionFunction(undefined, false);
  * fn2('anything'); // false
  * ```
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function asDecisionFunction(valueOrFunction) {
     var defaultIfUndefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
     var input = valueOrFunction !== null && valueOrFunction !== void 0 ? valueOrFunction : defaultIfUndefined;
@@ -10749,6 +11425,7 @@ function _unsupported_iterable_to_array$m(o, minLen) {
  *
  * @param type - The start type to enforce.
  * @returns A function that transforms paths to the specified start type.
+ * @__NO_SIDE_EFFECTS__
  */ function slashPathStartTypeFactory(type) {
     var fn;
     switch(type){
@@ -10795,6 +11472,7 @@ var ALL_SLASH_PATH_FILE_TYPE_SEPARATORS_REGEX = /\.+/g;
  *
  * @param config Configuration options for the factory.
  * @returns A SlashPathFolderFactory.
+ * @__NO_SIDE_EFFECTS__
  */ function slashPathFolderFactory() {
     var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     var startType = config.startType, validationConfig = config.validationConfig, inputInvalidPathValue = config.invalidPathValue, treatUntypedFilesAsFolders = config.treatUntypedFilesAsFolders;
@@ -10964,6 +11642,7 @@ var ALL_SLASH_PATH_FILE_TYPE_SEPARATORS_REGEX = /\.+/g;
  * @param input
  * @param replaceWith
  * @returns
+ * @__NO_SIDE_EFFECTS__
  */ function replaceInvalidFilePathTypeSeparatorsInSlashPathFunction() {
     var replaceWith = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_SLASH_PATH_ILLEGAL_CHARACTER_REPLACEMENT;
     return function(input) {
@@ -11009,6 +11688,7 @@ var ALL_SLASH_PATH_FILE_TYPE_SEPARATORS_REGEX = /\.+/g;
  *
  * @param config - Configuration for validation behavior.
  * @returns A function that validates and fixes a slash path.
+ * @__NO_SIDE_EFFECTS__
  */ function slashPathValidationFactory(config) {
     var _ref = config !== null && config !== void 0 ? config : {}, _ref_illegalStrings = _ref.illegalStrings, illegalStrings = _ref_illegalStrings === void 0 ? DEFAULT_SLASH_PATH_ILLEGAL_CHARACTERS : _ref_illegalStrings, tmp = _ref.replaceIllegalCharacters, inputReplaceIllegalCharacters = tmp === void 0 ? true : tmp, tmp1 = _ref.replaceIllegalDots, inputReplaceIllegalDots = tmp1 === void 0 ? true : tmp1, throwError = _ref.throwError;
     var fns = [];
@@ -11040,6 +11720,7 @@ var ALL_SLASH_PATH_FILE_TYPE_SEPARATORS_REGEX = /\.+/g;
  *
  * @param config - Configuration for path generation.
  * @returns A factory function that merges input paths into a single validated slash path.
+ * @__NO_SIDE_EFFECTS__
  */ function slashPathFactory(config) {
     var _ref = config !== null && config !== void 0 ? config : {}, tmp = _ref.startType, type = tmp === void 0 ? 'any' : tmp, inputBasePaths = _ref.basePath, _ref_validate = _ref.validate, validate = _ref_validate === void 0 ? true : _ref_validate;
     var basePath = inputBasePaths ? mergeSlashPaths(asArray(inputBasePaths)) : undefined;
@@ -11106,6 +11787,7 @@ var ALL_SLASH_PATH_FILE_TYPE_SEPARATORS_REGEX = /\.+/g;
  *
  * @param config - Configuration with range, optional start type, and file mode.
  * @returns A function that isolates path segments within the configured range.
+ * @__NO_SIDE_EFFECTS__
  */ function isolateSlashPathFunction(config) {
     var startType = config.startType, asFile = config.asFile;
     var range = indexRange(config.range);
@@ -11208,6 +11890,7 @@ var ALL_SLASH_PATH_FILE_TYPE_SEPARATORS_REGEX = /\.+/g;
  *
  * @param path - Matcher path parts to expand into decision functions.
  * @returns Array of decision functions for each path part.
+ * @__NO_SIDE_EFFECTS__
  */ function expandSlashPathPathMatcherPartToDecisionFunctions(path) {
     var targetPathPartsInput = asArray(path);
     var indexMatchingDecisionFunctions = [];
@@ -11290,6 +11973,7 @@ var ALL_SLASH_PATH_FILE_TYPE_SEPARATORS_REGEX = /\.+/g;
  *
  * @param input - the matcher configuration, which may be a target path string, an array of path parts, or a full config object
  * @returns The matcher.
+ * @__NO_SIDE_EFFECTS__
  */ function slashPathPathMatcher(input) {
     var _config_matchRemaining, _config_nonMatchingFillValue;
     var config = slashPathPathMatcherConfig(input);
@@ -11351,6 +12035,7 @@ var ALL_SLASH_PATH_FILE_TYPE_SEPARATORS_REGEX = /\.+/g;
  *
  * @param config The configuration for the matcher.
  * @returns The matcher.
+ * @__NO_SIDE_EFFECTS__
  */ function slashPathSubPathMatcher(config) {
     var targetPathIndexMatchingDecisionFunctions = expandSlashPathPathMatcherPartToDecisionFunctions(config.basePath);
     var basePathPartsCount = targetPathIndexMatchingDecisionFunctions.length;
@@ -11604,8 +12289,15 @@ function _unsupported_iterable_to_array$l(o, minLen) {
 /**
  * Creates an {@link IsolateWebsitePathFunction} that extracts and transforms a path from a website URL based on the configuration.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, url, path, isolate, transform, factory, query
+ * @dbxUtilRelated website-path-from-website-url, website-path-and-query-pair, fix-extra-query-parameters
+ *
  * @param config - Configuration for path isolation, including base path removal, component range, query handling, and trailing slash behavior.
  * @returns A function that isolates the configured portion of a website path.
+ * @__NO_SIDE_EFFECTS__
  */ function isolateWebsitePathFunction() {
     var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     var removeQueryParameters = config.removeQueryParameters, ignoredBasePath = config.ignoredBasePath, isolatePathComponents = config.isolatePathComponents, removeTrailingSlash = config.removeTrailingSlash;
@@ -11985,8 +12677,15 @@ function _unsupported_iterable_to_array$k(o, minLen) {
 /**
  * Creates a factory that generates random email addresses using configurable prefixes, domains, and number generators.
  *
+ * @dbxUtil
+ * @dbxUtilCategory contact
+ * @dbxUtilKind factory
+ * @dbxUtilTags contact, email, random, factory, generate
+ * @dbxUtilRelated random-phone-number-factory, incrementing-number-factory
+ *
  * @param inputConfig - Optional configuration overrides
  * @returns A factory function that produces random email address strings
+ * @__NO_SIDE_EFFECTS__
  */ function randomEmailFactory(inputConfig) {
     var _config_prefixes, _config_domains;
     var config = mergeObjects([
@@ -12022,8 +12721,15 @@ function _unsupported_iterable_to_array$k(o, minLen) {
 /**
  * Creates a factory that generates random E.164 phone numbers using configurable area codes and number generators.
  *
+ * @dbxUtil
+ * @dbxUtilCategory contact
+ * @dbxUtilKind factory
+ * @dbxUtilTags contact, phone, e164, random, factory, generate
+ * @dbxUtilRelated random-email-factory, random-number-factory
+ *
  * @param inputConfig - Optional configuration overrides
  * @returns A factory function that produces random E.164 phone number strings
+ * @__NO_SIDE_EFFECTS__
  */ function randomPhoneNumberFactory(inputConfig) {
     var _config_internationalAreaCodes;
     var config = mergeObjects([
@@ -12310,8 +13016,15 @@ function toReadableError(inputError) {
 /**
  * Creates a function that checks if an error's message contains the target string.
  *
+ * @dbxUtil
+ * @dbxUtilCategory error
+ * @dbxUtilKind factory
+ * @dbxUtilTags error, message, contains, factory, predicate, regex
+ * @dbxUtilRelated escape-string-for-regex
+ *
  * @param target - The string to search for
  * @returns A function that checks error messages for the target string
+ * @__NO_SIDE_EFFECTS__
  */ function errorMessageContainsStringFunction(target) {
     var regex = new RegExp(escapeStringForRegex(target));
     return function(input) {
@@ -12425,8 +13138,15 @@ function _unsupported_iterable_to_array$j(o, minLen) {
  *
  * Useful for late-binding or circular dependency resolution.
  *
+ * @dbxUtil
+ * @dbxUtilCategory function
+ * @dbxUtilKind factory
+ * @dbxUtilTags function, forward, late-binding, factory, lazy
+ * @dbxUtilRelated default-forward-function-factory
+ *
  * @param getter - A Getter that provides the target function
  * @returns A forwarding function with the same signature as the target
+ * @__NO_SIDE_EFFECTS__
  */ function forwardFunction(getter) {
     return function() {
         for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
@@ -12440,8 +13160,15 @@ function _unsupported_iterable_to_array$j(o, minLen) {
  * Creates a factory that produces forwarding functions which use the provided function
  * or fall back to the default function when not provided.
  *
+ * @dbxUtil
+ * @dbxUtilCategory function
+ * @dbxUtilKind factory
+ * @dbxUtilTags function, forward, factory, default, fallback
+ * @dbxUtilRelated forward-function
+ *
  * @param defaultFn - The default function to use as fallback
  * @returns A factory that wraps optional functions with a default fallback
+ * @__NO_SIDE_EFFECTS__
  */ function defaultForwardFunctionFactory(defaultFn) {
     return function(fn) {
         return forwardFunction(function() {
@@ -12977,9 +13704,16 @@ function _ts_generator$8(thisArg, body) {
  * The factory generates identifiers in batches, filters them for uniqueness, and verifies each batch
  * using the configured verifier. Throws if uniqueness generation fails repeatedly (after 20 attempts).
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, id, batch, factory, async, unique, identifier
+ * @dbxUtilRelated sequential-incrementing-number-string-model-id-factory
+ *
  * @param config - Configuration with the base factory for generating candidates and the verifier for validating them
  * @returns An async factory function that produces the requested number of valid identifiers
  * @throws Error if the factory cannot produce enough unique values after repeated attempts
+ * @__NO_SIDE_EFFECTS__
  */ function idBatchFactory(config) {
     var factory = config.factory, verifier = config.verifier;
     var tagsToGeneratePerBatch = verifier.maxBatchSize, _verifier_filterUnique = verifier.filterUnique, filterUnique = _verifier_filterUnique === void 0 ? function(x) {
@@ -13186,9 +13920,16 @@ function _unsupported_iterable_to_array$g(o, minLen) {
  * Creates a new {@link PrimativeKeyDencoderFunction} that can bidirectionally encode/decode
  * primitive key values based on the configured value pairs.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, encode, decode, dencoder, bidirectional, factory, primitive
+ * @dbxUtilRelated primative-key-dencoder-map, primative-key-string-dencoder
+ *
  * @param config - configuration with value pairs and optional default fallback
  * @returns a function that encodes or decodes single values or arrays
  * @throws Error if a single value lookup produces a null result and no default handles it
+ * @__NO_SIDE_EFFECTS__
  */ function primativeKeyDencoder(config) {
     var _config_defaultValue = config.defaultValue, defaultValue = _config_defaultValue === void 0 ? PRIMATIVE_KEY_DENCODER_VALUE : _config_defaultValue;
     var map = primativeKeyDencoderMap(config.values);
@@ -13217,9 +13958,16 @@ function _unsupported_iterable_to_array$g(o, minLen) {
  * When no splitter is defined, all encoded values must be exactly one character long so the string
  * can be split character-by-character.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, encode, decode, dencoder, splitter, factory, primitive
+ * @dbxUtilRelated primative-key-dencoder, primative-key-dencoder-map
+ *
  * @param config - configuration with dencoder and optional splitter
  * @returns a bidirectional function for string-to-array and array-to-string conversion
  * @throws Error if encoded values contain the splitter character, or if values exceed one character when no splitter is defined
+ * @__NO_SIDE_EFFECTS__
  */ function primativeKeyStringDencoder(config) {
     var dencoder = typeof config.dencoder === 'function' ? config.dencoder : primativeKeyDencoder(config.dencoder);
     var splitter = config.splitter;
@@ -13324,8 +14072,15 @@ function _unsupported_iterable_to_array$g(o, minLen) {
  * Creates a {@link NumberStringDencoderFunction} from the given dencoder.
  * The returned function auto-detects the input type: numbers are encoded, strings are decoded.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, number, encode, decode, dencoder, bidirectional, factory
+ * @dbxUtilRelated number-string-dencoder, number-string-dencoder-encoded-string-value-function, number-string-dencoder-decoded-number-value-function
+ *
  * @param dencoder - the NumberStringDencoder to wrap
  * @returns a bidirectional encode/decode function
+ * @__NO_SIDE_EFFECTS__
  */ function numberStringDencoderFunction(dencoder) {
     var fn = function fn(input) {
         var result = typeof input === 'number' ? dencoder.encodeNumber(input) : dencoder.decodeNumber(input);
@@ -13337,8 +14092,15 @@ function _unsupported_iterable_to_array$g(o, minLen) {
  * Creates a function that always returns the encoded string form of the input.
  * Numbers are encoded; strings are passed through as-is.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, number, encode, normalize, factory
+ * @dbxUtilRelated number-string-dencoder-function, number-string-dencoder-decoded-number-value-function
+ *
  * @param dencoder - the NumberStringDencoder to use for encoding
  * @returns a function that normalizes input to an encoded string
+ * @__NO_SIDE_EFFECTS__
  */ function numberStringDencoderEncodedStringValueFunction(dencoder) {
     return function(input) {
         return typeof input === 'number' ? dencoder.encodeNumber(input) : input;
@@ -13348,8 +14110,15 @@ function _unsupported_iterable_to_array$g(o, minLen) {
  * Creates a function that always returns the decoded number form of the input.
  * Strings are decoded; numbers are passed through as-is.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, number, decode, normalize, factory
+ * @dbxUtilRelated number-string-dencoder-function, number-string-dencoder-encoded-string-value-function
+ *
  * @param dencoder - the NumberStringDencoder to use for decoding
  * @returns a function that normalizes input to a decoded number
+ * @__NO_SIDE_EFFECTS__
  */ function numberStringDencoderDecodedNumberValueFunction(dencoder) {
     return function(input) {
         return typeof input === 'number' ? input : dencoder.decodeNumber(input);
@@ -13474,12 +14243,19 @@ function _unsupported_iterable_to_array$g(o, minLen) {
  * @param minSize - the minimum dimensions to enforce
  * @returns a resize function that clamps each axis to the specified minimum
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, vector, resize, minimum, factory, clamp
+ * @dbxUtilRelated vector
+ *
  * @example
  * ```ts
  * const resize = vectorMinimumSizeResizeFunction({ x: 5 });
  * resize({ x: 3, y: 10 });
  * // { x: 5, y: 10 }
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function vectorMinimumSizeResizeFunction(minSize) {
     return function(input) {
         return {
@@ -13951,8 +14727,15 @@ function _wrap_reg_exp(re, groups, source) {
  * Creates a {@link LatLngTupleFunction} that converts various input formats into `[lat, lng]` tuples,
  * applying optional precision configuration.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, tuple, factory, geographic, normalize
+ * @dbxUtilRelated lat-lng-point-function, lat-lng-string-function
+ *
  * @param config - optional configuration for precision and wrapping behavior
  * @returns a function that produces lat/lng tuples from flexible inputs
+ * @__NO_SIDE_EFFECTS__
  */ function latLngTupleFunction(config) {
     var fn = latLngPointFunction(config);
     return function(lat, lng) {
@@ -14035,9 +14818,16 @@ function latLngString(lat, lng) {
  * Creates a {@link LatLngPointPrecisionFunction} that rounds both lat and lng values
  * to the specified number of decimal places.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, precision, round, factory, geographic
+ * @dbxUtilRelated lat-lng-point-function, cut-value-to-precision-function
+ *
  * @param precision - number of decimal places to retain
  * @param precisionRounding - optional rounding strategy (e.g., floor, ceil, round)
  * @returns a function that rounds points to the given precision
+ * @__NO_SIDE_EFFECTS__
  */ function latLngPointPrecisionFunction(precision, precisionRounding) {
     var precisionFunction = cutValueToPrecisionFunction(precision, precisionRounding);
     return function(latLng) {
@@ -14054,8 +14844,15 @@ function latLngString(lat, lng) {
  * Creates a {@link LatLngStringFunction} that converts various input formats into comma-separated lat/lng strings,
  * applying optional precision configuration.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, string, factory, geographic, normalize
+ * @dbxUtilRelated lat-lng-point-function, lat-lng-tuple-function
+ *
  * @param config - optional configuration for precision and wrapping behavior
  * @returns a function that produces lat/lng strings from flexible inputs
+ * @__NO_SIDE_EFFECTS__
  */ function latLngStringFunction(config) {
     var fn = latLngPointFunction(config);
     return function(lat, lng) {
@@ -14086,12 +14883,19 @@ function latLngString(lat, lng) {
  * @returns a function that produces points from flexible inputs
  * @throws {Error} when the input cannot be parsed into a valid point
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, point, factory, geographic, normalize
+ * @dbxUtilRelated lat-lng-point, lat-lng-tuple-function, lat-lng-string-function, lat-lng-point-precision-function
+ *
  * @example
  * ```ts
  * const fn = latLngPointFunction({ precision: 3 });
  * const result = fn(30.59929, -96.38315);
  * // result.lat === 30.599, result.lng === -96.383
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function latLngPointFunction(config) {
     var _ref = config !== null && config !== void 0 ? config : {}, validate = _ref.validate, wrap = _ref.wrap, defaultValue = _ref.default, _ref_precision = _ref.precision, precision = _ref_precision === void 0 ? LAT_LONG_1MM_PRECISION : _ref_precision, readLonLatTuples = _ref.readLonLatTuples, precisionRounding = _ref.precisionRounding;
     var precisionFunction = precision != null ? latLngPointPrecisionFunction(precision, precisionRounding) : mapIdentityFunction();
@@ -14162,8 +14966,15 @@ function latLngString(lat, lng) {
 /**
  * Creates a {@link ValidLatLngPointFunction} that returns the input point when valid, or a default point otherwise.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, validate, fallback, factory, geographic
+ * @dbxUtilRelated valid-lat-lng-point, is-valid-lat-lng-point
+ *
  * @param defaultValue - factory for the fallback point; defaults to `defaultLatLngPoint`
  * @returns a validation function
+ * @__NO_SIDE_EFFECTS__
  */ function validLatLngPointFunction() {
     var defaultValue = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : defaultLatLngPoint;
     return function(latLngPoint) {
@@ -14173,8 +14984,15 @@ function latLngString(lat, lng) {
 /**
  * Creates a {@link LatLngDataPointFunction} that wraps a {@link LatLngRef} object with its resolved point coordinates.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, data-point, factory, geographic, ref
+ * @dbxUtilRelated lat-lng-point-function
+ *
  * @param config - optional configuration for precision and wrapping behavior
  * @returns a function that produces data points from lat/lng references
+ * @__NO_SIDE_EFFECTS__
  */ function latLngDataPointFunction(config) {
     var fn = latLngPointFunction(config);
     return function(data) {
@@ -14189,8 +15007,15 @@ function latLngString(lat, lng) {
  * Creates a {@link RandomLatLngFactory} that generates random points within the specified bounding box.
  * The bounding box corners are capped/wrapped to valid coordinate ranges.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, random, factory, geographic, bounding-box
+ * @dbxUtilRelated random-lat-lng-from-center-factory, random-number-factory
+ *
  * @param config - optional bounding box and precision configuration
  * @returns a factory that produces random points within the bounds
+ * @__NO_SIDE_EFFECTS__
  */ function randomLatLngFactory(config) {
     var _$_object_spread_props = _object_spread_props$4(_object_spread$8({}, config), {
         sw: _object_spread$8({
@@ -14222,8 +15047,15 @@ function latLngString(lat, lng) {
  * Creates a {@link RandomLatLngFactory} that generates random points within a rectangle
  * centered on the given point, extending by `latDistance` and `lngDistance` in each direction.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, random, factory, geographic, center
+ * @dbxUtilRelated random-lat-lng-factory, random-number-factory
+ *
  * @param config - center point, distances, and optional precision
  * @returns a factory that produces random points near the center
+ * @__NO_SIDE_EFFECTS__
  */ function randomLatLngFromCenterFactory(config) {
     var center = config.center, latDistance = config.latDistance, lngDistance = config.lngDistance, precision = config.precision;
     var sw = {
@@ -14475,8 +15307,15 @@ function _unsupported_iterable_to_array$e(o, minLen) {
  * Creates a {@link LatLngBoundTupleFunction} that converts various bound inputs into a `[sw, ne]` tuple,
  * applying optional precision to the resulting points.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, bound, tuple, factory, geographic
+ * @dbxUtilRelated lat-lng-bound-function, lat-lng-bound
+ *
  * @param config - optional configuration for point precision
  * @returns a function that produces bound tuples from flexible inputs
+ * @__NO_SIDE_EFFECTS__
  */ function latLngBoundTupleFunction(config) {
     var fn = latLngBoundFunction(config);
     return function(input, inputNe) {
@@ -14513,12 +15352,19 @@ function _unsupported_iterable_to_array$e(o, minLen) {
  * @returns a function that produces bounds from flexible inputs
  * @throws {Error} when the input cannot be parsed into a valid bound
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, bound, factory, geographic, normalize
+ * @dbxUtilRelated lat-lng-bound, lat-lng-bound-tuple-function, lat-lng-point-function
+ *
  * @example
  * ```ts
  * const fn = latLngBoundFunction({ precision: 3 });
  * const result = fn([{ lat: 20, lng: 20 }, { lat: 30, lng: 30 }]);
  * // result.sw.lat === 20, result.ne.lat === 30
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function latLngBoundFunction(config) {
     var _ref = config !== null && config !== void 0 ? config : {}, pointFunction = _ref.pointFunction, precision = _ref.precision;
     var latLngPoint = pointFunction !== null && pointFunction !== void 0 ? pointFunction : latLngPointFunction({
@@ -14640,8 +15486,15 @@ function _unsupported_iterable_to_array$e(o, minLen) {
  * falls entirely within the specified bound. Points are checked directly; bounds require
  * both corners to be within.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, bound, contains, decision, factory, geographic
+ * @dbxUtilRelated overlaps-lat-lng-bound-function, is-lat-lng-point-within-lat-lng-bound
+ *
  * @param bound - the reference bound to check containment against
  * @returns a function that returns `true` if the input is within the reference bound
+ * @__NO_SIDE_EFFECTS__
  */ function isWithinLatLngBoundFunction(bound) {
     var fn = function fn(boundOrPoint) {
         return isLatLngPoint(boundOrPoint) ? isLatLngPointWithinLatLngBound(boundOrPoint, bound) : isLatLngBoundWithinLatLngBound(boundOrPoint, bound);
@@ -14699,8 +15552,15 @@ function _unsupported_iterable_to_array$e(o, minLen) {
  * overlaps the reference bound. Internally converts bounds to rectangles for overlap detection,
  * handling antimeridian wrapping.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, lat-lng, bound, overlap, decision, factory, geographic
+ * @dbxUtilRelated is-within-lat-lng-bound-function, lat-lng-bound-overlaps-lat-lng-bound
+ *
  * @param bound - the reference bound to check overlap against
  * @returns a function that returns `true` if the input overlaps the reference bound
+ * @__NO_SIDE_EFFECTS__
  */ function overlapsLatLngBoundFunction(bound) {
     var a = boundToRectangle(bound);
     var fn = function fn(boundOrPoint) {
@@ -14772,6 +15632,7 @@ function _unsupported_iterable_to_array$e(o, minLen) {
  * safeCompare(null, null);  // true
  * safeCompare(null, undefined); // false
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function safeEqualityComparatorFunction(compare) {
     return function(a, b) {
         return a != null && b != null ? compare(a, b) : a === b;
@@ -14810,9 +15671,16 @@ function _unsupported_iterable_to_array$e(o, minLen) {
  * This is a convenience wrapper around {@link compareEqualityWithValueFromItemsFunctionFactory} that
  * accepts both the value reader and comparator in a single call.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, comparator, equality, factory, read
+ * @dbxUtilRelated compare-equality-with-value-from-items-function-factory, safe-equality-comparator-function
+ *
  * @param readValues - extracts the comparable value from each item
  * @param equalityComparator - compares the extracted values for equality
  * @returns a function that compares two items by their extracted values
+ * @__NO_SIDE_EFFECTS__
  */ function compareEqualityWithValueFromItemsFunction(readValues, equalityComparator) {
     return compareEqualityWithValueFromItemsFunctionFactory(readValues)(equalityComparator);
 }
@@ -14835,6 +15703,14 @@ function _unsupported_iterable_to_array$e(o, minLen) {
  * fn(undefined, undefined); // true
  * fn(0, 1);           // false
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, comparator, equality, factory, read, reuse
+ * @dbxUtilRelated compare-equality-with-value-from-items-function, safe-equality-comparator-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function compareEqualityWithValueFromItemsFunctionFactory(readValues) {
     var fn = function fn(equalityComparator) {
         var fn = safeEqualityComparatorFunction(function(a, b) {
@@ -15134,8 +16010,14 @@ function dateFromDateOrTimeMillisecondsNumber(input) {
 /**
  * Converts a MonthOfYear (1-12) to a JavaScript Date month (0-11).
  *
+ * @dbxUtil
+ * @dbxUtilCategory date
+ * @dbxUtilTags date, month, convert, javascript
+ * @dbxUtilRelated month-of-year-from-date-month
+ *
  * @param monthOfYear - Month of year (1-12)
  * @returns JavaScript Date month (0-11)
+ * @__NO_SIDE_EFFECTS__
  */ function makeDateMonthForMonthOfYear(monthOfYear) {
     return monthOfYear - 1;
 }
@@ -15364,6 +16246,7 @@ var MINUTE_OF_DAY_MAXMIMUM = MINUTES_IN_DAY - 1;
  * context(0);  // true
  * context(10); // false
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function isEqualContext(contextValue, fn) {
     return function(value) {
         return fn(contextValue, value);
@@ -15393,6 +16276,7 @@ var MINUTE_OF_DAY_MAXMIMUM = MINUTES_IN_DAY - 1;
  * context([0, 0, 0]); // true
  * context([0, 1, 2]); // false
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function areEqualContext(contextValue, fn) {
     var isEqual = isEqualContext(contextValue, fn);
     return function(input) {
@@ -15561,6 +16445,13 @@ var MINUTE_OF_DAY_MAXMIMUM = MINUTES_IN_DAY - 1;
  * fn(obj);
  * // obj.x === 1
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilTags modifier, map, factory, compose
+ * @dbxUtilRelated maybe-modifier-map-to-function, modifier
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function modifierMapToFunction(map) {
     var _maybeModifierMapToFunction;
     return (_maybeModifierMapToFunction = maybeModifierMapToFunction(map)) !== null && _maybeModifierMapToFunction !== void 0 ? _maybeModifierMapToFunction : NOOP_MODIFIER;
@@ -15570,8 +16461,14 @@ var MINUTE_OF_DAY_MAXMIMUM = MINUTES_IN_DAY - 1;
  *
  * Returns undefined if no map is provided, allowing callers to distinguish "no modifiers" from "empty modifiers".
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilTags modifier, map, factory, compose, optional
+ * @dbxUtilRelated modifier-map-to-function, modifier
+ *
  * @param map - the modifier map to convert
  * @returns a composed modifier function, or `undefined` if no map is provided
+ * @__NO_SIDE_EFFECTS__
  */ function maybeModifierMapToFunction(map) {
     var fn;
     if (map != null) {
@@ -15843,6 +16740,14 @@ function _ts_generator$7(thisArg, body) {
  * const fallback = mappedUseFn(undefined, () => 'wrong', 'default');
  * // fallback === 'default'
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, use, map, factory, optional, fallback
+ * @dbxUtilRelated wrap-use-function, use-context-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function mappedUseFunction(map) {
     return wrapUseFunction(useValue, map);
 }
@@ -15850,9 +16755,16 @@ function _ts_generator$7(thisArg, body) {
  * Wraps an existing {@link MappedUseFunction} with an additional mapping step, allowing further transformation
  * of the intermediate value before it reaches the consumer.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, use, map, wrap, compose, factory
+ * @dbxUtilRelated mapped-use-function, use-value
+ *
  * @param mappedUseFn - the existing mapped use function to wrap
  * @param map - additional transformation applied to the intermediate value
  * @returns a new MappedUseFunction with the extra mapping layer
+ * @__NO_SIDE_EFFECTS__
  */ function wrapUseFunction(mappedUseFn, map) {
     return function(input, useFn, defaultValue) {
         return mappedUseFn(input, function(value) {
@@ -15864,9 +16776,16 @@ function _ts_generator$7(thisArg, body) {
  * Creates a {@link UseContextFunction} by binding a consumer and optional default value, so callers
  * only need to supply the input.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, use, context, factory, bind, default
+ * @dbxUtilRelated use-value, mapped-use-function
+ *
  * @param use - the consumer function to bind
  * @param defaultValue - fallback when input is null/undefined
  * @returns a single-argument function that applies the bound consumer
+ * @__NO_SIDE_EFFECTS__
  */ function useContextFunction(use, defaultValue) {
     return function(input) {
         var result;
@@ -15938,6 +16857,14 @@ function _ts_generator$7(thisArg, body) {
  * const result = await mappedUseAsyncFn(1, () => Promise.resolve('hello'));
  * // result === 'hello'
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, use, async, map, factory, promise
+ * @dbxUtilRelated wrap-use-async-function, mapped-use-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */ function mappedUseAsyncFunction(map) {
     return wrapUseAsyncFunction(useAsync, map);
 }
@@ -15945,9 +16872,16 @@ function _ts_generator$7(thisArg, body) {
  * Wraps an existing {@link MappedUseAsyncFunction} with an additional async-capable mapping step,
  * allowing further transformation of the intermediate value before it reaches the consumer.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags value, use, async, map, wrap, compose, factory, promise
+ * @dbxUtilRelated mapped-use-async-function, wrap-use-function
+ *
  * @param mappedUsePromiseFn - the existing async mapped use function to wrap
  * @param map - additional transformation (sync or async) applied to the intermediate value
  * @returns a new MappedUseAsyncFunction with the extra mapping layer
+ * @__NO_SIDE_EFFECTS__
  */ function wrapUseAsyncFunction(mappedUsePromiseFn, map) {
     return function(input, useFn, defaultValue) {
         return mappedUsePromiseFn(input, function(value) {
@@ -15986,12 +16920,19 @@ function _ts_generator$7(thisArg, body) {
  * @returns A factory function that returns the next encoded string identifier on each call
  * @throws Error if `increaseBy` is 0
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, id, factory, sequential, incrementing, dencoder
+ * @dbxUtilRelated id-batch-factory, number-string-dencoder-function
+ *
  * @example
  * ```ts
  * const factory = sequentialIncrementingNumberStringModelIdFactory({ startAt: 0 });
  * const first = factory(); // encoded representation of 0
  * const second = factory(); // encoded representation of 1
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function sequentialIncrementingNumberStringModelIdFactory() {
     var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
     var inputTranformFunction = config.transform, inputDencoder = config.dencoder, currentIndex = config.currentIndex, inputStartAt = config.startAt, inputIncreaseBy = config.increaseBy;
@@ -16046,8 +16987,15 @@ function _unsupported_iterable_to_array$c(o, minLen) {
  * The first object is stored fully. Subsequent objects store only fields that changed from the previous entry.
  * Null in a delta entry means the field was cleared. Undefined (missing key) means no change.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, delta, array, compress, expand, factory
+ * @dbxUtilRelated equality-comparator-function, object-keys-equality-comparator-function
+ *
  * @param config - Configuration with the equality checker that defines which fields to track
  * @returns A compressor with `compress` and `expand` methods
+ * @__NO_SIDE_EFFECTS__
  */ function objectDeltaArrayCompressor(config) {
     var _equalityChecker = config.equalityChecker;
     var assignKnownValuesToCopy = assignValuesToPOJOFunction({
@@ -16690,8 +17638,15 @@ function _unsupported_iterable_to_array$b(o, minLen) {
 /**
  * Creates a function that returns the name for a given DayOfWeek.
  *
+ * @dbxUtil
+ * @dbxUtilCategory date
+ * @dbxUtilKind factory
+ * @dbxUtilTags date, week, day-of-week, name, factory, format
+ * @dbxUtilRelated days-of-week-name-map
+ *
  * @param transform - Optional configuration for abbreviation and casing
  * @returns A function that maps DayOfWeek values to name strings
+ * @__NO_SIDE_EFFECTS__
  */ function daysOfWeekNameFunction(transform) {
     var map = daysOfWeekNameMap(transform);
     return function(dayOfWeek) {
@@ -17209,9 +18164,16 @@ function _object_spread_props$3(target, source) {
 /**
  * Wraps an existing factory with a {@link ToStringFunction} to produce strings from the factory's output.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, factory, wrap, transform, to-string
+ * @dbxUtilRelated string-from-date-factory, string-from-time-factory
+ *
  * @param factory - the original value factory
  * @param toStringFunction - function to convert the factory's output to a string
  * @returns a new factory that produces string values
+ * @__NO_SIDE_EFFECTS__
  */ function stringFactoryFromFactory(factory, toStringFunction) {
     return function() {
         return toStringFunction(factory());
@@ -17219,9 +18181,16 @@ function _object_spread_props$3(target, source) {
 }
 /**
  * Creates a factory that returns a string based on the input date.
- 
+ *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, date, factory, transform, slice
+ * @dbxUtilRelated string-from-time-factory, string-factory-from-factory, transform-string-function
+ *
  * @param config Configuration for the factory.
  * @returns A factory that returns a string based on the input date.
+ * @__NO_SIDE_EFFECTS__
  */ function stringFromDateFactory(config) {
     var _ref;
     var takeFromEnd = config.takeFromEnd, transformStringConfig = config.transformStringConfig, dateToString = config.dateToString;
@@ -17239,8 +18208,15 @@ function _object_spread_props$3(target, source) {
 /**
  * Creates a factory that returns a string based on the Unix timestamp of the input date.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, date, time, timestamp, factory, suffix
+ * @dbxUtilRelated string-from-date-factory
+ *
  * @param digitsFromEnd The number of digits to return from the end of the generated string. Defaults to 7.
  * @returns A StringFromDateFactory.
+ * @__NO_SIDE_EFFECTS__
  */ function stringFromTimeFactory() {
     var digitsFromEnd = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 7;
     return stringFromDateFactory({
@@ -17848,8 +18824,15 @@ function _performAsyncTask(_0, _1) {
  * Creates a reusable function that performs tasks in parallel with optional concurrency limits
  * and non-concurrent task key constraints.
  *
+ * @dbxUtil
+ * @dbxUtilCategory promise
+ * @dbxUtilKind factory
+ * @dbxUtilTags promise, parallel, factory, concurrency, async, tasks
+ * @dbxUtilRelated perform-tasks-in-parallel, perform-async-tasks-function
+ *
  * @param config - Configuration for task factory, parallelism limits, and concurrency keys.
  * @returns A function that accepts an array of inputs and returns a Promise resolving when all tasks complete.
+ * @__NO_SIDE_EFFECTS__
  */ function performTasksInParallelFunction(config) {
     var taskFactory = config.taskFactory, sequential = config.sequential, nonConcurrentTaskKeyFactory = config.nonConcurrentTaskKeyFactory, inputMaxParallelTasks = config.maxParallelTasks; config.waitBetweenTasks;
     var defaultNonConcurrentTaskKeyFactory = makeDefaultNonConcurrentTaskKeyFactory();
@@ -17891,8 +18874,15 @@ function _performAsyncTask(_0, _1) {
  * Creates a function that pulls task inputs from a factory and executes them in parallel
  * with configurable concurrency limits and non-concurrent key constraints.
  *
+ * @dbxUtil
+ * @dbxUtilCategory promise
+ * @dbxUtilKind factory
+ * @dbxUtilTags promise, parallel, factory, concurrency, async, pull-tasks
+ * @dbxUtilRelated perform-tasks-in-parallel-function
+ *
  * @param config - Configuration for the task factory, parallelism, and concurrency behavior.
  * @returns a function that accepts a task input factory and returns a Promise that resolves when all tasks complete
+ * @__NO_SIDE_EFFECTS__
  */ function performTasksFromFactoryInParallelFunction(config) {
     /**
      * @returns null
@@ -18158,7 +19148,14 @@ function _performAsyncTask(_0, _1) {
 /**
  * Creates a default non-concurrent task key factory that generates unique incrementing number strings.
  *
+ * @dbxUtil
+ * @dbxUtilCategory promise
+ * @dbxUtilKind factory
+ * @dbxUtilTags promise, parallel, key, factory, unique, incrementing
+ * @dbxUtilRelated perform-tasks-in-parallel-function, incrementing-number-factory
+ *
  * @returns A {@link StringFactory} that produces unique keys for identifying non-concurrent tasks.
+ * @__NO_SIDE_EFFECTS__
  */ function makeDefaultNonConcurrentTaskKeyFactory() {
     return stringFactoryFromFactory(incrementingNumberFactory(), function(x) {
         return x.toString();
@@ -18521,8 +19518,15 @@ function _ts_generator$3(thisArg, body) {
  * Creates a {@link TryWithPromiseFactoriesFunction} that sequentially tries each promise factory
  * until one returns a non-null value (or a Maybe value if `successOnMaybe` is true).
  *
+ * @dbxUtil
+ * @dbxUtilCategory promise
+ * @dbxUtilKind factory
+ * @dbxUtilTags promise, factory, try, sequential, fallback, async
+ * @dbxUtilRelated run-named-async-tasks-function
+ *
  * @param config - Configuration including the array of promise factories and default behavior options.
  * @returns A function that tries each factory in order for a given input.
+ * @__NO_SIDE_EFFECTS__
  */ function tryWithPromiseFactoriesFunction(config) {
     var promiseFactories = config.promiseFactories, defaultSuccessOnMaybe = config.successOnMaybe, defaultThrowErrors = config.throwErrors;
     return function(input, config) {
@@ -18852,8 +19856,15 @@ function _ts_generator$2(thisArg, body) {
 /**
  * Creates a new RunNamedAsyncTasksFunction.
  *
+ * @dbxUtil
+ * @dbxUtilCategory promise
+ * @dbxUtilKind factory
+ * @dbxUtilTags promise, async, task, factory, named, parallel
+ * @dbxUtilRelated try-with-promise-factories-function
+ *
  * @param config Optional configuration.
  * @returns A new RunNamedAsyncTasksFunction.
+ * @__NO_SIDE_EFFECTS__
  */ function runNamedAsyncTasksFunction(config) {
     var _ref = config !== null && config !== void 0 ? config : {}, onTaskSuccess = _ref.onTaskSuccess, onTaskFailure = _ref.onTaskFailure;
     return function(inputTasks, options) {
@@ -19076,9 +20087,16 @@ function _is_native_reflect_construct$2() {
 /**
  * Creates a new Timer from the input duration.
  *
+ * @dbxUtil
+ * @dbxUtilCategory date
+ * @dbxUtilKind factory
+ * @dbxUtilTags date, time, timer, factory, duration
+ * @dbxUtilRelated timer
+ *
  * @param duration - The duration of the timer.
  * @param startImmediately - Whether the timer should start immediately. Defaults to true.
  * @returns The new Timer.
+ * @__NO_SIDE_EFFECTS__
  */ function makeTimer(duration) {
     var startImmediately = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
     var createdAt = new Date();
@@ -19570,8 +20588,15 @@ function _compareObjects(a, b, pojoFilter) {
  *
  * Fields can be specified as simple field names (using the default `===` comparator) or as config objects with custom comparators.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, equality, fields, comparator, factory
+ * @dbxUtilRelated object-keys-equality-comparator-function, object-key-equality-comparator-function
+ *
  * @param config - Configuration with the fields to compare and an optional default equality function
  * @returns A function that compares two objects and reports which fields are equal/unequal
+ * @__NO_SIDE_EFFECTS__
  */ function objectFieldEqualityChecker(config) {
     var fields = config.fields, _config_defaultEqualityFunction = config.defaultEqualityFunction, defaultEqualityFunction = _config_defaultEqualityFunction === void 0 ? function(a, b) {
         return a === b;
@@ -19619,8 +20644,15 @@ function _compareObjects(a, b, pojoFilter) {
  * Returns `true` if both arrays have the same length and produce identical key sets.
  * Handles `null`/`undefined` inputs via {@link safeEqualityComparatorFunction}.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, key, equality, comparator, factory, array
+ * @dbxUtilRelated object-key-equality-comparator-function, safe-equality-comparator-function
+ *
  * @param readKey - Function to extract one or more keys from each object
  * @returns An equality comparator for arrays of keyed objects
+ * @__NO_SIDE_EFFECTS__
  */ function objectKeysEqualityComparatorFunction(readKey) {
     var readKeysSet = readKeysSetFunction(readKey);
     var readKeysArray = readKeysFunction(readKey);
@@ -19644,8 +20676,15 @@ function _compareObjects(a, b, pojoFilter) {
  *
  * Handles `null`/`undefined` inputs via {@link safeEqualityComparatorFunction}.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, key, equality, comparator, factory
+ * @dbxUtilRelated object-keys-equality-comparator-function, safe-equality-comparator-function
+ *
  * @param readKey - Function to extract the key from an object
  * @returns An equality comparator for keyed objects
+ * @__NO_SIDE_EFFECTS__
  */ function objectKeyEqualityComparatorFunction(readKey) {
     return safeEqualityComparatorFunction(function(a, b) {
         return readKey(a) === readKey(b);
@@ -19709,8 +20748,15 @@ function _unsupported_iterable_to_array$7(o, minLen) {
 /**
  * Creates a reusable {@link MapObjectMapFunction} that applies {@link mapObjectMap} with the given mapping function.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, map, transform, factory, values
+ * @dbxUtilRelated map-object-map, map-object-keys-function
+ *
  * @param mapFn - Function that transforms each value (receives value and key)
  * @returns A function that maps all values in an input object map
+ * @__NO_SIDE_EFFECTS__
  */ function mapObjectMapFunction(mapFn) {
     return function(object) {
         return mapObjectMap(object, mapFn);
@@ -19744,8 +20790,15 @@ function _unsupported_iterable_to_array$7(o, minLen) {
 /**
  * Creates a reusable {@link MapObjectKeysFunction} that transforms the keys of an input object using the given mapping function.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, map, keys, transform, factory, rename
+ * @dbxUtilRelated map-object-map-function, map-object-keys-to-lowercase
+ *
  * @param mapKeyFn - Function that computes the new key from the old key and its value
  * @returns A function that remaps keys on any input object
+ * @__NO_SIDE_EFFECTS__
  */ function mapObjectKeysFunction(mapKeyFn) {
     return function(object) {
         var target = {};
@@ -19863,9 +20916,16 @@ function _type_of$2(obj) {
  * If the field does not exist on the source but a default is configured, the default is used.
  * Otherwise, the target is left unchanged.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, copy, field, factory, default
+ * @dbxUtilRelated make-model-map-functions, modify-model-map-functions
+ *
  * @param key - The property key to copy
  * @param inputConfig - Optional config with a default value for the field
  * @returns A function that copies the field from source to target
+ * @__NO_SIDE_EFFECTS__
  */ function makeCopyModelFieldFunction(key, inputConfig) {
     var config = inputConfig !== null && inputConfig !== void 0 ? inputConfig : {};
     var hasDefault = objectHasKey(config, 'default');
@@ -19931,8 +20991,15 @@ function _unsupported_iterable_to_array$6(o, minLen) {
  *
  * The `to` function converts from the model (V) to data (D), while `from` converts back from data (D) to model (V).
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, conversion, map, factory, bidirectional, fields
+ * @dbxUtilRelated to-model-map-functions, modify-model-map-functions, model-field-conversions
+ *
  * @param fields - Field conversion definitions for each key in the model
  * @returns Object with `from` and `to` mapping functions
+ * @__NO_SIDE_EFFECTS__
  */ function makeModelMapFunctions(fields) {
     var keys = filterKeyValueTuples(fields);
     var conversionsByKey = keys.map(function(param) {
@@ -19968,8 +21035,15 @@ function _unsupported_iterable_to_array$6(o, minLen) {
  *
  * Supports optional filtering by field names and skipping undefined values via {@link ModelConversionOptions}.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, conversion, factory, fields, map, transform
+ * @dbxUtilRelated make-model-map-functions, model-field-map-functions
+ *
  * @param fields - Array of `[key, convertFn]` tuples defining how each field is converted
  * @returns A function that converts an input object to an output object
+ * @__NO_SIDE_EFFECTS__
  */ function makeModelConversionFieldValuesFunction(fields) {
     return function(input, inputTarget, options) {
         var target = inputTarget !== null && inputTarget !== void 0 ? inputTarget : {};
@@ -20006,8 +21080,15 @@ function _unsupported_iterable_to_array$6(o, minLen) {
 /**
  * Compiles a {@link ModelFieldMapFunctionsConfig} into resolved {@link ModelFieldMapFunctions} with `from` and `to` mapping functions.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, field, map, factory, conversion, bidirectional
+ * @dbxUtilRelated model-field-map-function, make-model-map-functions
+ *
  * @param config - Configuration with `from` and `to` field map configs
  * @returns Compiled field map functions
+ * @__NO_SIDE_EFFECTS__
  */ function modelFieldMapFunctions(config) {
     return {
         from: modelFieldMapFunction(config.from),
@@ -20022,8 +21103,15 @@ function _unsupported_iterable_to_array$6(o, minLen) {
  * - Null/undefined input with `convertMaybe`: delegates to that function
  * - Null/undefined input with `default` or `defaultInput`: uses the appropriate fallback
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, field, map, factory, maybe, default, convert
+ * @dbxUtilRelated model-field-map-functions, make-model-map-functions
+ *
  * @param config - Configuration specifying how to convert values and handle null/undefined
  * @returns A function that maps Maybe input values to output values
+ * @__NO_SIDE_EFFECTS__
  */ function modelFieldMapFunction(config) {
     var convert = config.convert;
     var convertMaybe = 'convertMaybe' in config ? config.convertMaybe : undefined;
@@ -20064,8 +21152,15 @@ function _unsupported_iterable_to_array$6(o, minLen) {
  *
  * Accepts a pre-built `mapFunctions` reference, a `fieldConversions` ref, or a `fields` config.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, conversion, map, factory, normalize, resolve
+ * @dbxUtilRelated make-model-map-functions, to-model-field-conversions
+ *
  * @param input - Input that can be resolved to model map functions
  * @returns Bidirectional model map functions
+ * @__NO_SIDE_EFFECTS__
  */ function toModelMapFunctions(input) {
     var mapFunctions;
     if ('mapFunctions' in input) {
@@ -20164,8 +21259,15 @@ function _object_spread$2(target) {
  *
  * Optionally copies the input object before modification to avoid mutating the original.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, map, modify, factory, modifier, copy
+ * @dbxUtilRelated make-model-map-functions, modify-model-map-function
+ *
  * @param config - Configuration with the base map functions, modifiers, and copy options
  * @returns New model map functions with modifiers applied before each conversion
+ * @__NO_SIDE_EFFECTS__
  */ function modifyModelMapFunctions(config) {
     var copy = config.copy, _config_copyModel = config.copyModel, copyModel = _config_copyModel === void 0 ? copy : _config_copyModel, _config_copyData = config.copyData, copyData = _config_copyData === void 0 ? copy : _config_copyData, mapFunctions = config.mapFunctions, modifiers = config.modifiers;
     var from = mapFunctions.from, to = mapFunctions.to;
@@ -20183,10 +21285,17 @@ function _object_spread$2(target) {
  * When `copy` is true (default), the input is shallow-copied before modification to avoid mutating the original.
  * If no modifier is provided, the original map function is returned unchanged.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, map, modify, factory, modifier, wrap
+ * @dbxUtilRelated modify-model-map-functions, model-field-map-function
+ *
  * @param mapFn - The base map function to wrap
  * @param modifyModel - Optional modifier to apply before mapping
  * @param copy - Whether to shallow-copy the input before modifying; defaults to true
  * @returns The wrapped map function, or the original if no modifier is provided
+ * @__NO_SIDE_EFFECTS__
  */ function modifyModelMapFunction(mapFn, modifyModel) {
     var copy = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
     return modifyModel ? function(input, target, options) {
@@ -20201,8 +21310,15 @@ function _object_spread$2(target) {
 /**
  * Creates a function that reads a Node.js ReadableStream and converts its contents to a string using the specified encoding.
  *
+ * @dbxUtil
+ * @dbxUtilCategory nodejs
+ * @dbxUtilKind factory
+ * @dbxUtilTags nodejs, stream, readable, string, factory, encoding
+ * @dbxUtilRelated readable-stream-to-buffer, readable-stream-to-base64
+ *
  * @param encoding - The buffer encoding to use (e.g., 'utf-8', 'base64')
  * @returns A function that consumes a ReadableStream and resolves to its string content
+ * @__NO_SIDE_EFFECTS__
  */ function readableStreamToStringFunction(encoding) {
     return function(stream) {
         return readableStreamToBuffer(stream).then(function(x) {
@@ -20683,8 +21799,15 @@ function handlerFactory(readKey, options) {
 /**
  * Convenience function that creates a new {@link Handler} from the given key reader using default options.
  *
+ * @dbxUtil
+ * @dbxUtilCategory service
+ * @dbxUtilKind factory
+ * @dbxUtilTags service, handler, factory, dispatch, key, convenience
+ * @dbxUtilRelated handler-factory
+ *
  * @param readKey - Function to extract the dispatch key from an input value.
  * @returns A new Handler instance.
+ * @__NO_SIDE_EFFECTS__
  */ function makeHandler(readKey) {
     return handlerFactory(readKey)();
 }
@@ -20718,9 +21841,16 @@ function handlerFactory(readKey, options) {
 /**
  * Creates a {@link HandlerSetFunction} that registers a handler function on a pre-defined key.
  *
+ * @dbxUtil
+ * @dbxUtilCategory service
+ * @dbxUtilKind factory
+ * @dbxUtilTags service, handler, set, factory, register
+ * @dbxUtilRelated handler-mapped-set-function, handler-factory
+ *
  * @param accessor - The handler set accessor to register on.
  * @param key - The key (or keys) to associate the handler with.
  * @returns A function that accepts a handler function and registers it for the given key.
+ * @__NO_SIDE_EFFECTS__
  */ function handlerSetFunction(accessor, key) {
     var fn = function fn(handlerFunction) {
         accessor.set(key, handlerFunction); // set the handler on the pre-defined key.
@@ -20732,10 +21862,17 @@ function handlerFactory(readKey, options) {
  * Creates a {@link HandlerMappedSetFunction} that maps the handler's native input type to a different
  * type before invoking the registered handler function.
  *
+ * @dbxUtil
+ * @dbxUtilCategory service
+ * @dbxUtilKind factory
+ * @dbxUtilTags service, handler, set, mapped, factory, transform
+ * @dbxUtilRelated handler-set-function, handler-mapped-set-function-factory
+ *
  * @param accessor - The handler set accessor to register on.
  * @param key - The key (or keys) to associate the handler with.
  * @param mapFn - Function to map from the handler's native type to the handler function's expected type.
  * @returns A function that accepts a mapped handler function and registers it.
+ * @__NO_SIDE_EFFECTS__
  */ function handlerMappedSetFunction(accessor, key, mapFn) {
     var handlerSet = handlerSetFunction(accessor, key);
     return function(handlerFunction) {
@@ -20749,9 +21886,16 @@ function handlerFactory(readKey, options) {
 /**
  * Creates a {@link HandlerMappedSetFunctionFactory} that produces mapped set functions for any given key.
  *
+ * @dbxUtil
+ * @dbxUtilCategory service
+ * @dbxUtilKind factory
+ * @dbxUtilTags service, handler, mapped, factory, dispatch
+ * @dbxUtilRelated handler-mapped-set-function, handler-set-function
+ *
  * @param accessor - The handler set accessor to register on.
  * @param mapFn - Function to map from the handler's native type to the handler function's expected type.
  * @returns A factory that creates HandlerMappedSetFunctions for specific keys.
+ * @__NO_SIDE_EFFECTS__
  */ function handlerMappedSetFunctionFactory(accessor, mapFn) {
     return function(key) {
         return handlerMappedSetFunction(accessor, key, mapFn);
@@ -20761,8 +21905,15 @@ function handlerFactory(readKey, options) {
  * Creates a {@link HandlerConfigurerFactory} that produces configurers for binding handler functions
  * to a handler instance with automatic `this` binding.
  *
+ * @dbxUtil
+ * @dbxUtilCategory service
+ * @dbxUtilKind factory
+ * @dbxUtilTags service, handler, configurer, factory, bind
+ * @dbxUtilRelated handler-bind-accessor, handler-factory
+ *
  * @param config - Configuration providing the accessor-to-configurer mapping.
  * @returns A factory that creates HandlerConfigurers for specific handlers.
+ * @__NO_SIDE_EFFECTS__
  */ function handlerConfigurerFactory(config) {
     return function(handler) {
         return function(bindTo, configure) {
@@ -21826,8 +22977,15 @@ function mimeTypeForFileExtension(extension) {
 /**
  * Creates a {@link SortByStringFunction} that sorts values in ascending alphabetical order using `localeCompare`.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, sort, compare, alphabetical, factory, locale
+ * @dbxUtilRelated sort-by-label-function
+ *
  * @param readStringFn - Function to extract a string from each value for comparison.
  * @returns A comparator function suitable for use with `Array.sort()`.
+ * @__NO_SIDE_EFFECTS__
  */ function sortByStringFunction(readStringFn) {
     return function(a, b) {
         var as = readStringFn(a);
@@ -21844,8 +23002,15 @@ function mimeTypeForFileExtension(extension) {
 /**
  * Creates a {@link SearchStringFilterFunction} that filters values based on whether their string representation matches the filter text.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, search, filter, factory, match, decision
+ * @dbxUtilRelated case-insensitive-filter-by-index-of-decision-factory
+ *
  * @param config - A read function or full configuration specifying how to extract and match search strings.
  * @returns A function that filters an array of values by a search/filter text string.
+ * @__NO_SIDE_EFFECTS__
  */ function searchStringFilterFunction(config) {
     var _ref = typeof config === 'function' ? {
         readStrings: config
@@ -21940,8 +23105,15 @@ function _unsupported_iterable_to_array(o, minLen) {
 /**
  * Creates a {@link SplitStringTreeFactory} that builds tree structures by splitting strings on the configured separator.
  *
+ * @dbxUtil
+ * @dbxUtilCategory string
+ * @dbxUtilKind factory
+ * @dbxUtilTags string, tree, split, separator, factory, hierarchy
+ * @dbxUtilRelated add-to-split-string-tree, find-best-split-string-tree-match
+ *
  * @param config - Configuration specifying the separator and optional metadata merge strategy.
  * @returns A factory function that creates or extends split string trees.
+ * @__NO_SIDE_EFFECTS__
  */ function splitStringTreeFactory(config) {
     var separator = config.separator;
     var fn = function fn(input, existing) {
@@ -22101,6 +23273,7 @@ function _unsupported_iterable_to_array(o, minLen) {
  * @template N The type of the TreeNode to be created. Defaults to TreeNode<T, any> if not specified by ExpandTreeWithNodeBuilder.
  * @param config An ExpandTree<T> or ExpandTreeWithNodeBuilder<T, N> configuration object.
  * @returns An ExpandTreeFunction<T, N> that takes a root value and returns its corresponding tree structure.
+ * @__NO_SIDE_EFFECTS__
  */ function expandTreeFunction(config) {
     var _config_makeNode;
     var makeNodeFromConfig = (_config_makeNode = config.makeNode) !== null && _config_makeNode !== void 0 ? _config_makeNode : function(basicNode) {
@@ -22193,6 +23366,7 @@ function _unsupported_iterable_to_array(o, minLen) {
  *   visited.push(id);
  * });
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function exploreTreeFunction(config) {
     var _ref, _ref1, _ref2;
     var defaultMapNodeFn = (_ref = config === null || config === void 0 ? void 0 : config.mapNodeFunction) !== null && _ref !== void 0 ? _ref : MAP_IDENTITY;
@@ -22243,6 +23417,7 @@ function _unsupported_iterable_to_array(o, minLen) {
  * });
  * // Visits: root -> child1 -> leaf1 -> leaf2 -> child2 -> leaf3
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function depthFirstExploreTreeTraversalFactoryFunction() {
     return function(visit, continueTraversal) {
         return function(node, nodeMappedValue, visitDecision) {
@@ -22281,6 +23456,7 @@ function _unsupported_iterable_to_array(o, minLen) {
  * });
  * // Visits: root -> child1, child2, child3 -> leaf1, leaf2, leaf3
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function breadthFirstExploreTreeTraversalFactoryFunction() {
     return function(visit, continueTraversal) {
         var queue = [];
@@ -22453,6 +23629,7 @@ function _object_spread_props(target, source) {
  * const ids = flattenIds(rootNode);
  * // ['root', 'child1', 'leaf1', 'leaf2', 'child2', 'leaf3']
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function flattenTreeToArrayFunction(mapNodeFnOrConfig, defaultAddNodeFn) {
     var _config_shouldAddNodeFunction;
     var config = typeof mapNodeFnOrConfig === 'function' ? {
@@ -22491,6 +23668,7 @@ function _object_spread_props(target, source) {
  * @param expand An ExpandTreeFunction (values: T[]) => N[] that converts an array of T into an array of tree nodes N.
  * @param flatten A FlattenTreeFunction (tree: N, array?: V[]) => V[] that flattens a tree of N nodes into an array of V values.
  * @returns An ExpandFlattenTreeFunction (values: T[]) => V[] that performs the combined expansion and flattening.
+ * @__NO_SIDE_EFFECTS__
  */ function expandFlattenTreeFunction(expand, flatten) {
     return function(values) {
         return flatten(expandTrees(values, expand));
@@ -22617,6 +23795,7 @@ function invertMaybeBoolean(x) {
  * const coinFlip = booleanFactory({ chance: 50 });
  * coinFlip(); // true or false with equal probability
  * ```
+ * @__NO_SIDE_EFFECTS__
  */ function booleanFactory(config) {
     var inputChance = config.chance;
     var chance = inputChance / 100;
@@ -22794,6 +23973,7 @@ function _define_property$1(obj, key, value) {
  * @param decodeValues - An array of potential original string values.
  * @param hashFn - A function that takes a string and returns its hashed representation.
  * @returns A {@link HashDecodeMap} for decoding hashed values.
+ * @__NO_SIDE_EFFECTS__
  */ function makeHashDecodeMap(decodeValues, hashFn) {
     var keyValuePairs = decodeValues.map(function(x) {
         return [