{"version":3,"sources":["../src/index.ts","../src/core/string.ts","../src/core/array.ts","../src/core/object.ts","../src/core/number.ts","../src/core/date.ts","../src/core/math.ts","../src/core/function.ts","../src/core/collection.ts","../src/core/utility.ts","../src/core/type.ts","../src/constants/index.ts","../src/utils/api.ts","../src/utils/extractFromString.ts","../src/utils/hash.ts","../src/utils/getCountry.ts"],"sourcesContent":["export * from './core';\nexport * from './constants';\nexport * from './utils';","/**\n * Lightweight string utility functions\n * No external dependencies - includes lodash-inspired methods\n * @since 0.8.0\n */\n\n/**\n * Removes all accents from a string\n * @param {any} str - The string to purify\n * @returns {string} Returns the string without accents\n * @since 0.8.0\n * @example\n * purify('café'); // 'cafe'\n * purify('naïve'); // 'naive'\n */\nexport function purify (str: any): string {\n  return typeof str === \"string\"\n    ? str.normalize(\"NFD\").replace(/[\\u0300-\\u036f]/g, \"\")\n    : \"\";\n}\n\n/**\n * Capitalizes the first character of a string\n * @param {string} str - The string to capitalize\n * @returns {string} Returns the capitalized string\n * @since 0.8.0\n * @example\n * capitalize('hello'); // 'Hello'\n * capitalize('WORLD'); // 'WORLD'\n */\nexport function capitalize (str: string): string {\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\n/**\n * Removes leading and trailing whitespace\n * @param {string} str - The string to trim\n * @param {string} [chars] - The characters to remove\n * @returns {string} Returns the trimmed string\n * @since 0.8.0\n * @example\n * trim('  hello  '); // 'hello'\n * trim('---hello---', '-'); // 'hello'\n */\nexport function trim (str: string, chars?: string): string {\n  if (chars === undefined) {\n    return str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n  }\n  const charRegex = new RegExp(`^[${escapeRegExp(chars)}]+|[${escapeRegExp(chars)}]+$`, 'g');\n  return str.replace(charRegex, '');\n}\n\n/**\n * Removes leading whitespace\n * @param {string} str - The string to trim\n * @param {string} [chars] - The characters to remove\n * @returns {string} Returns the trimmed string\n * @since 0.8.0\n * @example\n * trimStart('  hello  '); // 'hello  '\n * trimStart('---hello---', '-'); // 'hello---'\n */\nexport function trimStart (str: string, chars?: string): string {\n  if (chars === undefined) {\n    return str.replace(/^[\\s\\uFEFF\\xA0]+/, '');\n  }\n  const charRegex = new RegExp(`^[${escapeRegExp(chars)}]+`, 'g');\n  return str.replace(charRegex, '');\n}\n\n/**\n * Removes trailing whitespace\n * @param {string} str - The string to trim\n * @param {string} [chars] - The characters to remove\n * @returns {string} Returns the trimmed string\n * @since 0.8.0\n * @example\n * trimEnd('  hello  '); // '  hello'\n * trimEnd('---hello---', '-'); // '---hello'\n */\nexport function trimEnd (str: string, chars?: string): string {\n  if (chars === undefined) {\n    return str.replace(/[\\s\\uFEFF\\xA0]+$/, '');\n  }\n  const charRegex = new RegExp(`[${escapeRegExp(chars)}]+$`, 'g');\n  return str.replace(charRegex, '');\n}\n\n/**\n * Converts string to camelCase\n * @param {string} str - The string to convert\n * @returns {string} Returns the camel cased string\n * @since 0.9.0\n * @example\n * camelCase('hello world'); // 'helloWorld'\n * camelCase('hello-world'); // 'helloWorld'\n */\nexport function camelCase (str: string): string {\n  return str\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, (word, index) =>\n      index === 0 ? word.toLowerCase() : word.toUpperCase())\n    .replace(/\\s+/g, '')\n    .replace(/[^a-zA-Z0-9]/g, '');\n}\n\n/**\n * Converts string to kebab-case\n * @param {string} str - The string to convert\n * @returns {string} Returns the kebab cased string\n * @since 0.9.0\n * @example\n * kebabCase('hello world'); // 'hello-world'\n * kebabCase('HelloWorld'); // 'hello-world'\n */\nexport function kebabCase (str: string): string {\n  return str\n    .replace(/([a-z])([A-Z])/g, '$1-$2')\n    .replace(/[\\s_]+/g, '-')\n    .toLowerCase();\n}\n\n/**\n * Converts string to snake_case\n * @param {string} str - The string to convert\n * @returns {string} Returns the snake cased string\n * @since 0.9.0\n * @example\n * snakeCase('hello world'); // 'hello_world'\n * snakeCase('HelloWorld'); // 'hello_world'\n */\nexport function snakeCase (str: string): string {\n  return str\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    .replace(/[\\s-]+/g, '_')\n    .toLowerCase();\n}\n\n/**\n * Converts string to PascalCase\n * @param {string} str - The string to convert\n * @returns {string} Returns the Pascal cased string\n * @since 0.9.0\n * @example\n * pascalCase('hello world'); // 'HelloWorld'\n * pascalCase('hello-world'); // 'HelloWorld'\n */\nexport function pascalCase (str: string): string {\n  return str\n    .replace(/(?:^\\w|[A-Z]|\\b\\w)/g, word => word.toUpperCase())\n    .replace(/\\s+/g, '')\n    .replace(/[^a-zA-Z0-9]/g, '');\n}\n\n/**\n * Converts string to UPPER_CASE\n * @param {string} str - The string to convert\n * @returns {string} Returns the upper cased string\n * @since 0.8.0\n * @example\n * upperCase('hello world'); // 'HELLO WORLD'\n * upperCase('hello-world'); // 'HELLO WORLD'\n */\nexport function upperCase (str: string): string {\n  return str\n    .replace(/([a-z])([A-Z])/g, '$1 $2')\n    .replace(/[\\s-_]+/g, ' ')\n    .toUpperCase();\n}\n\n/**\n * Converts string to lower case\n * @param {string} str - The string to convert\n * @returns {string} Returns the lower cased string\n * @since 0.8.0\n * @example\n * lowerCase('HELLO WORLD'); // 'hello world'\n * lowerCase('Hello-World'); // 'hello world'\n */\nexport function lowerCase (str: string): string {\n  return str\n    .replace(/([a-z])([A-Z])/g, '$1 $2')\n    .replace(/[\\s-_]+/g, ' ')\n    .toLowerCase();\n}\n\n/**\n * Converts first character to uppercase and rest to lowercase\n * @param {string} str - The string to convert\n * @returns {string} Returns the start cased string\n * @since 0.9.0\n * @example\n * startCase('hello world'); // 'Hello world'\n * startCase('hELLO wORLD'); // 'Hello world'\n */\nexport function startCase (str: string): string {\n  return str\n    .replace(/([a-z])([A-Z])/g, '$1 $2')\n    .replace(/[\\s-_]+/g, ' ')\n    .replace(/\\b\\w/g, char => char.toUpperCase());\n}\n\n/**\n * Deburrs string by converting Latin-1 Supplement and Latin Extended-A letters to basic Latin letters\n * @param {string} str - The string to deburr\n * @returns {string} Returns the deburred string\n * @since 0.8.0\n * @example\n * deburr('déjà vu'); // 'deja vu'\n * deburr('niño'); // 'nino'\n */\nexport function deburr (str: string): string {\n  return purify(str);\n}\n\n/**\n * Checks if string ends with target string\n * @param {string} str - The string to check\n * @param {string} target - The target string\n * @param {number} [position] - The position to check from\n * @returns {boolean} Returns true if the string ends with the target\n * @since 0.8.0\n * @example\n * endsWith('hello world', 'world'); // true\n * endsWith('hello world', 'hello', 5); // true\n */\nexport function endsWith (str: string, target: string, position?: number): boolean {\n  const end = position === undefined ? str.length : position;\n  return str.slice(end - target.length, end) === target;\n}\n\n/**\n * Escapes RegExp special characters\n * @param {string} str - The string to escape\n * @returns {string} Returns the escaped string\n * @since 0.8.0\n * @example\n * escapeRegExp('hello.world?'); // 'hello\\.world\\?'\n * escapeRegExp('^hello$'); // '\\^hello\\$'\n */\nexport function escapeRegExp (str: string): string {\n  return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n/**\n * Pads string on the left and right sides\n * @param {string} str - The string to pad\n * @param {number} length - The length of the resulting string\n * @param {string} [chars=' '] - The characters to pad with\n * @returns {string} Returns the padded string\n * @since 0.8.0\n * @example\n * pad('hello', 10); // '  hello   '\n * pad('hello', 10, '-'); // '--hello----'\n */\nexport function pad (str: string, length: number, chars: string = ' '): string {\n  const strLen = str.length;\n  if (strLen >= length) return str;\n\n  const padLength = length - strLen;\n  const leftPad = Math.floor(padLength / 2);\n  const rightPad = padLength - leftPad;\n\n  return padStart(padEnd(str, strLen + rightPad, chars), length, chars);\n}\n\n/**\n * Pads string on the left side\n * @param {string} str - The string to pad\n * @param {number} length - The length of the resulting string\n * @param {string} [chars=' '] - The characters to pad with\n * @returns {string} Returns the padded string\n * @since 0.8.0\n * @example\n * padStart('hello', 10); // '     hello'\n * padStart('hello', 10, '-'); // '-----hello'\n */\nexport function padStart (str: string, length: number, chars: string = ' '): string {\n  const strLen = str.length;\n  if (strLen >= length) return str;\n\n  const padLength = length - strLen;\n  const padding = chars.repeat(Math.ceil(padLength / chars.length)).slice(0, padLength);\n  return padding + str;\n}\n\n/**\n * Pads string on the right side\n * @param {string} str - The string to pad\n * @param {number} length - The length of the resulting string\n * @param {string} [chars=' '] - The characters to pad with\n * @returns {string} Returns the padded string\n * @since 0.8.0\n * @example\n * padEnd('hello', 10); // 'hello     '\n * padEnd('hello', 10, '-'); // 'hello-----'\n */\nexport function padEnd (str: string, length: number, chars: string = ' '): string {\n  const strLen = str.length;\n  if (strLen >= length) return str;\n\n  const padLength = length - strLen;\n  const padding = chars.repeat(Math.ceil(padLength / chars.length)).slice(0, padLength);\n  return str + padding;\n}\n\n/**\n * Repeats string n times\n * @param {string} str - The string to repeat\n * @param {number} n - The number of times to repeat the string\n * @returns {string} Returns the repeated string\n * @since 0.8.0\n * @example\n * repeat('hello', 3); // 'hellohellohello'\n * repeat('abc', 2); // 'abcabc'\n */\nexport function repeat (str: string, n: number): string {\n  return str.repeat(n);\n}\n\n/**\n * Replaces matches for pattern in string with replacement\n * @param {string} str - The string to search and replace in\n * @param {string | RegExp} pattern - The pattern to match\n * @param {string} replacement - The replacement string\n * @returns {string} Returns the string with replacements\n * @since 0.8.0\n * @example\n * replace('hello world', 'world', 'there'); // 'hello there'\n * replace('hello 123', /\\d+/, '456'); // 'hello 456'\n */\nexport function replace (str: string, pattern: string | RegExp, replacement: string): string {\n  return str.replace(pattern, replacement);\n}\n\n/**\n * Splits string by separator\n * @param {string} str - The string to split\n * @param {string | RegExp} [separator] - The separator to split by\n * @param {number} [limit] - The maximum number of splits\n * @returns {string[]} Returns the array of split strings\n * @since 0.8.0\n * @example\n * split('hello,world', ','); // ['hello', 'world']\n * split('hello world', /\\s+/); // ['hello', 'world']\n */\nexport function split (str: string, separator?: string | RegExp, limit?: number): string[] {\n  return separator === undefined ? str.split('') : str.split(separator, limit);\n}\n\n/**\n * Checks if string starts with target string\n * @param {string} str - The string to check\n * @param {string} target - The target string\n * @param {number} [position=0] - The position to check from\n * @returns {boolean} Returns true if the string starts with the target\n * @since 0.8.0\n * @example\n * startsWith('hello world', 'hello'); // true\n * startsWith('hello world', 'world', 6); // true\n */\nexport function startsWith (str: string, target: string, position: number = 0): boolean {\n  return str.slice(position, position + target.length) === target;\n}\n\n/**\n * Converts string to an array of its characters\n * @param {string} str - The string to convert\n * @returns {string[]} Returns the array of characters\n * @since 0.8.0\n * @example\n * toArray('hello'); // ['h', 'e', 'l', 'l', 'o']\n * toArray('abc'); // ['a', 'b', 'c']\n */\nexport function toArray (str: string): string[] {\n  return Array.from(str);\n}\n\n/**\n * Converts string to lowercase\n * @param {string} str - The string to convert\n * @returns {string} Returns the lower cased string\n * @since 0.8.0\n * @example\n * toLowerCase('HELLO'); // 'hello'\n * toLowerCase('HeLLo'); // 'hello'\n */\nexport function toLowerCase (str: string): string {\n  return str.toLowerCase();\n}\n\n/**\n * Converts string to uppercase\n * @param {string} str - The string to convert\n * @returns {string} Returns the upper cased string\n * @since 0.8.0\n * @example\n * toUpperCase('hello'); // 'HELLO'\n * toUpperCase('HeLLo'); // 'HELLO'\n */\nexport function toUpperCase (str: string): string {\n  return str.toUpperCase();\n}\n\n/**\n * Truncates string if it's longer than the given maximum string length\n * @param {string} str - The string to truncate\n * @param {Object} [options] - The options for truncating\n * @param {number} [options.length=30] - The maximum length of the string\n * @param {string} [options.omission='...'] - The string to indicate omission\n * @param {string | RegExp} [options.separator] - The separator to truncate on\n * @returns {string} Returns the truncated string\n * @since 0.8.0\n * @example\n * truncate('hello world', { length: 10 }); // 'hello worl...'\n * truncate('hello world', { length: 10, separator: ' ' }); // 'hello...'\n */\nexport function truncate (str: string, options: { length?: number; omission?: string; separator?: string | RegExp } = {}): string {\n  const { length = 30, omission = '...', separator } = options;\n\n  if (str.length <= length) return str;\n\n  let truncated = str.slice(0, length - omission.length);\n\n  if (separator !== undefined) {\n    const lastIndex = truncated.lastIndexOf(separator as string);\n    if (lastIndex > 0) {\n      truncated = truncated.slice(0, lastIndex);\n    }\n  }\n\n  return truncated + omission;\n}\n\n/**\n * Removes leading and trailing whitespace or specified characters\n * @param {string} str - The string to process\n * @param {RegExp} [pattern] - The pattern to match words\n * @returns {string[]} Returns the array of words\n * @since 0.8.0\n * @example\n * words('  hello world  '); // ['hello', 'world']\n * words('---hello---world---', /-/); // ['hello', 'world']\n */\nexport function words (str: string, pattern?: RegExp): string[] {\n  const defaultPattern = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n  return str.match(pattern || defaultPattern) || [];\n}\n\n/**\n * Remove breaklines from string\n * @param {string} str - The string to process\n * @returns {string} Returns the string without breaklines\n * @since 0.8.0\n * @example\n * removeBreakLines('hello\\nworld'); // 'hello world'\n * removeBreakLines('line1\\r\\nline2'); // 'line1 line2'\n */\nexport function removeBreakLines (str: string): string {\n  return str\n    .replace(/[\\r\\n]+/g, \" \")\n    .replace(/ {2,}/g, \" \")\n    .trim();\n}\n\n/**\n * Converts string to template string\n * @param {string} string - The string to convert\n * @param {Object} [options] - The options for the template\n * @param {RegExp} [options.interpolate] - The pattern for interpolation\n * @param {RegExp} [options.evaluate] - The pattern for evaluation\n * @param {RegExp} [options.escape] - The pattern for escaping\n * @returns {Function} Returns the template function\n * @since 0.8.0\n * @example\n * const compiled = template('hello <%= name %>!');\n * compiled({ name: 'world' }); // 'hello world!'\n * \n * const compiled = template('number: <%= number %>', { interpolate: /<%=([\\s\\S]+?)%>/g });\n * compiled({ number: 42 }); // 'number: 42'\n */\nexport function template (string: string, options: { interpolate?: RegExp; evaluate?: RegExp; escape?: RegExp } = {}): (data: any) => string {\n  const { interpolate = /<%=([\\s\\S]+?)%>/g, evaluate = /<%([\\s\\S]+?)%>/g, escape = /<%-([\\s\\S]+?)%>/g } = options;\n\n  return function (data: any = {}) {\n    return string\n      .replace(escape, (match, code) => {\n        const result = new Function('obj', `with(obj) { return ${code}; }`)(data);\n        return String(result).replace(/[&<>\"']/g, char => {\n          const escapeMap: Record<string, string> = {\n            '&': '&amp;',\n            '<': '&lt;',\n            '>': '&gt;',\n            '\"': '&quot;',\n            \"'\": '&#39;'\n          };\n          return escapeMap[char];\n        });\n      })\n      .replace(interpolate, (match, code) => {\n        const result = new Function('obj', `with(obj) { return ${code}; }`)(data);\n        return String(result);\n      })\n      .replace(evaluate, (match, code) => {\n        new Function('obj', `with(obj) { ${code}; }`)(data);\n        return '';\n      });\n  };\n}\n\n/**\n * Converts HTML entities to characters\n * @param {string} str - The string to unescape\n * @returns {string} Returns the unescaped string\n * @since 0.8.0\n * @example\n * unescape('&lt;div&gt;hello&lt;/div&gt;'); // '<div>hello</div>'\n * unescape('&amp;copy; 2023'); // '© 2023'\n */\nexport function unescape (str: string): string {\n  const htmlUnescapes: Record<string, string> = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\"\n  };\n\n  return str.replace(/&(?:amp|lt|gt|quot|#39);/g, match => htmlUnescapes[match]);\n}\n\n/**\n * Converts characters to HTML entities\n * @param {string} str - The string to escape\n * @returns {string} Returns the escaped string\n * @since 0.8.0\n * @example\n * escape('hello & world'); // 'hello &amp; world'\n * escape('<div>hello</div>'); // '&lt;div&gt;hello&lt;/div&gt;'\n */\nexport function escape (str: string): string {\n  const htmlEscapes: Record<string, string> = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;'\n  };\n\n  return str.replace(/[&<>\"']/g, match => htmlEscapes[match]);\n}\n\n/**\n * Converts the first character of string to upper case\n * @param {string} str - The string to convert\n * @returns {string} Returns the string with the first character uppercased\n * @since 0.8.0\n * @example\n * upperFirst('hello'); // 'Hello'\n * upperFirst('javaScript'); // 'JavaScript'\n */\nexport function upperFirst (str: string): string {\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\n/**\n * Converts the first character of string to lower case\n * @param {string} str - The string to convert\n * @returns {string} Returns the string with the first character lowercased\n * @since 0.8.0\n * @example\n * lowerFirst('Hello'); // 'hello'\n * lowerFirst('JavaScript'); // 'javaScript'\n */\nexport function lowerFirst (str: string): string {\n  return str.charAt(0).toLowerCase() + str.slice(1);\n}\n\n/**\n * Converts string to an integer of the specified radix\n * @param {string} str - The string to convert\n * @param {number} [radix=10] - The radix to use\n * @returns {number} Returns the converted integer\n * @since 0.8.0\n * @example\n * parseInt('10'); // 10\n * parseInt('10', 2); // 2\n */\nexport function parseInt (str: string, radix: number = 10): number {\n  return Number.parseInt(str, radix);\n}\n","/**\n * Lightweight array utility functions\n * No external dependencies - includes lodash-inspired methods\n * @since 0.8.0\n */\n\nexport interface SortOptions<T> {\n  arr: T[];\n  prop: keyof T;\n  ascending?: boolean;\n}\n\n/**\n * Object with string keys and any values.\n */\nexport interface o {\n  [key: string]: any;\n}\n\n/** Selection object for filtering */\nexport interface SelectionObject {\n  selection: string[];\n  property: string;\n}\n\n/**\n * Filter data based on search term and selections\n */\nexport interface i_func_filterData {\n  sW: string;\n  tbRS: number[];\n  selections: SelectionObject[];\n  field_search?: string;\n  ddeb?: string;\n  regex?: RegExp;\n}\n\n/**\n * Removes all accents from a string (inline to avoid circular imports)\n * @private\n * @param {any} str - The string to purify\n * @returns {string} Returns the purified string\n * @since 0.8.0\n */\nfunction purify (str: any): string {\n  return typeof str === \"string\"\n    ? str.normalize(\"NFD\").replace(/[\\u0300-\\u036f]/g, \"\")\n    : \"\";\n}\n\n/**\n * Sort an array of objects by a property\n * @param {SortOptions<T>} options - The sort options\n * @param {T[]} options.arr - The array to sort\n * @param {keyof T} options.prop - The property to sort by\n * @param {boolean} [options.ascending=true] - Sort in ascending order\n * @returns {T[]} Returns the sorted array\n * @since 0.8.0\n * @example\n * sort({ arr: [{name: 'Bob'}, {name: 'Alice'}], prop: 'name' });\n * // [{name: 'Alice'}, {name: 'Bob'}]\n */\nexport function sort<T extends Record<string, any>> (options: SortOptions<T>): T[] {\n  const { arr, prop, ascending = true } = options;\n\n  const compare = (a: T, b: T) => {\n    const valueA = a[prop];\n    const valueB = b[prop];\n\n    const sortOrder = ascending ? 1 : -1;\n\n    if (typeof valueA === 'number' && typeof valueB === 'number') {\n      return sortOrder * (valueA - valueB);\n    }\n\n    return sortOrder * purify(String(valueA)).localeCompare(purify(String(valueB)));\n  };\n\n  return arr.slice().sort(compare);\n}\n\n/**\n * Get unique values from an array\n * @param {T[]} data - The array to filter\n * @param {string} [field] - Optional field to use for uniqueness in objects\n * @returns {T[]} Returns array of unique values\n * @since 0.8.0\n * @example\n * getUnique([1, 2, 2, 3]); // [1, 2, 3]\n * getUnique([{id: 1}, {id: 2}, {id: 1}], 'id'); // [{id: 1}, {id: 2}]\n */\nexport function getUnique<T> (data: T[], field?: string): T[] {\n  const seen = new Set();\n\n  return data.filter(item => {\n    const key = field && typeof item === 'object' && item !== null\n      ? JSON.stringify((item as any)[field])\n      : JSON.stringify(item);\n\n    if (seen.has(key)) {\n      return false;\n    }\n\n    seen.add(key);\n    return true;\n  });\n}\n\n/**\n * Get the last element(s) from an array or object\n * @param data - The data to get last element from\n * @returns The last element(s)\n * @since 0.8.0\n * @example\n * getLastElement([1, 2, 3]); // [3]\n * getLastElement({a: 1, b: 2}); // {b: 2}\n */\nexport function getLastElement<T> (data: T[] | Record<string, any>): T[] | Record<string, any> {\n  if (Array.isArray(data)) {\n    return data.length > 0 ? [data[data.length - 1]] : [];\n  } else if (typeof data === 'object' && data) {\n    const keys = Object.keys(data);\n    return keys.length > 0\n      ? { [keys[keys.length - 1]]: data[keys[keys.length - 1]] }\n      : {};\n  }\n  return data as any;\n}\n\n/**\n * Get a random string from an array\n * @param arr - Array of strings\n * @returns Random string from the array\n * @since 0.8.0\n * @example\n * randomString(['apple', 'banana', 'cherry']); // 'banana' (random)\n */\nexport function randomString (arr: string[]): string {\n  return arr[Math.floor(Math.random() * arr.length)];\n}\n\n/**\n * Check if array length is less than size, return array or fallback\n * @param first - The array to check\n * @param second - Fallback value\n * @param size - Size threshold\n * @returns The array or fallback based on size\n * @since 0.8.0\n * @example\n * checkLength([1, 2], 'fallback', 5); // [1, 2]\n * checkLength([1, 2, 3, 4, 5, 6], 'fallback', 5); // 'fallback'\n */\nexport function checkLength<T> (first: T[], second: string, size: number): T[] | string {\n  return first.length < size ? first : second;\n}\n\n/**\n * Creates an array of elements split into groups the length of size\n * @param {T[]} array - The array to process\n * @param {number} [size=1] - The length of each chunk\n * @returns {T[][]} Returns the new array of chunks\n * @since 0.9.0\n * @example\n * chunk([1, 2, 3, 4], 2); // [[1, 2], [3, 4]]\n * chunk([1, 2, 3, 4, 5], 3); // [[1, 2, 3], [4, 5]]\n */\nexport function chunk<T> (array: T[], size: number = 1): T[][] {\n  const result: T[][] = [];\n  for (let i = 0; i < array.length; i += size) {\n    result.push(array.slice(i, i + size));\n  }\n  return result;\n}\n\n/**\n * Creates an array with all falsy values removed\n * @param {(T | null | undefined | false | 0 | \"\")[]} array - The array to compact\n * @returns {T[]} Returns the new array of filtered values\n * @since 0.9.0\n * @example\n * compact([0, 1, false, 2, '', 3]); // [1, 2, 3]\n */\nexport function compact<T> (array: (T | null | undefined | false | 0 | \"\")[]): T[] {\n  return array.filter(Boolean) as T[];\n}\n\n/**\n * Creates a new array concatenating array with any additional arrays and/or values\n * @param {T[]} array - The array to concatenate\n * @param {...(T | T[])} values - The values to concatenate\n * @returns {T[]} Returns the new concatenated array\n * @since 0.9.0\n * @example\n * concat([1], 2, [3], [[4]]); // [1, 2, 3, [4]]\n */\nexport function concat<T> (array: T[], ...values: (T | T[])[]): T[] {\n  const result = [...array];\n  for (const value of values) {\n    if (Array.isArray(value)) {\n      result.push(...value);\n    } else {\n      result.push(value);\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of array values not included in the other given arrays\n * @param {T[]} array - The array to inspect\n * @param {...T[][]} values - The values to exclude\n * @returns {T[]} Returns the new array of filtered values\n * @since 0.9.0\n * @example\n * difference([2, 1], [2, 3]); // [1]\n */\nexport function difference<T> (array: T[], ...values: T[][]): T[] {\n  const excludeSet = new Set(values.flat());\n  return array.filter(item => !excludeSet.has(item));\n}\n\n/**\n * Like difference except that it accepts iteratee which is invoked for each element\n * @param {T[]} array - The array to inspect\n * @param {T[]} values - The values to exclude\n * @param {(value: T) => any} iteratee - The iteratee invoked per element\n * @returns {T[]} Returns the new array of filtered values\n * @since 0.9.0\n * @example\n * differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); // [1.2]\n */\nexport function differenceBy<T> (array: T[], values: T[], iteratee: (value: T) => any): T[] {\n  const excludeSet = new Set(values.map(iteratee));\n  return array.filter(item => !excludeSet.has(iteratee(item)));\n}\n\n/**\n * Like difference except that it accepts comparator which is invoked to compare elements\n * @param {T[]} array - The array to inspect\n * @param {T[]} values - The values to exclude\n * @param {(a: T, b: T) => boolean} comparator - The comparator invoked per element\n * @returns {T[]} Returns the new array of filtered values\n * @since 0.9.0\n * @example\n * differenceWith([{ 'x': 1 }, { 'x': 2 }], [{ 'x': 1 }], (a, b) => a.x === b.x); // [{ 'x': 2 }]\n */\nexport function differenceWith<T> (array: T[], values: T[], comparator: (a: T, b: T) => boolean): T[] {\n  return array.filter(arrayItem => !values.some(valueItem => comparator(arrayItem, valueItem)));\n}\n\n/**\n * Creates a slice of array with n elements dropped from the beginning\n * @param {T[]} array - The array to query\n * @param {number} [n=1] - The number of elements to drop\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * drop([1, 2, 3]); // [2, 3]\n * drop([1, 2, 3], 2); // [3]\n */\nexport function drop<T> (array: T[], n: number = 1): T[] {\n  return array.slice(n);\n}\n\n/**\n * Creates a slice of array with n elements dropped from the end\n * @param {T[]} array - The array to query\n * @param {number} [n=1] - The number of elements to drop\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * dropRight([1, 2, 3]); // [1, 2]\n * dropRight([1, 2, 3], 2); // [1]\n */\nexport function dropRight<T> (array: T[], n: number = 1): T[] {\n  return array.slice(0, -n || array.length);\n}\n\n/**\n * Creates a slice of array excluding elements dropped from the beginning\n * @param {T[]} array - The array to query\n * @param {(value: T) => boolean} predicate - The function invoked per iteration\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * dropWhile([1, 2, 3, 4], n => n < 3); // [3, 4]\n */\nexport function dropWhile<T> (array: T[], predicate: (value: T) => boolean): T[] {\n  let index = 0;\n  while (index < array.length && predicate(array[index])) {\n    index++;\n  }\n  return array.slice(index);\n}\n\n/**\n * Creates a slice of array excluding elements dropped from the end\n * @param {T[]} array - The array to query\n * @param {(value: T) => boolean} predicate - The function invoked per iteration\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * dropRightWhile([1, 2, 3, 4], n => n > 2); // [1, 2]\n */\nexport function dropRightWhile<T> (array: T[], predicate: (value: T) => boolean): T[] {\n  let index = array.length;\n  while (index > 0 && predicate(array[index - 1])) {\n    index--;\n  }\n  return array.slice(0, index);\n}\n\n/**\n * Fills elements of array with value from start up to, but not including, end\n * @param {T[]} array - The array to fill\n * @param {T} value - The value to fill array with\n * @param {number} [start=0] - The start position\n * @param {number} [end=array.length] - The end position\n * @returns {T[]} Returns the filled array\n * @since 0.9.0\n * @example\n * fill([1, 2, 3], 'a'); // ['a', 'a', 'a']\n * fill([4, 6, 8, 10], '*', 1, 3); // [4, '*', '*', 10]\n */\nexport function fill<T> (array: T[], value: T, start: number = 0, end: number = array.length): T[] {\n  const result = [...array];\n  for (let i = start; i < end && i < result.length; i++) {\n    result[i] = value;\n  }\n  return result;\n}\n\n/**\n * Returns the first index at which a given element can be found\n * @param {T[]} array - The array to inspect\n * @param {(value: T, index: number, array: T[]) => boolean} predicate - The function invoked per iteration\n * @param {number} [fromIndex=0] - The index to search from\n * @returns {number} Returns the index of the found element, else -1\n * @since 0.9.0\n * @example\n * findIndex([1, 2, 3, 4], n => n % 2 === 0); // 1\n */\nexport function findIndex<T> (array: T[], predicate: (value: T, index: number, array: T[]) => boolean, fromIndex: number = 0): number {\n  for (let i = fromIndex; i < array.length; i++) {\n    if (predicate(array[i], i, array)) {\n      return i;\n    }\n  }\n  return -1;\n}\n\n/**\n * Like findIndex except that it iterates over elements from right to left\n * @param {T[]} array - The array to inspect\n * @param {(value: T, index: number, array: T[]) => boolean} predicate - The function invoked per iteration\n * @param {number} [fromIndex=array.length-1] - The index to search from\n * @returns {number} Returns the index of the found element, else -1\n * @since 0.9.0\n * @example\n * findLastIndex([1, 2, 3, 4], n => n % 2 === 1); // 2\n */\nexport function findLastIndex<T> (array: T[], predicate: (value: T, index: number, array: T[]) => boolean, fromIndex: number = array.length - 1): number {\n  for (let i = fromIndex; i >= 0; i--) {\n    if (predicate(array[i], i, array)) {\n      return i;\n    }\n  }\n  return -1;\n}\n\n/**\n * Flattens array a single level deep\n * @param {(T | T[])[]} array - The array to flatten\n * @returns {T[]} Returns the new flattened array\n * @since 0.9.0\n * @example\n * flatten([1, [2, [3, [4]], 5]]); // [1, 2, [3, [4]], 5]\n */\nexport function flatten<T> (array: (T | T[])[]): T[] {\n  return array.flat() as T[];\n}\n\n/**\n * Recursively flattens array\n * @param {any[]} array - The array to flatten\n * @returns {T[]} Returns the new flattened array\n * @since 0.9.0\n * @example\n * flattenDeep([1, [2, [3, [4]], 5]]); // [1, 2, 3, 4, 5]\n */\nexport function flattenDeep<T> (array: any[]): T[] {\n  return array.flat(Infinity) as T[];\n}\n\n/**\n * Recursively flatten array up to depth times\n * @param {any[]} array - The array to flatten\n * @param {number} [depth=1] - The maximum recursion depth\n * @returns {T[]} Returns the new flattened array\n * @since 0.9.0\n * @example\n * flattenDepth([1, [2, [3, [4]], 5]], 1); // [1, 2, [3, [4]], 5]\n * flattenDepth([1, [2, [3, [4]], 5]], 2); // [1, 2, 3, [4], 5]\n */\nexport function flattenDepth<T> (array: any[], depth: number = 1): T[] {\n  return array.flat(depth) as T[];\n}\n\n/**\n * Reverses array so that the first element becomes the last\n * @param {T[]} array - The array to reverse\n * @returns {T[]} Returns the new reversed array\n * @since 0.9.0\n * @example\n * reverse([1, 2, 3]); // [3, 2, 1]\n */\nexport function reverse<T> (array: T[]): T[] {\n  return [...array].reverse();\n}\n\n/**\n * Creates an array of unique values from all given arrays\n * @param {...T[][]} arrays - The arrays to inspect\n * @returns {T[]} Returns the new array of combined values\n * @since 0.9.0\n * @example\n * union([2], [1, 2]); // [2, 1]\n */\nexport function union<T> (...arrays: T[][]): T[] {\n  return [...new Set(arrays.flat())];\n}\n\n/**\n * Like union except that it accepts iteratee\n * @param {T[][]} arrays - The arrays to inspect\n * @param {(value: T) => any} iteratee - The iteratee invoked per element\n * @returns {T[]} Returns the new array of combined values\n * @since 0.9.0\n * @example\n * unionBy([[2.1], [1.2, 2.3]], Math.floor); // [2.1, 1.2]\n */\nexport function unionBy<T> (arrays: T[][], iteratee: (value: T) => any): T[] {\n  const seen = new Set();\n  const result: T[] = [];\n\n  for (const array of arrays) {\n    for (const item of array) {\n      const key = iteratee(item);\n      if (!seen.has(key)) {\n        seen.add(key);\n        result.push(item);\n      }\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of unique values that are included in all given arrays\n * @param {...T[][]} arrays - The arrays to inspect\n * @returns {T[]} Returns the new array of intersecting values\n * @since 0.9.0\n * @example\n * intersection([2, 1], [2, 3]); // [2]\n */\nexport function intersection<T> (...arrays: T[][]): T[] {\n  if (arrays.length === 0) return [];\n  if (arrays.length === 1) return [...arrays[0]];\n\n  const [first, ...rest] = arrays;\n  return first.filter(item => rest.every(array => array.includes(item)));\n}\n\n/**\n * Like intersection except that it accepts iteratee\n * @param {T[][]} arrays - The arrays to inspect\n * @param {(value: T) => any} iteratee - The iteratee invoked per element\n * @returns {T[]} Returns the new array of intersecting values\n * @since 0.9.0\n * @example\n * intersectionBy([[2.1, 1.2], [2.3, 3.4]], Math.floor); // [2.1]\n */\nexport function intersectionBy<T> (arrays: T[][], iteratee: (value: T) => any): T[] {\n  if (arrays.length === 0) return [];\n  if (arrays.length === 1) return [...arrays[0]];\n\n  const [first, ...rest] = arrays;\n  return first.filter(item => {\n    const key = iteratee(item);\n    return rest.every(array => array.some(arrayItem => iteratee(arrayItem) === key));\n  });\n}\n\n/**\n * Removes all given values from array\n * @param {T[]} array - The array to modify\n * @param {...T} values - The values to remove\n * @returns {T[]} Returns the new array with values removed\n * @since 0.9.0\n * @example\n * pull([1, 2, 3, 1, 2, 3], 2, 3); // [1, 1]\n */\nexport function pull<T> (array: T[], ...values: T[]): T[] {\n  return array.filter(item => !values.includes(item));\n}\n\n/**\n * Removes elements from array corresponding to indexes\n * @param {T[]} array - The array to modify\n * @param {...number} indexes - The indexes of elements to remove\n * @returns {T[]} Returns the new array with elements removed\n * @since 0.9.0\n * @example\n * pullAt(['a', 'b', 'c', 'd'], 1, 3); // ['a', 'c']\n */\nexport function pullAt<T> (array: T[], ...indexes: number[]): T[] {\n  const indexSet = new Set(indexes);\n  return array.filter((_, index) => !indexSet.has(index));\n}\n\n/**\n * Removes all elements from array that predicate returns truthy for\n * @param {T[]} array - The array to modify\n * @param {(value: T, index: number, array: T[]) => boolean} predicate - The function invoked per iteration\n * @returns {T[]} Returns an array of removed elements\n * @since 0.9.0\n * @example\n * const array = [1, 2, 3, 4];\n * const evens = remove(array, n => n % 2 === 0); // evens: [2, 4], array: [1, 3]\n */\nexport function remove<T> (array: T[], predicate: (value: T, index: number, array: T[]) => boolean): T[] {\n  const removed: T[] = [];\n  for (let i = array.length - 1; i >= 0; i--) {\n    if (predicate(array[i], i, array)) {\n      removed.unshift(...array.splice(i, 1));\n    }\n  }\n  return removed;\n}\n\n/**\n * Gets all but the first element of array\n * @param {T[]} array - The array to query\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * tail([1, 2, 3]); // [2, 3]\n */\nexport function tail<T> (array: T[]): T[] {\n  return array.slice(1);\n}\n\n/**\n * Creates a slice of array with n elements taken from the beginning\n * @param {T[]} array - The array to query\n * @param {number} [n=1] - The number of elements to take\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * take([1, 2, 3]); // [1]\n * take([1, 2, 3], 2); // [1, 2]\n */\nexport function take<T> (array: T[], n: number = 1): T[] {\n  return array.slice(0, n);\n}\n\n/**\n * Creates a slice of array with n elements taken from the end\n * @param {T[]} array - The array to query\n * @param {number} [n=1] - The number of elements to take\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * takeRight([1, 2, 3]); // [3]\n * takeRight([1, 2, 3], 2); // [2, 3]\n */\nexport function takeRight<T> (array: T[], n: number = 1): T[] {\n  return array.slice(-n);\n}\n\n/**\n * Creates a slice of array with elements taken from the beginning\n * @param {T[]} array - The array to query\n * @param {(value: T) => boolean} predicate - The function invoked per iteration\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * takeWhile([1, 2, 3], n => n < 3); // [1, 2]\n */\nexport function takeWhile<T> (array: T[], predicate: (value: T) => boolean): T[] {\n  const result: T[] = [];\n  for (const item of array) {\n    if (predicate(item)) {\n      result.push(item);\n    } else {\n      break;\n    }\n  }\n  return result;\n}\n\n/**\n * Creates a slice of array with elements taken from the end\n * @param {T[]} array - The array to query\n * @param {(value: T) => boolean} predicate - The function invoked per iteration\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * takeRightWhile([1, 2, 3], n => n > 1); // [2, 3]\n */\nexport function takeRightWhile<T> (array: T[], predicate: (value: T) => boolean): T[] {\n  const result: T[] = [];\n  for (let i = array.length - 1; i >= 0; i--) {\n    if (predicate(array[i])) {\n      result.unshift(array[i]);\n    } else {\n      break;\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of unique values from the first array not included in the other given arrays\n * @param {T[]} array - The array to inspect\n * @param {...T} values - The values to exclude\n * @returns {T[]} Returns the new array of filtered values\n * @since 0.9.0\n * @example\n * without([2, 1, 2, 3], 1, 2); // [3]\n */\nexport function without<T> (array: T[], ...values: T[]): T[] {\n  return array.filter(item => !values.includes(item));\n}\n\n/**\n * Creates an array of unique values that is the symmetric difference of the given arrays\n * @param {...T[][]} arrays - The arrays to inspect\n * @returns {T[]} Returns the new array of filtered values\n * @since 0.9.0\n * @example\n * xor([2, 1], [2, 3]); // [1, 3]\n */\nexport function xor<T> (...arrays: T[][]): T[] {\n  const counts = new Map();\n  for (const array of arrays) {\n    for (const item of array) {\n      counts.set(item, (counts.get(item) || 0) + 1);\n    }\n  }\n  return Array.from(counts.entries())\n    .filter(([_, count]) => count === 1)\n    .map(([item]) => item);\n}\n\n/**\n * Creates an array that is the zip of arrays\n * @param {...T[][]} arrays - The arrays to process\n * @returns {T[][]} Returns the new array of grouped elements\n * @since 0.9.0\n * @example\n * zip(['a', 'b'], [1, 2], [true, false]); // [['a', 1, true], ['b', 2, false]]\n */\nexport function zip<T> (...arrays: T[][]): T[][] {\n  const length = Math.max(...arrays.map(arr => arr.length));\n  const result: T[][] = [];\n\n  for (let i = 0; i < length; i++) {\n    result.push(arrays.map(arr => arr[i]));\n  }\n\n  return result;\n}\n\n/**\n * Creates an object composed from arrays of keys and values\n * @param {string[]} keys - The property names\n * @param {T[]} values - The property values\n * @returns {Record<string, T>} Returns the new object\n * @since 0.9.0\n * @example\n * zipObject(['a', 'b'], [1, 2]); // { 'a': 1, 'b': 2 }\n */\nexport function zipObject<T> (keys: string[], values: T[]): Record<string, T> {\n  const result: Record<string, T> = {};\n  for (let i = 0; i < keys.length; i++) {\n    if (i < values.length) {\n      result[keys[i]] = values[i];\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of grouped elements\n * @param {...[...T[][], ((...values: T[]) => R)]} arrays - The arrays to process and the function to combine grouped values\n * @returns {R[]} Returns the new array of grouped elements\n * @since 0.9.0\n * @example\n * zipWith([1, 2], [10, 20], [100, 200], (a, b, c) => a + b + c); // [111, 222]\n */\nexport function zipWith<T, R> (...arrays: [...T[][], ((...values: T[]) => R)]): R[] {\n  const func = arrays.pop() as (...values: T[]) => R;\n  const arraysToZip = arrays as T[][];\n\n  const length = Math.max(...arraysToZip.map(arr => arr.length));\n  const result: R[] = [];\n\n  for (let i = 0; i < length; i++) {\n    const values = arraysToZip.map(arr => arr[i]);\n    result.push(func(...values));\n  }\n\n  return result;\n}\n\n/**\n * The opposite of zip; creates an array of arrays\n * @param {T[][]} array - The array of grouped elements to process\n * @returns {T[][]} Returns the new array of regrouped elements\n * @since 0.9.0\n * @example\n * unzip([['a', 1, true], ['b', 2, false]]); // [['a', 'b'], [1, 2], [true, false]]\n */\nexport function unzip<T> (array: T[][]): T[][] {\n  if (array.length === 0) return [];\n\n  const length = Math.max(...array.map(arr => arr.length));\n  const result: T[][] = [];\n\n  for (let i = 0; i < length; i++) {\n    result.push(array.map(arr => arr[i]));\n  }\n\n  return result;\n}\n\n/**\n * Gets the first element of array\n * @param {T[]} array - The array to query\n * @returns {T | undefined} Returns the first element of array\n * @example\n * head([1, 2, 3]); // 1\n * head([]); // undefined\n */\nexport function head<T> (array: T[]): T | undefined {\n  return array[0];\n}\n\n/**\n * Gets the last element of array\n * @param {T[]} array - The array to query\n * @returns {T | undefined} Returns the last element of array\n * @example\n * last([1, 2, 3]); // 3\n * last([]); // undefined\n */\nexport function last<T> (array: T[]): T | undefined {\n  return array[array.length - 1];\n}\n\n/**\n * Gets the element at index n of array\n * @param {T[]} array - The array to query\n * @param {number} [n=0] - The index of the element to return\n * @returns {T | undefined} Returns the nth element of array\n * @example\n * nth(['a', 'b', 'c', 'd'], 1); // 'b'\n * nth(['a', 'b', 'c', 'd'], -2); // 'c'\n */\nexport function nth<T> (array: T[], n: number = 0): T | undefined {\n  const index = n < 0 ? array.length + n : n;\n  return array[index];\n}\n\n/**\n * Gets all but the last element of array\n * @param {T[]} array - The array to query\n * @returns {T[]} Returns the slice of array\n * @example\n * initial([1, 2, 3]); // [1, 2]\n */\nexport function initial<T> (array: T[]): T[] {\n  return array.slice(0, -1);\n}\n\n/**\n * Creates an array of unique values from all given arrays using SameValueZero for equality comparisons\n * @param {T[][]} arrays - The arrays to inspect\n * @param {(a: T, b: T) => boolean} comparator - The comparator invoked per element\n * @returns {T[]} Returns the new array of combined values\n * @since 0.9.0\n * @example\n * unionWith([[{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }]], (a, b) => a.x === b.x); // [{ 'x': 1 }, { 'x': 2 }]\n */\nexport function unionWith<T> (arrays: T[][], comparator: (a: T, b: T) => boolean): T[] {\n  const result: T[] = [];\n  const allValues = arrays.flat();\n\n  for (const value of allValues) {\n    if (!result.some(item => comparator(item, value))) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of unique values that are included in all given arrays using SameValueZero for equality comparisons\n * @param {T[][]} arrays - The arrays to inspect\n * @param {(a: T, b: T) => boolean} comparator - The comparator invoked per element\n * @returns {T[]} Returns the new array of intersecting values\n * @since 0.9.0\n * @example\n * intersectionWith([[{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }]], (a, b) => a.x === b.x); // [{ 'x': 1 }]\n */\nexport function intersectionWith<T> (arrays: T[][], comparator: (a: T, b: T) => boolean): T[] {\n  if (arrays.length === 0) return [];\n  if (arrays.length === 1) return [...arrays[0]];\n\n  const [first, ...rest] = arrays;\n  return first.filter(item =>\n    rest.every(array =>\n      array.some(arrayItem => comparator(item, arrayItem))\n    )\n  );\n}\n\n/**\n * Like xor except that it accepts comparator which is invoked to compare elements\n * @param {T[][]} arrays - The arrays to inspect\n * @param {(a: T, b: T) => boolean} comparator - The comparator invoked per element\n * @returns {T[]} Returns the new array of filtered values\n * @since 0.9.0\n * @example\n * xorWith([[{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }]], (a, b) => a.x === b.x); // [{ 'x': 2 }]\n */\nexport function xorWith<T> (arrays: T[][], comparator: (a: T, b: T) => boolean): T[] {\n  const allValues = arrays.flat();\n  const result: T[] = [];\n\n  for (const value of allValues) {\n    const occurrences = allValues.filter(item => comparator(item, value)).length;\n    if (occurrences === 1 && !result.some(item => comparator(item, value))) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n\n/**\n * Like xor except that it accepts iteratee which is invoked for each element\n * @param {T[][]} arrays - The arrays to inspect\n * @param {(value: T) => any} iteratee - The iteratee invoked per element\n * @returns {T[]} Returns the new array of filtered values\n * @since 0.9.0\n * @example\n * xorBy([[2.1, 1.2], [2.3, 3.4]], Math.floor); // [1.2, 3.4]\n */\nexport function xorBy<T> (arrays: T[][], iteratee: (value: T) => any): T[] {\n  const allValues = arrays.flat();\n  const counts = new Map();\n  const valueMap = new Map();\n\n  for (const value of allValues) {\n    const key = iteratee(value);\n    counts.set(key, (counts.get(key) || 0) + 1);\n    if (!valueMap.has(key)) {\n      valueMap.set(key, value);\n    }\n  }\n\n  return Array.from(counts.entries())\n    .filter(([_, count]) => count === 1)\n    .map(([key]) => valueMap.get(key));\n}\n\n/**\n * Like zipObject except that it supports property paths\n * @param {string[]} paths - The property paths\n * @param {T[]} values - The property values\n * @returns {any} Returns the new object\n * @example\n * zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]); // { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n */\nexport function zipObjectDeep<T> (paths: string[], values: T[]): any {\n  const result: any = {};\n\n  for (let i = 0; i < paths.length; i++) {\n    if (i < values.length) {\n      const path = paths[i].split('.');\n      let current = result;\n\n      for (let j = 0; j < path.length - 1; j++) {\n        if (!current[path[j]]) {\n          current[path[j]] = {};\n        }\n        current = current[path[j]];\n      }\n\n      current[path[path.length - 1]] = values[i];\n    }\n  }\n\n  return result;\n}\n\n/**\n * Creates an array of elements corresponding to the given keys\n * @param {T[]} array - The array to modify\n * @param {T[]} values - The values to remove\n * @returns {T[]} Returns the new array with values removed\n * @example\n * pullAll([1, 2, 3, 1, 2, 3], [2, 3]); // [1, 1]\n */\nexport function pullAll<T> (array: T[], values: T[]): T[] {\n  return array.filter(item => !values.includes(item));\n}\n\n/**\n * Like pullAll except that it accepts iteratee which is invoked per element\n * @param {T[]} array - The array to modify\n * @param {T[]} values - The values to remove\n * @param {(value: T) => any} iteratee - The iteratee invoked per element\n * @returns {T[]} Returns the new array with values removed\n * @example\n * pullAllBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }], [{ 'x': 1 }, { 'x': 3 }], 'x'); // [{ 'x': 2 }]\n */\nexport function pullAllBy<T> (array: T[], values: T[], iteratee: (value: T) => any): T[] {\n  const valueKeys = values.map(iteratee);\n  return array.filter(item => !valueKeys.includes(iteratee(item)));\n}\n\n/**\n * Like pullAll except that it accepts comparator which is invoked to compare elements\n * @param {T[]} array - The array to modify\n * @param {T[]} values - The values to remove\n * @param {(a: T, b: T) => boolean} comparator - The comparator invoked per element\n * @returns {T[]} Returns the new array with values removed\n * @example\n * pullAllWith([{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }], [{ 'x': 3, 'y': 4 }], (a, b) => a.x === b.x); // [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]\n */\nexport function pullAllWith<T> (array: T[], values: T[], comparator: (a: T, b: T) => boolean): T[] {\n  return array.filter(arrayItem => !values.some(valueItem => comparator(arrayItem, valueItem)));\n}\n\n/**\n * Creates a duplicate-free version of an array using SameValueZero for equality comparisons\n * @param {T[]} array - The array to inspect\n * @returns {T[]} Returns the new duplicate free array\n * @example\n * uniq([2, 1, 2]); // [2, 1]\n */\nexport function uniq<T> (array: T[]): T[] {\n  return [...new Set(array)];\n}\n\n/**\n * Like uniq except that it accepts iteratee which is invoked for each element\n * @param {T[]} array - The array to inspect\n * @param {(value: T) => any} iteratee - The iteratee invoked per element\n * @returns {T[]} Returns the new duplicate free array\n * @example\n * uniqBy([2.1, 1.2, 2.3], Math.floor); // [2.1, 1.2]\n */\nexport function uniqBy<T> (array: T[], iteratee: (value: T) => any): T[] {\n  const seen = new Set();\n  return array.filter(item => {\n    const key = iteratee(item);\n    if (seen.has(key)) {\n      return false;\n    }\n    seen.add(key);\n    return true;\n  });\n}\n\n/**\n * Like uniq except that it accepts comparator which is invoked to compare elements\n * @param {T[]} array - The array to inspect\n * @param {(a: T, b: T) => boolean} comparator - The comparator invoked per element\n * @returns {T[]} Returns the new duplicate free array\n * @example\n * uniqWith([{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }], (a, b) => a.x === b.x); // [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n */\nexport function uniqWith<T> (array: T[], comparator: (a: T, b: T) => boolean): T[] {\n  const result: T[] = [];\n  for (const item of array) {\n    if (!result.some(resultItem => comparator(item, resultItem))) {\n      result.push(item);\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array excluding all given values using SameValueZero for equality comparisons\n * @param {T[][]} array - The array of grouped elements to process\n * @param {(...values: T[]) => R} iteratee - The function to combine regrouped values\n * @returns {R[]} Returns the new array of regrouped elements\n * @example\n * unzipWith([['1', '2'], ['3', '4'], ['5', '6']], (...group) => group.join('')); // ['135', '246']\n */\nexport function unzipWith<T, R> (array: T[][], iteratee: (...values: T[]) => R): R[] {\n  if (array.length === 0) return [];\n\n  const length = Math.max(...array.map(arr => arr.length));\n  const result: R[] = [];\n\n  for (let i = 0; i < length; i++) {\n    const values = array.map(arr => arr[i]);\n    result.push(iteratee(...values));\n  }\n\n  return result;\n}\n\n/**\n * Creates an array of elements sorted in ascending order\n * @param {T[]} array - The sorted array to inspect\n * @param {T} value - The value to evaluate\n * @returns {number} Returns the index at which value should be inserted into array\n * @since 0.9.0\n * @example\n * sortedIndex([30, 50], 40); // 1\n */\nexport function sortedIndex<T> (array: T[], value: T): number {\n  let low = 0;\n  let high = array.length;\n\n  while (low < high) {\n    const mid = Math.floor((low + high) / 2);\n    if (array[mid] < value) {\n      low = mid + 1;\n    } else {\n      high = mid;\n    }\n  }\n\n  return low;\n}\n\n/**\n * Like sortedIndex except that it accepts iteratee\n * @param {T[]} array - The sorted array to inspect\n * @param {T} value - The value to evaluate\n * @param {(value: T) => any} iteratee - The iteratee invoked per element\n * @returns {number} Returns the index at which value should be inserted into array\n * @since 0.9.0\n * @example\n * sortedIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, o => o.x); // 0\n */\nexport function sortedIndexBy<T> (array: T[], value: T, iteratee: (value: T) => any): number {\n  let low = 0;\n  let high = array.length;\n  const computedValue = iteratee(value);\n\n  while (low < high) {\n    const mid = Math.floor((low + high) / 2);\n    if (iteratee(array[mid]) < computedValue) {\n      low = mid + 1;\n    } else {\n      high = mid;\n    }\n  }\n\n  return low;\n}\n\n/**\n * Uses a binary search to determine the highest index at which value should be inserted\n * @param {T[]} array - The sorted array to inspect\n * @param {T} value - The value to evaluate\n * @returns {number} Returns the index at which value should be inserted into array\n * @since 0.9.0\n * @example\n * sortedLastIndex([4, 5, 5, 5, 6], 5); // 4\n */\nexport function sortedLastIndex<T> (array: T[], value: T): number {\n  let low = 0;\n  let high = array.length;\n\n  while (low < high) {\n    const mid = Math.floor((low + high) / 2);\n    if (value < array[mid]) {\n      high = mid;\n    } else {\n      low = mid + 1;\n    }\n  }\n\n  return low;\n}\n\n/**\n * Like sortedLastIndex except that it accepts iteratee\n * @param {T[]} array - The sorted array to inspect\n * @param {T} value - The value to evaluate\n * @param {(value: T) => any} iteratee - The iteratee invoked per element\n * @returns {number} Returns the index at which value should be inserted into array\n * @since 0.9.0\n * @example\n * sortedLastIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, o => o.x); // 1\n */\nexport function sortedLastIndexBy<T> (array: T[], value: T, iteratee: (value: T) => any): number {\n  let low = 0;\n  let high = array.length;\n  const computedValue = iteratee(value);\n\n  while (low < high) {\n    const mid = Math.floor((low + high) / 2);\n    if (computedValue < iteratee(array[mid])) {\n      high = mid;\n    } else {\n      low = mid + 1;\n    }\n  }\n\n  return low;\n}\n\n/**\n * Uses a binary search to find the index of the value in the sorted array\n * @param {T[]} array - The sorted array to inspect\n * @param {T} value - The value to search for\n * @returns {number} Returns the index of the matched value, else -1\n * @since 0.9.0\n * @example\n * sortedIndexOf([4, 5, 5, 5, 6], 5); // 1\n */\nexport function sortedIndexOf<T> (array: T[], value: T): number {\n  const index = sortedIndex(array, value);\n  return index < array.length && array[index] === value ? index : -1;\n}\n\n/**\n * Uses a binary search to find the last index of the value in the sorted array\n * @param {T[]} array - The sorted array to inspect\n * @param {T} value - The value to search for\n * @returns {number} Returns the index of the matched value, else -1\n * @since 0.9.0\n * @example\n * sortedLastIndexOf([4, 5, 5, 5, 6], 5); // 3\n */\nexport function sortedLastIndexOf<T> (array: T[], value: T): number {\n  const index = sortedLastIndex(array, value) - 1;\n  return index >= 0 && array[index] === value ? index : -1;\n}\n\n/**\n * Creates a slice of array from start up to, but not including, end\n * @param {T[]} array - The array to slice\n * @param {number} [start=0] - The start position\n * @param {number} [end=array.length] - The end position\n * @returns {T[]} Returns the slice of array\n * @since 0.9.0\n * @example\n * slice([1, 2, 3, 4], 2); // [3, 4]\n * slice([1, 2, 3, 4], 1, 3); // [2, 3]\n */\nexport function slice<T> (array: T[], start: number = 0, end: number = array.length): T[] {\n  return array.slice(start, end);\n}\n\n/**\n * Joins a list of elements using a separator\n * @param {T[]} array - The array to convert\n * @param {string} [separator=','] - The element separator\n * @returns {string} Returns the joined string\n * @since 0.9.0\n * @example\n * join(['a', 'b', 'c'], '~'); // 'a~b~c'\n */\nexport function join<T> (array: T[], separator: string = ','): string {\n  return array.join(separator);\n}\n\n/**\n * Gets the index at which the first occurrence of value is found in array\n * @param {T[]} array - The array to inspect\n * @param {T} value - The value to search for\n * @param {number} [fromIndex=0] - The index to search from\n * @returns {number} Returns the index of the matched value, else -1\n * @since 0.9.0\n * @example\n * indexOf([1, 2, 1, 2], 2); // 1\n * indexOf([1, 2, 1, 2], 2, 2); // 3\n */\nexport function indexOf<T> (array: T[], value: T, fromIndex: number = 0): number {\n  return array.indexOf(value, fromIndex);\n}\n\n/**\n * Gets the index at which the last occurrence of value is found in array\n * @param {T[]} array - The array to inspect\n * @param {T} value - The value to search for\n * @param {number} [fromIndex=array.length-1] - The index to search from\n * @returns {number} Returns the index of the matched value, else -1\n * @since 0.9.7\n * @example\n * lastIndexOf([1, 2, 1, 2], 2); // 3\n * lastIndexOf([1, 2, 1, 2], 2, 2); // 1\n */\nexport function lastIndexOf<T> (array: T[], value: T, fromIndex: number = array.length - 1): number {\n  return array.lastIndexOf(value, fromIndex);\n}\n\n/**\n * Filters an array of objects based on provided parameters\n * @param {T[]} arr - The array of objects to be filtered\n * @param {i_func_filterData} param - The filtering parameters\n * @returns {T[]} Returns the filtered array containing objects of type T\n * @since 0.9.7\n * @example\n * const data = [\n *   { field_search: 'John Doe', state: [{ state: 'active' }], ddeb: '2023-01-15' },\n *   { field_search: 'Jane Smith', state: [{ state: 'inactive' }], ddeb: '2024-02-20' }\n * ];\n * filterData(data, { \n *   sW: 'John', \n *   tbRS: [], \n *   selections: [{ selection: ['active'], property: 'state' }] \n * });\n * // [{ field_search: 'John Doe', state: [{ state: 'active' }], ddeb: '2023-01-15' }]\n */\nexport function filterData<T extends o> (\n  arr: T[],\n  param: i_func_filterData,\n): T[] {\n  const {\n    sW,\n    tbRS,\n    field_search = 'field_search',\n    ddeb = 'ddeb',\n    regex = '[A-Za-zÀ-ÖØ-öø-ÿ0-9]+',\n    selections = [],\n  } = param;\n\n  const tbExp = sW.match(new RegExp(regex, 'gi')) || [];\n\n  return arr.filter((item: T) => {\n    // Check word search\n    for (let i = 0; i < tbExp.length; i++) {\n      const searchedWord = purify(tbExp[i].toUpperCase());\n      if (!new RegExp(searchedWord, 'gi').test(item[field_search])) {\n        return false;\n      }\n    }\n\n    // Check selections\n    function checkSelections (selectedItems: string[], itemProperty: string) {\n      if (!item[itemProperty] || !Array.isArray(item[itemProperty])) {\n        return false;\n      }\n\n      for (const selected of selectedItems) {\n        const itemArray = item[itemProperty];\n        let hasMatch = false;\n\n        for (let j = 0; j < itemArray.length; j++) {\n          const itemState = itemArray[j];\n          if (itemState && itemState.state && itemState.state.toString().includes(selected)) {\n            hasMatch = true;\n            break;\n          }\n        }\n\n        if (!hasMatch) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    for (const { selection, property } of selections) {\n      if (!checkSelections(selection, property)) {\n        return false;\n      }\n    }\n\n    // Check date range\n    if (tbRS.length === 2 && item[ddeb]) {\n      const itemDate = new Date(item[ddeb]);\n      const startDate = new Date(tbRS[0], 0, 1); // January 1st of start year\n      const endDate = new Date(tbRS[1], 11, 31); // December 31st of end year\n\n      if (itemDate < startDate || itemDate > endDate) {\n        return false;\n      }\n    }\n\n    return true;\n  });\n}","/**\n * Lightweight object utility functions\n * No external dependencies\n * @since 0.8.0\n */\n\nexport interface FlatOptions {\n  props?: string[];\n}\n\n/**\n * Flatten an object and extract values\n * @param data - The data to flatten\n * @param options - Flatten options\n * @param options.props - Array of property names to include (empty array includes all)\n * @returns Flattened string of values joined by commas\n * @since 0.8.0\n * @example\n * flat({ a: 1, b: { c: 2 } }) // '1, 2'\n * flat({ a: 1, b: { c: 2 } }, { props: ['a'] }) // '1'\n */\nexport function flat (data: any, options: FlatOptions = {}): string {\n  const { props = [] } = options;\n  const result: string[] = [];\n\n  const traverse = (obj: any) => {\n    for (const key in obj) {\n      const val = obj[key];\n\n      if (typeof val === \"object\" && val) {\n        traverse(val);\n      } else if (!props.length || props.includes(key)) {\n        if (Array.isArray(val)) {\n          result.push(...val.filter(item => item));\n        } else if (val) {\n          result.push(val);\n        }\n      }\n    }\n  };\n\n  traverse(data);\n  return [...new Set(result)].join(', ');\n}\n\n/**\n * Get object keys by value type\n * @param obj - The object to analyze\n * @param type - The type to filter by ('string', 'number', 'boolean', etc.)\n * @returns Array of keys whose values match the specified type\n * @example\n * getObjectKeysByType({ a: 1, b: 'hello', c: true }, 'string') // ['b']\n */\nexport function getObjectKeysByType (obj: object, type: string): string[] {\n  return Object.entries(obj)\n    .filter(([_, value]) => typeof value === type)\n    .map(([key, _]) => key);\n}\n\n/**\n * Get value from object by path\n * @param obj - The object to traverse\n * @param path - Array of keys representing the path to the desired value\n * @returns The value at the specified path or null if not found\n * @example\n * getObjectValueByPath({ a: { b: { c: 42 } } }, ['a', 'b', 'c']) // 42\n * getObjectValueByPath({ items: [{ name: 'John' }, { name: 'Jane' }] }, ['items', 'name']) // ['John', 'Jane']\n */\nexport function getObjectValueByPath<T> (obj: any, path: string[]): T | null {\n  return path.reduce((o, key) => {\n    if (o && Array.isArray(o)) {\n      return o.map((item) => getObjectValueByPath<T>(item, [key])).flat();\n    }\n    return (o && o[key]) ? o[key] : null;\n  }, obj);\n}\n\n/**\n * Check if a value is empty\n * @param value - The value to check (string, object, or array)\n * @param options - Check options\n * @param options.props - If true, checks if all object properties are empty recursively\n * @returns True if the value is considered empty, false otherwise\n * @example\n * isEmpty('') // true\n * isEmpty([]) // true\n * isEmpty({}) // true\n * isEmpty({ a: '' }, { props: true }) // true\n */\nexport function isEmpty (\n  value: string | object | any[],\n  options: { props?: boolean } = { props: false }\n): boolean {\n  switch (typeof value) {\n    case \"string\":\n      return value.length === 0;\n    case \"object\":\n      if (Array.isArray(value)) {\n        return value.every((item) => isEmpty(item, options));\n      } else {\n        if (options.props) {\n          return Object.values(value).every((prop) =>\n            isEmpty(prop, options)\n          );\n        }\n        return Object.keys(value).length === 0;\n      }\n    default:\n      return true;\n  }\n}\n\n/**\n * Gets the type of a value\n * @param value - The value to check\n * @returns The type as a string ('string', 'number', 'object', etc.)\n * @example\n * getValueType('hello') // 'string'\n * getValueType(42) // 'number'\n * getValueType({}) // 'object'\n */\nexport function getValueType (value: any): string {\n  return typeof value;\n}\n\n/**\n * Creates an object with the same keys as the input object and values generated by running each property through an iteratee function\n * @param obj - The object to map over\n * @param iteratee - The function invoked per property (value, key) => newValue\n * @returns A new object with transformed values\n * @example\n * mapValues({ a: 1, b: 2 }, x => x * 2) // { a: 2, b: 4 }\n * mapValues({ a: 'hello', b: 'world' }, (value, key) => `${key}: ${value}`) // { a: 'a: hello', b: 'b: world' }\n */\nexport function mapValues<T, R> (obj: Record<string, T>, iteratee: (value: T, key: string) => R): Record<string, R> {\n  const result: Record<string, R> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    result[key] = iteratee(value, key);\n  }\n  return result;\n}\n\n/**\n * Creates an object with the same values as the input object and keys generated by running each property through an iteratee function\n * @param obj - The object to map over\n * @param iteratee - The function invoked per property (value, key) => newKey\n * @returns A new object with transformed keys\n * @example\n * mapKeys({ a: 1, b: 2 }, (value, key) => key.toUpperCase()) // { A: 1, B: 2 }\n */\nexport function mapKeys<T> (obj: Record<string, T>, iteratee: (value: T, key: string) => string): Record<string, T> {\n  const result: Record<string, T> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    const newKey = iteratee(value, key);\n    result[newKey] = value;\n  }\n  return result;\n}\n\n/**\n * Creates an object that inherits from the given prototype object\n * @param prototype - The object to inherit from (can be null)\n * @param properties - Optional properties to assign to the new object\n * @returns A new object inheriting from the prototype\n * @example\n * const proto = { greet: () => 'hello' }\n * const obj = create(proto, { name: 'John' }) // obj.greet() works and obj.name === 'John'\n */\nexport function create<T extends object> (prototype: T | null, properties?: Record<string, any>): T {\n  const result = Object.create(prototype);\n  if (properties) {\n    Object.assign(result, properties);\n  }\n  return result;\n}\n\n/**\n * Assigns own enumerable string keyed properties of source objects to the destination object\n * @param target - The destination object to assign properties to\n * @param sources - The source objects to copy properties from\n * @returns The target object with assigned properties\n * @example\n * assign({ a: 1 }, { b: 2 }, { c: 3 }) // { a: 1, b: 2, c: 3 }\n */\nexport function assign<T extends Record<string, any>> (target: T, ...sources: Partial<T>[]): T {\n  return Object.assign(target, ...sources);\n}\n\n/**\n * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object\n * @param target - The destination object to merge into\n * @param sources - The source objects to merge from\n * @returns The target object with merged properties\n * @example\n * merge({ a: { x: 1 } }, { a: { y: 2 }, b: 3 }) // { a: { x: 1, y: 2 }, b: 3 }\n */\nexport function merge<T extends Record<string, any>> (target: T, ...sources: any[]): T {\n  function isObject (obj: any): obj is Record<string, any> {\n    return obj && typeof obj === 'object' && !Array.isArray(obj);\n  }\n\n  for (const source of sources) {\n    if (isObject(source)) {\n      for (const key in source) {\n        if (isObject(target[key]) && isObject(source[key])) {\n          (target as any)[key] = merge((target as any)[key], source[key]);\n        } else {\n          (target as any)[key] = source[key];\n        }\n      }\n    }\n  }\n  return target;\n}\n\n/**\n * Like merge except that it accepts a customizer function which is invoked to produce the merged values\n * @param target - The destination object to merge into\n * @param source - The source object to merge from\n * @param customizer - The function to customize assigned values (objValue, srcValue, key) => mergedValue\n * @returns The target object with custom merged properties\n * @example\n * mergeWith({ a: [1] }, { a: [2] }, (obj, src) => Array.isArray(obj) ? obj.concat(src) : undefined) // { a: [1, 2] }\n */\nexport function mergeWith<T> (target: T, source: any, customizer: (objValue: any, srcValue: any, key: string) => any): T {\n  function isObject (obj: any): obj is object {\n    return obj && typeof obj === 'object' && !Array.isArray(obj);\n  }\n\n  for (const key in source) {\n    const objValue = (target as any)[key];\n    const srcValue = source[key];\n    const result = customizer(objValue, srcValue, key);\n\n    if (result !== undefined) {\n      (target as any)[key] = result;\n    } else if (isObject(objValue) && isObject(srcValue)) {\n      (target as any)[key] = mergeWith(objValue, srcValue, customizer);\n    } else {\n      (target as any)[key] = srcValue;\n    }\n  }\n  return target;\n}\n\n/**\n * Creates an object composed of the picked object properties\n * @param obj - The source object to pick from\n * @param keys - The property keys to pick\n * @returns A new object with only the specified properties\n * @example\n * pick({ a: 1, b: 2, c: 3 }, 'a', 'c') // { a: 1, c: 3 }\n */\nexport function pick<T extends object, K extends keyof T> (obj: T, ...keys: K[]): Pick<T, K> {\n  const result = {} as Pick<T, K>;\n  for (const key of keys) {\n    if (key in obj) {\n      result[key] = obj[key];\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an object composed of properties that satisfy the predicate function\n * @param obj - The source object to pick from\n * @param predicate - The function invoked per property (value, key) => boolean\n * @returns A new object with properties that pass the predicate test\n * @example\n * pickBy({ a: 1, b: 2, c: 3 }, value => value > 1) // { b: 2, c: 3 }\n */\nexport function pickBy<T> (obj: Record<string, T>, predicate: (value: T, key: string) => boolean): Partial<Record<string, T>> {\n  const result: Partial<Record<string, T>> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    if (predicate(value, key)) {\n      result[key] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an object composed of all properties except the specified ones\n * @param obj - The source object to omit from\n * @param keys - The property keys to omit\n * @returns A new object without the specified properties\n * @example\n * omit({ a: 1, b: 2, c: 3 }, 'a', 'c') // { b: 2 }\n */\nexport function omit<T, K extends keyof T> (obj: T, ...keys: K[]): Omit<T, K> {\n  const result = { ...obj } as any;\n  for (const key of keys) {\n    delete result[key];\n  }\n  return result;\n}\n\n/**\n * Creates an object composed of properties that do not satisfy the predicate function\n * @param obj - The source object to omit from\n * @param predicate - The function invoked per property (value, key) => boolean\n * @returns A new object with properties that fail the predicate test\n * @example\n * omitBy({ a: 1, b: 2, c: 3 }, value => value > 1) // { a: 1 }\n */\nexport function omitBy<T> (obj: Record<string, T>, predicate: (value: T, key: string) => boolean): Partial<Record<string, T>> {\n  const result: Partial<Record<string, T>> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    if (!predicate(value, key)) {\n      result[key] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Gets the value at the specified path of an object\n * @param obj - The object to query\n * @param path - The path of the property to get (string with dots or array of keys)\n * @param defaultValue - The value returned if the resolved value is undefined\n * @returns The resolved value or default value\n * @example\n * get({ a: { b: { c: 3 } } }, 'a.b.c') // 3\n * get({ a: { b: { c: 3 } } }, ['a', 'b', 'c']) // 3\n * get({}, 'a.b.c', 'default') // 'default'\n */\nexport function get<T> (obj: any, path: string | string[], defaultValue?: T): T {\n  const keys = Array.isArray(path) ? path : path.split('.');\n  let result = obj;\n\n  for (const key of keys) {\n    if (result == null) break;\n    result = result[key];\n  }\n\n  return result === undefined ? defaultValue as T : result;\n}\n\n/**\n * Sets the value at the specified path of an object\n * @param obj - The object to modify\n * @param path - The path of the property to set (string with dots or array of keys)\n * @param value - The value to set\n * @returns The modified object\n * @example\n * set({}, 'a.b.c', 3) // { a: { b: { c: 3 } } }\n * set({}, ['a', 'b', 'c'], 3) // { a: { b: { c: 3 } } }\n */\nexport function set<T> (obj: any, path: string | string[], value: T): any {\n  const keys = Array.isArray(path) ? path : path.split('.');\n  let current = obj;\n\n  for (let i = 0; i < keys.length - 1; i++) {\n    const key = keys[i];\n    if (!(key in current) || typeof current[key] !== 'object') {\n      current[key] = {};\n    }\n    current = current[key];\n  }\n\n  current[keys[keys.length - 1]] = value;\n  return obj;\n}\n\n/**\n * Checks if the specified path exists as a direct property of the object\n * @param obj - The object to query\n * @param path - The path to check (string with dots or array of keys)\n * @returns True if path exists, false otherwise\n * @example\n * has({ a: { b: { c: 3 } } }, 'a.b.c') // true\n * has({ a: { b: { c: 3 } } }, 'a.b.d') // false\n */\nexport function has (obj: any, path: string | string[]): boolean {\n  const keys = Array.isArray(path) ? path : path.split('.');\n  let current = obj;\n\n  for (const key of keys) {\n    if (current == null || !(key in current)) {\n      return false;\n    }\n    current = current[key];\n  }\n\n  return true;\n}\n\n/**\n * Checks if the specified path exists as an own property of the object\n * @param obj - The object to query\n * @param path - The path to check (string with dots or array of keys)\n * @returns True if path exists as own property, false otherwise\n * @example\n * hasIn({ a: { b: 2 } }, 'a.b') // true\n */\nexport function hasIn (obj: any, path: string | string[]): boolean {\n  const keys = Array.isArray(path) ? path : path.split('.');\n  let current = obj;\n\n  for (const key of keys) {\n    if (current == null || !Object.prototype.hasOwnProperty.call(current, key)) {\n      return false;\n    }\n    current = current[key];\n  }\n\n  return true;\n}\n\n/**\n * Removes the property at the specified path of an object\n * @param obj - The object to modify\n * @param path - The path of the property to unset (string with dots or array of keys)\n * @returns True if the property is deleted, false otherwise\n * @example\n * const obj = { a: { b: { c: 3 } } }\n * unset(obj, 'a.b.c') // true, obj becomes { a: { b: {} } }\n */\nexport function unset (obj: any, path: string | string[]): boolean {\n  const keys = Array.isArray(path) ? path : path.split('.');\n  if (keys.length === 0) return true;\n\n  let current = obj;\n  for (let i = 0; i < keys.length - 1; i++) {\n    if (current == null || typeof current !== 'object') {\n      return true;\n    }\n    current = current[keys[i]];\n  }\n\n  if (current != null && typeof current === 'object') {\n    delete current[keys[keys.length - 1]];\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Creates an array of own enumerable property names of an object\n * @param obj - The object to query\n * @returns An array of property names\n * @example\n * keys({ a: 1, b: 2, c: 3 }) // ['a', 'b', 'c']\n */\nexport function keys<T> (obj: Record<string, T>): string[] {\n  return Object.keys(obj);\n}\n\n/**\n * Creates an array of own enumerable property values of an object\n * @param obj - The object to query\n * @returns An array of property values\n * @example\n * values({ a: 1, b: 2, c: 3 }) // [1, 2, 3]\n */\nexport function values<T> (obj: Record<string, T>): T[] {\n  return Object.values(obj);\n}\n\n/**\n * Creates an array of own enumerable string keyed-value pairs for an object\n * @param obj - The object to query\n * @returns An array of key-value pairs\n * @example\n * entries({ a: 1, b: 2 }) // [['a', 1], ['b', 2]]\n */\nexport function entries<T> (obj: Record<string, T>): [string, T][] {\n  return Object.entries(obj);\n}\n\n/**\n * Creates an array of own and inherited enumerable string keyed-value pairs for an object\n * @param obj - The object to query\n * @returns An array of key-value pairs including inherited properties\n * @example\n * const obj = Object.create({ inherited: 'value' })\n * obj.own = 'property'\n * entriesIn(obj) // [['own', 'property'], ['inherited', 'value']]\n */\nexport function entriesIn<T> (obj: Record<string, T>): [string, T][] {\n  const result: [string, T][] = [];\n  for (const key in obj) {\n    result.push([key, obj[key]]);\n  }\n  return result;\n}\n\n/**\n * Creates an object from an array of key-value pairs\n * @param pairs - The array of key-value pairs\n * @returns The new object\n * @example\n * fromPairs([['a', 1], ['b', 2]]) // { a: 1, b: 2 }\n */\nexport function fromPairs<T> (pairs: [string, T][]): Record<string, T> {\n  const result: Record<string, T> = {};\n  for (const [key, value] of pairs) {\n    result[key] = value;\n  }\n  return result;\n}\n\n/**\n * Creates an array of function property names from own enumerable properties of an object\n * @param obj - The object to inspect\n * @returns An array of function property names\n * @example\n * functions({ a: 1, b: () => {}, c: 'string', d: function() {} }) // ['b', 'd']\n */\nexport function functions (obj: any): string[] {\n  return Object.keys(obj).filter(key => typeof obj[key] === 'function');\n}\n\n/**\n * Creates an array of function property names from own and inherited enumerable properties of an object\n * @param obj - The object to inspect\n * @returns An array of function property names including inherited ones\n * @example\n * const obj = Object.create({ inheritedFn: () => {} })\n * obj.ownFn = () => {}\n * functionsIn(obj) // ['ownFn', 'inheritedFn']\n */\nexport function functionsIn (obj: any): string[] {\n  const result: string[] = [];\n  for (const key in obj) {\n    if (typeof obj[key] === 'function') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an object that inverts the keys and values of the input object\n * @param obj - The object to invert\n * @returns The inverted object\n * @example\n * invert({ a: 1, b: 2, c: 1 }) // { '1': 'c', '2': 'b' }\n */\nexport function invert<T extends Record<string, string | number>> (obj: T): Record<string, string> {\n  const result: Record<string, string> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    result[String(value)] = key;\n  }\n  return result;\n}\n\n/**\n * Creates an inverted object where the inverted keys are generated from running each element through an iteratee\n * @param obj - The object to invert\n * @param iteratee - The iteratee function to transform values into keys\n * @returns The inverted object with arrays of original keys\n * @example\n * invertBy({ a: 1, b: 2, c: 1 }, value => `group${value}`) // { group1: ['a', 'c'], group2: ['b'] }\n */\nexport function invertBy<T> (obj: Record<string, T>, iteratee: (value: T) => string): Record<string, string[]> {\n  const result: Record<string, string[]> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    const invertedKey = iteratee(value);\n    if (!result[invertedKey]) {\n      result[invertedKey] = [];\n    }\n    result[invertedKey].push(key);\n  }\n  return result;\n}\n\n/**\n * Transforms an object by running each own enumerable string keyed property through a transform function\n * @param obj - The object to transform\n * @param transform - The transform function (result, value, key) => void\n * @param accumulator - The initial accumulator value\n * @returns The accumulated result\n * @example\n * transform({ a: 1, b: 2 }, (result, value, key) => { result[key] = value * 2 }, {}) // { a: 2, b: 4 }\n */\nexport function transform<T, R> (obj: Record<string, T>, transform: (result: R, value: T, key: string) => void, accumulator: R): R {\n  const result = accumulator;\n  for (const [key, value] of Object.entries(obj)) {\n    transform(result, value, key);\n  }\n  return result;\n}\n\n/**\n * Creates a shallow clone of an object\n * @param obj - The object to clone\n * @returns A shallow clone of the object\n * @example\n * const obj = { a: 1, b: { c: 2 } }\n * const cloned = clone(obj) // cloned.b === obj.b (same reference)\n */\nexport function clone<T> (obj: T): T {\n  if (obj === null || typeof obj !== 'object') return obj;\n  if (obj instanceof Date) return new Date(obj.getTime()) as any;\n  if (Array.isArray(obj)) return obj.slice() as any;\n  return Object.assign({}, obj);\n}\n\n/**\n * Creates a deep clone of an object\n * @param obj - The object to clone\n * @returns A deep clone of the object\n * @example\n * const obj = { a: 1, b: { c: 2 } }\n * const cloned = cloneDeep(obj) // cloned.b !== obj.b (different reference)\n */\nexport function cloneDeep<T> (obj: T): T {\n  if (obj === null || typeof obj !== 'object') return obj;\n  if (obj instanceof Date) return new Date(obj.getTime()) as any;\n  if (Array.isArray(obj)) return obj.map(item => cloneDeep(item)) as any;\n\n  const cloned = {} as any;\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      cloned[key] = cloneDeep((obj as any)[key]);\n    }\n  }\n  return cloned;\n}\n\n/**\n * Performs a deep comparison between two values to determine if they are equivalent\n * @param a - The first value to compare\n * @param b - The second value to compare\n * @returns True if the values are equivalent, false otherwise\n * @example\n * isEqual([1, 2, 3], [1, 2, 3]) // true\n * isEqual({ a: 1 }, { a: 1 }) // true\n * isEqual({ a: 1 }, { a: 2 }) // false\n */\nexport function isEqual (a: any, b: any): boolean {\n  if (a === b) return true;\n  if (a == null || b == null) return a === b;\n  if (typeof a !== typeof b) return false;\n\n  if (typeof a === 'object') {\n    if (Array.isArray(a) !== Array.isArray(b)) return false;\n\n    if (Array.isArray(a)) {\n      if (a.length !== b.length) return false;\n      return a.every((item, index) => isEqual(item, b[index]));\n    }\n\n    const keysA = Object.keys(a);\n    const keysB = Object.keys(b);\n    if (keysA.length !== keysB.length) return false;\n\n    return keysA.every(key => isEqual(a[key], b[key]));\n  }\n\n  return false;\n}\n\n/**\n * Checks if an object conforms to a source by invoking predicate properties with corresponding object values\n * @param obj - The object to inspect\n * @param source - The object of predicate functions\n * @returns True if the object conforms, false otherwise\n * @example\n * conformsTo({ a: 1, b: 2 }, { a: n => n > 0, b: n => n < 5 }) // true\n */\nexport function conformsTo<T> (obj: T, source: Partial<Record<keyof T, (value: any) => boolean>>): boolean {\n  for (const key in source) {\n    const predicate = source[key];\n    if (predicate && !predicate((obj as any)[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Creates a function that invokes the method at a specified path of a given object\n * @param path - The path of the method to invoke\n * @param args - The arguments to invoke the method with\n * @returns A function that takes an object and invokes the method\n * @example\n * const fn = method('toUpperCase')\n * fn('hello') // 'HELLO'\n */\nexport function method (path: string | string[], ...args: any[]): (obj: any) => any {\n  return function (obj: any) {\n    const method = get(obj, path);\n    return typeof method === 'function' ? method.apply(obj, args) : undefined;\n  };\n}\n\n/**\n * Creates a function that invokes the method at a given path of the specified object\n * @param obj - The object to query\n * @param args - The arguments to invoke the method with\n * @returns A function that takes a path and invokes the method\n * @example\n * const fn = methodOf('hello world')\n * fn('split') // ['hello', 'world']\n */\nexport function methodOf (obj: any, ...args: any[]): (path: string | string[]) => any {\n  return function (path: string | string[]) {\n    const method = get(obj, path);\n    return typeof method === 'function' ? method.apply(obj, args) : undefined;\n  };\n}\n\n/**\n * Assigns properties of source objects to the destination object for all destination properties that resolve to undefined\n * @param obj - The destination object\n * @param sources - The source objects\n * @returns The destination object with default values assigned\n * @example\n * defaults({ a: 1 }, { a: 3, b: 2 }, { c: 3 }) // { a: 1, b: 2, c: 3 }\n */\nexport function defaults<T extends object> (obj: T, ...sources: Partial<T>[]): T {\n  const result = { ...obj };\n  for (const source of sources) {\n    for (const key in source) {\n      if (result[key] === undefined) {\n        (result as any)[key] = source[key];\n      }\n    }\n  }\n  return result;\n}\n\n/**\n * Recursively assigns default properties from source objects to the destination object\n * @param obj - The destination object\n * @param sources - The source objects\n * @returns The destination object with deep default values assigned\n * @example\n * defaultsDeep({ a: { x: 1 } }, { a: { y: 2, x: 3 }, b: 4 }) // { a: { x: 1, y: 2 }, b: 4 }\n */\nexport function defaultsDeep<T extends object> (obj: T, ...sources: any[]): T {\n  function isObject (value: any): value is object {\n    return value != null && typeof value === 'object' && !Array.isArray(value);\n  }\n\n  const result = cloneDeep(obj);\n\n  for (const source of sources) {\n    function assignDefaults (target: any, src: any) {\n      for (const key in src) {\n        if (target[key] === undefined) {\n          target[key] = isObject(src[key]) ? assignDefaults({}, src[key]) : src[key];\n        } else if (isObject(target[key]) && isObject(src[key])) {\n          assignDefaults(target[key], src[key]);\n        }\n      }\n      return target;\n    }\n    assignDefaults(result, source);\n  }\n\n  return result;\n}\n\n/**\n * Gets the values at multiple paths of an object\n * @param obj - The object to query\n * @param paths - The property paths to get values from\n * @returns An array of resolved values\n * @example\n * at({ a: 1, b: { c: 2 } }, 'a', 'b.c', 'missing') // [1, 2, undefined]\n */\nexport function at<T> (obj: any, ...paths: (string | string[])[]): (T | undefined)[] {\n  return paths.map(path => get<T>(obj, path));\n}\n\n/**\n * Gets the value at path of object. If the resolved value is a function, it's invoked and its result is returned\n * @param obj - The object to query\n * @param path - The path of the property to get\n * @param defaultValue - The value returned if the resolved value is undefined\n * @returns The resolved value, function result, or default value\n * @example\n * result({ a: () => 42 }, 'a') // 42\n * result({ a: 5 }, 'a') // 5\n */\nexport function result<T> (obj: any, path: string | string[], defaultValue?: T): T {\n  const value = get(obj, path, defaultValue);\n  return typeof value === 'function' ? value.call(obj) : value;\n}\n\n/**\n * Invokes the method at the specified path of an object\n * @param obj - The object to query\n * @param path - The path of the method to invoke\n * @param args - The arguments to invoke the method with\n * @returns The result of the invoked method\n * @example\n * invoke({ a: { b: Math.max } }, 'a.b', 1, 2, 3) // 3\n */\nexport function invoke (obj: any, path: string | string[], ...args: any[]): any {\n  const method = get(obj, path);\n  return typeof method === 'function' ? method.apply(obj, args) : undefined;\n}\n\n/**\n * Sets the value at path of object using an updater function\n * @param obj - The object to modify\n * @param path - The path of the property to set\n * @param updater - The function to produce the updated value\n * @returns The modified object\n * @example\n * update({ a: 1 }, 'a', n => n * 2) // { a: 2 }\n */\nexport function update<T> (obj: any, path: string | string[], updater: (value: any) => T): any {\n  const currentValue = get(obj, path);\n  const newValue = updater(currentValue);\n  return set(obj, path, newValue);\n}\n\n/**\n * Like update except that it accepts a customizer which is invoked to produce the updated value\n * @param obj - The object to modify\n * @param path - The path of the property to set\n * @param updater - The function to produce the updated value\n * @param customizer - The function to customize assigned values\n * @returns The modified object\n * @example\n * updateWith({}, 'a.b', () => 'value', () => ({})) // { a: { b: 'value' } }\n */\nexport function updateWith<T> (obj: any, path: string | string[], updater: (value: any) => T, customizer: (value: any, key: string, object: any) => any): any {\n  const keys = Array.isArray(path) ? path : path.split('.');\n  let current = obj;\n\n  for (let i = 0; i < keys.length - 1; i++) {\n    const key = keys[i];\n    const nextKey = keys[i + 1];\n\n    if (!(key in current) || typeof current[key] !== 'object') {\n      current[key] = customizer(undefined, nextKey, current) || {};\n    }\n    current = current[key];\n  }\n\n  const lastKey = keys[keys.length - 1];\n  const currentValue = current[lastKey];\n  current[lastKey] = updater(currentValue);\n\n  return obj;\n}\n\n/**\n * Like set except that it accepts a customizer which is invoked to produce the objects of path\n * @param obj - The object to modify\n * @param path - The path of the property to set\n * @param value - The value to set\n * @param customizer - The function to customize assigned values\n * @returns The modified object\n * @example\n * setWith({}, 'a[0].b.c', 4, Object) // { a: { '0': { b: { c: 4 } } } }\n */\nexport function setWith<T> (obj: any, path: string | string[], value: T, customizer: (value: any, key: string, object: any) => any): any {\n  const keys = Array.isArray(path) ? path : path.split('.');\n  let current = obj;\n\n  for (let i = 0; i < keys.length - 1; i++) {\n    const key = keys[i];\n    const nextKey = keys[i + 1];\n\n    if (!(key in current) || typeof current[key] !== 'object') {\n      current[key] = customizer(undefined, nextKey, current) || {};\n    }\n    current = current[key];\n  }\n\n  current[keys[keys.length - 1]] = value;\n  return obj;\n}\n\n/**\n * Finds the last key of an object where the predicate returns truthy\n * @param collection - The object to inspect\n * @param predicate - The function invoked per property\n * @returns The key of the matched element, else undefined\n * @example\n * findLastKey({ a: 1, b: 2, c: 3 }, n => n > 1) // 'c'\n */\nexport function findLastKey<T> (collection: Record<string, T>, predicate: (value: T, key: string, collection: Record<string, T>) => boolean): string | undefined {\n  const keys = Object.keys(collection).reverse();\n  for (const key of keys) {\n    if (predicate(collection[key], key, collection)) {\n      return key;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Iterates over own and inherited enumerable string keyed properties of an object\n * @param obj - The object to iterate over\n * @param iteratee - The function invoked per property\n * @returns The original object\n * @example\n * forIn({ a: 1, b: 2 }, (value, key) => console.log(key, value))\n */\nexport function forIn<T> (obj: Record<string, T>, iteratee: (value: T, key: string) => void): Record<string, T> {\n  for (const key in obj) {\n    iteratee(obj[key], key);\n  }\n  return obj;\n}\n\n/**\n * Like forIn except that it iterates over properties in the opposite order\n * @param obj - The object to iterate over\n * @param iteratee - The function invoked per property\n * @returns The original object\n * @example\n * forInRight({ a: 1, b: 2 }, (value, key) => console.log(key, value)) // logs 'b 2' then 'a 1'\n */\nexport function forInRight<T> (obj: Record<string, T>, iteratee: (value: T, key: string) => void): Record<string, T> {\n  const keys: string[] = [];\n  for (const key in obj) {\n    keys.push(key);\n  }\n  for (let i = keys.length - 1; i >= 0; i--) {\n    const key = keys[i];\n    iteratee(obj[key], key);\n  }\n  return obj;\n}\n\n/**\n * Iterates over own enumerable string keyed properties of an object\n * @param obj - The object to iterate over\n * @param iteratee - The function invoked per property\n * @returns The original object\n * @example\n * forOwn({ a: 1, b: 2 }, (value, key) => console.log(key, value))\n */\nexport function forOwn<T> (obj: Record<string, T>, iteratee: (value: T, key: string) => void): Record<string, T> {\n  for (const [key, value] of Object.entries(obj)) {\n    iteratee(value, key);\n  }\n  return obj;\n}\n\n/**\n * Like forOwn except that it iterates over properties in the opposite order\n * @param obj - The object to iterate over\n * @param iteratee - The function invoked per property\n * @returns The original object\n * @example\n * forOwnRight({ a: 1, b: 2 }, (value, key) => console.log(key, value)) // logs 'b 2' then 'a 1'\n */\nexport function forOwnRight<T> (obj: Record<string, T>, iteratee: (value: T, key: string) => void): Record<string, T> {\n  const entries = Object.entries(obj).reverse();\n  for (const [key, value] of entries) {\n    iteratee(value, key);\n  }\n  return obj;\n}\n\n/**\n * Creates an array of own enumerable string keyed-value pairs for an object (alias for entries)\n * @param obj - The object to query\n * @returns An array of key-value pairs\n * @example\n * toPairs({ a: 1, b: 2 }) // [['a', 1], ['b', 2]]\n */\nexport function toPairs<T> (obj: Record<string, T>): [string, T][] {\n  return entries(obj);\n}\n\n/**\n * Creates an array of own and inherited enumerable string keyed-value pairs for an object (alias for entriesIn)\n * @param obj - The object to query\n * @returns An array of key-value pairs including inherited properties\n * @example\n * const obj = Object.create({ inherited: 'value' })\n * obj.own = 'property'\n * toPairsIn(obj) // [['own', 'property'], ['inherited', 'value']]\n */\nexport function toPairsIn<T> (obj: Record<string, T>): [string, T][] {\n  return entriesIn(obj);\n}\n","/**\n * Lightweight number utility functions\n * No external dependencies\n * @since 0.8.0\n */\n\nexport interface NumberOptions {\n  deep?: boolean;\n}\n\nexport type NumberInput = string | number | boolean | object | any[];\n\n/**\n * Parse string to number if possible\n * @param {NumberInput} data - The data to parse\n * @param {NumberOptions} [options={ deep: false }] - Parse options\n * @param {boolean} [options.deep=false] - Whether to recursively parse nested objects and arrays\n * @returns {NumberInput | number} Parsed number or original value if parsing fails\n * @since 0.8.0\n * @example\n * number('123') // 123\n * number('abc') // 'abc'\n * number(['1', '2', 'abc']) // [1, 2, 'abc']\n * number({ a: '123', b: 'abc' }, { deep: true }) // { a: 123, b: 'abc' }\n */\nexport function number (data: NumberInput, options: NumberOptions = { deep: false }): NumberInput | number {\n  const { deep } = options;\n\n  if (Array.isArray(data)) {\n    return data.map((item): NumberInput | number => number(item, options));\n  }\n\n  if (typeof data === \"object\" && data) {\n    const result: Record<string, NumberInput | number> = {};\n    for (const [key, value] of Object.entries(data)) {\n      result[key] = deep ? number(value, options) : value;\n    }\n    return result;\n  }\n\n  const parsedNumber = parseInt(data as string);\n  return isNaN(parsedNumber) ? data : parsedNumber;\n}\n\n/**\n * Parse float with optional precision\n * @param {string | number} data - The data to parse as a floating point number\n * @param {number} [precision] - Number of decimal places to round to\n * @returns {number | string | number} Parsed float rounded to specified precision, or original value if parsing fails\n * @since 0.8.0\n * @example\n * parseFloat('3.14159') // 3.14159\n * parseFloat('3.14159', 2) // 3.14\n * parseFloat('abc') // 'abc'\n */\nexport function parseFloat (data: string | number, precision?: number): number | string | number {\n  const parsed = Number.parseFloat(String(data));\n  if (isNaN(parsed)) return data;\n\n  return precision !== undefined ? Number(parsed.toFixed(precision)) : parsed;\n}\n\n/**\n * Clamp a number between min and max values\n * @param {number} value - The value to clamp\n * @param {number} min - Minimum allowed value (inclusive)\n * @param {number} max - Maximum allowed value (inclusive)\n * @returns {number} The clamped value between min and max\n * @since 0.8.0\n * @example\n * clamp(5, 0, 10) // 5\n * clamp(-5, 0, 10) // 0\n * clamp(15, 0, 10) // 10\n */\nexport function clamp (value: number, min: number, max: number): number {\n  return Math.min(Math.max(value, min), max);\n}\n\n/**\n * Generate random number between min and max\n * @param {number} [min=0] - Minimum value (inclusive)\n * @param {number} [max=1] - Maximum value (exclusive)\n * @returns {number} Random floating point number in the specified range\n * @since 0.8.0\n * @example\n * random() // Random number between 0 and 1\n * random(5, 10) // Random number between 5 and 10\n */\nexport function random (min: number = 0, max: number = 1): number {\n  return Math.random() * (max - min) + min;\n}\n\n/**\n * Generate random integer between min and max\n * @param {number} [min=0] - Minimum value (inclusive)\n * @param {number} [max=100] - Maximum value (inclusive)\n * @returns {number} Random integer in the specified range\n * @since 0.8.0\n * @example\n * randomInt() // Random integer between 0 and 100\n * randomInt(1, 6) // Random integer between 1 and 6 (like a dice roll)\n */\nexport function randomInt (min: number = 0, max: number = 100): number {\n  return Math.floor(random(min, max + 1));\n}\n","/**\n * Lightweight date utility functions\n * No external dependencies - uses native Date API\n * @since 0.8.0\n */\n\nexport type TimeUnit = \"hour\" | \"minute\" | \"second\" | \"millisecond\" | \"day\" | \"month\" | \"year\";\nexport type FormatType = \"DATE\" | \"TIME\" | \"DATE_TIME\";\nexport type CodeISO = \"AD\" | \"AT\" | \"BE\" | \"BG\" | \"CH\" | \"CY\" | \"CZ\" | \"DE\" | \"DK\" | \"EE\" | \"ES\" | \"FI\" | \"FR\" | \"GB\" | \"GR\" | \"HR\" | \"HU\" | \"IE\" | \"IS\" | \"IT\" | \"LI\" | \"LT\" | \"LU\" | \"LV\" | \"MC\" | \"MT\" | \"NL\" | \"NO\" | \"PL\" | \"PT\" | \"RO\" | \"SE\" | \"SI\" | \"SK\" | \"SM\" | \"TR\" | \"US\" | \"CA\" | \"JP\" | \"CN\" | \"KR\";\n\n/**\n * Format a date to string using a custom format pattern\n * @param date - The date to format (Date object or date string)\n * @param format - The format string pattern (supports YYYY, MM, DD, HH, mm, ss)\n * @returns Formatted date string, or empty string if date is invalid\n * @since 0.8.0\n * @example\n * ```typescript\n * formatDate(new Date(), 'DD/MM/YYYY') // '25/12/2023'\n * formatDate('2023-12-25', 'HH:mm:ss') // '00:00:00'\n * formatDate('invalid', 'DD/MM/YYYY') // ''\n * ```\n */\nexport function formatDate (date: string | Date, format: string): string {\n  const d = new Date(date);\n  if (isNaN(d.getTime())) return \"\";\n\n  const pad = (n: number) => n.toString().padStart(2, '0');\n\n  const replacements: Record<string, string> = {\n    'YYYY': d.getFullYear().toString(),\n    'MM': pad(d.getMonth() + 1),\n    'DD': pad(d.getDate()),\n    'HH': pad(d.getHours()),\n    'mm': pad(d.getMinutes()),\n    'ss': pad(d.getSeconds())\n  };\n\n  let result = format;\n  for (const [key, value] of Object.entries(replacements)) {\n    result = result.replace(new RegExp(key, 'g'), value);\n  }\n\n  return result;\n}\n\n/**\n * Check if a value is a valid Date object\n * @param date - The value to check for date validity\n * @returns True if the value is a valid Date object, false otherwise\n * @example\n * ```typescript\n * isDate(new Date()) // true\n * isDate('2023-12-25') // false (string, not Date object)\n * isDate(new Date('invalid')) // false (invalid date)\n * ```\n */\nexport function isDate (date: any): boolean {\n  return date instanceof Date && !isNaN(date.getTime());\n}\n\n/**\n * Get the current date and time, optionally formatted\n * @param format - Optional format string to apply to the current date\n * @returns Current date as Date object, or formatted string if format is provided\n * @example\n * ```typescript\n * now() // Date object for current time\n * now('DD/MM/YYYY HH:mm') // '25/12/2023 14:30'\n * ```\n */\nexport function now (format?: string): string | Date {\n  const currentDate = new Date();\n  return format ? formatDate(currentDate, format) : currentDate;\n}\n\n/**\n * Calculate the number of seconds remaining until tomorrow (midnight)\n * @returns Number of seconds until the next day begins\n * @example\n * ```typescript\n * // If current time is 23:30:00\n * secondsToTomorrow() // 1800 (30 minutes = 1800 seconds)\n * ```\n */\nexport function secondsToTomorrow (): number {\n  const now = new Date();\n  const tomorrow = new Date(now);\n  tomorrow.setDate(tomorrow.getDate() + 1);\n  tomorrow.setHours(0, 0, 0, 0);\n\n  return Math.floor((tomorrow.getTime() - now.getTime()) / 1000);\n}\n\n/**\n * Check if a given number differs from the current time's corresponding unit\n * @param nb - The number to compare against the current time unit\n * @param unit - The time unit to compare (hour, minute, second, day, month, year)\n * @returns True if the number differs from the current time's unit value\n * @example\n * ```typescript\n * // If current time is 14:30:45 on 25th December 2023\n * isDateDifferent(15, 'hour') // true (current hour is 14)\n * isDateDifferent(30, 'minute') // false (current minute is 30)\n * isDateDifferent(2023, 'year') // false (current year is 2023)\n * ```\n */\nexport function isDateDifferent (nb: number, unit: TimeUnit): boolean {\n  const now = new Date();\n\n  switch (unit) {\n    case 'hour':\n      return nb !== now.getHours();\n    case 'minute':\n      return nb !== now.getMinutes();\n    case 'second':\n      return nb !== now.getSeconds();\n    case 'day':\n      return nb !== now.getDate();\n    case 'month':\n      return nb !== now.getMonth() + 1;\n    case 'year':\n      return nb !== now.getFullYear();\n    default:\n      return false;\n  }\n}\n\n/**\n * Get the date/time format string for a specific country and format type\n * @param format - The type of format to retrieve (DATE, TIME, or DATE_TIME)\n * @param iso - The ISO country code\n * @returns The format string for the specified country and type, or null if not found\n * @example\n * ```typescript\n * getFormat('DATE', 'US') // 'MM/DD/YYYY'\n * getFormat('DATE', 'FR') // 'DD/MM/YYYY'\n * getFormat('TIME', 'US') // 'HH:mm:ss'\n * getFormat('DATE_TIME', 'DE') // 'DD.MM.YYYY, HH:mm:ss'\n * ```\n */\nexport function getFormat (format: FormatType, iso: CodeISO): string | null {\n  const dateFormats: Record<CodeISO, string> = {\n    AD: \"DD/MM/YYYY\", AT: \"DD.MM.YYYY\", BE: \"DD/MM/YYYY\", BG: \"DD.MM.YYYY\",\n    CH: \"DD.MM.YYYY\", CY: \"DD/MM/YYYY\", CZ: \"DD.MM.YYYY\", DE: \"DD.MM.YYYY\",\n    DK: \"DD.MM.YYYY\", EE: \"DD.MM.YYYY\", ES: \"DD/MM/YYYY\", FI: \"DD.MM.YYYY\",\n    FR: \"DD/MM/YYYY\", GB: \"DD/MM/YYYY\", GR: \"DD/MM/YYYY\", HR: \"DD.MM.YYYY\",\n    HU: \"YYYY.MM.DD.\", IE: \"DD/MM/YYYY\", IS: \"DD.MM.YYYY\", IT: \"DD/MM/YYYY\",\n    LI: \"DD.MM.YYYY\", LT: \"YYYY.MM.DD\", LU: \"DD/MM/YYYY\", LV: \"DD.MM.YYYY\",\n    MC: \"DD/MM/YYYY\", MT: \"DD/MM/YYYY\", NL: \"DD-MM-YYYY\", NO: \"DD.MM.YYYY\",\n    PL: \"DD.MM.YYYY\", PT: \"DD/MM/YYYY\", RO: \"DD.MM.YYYY\", SE: \"YYYY-MM-DD\",\n    SI: \"DD.MM.YYYY\", SK: \"DD.MM.YYYY\", SM: \"DD/MM/YYYY\", TR: \"DD.MM.YYYY\",\n    US: \"MM/DD/YYYY\", CA: \"MM/DD/YYYY\", JP: \"YYYY年MM月DD日\", CN: \"YYYY年MM月DD日\", KR: \"YYYY-MM-DD\"\n  };\n\n  const dateFormat = dateFormats[iso];\n\n  switch (format) {\n    case \"DATE\":\n      return dateFormat;\n    case \"TIME\":\n      return \"HH:mm:ss\";\n    case \"DATE_TIME\":\n      return `${dateFormat}, HH:mm:ss`;\n    default:\n      return null;\n  }\n}\n\n/**\n * Check if a date falls between two other dates (inclusive)\n * @param date - The date to check (Date object or date string)\n * @param start - The start date of the range (Date object or date string)\n * @param end - The end date of the range (Date object or date string)\n * @returns True if the date is between start and end dates (inclusive)\n * @example\n * ```typescript\n * isBetween('2023-12-25', '2023-12-01', '2023-12-31') // true\n * isBetween(new Date('2023-11-30'), '2023-12-01', '2023-12-31') // false\n * isBetween('2023-12-01', '2023-12-01', '2023-12-31') // true (inclusive)\n * ```\n */\nexport function isBetween (date: Date | string, start: Date | string, end: Date | string): boolean {\n  const d = new Date(date);\n  const s = new Date(start);\n  const e = new Date(end);\n\n  return d >= s && d <= e;\n}\n\n/**\n * Add a specified amount of time to a date\n * @param date - The base date to add time to (Date object or date string)\n * @param amount - The amount of time to add (can be negative to subtract)\n * @param unit - The time unit for the amount (millisecond, second, minute, hour, day, month, year)\n * @returns A new Date object with the added time\n * @example\n * ```typescript\n * addTime(new Date('2023-12-25'), 5, 'day') // 2023-12-30\n * addTime('2023-12-25T10:00:00', 2, 'hour') // 2023-12-25T12:00:00\n * addTime(new Date(), -1, 'month') // One month ago\n * addTime('2023-01-31', 1, 'month') // 2023-02-28 (handles month overflow)\n * ```\n */\nexport function addTime (date: Date | string, amount: number, unit: TimeUnit): Date {\n  const d = new Date(date);\n\n  switch (unit) {\n    case 'millisecond':\n      d.setMilliseconds(d.getMilliseconds() + amount);\n      break;\n    case 'second':\n      d.setSeconds(d.getSeconds() + amount);\n      break;\n    case 'minute':\n      d.setMinutes(d.getMinutes() + amount);\n      break;\n    case 'hour':\n      d.setHours(d.getHours() + amount);\n      break;\n    case 'day':\n      d.setDate(d.getDate() + amount);\n      break;\n    case 'month':\n      d.setMonth(d.getMonth() + amount);\n      break;\n    case 'year':\n      d.setFullYear(d.getFullYear() + amount);\n      break;\n  }\n\n  return d;\n}\n","/**\n * Math utility functions\n * No external dependencies - includes lodash-inspired methods\n * @since 0.8.0\n */\n\n/**\n * Adds two numbers together\n * @param a - The first number to add\n * @param b - The second number to add\n * @returns The sum of a and b\n * @since 0.8.0\n * @example\n * ```typescript\n * add(2, 3) // => 5\n * add(-1, 1) // => 0\n * ```\n */\nexport function add (a: number, b: number): number {\n  return a + b;\n}\n\n/**\n * Computes the sum of all values in an array\n * @param array - The array of numbers to sum\n * @returns The total sum of all numbers in the array, or 0 if array is empty\n * @since 0.8.0\n * @example\n * ```typescript\n * sum([1, 2, 3, 4]) // => 10\n * sum([]) // => 0\n * sum([-1, 1]) // => 0\n * ```\n */\nexport function sum (array: number[]): number {\n  return array.reduce((sum, value) => sum + value, 0);\n}\n\n/**\n * Computes the sum of all values in an array after applying an iteratee function to each element\n * @param array - The array to iterate over\n * @param iteratee - The function invoked per iteration, should return a number\n * @returns The total sum after applying the iteratee to each element\n * @since 0.8.0\n * @example\n * ```typescript\n * const objects = [{ n: 4 }, { n: 2 }, { n: 8 }];\n * sumBy(objects, o => o.n) // => 14\n * \n * const strings = ['a', 'bb', 'ccc'];\n * sumBy(strings, s => s.length) // => 6\n * ```\n */\nexport function sumBy<T> (array: T[], iteratee: (value: T) => number): number {\n  return array.reduce((sum, value) => sum + iteratee(value), 0);\n}\n\n/**\n * Computes the arithmetic mean (average) of all values in an array\n * @param array - The array of numbers to calculate the mean for\n * @returns The arithmetic mean of the array, or 0 if array is empty\n * @since 0.8.0\n * @example\n * ```typescript\n * mean([1, 2, 3, 4, 5]) // => 3\n * mean([10, 20]) // => 15\n * mean([]) // => 0\n * ```\n */\nexport function mean (array: number[]): number {\n  return array.length ? sum(array) / array.length : 0;\n}\n\n/**\n * Computes the arithmetic mean of all values in an array after applying an iteratee function\n * @param array - The array to iterate over\n * @param iteratee - The function invoked per iteration, should return a number\n * @returns The arithmetic mean after applying the iteratee to each element, or 0 if array is empty\n * @since 0.8.0\n * @example\n * ```typescript\n * const objects = [{ n: 4 }, { n: 2 }, { n: 8 }];\n * meanBy(objects, o => o.n) // => 4.666...\n * \n * const people = [{ age: 25 }, { age: 30 }, { age: 35 }];\n * meanBy(people, p => p.age) // => 30\n * ```\n */\nexport function meanBy<T> (array: T[], iteratee: (value: T) => number): number {\n  return array.length ? sumBy(array, iteratee) / array.length : 0;\n}\n\n/**\n * Finds the maximum value in an array of numbers\n * @param array - The array of numbers to search\n * @returns The maximum value in the array, or undefined if array is empty\n * @since 0.8.0\n * @example\n * ```typescript\n * max([1, 5, 3, 9, 2]) // => 9\n * max([-1, -5, -3]) // => -1\n * max([]) // => undefined\n * ```\n */\nexport function max (array: number[]): number | undefined {\n  return array.length ? Math.max(...array) : undefined;\n}\n\n/**\n * Finds the element in an array that produces the maximum value when passed through an iteratee function\n * @param array - The array to iterate over\n * @param iteratee - The function invoked per iteration, should return a number for comparison\n * @returns The element that produces the maximum value, or undefined if array is empty\n * @since 0.8.0\n * @example\n * ```typescript\n * const objects = [{ n: 1 }, { n: 9 }, { n: 3 }];\n * maxBy(objects, o => o.n) // => { n: 9 }\n * \n * const people = [{ name: 'John', age: 25 }, { name: 'Jane', age: 30 }];\n * maxBy(people, p => p.age) // => { name: 'Jane', age: 30 }\n * ```\n */\nexport function maxBy<T> (array: T[], iteratee: (value: T) => number): T | undefined {\n  if (!array.length) return undefined;\n\n  let maxItem = array[0];\n  let maxValue = iteratee(maxItem);\n\n  for (let i = 1; i < array.length; i++) {\n    const value = iteratee(array[i]);\n    if (value > maxValue) {\n      maxValue = value;\n      maxItem = array[i];\n    }\n  }\n\n  return maxItem;\n}\n\n/**\n * Finds the minimum value in an array of numbers\n * @param array - The array of numbers to search\n * @returns The minimum value in the array, or undefined if array is empty\n * @since 0.8.0\n * @example\n * ```typescript\n * min([1, 5, 3, 9, 2]) // => 1\n * min([-1, -5, -3]) // => -5\n * min([]) // => undefined\n * ```\n */\nexport function min (array: number[]): number | undefined {\n  return array.length ? Math.min(...array) : undefined;\n}\n\n/**\n * Finds the element in an array that produces the minimum value when passed through an iteratee function\n * @param array - The array to iterate over\n * @param iteratee - The function invoked per iteration, should return a number for comparison\n * @returns The element that produces the minimum value, or undefined if array is empty\n * @since 0.8.0\n * @example\n * ```typescript\n * const objects = [{ n: 1 }, { n: 9 }, { n: 3 }];\n * minBy(objects, o => o.n) // => { n: 1 }\n * \n * const people = [{ name: 'John', age: 25 }, { name: 'Jane', age: 30 }];\n * minBy(people, p => p.age) // => { name: 'John', age: 25 }\n * ```\n */\nexport function minBy<T> (array: T[], iteratee: (value: T) => number): T | undefined {\n  if (!array.length) return undefined;\n\n  let minItem = array[0];\n  let minValue = iteratee(minItem);\n\n  for (let i = 1; i < array.length; i++) {\n    const value = iteratee(array[i]);\n    if (value < minValue) {\n      minValue = value;\n      minItem = array[i];\n    }\n  }\n\n  return minItem;\n}\n\n/**\n * Subtracts the second number from the first number\n * @param a - The number to subtract from (minuend)\n * @param b - The number to subtract (subtrahend)\n * @returns The difference of a minus b\n * @since 0.8.0\n * @example\n * ```typescript\n * subtract(5, 3) // => 2\n * subtract(1, 4) // => -3\n * subtract(0, 0) // => 0\n * ```\n */\nexport function subtract (a: number, b: number): number {\n  return a - b;\n}\n\n/**\n * Multiplies two numbers together\n * @param a - The first number to multiply\n * @param b - The second number to multiply\n * @returns The product of a and b\n * @since 0.8.0\n * @example\n * ```typescript\n * multiply(3, 4) // => 12\n * multiply(-2, 5) // => -10\n * multiply(0, 100) // => 0\n * ```\n */\nexport function multiply (a: number, b: number): number {\n  return a * b;\n}\n\n/**\n * Divides the first number by the second number\n * @param a - The dividend (number to be divided)\n * @param b - The divisor (number to divide by)\n * @returns The quotient of a divided by b\n * @since 0.8.0\n * @example\n * ```typescript\n * divide(10, 2) // => 5\n * divide(7, 3) // => 2.333...\n * divide(1, 0) // => Infinity\n * ```\n */\nexport function divide (a: number, b: number): number {\n  return a / b;\n}\n\n/**\n * Rounds a number to a specified precision\n * @param number - The number to round\n * @param precision - The number of decimal places to round to (defaults to 0)\n * @returns The rounded number\n * @since 0.8.0\n * @example\n * ```typescript\n * round(4.006) // => 4\n * round(4.006, 2) // => 4.01\n * round(4060, -2) // => 4100\n * round(1.2345, 3) // => 1.235\n * ```\n */\nexport function round (number: number, precision: number = 0): number {\n  const factor = Math.pow(10, precision);\n  return Math.round(number * factor) / factor;\n}\n\n/**\n * Rounds a number up to a specified precision\n * @param number - The number to round up\n * @param precision - The number of decimal places to round to (defaults to 0)\n * @returns The rounded up number\n * @since 0.8.0\n * @example\n * ```typescript\n * ceil(4.006) // => 5\n * ceil(4.006, 2) // => 4.01\n * ceil(4040, -2) // => 4100\n * ceil(1.2345, 3) // => 1.235\n * ```\n */\nexport function ceil (number: number, precision: number = 0): number {\n  const factor = Math.pow(10, precision);\n  return Math.ceil(number * factor) / factor;\n}\n\n/**\n * Rounds a number down to a specified precision\n * @param number - The number to round down\n * @param precision - The number of decimal places to round to (defaults to 0)\n * @returns The rounded down number\n * @since 0.8.0\n * @example\n * ```typescript\n * floor(4.006) // => 4\n * floor(4.006, 2) // => 4.00\n * floor(4090, -2) // => 4000\n * floor(1.2345, 3) // => 1.234\n * ```\n */\nexport function floor (number: number, precision: number = 0): number {\n  const factor = Math.pow(10, precision);\n  return Math.floor(number * factor) / factor;\n}\n\n/**\n * Checks if a number is within a specified range (inclusive start, exclusive end)\n * @param n - The number to check\n * @param start - The start of the range (inclusive). If end is not specified, this becomes the end and start becomes 0\n * @param end - The end of the range (exclusive). Optional parameter\n * @returns True if the number is within the range, false otherwise\n * @since 0.8.0\n * @example\n * ```typescript\n * inRange(3, 2, 4) // => true\n * inRange(4, 8) // => true (equivalent to inRange(4, 0, 8))\n * inRange(4, 2) // => false\n * inRange(2, 2, 4) // => true (start is inclusive)\n * inRange(4, 2, 4) // => false (end is exclusive)\n * inRange(1.2, 2, 1) // => true (start and end are swapped automatically)\n * ```\n */\nexport function inRange (n: number, start: number, end?: number): boolean {\n  if (end === undefined) {\n    end = start;\n    start = 0;\n  }\n  if (start > end) {\n    [start, end] = [end, start];\n  }\n  return n >= start && n < end;\n}\n\n/**\n * Computes the standard deviation of an array of numbers\n * @param array - The array of numbers to calculate standard deviation for\n * @returns The standard deviation of the array, or 0 if array is empty\n * @since 0.9.0\n * @example\n * ```typescript\n * std([2, 4, 4, 4, 5, 5, 7, 9]) // => 2.138...\n * std([1, 1, 1, 1]) // => 0\n * std([]) // => 0\n * ```\n */\nexport function std (array: number[]): number {\n  if (array.length === 0) return 0;\n  const avg = mean(array);\n  const squareDiffs = array.map(value => Math.pow(value - avg, 2));\n  return Math.sqrt(mean(squareDiffs));\n}\n\n/**\n * Computes the variance of an array of numbers\n * @param array - The array of numbers to calculate variance for\n * @returns The variance of the array, or 0 if array is empty\n * @since 0.9.0\n * @example\n * ```typescript\n * variance([2, 4, 4, 4, 5, 5, 7, 9]) // => 4.571...\n * variance([1, 1, 1, 1]) // => 0\n * variance([]) // => 0\n * ```\n */\nexport function variance (array: number[]): number {\n  if (array.length === 0) return 0;\n  const avg = mean(array);\n  const squareDiffs = array.map(value => Math.pow(value - avg, 2));\n  return mean(squareDiffs);\n}","/**\n * Function utility functions\n * No external dependencies - includes lodash-inspired methods\n * @since 0.9.0\n */\n\n/**\n * Creates a function that invokes func with the this binding of thisArg and arguments of the created function\n * @param func - The function to bind\n * @param thisArg - The this binding of func\n * @param partials - The arguments to be partially applied\n * @returns Returns the new bound function\n * @since 0.9.0\n * @example\n * function greet(greeting, punctuation) {\n *   return greeting + ' ' + this.user + punctuation;\n * }\n * const object = { 'user': 'fred' };\n * const bound = bind(greet, object, 'hi');\n * bound('!'); // => 'hi fred!'\n */\nexport function bind<T extends (...args: any[]) => any> (func: T, thisArg: any, ...partials: any[]): T {\n  return function (this: any, ...args: any[]) {\n    return func.apply(thisArg, [...partials, ...args]);\n  } as T;\n}\n\n/**\n * Creates a function that invokes the method at object[key] with arguments\n * @param object - The object to query\n * @param key - The key of the method to bind\n * @param partials - The arguments to be partially applied\n * @returns Returns the new bound function\n * @throws {TypeError} Throws if the method is not a function\n * @since 0.9.0\n * @example\n * const object = {\n *   'user': 'fred',\n *   'greet': function(greeting, punctuation) {\n *     return greeting + ' ' + this.user + punctuation;\n *   }\n * };\n * const bound = bindKey(object, 'greet', 'hi');\n * bound('!'); // => 'hi fred!'\n */\nexport function bindKey<T> (object: T, key: keyof T, ...partials: any[]): (...args: any[]) => any {\n  return function (...args: any[]) {\n    const method = object[key];\n    if (typeof method === 'function') {\n      return (method as any).apply(object, [...partials, ...args]);\n    }\n    throw new TypeError(`${String(key)} is not a function`);\n  };\n}\n\n/**\n * Creates a function that accepts up to n arguments, ignoring any additional arguments\n * @param func - The function to cap arguments for\n * @param n - The arity cap (defaults to func.length)\n * @returns Returns the new capped function\n * @since 0.9.0\n * @example\n * ['6', '8', '10'].map(ary(parseInt, 1)); // => [6, 8, 10]\n */\nexport function ary<T extends (...args: any[]) => any> (func: T, n: number = func.length): (...args: any[]) => ReturnType<T> {\n  return function (...args: any[]) {\n    return func(...args.slice(0, n));\n  };\n}\n\n/**\n * Creates a function that invokes func with arguments reversed\n * @param func - The function to flip arguments for\n * @returns Returns the new flipped function\n * @since 0.9.0\n * @example\n * const flipped = flip(function(a, b, c) {\n *   return [a, b, c];\n * });\n * flipped('a', 'b', 'c'); // => ['c', 'b', 'a']\n */\nexport function flip<T extends (...args: any[]) => any> (func: T): (...args: Parameters<T>) => ReturnType<T> {\n  return function (...args: Parameters<T>) {\n    return func(...args.reverse());\n  };\n}\n\n/**\n * Creates a function that memoizes the result of func\n * @param func - The function to have its output memoized\n * @param resolver - The function to resolve the cache key (optional)\n * @returns Returns the new memoized function\n * @since 0.9.0\n * @example\n * const object = { 'a': 1, 'b': 2 };\n * const other = { 'c': 3, 'd': 4 };\n * const values = memoize(function(obj) { return Object.values(obj); });\n * values(object); // => [1, 2]\n * values(other); // => [3, 4]\n */\nexport function memoize<T extends (...args: any[]) => any> (func: T, resolver?: (...args: Parameters<T>) => any): T {\n  const cache = new Map();\n\n  const memoized = function (...args: Parameters<T>): ReturnType<T> {\n    const key = resolver ? resolver(...args) : JSON.stringify(args);\n\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n\n    const result = func(...args);\n    cache.set(key, result);\n    return result;\n  } as T;\n\n  (memoized as any).cache = cache;\n  return memoized;\n}\n\n/**\n * Creates a function that negates the result of the predicate func\n * @param predicate - The predicate to negate\n * @returns Returns the new negated function\n * @since 0.9.0\n * @example\n * function isEven(n) {\n *   return n % 2 == 0;\n * }\n * const isOdd = negate(isEven);\n * isOdd(3); // => true\n */\nexport function negate<T extends (...args: any[]) => boolean> (predicate: T): (...args: Parameters<T>) => boolean {\n  return function (...args: Parameters<T>) {\n    return !predicate(...args);\n  };\n}\n\n/**\n * Creates a function that is restricted to invoking func once\n * @param func - The function to restrict\n * @returns Returns the new restricted function\n * @since 0.9.0\n * @example\n * const initialize = once(createApplication);\n * initialize(); // creates the application\n * initialize(); // returns the cached result\n */\nexport function once<T extends (...args: any[]) => any> (func: T): T {\n  let called = false;\n  let result: ReturnType<T>;\n\n  return function (...args: Parameters<T>): ReturnType<T> {\n    if (!called) {\n      called = true;\n      result = func(...args);\n    }\n    return result;\n  } as T;\n}\n\n/**\n * Creates a function that invokes func with its arguments transformed\n * @param func - The function to wrap\n * @param transforms - The argument transforms\n * @returns Returns the new function\n * @since 0.9.0\n * @example\n * function doubled(n) {\n *   return n * 2;\n * }\n * function square(n) {\n *   return n * n;\n * }\n * const func = overArgs(function(x, y) {\n *   return [x, y];\n * }, square, doubled);\n * func(9, 3); // => [81, 6]\n */\nexport function overArgs<T extends (...args: any[]) => any> (func: T, ...transforms: ((...args: any[]) => any)[]): (...args: any[]) => ReturnType<T> {\n  return function (...args: any[]) {\n    const transformedArgs = args.map((arg, index) => {\n      const transform = transforms[index];\n      return transform ? transform(arg) : arg;\n    });\n    return func(...transformedArgs);\n  };\n}\n\n/**\n * Creates a function that invokes func with partials prepended to the arguments it receives\n * @param func - The function to partially apply arguments to\n * @param partials - The arguments to be partially applied\n * @returns Returns the new partially applied function\n * @since 0.9.0\n * @example\n * function greet(greeting, name) {\n *   return greeting + ' ' + name;\n * }\n * const sayHelloTo = partial(greet, 'hello');\n * sayHelloTo('fred'); // => 'hello fred'\n */\nexport function partial<T extends (...args: any[]) => any> (func: T, ...partials: any[]): (...args: any[]) => ReturnType<T> {\n  return function (...args: any[]) {\n    return func(...partials, ...args);\n  };\n}\n\n/**\n * Like partial except that partially applied arguments are appended to the arguments it receives\n * @param func - The function to partially apply arguments to\n * @param partials - The arguments to be partially applied\n * @returns Returns the new partially applied function\n * @since 0.9.0\n * @example\n * function greet(greeting, name) {\n *   return greeting + ' ' + name;\n * }\n * const greetFred = partialRight(greet, 'fred');\n * greetFred('hi'); // => 'hi fred'\n */\nexport function partialRight<T extends (...args: any[]) => any> (func: T, ...partials: any[]): (...args: any[]) => ReturnType<T> {\n  return function (...args: any[]) {\n    return func(...args, ...partials);\n  };\n}\n\n/**\n * Creates a function that invokes func with arguments arranged according to the specified indexes\n * @param func - The function to rearrange arguments for\n * @param indexes - The arranged argument indexes\n * @returns Returns the new function\n * @since 0.9.0\n * @example\n * const rearged = rearg(function(a, b, c) {\n *   return [a, b, c];\n * }, 2, 0, 1);\n * rearged('b', 'c', 'a'); // => ['a', 'b', 'c']\n */\nexport function rearg<T extends (...args: any[]) => any> (func: T, ...indexes: number[]): (...args: any[]) => ReturnType<T> {\n  return function (...args: any[]) {\n    const reorderedArgs = indexes.map(index => args[index]);\n    return func(...reorderedArgs);\n  };\n}\n\n/**\n * Creates a function that invokes func with the this binding of the created function and an array of arguments\n * @param func - The function to spread arguments over\n * @returns Returns the new function\n * @since 0.9.0\n * @example\n * const say = spread(function(who, what) {\n *   return who + ' says ' + what;\n * });\n * say(['fred', 'hello']); // => 'fred says hello'\n */\nexport function spread<T extends (args: any[]) => any> (func: T): (...args: any[]) => ReturnType<T> {\n  return function (...args: any[]) {\n    return func(args);\n  };\n}\n\n/**\n * Creates a throttled function that only invokes func at most once per every wait milliseconds\n * @param func - The function to throttle\n * @param wait - The number of milliseconds to throttle invocations to\n * @param options - The options object\n * @param options.leading - Specify invoking on the leading edge of the timeout (default: true)\n * @param options.trailing - Specify invoking on the trailing edge of the timeout (default: true)\n * @returns Returns the new throttled function\n * @since 0.9.0\n * @example\n * // Avoid excessively updating the position while scrolling.\n * const throttled = throttle(updatePosition, 100);\n * window.addEventListener('scroll', throttled);\n */\nexport function throttle<T extends (...args: any[]) => any> (func: T, wait: number, options: { leading?: boolean; trailing?: boolean } = {}): T & { cancel (): void; flush (): ReturnType<T> | undefined } {\n  let timeout: NodeJS.Timeout | null = null;\n  let lastCallTime = 0;\n  let lastArgs: Parameters<T> | null = null;\n  let result: ReturnType<T>;\n\n  const { leading = true, trailing = true } = options;\n\n  function invokeFunc () {\n    if (lastArgs) {\n      result = func(...lastArgs);\n      lastArgs = null;\n    }\n    return result;\n  }\n\n  function leadingEdge () {\n    lastCallTime = Date.now();\n    if (leading) {\n      return invokeFunc();\n    }\n    return result;\n  }\n\n  function trailingEdge () {\n    timeout = null;\n    if (trailing && lastArgs) {\n      return invokeFunc();\n    }\n    lastArgs = null;\n    return result;\n  }\n\n  const throttled = function (...args: Parameters<T>): ReturnType<T> {\n    const now = Date.now();\n\n    if (!lastCallTime && !leading) {\n      lastCallTime = now;\n    }\n\n    const remaining = wait - (now - lastCallTime);\n    lastArgs = args;\n\n    if (remaining <= 0 || remaining > wait) {\n      if (timeout) {\n        clearTimeout(timeout);\n        timeout = null;\n      }\n      lastCallTime = now;\n      return invokeFunc();\n    } else if (!timeout && trailing) {\n      timeout = setTimeout(trailingEdge, remaining);\n    }\n\n    return result;\n  } as T & { cancel (): void; flush (): ReturnType<T> | undefined };\n\n  throttled.cancel = function () {\n    if (timeout) {\n      clearTimeout(timeout);\n      timeout = null;\n    }\n    lastCallTime = 0;\n    lastArgs = null;\n  };\n\n  throttled.flush = function () {\n    return timeout ? trailingEdge() : result;\n  };\n\n  return throttled;\n}\n\n/**\n * Creates a debounced function that delays invoking func until after wait milliseconds have elapsed\n * @param func - The function to debounce\n * @param wait - The number of milliseconds to delay\n * @param options - The options object\n * @param options.leading - Specify invoking on the leading edge of the timeout (default: false)\n * @param options.trailing - Specify invoking on the trailing edge of the timeout (default: true)\n * @param options.maxWait - The maximum time func is allowed to be delayed before it's invoked\n * @returns Returns the new debounced function\n * @since 0.9.0\n * @example\n * // Avoid costly calculations while the window size is in flux.\n * const debounced = debounce(calculateLayout, 150);\n * window.addEventListener('resize', debounced);\n */\nexport function debounce<T extends (...args: any[]) => any> (func: T, wait: number, options: { leading?: boolean; trailing?: boolean; maxWait?: number } = {}): T & { cancel (): void; flush (): ReturnType<T> | undefined; pending (): boolean } {\n  let timeout: NodeJS.Timeout | null = null;\n  let maxTimeout: NodeJS.Timeout | null = null;\n  let lastCallTime = 0;\n  let lastInvokeTime = 0;\n  let lastArgs: Parameters<T> | null = null;\n  let result: ReturnType<T>;\n\n  const { leading = false, trailing = true, maxWait } = options;\n\n  function invokeFunc () {\n    if (lastArgs) {\n      const args = lastArgs;\n      lastArgs = null;\n      lastInvokeTime = Date.now();\n      result = func(...args);\n    }\n    return result;\n  }\n\n  function leadingEdge () {\n    lastInvokeTime = Date.now();\n    if (leading) {\n      return invokeFunc();\n    }\n    return result;\n  }\n\n  function trailingEdge () {\n    timeout = null;\n    if (trailing && lastArgs) {\n      return invokeFunc();\n    }\n    lastArgs = null;\n    return result;\n  }\n\n  function timerExpired () {\n    const time = Date.now();\n    if (shouldInvoke(time)) {\n      return trailingEdge();\n    }\n    timeout = setTimeout(timerExpired, remainingWait(time));\n    return result;\n  }\n\n  function shouldInvoke (time: number) {\n    const timeSinceLastCall = time - lastCallTime;\n    const timeSinceLastInvoke = time - lastInvokeTime;\n\n    return (\n      !lastCallTime ||\n      timeSinceLastCall >= wait ||\n      timeSinceLastCall < 0 ||\n      (maxWait !== undefined && timeSinceLastInvoke >= maxWait)\n    );\n  }\n\n  function remainingWait (time: number) {\n    const timeSinceLastCall = time - lastCallTime;\n    const timeSinceLastInvoke = time - lastInvokeTime;\n    const timeWaiting = wait - timeSinceLastCall;\n\n    return maxWait !== undefined\n      ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function cancel () {\n    if (timeout) {\n      clearTimeout(timeout);\n      timeout = null;\n    }\n    if (maxTimeout) {\n      clearTimeout(maxTimeout);\n      maxTimeout = null;\n    }\n    lastCallTime = 0;\n    lastInvokeTime = 0;\n    lastArgs = null;\n  }\n\n  function flush () {\n    return timeout ? trailingEdge() : result;\n  }\n\n  function pending () {\n    return timeout !== null;\n  }\n\n  const debounced = function (...args: Parameters<T>): ReturnType<T> {\n    const time = Date.now();\n    const isInvoking = shouldInvoke(time);\n\n    lastArgs = args;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (!timeout) {\n        return leadingEdge();\n      }\n      if (maxWait) {\n        timeout = setTimeout(timerExpired, wait);\n        return invokeFunc();\n      }\n    }\n\n    if (!timeout) {\n      timeout = setTimeout(timerExpired, wait);\n    }\n\n    return result;\n  } as T & { cancel (): void; flush (): ReturnType<T> | undefined; pending (): boolean };\n\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  debounced.pending = pending;\n\n  return debounced;\n}\n\n/**\n * Creates a function that accepts up to one argument, ignoring any additional arguments\n * @param func - The function to cap arguments for\n * @returns Returns the new capped function\n * @since 0.9.0\n * @example\n * ['6', '8', '10'].map(unary(parseInt)); // => [6, 8, 10]\n */\nexport function unary<T extends (...args: any[]) => any> (func: T): (arg: Parameters<T>[0]) => ReturnType<T> {\n  return function (arg: Parameters<T>[0]) {\n    return func(arg);\n  };\n}\n\n/**\n * Creates a function that provides value to wrapper as its first argument\n * @param value - The value to wrap\n * @param wrapper - The wrapper function\n * @returns Returns the new function\n * @since 0.9.0\n * @example\n * const p = wrap('hello', function(greeting, name) {\n *   return greeting + ' ' + name;\n * });\n * p('world'); // => 'hello world'\n */\nexport function wrap<T, R> (value: T, wrapper: (value: T, ...args: any[]) => R): (...args: any[]) => R {\n  return function (...args: any[]) {\n    return wrapper(value, ...args);\n  };\n}\n\n/**\n * Creates a function that accepts arguments of func and either invokes func returning its result,\n * if at least arity number of arguments have been provided, or returns a function that accepts\n * the remaining func arguments\n * @param func - The function to curry\n * @param arity - The arity of func (defaults to func.length)\n * @returns Returns the new curried function\n * @since 0.9.0\n * @example\n * const abc = function(a, b, c) {\n *   return [a, b, c];\n * };\n * const curried = curry(abc);\n * curried(1)(2)(3); // => [1, 2, 3]\n * curried(1, 2)(3); // => [1, 2, 3]\n * curried(1, 2, 3); // => [1, 2, 3]\n */\nexport function curry<T extends (...args: any[]) => any> (func: T, arity: number = func.length): any {\n  return function curried (this: any, ...args: any[]): any {\n    if (args.length >= arity) {\n      return func.apply(this, args);\n    } else {\n      return function (this: any, ...args2: any[]) {\n        return curried.apply(this, args.concat(args2));\n      };\n    }\n  };\n}\n\n/**\n * This method is like curry except that arguments are applied to func in the manner of partialRight instead of partial\n * @param func - The function to curry\n * @param arity - The arity of func (defaults to func.length)\n * @returns Returns the new curried function\n * @since 0.9.0\n * @example\n * const abc = function(a, b, c) {\n *   return [a, b, c];\n * };\n * const curried = curryRight(abc);\n * curried(3)(2)(1); // => [1, 2, 3]\n * curried(2, 3)(1); // => [1, 2, 3]\n * curried(1, 2, 3); // => [1, 2, 3]\n */\nexport function curryRight<T extends (...args: any[]) => any> (func: T, arity: number = func.length): any {\n  return function curried (this: any, ...args: any[]): any {\n    if (args.length >= arity) {\n      return func.apply(this, args);\n    } else {\n      return function (this: any, ...args2: any[]) {\n        return curried.apply(this, args2.concat(args));\n      };\n    }\n  };\n}\n\n/**\n * Creates a function that invokes func with arguments arranged according to the specified indexes\n * where the argument value at the first index is provided as the first argument\n * @param func - The function to change the argument order for\n * @param start - The start position of the rest parameter (defaults to func.length - 1)\n * @returns Returns the new function\n * @since 0.9.0\n * @example\n * const say = rest(function(what, names) {\n *   return what + ' ' + names.join(', ');\n * });\n * say('hello', 'fred', 'barney', 'pebbles'); // => 'hello fred, barney, pebbles'\n */\nexport function rest<T extends (...args: any[]) => any> (func: T, start: number = func.length - 1): (...args: any[]) => ReturnType<T> {\n  return function (...args: any[]) {\n    const restArgs = args.slice(start);\n    const normalArgs = args.slice(0, start);\n    return func(...normalArgs, restArgs);\n  };\n}","/**\n * Collection utility functions (arrays and objects)\n * No external dependencies - includes lodash-inspired methods\n * @since 0.9.0\n */\n\n/**\n * Checks if predicate returns truthy for all elements of collection.\n * Iteration is stopped once predicate returns falsy.\n * \n * @param collection - The collection to iterate over (array or object)\n * @param predicate - The function invoked per iteration\n * @returns Returns true if all elements pass the predicate check, else false\n * @since 0.9.0\n * \n * @example\n * every([2, 4, 6], x => x % 2 === 0) // => true\n * every({a: 2, b: 4, c: 5}, x => x % 2 === 0) // => false\n */\nexport function every<T> (collection: T[], predicate: (value: T, index: number, collection: T[]) => boolean): boolean;\nexport function every<T> (collection: Record<string, T>, predicate: (value: T, key: string, collection: Record<string, T>) => boolean): boolean;\nexport function every<T> (collection: T[] | Record<string, T>, predicate: any): boolean {\n  if (Array.isArray(collection)) {\n    return collection.every(predicate);\n  }\n  return Object.entries(collection).every(([key, value]) => predicate(value, key, collection));\n}\n\n/**\n * Iterates over elements of collection and invokes iteratee for each element.\n * The iteratee is invoked with three arguments: (value, index|key, collection).\n * \n * @param collection - The collection to iterate over (array or object)\n * @param iteratee - The function invoked per iteration\n * @returns Returns the original collection\n * @since 0.9.0\n * \n * @example\n * forEach([1, 2], value => console.log(value))\n * forEach({a: 1, b: 2}, (value, key) => console.log(key, value))\n */\nexport function forEach<T> (collection: T[], iteratee: (value: T, index: number, collection: T[]) => void): T[];\nexport function forEach<T> (collection: Record<string, T>, iteratee: (value: T, key: string, collection: Record<string, T>) => void): Record<string, T>;\nexport function forEach<T> (collection: T[] | Record<string, T>, iteratee: any): T[] | Record<string, T> {\n  if (Array.isArray(collection)) {\n    collection.forEach(iteratee);\n    return collection;\n  }\n  Object.entries(collection).forEach(([key, value]) => iteratee(value, key, collection));\n  return collection;\n}\n\n/**\n * Creates an array of values by running each element in collection through iteratee.\n * The iteratee is invoked with three arguments: (value, index|key, collection).\n * \n * @param collection - The collection to iterate over (array or object)\n * @param iteratee - The function invoked per iteration\n * @returns Returns the new mapped array\n * @since 0.9.0\n * \n * @example\n * map([1, 2, 3], x => x * 2) // => [2, 4, 6]\n * map({a: 1, b: 2}, x => x * 2) // => [2, 4]\n */\nexport function map<T, R> (collection: T[], iteratee: (value: T, index: number, collection: T[]) => R): R[];\nexport function map<T, R> (collection: Record<string, T>, iteratee: (value: T, key: string, collection: Record<string, T>) => R): R[];\nexport function map<T, R> (collection: T[] | Record<string, T>, iteratee: any): R[] {\n  if (Array.isArray(collection)) {\n    return collection.map(iteratee);\n  }\n  return Object.entries(collection).map(([key, value]) => iteratee(value, key, collection));\n}\n\n/**\n * Iterates over elements of collection, returning an array of all elements predicate returns truthy for.\n * The predicate is invoked with three arguments: (value, index|key, collection).\n * \n * @param collection - The collection to iterate over (array or object)\n * @param predicate - The function invoked per iteration\n * @returns Returns the new filtered array\n * @since 0.9.0\n * \n * @example\n * filter([1, 2, 3, 4], x => x % 2 === 0) // => [2, 4]\n * filter({a: 1, b: 2, c: 3}, x => x > 1) // => [2, 3]\n */\nexport function filter<T> (collection: T[], predicate: (value: T, index: number, collection: T[]) => boolean): T[];\nexport function filter<T> (collection: Record<string, T>, predicate: (value: T, key: string, collection: Record<string, T>) => boolean): T[];\nexport function filter<T> (collection: T[] | Record<string, T>, predicate: any): T[] {\n  if (Array.isArray(collection)) {\n    return collection.filter(predicate);\n  }\n  return Object.entries(collection)\n    .filter(([key, value]) => predicate(value, key, collection))\n    .map(([_, value]) => value);\n}\n\n/**\n * Iterates over elements of collection, returning the first element predicate returns truthy for.\n * The predicate is invoked with three arguments: (value, index|key, collection).\n * \n * @param collection - The collection to inspect (array or object)\n * @param predicate - The function invoked per iteration\n * @returns Returns the matched element, else undefined\n * @since 0.9.0\n * \n * @example\n * find([1, 2, 3, 4], x => x > 2) // => 3\n * find({a: 1, b: 2, c: 3}, x => x > 2) // => 3\n */\nexport function find<T> (collection: T[], predicate: (value: T, index: number, collection: T[]) => boolean): T | undefined;\nexport function find<T> (collection: Record<string, T>, predicate: (value: T, key: string, collection: Record<string, T>) => boolean): T | undefined;\nexport function find<T> (collection: T[] | Record<string, T>, predicate: any): T | undefined {\n  if (Array.isArray(collection)) {\n    return collection.find(predicate);\n  }\n  for (const [key, value] of Object.entries(collection)) {\n    if (predicate(value, key, collection)) {\n      return value;\n    }\n  }\n  return undefined;\n}\n\n/**\n * This method is like find except that it returns the key of the first element \n * predicate returns truthy for instead of the element itself.\n * \n * @param collection - The collection to inspect\n * @param predicate - The function invoked per iteration\n * @returns Returns the key of the matched element, else undefined\n * @since 0.9.0\n * \n * @example\n * findKey({a: 1, b: 2, c: 3}, x => x > 2) // => 'c'\n */\nexport function findKey<T> (collection: Record<string, T>, predicate: (value: T, key: string, collection: Record<string, T>) => boolean): string | undefined {\n  for (const [key, value] of Object.entries(collection)) {\n    if (predicate(value, key, collection)) {\n      return key;\n    }\n  }\n  return undefined;\n}\n\n/**\n * This method is like find except that it iterates over elements of collection from right to left.\n * \n * @param collection - The collection to inspect (array or object)\n * @param predicate - The function invoked per iteration\n * @returns Returns the matched element, else undefined\n * @since 0.9.0\n * \n * @example\n * findLast([1, 2, 3, 4], x => x % 2 === 1) // => 3\n */\nexport function findLast<T> (collection: T[], predicate: (value: T, index: number, collection: T[]) => boolean): T | undefined;\nexport function findLast<T> (collection: Record<string, T>, predicate: (value: T, key: string, collection: Record<string, T>) => boolean): T | undefined;\nexport function findLast<T> (collection: T[] | Record<string, T>, predicate: any): T | undefined {\n  if (Array.isArray(collection)) {\n    for (let i = collection.length - 1; i >= 0; i--) {\n      if (predicate(collection[i], i, collection)) {\n        return collection[i];\n      }\n    }\n    return undefined;\n  }\n  const entries = Object.entries(collection).reverse();\n  for (const [key, value] of entries) {\n    if (predicate(value, key, collection)) {\n      return value;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Creates a flattened array of values by running each element in collection through iteratee \n * and flattening the mapped results. The iteratee is invoked with three arguments: \n * (value, index|key, collection).\n * \n * @param collection - The collection to iterate over (array or object)\n * @param iteratee - The function invoked per iteration\n * @returns Returns the new flattened array\n * @since 0.9.0\n * \n * @example\n * flatMap([1, 2], x => [x, x]) // => [1, 1, 2, 2]\n */\nexport function flatMap<T, R> (collection: T[], iteratee: (value: T, index: number, collection: T[]) => R | R[]): R[];\nexport function flatMap<T, R> (collection: Record<string, T>, iteratee: (value: T, key: string, collection: Record<string, T>) => R | R[]): R[];\nexport function flatMap<T, R> (collection: T[] | Record<string, T>, iteratee: any): R[] {\n  if (Array.isArray(collection)) {\n    return map<T, R | R[]>(collection, iteratee).flat() as R[];\n  } else {\n    return map<T, R | R[]>(collection as Record<string, T>, iteratee).flat() as R[];\n  }\n}\n\n/**\n * This method is like flatMap except that it recursively flattens the mapped results.\n * \n * @param collection - The collection to iterate over (array or object)\n * @param iteratee - The function invoked per iteration\n * @returns Returns the new flattened array\n * @since 0.9.0\n * \n * @example\n * flatMapDeep([1, 2], x => [x, [x]]) // => [1, 1, 2, 2]\n */\nexport function flatMapDeep<T, R> (collection: T[], iteratee: (value: T, index: number, collection: T[]) => any): R[];\nexport function flatMapDeep<T, R> (collection: Record<string, T>, iteratee: (value: T, key: string, collection: Record<string, T>) => any): R[];\nexport function flatMapDeep<T, R> (collection: T[] | Record<string, T>, iteratee: any): R[] {\n  if (Array.isArray(collection)) {\n    return map<T, any>(collection, iteratee).flat(Infinity) as R[];\n  } else {\n    return map<T, any>(collection as Record<string, T>, iteratee).flat(Infinity) as R[];\n  }\n}\n\n/**\n * Creates an object composed of keys generated from the results of running each element \n * of collection through iteratee. The order of grouped values is determined by the order \n * they occur in collection.\n * \n * @param collection - The collection to iterate over (array or object)\n * @param iteratee - The iteratee to transform keys\n * @returns Returns the composed aggregate object\n * @since 0.9.0\n * \n * @example\n * groupBy(['one', 'two', 'three'], x => x.length) // => {3: ['one', 'two'], 5: ['three']}\n */\nexport function groupBy<T> (collection: T[], iteratee: (value: T) => string): Record<string, T[]>;\nexport function groupBy<T> (collection: Record<string, T>, iteratee: (value: T) => string): Record<string, T[]>;\nexport function groupBy<T> (collection: T[] | Record<string, T>, iteratee: (value: T) => string): Record<string, T[]> {\n  const result: Record<string, T[]> = {};\n  const values = Array.isArray(collection) ? collection : Object.values(collection);\n\n  for (const item of values) {\n    const key = iteratee(item);\n    if (!result[key]) {\n      result[key] = [];\n    }\n    result[key].push(item);\n  }\n\n  return result;\n}\n\n/**\n * Checks if value is in collection. If collection is a string, it's checked for a substring of value,\n * otherwise SameValueZero is used for equality comparisons.\n * \n * @param collection - The collection to inspect\n * @param value - The value to search for\n * @param fromIndex - The index to search from\n * @returns Returns true if value is found, else false\n * @since 0.9.0\n * \n * @example\n * includes([1, 2, 3], 1) // => true\n * includes({a: 1, b: 2}, 1) // => true\n * includes('hello', 'ell') // => true\n */\nexport function includes<T> (collection: T[] | Record<string, T> | string, value: T, fromIndex: number = 0): boolean {\n  if (typeof collection === 'string') {\n    return collection.indexOf(value as any, fromIndex) !== -1;\n  }\n  if (Array.isArray(collection)) {\n    return collection.indexOf(value, fromIndex) !== -1;\n  }\n  return Object.values(collection).includes(value);\n}\n\n/**\n * Invokes the method at path of each element in collection, returning an array of the results \n * of each invoked method. Any additional arguments are provided to each invoked method.\n * \n * @param collection - The collection to iterate over\n * @param path - The path of the method to invoke\n * @param args - The arguments to invoke each method with\n * @returns Returns the array of results\n * @since 0.9.0\n * \n * @example\n * invokeMap([[5, 1, 7], [3, 2, 1]], 'sort') // => [[1, 5, 7], [1, 2, 3]]\n */\nexport function invokeMap<T> (collection: T[], path: string, ...args: any[]): any[] {\n  return collection.map(item => {\n    const method = (item as any)[path];\n    return typeof method === 'function' ? method.apply(item, args) : undefined;\n  });\n}\n\n/**\n * Creates an object composed of keys generated from the results of running each element \n * of collection through iteratee. The corresponding value of each key is the last element \n * responsible for generating the key.\n * \n * @param collection - The collection to iterate over (array or object)\n * @param iteratee - The iteratee to transform keys\n * @returns Returns the composed aggregate object\n * @since 0.9.0\n * \n * @example\n * keyBy([{id: 'a', dir: 'left'}, {id: 'b', dir: 'right'}], x => x.id) \n * // => {a: {id: 'a', dir: 'left'}, b: {id: 'b', dir: 'right'}}\n */\nexport function keyBy<T> (collection: T[], iteratee: (value: T) => string): Record<string, T>;\nexport function keyBy<T> (collection: Record<string, T>, iteratee: (value: T) => string): Record<string, T>;\nexport function keyBy<T> (collection: T[] | Record<string, T>, iteratee: (value: T) => string): Record<string, T> {\n  const result: Record<string, T> = {};\n  const values = Array.isArray(collection) ? collection : Object.values(collection);\n\n  for (const item of values) {\n    const key = iteratee(item);\n    result[key] = item;\n  }\n\n  return result;\n}\n\n/**\n * Creates an array of elements, sorted in ascending or descending order by the results \n * of running each element in a collection through each iteratee.\n * \n * @param collection - The collection to iterate over\n * @param iteratees - The iteratees to sort by\n * @param orders - The sort orders of iteratees\n * @returns Returns the new sorted array\n * @since 0.9.0\n * \n * @example\n * orderBy([{user: 'fred', age: 48}, {user: 'barney', age: 36}], \n *         [x => x.user], ['desc']) \n * // => [{user: 'fred', age: 48}, {user: 'barney', age: 36}]\n */\nexport function orderBy<T> (collection: T[], iteratees: ((item: T) => any)[], orders: ('asc' | 'desc')[] = []): T[] {\n  return [...collection].sort((a, b) => {\n    for (let i = 0; i < iteratees.length; i++) {\n      const iteratee = iteratees[i];\n      const order = orders[i] || 'asc';\n\n      const aVal = iteratee(a);\n      const bVal = iteratee(b);\n\n      if (aVal < bVal) {\n        return order === 'asc' ? -1 : 1;\n      }\n      if (aVal > bVal) {\n        return order === 'asc' ? 1 : -1;\n      }\n    }\n    return 0;\n  });\n}\n\n/**\n * Creates an array of elements split into two groups, the first of which contains elements \n * predicate returns truthy for, the second of which contains elements predicate returns falsy for.\n * \n * @param collection - The collection to iterate over\n * @param predicate - The function invoked per iteration\n * @returns Returns the array of grouped elements\n * @since 0.9.0\n * \n * @example\n * partition([1, 2, 3, 4], x => x % 2) // => [[1, 3], [2, 4]]\n */\nexport function partition<T> (collection: T[], predicate: (value: T) => boolean): [T[], T[]] {\n  const truthy: T[] = [];\n  const falsy: T[] = [];\n\n  for (const item of collection) {\n    if (predicate(item)) {\n      truthy.push(item);\n    } else {\n      falsy.push(item);\n    }\n  }\n\n  return [truthy, falsy];\n}\n\n/**\n * Reduces collection to a value which is the accumulated result of running each element \n * in collection through iteratee, where each successive invocation is supplied the return \n * value of the previous.\n * \n * @param collection - The collection to iterate over (array or object)\n * @param iteratee - The function invoked per iteration\n * @param accumulator - The initial value\n * @returns Returns the accumulated value\n * @since 0.9.0\n * \n * @example\n * reduce([1, 2], (sum, n) => sum + n, 0) // => 3\n * reduce({a: 1, b: 2, c: 1}, (result, value, key) => { ... }, {})\n */\nexport function reduce<T, R> (collection: T[], iteratee: (accumulator: R, value: T, index: number, collection: T[]) => R, accumulator: R): R;\nexport function reduce<T, R> (collection: Record<string, T>, iteratee: (accumulator: R, value: T, key: string, collection: Record<string, T>) => R, accumulator: R): R;\nexport function reduce<T, R> (collection: T[] | Record<string, T>, iteratee: any, accumulator: R): R {\n  if (Array.isArray(collection)) {\n    return collection.reduce(iteratee, accumulator);\n  }\n  let result = accumulator;\n  for (const [key, value] of Object.entries(collection)) {\n    result = iteratee(result, value, key, collection);\n  }\n  return result;\n}\n\n/**\n * This method is like reduce except that it iterates over elements of collection from right to left.\n * \n * @param collection - The collection to iterate over\n * @param iteratee - The function invoked per iteration\n * @param accumulator - The initial value\n * @returns Returns the accumulated value\n * @since 0.9.0\n * \n * @example\n * reduceRight([1, 2, 3], (acc, n) => acc.concat(n), []) // => [3, 2, 1]\n */\nexport function reduceRight<T, R> (collection: T[], iteratee: (accumulator: R, value: T, index: number, collection: T[]) => R, accumulator: R): R {\n  return collection.reduceRight(iteratee, accumulator);\n}\n\n/**\n * The opposite of filter; this method returns the elements of collection that predicate \n * does not return truthy for.\n * \n * @param collection - The collection to iterate over (array or object)\n * @param predicate - The function invoked per iteration\n * @returns Returns the new filtered array\n * @since 0.9.0\n * \n * @example\n * reject([1, 2, 3, 4], x => x % 2 === 0) // => [1, 3]\n */\nexport function reject<T> (collection: T[], predicate: (value: T, index: number, collection: T[]) => boolean): T[];\nexport function reject<T> (collection: Record<string, T>, predicate: (value: T, key: string, collection: Record<string, T>) => boolean): T[];\nexport function reject<T> (collection: T[] | Record<string, T>, predicate: any): T[] {\n  if (Array.isArray(collection)) {\n    return collection.filter((value, index, collection) => !predicate(value, index, collection));\n  }\n  return Object.entries(collection)\n    .filter(([key, value]) => !predicate(value, key, collection))\n    .map(([_, value]) => value);\n}\n\n/**\n * Gets a random element from collection.\n * \n * @param collection - The collection to sample\n * @returns Returns the random element\n * @since 0.9.0\n * \n * @example\n * sample([1, 2, 3, 4]) // => 2\n * sample({a: 1, b: 2, c: 3}) // => 2\n */\nexport function sample<T> (collection: T[] | Record<string, T>): T | undefined {\n  if (Array.isArray(collection)) {\n    return collection[Math.floor(Math.random() * collection.length)];\n  }\n  const values = Object.values(collection);\n  return values[Math.floor(Math.random() * values.length)];\n}\n\n/**\n * Gets n random elements at unique keys from collection up to the size of collection.\n * \n * @param collection - The collection to sample\n * @param n - The number of elements to sample\n * @returns Returns the random elements\n * @since 0.9.0\n * \n * @example\n * sampleSize([1, 2, 3], 2) // => [3, 1]\n * sampleSize([1, 2, 3], 4) // => [2, 3, 1]\n */\nexport function sampleSize<T> (collection: T[] | Record<string, T>, n: number): T[] {\n  const values = Array.isArray(collection) ? collection : Object.values(collection);\n  const result: T[] = [];\n  const indices = new Set<number>();\n\n  while (result.length < n && result.length < values.length) {\n    const randomIndex = Math.floor(Math.random() * values.length);\n    if (!indices.has(randomIndex)) {\n      indices.add(randomIndex);\n      result.push(values[randomIndex]);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Creates an array of shuffled values, using a version of the Fisher-Yates shuffle.\n * \n * @param collection - The collection to shuffle\n * @returns Returns the new shuffled array\n * @since 0.9.0\n * \n * @example\n * shuffle([1, 2, 3, 4]) // => [4, 1, 3, 2]\n */\nexport function shuffle<T> (collection: T[] | Record<string, T>): T[] {\n  const values = Array.isArray(collection) ? [...collection] : Object.values(collection);\n  for (let i = values.length - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    [values[i], values[j]] = [values[j], values[i]];\n  }\n  return values;\n}\n\n/**\n * Gets the size of collection by returning its length for array-like values or the number \n * of own enumerable string keyed properties for objects.\n * \n * @param collection - The collection to inspect\n * @returns Returns the collection size\n * @since 0.9.0\n * \n * @example\n * size([1, 2, 3]) // => 3\n * size({a: 1, b: 2}) // => 2\n * size('pebbles') // => 7\n */\nexport function size<T> (collection: T[] | Record<string, T> | string): number {\n  if (typeof collection === 'string' || Array.isArray(collection)) {\n    return collection.length;\n  }\n  return Object.keys(collection).length;\n}\n\n/**\n * Checks if predicate returns truthy for any element of collection. Iteration is stopped \n * once predicate returns truthy.\n * \n * @param collection - The collection to iterate over (array or object)\n * @param predicate - The function invoked per iteration\n * @returns Returns true if any element passes the predicate check, else false\n * @since 0.9.0\n * \n * @example\n * some([null, 0, 'yes', false], Boolean) // => true\n * some({a: null, b: 0, c: 'yes'}, Boolean) // => true\n */\nexport function some<T> (collection: T[], predicate: (value: T, index: number, collection: T[]) => boolean): boolean;\nexport function some<T> (collection: Record<string, T>, predicate: (value: T, key: string, collection: Record<string, T>) => boolean): boolean;\nexport function some<T> (collection: T[] | Record<string, T>, predicate: any): boolean {\n  if (Array.isArray(collection)) {\n    return collection.some(predicate);\n  }\n  return Object.entries(collection).some(([key, value]) => predicate(value, key, collection));\n}\n\n/**\n * Creates an array of elements, sorted in ascending order by the results of running \n * each element in a collection through each iteratee.\n * \n * @param collection - The collection to iterate over\n * @param iteratees - The iteratees to sort by\n * @returns Returns the new sorted array\n * @since 0.9.0\n * \n * @example\n * sortBy([{user: 'fred', age: 48}, {user: 'barney', age: 36}], x => x.age)\n * // => [{user: 'barney', age: 36}, {user: 'fred', age: 48}]\n */\nexport function sortBy<T> (collection: T[], ...iteratees: ((item: T) => any)[]): T[] {\n  return [...collection].sort((a, b) => {\n    for (const iteratee of iteratees) {\n      const aVal = iteratee(a);\n      const bVal = iteratee(b);\n\n      if (aVal < bVal) return -1;\n      if (aVal > bVal) return 1;\n    }\n    return 0;\n  });\n}\n\n/**\n * Creates an object composed of keys generated from the results of running each element \n * of collection through iteratee. The corresponding value of each key is the number of \n * times the key was returned by iteratee.\n * \n * @param collection - The collection to iterate over (array or object)\n * @param iteratee - The iteratee to transform keys\n * @returns Returns the composed aggregate object\n * @since 0.9.0\n * \n * @example\n * countBy([6.1, 4.2, 6.3], Math.floor) // => {4: 1, 6: 2}\n * countBy(['one', 'two', 'three'], x => x.length) // => {3: 2, 5: 1}\n */\nexport function countBy<T> (collection: T[], iteratee: (value: T) => string): Record<string, number>;\nexport function countBy<T> (collection: Record<string, T>, iteratee: (value: T) => string): Record<string, number>;\nexport function countBy<T> (collection: T[] | Record<string, T>, iteratee: (value: T) => string): Record<string, number> {\n  const result: Record<string, number> = {};\n  const values = Array.isArray(collection) ? collection : Object.values(collection);\n\n  for (const item of values) {\n    const key = iteratee(item);\n    result[key] = (result[key] || 0) + 1;\n  }\n\n  return result;\n}\n\n/**\n * This method is like forEach except that it iterates over elements of collection from right to left.\n * \n * @param collection - The collection to iterate over\n * @param iteratee - The function invoked per iteration\n * @returns Returns the collection\n * @since 0.9.0\n * \n * @example\n * eachRight([1, 2], value => console.log(value)) // => logs `2` then `1`\n */\nexport function eachRight<T> (collection: T[], iteratee: (value: T, index: number, collection: T[]) => void): T[] {\n  for (let i = collection.length - 1; i >= 0; i--) {\n    iteratee(collection[i], i, collection);\n  }\n  return collection;\n}\n\n/**\n * Alias for eachRight. This method is like forEach except that it iterates over elements \n * of collection from right to left.\n * \n * @param collection - The collection to iterate over\n * @param iteratee - The function invoked per iteration\n * @returns Returns the collection\n * @since 0.9.0\n * \n * @example\n * forEachRight([1, 2], value => console.log(value)) // => logs `2` then `1`\n */\nexport function forEachRight<T> (collection: T[], iteratee: (value: T, index: number, collection: T[]) => void): T[] {\n  return eachRight(collection, iteratee);\n}\n","/**\n * Utility functions\n * No external dependencies - includes lodash-inspired methods\n */\n\n/**\n * Returns the first argument it receives\n * @param {T} value - The value to return\n * @returns {T} Returns value\n * @example\n * identity(42); // 42\n * identity('hello'); // 'hello'\n */\nexport function identity<T> (value: T): T {\n  return value;\n}\n\n/**\n * Creates a function that returns value\n * @param {T} value - The value to wrap in a function\n * @returns {() => T} Returns the new constant function\n * @example\n * const getAnswer = constant(42);\n * getAnswer(); // 42\n */\nexport function constant<T> (value: T): () => T {\n  return function () {\n    return value;\n  };\n}\n\n/**\n * A method that returns undefined\n * @returns {undefined} Returns undefined\n * @example\n * noop(); // undefined\n */\nexport function noop (): undefined {\n  return undefined;\n}\n\n/**\n * Creates a function that returns the value at path of a given object\n * @param {string | string[]} path - The path of the property to get\n * @returns {(obj: Record<string, unknown>) => T | undefined} Returns the new accessor function\n * @example\n * const getName = property('name');\n * getName({ name: 'John' }); // 'John'\n * \n * const getDeep = property(['user', 'profile', 'name']);\n * getDeep({ user: { profile: { name: 'Jane' } } }); // 'Jane'\n */\nexport function property<T = unknown> (path: string | string[]): (obj: Record<string, unknown>) => T | undefined {\n  return function (obj: Record<string, unknown>) {\n    const keys = Array.isArray(path) ? path : path.split('.');\n    let result: unknown = obj;\n    for (const key of keys) {\n      if (result == null) return undefined;\n      result = (result as Record<string, unknown>)[key];\n    }\n    return result as T | undefined;\n  };\n}\n\n/**\n * The opposite of property; creates a function that returns the value at a given path of object\n * @param {Record<string, unknown>} obj - The object to query\n * @returns {(path: string | string[]) => unknown} Returns the new accessor function\n * @example\n * const object = { a: { b: 2 } };\n * const at = propertyOf(object);\n * at('a.b'); // 2\n * at(['a', 'b']); // 2\n */\nexport function propertyOf (obj: Record<string, unknown>): (path: string | string[]) => unknown {\n  return function (path: string | string[]) {\n    const keys = Array.isArray(path) ? path : path.split('.');\n    let result: unknown = obj;\n    for (const key of keys) {\n      if (result == null) return undefined;\n      result = (result as Record<string, unknown>)[key];\n    }\n    return result;\n  };\n}\n\n/**\n * Creates a function that performs a partial deep comparison between a given object and source\n * @param {Partial<T>} source - The object of property values to match\n * @returns {(obj: T) => boolean} Returns the new spec function\n * @example\n * const isActive = matches({ active: true });\n * isActive({ active: true, name: 'John' }); // true\n */\nexport function matches<T extends Record<string, unknown>> (source: Partial<T>): (obj: T) => boolean {\n  return function (obj: T) {\n    return isMatch(obj, source);\n  };\n}\n\n/**\n * Creates a function that performs a partial deep comparison between the value at path of a given object to srcValue\n * @param {string | string[]} path - The path of the property to get\n * @param {unknown} srcValue - The value to match\n * @returns {(obj: T) => boolean} Returns the new spec function\n * @example\n * const isJohn = matchesProperty('name', 'John');\n * isJohn({ name: 'John', age: 25 }); // true\n */\nexport function matchesProperty<T extends Record<string, unknown>> (path: string | string[], srcValue: unknown): (obj: T) => boolean {\n  return function (obj: T) {\n    const keys = Array.isArray(path) ? path : path.split('.');\n    let current: unknown = obj;\n    for (const key of keys) {\n      if (current == null) return false;\n      current = (current as Record<string, unknown>)[key];\n    }\n    return isEqual(current, srcValue);\n  };\n}\n\n/**\n * Creates a function that invokes the iteratee with the arguments it receives\n * @param {Function | Record<string, unknown> | string | [string, unknown] | null} [func] - The iteratee to transform\n * @returns {(value: T) => R} Returns the callback\n * @example\n * iteratee('name')({ name: 'John' }); // 'John'\n * iteratee(['age', 25])({ age: 25 }); // true\n */\nexport function iteratee<T, R = unknown> (func?: ((value: T) => R) | Record<string, unknown> | string | [string, unknown] | null): (value: T) => R {\n  if (func == null) {\n    return identity as (value: T) => R;\n  }\n  if (typeof func === 'function') {\n    return func;\n  }\n  if (typeof func === 'object') {\n    return Array.isArray(func)\n      ? matchesProperty<T extends Record<string, unknown> ? T : Record<string, unknown>>(func[0], func[1]) as (value: T) => R\n      : matches<T extends Record<string, unknown> ? T : Record<string, unknown>>(func as Partial<T extends Record<string, unknown> ? T : Record<string, unknown>>) as (value: T) => R;\n  }\n  return property<R>(func) as (value: T) => R;\n}\n\n/**\n * Generates a unique ID\n * @param {string} [prefix=''] - The value to prefix the ID with\n * @returns {string} Returns the unique ID\n * @example\n * uniqueId(); // '8h3k2d'\n * uniqueId('user_'); // 'user_8h3k2d'\n */\nexport function uniqueId (prefix: string = ''): string {\n  const id = Math.random().toString(36).substr(2, 9);\n  return prefix + id;\n}\n\n/**\n * Invokes the iteratee n times, returning an array of the results\n * @param {number} n - The number of times to invoke iteratee\n * @param {(index: number) => T} iteratee - The function invoked per iteration\n * @returns {T[]} Returns the array of results\n * @example\n * times(3, i => i * 2); // [0, 2, 4]\n * times(4, () => 'a'); // ['a', 'a', 'a', 'a']\n */\nexport function times<T> (n: number, iteratee: (index: number) => T): T[] {\n  const result: T[] = [];\n  for (let i = 0; i < n; i++) {\n    result.push(iteratee(i));\n  }\n  return result;\n}\n\n/**\n * Creates an array of numbers progressing from start up to, but not including, end\n * @param {number} start - The start of the range\n * @param {number} [end] - The end of the range\n * @param {number} [step=1] - The value to increment or decrement by\n * @returns {number[]} Returns the range of numbers\n * @example\n * range(4); // [0, 1, 2, 3]\n * range(1, 5); // [1, 2, 3, 4]\n * range(0, 20, 5); // [0, 5, 10, 15]\n */\nexport function range (start: number, end?: number, step: number = 1): number[] {\n  if (end === undefined) {\n    end = start;\n    start = 0;\n  }\n\n  const result: number[] = [];\n  if (step > 0) {\n    for (let i = start; i < end; i += step) {\n      result.push(i);\n    }\n  } else {\n    for (let i = start; i > end; i += step) {\n      result.push(i);\n    }\n  }\n  return result;\n}\n\n/**\n * Like range except that it populates values in descending order\n * @param {number} start - The start of the range\n * @param {number} [end] - The end of the range\n * @param {number} [step=1] - The value to increment or decrement by\n * @returns {number[]} Returns the range of numbers\n * @example\n * rangeRight(4); // [3, 2, 1, 0]\n * rangeRight(1, 5); // [4, 3, 2, 1]\n */\nexport function rangeRight (start: number, end?: number, step: number = 1): number[] {\n  return range(start, end, step).reverse();\n}\n\n/**\n * Stub function that returns an empty array\n * @returns {any[]} Returns a new empty array\n * @example\n * stubArray(); // []\n */\nexport function stubArray (): any[] {\n  return [];\n}\n\n/**\n * Stub function that returns false\n * @returns {false} Returns false\n * @example\n * stubFalse(); // false\n */\nexport function stubFalse (): false {\n  return false;\n}\n\n/**\n * Stub function that returns an empty object\n * @returns {object} Returns a new empty object\n * @example\n * stubObject(); // {}\n */\nexport function stubObject (): object {\n  return {};\n}\n\n/**\n * Stub function that returns an empty string\n * @returns {string} Returns an empty string\n * @example\n * stubString(); // ''\n */\nexport function stubString (): string {\n  return '';\n}\n\n/**\n * Stub function that returns true\n * @returns {true} Returns true\n * @example\n * stubTrue(); // true\n */\nexport function stubTrue (): true {\n  return true;\n}\n\n/**\n * Helper function that performs a partial deep comparison between an object and source\n * @param {T} obj - The object to inspect\n * @param {Partial<T>} source - The object of property values to match\n * @returns {boolean} Returns true if object is a match, else false\n */\nfunction isMatch<T extends Record<string, unknown>> (obj: T, source: Partial<T>): boolean {\n  for (const key in source) {\n    if (source[key] !== obj[key]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Performs a deep comparison between two values to determine if they are equivalent\n * @param {unknown} a - The first value to compare\n * @param {unknown} b - The second value to compare\n * @returns {boolean} True if the values are equivalent, false otherwise\n * @since 0.8.0\n * @example\n * isEqual([1, 2, 3], [1, 2, 3]) // true\n * isEqual({ a: 1 }, { a: 1 }) // true\n * isEqual({ a: 1 }, { a: 2 }) // false\n */\nfunction isEqual (a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n  if (a == null || b == null) return a === b;\n  if (typeof a !== typeof b) return false;\n\n  if (typeof a === 'object') {\n    if (Array.isArray(a) !== Array.isArray(b)) return false;\n\n    if (Array.isArray(a) && Array.isArray(b)) {\n      if (a.length !== b.length) return false;\n      return a.every((item, index) => isEqual(item, b[index]));\n    }\n\n    const keysA = Object.keys(a as Record<string, unknown>);\n    const keysB = Object.keys(b as Record<string, unknown>);\n    if (keysA.length !== keysB.length) return false;\n\n    return keysA.every(key => isEqual((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key]));\n  }\n\n  return false;\n}","/**\n * Type checking utility functions\n * No external dependencies - includes lodash-inspired methods\n * @since 0.9.0\n */\n\nimport { isEqual } from \"./object\";\n\n/**\n * Checks if value is an arguments object\n * @param value - The value to check\n * @returns Returns true if value is an arguments object, else false\n * @since 0.9.0\n * @example\n * isArguments(function() { return arguments; }())\n * // => true\n * \n * isArguments([1, 2, 3])\n * // => false\n */\nexport function isArguments (value: unknown): value is IArguments {\n  return Object.prototype.toString.call(value) === '[object Arguments]';\n}\n\n/**\n * Checks if value is classified as an ArrayBuffer object\n * @param value - The value to check\n * @returns Returns true if value is an ArrayBuffer, else false\n * @since 0.9.0\n * @example\n * isArrayBuffer(new ArrayBuffer(2))\n * // => true\n * \n * isArrayBuffer(new Array(2))\n * // => false\n */\nexport function isArrayBuffer (value: unknown): value is ArrayBuffer {\n  return value instanceof ArrayBuffer;\n}\n\n/**\n * Checks if value is array-like. A value is considered array-like if it's not a function and has a valid length property\n * @param value - The value to check\n * @returns Returns true if value is array-like, else false\n * @since 0.9.0\n * @example\n * isArrayLike([1, 2, 3])\n * // => true\n * \n * isArrayLike('abc')\n * // => true\n * \n * isArrayLike(Function)\n * // => false\n */\nexport function isArrayLike (value: unknown): value is { length: number } {\n  return value != null && typeof value !== 'function' && isLength((value as { length?: unknown }).length);\n}\n\n/**\n * Checks if value is array-like and not a function. This method is like isArrayLike except that it also checks if value is an object\n * @param value - The value to check\n * @returns Returns true if value is an array-like object, else false\n * @since 0.9.0\n * @example\n * isArrayLikeObject([1, 2, 3])\n * // => true\n * \n * isArrayLikeObject('abc')\n * // => true\n * \n * isArrayLikeObject(Function)\n * // => false\n */\nexport function isArrayLikeObject (value: unknown): value is object & { length: number } {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if value is classified as a boolean primitive or object\n * @param value - The value to check\n * @returns Returns true if value is a boolean, else false\n * @since 0.9.0\n * @example\n * isBoolean(false)\n * // => true\n * \n * isBoolean(null)\n * // => false\n */\nexport function isBoolean (value: unknown): value is boolean {\n  return value === true || value === false || (isObjectLike(value) && Object.prototype.toString.call(value) === '[object Boolean]');\n}\n\n/**\n * Checks if value is a buffer\n * @param value - The value to check\n * @returns Returns true if value is a buffer, else false\n * @since 0.9.0\n * @example\n * isBuffer(Buffer.alloc(2))\n * // => true\n * \n * isBuffer(new Uint8Array(2))\n * // => false\n */\nexport function isBuffer (value: unknown): boolean {\n  return value != null && typeof (value as { constructor?: unknown }).constructor === 'function' &&\n    typeof ((value as { constructor: { isBuffer?: unknown } }).constructor.isBuffer) === 'function' &&\n    ((value as { constructor: { isBuffer: (val: unknown) => boolean } }).constructor.isBuffer)(value);\n}\n\n/**\n * Checks if value is likely a DOM element\n * @param value - The value to check\n * @returns Returns true if value is a DOM element, else false\n * @since 0.9.0\n * @example\n * isElement(document.body)\n * // => true\n * \n * isElement('<body>')\n * // => false\n */\nexport function isElement (value: unknown): value is Element {\n  return isObjectLike(value) && (value as Element).nodeType === 1 && typeof (value as Element).nodeName === 'string';\n}\n\n/**\n * Like isEqual except that it accepts customizer which is invoked to compare values.\n * If customizer returns undefined, comparisons are handled by the method instead.\n * The customizer is invoked with up to six arguments: (objValue, othValue [, index|key, object, other, stack]).\n * @param a - The value to compare\n * @param b - The other value to compare\n * @param customizer - The function to customize comparisons\n * @returns Returns true if the values are equivalent, else false\n * @since 0.9.0\n * @example\n * function isGreeting(value) {\n *   return /^h(?:i|ello)$/.test(value);\n * }\n * \n * function customizer(objValue, othValue) {\n *   if (isGreeting(objValue) && isGreeting(othValue)) {\n *     return true;\n *   }\n * }\n * \n * isEqualWith(['hello'], ['hi'], customizer)\n * // => true\n */\nexport function isEqualWith (a: unknown, b: unknown, customizer: (objValue: unknown, othValue: unknown, key?: string) => boolean | undefined): boolean {\n  const result = customizer(a, b);\n  return result === undefined ? isEqual(a, b) : result;\n}\n\n/**\n * Checks if value is an Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, or URIError object\n * @param value - The value to check\n * @returns Returns true if value is an error object, else false\n * @since 0.9.0\n * @example\n * isError(new Error)\n * // => true\n * \n * isError(Error)\n * // => false\n */\nexport function isError (value: unknown): value is Error {\n  return value instanceof Error || (isObjectLike(value) && Object.prototype.toString.call(value) === '[object Error]');\n}\n\n/**\n * Checks if value is a finite primitive number.\n * Note: This method is based on Number.isFinite\n * @param value - The value to check\n * @returns Returns true if value is a finite number, else false\n * @since 0.9.0\n * @example\n * isFinite(3)\n * // => true\n * \n * isFinite(Number.MIN_VALUE)\n * // => true\n * \n * isFinite(Infinity)\n * // => false\n * \n * isFinite('3')\n * // => false\n */\nexport function isFinite (value: unknown): value is number {\n  return typeof value === 'number' && Number.isFinite(value);\n}\n\n/**\n * Checks if value is classified as a Function object\n * @param value - The value to check\n * @returns Returns true if value is a function, else false\n * @since 0.9.0\n * @example\n * isFunction(() => {})\n * // => true\n * \n * isFunction(/abc/)\n * // => false\n */\nexport function isFunction (value: unknown): value is Function {\n  return typeof value === 'function';\n}\n\n/**\n * Checks if value is an integer.\n * Note: This method is based on Number.isInteger\n * @param value - The value to check\n * @returns Returns true if value is an integer, else false\n * @since 0.9.0\n * @example\n * isInteger(3)\n * // => true\n * \n * isInteger(Number.MIN_VALUE)\n * // => false\n * \n * isInteger(Infinity)\n * // => false\n * \n * isInteger('3')\n * // => false\n */\nexport function isInteger (value: unknown): value is number {\n  return typeof value === 'number' && Number.isInteger(value);\n}\n\n/**\n * Checks if value is a valid array-like length.\n * Note: This method is loosely based on ToLength operation\n * @param value - The value to check\n * @returns Returns true if value is a valid length, else false\n * @since 0.9.0\n * @example\n * isLength(3)\n * // => true\n * \n * isLength(Number.MIN_VALUE)\n * // => false\n * \n * isLength(Infinity)\n * // => false\n * \n * isLength('3')\n * // => false\n */\nexport function isLength (value: unknown): boolean {\n  return typeof value === 'number' && value >= 0 && value <= Number.MAX_SAFE_INTEGER && Math.floor(value) === value;\n}\n\n/**\n * Checks if value is classified as a Map object\n * @param value - The value to check\n * @returns Returns true if value is a map, else false\n * @since 0.9.0\n * @example\n * isMap(new Map)\n * // => true\n * \n * isMap(new WeakMap)\n * // => false\n */\nexport function isMap (value: unknown): value is Map<unknown, unknown> {\n  return value instanceof Map;\n}\n\n/**\n * Performs a partial deep comparison between object and source to determine if object contains equivalent property values.\n * Note: This method is equivalent to partial application with a source object\n * @param object - The object to inspect\n * @param source - The object of property values to match\n * @returns Returns true if object is a match, else false\n * @since 0.9.0\n * @example\n * const object = { 'a': 1, 'b': 2 };\n * \n * isMatch(object, { 'b': 2 })\n * // => true\n * \n * isMatch(object, { 'b': 1 })\n * // => false\n */\nexport function isMatch (object: unknown, source: unknown): boolean {\n  if (!isObjectLike(object) || !isObjectLike(source)) return false;\n\n  const sourceObj = source as Record<string, unknown>;\n  const objectObj = object as Record<string, unknown>;\n\n  for (const key in sourceObj) {\n    if (!(key in objectObj) || !isEqual(objectObj[key], sourceObj[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Like isMatch except that it accepts customizer which is invoked to compare values.\n * If customizer returns undefined, comparisons are handled by the method instead.\n * The customizer is invoked with five arguments: (objValue, srcValue, index|key, object, source).\n * @param object - The object to inspect\n * @param source - The object of property values to match\n * @param customizer - The function to customize comparisons\n * @returns Returns true if object is a match, else false\n * @since 0.9.0\n * @example\n * function isGreeting(value) {\n *   return /^h(?:i|ello)$/.test(value);\n * }\n * \n * function customizer(objValue, srcValue) {\n *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n *     return true;\n *   }\n * }\n * \n * const object = { 'greeting': 'hello' };\n * const source = { 'greeting': 'hi' };\n * \n * isMatchWith(object, source, customizer)\n * // => true\n */\nexport function isMatchWith (object: unknown, source: unknown, customizer: (objValue: unknown, srcValue: unknown, key: string) => boolean | undefined): boolean {\n  if (!isObjectLike(object) || !isObjectLike(source)) return false;\n\n  const sourceObj = source as Record<string, unknown>;\n  const objectObj = object as Record<string, unknown>;\n\n  for (const key in sourceObj) {\n    const result = customizer(objectObj[key], sourceObj[key], key);\n    if (result === undefined) {\n      if (!(key in objectObj) || !isEqual(objectObj[key], sourceObj[key])) {\n        return false;\n      }\n    } else if (!result) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Checks if value is NaN.\n * Note: This method is based on Number.isNaN and not global isNaN which returns true for undefined and other non-number values\n * @param value - The value to check\n * @returns Returns true if value is NaN, else false\n * @since 0.9.0\n * @example\n * isNaN(NaN)\n * // => true\n * \n * isNaN(new Number(NaN))\n * // => true\n * \n * isNaN(undefined)\n * // => false\n */\nexport function isNaN (value: unknown): boolean {\n  return isNumber(value) && value !== value;\n}\n\n/**\n * Checks if value is a pristine native function.\n * Note: This method can't reliably detect native functions in the presence of the core-js package\n * @param value - The value to check\n * @returns Returns true if value is a native function, else false\n * @since 0.9.0\n * @example\n * isNative(Array.prototype.push)\n * // => true\n * \n * isNative(() => {})\n * // => false\n */\nexport function isNative (value: unknown): boolean {\n  return isFunction(value) && /\\[native code\\]/.test(value.toString());\n}\n\n/**\n * Checks if value is null or undefined\n * @param value - The value to check\n * @returns Returns true if value is nullish, else false\n * @since 0.9.0\n * @example\n * isNil(null)\n * // => true\n * \n * isNil(void 0)\n * // => true\n * \n * isNil(NaN)\n * // => false\n */\nexport function isNil (value: unknown): value is null | undefined {\n  return value == null;\n}\n\n/**\n * Checks if value is null\n * @param value - The value to check\n * @returns Returns true if value is null, else false\n * @since 0.9.0\n * @example\n * isNull(null)\n * // => true\n * \n * isNull(void 0)\n * // => false\n */\nexport function isNull (value: unknown): value is null {\n  return value === null;\n}\n\n/**\n * Checks if value is classified as a Number primitive or object.\n * Note: To exclude Infinity, -Infinity, and NaN, which are classified as numbers, use the isFinite method\n * @param value - The value to check\n * @returns Returns true if value is a number, else false\n * @since 0.9.0\n * @example\n * isNumber(3)\n * // => true\n * \n * isNumber(Number.MIN_VALUE)\n * // => true\n * \n * isNumber(Infinity)\n * // => true\n * \n * isNumber('3')\n * // => false\n */\nexport function isNumber (value: unknown): value is number {\n  return typeof value === 'number' || (isObjectLike(value) && Object.prototype.toString.call(value) === '[object Number]');\n}\n\n/**\n * Checks if value is the language type of Object.\n * (e.g. arrays, functions, objects, regexes, new Number(0), and new String(''))\n * @param value - The value to check\n * @returns Returns true if value is an object, else false\n * @since 0.9.0\n * @example\n * isObject({})\n * // => true\n * \n * isObject([1, 2, 3])\n * // => true\n * \n * isObject(() => {})\n * // => true\n * \n * isObject(null)\n * // => false\n */\nexport function isObject (value: unknown): value is object {\n  const type = typeof value;\n  return value != null && (type === 'object' || type === 'function');\n}\n\n/**\n * Checks if value is object-like. A value is object-like if it's not null and has a typeof result of \"object\"\n * @param value - The value to check\n * @returns Returns true if value is object-like, else false\n * @since 0.9.0\n * @example\n * isObjectLike({})\n * // => true\n * \n * isObjectLike([1, 2, 3])\n * // => true\n * \n * isObjectLike(() => {})\n * // => false\n * \n * isObjectLike(null)\n * // => false\n */\nexport function isObjectLike (value: unknown): value is object {\n  return value != null && typeof value === 'object';\n}\n\n/**\n * Checks if value is a plain object, that is, an object created by the Object constructor or one with a [[Prototype]] of null\n * @param value - The value to check\n * @returns Returns true if value is a plain object, else false\n * @since 0.9.0\n * @example\n * function Foo() {\n *   this.a = 1;\n * }\n * \n * isPlainObject(new Foo)\n * // => false\n * \n * isPlainObject([1, 2, 3])\n * // => false\n * \n * isPlainObject({ 'x': 0, 'y': 0 })\n * // => true\n * \n * isPlainObject(Object.create(null))\n * // => true\n */\nexport function isPlainObject (value: unknown): boolean {\n  if (!isObjectLike(value) || Object.prototype.toString.call(value) !== '[object Object]') {\n    return false;\n  }\n  if (Object.getPrototypeOf(value) === null) {\n    return true;\n  }\n  let proto = value;\n  while (Object.getPrototypeOf(proto) !== null) {\n    proto = Object.getPrototypeOf(proto);\n  }\n  return Object.getPrototypeOf(value) === proto;\n}\n\n/**\n * Checks if value is classified as a RegExp object\n * @param value - The value to check\n * @returns Returns true if value is a regexp, else false\n * @since 0.9.0\n * @example\n * isRegExp(/abc/)\n * // => true\n * \n * isRegExp('/abc/')\n * // => false\n */\nexport function isRegExp (value: unknown): value is RegExp {\n  return value instanceof RegExp;\n}\n\n/**\n * Checks if value is a safe integer. An integer is safe if it's an IEEE-754 double precision number which isn't the result of a rounded unsafe integer.\n * Note: This method is based on Number.isSafeInteger\n * @param value - The value to check\n * @returns Returns true if value is a safe integer, else false\n * @since 0.9.0\n * @example\n * isSafeInteger(3)\n * // => true\n * \n * isSafeInteger(Number.MIN_VALUE)\n * // => false\n * \n * isSafeInteger(Infinity)\n * // => false\n * \n * isSafeInteger('3')\n * // => false\n */\nexport function isSafeInteger (value: unknown): value is number {\n  return isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if value is classified as a Set object\n * @param value - The value to check\n * @returns Returns true if value is a set, else false\n * @since 0.9.0\n * @example\n * isSet(new Set)\n * // => true\n * \n * isSet(new WeakSet)\n * // => false\n */\nexport function isSet (value: unknown): value is Set<unknown> {\n  return value instanceof Set;\n}\n\n/**\n * Checks if value is classified as a String primitive or object\n * @param value - The value to check\n * @returns Returns true if value is a string, else false\n * @since 0.9.0\n * @example\n * isString('abc')\n * // => true\n * \n * isString(1)\n * // => false\n */\nexport function isString (value: unknown): value is string {\n  return typeof value === 'string' || (isObjectLike(value) && Object.prototype.toString.call(value) === '[object String]');\n}\n\n/**\n * Checks if value is classified as a Symbol primitive or object\n * @param value - The value to check\n * @returns Returns true if value is a symbol, else false\n * @since 0.9.0\n * @example\n * isSymbol(Symbol.iterator)\n * // => true\n * \n * isSymbol('abc')\n * // => false\n */\nexport function isSymbol (value: unknown): value is symbol {\n  return typeof value === 'symbol' || (isObjectLike(value) && Object.prototype.toString.call(value) === '[object Symbol]');\n}\n\n/**\n * Checks if value is classified as a typed array\n * @param value - The value to check\n * @returns Returns true if value is a typed array, else false\n * @since 0.9.0\n * @example\n * isTypedArray(new Uint8Array)\n * // => true\n * \n * isTypedArray([])\n * // => false\n */\nexport function isTypedArray (value: unknown): boolean {\n  return isObjectLike(value) && /^\\[object (Int8|Uint8|Uint8Clamped|Int16|Uint16|Int32|Uint32|Float32|Float64)Array\\]$/.test(Object.prototype.toString.call(value));\n}\n\n/**\n * Checks if value is undefined\n * @param value - The value to check\n * @returns Returns true if value is undefined, else false\n * @since 0.9.0\n * @example\n * isUndefined(void 0)\n * // => true\n * \n * isUndefined(null)\n * // => false\n */\nexport function isUndefined (value: unknown): value is undefined {\n  return value === undefined;\n}\n\n/**\n * Checks if value is classified as a WeakMap object\n * @param value - The value to check\n * @returns Returns true if value is a weak map, else false\n * @since 0.9.0\n * @example\n * isWeakMap(new WeakMap)\n * // => true\n * \n * isWeakMap(new Map)\n * // => false\n */\nexport function isWeakMap (value: unknown): value is WeakMap<object, unknown> {\n  return value instanceof WeakMap;\n}\n\n/**\n * Checks if value is classified as a WeakSet object\n * @param value - The value to check\n * @returns Returns true if value is a weak set, else false\n * @since 0.9.0\n * @example\n * isWeakSet(new WeakSet)\n * // => true\n * \n * isWeakSet(new Set)\n * // => false\n */\nexport function isWeakSet (value: unknown): value is WeakSet<object> {\n  return value instanceof WeakSet;\n}\n","/**\n * Common regular expressions\n * @since 0.8.0\n */\nexport const REGEX = {\n  /** Match HTML tags @since 0.8.0 */\n  htmlTag: /.*?>([^<]*)/,\n\n  /** Match content in brackets @since 0.8.0 */\n  inBrackets: /\\[[^\\[\\]]*\\]/,\n\n  /** Match content in strings @since 0.8.0 */\n  inStrings: /.*?\"([^\"]*)/,\n\n  /** Match HTML tags or arrays @since 0.8.0 */\n  tagRegex: /<([a-z][a-z0-9]*)[^>]*>([^<]*)<\\/\\1>|(\\[(.*?)\\])/i,\n\n  /** Match opening parentheses @since 0.8.0 */\n  openParentheses: /^(.*?)\\(/,\n\n  /** Match all non-whitespace sequences @since 0.8.0 */\n  allSpaces: /\\S+/g,\n\n  /** Match datetime strings @since 0.8.0 */\n  datetime: /^((?:(\\d{4}-\\d{2}-\\d{2})T(\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?))(Z|[\\+-]\\d{2}:\\d{2})?)$/,\n\n  /** Match email addresses @since 0.8.0 */\n  email: /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/,\n\n  /** Match URLs @since 0.8.0 */\n  url: /^https?:\\/\\/.+/,\n\n  /** Match numbers @since 0.9.0 */\n  number: /^-?\\d+(\\.\\d+)?$/\n} as const;\n\n/**\n * Date format constants\n * @since 0.8.0\n */\nexport const DATE_FORMATS = {\n  DATE: \"DD/MM/YYYY\",\n  TIME: \"HH:mm\",\n  DATE_TIME: \"DD/MM/YYYY,HH:mm:ss\"\n} as const;\n\n/**\n * Country date formats by ISO code\n * @since 0.8.0\n */\nexport const COUNTRY_DATE_FORMATS = {\n  AD: \"DD/MM/YYYY\", AT: \"DD.MM.YYYY\", BE: \"DD/MM/YYYY\", BG: \"DD.MM.YYYY\",\n  CH: \"DD.MM.YYYY\", CY: \"DD/MM/YYYY\", CZ: \"DD.MM.YYYY\", DE: \"DD.MM.YYYY\",\n  DK: \"DD.MM.YYYY\", EE: \"DD.MM.YYYY\", ES: \"DD/MM/YYYY\", FI: \"DD.MM.YYYY\",\n  FR: \"DD/MM/YYYY\", GB: \"DD/MM/YYYY\", GR: \"DD/MM/YYYY\", HR: \"DD.MM.YYYY\",\n  HU: \"YYYY.MM.DD.\", IE: \"DD/MM/YYYY\", IS: \"DD.MM.YYYY\", IT: \"DD/MM/YYYY\",\n  LI: \"DD.MM.YYYY\", LT: \"YYYY.MM.DD\", LU: \"DD/MM/YYYY\", LV: \"DD.MM.YYYY\",\n  MC: \"DD/MM/YYYY\", MT: \"DD/MM/YYYY\", NL: \"DD-MM-YYYY\", NO: \"DD.MM.YYYY\",\n  PL: \"DD.MM.YYYY\", PT: \"DD/MM/YYYY\", RO: \"DD.MM.YYYY\", SE: \"YYYY-MM-DD\",\n  SI: \"DD.MM.YYYY\", SK: \"DD.MM.YYYY\", SM: \"DD/MM/YYYY\", TR: \"DD.MM.YYYY\",\n  US: \"MM/DD/YYYY\", CA: \"MM/DD/YYYY\", JP: \"YYYY年MM月DD日\", CN: \"YYYY年MM月DD日\", KR: \"YYYY-MM-DD\"\n} as const;\n\n/**\n * Response codes\n * @since 0.8.0\n */\nexport const RESPONSE_CODES = {\n  NOT_INIT: 0,\n  IS_INIT: 1,\n  NOT_FOUND_INIT: 2,\n  NOT_FOUND: 9\n} as const;\n\n/**\n * Common colors for status indicators\n * @since 0.9.0\n */\nexport const STATUS_COLORS = {\n  ACTIVE: \"green\",\n  INACTIVE: \"grey\",\n  PENDING: \"orange\",\n  ERROR: \"red\",\n  WARNING: \"yellow\",\n  INFO: \"blue\"\n} as const;\n","/**\n * HTTP request options (lightweight, axios-free)\n * @since 0.9.8\n */\nexport interface RequestOptions {\n  method?: 'GET' | 'POST' | 'PUT' | 'DELETE';\n  headers?: Record<string, string>;\n  body?: any;\n}\n\n/**\n * Simple HTTP client using fetch (no axios dependency)\n * @param {string} url - Request URL\n * @param {RequestOptions} [options={}] - Request options including method, headers, and body\n * @returns {Promise<T | { ok: false; message: string }>} Promise with response data or error object\n * @since 0.9.8\n * @example\n * // GET request\n * const data = await api('https://api.example.com/users');\n * \n * // POST request\n * const result = await api('https://api.example.com/users', {\n *   method: 'POST',\n *   body: { name: 'John' }\n * });\n */\nexport async function api<T = unknown> (url: string, options: RequestOptions = {}): Promise<T | { ok: false; message: string }> {\n  const { method = 'GET', headers = {}, body } = options;\n\n  try {\n    const fetchOptions: RequestInit = {\n      method,\n      headers: {\n        'Content-Type': 'application/json',\n        ...headers\n      }\n    };\n\n    if (body && method !== 'GET') {\n      fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);\n    }\n\n    const response = await fetch(url, fetchOptions);\n\n    if (!response.ok) {\n      throw new Error(`HTTP error! status: ${response.status}`);\n    }\n\n    return await response.json() as T;\n  } catch (error) {\n    return {\n      ok: false,\n      message: error instanceof Error ? error.message : 'Unknown error'\n    };\n  }\n}","/**\n * Extract value from string using regex\n * @param {string} str - Input string to extract from\n * @param {RegExp} regex - Regular expression with capture groups\n * @param {T} type - Expected return type ('string' | 'number' | 'boolean' | 'array' | 'date')\n * @returns {ExtractedValue} Extracted and converted value based on type\n * @since 0.9.8\n * @example\n * extractFromString('Price: $25.99', /\\$(\\d+\\.\\d+)/, 'number'); // 25.99\n * extractFromString('Active: true', /Active: (\\w+)/, 'boolean'); // true\n * extractFromString('Date: 2023-12-25', /Date: (.+)/, 'date'); // Date object\n */\nexport function extractFromString<T extends 'string' | 'number' | 'boolean' | 'array' | 'date'> (\n  str: string,\n  regex: RegExp,\n  type: T\n): T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'array' ? unknown[] : T extends 'date' ? Date : unknown {\n  const match = str?.match?.(regex);\n  if (!match) return str as never;\n\n  switch (type) {\n    case 'string':\n      return (match[2] || match[1] || match[0]) as never;\n    case 'boolean':\n      return (match[2] === 'true' || match[1] === 'true') as never;\n    case 'array':\n      try {\n        return JSON.parse(match[0]) as never;\n      } catch {\n        return [] as never;\n      }\n    case 'number':\n      const num = parseFloat(match[1] || match[0]);\n      return (isNaN(num) ? str : num) as never;\n    case 'date':\n      const date = new Date(match[2] || match[1] || match[0]);\n      return (isNaN(date.getTime()) ? new Date() : date) as never;\n    default:\n      return match[0] as never;\n  }\n}","/**\n * Simple hash function (lightweight alternative to object-hash)\n * @param {unknown} obj - Object or value to hash\n * @returns {string} Simple hash string in base 36\n * @since 0.9.8\n * @example\n * hash('hello'); // \"1k4xd\"\n * hash({ a: 1, b: 2 }); // \"1x3k2d\"\n */\nexport function hash (obj: unknown): string {\n  const str = typeof obj === 'string' ? obj : JSON.stringify(obj);\n  let hash = 0;\n  for (let i = 0; i < str.length; i++) {\n    const char = str.charCodeAt(i);\n    hash = ((hash << 5) - hash) + char;\n    hash = hash & hash; // Convert to 32-bit integer\n  }\n  return hash.toString(36);\n}","/**\n * Country interface\n * @since 0.9.8\n */\nexport interface Country {\n  name?: {\n    common: string;\n    official: string;\n  };\n  cca2?: string;\n  altNames?: string;\n  flag?: string;\n}\n\n/**\n * Find country by various criteria\n * @param {Object} searchParams - Search criteria\n * @param {string} [searchParams.cc] - Country code (ISO 3166-1 alpha-2)\n * @param {string} [searchParams.cn] - Country name (common or official)\n * @param {string} [searchParams.cf] - Country flag emoji\n * @param {Country[]} countries - Array of countries to search in\n * @returns {Partial<Country>} Found country or empty object if not found\n * @since 0.9.8\n * @example\n * const country = getCountry({ cc: 'US' }, countries);\n * const country2 = getCountry({ cn: 'France' }, countries);\n */\nexport function getCountry (\n  { cc, cn, cf }: { cc?: string; cn?: string; cf?: string },\n  countries: Country[]\n): Partial<Country> {\n  if (!countries || countries.length === 0) return {};\n\n  const normalizedCn = cn?.normalize(\"NFD\").replace(/[\\u0300-\\u036f]/g, \"\");\n\n  const searchInAltNames = (altNames: string) => {\n    return new RegExp(`\\\\b${normalizedCn}\\\\b`, \"i\").test(altNames);\n  };\n\n  const country = countries\n    .sort((a, b) => (a.cca2 || '').localeCompare(b.cca2 || ''))\n    .find(({ name, altNames, cca2, flag }) => {\n      if (cc && cca2 === cc) return true;\n      if (cf && flag === cf) return true;\n      if (normalizedCn && name) {\n        if (name.common === normalizedCn || name.official === normalizedCn) return true;\n        if (altNames && searchInAltNames(altNames)) return true;\n      }\n      return false;\n    });\n\n  return country || {};\n}"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAAA;AAAA,EAAA;AAAA,eAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAAC;AAAA,EAAA,gBAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAA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","names":["isMatch","isNaN","parseFloat","parseInt","escape","result","parseInt","purify","keys","size","result","values","iteratee","rest","property","result","iteratee","isObject","keys","transform","method","assignDefaults","entries","result","parseFloat","min","max","pad","result","now","sum","iteratee","number","method","result","transform","now","iteratee","entries","result","values","method","collection","keys","result","isEqual","iteratee","result","isMatch","isNaN","method","hash"]}