@mdigitalcn/utils 2.0.0

package/dist/esm/string/formatBytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatBytes.js","sources":["../../../src/string/formatBytes.ts"],"sourcesContent":["/**\n * Formats a byte count into a human-readable string.\n *\n * @example\n * formatBytes(0) // '0 B'\n * formatBytes(1024) // '1 KB'\n * formatBytes(1536, 1) // '1.5 KB'\n * formatBytes(1073741824) // '1 GB'\n * formatBytes(1234567890, 2) // '1.15 GB'\n *\n * @param bytes - Number of bytes\n * @param decimals - Decimal places (default: 2)\n * @returns Formatted string (e.g., '1.5 MB')\n */\nexport function formatBytes(bytes: number, decimals: number = 2): string {\n  if (bytes === 0) return '0 B';\n  const k = 1024;\n  const dm = Math.max(0, decimals);\n  const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];\n  const i = Math.floor(Math.log(bytes) / Math.log(k));\n  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;\n}\n"],"names":["formatBytes","bytes","decimals","dm","Math","max","i","floor","log","parseFloat","pow","toFixed"],"mappings":"SAcgBA,EAAYC,EAAeC,EAAmB,GAC5D,GAAc,IAAVD,EAAa,MAAO,MACxB,MACME,EAAKC,KAAKC,IAAI,EAAGH,GAEjBI,EAAIF,KAAKG,MAAMH,KAAKI,IAAIP,GAASG,KAAKI,IAHlC,OAIV,MAAO,GAAGC,YAAYR,EAAQG,KAAKM,IAJzB,KAIgCJ,IAAIK,QAAQR,OAFxC,CAAC,IAAK,KAAM,KAAM,KAAM,KAAM,MAEwBG,IACtE"}

package/dist/esm/string/formatDuration.js

@@ -0,0 +1,2 @@
+function o(o){if(o<1e3)return o>0?`${o}ms`:"0s";const h=Math.floor(o/1e3)%60,r=Math.floor(o/6e4)%60,t=Math.floor(o/36e5)%24,e=Math.floor(o/864e5),s=[];return e>0&&s.push(`${e}d`),t>0&&s.push(`${t}h`),r>0&&s.push(`${r}m`),h>0&&s.push(`${h}s`),s.join(" ")}export{o as formatDuration};
+//# sourceMappingURL=formatDuration.js.map

package/dist/esm/string/formatDuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatDuration.js","sources":["../../../src/string/formatDuration.ts"],"sourcesContent":["/**\n * Formats milliseconds into a human-readable duration string.\n *\n * @example\n * formatDuration(0) // '0s'\n * formatDuration(5000) // '5s'\n * formatDuration(65000) // '1m 5s'\n * formatDuration(3661000) // '1h 1m 1s'\n * formatDuration(90061000) // '1d 1h 1m 1s'\n *\n * @param ms - Duration in milliseconds\n * @returns Human-readable duration string\n */\nexport function formatDuration(ms: number): string {\n  if (ms < 1000) return ms > 0 ? `${ms}ms` : '0s';\n\n  const seconds = Math.floor(ms / 1000) % 60;\n  const minutes = Math.floor(ms / 60000) % 60;\n  const hours = Math.floor(ms / 3600000) % 24;\n  const days = Math.floor(ms / 86400000);\n\n  const parts: string[] = [];\n  if (days > 0) parts.push(`${days}d`);\n  if (hours > 0) parts.push(`${hours}h`);\n  if (minutes > 0) parts.push(`${minutes}m`);\n  if (seconds > 0) parts.push(`${seconds}s`);\n\n  return parts.join(' ');\n}\n"],"names":["formatDuration","ms","seconds","Math","floor","minutes","hours","days","parts","push","join"],"mappings":"AAaM,SAAUA,EAAeC,GAC7B,GAAIA,EAAK,IAAM,OAAOA,EAAK,EAAI,GAAGA,MAAS,KAE3C,MAAMC,EAAUC,KAAKC,MAAMH,EAAK,KAAQ,GAClCI,EAAUF,KAAKC,MAAMH,EAAK,KAAS,GACnCK,EAAQH,KAAKC,MAAMH,EAAK,MAAW,GACnCM,EAAOJ,KAAKC,MAAMH,EAAK,OAEvBO,EAAkB,GAMxB,OALID,EAAO,GAAGC,EAAMC,KAAK,GAAGF,MACxBD,EAAQ,GAAGE,EAAMC,KAAK,GAAGH,MACzBD,EAAU,GAAGG,EAAMC,KAAK,GAAGJ,MAC3BH,EAAU,GAAGM,EAAMC,KAAK,GAAGP,MAExBM,EAAME,KAAK,IACpB"}

package/dist/esm/string/formatNumber.js

@@ -0,0 +1,2 @@
+const r=(r,t="en-US")=>{const n=Number(r);return isNaN(n)?String(r):new Intl.NumberFormat(t).format(n)};export{r as formatNumber};
+//# sourceMappingURL=formatNumber.js.map

package/dist/esm/string/formatNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatNumber.js","sources":["../../../src/string/formatNumber.ts"],"sourcesContent":["/**\n * Formats a number or numeric string by adding thousands separators\n * according to the specified locale.\n *\n * If the value is not a number, returns the original string.\n *\n * @param {number | string} number - Number or string to format.\n * @param {string} [locale='en-US'] - Locale for formatting (e.g., 'en-US', 'ru-RU').\n * @returns {string} Formatted string with thousands separators or original value if not a number.\n *\n * @example\n * ```ts\n * formatNumber(1234567); // \"1,234,567\"\n * formatNumber(1234567, 'ru-RU'); // \"1 234 567\"\n * formatNumber(\"987654321\"); // \"987,654,321\"\n * formatNumber(\"abc\"); // \"abc\"\n * ```\n */\nexport const formatNumber = (\n  number: number | string,\n  locale: string = \"en-US\"\n): string => {\n  const value = Number(number);\n\n  if (!isNaN(value)) {\n    return new Intl.NumberFormat(locale).format(value);\n  }\n\n  return String(number);\n};\n"],"names":["formatNumber","number","locale","value","Number","isNaN","String","Intl","NumberFormat","format"],"mappings":"AAkBO,MAAMA,EAAe,CAC1BC,EACAC,EAAiB,WAEjB,MAAMC,EAAQC,OAAOH,GAErB,OAAKI,MAAMF,GAIJG,OAAOL,GAHL,IAAIM,KAAKC,aAAaN,GAAQO,OAAON"}

package/dist/esm/string/htmlToText.js

@@ -0,0 +1,2 @@
+function e(e){return e?e.replace(/<[^>]*>/g,"").replace(/\s+/g," ").trim():""}export{e as htmlToText};
+//# sourceMappingURL=htmlToText.js.map

package/dist/esm/string/htmlToText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlToText.js","sources":["../../../src/string/htmlToText.ts"],"sourcesContent":["/**\n * Converts an HTML string into plain text by removing all HTML tags,\n * normalizing whitespace, and trimming extra spaces.\n *\n * If the input is empty or falsy, returns an empty string.\n *\n * @param {string} html - The HTML string to convert.\n * @returns {string} The plain text result.\n *\n * @example\n * const html = `\n *   <h1>Добро пожаловать в <b>MBank</b></h1>\n *   <p>Первый цифровой <a href=\"https://mbank.example\">банк</a> в стране.</p>\n *   <ul>\n *     <li>Онлайн-операции</li>\n *     <li>Мобильное приложение</li>\n *     <li>Безопасные переводы</li>\n *   </ul>\n * `;\n *\n * const text = htmlToText(html);\n * console.log(text);\n * // Output:\n * // \"Добро пожаловать в MBank Первый цифровой банк в стране. Онлайн-операции Мобильное приложение Безопасные переводы\"\n *\n\n */\nexport function htmlToText(html: string): string {\n  if (!html) return \"\";\n\n  return html\n    .replace(/<[^>]*>/g, \"\")\n    .replace(/\\s+/g, \" \")\n    .trim();\n}\n"],"names":["htmlToText","html","replace","trim"],"mappings":"AA2BM,SAAUA,EAAWC,GACzB,OAAKA,EAEEA,EACJC,QAAQ,WAAY,IACpBA,QAAQ,OAAQ,KAChBC,OALe,EAMpB"}

package/dist/esm/string/index.js

@@ -0,0 +1,2 @@
+export{capitalize}from"./capitalize.js";export{camelCase}from"./camelCase.js";export{deburr}from"./deburr.js";export{escapeHtml}from"./escapeHtml.js";export{escapeRegExp}from"./escapeRegExp.js";export{formatBytes}from"./formatBytes.js";export{formatDuration}from"./formatDuration.js";export{formatNumber}from"./formatNumber.js";export{htmlToText}from"./htmlToText.js";export{kebabCase}from"./kebabCase.js";export{maskString}from"./maskString.js";export{pascalCase}from"./pascalCase.js";export{pluralize}from"./pluralize.js";export{slugify}from"./slugify.js";export{snakeCase}from"./snakeCase.js";export{startCase}from"./startCase.js";export{template}from"./template.js";export{truncateString}from"./truncateString.js";export{words}from"./words.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/string/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/esm/string/kebabCase.js

@@ -0,0 +1,2 @@
+import{words as o}from"./words.js";function r(r){return o(r).join("-")}export{r as kebabCase};
+//# sourceMappingURL=kebabCase.js.map

package/dist/esm/string/kebabCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kebabCase.js","sources":["../../../src/string/kebabCase.ts"],"sourcesContent":["import { words } from './words.js';\n\n/**\n * Converts a string to kebab-case.\n * Handles spaces, underscores, camelCase, and PascalCase.\n *\n * @example\n * kebabCase('helloWorld') // 'hello-world'\n * kebabCase('FOO_BAR') // 'foo-bar'\n * kebabCase('some string here') // 'some-string-here'\n * kebabCase('PascalCase') // 'pascal-case'\n * kebabCase('') // ''\n *\n * @param str - String to convert\n * @returns kebab-case string\n */\nexport function kebabCase(str: string): string {\n  return words(str).join('-');\n}\n"],"names":["kebabCase","str","words","join"],"mappings":"mCAgBM,SAAUA,EAAUC,GACxB,OAAOC,EAAMD,GAAKE,KAAK,IACzB"}

package/dist/esm/string/maskString.js

@@ -0,0 +1,2 @@
+function e(e,t,n,r="*"){if(e.length<=t+n)return e;const c=e.slice(0,t),i=n>0?e.slice(-n):"",l=e.length-t-n;return c+r.repeat(l)+i}export{e as maskString};
+//# sourceMappingURL=maskString.js.map

package/dist/esm/string/maskString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maskString.js","sources":["../../../src/string/maskString.ts"],"sourcesContent":["/**\n * Masks a portion of a string, revealing only start and end characters.\n * Useful for credit cards, phone numbers, emails, API keys.\n *\n * @example\n * maskString('1234567890', 4, 2) // '1234****90'\n * maskString('hello@example.com', 2, 4) // 'he***********e.com'\n * maskString('secret', 0, 0) // '******'\n * maskString('ab', 1, 1, '#') // 'ab' (nothing to mask)\n *\n * @param str - String to mask\n * @param visibleStart - Number of visible chars at start\n * @param visibleEnd - Number of visible chars at end\n * @param maskChar - Character used for masking (default: '*')\n * @returns Masked string\n */\nexport function maskString(\n  str: string,\n  visibleStart: number,\n  visibleEnd: number,\n  maskChar: string = '*'\n): string {\n  if (str.length <= visibleStart + visibleEnd) return str;\n  const start = str.slice(0, visibleStart);\n  const end = visibleEnd > 0 ? str.slice(-visibleEnd) : '';\n  const maskLen = str.length - visibleStart - visibleEnd;\n  return start + maskChar.repeat(maskLen) + end;\n}\n"],"names":["maskString","str","visibleStart","visibleEnd","maskChar","length","start","slice","end","maskLen","repeat"],"mappings":"AAgBM,SAAUA,EACdC,EACAC,EACAC,EACAC,EAAmB,KAEnB,GAAIH,EAAII,QAAUH,EAAeC,EAAY,OAAOF,EACpD,MAAMK,EAAQL,EAAIM,MAAM,EAAGL,GACrBM,EAAML,EAAa,EAAIF,EAAIM,OAAOJ,GAAc,GAChDM,EAAUR,EAAII,OAASH,EAAeC,EAC5C,OAAOG,EAAQF,EAASM,OAAOD,GAAWD,CAC5C"}

package/dist/esm/string/pascalCase.js

@@ -0,0 +1,2 @@
+import{words as r}from"./words.js";function o(o){return r(o).map(r=>r.charAt(0).toUpperCase()+r.slice(1)).join("")}export{o as pascalCase};
+//# sourceMappingURL=pascalCase.js.map

package/dist/esm/string/pascalCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascalCase.js","sources":["../../../src/string/pascalCase.ts"],"sourcesContent":["import { words } from './words.js';\n\n/**\n * Converts a string to PascalCase.\n *\n * @example\n * pascalCase('hello world') // 'HelloWorld'\n * pascalCase('foo-bar-baz') // 'FooBarBaz'\n * pascalCase('some_snake_case') // 'SomeSnakeCase'\n * pascalCase('') // ''\n *\n * @param str - String to convert\n * @returns PascalCase string\n */\nexport function pascalCase(str: string): string {\n  return words(str)\n    .map(w => w.charAt(0).toUpperCase() + w.slice(1))\n    .join('');\n}\n"],"names":["pascalCase","str","words","map","w","charAt","toUpperCase","slice","join"],"mappings":"mCAcM,SAAUA,EAAWC,GACzB,OAAOC,EAAMD,GACVE,IAAIC,GAAKA,EAAEC,OAAO,GAAGC,cAAgBF,EAAEG,MAAM,IAC7CC,KAAK,GACV"}

package/dist/esm/string/pluralize.js

@@ -0,0 +1,2 @@
+function n(n,r,t){return`${n} ${1===n?r:t??`${r}s`}`}export{n as pluralize};
+//# sourceMappingURL=pluralize.js.map

package/dist/esm/string/pluralize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluralize.js","sources":["../../../src/string/pluralize.ts"],"sourcesContent":["/**\n * Returns singular or plural form based on count.\n *\n * @example\n * pluralize(0, 'item') // '0 items'\n * pluralize(1, 'item') // '1 item'\n * pluralize(5, 'item') // '5 items'\n * pluralize(2, 'child', 'children') // '2 children'\n * pluralize(1, 'person', 'people') // '1 person'\n *\n * @param count - The number\n * @param singular - Singular form\n * @param plural - Plural form (default: singular + 's')\n * @returns Formatted count + word\n */\nexport function pluralize(count: number, singular: string, plural?: string): string {\n  const word = count === 1 ? singular : (plural ?? `${singular}s`);\n  return `${count} ${word}`;\n}\n"],"names":["pluralize","count","singular","plural"],"mappings":"SAegBA,EAAUC,EAAeC,EAAkBC,GAEzD,MAAO,GAAGF,KADa,IAAVA,EAAcC,EAAYC,GAAU,GAAGD,MAEtD"}

package/dist/esm/string/slugify.js

@@ -0,0 +1,2 @@
+function e(e){return e.normalize("NFD").replace(/[\u0300-\u036f]/g,"").toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-+|-+$/g,"")}export{e as slugify};
+//# sourceMappingURL=slugify.js.map

package/dist/esm/string/slugify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slugify.js","sources":["../../../src/string/slugify.ts"],"sourcesContent":["/**\n * Converts a string to a URL-friendly slug.\n * Lowercases, replaces non-alphanumeric chars with hyphens, trims hyphens.\n *\n * @example\n * slugify('Hello World!') // 'hello-world'\n * slugify('  Crème Brûlée ') // 'cr-me-br-l-e'\n * slugify('foo---bar') // 'foo-bar'\n * slugify('') // ''\n *\n * @param str - String to slugify\n * @returns URL-safe slug\n */\nexport function slugify(str: string): string {\n  return str\n    .normalize('NFD')\n    .replace(/[\\u0300-\\u036f]/g, '')\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '-')\n    .replace(/^-+|-+$/g, '');\n}\n"],"names":["slugify","str","normalize","replace","toLowerCase"],"mappings":"AAaM,SAAUA,EAAQC,GACtB,OAAOA,EACJC,UAAU,OACVC,QAAQ,mBAAoB,IAC5BC,cACAD,QAAQ,cAAe,KACvBA,QAAQ,WAAY,GACzB"}

package/dist/esm/string/snakeCase.js

@@ -0,0 +1,2 @@
+import{words as o}from"./words.js";function r(r){return o(r).join("_")}export{r as snakeCase};
+//# sourceMappingURL=snakeCase.js.map

package/dist/esm/string/snakeCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snakeCase.js","sources":["../../../src/string/snakeCase.ts"],"sourcesContent":["import { words } from './words.js';\n\n/**\n * Converts a string to snake_case.\n * Handles spaces, hyphens, camelCase, and PascalCase.\n *\n * @example\n * snakeCase('helloWorld') // 'hello_world'\n * snakeCase('foo-bar-baz') // 'foo_bar_baz'\n * snakeCase('Some String Here') // 'some_string_here'\n * snakeCase('PascalCase') // 'pascal_case'\n * snakeCase('') // ''\n *\n * @param str - String to convert\n * @returns snake_case string\n */\nexport function snakeCase(str: string): string {\n  return words(str).join('_');\n}\n"],"names":["snakeCase","str","words","join"],"mappings":"mCAgBM,SAAUA,EAAUC,GACxB,OAAOC,EAAMD,GAAKE,KAAK,IACzB"}

package/dist/esm/string/startCase.js

@@ -0,0 +1,2 @@
+import{words as o}from"./words.js";function r(r){return o(r).map(o=>o.charAt(0).toUpperCase()+o.slice(1).toLowerCase()).join(" ")}export{r as startCase};
+//# sourceMappingURL=startCase.js.map

package/dist/esm/string/startCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startCase.js","sources":["../../../src/string/startCase.ts"],"sourcesContent":["import { words } from './words.js';\n\n/**\n * Converts a string to Start Case (each word capitalized, separated by spaces).\n *\n * @example\n * startCase('hello world') // 'Hello World'\n * startCase('fooBarBaz') // 'Foo Bar Baz'\n * startCase('some_snake_case') // 'Some Snake Case'\n * startCase('') // ''\n *\n * @param str - String to convert\n * @returns Start Case string\n */\nexport function startCase(str: string): string {\n  return words(str)\n    .map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())\n    .join(' ');\n}\n"],"names":["startCase","str","words","map","w","charAt","toUpperCase","slice","toLowerCase","join"],"mappings":"mCAcM,SAAUA,EAAUC,GACxB,OAAOC,EAAMD,GACVE,IAAIC,GAAKA,EAAEC,OAAO,GAAGC,cAAgBF,EAAEG,MAAM,GAAGC,eAChDC,KAAK,IACV"}

package/dist/esm/string/template.js

@@ -0,0 +1,2 @@
+function r(r,n,t=/\{\{(.+?)\}\}/g){return r.replace(t,(r,t)=>{const e=n[t.trim()];return null!=e?String(e):""})}export{r as template};
+//# sourceMappingURL=template.js.map

package/dist/esm/string/template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.js","sources":["../../../src/string/template.ts"],"sourcesContent":["/**\n * Simple string template interpolation using `{{key}}` placeholders.\n *\n * @example\n * template('Hello, {{name}}!', { name: 'World' }) // 'Hello, World!'\n * template('{{a}} + {{b}} = {{c}}', { a: 1, b: 2, c: 3 }) // '1 + 2 = 3'\n * template('Hi <name>', { name: 'Ray' }, /<(.+?)>/g) // 'Hi Ray'\n *\n * @param str - Template string\n * @param data - Object with replacement values\n * @param regex - Custom pattern (default: /\\{\\{(.+?)\\}\\}/g)\n * @returns Interpolated string\n */\nexport function template(\n  str: string,\n  data: Record<string, any>,\n  regex: RegExp = /\\{\\{(.+?)\\}\\}/g\n): string {\n  return str.replace(regex, (_, key) => {\n    const value = data[key.trim()];\n    return value !== undefined && value !== null ? String(value) : '';\n  });\n}\n"],"names":["template","str","data","regex","replace","_","key","value","trim","String"],"mappings":"AAaM,SAAUA,EACdC,EACAC,EACAC,EAAgB,kBAEhB,OAAOF,EAAIG,QAAQD,EAAO,CAACE,EAAGC,KAC5B,MAAMC,EAAQL,EAAKI,EAAIE,QACvB,OAAOD,QAAwCE,OAAOF,GAAS,IAEnE"}

package/dist/esm/string/truncateString.js

@@ -0,0 +1,2 @@
+function n(n,t){return n.length>t?n.substring(0,t)+"...":n}export{n as truncateString};
+//# sourceMappingURL=truncateString.js.map

package/dist/esm/string/truncateString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncateString.js","sources":["../../../src/string/truncateString.ts"],"sourcesContent":["/**\n * Truncates a string to a specified maximum length and adds an ellipsis (`...`) if truncated.\n *\n * @example\n * truncateString(\"Hello, world!\", 5) // \"Hello...\"\n * truncateString(\"Short\", 10)        // \"Short\"\n *\n * @param str - The string to truncate\n * @param maxLength - Maximum length of the returned string\n * @returns The truncated string with ellipsis if needed, otherwise the original string\n */\nexport function truncateString(str: string, maxLength: number): string {\n  if (str.length > maxLength) {\n    return str.substring(0, maxLength) + \"...\";\n  }\n  return str;\n}\n"],"names":["truncateString","str","maxLength","length","substring"],"mappings":"AAWM,SAAUA,EAAeC,EAAaC,GAC1C,OAAID,EAAIE,OAASD,EACRD,EAAIG,UAAU,EAAGF,GAAa,MAEhCD,CACT"}

package/dist/esm/string/words.js

@@ -0,0 +1,2 @@
+function e(e){return e?e.replace(/[^a-zA-Z0-9]+/g," ").replace(/([a-z])([A-Z])/g,"$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g,"$1 $2").trim().toLowerCase().split(/\s+/):[]}export{e as words};
+//# sourceMappingURL=words.js.map

package/dist/esm/string/words.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.js","sources":["../../../src/string/words.ts"],"sourcesContent":["/**\n * Splits a string into an array of words.\n * Handles spaces, hyphens, underscores, camelCase, and PascalCase boundaries.\n *\n * @example\n * words('helloWorld') // ['hello', 'world']\n * words('foo-bar_baz') // ['foo', 'bar', 'baz']\n * words('FOO_BAR') // ['foo', 'bar']\n * words('PascalCase') // ['pascal', 'case']\n * words('') // []\n *\n * @param str - String to split\n * @returns Array of lowercase words\n */\nexport function words(str: string): string[] {\n  if (!str) return [];\n\n  return str\n    .replace(/[^a-zA-Z0-9]+/g, ' ')\n    .replace(/([a-z])([A-Z])/g, '$1 $2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')\n    .trim()\n    .toLowerCase()\n    .split(/\\s+/);\n}\n"],"names":["words","str","replace","trim","toLowerCase","split"],"mappings":"AAcM,SAAUA,EAAMC,GACpB,OAAKA,EAEEA,EACJC,QAAQ,iBAAkB,KAC1BA,QAAQ,kBAAmB,SAC3BA,QAAQ,wBAAyB,SACjCC,OACAC,cACAC,MAAM,OARQ,EASnB"}

package/dist/esm/validation/index.js

@@ -0,0 +1,2 @@
+export{validateFileSize}from"./validateFileSizeByType.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/validation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/esm/validation/validateFileSizeByType.js

@@ -0,0 +1,2 @@
+function e(e,i,t,s){const o=t??(e=>e.type.startsWith("image/")?"image":e.type.startsWith("video/")?"video":"document"),r=o(e),d=i[r],a=e.size/1048576;if(void 0!==d&&a>d){return{isValid:!1,errorMessage:s??`File exceeds the limit of ${d} MB for ${r}.`,size:(e=>e.toFixed(2))(a)}}return{isValid:!0}}export{e as validateFileSize};
+//# sourceMappingURL=validateFileSizeByType.js.map

package/dist/esm/validation/validateFileSizeByType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateFileSizeByType.js","sources":["../../../src/validation/validateFileSizeByType.ts"],"sourcesContent":["/**\n * Validates the size of a file based on its type/category.\n * Returns an object indicating whether the file is valid and an optional error message.\n *\n * By default, supports three categories: 'image', 'video', 'document'.\n * You can provide a custom category resolver to extend support for other types.\n *\n * @param {File} file - The file to validate.\n * @param {Record<string, number>} sizeLimits - Maximum allowed sizes for each category in MB.\n * @param {(file: File) => string} [resolveCategory] - Optional function to determine the file's category.\n * @returns {{ isValid: boolean; errorMessage?: string }} Result of the validation.\n *\n * @example\n * const sizeLimits = { image: 5, video: 50, document: 10 };\n * const result = validateFileSize(fileInput.files[0], sizeLimits);\n * if (!result.isValid) {\n *   console.error(result.errorMessage);\n * }\n *\n * @example\n * // Custom category resolver\n * const result = validateFileSize(file, { audio: 10, other: 5 }, file => {\n *   if (file.type.startsWith('audio/')) return 'audio';\n *   return 'other';\n * });\n */\nexport function validateFileSize(\n  file: File,\n  sizeLimits: Record<string, number>,\n  resolveCategory?: (file: File) => string,\n  error?: string\n): { isValid: boolean; errorMessage?: string; size?: string } {\n  const categoryResolver =\n    resolveCategory ??\n    ((file: File) => {\n      if (file.type.startsWith(\"image/\")) return \"image\";\n      if (file.type.startsWith(\"video/\")) return \"video\";\n      return \"document\";\n    });\n\n  const category = categoryResolver(file);\n  const limitMB = sizeLimits[category];\n  const fileSizeMB = file.size / (1024 * 1024);\n\n  if (limitMB !== undefined && fileSizeMB > limitMB) {\n    const formatSize = (size: number) => size.toFixed(2);\n    return {\n      isValid: false,\n      errorMessage:\n        error ?? `File exceeds the limit of ${limitMB} MB for ${category}.`,\n      size: formatSize(fileSizeMB),\n    };\n  }\n\n  return { isValid: true };\n}\n"],"names":["validateFileSize","file","sizeLimits","resolveCategory","error","categoryResolver","type","startsWith","category","limitMB","fileSizeMB","size","undefined","isValid","errorMessage","toFixed","formatSize"],"mappings":"AA0BM,SAAUA,EACdC,EACAC,EACAC,EACAC,GAEA,MAAMC,EACJF,IACEF,GACIA,EAAKK,KAAKC,WAAW,UAAkB,QACvCN,EAAKK,KAAKC,WAAW,UAAkB,QACpC,YAGLC,EAAWH,EAAiBJ,GAC5BQ,EAAUP,EAAWM,GACrBE,EAAaT,EAAKU,KAAI,QAE5B,QAAgBC,IAAZH,GAAyBC,EAAaD,EAAS,CAEjD,MAAO,CACLI,SAAS,EACTC,aACEV,GAAS,6BAA6BK,YAAkBD,KAC1DG,KALiB,CAACA,GAAiBA,EAAKI,QAAQ,GAK1CC,CAAWN,GAErB,CAEA,MAAO,CAAEG,SAAS,EACpB"}

package/dist/types/array/checkValueInArray.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Checks if a value exists for a given key in any object within an array.
+ *
+ * Iterates over the array of objects and returns `true` if **any** object
+ * has the specified key and its value strictly equals the provided value.
+ *
+ * @example
+ * const users = [
+ *   { id: '1', name: 'Alice' },
+ *   { id: '2', name: 'Bob' }
+ * ];
+ *
+ * checkValueInArray(users, 'name', 'Alice') // true
+ * checkValueInArray(users, 'id', '3') // false
+ *
+ * @template T - The type of objects in the array
+ * @param {T[]} array - Array of objects to check
+ * @param {keyof T} key - Key to check in each object
+ * @param {T[keyof T]} value - Value to compare against
+ * @returns {boolean} `true` if at least one object has the key with the given value, otherwise `false`
+ */
+export declare function checkValueInArray<T>(array: T[], key: keyof T, value: T[keyof T]): boolean;
+//# sourceMappingURL=checkValueInArray.d.ts.map

package/dist/types/array/checkValueInArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkValueInArray.d.ts","sourceRoot":"","sources":["../../../src/array/checkValueInArray.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,CAAC,EAAE,EACV,GAAG,EAAE,MAAM,CAAC,EACZ,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,GAChB,OAAO,CAOT"}

package/dist/types/array/chunk.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Splits an array into groups of the specified size.
+ *
+ * @example
+ * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]
+ * chunk([1, 2, 3], 1) // [[1], [2], [3]]
+ * chunk([], 3) // []
+ *
+ * @param arr - Array to split
+ * @param size - Size of each chunk (must be > 0)
+ * @returns Array of chunks
+ * @throws {Error} If size is less than 1
+ */
+export declare function chunk<T>(arr: readonly T[], size: number): T[][];
+//# sourceMappingURL=chunk.d.ts.map

package/dist/types/array/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../src/array/chunk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,CAU/D"}

package/dist/types/array/collectBy.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Splits a list into sub-lists based on a key returned from each item.
+ *
+ * @example
+ * const result = collectBy(
+ *   [
+ *     { type: 'breakfast', item: '☕️' },
+ *     { type: 'lunch', item: '🌯' },
+ *     { type: 'dinner', item: '🍝' },
+ *     { type: 'breakfast', item: '🥐' },
+ *     { type: 'lunch', item: '🍕' }
+ *   ],
+ *   (item) => item.type
+ * );
+ *
+ * @param list Array of items
+ * @param fn Function that extracts a key from each item
+ * @returns Array of groups, each group containing items with same key
+ */
+export declare function collectBy<T, K extends string | number | symbol>(list: T[], fn: (item: T) => K): T[][];
+//# sourceMappingURL=collectBy.d.ts.map

package/dist/types/array/collectBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectBy.d.ts","sourceRoot":"","sources":["../../../src/array/collectBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAC7D,IAAI,EAAE,CAAC,EAAE,EACT,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACjB,CAAC,EAAE,EAAE,CAcP"}

package/dist/types/array/compact.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Removes all falsy values (false, null, 0, '', undefined, NaN) from an array.
+ * Returns a properly narrowed type excluding falsy values.
+ *
+ * @example
+ * compact([0, 1, false, 2, '', 3, null, undefined, NaN])
+ * // [1, 2, 3]
+ *
+ * @example
+ * compact(['hello', '', 'world', null])
+ * // ['hello', 'world']
+ *
+ * @param arr - Array to compact
+ * @returns New array without falsy values
+ */
+type Falsy = false | null | undefined | 0 | '' | 0n;
+export declare function compact<T>(arr: readonly (T | Falsy)[]): Exclude<T, Falsy>[];
+export {};
+//# sourceMappingURL=compact.d.ts.map

package/dist/types/array/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../src/array/compact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,KAAK,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;AAEpD,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,GAAG,KAAK,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,CAE3E"}

package/dist/types/array/countBy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Counts occurrences of each item based on a transformation function.
+ *
+ * @example
+ * countBy(['a', 'b', 'a', 'c', 'b', 'a'], x => x) // { a: 3, b: 2, c: 1 }
+ * countBy([1, 2, 3, 4, 5], x => x % 2 === 0 ? 'even' : 'odd') // { odd: 3, even: 2 }
+ *
+ * @param arr - Array to count
+ * @param fn - Function that returns the group key for each item
+ * @returns Object with keys and their counts
+ */
+export declare function countBy<T>(arr: readonly T[], fn: (item: T) => string | number): Record<string, number>;
+//# sourceMappingURL=countBy.d.ts.map

package/dist/types/array/countBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"countBy.d.ts","sourceRoot":"","sources":["../../../src/array/countBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,GAAG,EAAE,SAAS,CAAC,EAAE,EACjB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,GAC/B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOxB"}

package/dist/types/array/difference.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns elements from the first array that are not in the second array.
+ *
+ * @example
+ * difference([1, 2, 3, 4], [2, 4]) // [1, 3]
+ * difference(['a', 'b', 'c'], ['b']) // ['a', 'c']
+ * difference([1, 2], [1, 2]) // []
+ *
+ * @param arr1 - Source array
+ * @param arr2 - Array of elements to exclude
+ * @returns Array of elements only in arr1
+ */
+export declare function difference<T>(arr1: readonly T[], arr2: readonly T[]): T[];
+//# sourceMappingURL=difference.d.ts.map

package/dist/types/array/difference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.d.ts","sourceRoot":"","sources":["../../../src/array/difference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAGzE"}

package/dist/types/array/drop.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns all but the first n elements of an array.
+ *
+ * @example
+ * drop([1, 2, 3, 4, 5], 2) // [3, 4, 5]
+ * drop([1, 2], 5) // []
+ * drop([], 3) // []
+ *
+ * @param arr - Source array
+ * @param n - Number of elements to drop
+ * @returns New array without the first n elements
+ */
+export declare function drop<T>(arr: readonly T[], n: number): T[];
+//# sourceMappingURL=drop.d.ts.map

package/dist/types/array/drop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../src/array/drop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE,CAEzD"}

package/dist/types/array/dropWhile.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Drops leading elements while predicate returns true, returns the rest.
+ *
+ * @example
+ * dropWhile([1, 2, 3, 4, 1], x => x < 3) // [3, 4, 1]
+ * dropWhile([5, 4, 3], x => x > 3) // [3]
+ *
+ * @param arr - Source array
+ * @param fn - Predicate function
+ * @returns New array without leading elements that pass the predicate
+ */
+export declare function dropWhile<T>(arr: readonly T[], fn: (item: T, index: number) => boolean): T[];
+//# sourceMappingURL=dropWhile.d.ts.map

package/dist/types/array/dropWhile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropWhile.d.ts","sourceRoot":"","sources":["../../../src/array/dropWhile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,CAAC,EAAE,CAG5F"}

package/dist/types/array/first.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the first element of an array, or undefined if empty.
+ *
+ * @example
+ * first([1, 2, 3]) // 1
+ * first([]) // undefined
+ * first(['a', 'b']) // 'a'
+ *
+ * @param arr - Source array
+ * @returns First element or undefined
+ */
+export declare function first<T>(arr: readonly T[]): T | undefined;
+//# sourceMappingURL=first.d.ts.map

package/dist/types/array/first.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first.d.ts","sourceRoot":"","sources":["../../../src/array/first.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAEzD"}

package/dist/types/array/flatten.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Flattens a nested array by one level.
+ *
+ * @example
+ * flatten([[1, 2], [3, 4], [5]]) // [1, 2, 3, 4, 5]
+ * flatten([[1, [2]], [3]]) // [1, [2], 3]
+ * flatten([]) // []
+ *
+ * @param arr - Nested array to flatten
+ * @returns Flattened array (one level)
+ */
+export declare function flatten<T>(arr: readonly (T | readonly T[])[]): T[];
+//# sourceMappingURL=flatten.d.ts.map

package/dist/types/array/flatten.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["../../../src/array/flatten.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAElE"}

package/dist/types/array/groupBy.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Groups array elements by the result of a function.
+ *
+ * @example
+ * groupBy([1, 2, 3, 4], x => x % 2 === 0 ? 'even' : 'odd')
+ * // { odd: [1, 3], even: [2, 4] }
+ *
+ * @example
+ * groupBy([{ type: 'a' }, { type: 'b' }, { type: 'a' }], x => x.type)
+ * // { a: [{ type: 'a' }, { type: 'a' }], b: [{ type: 'b' }] }
+ *
+ * @param list - Array to group
+ * @param fn - Function to determine group key
+ * @returns Object with grouped arrays
+ */
+export declare function groupBy<T>(list: T[], fn: (item: T) => string): Record<string, T[]>;
+//# sourceMappingURL=groupBy.d.ts.map

package/dist/types/array/groupBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groupBy.d.ts","sourceRoot":"","sources":["../../../src/array/groupBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,CAAC,EAAE,EACT,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACtB,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAYrB"}

package/dist/types/array/index.d.ts

@@ -0,0 +1,31 @@
+export { chunk } from './chunk.js';
+export { compact } from './compact.js';
+export { countBy } from './countBy.js';
+export { difference } from './difference.js';
+export { drop } from './drop.js';
+export { dropWhile } from './dropWhile.js';
+export { first } from './first.js';
+export { flatten } from './flatten.js';
+export { groupBy } from './groupBy.js';
+export { intersection } from './intersection.js';
+export { keyBy } from './keyBy.js';
+export { last } from './last.js';
+export { maxBy } from './maxBy.js';
+export { minBy } from './minBy.js';
+export { partition } from './partition.js';
+export { sample } from './sample.js';
+export { shuffle } from './shuffle.js';
+export { sortBy } from './sortBy.js';
+export { take } from './take.js';
+export { takeWhile } from './takeWhile.js';
+export { union } from './union.js';
+export { uniq } from './uniq.js';
+export { uniqBy } from './uniqBy.js';
+export { without } from './without.js';
+export { xor } from './xor.js';
+export { zip } from './zip.js';
+export { zipObject } from './zipObject.js';
+export { collectBy } from './collectBy.js';
+export { checkValueInArray } from './checkValueInArray.js';
+export { sameElementsInArrays } from './sameElementsInArrays.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/array/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/array/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/types/array/intersection.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns elements that exist in both arrays.
+ *
+ * @example
+ * intersection([1, 2, 3], [2, 3, 4]) // [2, 3]
+ * intersection(['a', 'b'], ['b', 'c']) // ['b']
+ * intersection([1, 2], [3, 4]) // []
+ *
+ * @param arr1 - First array
+ * @param arr2 - Second array
+ * @returns Array of common elements
+ */
+export declare function intersection<T>(arr1: readonly T[], arr2: readonly T[]): T[];
+//# sourceMappingURL=intersection.d.ts.map

package/dist/types/array/intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.d.ts","sourceRoot":"","sources":["../../../src/array/intersection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAG3E"}

package/dist/types/array/keyBy.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element through the iteratee. The value of each key is the last
+ * element responsible for generating the key.
+ *
+ * @example
+ * keyBy([{ id: 'a1', name: 'Alice' }, { id: 'b2', name: 'Bob' }], item => item.id)
+ * // { a1: { id: 'a1', name: 'Alice' }, b2: { id: 'b2', name: 'Bob' } }
+ *
+ * @param arr - Array to index
+ * @param fn - Function that returns the key for each element
+ * @returns Object indexed by the generated keys
+ */
+export declare function keyBy<T>(arr: readonly T[], fn: (item: T) => string | number): Record<string | number, T>;
+//# sourceMappingURL=keyBy.d.ts.map

package/dist/types/array/keyBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyBy.d.ts","sourceRoot":"","sources":["../../../src/array/keyBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,GAAG,EAAE,SAAS,CAAC,EAAE,EACjB,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,GAC/B,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC,CAM5B"}

package/dist/types/array/last.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the last element of an array, or undefined if empty.
+ *
+ * @example
+ * last([1, 2, 3]) // 3
+ * last([]) // undefined
+ * last(['a', 'b']) // 'b'
+ *
+ * @param arr - Source array
+ * @returns Last element or undefined
+ */
+export declare function last<T>(arr: readonly T[]): T | undefined;
+//# sourceMappingURL=last.d.ts.map

package/dist/types/array/last.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"last.d.ts","sourceRoot":"","sources":["../../../src/array/last.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAExD"}

package/dist/types/array/maxBy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the element with the maximum value as determined by a function.
+ *
+ * @example
+ * maxBy([{ age: 30 }, { age: 20 }, { age: 25 }], x => x.age) // { age: 30 }
+ * maxBy([], x => x) // undefined
+ *
+ * @param arr - Array to search
+ * @param fn - Function that returns a numeric value for comparison
+ * @returns Element with the maximum value, or undefined if empty
+ */
+export declare function maxBy<T>(arr: readonly T[], fn: (item: T) => number): T | undefined;
+//# sourceMappingURL=maxBy.d.ts.map

package/dist/types/array/maxBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maxBy.d.ts","sourceRoot":"","sources":["../../../src/array/maxBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,CAAC,GAAG,SAAS,CAYlF"}

package/dist/types/array/minBy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns the element with the minimum value as determined by a function.
+ *
+ * @example
+ * minBy([{ age: 30 }, { age: 20 }, { age: 25 }], x => x.age) // { age: 20 }
+ * minBy([], x => x) // undefined
+ *
+ * @param arr - Array to search
+ * @param fn - Function that returns a numeric value for comparison
+ * @returns Element with the minimum value, or undefined if empty
+ */
+export declare function minBy<T>(arr: readonly T[], fn: (item: T) => number): T | undefined;
+//# sourceMappingURL=minBy.d.ts.map

package/dist/types/array/minBy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minBy.d.ts","sourceRoot":"","sources":["../../../src/array/minBy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,CAAC,GAAG,SAAS,CAYlF"}

package/dist/types/array/partition.d.ts

@@ -0,0 +1,13 @@
+import type { Predicate } from '../types/index.js';
+/**
+ * Partitions an array into two arrays based on a predicate.
+ *
+ * @example
+ * partition([1, 2, 3, 4], x => x > 2) // [[3, 4], [1, 2]]
+ *
+ * @param list - Array to partition
+ * @param predicate - Function to test each element
+ * @returns Tuple of [passed, failed] arrays
+ */
+export declare function partition<T>(list: T[], predicate: Predicate<T>): [T[], T[]];
+//# sourceMappingURL=partition.d.ts.map

package/dist/types/array/partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../src/array/partition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAa3E"}

package/dist/types/array/sameElementsInArrays.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Finds the first element that exists in all provided arrays.
+ *
+ * Works with any type (numbers, strings, booleans, etc.).
+ *
+ * @example
+ * sameElementInMultipleArrays([1, 2, 3], [3, 4, 5], [3, 6]) // 3
+ * sameElementInMultipleArrays(['a', 'b'], ['b', 'c'], ['b', 'd']) // 'b'
+ * sameElementInMultipleArrays([1, 2], [3, 4]) // null
+ *
+ * @param {...T[][]} arrays - Two or more arrays to check
+ * @returns {T | null} The first element found in all arrays, or `null` if none found
+ */
+export declare const sameElementsInArrays: <T>(...arrays: T[][]) => T | null;
+//# sourceMappingURL=sameElementsInArrays.d.ts.map

package/dist/types/array/sameElementsInArrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sameElementsInArrays.d.ts","sourceRoot":"","sources":["../../../src/array/sameElementsInArrays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,EAAE,GAAG,QAAQ,CAAC,EAAE,EAAE,KAAG,CAAC,GAAG,IAK9D,CAAC"}

package/dist/types/array/sample.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns a random element from an array.
+ *
+ * @example
+ * sample([1, 2, 3, 4, 5]) // random element
+ * sample(['a', 'b', 'c']) // random element
+ *
+ * @param arr - Source array
+ * @returns Random element, or undefined if empty
+ */
+export declare function sample<T>(arr: readonly T[]): T | undefined;
+//# sourceMappingURL=sample.d.ts.map

package/dist/types/array/sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample.d.ts","sourceRoot":"","sources":["../../../src/array/sample.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAG1D"}