modern-ts 0.8.0

package/dist/types/Utils/Predicates.d.ts

@@ -0,0 +1,361 @@
+/**
+ * Gets the internal [[Class]] property of a value using Object.prototype.toString
+ * @param value - Value to check
+ * @returns String representation of value's type
+ * @remarks Handles null and undefined explicitly to avoid [[Class]] inconsistencies
+ */
+export declare const getTag: (value: unknown) => string;
+/**
+ * Checks if value is a string primitive or String object
+ * @param value - Value to check
+ * @returns Type guard for string
+ * @remarks Returns true for both primitive strings and String objects
+ */
+export declare const isString: (value: unknown) => value is string;
+/**
+ * Checks if value is a number primitive or Number object
+ * @param value - Value to check
+ * @returns Type guard for number
+ * @remarks Returns true for both primitive numbers and Number objects
+ */
+export declare const isNumber: (value: unknown) => value is number;
+/**
+ * Checks if value is a finite number
+ * @param value - Value to check
+ * @returns Type guard for finite number
+ * @remarks Returns false for Infinity, -Infinity, and NaN
+ */
+export declare const isFinite: (value: unknown) => value is number;
+/**
+ * Checks if value is a boolean primitive or Boolean object
+ * @param value - Value to check
+ * @returns Type guard for boolean
+ * @remarks Returns true for both primitive booleans and Boolean objects
+ */
+export declare const isBoolean: (value: unknown) => value is boolean;
+/**
+ * Checks if value is a symbol primitive or Symbol object
+ * @param value - Value to check
+ * @returns Type guard for symbol
+ * @remarks Returns true for both primitive symbols and Symbol objects
+ */
+export declare const isSymbol: (value: unknown) => value is symbol;
+/**
+ * Checks if value is strictly null
+ * @param value - Value to check
+ * @returns Type guard for null
+ * @remarks Uses strict equality (value === null)
+ */
+export declare const isNull: (value: unknown) => value is null;
+/**
+ * Checks if value is strictly undefined
+ * @param value - Value to check
+ * @returns Type guard for undefined
+ * @remarks Uses strict equality (value === undefined)
+ */
+export declare const isUndefined: (value: unknown) => value is undefined;
+/**
+ * Checks if value is null or undefined (loose equality)
+ * @param value - Value to check
+ * @returns Type guard for null | undefined
+ * @remarks Uses loose equality (value == null)
+ */
+export declare const isNil: (value: unknown) => value is null | undefined;
+/**
+ * Checks if value is NOT null or undefined
+ * @param value - Value to check
+ * @returns Type guard for NonNullable<unknown>
+ * @remarks Opposite of isNil
+ */
+export declare const isNotNil: (value: unknown) => value is NonNullable<unknown>;
+/**
+ * Checks if value is NOT null or undefined with proper type narrowing
+ * @template T - Type of value when not nullish
+ * @param value - Value to check
+ * @returns Type guard for T
+ * @remarks Properly narrows generic types while filtering null/undefined
+ */
+export declare const isNotNullish: <T>(value: T | null | undefined) => value is T;
+/**
+ * Checks if value is a JavaScript primitive type
+ * @param value - Value to check
+ * @returns Type guard for primitive types
+ * @remarks Returns true for string, number, boolean, symbol, bigint, null, undefined
+ */
+export declare const isPrimitive: (value: unknown) => value is string | number | boolean | symbol | bigint | null | undefined;
+/**
+ * Checks if value is an object (including functions)
+ * @param value - Value to check
+ * @returns Type guard for object
+ * @remarks Returns true for objects and functions, false for null
+ */
+export declare const isObject: (value: unknown) => value is object;
+/**
+ * Checks if value is a function
+ * @param value - Value to check
+ * @returns Type guard for function
+ * @remarks Returns true for any function type
+ */
+export declare const isFunction: (value: unknown) => value is (...arg: unknown[]) => unknown;
+/**
+ * Checks if value is an array
+ * @param value - Value to check
+ * @returns Type guard for array
+ * @remarks Uses native Array.isArray for reliability
+ */
+export declare const isArray: (value: unknown) => value is unknown[];
+/**
+ * Checks if value is a plain object (object created by {} or new Object)
+ * @param value - Value to check
+ * @returns Type guard for plain object
+ * @remarks Returns false for arrays, dates, regexp, and custom class instances
+ */
+export declare const isPlainObject: (value: unknown) => value is Record<PropertyKey, unknown>;
+/**
+ * Checks if value is an integer
+ * @param value - Value to check
+ * @returns Type guard for integer number
+ * @remarks Returns true for integer numbers, false for non-integer numbers
+ */
+export declare const isInteger: (value: unknown) => value is number;
+/**
+ * Checks if value is a safe integer
+ * @param value - Value to check
+ * @returns Type guard for safe integer
+ * @remarks Safe integers are integers between -(2^53-1) and 2^53-1
+ */
+export declare const isSafeInteger: (value: unknown) => value is number;
+/**
+ * Checks if value is a valid array-like length
+ * @param value - Value to check
+ * @returns Type guard for valid length number
+ * @remarks Valid lengths are non-negative integers ≤ Number.MAX_SAFE_INTEGER
+ */
+export declare const isLength: (value: unknown) => value is number;
+/**
+ * Checks if value is a Date object
+ * @param value - Value to check
+ * @returns Type guard for Date
+ * @remarks Returns true for Date instances only
+ */
+export declare const isDate: (value: unknown) => value is Date;
+/**
+ * Checks if value is a RegExp object
+ * @param value - Value to check
+ * @returns Type guard for RegExp
+ * @remarks Returns true for RegExp instances only
+ */
+export declare const isRegExp: (value: unknown) => value is RegExp;
+/**
+ * Checks if value is an Error object
+ * @param value - Value to check
+ * @returns Type guard for Error
+ * @remarks Returns true for Error and DOMException instances
+ */
+export declare const isError: (value: unknown) => value is Error;
+/**
+ * Checks if value is a Map object
+ * @param value - Value to check
+ * @returns Type guard for Map<unknown, unknown>
+ * @remarks Returns true for Map instances only
+ */
+export declare const isMap: (value: unknown) => value is Map<unknown, unknown>;
+/**
+ * Checks if value is a Set object
+ * @param value - Value to check
+ * @returns Type guard for Set<unknown>
+ * @remarks Returns true for Set instances only
+ */
+export declare const isSet: (value: unknown) => value is Set<unknown>;
+/**
+ * Checks if value is a WeakMap object
+ * @param value - Value to check
+ * @returns Type guard for WeakMap<object, unknown>
+ * @remarks Returns true for WeakMap instances only
+ */
+export declare const isWeakMap: (value: unknown) => value is WeakMap<object, unknown>;
+/**
+ * Checks if value is a WeakSet object
+ * @param value - Value to check
+ * @returns Type guard for WeakSet<object>
+ * @remarks Returns true for WeakSet instances only
+ */
+export declare const isWeakSet: (value: unknown) => value is WeakSet<object>;
+/**
+ * Checks if value is an ArrayBuffer object
+ * @param value - Value to check
+ * @returns Type guard for ArrayBuffer
+ * @remarks Returns true for ArrayBuffer instances only
+ */
+export declare const isArrayBuffer: (value: unknown) => value is ArrayBuffer;
+/**
+ * Checks if value is a typed array
+ * @param value - Value to check
+ * @returns Type guard for ArrayBufferView
+ * @remarks Supports all standard typed array types
+ */
+export declare const isTypedArray: (value: unknown) => value is ArrayBufferView;
+/**
+ * Checks if code is running in a browser environment
+ * @returns True if running in browser with DOM access
+ * @remarks Verifies both window and document exist and are properly connected
+ */
+export declare const isBrowser: () => boolean;
+/**
+ * Checks if code is running in a client environment
+ * @returns True if running in any client-side context
+ * @remarks Less strict than isBrowser, checks for window or self
+ */
+export declare const isClient: () => boolean;
+/**
+ * Checks if code is running in a Node.js environment
+ * @returns True if running in Node.js
+ * @remarks Checks for process.versions.node existence
+ */
+export declare const isNode: () => boolean;
+/**
+ * Checks if value is a Buffer (Node.js)
+ * @param value - Value to check
+ * @returns True if value is a Buffer
+ * @remarks Uses Buffer.isBuffer if available, fails gracefully in browser
+ */
+export declare const isBuffer: (value: unknown) => boolean;
+/**
+ * Checks if value is a Blob object
+ * @param value - Value to check
+ * @returns Type guard for Blob
+ * @remarks Returns true for Blob instances only
+ */
+export declare const isBlob: (value: unknown) => value is Blob;
+/**
+ * Checks if value is a File object
+ * @param value - Value to check
+ * @returns Type guard for File
+ * @remarks Returns true for File instances only
+ */
+export declare const isFile: (value: unknown) => value is File;
+/**
+ * Checks if value is iterable (has Symbol.iterator)
+ * @param value - Value to check
+ * @returns Type guard for Iterable<unknown>
+ * @remarks Returns true for arrays, strings, maps, sets, and custom iterables
+ */
+export declare const isIterable: (value: unknown) => value is Iterable<unknown>;
+/**
+ * Checks if value is async iterable (has Symbol.asyncIterator)
+ * @param value - Value to check
+ * @returns Type guard for AsyncIterable<unknown>
+ * @remarks Returns true for async generators and custom async iterables
+ */
+export declare const isAsyncIterable: (value: unknown) => value is AsyncIterable<unknown>;
+export { isPromiseLike } from '../helper';
+/**
+ * Checks if value is a Promise
+ * @param value - Value to check
+ * @returns Type guard for Promise<unknown>
+ * @remarks Returns true for native promises and promise-like objects
+ */
+export declare const isPromise: (value: unknown) => value is Promise<unknown>;
+/**
+ * Checks if value is an instance of specified constructor
+ * @template T - Expected instance type
+ * @param value - Value to check
+ * @param constructor - Constructor function
+ * @returns Type guard for T
+ * @remarks Uses instanceof operator with type safety
+ */
+export declare const isInstanceOf: <T>(value: unknown, constructor: abstract new (...args: any[]) => T) => value is T;
+/**
+ * Checks if value is a valid property key (string, number, or symbol)
+ * @param value - Value to check
+ * @returns Type guard for PropertyKey
+ * @remarks Returns true for values usable as object keys
+ */
+export declare const isPropertyKey: (value: unknown) => value is PropertyKey;
+/**
+ * Checks if value is empty (null, undefined, or has no elements/properties)
+ * @param value - Value to check
+ * @returns True if value is considered empty
+ * @remarks Handles arrays, strings, maps, sets, and plain objects
+ */
+export declare const isEmpty: (value: unknown) => boolean;
+/**
+ * Checks if value is an empty plain object
+ * @param value - Value to check
+ * @returns Type guard for empty plain object
+ * @remarks Returns true only for plain objects with no own enumerable properties
+ */
+export declare const isEmptyObject: (value: unknown) => value is Record<PropertyKey, unknown>;
+/**
+ * Checks if value is JSON serializable
+ * @param value - Value to check
+ * @returns True if value can be serialized to JSON
+ * @remarks Recursively checks arrays and objects, excludes functions and symbols
+ */
+export declare const isSerializable: (value: unknown) => boolean;
+/**
+ * Checks if value is a valid JSON value
+ * @param value - Value to check
+ * @returns True if value is JSON-compatible
+ * @remarks Less strict than isSerializable, allows undefined in some contexts
+ */
+export declare const isJSONValue: (value: unknown) => boolean;
+/**
+ * Checks if value is a JSON-serializable object
+ * @param value - Value to check
+ * @returns Type guard for JSON object
+ * @remarks Returns true for plain objects with JSON-compatible values
+ */
+export declare const isJSONObject: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Checks if value is a JSON-serializable array
+ * @param value - Value to check
+ * @returns Type guard for JSON array
+ * @remarks Returns true for arrays with JSON-compatible values
+ */
+export declare const isJSONArray: (value: unknown) => value is unknown[];
+/**
+ * Checks if value is a valid JSON string
+ * @param value - Value to check
+ * @returns Type guard for JSON string
+ * @remarks Returns true for strings that parse to valid JSON
+ */
+export declare const isJSON: (value: unknown) => value is string;
+/**
+ * Checks if value is a valid email format string
+ * @param value - Value to check
+ * @returns Type guard for email string
+ * @remarks Uses basic email regex validation
+ */
+export declare const isEmail: (value: unknown) => value is string;
+/**
+ * Checks if value is a valid URL string
+ * @param value - Value to check
+ * @returns Type guard for URL string
+ * @remarks Uses URL constructor for validation
+ */
+export declare const isUrl: (value: unknown) => value is string;
+/**
+ * Checks if value is a valid UUID string
+ * @param value - Value to check
+ * @returns Type guard for UUID string
+ * @remarks Supports both uppercase and lowercase UUIDs
+ */
+export declare const isUUID: (value: unknown) => value is string;
+/**
+ * Deep equality check with custom comparator
+ * @param value - First value to compare
+ * @param other - Second value to compare
+ * @param customizer - Optional custom comparison function
+ * @returns True if values are deeply equal
+ * @remarks Handles circular references, NaN equality, and various object types
+ */
+export declare const isEqualWith: (value: unknown, other: unknown, customizer?: (val1: unknown, val2: unknown) => boolean | void) => boolean;
+/**
+ * Deep equality check without custom comparator
+ * @param value - First value to compare
+ * @param other - Second value to compare
+ * @returns True if values are deeply equal
+ * @remarks Convenience wrapper for isEqualWith without customizer
+ */
+export declare const isEqual: (value: unknown, other: unknown) => boolean;

package/dist/types/Utils/Set.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Creates a new set containing only values that satisfy the predicate
+ * @remarks Type-safe overload supports type narrowing via type guards
+ * @param set - The source set to filter
+ * @param predicate - Function returning true for values to include
+ * @returns New set containing filtered values
+ * @throws {TypeError} If predicate is not a function
+ */
+export declare function filter<T, S extends T>(set: Set<T>, predicate: (value: T) => value is S): Set<S>;
+export declare function filter<T>(set: Set<T>, predicate: (value: T) => boolean): Set<T>;
+/**
+ * Creates a new set by transforming each value
+ * @remarks Duplicate transformed values are deduplicated in the result set
+ * @param set - Source set to map
+ * @param iteratee - Transformation function
+ * @returns New set with transformed values
+ * @throws {TypeError} If iteratee is not a function
+ */
+export declare const map: <T, U>(set: Set<T>, iteratee: (value: T) => U) => Set<U>;
+/**
+ * Accumulates values into a single result
+ * @remarks Iteration order follows set iteration order
+ * @param set - Source set to reduce
+ * @param iteratee - Accumulator function
+ * @param initial_value - Starting value for accumulation
+ * @returns Final accumulated value
+ */
+export declare const reduce: <T, U>(set: Set<T>, iteratee: (accumulator: U, value: T) => U, initial_value: U) => U;
+/**
+ * Counts occurrences of values grouped by key
+ * @remarks Keys are coerced to strings for object property access
+ * @param set - Source set to count
+ * @param iteratee - Function returning grouping key
+ * @returns Object mapping keys to counts
+ */
+export declare const countBy: <T>(set: Set<T>, iteratee: (value: T) => string | number) => Record<string | number, number>;
+/**
+ * Groups values into a map by key
+ * @remarks Original values are preserved in arrays
+ * @param set - Source set to group
+ * @param iteratee - Function returning grouping key
+ * @returns Map from keys to arrays of values
+ */
+export declare const groupBy: <T, G>(set: Set<T>, iteratee: (value: T) => G) => Map<G, T[]>;
+/**
+ * Removes values that don't satisfy predicate from the original set
+ * @remarks Mutates the input set and returns it for chaining
+ * @param set - Set to filter in place
+ * @param predicate - Function returning true to keep value
+ * @returns The same set instance after mutation
+ * @throws {TypeError} If predicate is not a function
+ */
+export declare const filterInPlace: <T>(set: Set<T>, predicate: (value: T) => boolean) => Set<T>;
+/**
+ * Adds all values from an iterable to the target set
+ * @remarks Mutates target set, duplicate values are ignored
+ * @param target - Set to modify
+ * @param other - Iterable containing values to add
+ * @returns The mutated target set
+ */
+export declare const unionInPlace: <T>(target: Set<T>, other: Iterable<T>) => Set<T>;
+/**
+ * Removes values from target that aren't present in the other iterable
+ * @remarks Mutates target set. For non-Set iterables, creates temporary Set.
+ * @param target - Set to modify
+ * @param other - Iterable containing allowed values
+ * @returns The mutated target set
+ */
+export declare const intersectInPlace: <T>(target: Set<T>, other: Iterable<T>) => Set<T>;
+/**
+ * Removes values present in the other iterable from the target set
+ * @remarks Mutates target set. Values not in target are ignored.
+ * @param target - Set to modify
+ * @param other - Iterable containing values to remove
+ * @returns The mutated target set
+ */
+export declare const differenceInPlace: <T>(target: Set<T>, other: Iterable<T>) => Set<T>;
+export declare const subtractInPlace: <T>(target: Set<T>, other: Iterable<T>) => Set<T>;
+/**
+ * Tests if at least one value satisfies the predicate
+ * @remarks Short-circuits on first match. Empty sets return false.
+ * @param set - Set to test
+ * @param predicate - Test function
+ * @returns True if predicate returns true for any value
+ * @throws {TypeError} If predicate is not a function
+ */
+export declare const some: <T>(set: Set<T>, predicate: (value: T) => boolean) => boolean;
+/**
+ * Tests if all values satisfy the predicate
+ * @remarks Short-circuits on first failure. Empty sets return true.
+ * @param set - Set to test
+ * @param predicate - Test function
+ * @returns True if predicate returns true for all values
+ * @throws {TypeError} If predicate is not a function
+ */
+export declare const every: <T>(set: Set<T>, predicate: (value: T) => boolean) => boolean;
+/**
+ * Finds the first value that satisfies the predicate
+ * @remarks Iteration order follows set iteration order
+ * @param set - Set to search
+ * @param predicate - Test function
+ * @returns The first matching value, or undefined if none found
+ * @throws {TypeError} If predicate is not a function
+ */
+export declare const find: <T>(set: Set<T>, predicate: (value: T) => boolean) => T | undefined;

package/dist/types/Utils/String.d.ts

@@ -0,0 +1,217 @@
+/**
+ * Removes whitespace or specified characters from both ends of a string
+ * @param str - String to trim
+ * @param chars - Characters to trim (defaults to whitespace). If provided, removes all characters in this string from both ends.
+ * @returns Trimmed string. Returns empty string if input is empty.
+ * @example
+ * trim('  hello  ') // 'hello'
+ * trim('--hello--', '-') // 'hello'
+ * trim('', '-') // ''
+ */
+export declare const trim: (str: string, chars?: string) => string;
+/**
+ * Removes whitespace or specified characters from the start of a string
+ * @param str - String to trim
+ * @param chars - Characters to trim (defaults to whitespace). If provided, removes all characters in this string from the start.
+ * @returns Trimmed string. Returns empty string if input is empty.
+ * @example
+ * trimStart('  hello  ') // 'hello  '
+ * trimStart('--hello', '-') // 'hello'
+ */
+export declare const trimStart: (str: string, chars?: string) => string;
+/**
+ * Removes whitespace or specified characters from the end of a string
+ * @param str - String to trim
+ * @param chars - Characters to trim (defaults to whitespace). If provided, removes all characters in this string from the end.
+ * @returns Trimmed string. Returns empty string if input is empty.
+ * @example
+ * trimEnd('  hello  ') // '  hello'
+ * trimEnd('hello--', '-') // 'hello'
+ */
+export declare const trimEnd: (str: string, chars?: string) => string;
+/**
+ * Pads a string on both sides with specified characters to reach given length
+ * @param str - String to pad
+ * @param length - Target length after padding. If str length >= length, returns original string.
+ * @param chars - Padding characters (defaults to space). If empty string, returns original string.
+ * @returns Padded string. Returns original string if padding not needed or chars empty.
+ * @throws If length is negative
+ * @example
+ * pad('hi', 5) // '  hi  '
+ * pad('hi', 5, '-') // '--hi-'
+ * pad('hello', 3) // 'hello'
+ * pad('hi', 6, 'abc') // 'abhiab'
+ */
+export declare const pad: (str: string, length: number, chars?: string) => string;
+/**
+ * Removes diacritical marks (accents) from characters using Unicode normalization
+ * @param str - String to process
+ * @returns String with diacritical marks removed. Returns empty string if input is empty.
+ * @example
+ * deburr('déjà vu') // 'deja vu'
+ * deburr('') // ''
+ */
+export declare const deburr: (str: string) => string;
+/**
+ * Escapes special regex characters in a string
+ * @param str - String containing regex special characters
+ * @returns Escaped string safe for use in regex construction. Returns empty string if input is empty.
+ * @example
+ * escapeRegExp('[test].*') // '\\[test\\]\\.\\*'
+ */
+export declare const escapeRegExp: (str: string) => string;
+/**
+ * Escapes HTML special characters (&, <, >, ", ')
+ * @param str - String containing HTML
+ * @returns Escaped string with HTML entities. Returns empty string if input is empty.
+ * @example
+ * escape('<div>"test"</div>') // '&lt;div&gt;&quot;test&quot;&lt;/div&gt;'
+ */
+export declare const escape: (str: string) => string;
+/**
+ * Unescapes HTML entities (&amp;, &lt;, &gt;, &quot;, &#39;)
+ * @param str - String with HTML entities
+ * @returns Unescaped string. Returns empty string if input is empty.
+ * @example
+ * unescape('&lt;div&gt;') // '<div>'
+ */
+export declare const unescape: (str: string) => string;
+/**
+ * Reverses a string while preserving Unicode characters and emojis
+ * @param str - String to reverse
+ * @returns Reversed string. Returns empty string if input is empty.
+ * @example
+ * reverseString('hello') // 'olleh'
+ * reverseString('👍👋') // '👋👍'
+ */
+export declare const reverseString: (str: string) => string;
+/**
+ * Converts string to Start Case (capitalizes first letter of each word)
+ * @param str - String to convert
+ * @returns Start case string. Returns empty string if input contains no words.
+ * @remarks Handles alphanumeric boundaries (e.g., "test123" becomes "Test 123")
+ * @example
+ * startCase('hello world') // 'Hello World'
+ * startCase('hello-world') // 'Hello World'
+ * startCase('test123abc') // 'Test 123 Abc'
+ */
+export declare const startCase: (str: string) => string;
+/**
+ * Converts string to camelCase
+ * @param str - String to convert
+ * @returns camelCase string. Returns empty string if input contains no words.
+ * @example
+ * camelCase('Hello World') // 'helloWorld'
+ * camelCase('hello-world') // 'helloWorld'
+ * camelCase('') // ''
+ */
+export declare const camelCase: (str: string) => string;
+/**
+ * Capitalizes first character and lowercases the rest
+ * @param str - String to capitalize
+ * @returns Capitalized string. Returns empty string if input is empty.
+ * @example
+ * capitalize('hello') // 'Hello'
+ * capitalize('HELLO') // 'Hello'
+ */
+export declare const capitalize: (str: string) => string;
+/**
+ * Converts string to CONSTANT_CASE (UPPERCASE_WITH_UNDERSCORES)
+ * @param str - String to convert
+ * @returns CONSTANT_CASE string. Returns empty string if input contains no words.
+ * @example
+ * constantCase('hello world') // 'HELLO_WORLD'
+ */
+export declare const constantCase: (str: string) => string;
+/**
+ * Converts string to kebab-case (lowercase-with-hyphens)
+ * @param str - String to convert
+ * @returns kebab-case string. Returns empty string if input contains no words.
+ * @example
+ * kebabCase('Hello World') // 'hello-world'
+ */
+export declare const kebabCase: (str: string) => string;
+/**
+ * Converts string to lowercase with spaces
+ * @param str - String to convert
+ * @returns Lowercase string with words separated by spaces. Returns empty string if input contains no words.
+ * @example
+ * lowerCase('HelloWorld') // 'hello world'
+ */
+export declare const lowerCase: (str: string) => string;
+/**
+ * Converts first character to lowercase
+ * @param str - String to convert
+ * @returns String with first character lowercased. Returns empty string if input is empty.
+ * @example
+ * lowerFirst('Hello') // 'hello'
+ * lowerFirst('HELLO') // 'hELLO'
+ */
+export declare const lowerFirst: (str: string) => string;
+/**
+ * Converts string to PascalCase (capitalizes first letter of each word)
+ * @param str - String to convert
+ * @returns PascalCase string. Returns empty string if input contains no words.
+ * @example
+ * pascalCase('hello world') // 'HelloWorld'
+ */
+export declare const pascalCase: (str: string) => string;
+/**
+ * Converts string to snake_case (lowercase_with_underscores)
+ * @param str - String to convert
+ * @returns snake_case string. Returns empty string if input contains no words.
+ * @example
+ * snakeCase('Hello World') // 'hello_world'
+ */
+export declare const snakeCase: (str: string) => string;
+/**
+ * Converts string to UPPERCASE WITH SPACES
+ * @param str - String to convert
+ * @returns Uppercase string with words separated by spaces. Returns empty string if input contains no words.
+ * @example
+ * upperCase('hello-world') // 'HELLO WORLD'
+ */
+export declare const upperCase: (str: string) => string;
+/**
+ * Converts first character to uppercase
+ * @param str - String to convert
+ * @returns String with first character uppercased. Returns empty string if input is empty.
+ * @example
+ * upperFirst('hello') // 'Hello'
+ * upperFirst('hELLO') // 'HELLO'
+ */
+export declare const upperFirst: (str: string) => string;
+/**
+ * Extracts words from string using Unicode-aware regex (supports all languages)
+ * @param str - String to extract words from
+ * @returns Array of words (Unicode letters and numbers). Returns empty array if no words found.
+ * @example
+ * words('Hello world!') // ['Hello', 'world']
+ * words('你好，世界！') // ['你好', '世界']
+ * words('123 abc') // ['123', 'abc']
+ */
+export declare const words: (str: string) => string[];
+/**
+ * Generates a random string from the specified character set
+ * @param length - Length of the string to generate. Must be a non-negative integer.
+ * @param charset - Character set to use for generation. Defaults to alphanumeric (a-z, A-Z, 0-9).
+ * @returns Randomly generated string
+ * @throws ParameterError if length is negative or not an integer
+ * @example
+ * randomString(8) // 'aB3xK9pL'
+ * randomString(6, '0123456789') // '384729'
+ * randomString(10, 'abc') // 'abccabacba'
+ */
+export declare const randomString: (length: number, charset?: string) => string;
+/**
+ * Replaces placeholders in template string with values from data object
+ * @template T - Type of data object
+ * @param str - Template string with {{placeholder}} syntax
+ * @param data - Object containing values to replace placeholders. Supports nested paths like {{user.name}}
+ * @returns String with placeholders replaced by corresponding values. Undefined values are replaced with empty string.
+ * @example
+ * template('Hello {{name}}!', {name: 'Alice'}) // 'Hello Alice!'
+ * template('Hello {{user.name}}!', {user: {name: 'Bob'}}) // 'Hello Bob!'
+ * template('Welcome to {{company}}!', {company: 'Tech Corp'}) // 'Welcome to Tech Corp!'
+ */
+export declare const template: <T extends Record<string, unknown>>(str: string, data: T) => string;

package/dist/types/Utils/__export__.d.ts

@@ -0,0 +1,9 @@
+export * as Arr from './Array/__export__';
+export * from './Functions/__export__';
+export * from './Object/__export__';
+export * as Str from './String';
+export * as Sets from './Set';
+export * as Maps from './Map';
+export * from './Math';
+export * from './Predicates';
+export type * from './type-tool';