@zelgadis87/utils-core 5.3.4 → 5.3.6

package/.rollup/index.d.ts

@@ -563,7 +563,7 @@ type TBasicTimePattern = 'y' | 'yy' | 'yyyy' | 'M' | 'MM' | 'd' | 'dd' | 'H' | '
     * @returns Partial time instant parameters that were parsed from the string
     * @throws Error if the string doesn't match the pattern or contains invalid values
     */
-declare function parseTimeInstantBasicComponents(dateString: string, pattern: TBasicTimePattern): Partial<TTimeInstantParameters>;
+declare function parseTimeInstantBasicComponents(dateString: string, pattern: TBasicTimePattern, ignoreIntlAvailability?: boolean): Partial<TTimeInstantParameters>;
 
 declare class TimeDuration extends TimeBase<TimeDuration> {
     protected constructor(value: number, unit: TimeUnit);
@@ -778,13 +778,14 @@ declare function indexByNumberWith<V, R = V>(arr: V[], keyGetter: TFunction<V, n
 declare function indexBySymbolWith<V, R = V>(arr: V[], keyGetter: TFunction<V, symbol>, valueMapper?: TFunction<V, R>): Record<symbol, R>;
 declare function indexByWith<K extends string | number | symbol, V, R = V>(arr: V[], keyGetter: TFunction<V, K>, valueMapper?: TFunction<V, R>): Record<K, R>;
 
-declare function average(arr: TReadableArray<number>): number;
+declare function average(arr: TReadableArray<number>): TMaybe<number>;
+declare function averageBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): TMaybe<number>;
 declare function sum(arr: TReadableArray<number>): number;
 declare function sumBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): number;
-declare function min(arr: TReadableArray<number>): number;
-declare function minBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): number;
-declare function max(arr: TReadableArray<number>): number;
-declare function maxBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): number;
+declare function min(arr: TReadableArray<number>): TMaybe<number>;
+declare function minBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): TMaybe<number>;
+declare function max(arr: TReadableArray<number>): TMaybe<number>;
+declare function maxBy<T>(arr: TReadableArray<T>, getter: (t: T) => number): TMaybe<number>;
 
 declare function uniq<T>(arr: T[]): T[];
 declare function uniqBy<T, K>(arr: T[], getter: TFunction<T, K>): T[];
@@ -807,7 +808,28 @@ declare function isArray<const T>(t: unknown): t is Array<T>;
  */
 declare function upsert<T>(arr: ReadonlyArray<T>, item: T, isEqual: TBiPredicate<T>): Array<T>;
 declare function range(start: number, end: number): Array<number>;
+/**
+ * Creates an array of the specified length, where each element is filled with the given value.
+ * @param length - The length of the array to create. Must be a non-negative integer.
+ * @param value - The value to fill each element with.
+ * @returns A new array with all elements set to the given value.
+ * @throws {RangeError} If length is negative, not an integer, or NaN.
+ * @example
+ * ```ts
+ * fill(3, 'a'); // ['a', 'a', 'a']
+ * fill(0, 42); // []
+ * fill(5, null); // [null, null, null, null, null]
+ * ```
+ */
 declare function fill<T>(length: number, value: T): Array<T>;
+/**
+ * Creates an array of the specified length, where each element is generated by the provided generator function.
+ * @param length - The length of the array to create. Must be a non-negative integer.
+ * @param generator - A function that takes an index and returns the value for that position.
+ * @returns A new array with elements generated by the generator function.
+ * @throws {RangeError} If length is negative or not an integer.
+ */
+declare function fillWith<T>(length: number, generator: TFunction<number, T>): Array<T>;
 declare function extendArray<T extends Record<string | number | symbol, unknown>, X extends Record<string | number | symbol, unknown>>(arr: TReadableArray<T>, props: X): Array<(T & X)>;
 declare function extendArrayWith<T extends Record<string | number | symbol, unknown>, X extends Record<string | number | symbol, unknown>>(arr: TReadableArray<T>, propsFn: (t: T) => X): Array<(T & X)>;
 declare function reverse<T>(arr: TReadableArray<T>): Array<T>;
@@ -1422,5 +1444,5 @@ declare class DataUpgrader<X extends TUpgradable, XLatest extends X> implements
 }
 declare function isUpgradable(obj: TJsonSerializable): obj is TUpgradable;
 
-export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, indexByWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, parseTimeInstantBasicComponents, parseTimeInstantComponents, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomId, randomNumberInInterval, range, repeat, reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
+export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, averageBy, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, fillWith, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, indexByWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, parseTimeInstantBasicComponents, parseTimeInstantComponents, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomId, randomNumberInInterval, range, repeat, reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
 export type { ICancelable, ICancelablePromise, IDataUpgrader, TAccumulator, TAllKeysOptional, TAnyFunction, TArrayable, TAsyncAnyFunction, TAsyncBiConsumer, TAsyncBiFunction, TAsyncBiPredicate, TAsyncConsumer, TAsyncFunction, TAsyncOperation, TAsyncOperationTuple, TAsyncPredicate, TAsyncProducer, TAsyncValidation, TAsyncVoidFunction, TBasicTimePattern, TBiConsumer, TBiFunction, TBiPredicate, TComparisonDirection, TComparisonFunction, TComparisonResult, TConditionalOptionalType, TConditionalParameter, TConditionalParameterOptions, TConsumer, TCssDeclarationRulesDictionary, TCssSelectorDeclarationRulesDictionary, TDayOfMonth, TDayOfWeek, TDigit, TDigit1_9, TEmpty, TEmptyArray, TEmptyObject, TEmptyOptional, TFourDigits, TFourDigitsMillisecond, TFourDigitsYear, TFunction, THasNever, THourOfDay, THtmlString, TIdentityFunction, TIntervalHandle, TIsEmptyObject, TIso8601DateString, TIso8601DateUtcString, TJsonArray, TJsonObject, TJsonPrimitive, TJsonSerializable, TKeysOfType, TLoggerOpts, TMaybe, TMillisecondOfSecond, TMinuteOfHour, TMonth, TMonthName, TNegativeNumber, TNumber0_10, TNumber0_100, TNumber0_1000, TNumber0_15, TNumber0_20, TNumber0_5, TNumber1_10, TNumericFloatingPointString, TNumericString, TOneDigit, TOperation, TOperationTuple, TOptional, TOptionalKeysForType, TOptionsWithoutDefaults, TParseInt, TParseableInt, TPositiveNumber, TPredefinedTimeDuration, TPredicate, TPresentOptional, TPrettify, TPrimitive, TProducer, TPromisable, TReadableArray, TRelativeUrl, TReplaceType, TRequiredKeysForType, TSecondOfMinute, TSorter, TSorterBuilder, TStrictComparisonResult, TThreeDigits, TThreeDigitsMillisecond, TTimeInUnits, TTimeoutHandle, TTransformer, TTwoDigits, TTwoDigitsDate, TTwoDigitsHour, TTwoDigitsMinute, TTwoDigitsMonth, TTwoDigitsSecond, TTypePredicate, TUpToFourDigits, TUpToThreeDigits, TUpToTwoDigits, TUpgradable, TUrl, TValidTimeDuration, TValidation, TVoidFunction, TWeekNumber, TWithExtras, TWithRequiredProperties, TWithRequiredProperty, TYear, TZero };

package/.rollup/index.mjs

@@ -445,9 +445,14 @@ function indexByWith(arr, keyGetter, valueMapper = v => v) {
 }
 
 function average(arr) {
+    if (arr.length === 0)
+        return null;
     const f = 1 / arr.length;
     return arr.reduce((tot, cur) => tot + (cur * f), 0);
 }
+function averageBy(arr, getter) {
+    return average(arr.map(getter));
+}
 function sum(arr) {
     return arr.reduce((tot, cur) => tot + cur, 0);
 }
@@ -456,7 +461,7 @@ function sumBy(arr, getter) {
 }
 function min(arr) {
     if (arr.length === 0)
-        throw new Error('Cannot calculate value on empty array');
+        return null;
     return arr.reduce((min, cur) => cur < min ? cur : min);
 }
 function minBy(arr, getter) {
@@ -464,7 +469,7 @@ function minBy(arr, getter) {
 }
 function max(arr) {
     if (arr.length === 0)
-        throw new Error('Cannot calculate value on empty array');
+        return null;
     return arr.reduce((max, cur) => cur > max ? cur : max);
 }
 function maxBy(arr, getter) {
@@ -619,9 +624,36 @@ function range(start, end) {
     let length = (end - start) + 1;
     return new Array(length).fill(1).map((_, i) => start + i);
 }
+/**
+ * Creates an array of the specified length, where each element is filled with the given value.
+ * @param length - The length of the array to create. Must be a non-negative integer.
+ * @param value - The value to fill each element with.
+ * @returns A new array with all elements set to the given value.
+ * @throws {RangeError} If length is negative, not an integer, or NaN.
+ * @example
+ * ```ts
+ * fill(3, 'a'); // ['a', 'a', 'a']
+ * fill(0, 42); // []
+ * fill(5, null); // [null, null, null, null, null]
+ * ```
+ */
 function fill(length, value) {
+    if (!Number.isInteger(length) || length < 0)
+        throw new RangeError(`Length must be a non-negative integer. Got: ${length}`);
     return new Array(length).fill(value);
 }
+/**
+ * Creates an array of the specified length, where each element is generated by the provided generator function.
+ * @param length - The length of the array to create. Must be a non-negative integer.
+ * @param generator - A function that takes an index and returns the value for that position.
+ * @returns A new array with elements generated by the generator function.
+ * @throws {RangeError} If length is negative or not an integer.
+ */
+function fillWith(length, generator) {
+    if (!Number.isInteger(length) || length < 0)
+        throw new RangeError(`Length must be a non-negative integer. Got: ${length}`);
+    return Array.from({ length }, (_, i) => generator(i));
+}
 function extendArray(arr, props) {
     return arr.map((t) => ({
         ...t,
@@ -2311,8 +2343,48 @@ function normalizeMonthName(name) {
         // Trim whitespace
         .trim();
 }
-const PATTERN_REGEX = /(M|y|d|D|h|H|m|s|S|G|Z|P|a)+/g;
 const ESCAPE_REGEX = /\\"|"((?:\\"|[^"])*)"/g;
+/**
+ * Tokenize a date/time pattern by detecting character changes.
+ *
+ * This function uses a character-change detection algorithm to split a pattern into tokens:
+ * 1. Iterates through the pattern character by character
+ * 2. Detects when the character changes (e.g., 'y' → 'M' → 'd')
+ * 3. Creates tokens based on consecutive identical characters
+ * 4. Marks tokens as pattern tokens only if they consist of repeated pattern characters
+ *
+ * This approach works correctly for patterns with or without separators:
+ * - "yyyy-MM-dd" → [{token:"yyyy", type:"y"}, {token:"-", type:null}, {token:"MM", type:"M"}, {token:"-", type:null}, {token:"dd", type:"d"}]
+ * - "yyyyMMdd" → [{token:"yyyy", type:"y"}, {token:"MM", type:"M"}, {token:"dd", type:"d"}]
+ *
+ * @param pattern - The date/time pattern to tokenize
+ * @returns Array of tokens with their types (null for separators/literals, pattern char for pattern tokens)
+ */
+function tokenizePattern(pattern) {
+    const result = [];
+    let currentToken = '';
+    let currentChar = '';
+    for (const char of pattern) {
+        if (char === currentChar) {
+            // Same character, extend current token
+            currentToken += char;
+        }
+        else {
+            // Character changed, end current token and start new one
+            if (currentToken) {
+                // Mark the token with its character (caller will decide if it's a valid pattern)
+                result.push({ token: currentToken, type: currentChar });
+            }
+            currentToken = char;
+            currentChar = char;
+        }
+    }
+    // Don't forget the last token
+    if (currentToken) {
+        result.push({ token: currentToken, type: currentChar });
+    }
+    return result;
+}
 // Formatter configuration mapping: token pattern -> configuration with optional extraction rules
 const formatterConfigs = {
     // Year
@@ -2394,11 +2466,16 @@ function formatTimeInstant(instant, pattern, config = {}) {
         if (index % 2 !== 0) {
             return sub;
         }
-        return sub.replace(PATTERN_REGEX, (match) => {
-            const type = match.charAt(0);
-            const length = match.length;
-            return formatType(type, length, date, locale, timeZone) || match;
-        });
+        // Tokenize the pattern by detecting character changes
+        const tokens = tokenizePattern(sub);
+        // Format each token and join the results
+        return tokens.map(({ token, type }) => {
+            // If type is null or formatting fails, keep token as-is
+            if (!type)
+                return token;
+            const formatted = formatType(type, token.length, date, locale, timeZone);
+            return formatted !== undefined ? formatted : token;
+        }).join('');
     })
         .join('');
 }
@@ -2426,53 +2503,62 @@ function parseTimeInstantComponents(dateString, pattern, config = {}) {
         if (index % 2 !== 0) {
             return sub.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // Escape special regex chars
         }
-        return sub.replace(PATTERN_REGEX, (match) => {
-            const type = match.charAt(0);
-            tokens.push({ type, length: match.length, position: position++ });
+        // Tokenize the pattern by detecting character changes
+        const patternTokens = tokenizePattern(sub);
+        // Build regex pattern from tokens
+        return patternTokens.map(({ token, type }) => {
+            // Check if this is a valid pattern by looking it up in formatterConfigs
+            const isValidPattern = type && formatterConfigs[token];
+            if (!isValidPattern) {
+                // This is a literal/separator, escape it for regex
+                return token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            }
+            // This is a pattern token, track it and create regex
+            tokens.push({ type, length: token.length, position: position++ });
             // Create appropriate regex for each token type
             switch (type) {
                 case 'y':
-                    return match.length === 2 ? '(\\d{2})' : '(\\d{4})';
+                    return token.length === 2 ? '(\\d{2})' : '(\\d{4})';
                 case 'M':
-                    if (match.length === 1)
+                    if (token.length === 1)
                         return '(\\d{1,2})';
-                    if (match.length === 2)
+                    if (token.length === 2)
                         return '(\\d{2})';
-                    if (match.length === 3)
+                    if (token.length === 3)
                         return '([A-Za-z.]{1,7})';
                     return '([A-Za-z]+)';
                 case 'd':
-                    return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
+                    return token.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
                 case 'H':
                 case 'h':
-                    return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
+                    return token.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
                 case 'm':
                 case 's':
-                    return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
+                    return token.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
                 case 'S':
-                    return `(\\d{${match.length}})`;
+                    return `(\\d{${token.length}})`;
                 case 'a':
                     return '([aApP][mM])';
                 case 'D':
-                    if (match.length === 1)
+                    if (token.length === 1)
                         return '([A-Za-z])';
-                    if (match.length === 2)
+                    if (token.length === 2)
                         return '([A-Za-z]{3})';
                     return '([A-Za-z]+)';
                 case 'G':
-                    if (match.length === 1)
+                    if (token.length === 1)
                         return '([A-Za-z])';
-                    if (match.length === 2)
+                    if (token.length === 2)
                         return '([A-Za-z]{2})';
                     return '([A-Za-z\\s]+)';
                 case 'Z':
-                    return match.length === 1 ? '([A-Za-z0-9+\\-:]+)' : '([A-Za-z\\s]+)';
+                    return token.length === 1 ? '([A-Za-z0-9+\\-:]+)' : '([A-Za-z\\s]+)';
                 case 'P':
                     return '([A-Za-z\\s]+)';
                 default:
-                    return match;
+                    return token;
             }
-        });
+        }).join('');
     }).join('');
     const regex = new RegExp('^' + regexPattern + '$');
     const matches = dateString.match(regex);
@@ -2598,10 +2684,10 @@ function parseTimeInstantComponents(dateString, pattern, config = {}) {
     * @returns Partial time instant parameters that were parsed from the string
     * @throws Error if the string doesn't match the pattern or contains invalid values
     */
-function parseTimeInstantBasicComponents(dateString, pattern) {
+function parseTimeInstantBasicComponents(dateString, pattern, ignoreIntlAvailability = false) {
     // Check if Intl is available, if so warn the user about the existing function
     const isIntlAvailable = typeof Intl !== 'undefined' && typeof Intl.DateTimeFormat !== 'undefined';
-    if (isIntlAvailable)
+    if (isIntlAvailable && !ignoreIntlAvailability)
         console.warn('Intl is available, use parseTimeInstantComponents instead of parseTimeInstantBasicComponents.');
     const result = {};
     let patternIndex = 0;
@@ -3473,5 +3559,5 @@ function isUpgradable(obj) {
     return isDefined(obj) && typeof obj === "object" && VERSION_FIELD in obj && isNumber(obj.$version) && isPositiveNumber(obj.$version);
 }
 
-export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first$1 as first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, indexByWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last$1 as last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, parseTimeInstantBasicComponents, parseTimeInstantComponents, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomId, randomNumberInInterval, range, repeat, reverse$1 as reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
+export { Cached, DataUpgrader, Deferred, DeferredCanceledError, ErrorCannotInstantiatePresentOptionalWithEmptyValue, ErrorGetEmptyOptional, ErrorSetEmptyOptional, Lazy, LazyAsync, LazyDictionary, Logger, NEVER, NonExhaustiveSwitchError, Operation, Optional, PredicateBuilder, RandomTimeDuration, RateThrottler, Semaphore, Sorter, StringParts, TimeDuration, TimeFrequency, TimeInstant, TimeRange, TimeUnit, TimeoutError, alwaysFalse, alwaysTrue, and, arrayGet, arrayIncludes, asError, asPromise, average, averageBy, awaitAtMost, capitalizeWord, clamp, clampInt0_100, constant, constantFalse, constantNull, constantOne, constantTrue, constantUndefined, constantZero, cssDeclarationRulesDictionaryToCss, decrement, decrementBy, delayPromise, dictToEntries, dictToList, divideBy, ellipsis, ensureArray, ensureDefined, ensureNegativeNumber, ensureNonNegativeNumber, ensureNonPositiveNumber, ensurePositiveNumber, ensureReadableArray, entriesToDict, entriesToEntries, entriesToList, extendArray, extendArrayWith, fill, fillWith, filterMap, filterMapReduce, filterWithTypePredicate, findInArray, findIndexInArray, first$1 as first, flatMapTruthys, getCauseMessageFromError, getCauseStackFromError, getMessageFromError, getStackFromError, groupByBoolean, groupByBooleanWith, groupByNumber, groupByNumberWith, groupByString, groupByStringWith, groupBySymbol, groupBySymbolWith, hashCode, head, identity, ifDefined, ifNullOrUndefined, iff, includes, increment, incrementBy, indexByNumber, indexByNumberWith, indexByString, indexByStringWith, indexBySymbol, indexBySymbolWith, indexByWith, isAllowedTimeDuration, isArray, isDefined, isEmpty, isError, isFalse, isFunction, isNegativeNumber, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumber, isPositiveNumber, isString, isTimeInstant, isTrue, isUpgradable, isZero, jsonCloneDeep, last$1 as last, listToDict, mapDefined, mapEntries, mapFirstTruthy, mapTruthys, max, maxBy, min, minBy, multiplyBy, noop, not, omitFromJsonObject, or, pad, padLeft, padRight, parseJson, parseTimeInstantBasicComponents, parseTimeInstantComponents, partition, pick, pipedInvoke, pipedInvokeFromArray, pluralize, promiseSequence, randomId, randomNumberInInterval, range, repeat, reverse$1 as reverse, round, roundAwayFromZero, roundToLower, roundToNearest, roundToUpper, roundTowardsZero, shallowArrayEquals, shallowRecordEquals, sortedArray, splitWords, stringToNumber, stringifyJson, sum, sumBy, tail, throttle, throwIfNullOrUndefined, transformCssDictionary, tryToParseJson, tryToParseNumber, uniq, uniqBy, uniqByKey, unzip, upsert, withTryCatch, withTryCatchAsync, wrapWithString, xor, zip };
 //# sourceMappingURL=index.mjs.map