@vinicunca/perkakas 1.13.2 → 1.15.0

package/dist/take-last.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-last.cjs","names":["curry"],"sources":["../src/take-last.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Takes the last `n` elements from the `array`.\n *\n * @param array - The target array.\n * @param n - The number of elements to take.\n * @signature\n *    takeLast(array, n)\n * @example\n *    takeLast([1, 2, 3, 4, 5], 2) // => [4, 5]\n * @dataFirst\n * @category Array\n */\nexport function takeLast<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]>;\n\n/**\n * Take the last `n` elements from the `array`.\n *\n * @param n - The number of elements to take.\n * @signature\n *    takeLast(n)(array)\n * @example\n *    takeLast(2)([1, 2, 3, 4, 5]) // => [4, 5]\n * @dataLast\n * @category Array\n */\nexport function takeLast<T extends IterableContainer>(\n  n: number,\n): (array: T) => Array<T[number]>;\n\nexport function takeLast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeLastImplementation, args);\n}\n\nfunction takeLastImplementation<T extends IterableContainer>(array: T, n: number): Array<T[number]> {\n  return n > 0 ? array.slice(Math.max(0, array.length - n)) : [];\n}\n"],"mappings":"kGAmCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAG5C,SAAS,EAAoD,EAAU,EAA6B,CAClG,OAAO,EAAI,EAAI,EAAM,MAAM,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,EAAE"}

package/dist/take-last.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return t>0?e.slice(Math.max(0,e.length-t)):[]}export{t as takeLast};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){return t>0?e.slice(Math.max(0,e.length-t)):[]}export{t as takeLast};
 //# sourceMappingURL=take-last.js.map

package/dist/take-last.js.map

@@ -1 +1 @@
-{"version":3,"file":"take-last.js","names":[],"sources":["../src/take-last.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\n\nimport { curry } from './curry';\n\n/**\n * Takes the last `n` elements from the `array`.\n *\n * @param array - The target array.\n * @param n - The number of elements to take.\n * @signature\n *    P.takeLast(array, n)\n * @example\n *    P.takeLast([1, 2, 3, 4, 5], 2) // => [4, 5]\n * @dataFirst\n * @category Array\n */\nexport function takeLast<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]>;\n/**\n * Take the last `n` elements from the `array`.\n *\n * @param n - The number of elements to take.\n * @signature\n *    P.takeLast(n)(array)\n * @example\n *    P.takeLast(2)([1, 2, 3, 4, 5]) // => [4, 5]\n * @dataLast\n * @category Array\n */\nexport function takeLast<T extends IterableContainer>(\n  n: number,\n): (array: T) => Array<T[number]>;\n\nexport function takeLast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeLastImplementation, args);\n}\n\nfunction takeLastImplementation<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]> {\n  return n > 0 ? array.slice(Math.max(0, array.length - n)) : [];\n}\n"],"mappings":"wCAmCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACkB,CAClB,OAAO,EAAI,EAAI,EAAM,MAAM,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,EAAE"}
+{"version":3,"file":"take-last.js","names":[],"sources":["../src/take-last.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Takes the last `n` elements from the `array`.\n *\n * @param array - The target array.\n * @param n - The number of elements to take.\n * @signature\n *    takeLast(array, n)\n * @example\n *    takeLast([1, 2, 3, 4, 5], 2) // => [4, 5]\n * @dataFirst\n * @category Array\n */\nexport function takeLast<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]>;\n\n/**\n * Take the last `n` elements from the `array`.\n *\n * @param n - The number of elements to take.\n * @signature\n *    takeLast(n)(array)\n * @example\n *    takeLast(2)([1, 2, 3, 4, 5]) // => [4, 5]\n * @dataLast\n * @category Array\n */\nexport function takeLast<T extends IterableContainer>(\n  n: number,\n): (array: T) => Array<T[number]>;\n\nexport function takeLast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeLastImplementation, args);\n}\n\nfunction takeLastImplementation<T extends IterableContainer>(array: T, n: number): Array<T[number]> {\n  return n > 0 ? array.slice(Math.max(0, array.length - n)) : [];\n}\n"],"mappings":"mCAmCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EAAoD,EAAU,EAA6B,CAClG,OAAO,EAAI,EAAI,EAAM,MAAM,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,EAAE"}

package/dist/take-while.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n=[];for(let[r,i]of e.entries()){if(!t(i,r,e))break;n.push(i)}return n}exports.takeWhile=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n=[];for(let[r,i]of e.entries()){if(!t(i,r,e))break;n.push(i)}return n}exports.takeWhile=t;
+//# sourceMappingURL=take-while.cjs.map

package/dist/take-while.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.cjs","names":["curry"],"sources":["../src/take-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Returns elements from the array until predicate returns false.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    takeWhile(data, predicate)\n * @example\n *    takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]\n * @dataFirst\n * @category Array\n */\nexport function takeWhile<T extends IterableContainer, S extends T[number]>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): Array<S>;\nexport function takeWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]>;\n\n/**\n * Returns elements from the array until predicate returns false.\n *\n * @param predicate - The predicate.\n * @signature\n *    takeWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 3, 4, 3, 2, 1], takeWhile(x => x !== 4))  // => [1, 2, 3]\n * @dataLast\n * @category Array\n */\nexport function takeWhile<T extends IterableContainer, S extends T[number]>(\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): (array: T) => Array<S>;\nexport function takeWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (array: T) => Array<T[number]>;\n\nexport function takeWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeWhileImplementation, args);\n}\n\nfunction takeWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  const ret: Array<T[number]> = [];\n  for (const [index, item] of data.entries()) {\n    if (!predicate(item, index, data)) {\n      break;\n    }\n    ret.push(item);\n  }\n  return ret;\n}\n"],"mappings":"kGA0CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACkB,CAClB,IAAM,EAAwB,EAAE,CAChC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,GAAI,CAAC,EAAU,EAAM,EAAO,EAAK,CAC/B,MAEF,EAAI,KAAK,EAAK,CAEhB,OAAO"}

package/dist/take-while.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n=[];for(let[r,i]of e.entries()){if(!t(i,r,e))break;n.push(i)}return n}export{t as takeWhile};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){let n=[];for(let[r,i]of e.entries()){if(!t(i,r,e))break;n.push(i)}return n}export{t as takeWhile};
 //# sourceMappingURL=take-while.js.map

package/dist/take-while.js.map

@@ -1 +1 @@
-{"version":3,"file":"take-while.js","names":["ret: Array<T[number]>"],"sources":["../src/take-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\n\nimport { curry } from './curry';\n\n/**\n * Returns elements from the array until predicate returns false.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    P.takeWhile(data, predicate)\n * @example\n *    P.takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]\n * @dataFirst\n * @category Array\n */\nexport function takeWhile<T extends IterableContainer, S extends T[number]>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): Array<S>;\nexport function takeWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]>;\n\n/**\n * Returns elements from the array until predicate returns false.\n *\n * @param predicate - The predicate.\n * @signature\n *    P.takeWhile(predicate)(data)\n * @example\n *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.takeWhile(x => x !== 4))  // => [1, 2, 3]\n * @dataLast\n * @category Array\n */\nexport function takeWhile<T extends IterableContainer, S extends T[number]>(\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): (array: T) => Array<S>;\nexport function takeWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (array: T) => Array<T[number]>;\n\nexport function takeWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeWhileImplementation, args);\n}\n\nfunction takeWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  const ret: Array<T[number]> = [];\n  for (const [index, item] of data.entries()) {\n    if (!predicate(item, index, data)) {\n      break;\n    }\n    ret.push(item);\n  }\n  return ret;\n}\n"],"mappings":"wCA2CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACkB,CAClB,IAAMA,EAAwB,EAAE,CAChC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,GAAI,CAAC,EAAU,EAAM,EAAO,EAAK,CAC/B,MAEF,EAAI,KAAK,EAAK,CAEhB,OAAO"}
+{"version":3,"file":"take-while.js","names":[],"sources":["../src/take-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Returns elements from the array until predicate returns false.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    takeWhile(data, predicate)\n * @example\n *    takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]\n * @dataFirst\n * @category Array\n */\nexport function takeWhile<T extends IterableContainer, S extends T[number]>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): Array<S>;\nexport function takeWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]>;\n\n/**\n * Returns elements from the array until predicate returns false.\n *\n * @param predicate - The predicate.\n * @signature\n *    takeWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 3, 4, 3, 2, 1], takeWhile(x => x !== 4))  // => [1, 2, 3]\n * @dataLast\n * @category Array\n */\nexport function takeWhile<T extends IterableContainer, S extends T[number]>(\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): (array: T) => Array<S>;\nexport function takeWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (array: T) => Array<T[number]>;\n\nexport function takeWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeWhileImplementation, args);\n}\n\nfunction takeWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  const ret: Array<T[number]> = [];\n  for (const [index, item] of data.entries()) {\n    if (!predicate(item, index, data)) {\n      break;\n    }\n    ret.push(item);\n  }\n  return ret;\n}\n"],"mappings":"mCA0CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACkB,CAClB,IAAM,EAAwB,EAAE,CAChC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,GAAI,CAAC,EAAU,EAAM,EAAO,EAAK,CAC/B,MAEF,EAAI,KAAK,EAAK,CAEhB,OAAO"}

package/dist/take.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./utility-evaluators-CAbODbuk.cjs`);function n(...t){return e.t(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t.n;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}exports.take=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./utility-evaluators-C8koSp9T.cjs`);function n(...t){return e.curry(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t.n;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}exports.take=n;
+//# sourceMappingURL=take.cjs.map

package/dist/take.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.cjs","names":["curry","lazyEmptyEvaluator"],"sources":["../src/take.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { lazyEmptyEvaluator } from './internal/utility-evaluators';\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param array - The array.\n * @param n - The number of elements to take.\n * @signature\n *    take(array, n)\n * @example\n *    take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function take<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]>;\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param n - The number of elements to take.\n * @signature\n *    take(n)(array)\n * @example\n *    pipe([1, 2, 3, 4, 3, 2, 1], take(3)) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function take(\n  n: number,\n): <T extends IterableContainer>(array: T) => Array<T[number]>;\n\nexport function take(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeImplementation, args, lazyImplementation);\n}\n\nfunction takeImplementation<T extends IterableContainer>(array: T, n: number): Array<T[number]> {\n  return n < 0 ? [] : array.slice(0, n);\n}\n\nfunction lazyImplementation<T>(n: number): LazyEvaluator<T> {\n  if (n <= 0) {\n    return lazyEmptyEvaluator;\n  }\n\n  let remaining = n;\n  return (value) => {\n    remaining -= 1;\n    return { done: remaining <= 0, hasNext: true, next: value };\n  };\n}\n"],"mappings":"iJAuCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAM,EAAmB,CAG5D,SAAS,EAAgD,EAAU,EAA6B,CAC9F,OAAO,EAAI,EAAI,EAAE,CAAG,EAAM,MAAM,EAAG,EAAE,CAGvC,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAOC,EAAAA,EAGT,IAAI,EAAY,EAChB,MAAQ,KACN,IACO,CAAE,KAAM,GAAa,EAAG,QAAS,GAAM,KAAM,EAAO"}

package/dist/take.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{n as t}from"./utility-evaluators-Boc-TMbq.js";function n(...t){return e(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}export{n as take};
+import{curry as e}from"./curry.js";import{n as t}from"./utility-evaluators-ZAaUtL2Z.js";function n(...t){return e(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}export{n as take};
 //# sourceMappingURL=take.js.map

package/dist/take.js.map

@@ -1 +1 @@
-{"version":3,"file":"take.js","names":[],"sources":["../src/take.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curry } from './curry';\nimport { lazyEmptyEvaluator } from './internal/utility-evaluators';\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param array - The array.\n * @param n - The number of elements to take.\n * @signature\n *    P.take(array, n)\n * @example\n *    P.take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function take<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]>;\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param n - The number of elements to take.\n * @signature\n *    P.take(n)(array)\n * @example\n *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.take(n)) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function take(\n  n: number,\n): <T extends IterableContainer>(array: T) => Array<T[number]>;\n\nexport function take(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeImplementation, args, lazyImplementation);\n}\n\nfunction takeImplementation<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]> {\n  return n < 0 ? [] : array.slice(0, n);\n}\n\nfunction lazyImplementation<T>(n: number): LazyEvaluator<T> {\n  if (n <= 0) {\n    return lazyEmptyEvaluator;\n  }\n\n  let remaining = n;\n  return (value) => {\n    remaining -= 1;\n    return { done: remaining <= 0, hasNext: true, next: value };\n  };\n}\n"],"mappings":"6FAwCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,EAAmB,CAG5D,SAAS,EACP,EACA,EACkB,CAClB,OAAO,EAAI,EAAI,EAAE,CAAG,EAAM,MAAM,EAAG,EAAE,CAGvC,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAO,EAGT,IAAI,EAAY,EAChB,MAAQ,KACN,IACO,CAAE,KAAM,GAAa,EAAG,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"take.js","names":[],"sources":["../src/take.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { lazyEmptyEvaluator } from './internal/utility-evaluators';\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param array - The array.\n * @param n - The number of elements to take.\n * @signature\n *    take(array, n)\n * @example\n *    take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function take<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]>;\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param n - The number of elements to take.\n * @signature\n *    take(n)(array)\n * @example\n *    pipe([1, 2, 3, 4, 3, 2, 1], take(3)) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function take(\n  n: number,\n): <T extends IterableContainer>(array: T) => Array<T[number]>;\n\nexport function take(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeImplementation, args, lazyImplementation);\n}\n\nfunction takeImplementation<T extends IterableContainer>(array: T, n: number): Array<T[number]> {\n  return n < 0 ? [] : array.slice(0, n);\n}\n\nfunction lazyImplementation<T>(n: number): LazyEvaluator<T> {\n  if (n <= 0) {\n    return lazyEmptyEvaluator;\n  }\n\n  let remaining = n;\n  return (value) => {\n    remaining -= 1;\n    return { done: remaining <= 0, hasNext: true, next: value };\n  };\n}\n"],"mappings":"wFAuCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,EAAmB,CAG5D,SAAS,EAAgD,EAAU,EAA6B,CAC9F,OAAO,EAAI,EAAI,EAAE,CAAG,EAAM,MAAM,EAAG,EAAE,CAGvC,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAO,EAGT,IAAI,EAAY,EAChB,MAAQ,KACN,IACO,CAAE,KAAM,GAAa,EAAG,QAAS,GAAM,KAAM,EAAO"}

package/dist/tap.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return t(e),e}exports.tap=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return t(e),e}exports.tap=t;
+//# sourceMappingURL=tap.cjs.map

package/dist/tap.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.cjs","names":["curry"],"sources":["../src/tap.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Calls the given function with the given value, then returns the given value.\n * The return value of the provided function is ignored.\n *\n * This allows \"tapping into\" a function sequence in a pipe, to perform side\n * effects on intermediate results.\n *\n * @param value - The value to pass into the function.\n * @param fn - The function to call.\n * @signature\n *    tap(value, fn)\n * @example\n *    tap(\"foo\", console.log) // => \"foo\"\n * @dataFirst\n * @category Other\n */\nexport function tap<T>(value: T, fn: (value: T) => void): T;\n\n/**\n * Calls the given function with the given value, then returns the given value.\n * The return value of the provided function is ignored.\n *\n * This allows \"tapping into\" a function sequence in a pipe, to perform side\n * effects on intermediate results.\n *\n * @param fn - The function to call.\n * @signature\n *    tap(fn)(value)\n * @example\n *    pipe(\n *      [-5, -1, 2, 3],\n *      filter(n => n > 0),\n *      tap(console.log), // prints [2, 3]\n *      map(n => n * 2)\n *    ) // => [4, 6]\n * @dataLast\n * @category Other\n */\nexport function tap<\n  T,\n  F extends (value: T) => unknown,\n>(fn: F): (value: T) => T;\n\nexport function tap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(tapImplementation, args);\n}\n\nfunction tapImplementation<T>(value: T, fn: (value: T) => void): T {\n  fn(value);\n  return value;\n}\n"],"mappings":"kGA6CA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAOA,EAAAA,MAAM,EAAmB,EAAK,CAGvC,SAAS,EAAqB,EAAU,EAA2B,CAEjE,OADA,EAAG,EAAM,CACF"}

package/dist/tap.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return t(e),e}export{t as tap};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){return t(e),e}export{t as tap};
 //# sourceMappingURL=tap.js.map

package/dist/tap.js.map

@@ -1 +1 @@
-{"version":3,"file":"tap.js","names":[],"sources":["../src/tap.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Calls the given function with the given value, then returns the given value.\n * The return value of the provided function is ignored.\n *\n * This allows \"tapping into\" a function sequence in a pipe, to perform side\n * effects on intermediate results.\n *\n * @param value - The value to pass into the function.\n * @param fn - The function to call.\n * @signature\n *    P.tap(value, fn)\n * @example\n *    P.tap(\"foo\", console.log) // => \"foo\"\n * @dataFirst\n * @category Other\n */\nexport function tap<T>(value: T, fn: (value: T) => void): T;\n\n/**\n * Calls the given function with the given value, then returns the given value.\n * The return value of the provided function is ignored.\n *\n * This allows \"tapping into\" a function sequence in a pipe, to perform side\n * effects on intermediate results.\n *\n * @param fn - The function to call.\n * @signature\n *    P.tap(fn)(value)\n * @example\n *    P.pipe(\n *      [-5, -1, 2, 3],\n *      P.filter(n => n > 0),\n *      P.tap(console.log), // prints [2, 3]\n *      P.map(n => n * 2)\n *    ) // => [4, 6]\n * @dataLast\n * @category Other\n */\nexport function tap<T, F extends (value: T) => unknown>(fn: F): (value: T) => T;\n\nexport function tap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(tapImplementation, args);\n}\n\nfunction tapImplementation<T>(value: T, fn: (value: T) => void): T {\n  fn(value);\n  return value;\n}\n"],"mappings":"wCA0CA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EAAqB,EAAU,EAA2B,CAEjE,OADA,EAAG,EAAM,CACF"}
+{"version":3,"file":"tap.js","names":[],"sources":["../src/tap.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Calls the given function with the given value, then returns the given value.\n * The return value of the provided function is ignored.\n *\n * This allows \"tapping into\" a function sequence in a pipe, to perform side\n * effects on intermediate results.\n *\n * @param value - The value to pass into the function.\n * @param fn - The function to call.\n * @signature\n *    tap(value, fn)\n * @example\n *    tap(\"foo\", console.log) // => \"foo\"\n * @dataFirst\n * @category Other\n */\nexport function tap<T>(value: T, fn: (value: T) => void): T;\n\n/**\n * Calls the given function with the given value, then returns the given value.\n * The return value of the provided function is ignored.\n *\n * This allows \"tapping into\" a function sequence in a pipe, to perform side\n * effects on intermediate results.\n *\n * @param fn - The function to call.\n * @signature\n *    tap(fn)(value)\n * @example\n *    pipe(\n *      [-5, -1, 2, 3],\n *      filter(n => n > 0),\n *      tap(console.log), // prints [2, 3]\n *      map(n => n * 2)\n *    ) // => [4, 6]\n * @dataLast\n * @category Other\n */\nexport function tap<\n  T,\n  F extends (value: T) => unknown,\n>(fn: F): (value: T) => T;\n\nexport function tap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(tapImplementation, args);\n}\n\nfunction tapImplementation<T>(value: T, fn: (value: T) => void): T {\n  fn(value);\n  return value;\n}\n"],"mappings":"mCA6CA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EAAqB,EAAU,EAA2B,CAEjE,OADA,EAAG,EAAM,CACF"}

package/dist/times.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){if(e<1)return[];let n=Number.isInteger(e)?e:Math.floor(e),r=Array(n);for(let e=0;e<n;e++)r[e]=t(e);return r}exports.times=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(e<1)return[];let n=Number.isInteger(e)?e:Math.floor(e),r=Array(n);for(let e=0;e<n;e++)r[e]=t(e);return r}exports.times=t;
+//# sourceMappingURL=times.cjs.map

package/dist/times.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"times.cjs","names":["curry"],"sources":["../src/times.ts"],"sourcesContent":["import type { GreaterThan } from 'type-fest';\nimport { curry } from './curry';\n\n// This number was picked by trial-and-error until typescript stops failing with\n// \"Type instantiation is excessively deep and possibly infinite. (ts2589)\".\n// See the type tests for more information.\ntype MAX_LITERAL_SIZE = 46;\n\ntype TimesArray<\n  T,\n  N extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = number extends N\n  ? // N is not a literal number, we can't deduce the type\n  Array<T>\n  : `${N}` extends `-${number}`\n    ? // N is non-positive, the mapper will never run\n      []\n    : `${N}` extends `${infer K extends number}.${number}`\n      ? // N is not an integer, we \"floor\" the number.\n      TimesArray<T, K, Iteration>\n      : GreaterThan<N, MAX_LITERAL_SIZE> extends true\n        ? // We can't build a literal tuple beyond this size, after that we\n          // can't add more items to the tuple so we add a rest element instead.\n          [...TimesArray<T, MAX_LITERAL_SIZE, Iteration>, ...Array<T>]\n        : N extends Iteration['length']\n          ? // We finished building the output tuple\n            []\n          : // Add another item to the tuple and recurse.\n            [T, ...TimesArray<T, N, [unknown, ...Iteration]>];\n\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @param count - A value between `0` and `n - 1`. Increments after each\n * function call.\n * @param fn - The function to invoke. Passed one argument, the current value of\n * `n`.\n * @returns An array containing the return values of all calls to `fn`.\n * @signature\n *    times(count, fn)\n * @example\n *    times(5, identity()); //=> [0, 1, 2, 3, 4]\n * @dataFirst\n * @category Array\n */\nexport function times<T, N extends number>(\n  count: N,\n  fn: (index: number) => T,\n): TimesArray<T, N>;\n\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @param fn - The function to invoke. Passed one argument, the current value of\n * `n`.\n * @returns An array containing the return values of all calls to `fn`.\n * @signature\n *    times(fn)(count)\n * @example\n *    times(identity())(5); //=> [0, 1, 2, 3, 4]\n * @dataLast\n * @category Array\n */\nexport function times<T>(\n  fn: (index: number) => T,\n): <N extends number>(count: N) => TimesArray<T, N>;\n\nexport function times(...args: ReadonlyArray<unknown>): unknown {\n  return curry(timesImplementation, args);\n}\n\nfunction timesImplementation<T>(count: number, fn: (index: number) => T): Array<T> {\n  if (count < 1) {\n    // We prefer to return trivial results on trivial inputs vs throwing errors.\n    return [];\n  }\n\n  // Non-integer numbers would cause `new Array` to throw, but it makes more\n  // sense to simply round them down to the nearest integer instead; but\n  // rounding has some performance implications so we only do it when we have to\n  const length = Number.isInteger(count) ? count : Math.floor(count);\n\n  // eslint-disable-next-line unicorn/no-new-array -- This is the most efficient way to create the array, check out the benchmarks in the PR that added this comment.\n  const res = new Array<T>(length);\n\n  for (let i = 0; i < length; i++) {\n    res[i] = fn(i);\n  }\n\n  return res;\n}\n"],"mappings":"kGA4EA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EAAuB,EAAe,EAAoC,CACjF,GAAI,EAAQ,EAEV,MAAO,EAAE,CAMX,IAAM,EAAS,OAAO,UAAU,EAAM,CAAG,EAAQ,KAAK,MAAM,EAAM,CAG5D,EAAU,MAAS,EAAO,CAEhC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAI,GAAK,EAAG,EAAE,CAGhB,OAAO"}

package/dist/times.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){if(e<1)return[];let n=Number.isInteger(e)?e:Math.floor(e),r=Array(n);for(let e=0;e<n;e++)r[e]=t(e);return r}export{t as times};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){if(e<1)return[];let n=Number.isInteger(e)?e:Math.floor(e),r=Array(n);for(let e=0;e<n;e++)r[e]=t(e);return r}export{t as times};
 //# sourceMappingURL=times.js.map

package/dist/times.js.map

@@ -1 +1 @@
-{"version":3,"file":"times.js","names":[],"sources":["../src/times.ts"],"sourcesContent":["import type { GreaterThan } from 'type-fest';\n\nimport { curry } from './curry';\n\n// This number was picked by trial-and-error until typescript stops failing with\n// \"Type instantiation is excessively deep and possibly infinite. (ts2589)\".\n// See the type tests for more information.\ntype MAX_LITERAL_SIZE = 46;\n\ntype TimesArray<\n  T,\n  N extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = number extends N\n  // N is not a literal number, we can't deduce the type\n  ? Array<T>\n  : `${N}` extends `-${number}`\n    // N is non-positive, the mapper will never run\n    ? []\n    : `${N}` extends `${infer K extends number}.${number}`\n      // N is not an integer, we \"floor\" the number.\n      ? TimesArray<T, K, Iteration>\n      : GreaterThan<N, MAX_LITERAL_SIZE> extends true\n        // We can't build a literal tuple beyond this size, after that we\n        // can't add more items to the tuple so we add a rest element instead.\n        ? [...TimesArray<T, MAX_LITERAL_SIZE, Iteration>, ...Array<T>]\n        : N extends Iteration['length']\n          // We finished building the output tuple\n          ? []\n          // Add another item to the tuple and recurse.\n          : [T, ...TimesArray<T, N, [unknown, ...Iteration]>];\n\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @param count - A value between `0` and `n - 1`. Increments after each\n * function call.\n * @param fn - The function to invoke. Passed one argument, the current value of\n * `n`.\n * @signature\n *   P.times(count, fn)\n * @example\n *   P.times(5, identity()); //=> [0, 1, 2, 3, 4]\n *\n * @dataFirst\n * @category Array\n */\nexport function times<T, N extends number>(\n  count: N,\n  fn: (index: number) => T,\n): TimesArray<T, N>;\n\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @param fn - The function to invoke. Passed one argument, the current value of\n * `n`.\n * @returns An array containing the return values of all calls to `fn`.\n *\n * @signature\n *   P.times(count, fn)\n * @example\n *   P.times(identity())(5); //=> [0, 1, 2, 3, 4]\n *\n * @dataLast\n * @category Array\n */\nexport function times<T>(\n  fn: (index: number) => T,\n): <N extends number>(count: N) => TimesArray<T, N>;\n\nexport function times(...args: ReadonlyArray<unknown>): unknown {\n  return curry(timesImplementation, args);\n}\n\nfunction timesImplementation<T>(\n  count: number,\n  fn: (index: number) => T,\n): Array<T> {\n  if (count < 1) {\n    // We prefer to return trivial results on trivial inputs vs throwing errors.\n    return [];\n  }\n\n  // Non-integer numbers would cause `new Array` to throw, but it makes more\n  // sense to simply round them down to the nearest integer instead; but\n  // rounding has some performance implications so we only do it when we have to\n  const length = Number.isInteger(count) ? count : Math.floor(count);\n\n  // eslint-disable-next-line unicorn/no-new-array -- This is the most efficient way to create the array, check out the benchmarks in the PR that added this comment.\n  const res = new Array<T>(length);\n\n  for (let i = 0; i < length; i++) {\n    res[i] = fn(i);\n  }\n\n  return res;\n}\n"],"mappings":"wCA+EA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACU,CACV,GAAI,EAAQ,EAEV,MAAO,EAAE,CAMX,IAAM,EAAS,OAAO,UAAU,EAAM,CAAG,EAAQ,KAAK,MAAM,EAAM,CAG5D,EAAU,MAAS,EAAO,CAEhC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAI,GAAK,EAAG,EAAE,CAGhB,OAAO"}
+{"version":3,"file":"times.js","names":[],"sources":["../src/times.ts"],"sourcesContent":["import type { GreaterThan } from 'type-fest';\nimport { curry } from './curry';\n\n// This number was picked by trial-and-error until typescript stops failing with\n// \"Type instantiation is excessively deep and possibly infinite. (ts2589)\".\n// See the type tests for more information.\ntype MAX_LITERAL_SIZE = 46;\n\ntype TimesArray<\n  T,\n  N extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = number extends N\n  ? // N is not a literal number, we can't deduce the type\n  Array<T>\n  : `${N}` extends `-${number}`\n    ? // N is non-positive, the mapper will never run\n      []\n    : `${N}` extends `${infer K extends number}.${number}`\n      ? // N is not an integer, we \"floor\" the number.\n      TimesArray<T, K, Iteration>\n      : GreaterThan<N, MAX_LITERAL_SIZE> extends true\n        ? // We can't build a literal tuple beyond this size, after that we\n          // can't add more items to the tuple so we add a rest element instead.\n          [...TimesArray<T, MAX_LITERAL_SIZE, Iteration>, ...Array<T>]\n        : N extends Iteration['length']\n          ? // We finished building the output tuple\n            []\n          : // Add another item to the tuple and recurse.\n            [T, ...TimesArray<T, N, [unknown, ...Iteration]>];\n\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @param count - A value between `0` and `n - 1`. Increments after each\n * function call.\n * @param fn - The function to invoke. Passed one argument, the current value of\n * `n`.\n * @returns An array containing the return values of all calls to `fn`.\n * @signature\n *    times(count, fn)\n * @example\n *    times(5, identity()); //=> [0, 1, 2, 3, 4]\n * @dataFirst\n * @category Array\n */\nexport function times<T, N extends number>(\n  count: N,\n  fn: (index: number) => T,\n): TimesArray<T, N>;\n\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @param fn - The function to invoke. Passed one argument, the current value of\n * `n`.\n * @returns An array containing the return values of all calls to `fn`.\n * @signature\n *    times(fn)(count)\n * @example\n *    times(identity())(5); //=> [0, 1, 2, 3, 4]\n * @dataLast\n * @category Array\n */\nexport function times<T>(\n  fn: (index: number) => T,\n): <N extends number>(count: N) => TimesArray<T, N>;\n\nexport function times(...args: ReadonlyArray<unknown>): unknown {\n  return curry(timesImplementation, args);\n}\n\nfunction timesImplementation<T>(count: number, fn: (index: number) => T): Array<T> {\n  if (count < 1) {\n    // We prefer to return trivial results on trivial inputs vs throwing errors.\n    return [];\n  }\n\n  // Non-integer numbers would cause `new Array` to throw, but it makes more\n  // sense to simply round them down to the nearest integer instead; but\n  // rounding has some performance implications so we only do it when we have to\n  const length = Number.isInteger(count) ? count : Math.floor(count);\n\n  // eslint-disable-next-line unicorn/no-new-array -- This is the most efficient way to create the array, check out the benchmarks in the PR that added this comment.\n  const res = new Array<T>(length);\n\n  for (let i = 0; i < length; i++) {\n    res[i] = fn(i);\n  }\n\n  return res;\n}\n"],"mappings":"mCA4EA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAAuB,EAAe,EAAoC,CACjF,GAAI,EAAQ,EAEV,MAAO,EAAE,CAMX,IAAM,EAAS,OAAO,UAAU,EAAM,CAAG,EAAQ,KAAK,MAAM,EAAM,CAG5D,EAAU,MAAS,EAAO,CAEhC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAI,GAAK,EAAG,EAAE,CAGhB,OAAO"}

package/dist/to-camel-case.cjs

@@ -1 +1,2 @@
-const e=require(`./words-DRQKxzLU.cjs`),t=/[a-z]/u,n=!0;function r(e,t){return typeof e==`string`?i(e,t):t=>i(t,e)}function i(n,{preserveConsecutiveUppercase:r=!0}={}){return e.t(t.test(n)?n:n.toLowerCase()).map((e,t)=>`${t===0?e[0].toLowerCase():e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(``)}exports.toCamelCase=r;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./words-_h74qi45.cjs`),t=/[a-z]/u;function n(e,t){return typeof e==`string`?r(e,t):t=>r(t,e)}function r(n,{preserveConsecutiveUppercase:r=!0}={}){return e.t(t.test(n)?n:n.toLowerCase()).map((e,t)=>`${t===0?e[0].toLowerCase():e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(``)}exports.toCamelCase=n;
+//# sourceMappingURL=to-camel-case.cjs.map

package/dist/to-camel-case.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-camel-case.cjs","names":["words"],"sources":["../src/to-camel-case.ts"],"sourcesContent":["import type {\n  CamelCaseOptions as BaseCamelCaseOptions,\n  CamelCase,\n} from 'type-fest';\nimport type { OptionalOptionsWithDefaults } from './internal/types/optional-options-with-defaults';\nimport { words } from './internal/words';\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ninterface CamelCaseOptions {\n  readonly preserveConsecutiveUppercase?: boolean;\n}\n\ntype CamelCaseOptionsWithDefaults<Options extends CamelCaseOptions>\n  = OptionalOptionsWithDefaults<\n    CamelCaseOptions,\n    Options,\n    {\n      // We use the runtime const for the default type so they stay coupled.\n      preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;\n    }\n  >;\n\n/**\n * Converts text to **camelCase** by splitting it into words, lowercasing the\n * first word, capitalizing the rest, then joining them back together.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *PascalCase* use `capitalize(toCamelCase(data))`.\n *\n * @param data - A string.\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   toCamelCase(data);\n *   toCamelCase(data, { preserveConsecutiveUppercase });\n * @example\n *   toCamelCase(\"hello world\"); // \"helloWorld\"\n *   toCamelCase(\"__HELLO_WORLD__\"); // \"helloWorld\"\n *   toCamelCase(\"HasHTML\"); // \"hasHTML\"\n *   toCamelCase(\"HasHTML\", { preserveConsecutiveUppercase: false }); // \"hasHtml\"\n * @dataFirst\n * @category String\n */\nexport function toCamelCase<T extends string, Options extends CamelCaseOptions>(\n  data: T,\n  options?: Options,\n): CamelCase<T, CamelCaseOptionsWithDefaults<Options> & BaseCamelCaseOptions>;\n\n/**\n * Converts text to **camelCase** by splitting it into words, lowercasing the\n * first word, capitalizing the rest, then joining them back together.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *PascalCase* use `capitalize(toCamelCase(data))`.\n *\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   toCamelCase()(data);\n *   toCamelCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   pipe(\"hello world\", toCamelCase()); // \"helloWorld\"\n *   pipe(\"__HELLO_WORLD__\", toCamelCase()); // \"helloWorld\"\n *   pipe(\"HasHTML\", toCamelCase()); // \"hasHTML\"\n *   pipe(\n *     \"HasHTML\",\n *     toCamelCase({ preserveConsecutiveUppercase: false }),\n *   ); // \"hasHtml\"\n * @dataLast\n * @category String\n */\nexport function toCamelCase<Options extends CamelCaseOptions>(\n  options?: Options,\n): <T extends string>(\n  data: T,\n) => CamelCase<T, CamelCaseOptionsWithDefaults<Options> & BaseCamelCaseOptions>;\n\nexport function toCamelCase(\n  dataOrOptions: CamelCaseOptions | string,\n  options?: CamelCaseOptions,\n): unknown {\n  return typeof dataOrOptions === 'string'\n    ? toCamelCaseImplementation(dataOrOptions, options)\n    : (data: string) => toCamelCaseImplementation(data, dataOrOptions);\n}\n\n// Based on the type definition from type-fest.\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/camel-case.d.ts#L76-L80\nfunction toCamelCaseImplementation(data: string, {\n  preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n}: CamelCaseOptions = {}): string {\n  return words(\n    LOWER_CASE_CHARACTER_RE.test(data)\n      ? data\n      : // If the text doesn't have **any** lower case characters we also lower\n        // case everything, but if it does we need to maintain them as it\n        // affects the word boundaries.\n        data.toLowerCase(),\n  )\n    .map(\n      (word, index) =>\n        `${\n          // The first word is uncapitalized, the rest are capitalized\n          index === 0 ? word[0]!.toLowerCase() : word[0]!.toUpperCase()\n        }${preserveConsecutiveUppercase ? word.slice(1) : word.slice(1).toLowerCase()}`,\n    )\n    .join('');\n}\n"],"mappings":"2GAOM,EAA0B,SAiGhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAKtE,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,EAAE,CAAU,CAChC,OAAOA,EAAAA,EACL,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,KACE,EAAM,IACL,GAEE,IAAU,EAAI,EAAK,GAAI,aAAa,CAAG,EAAK,GAAI,aAAa,GAC5D,EAA+B,EAAK,MAAM,EAAE,CAAG,EAAK,MAAM,EAAE,CAAC,aAAa,GAChF,CACA,KAAK,GAAG"}

package/dist/to-camel-case.js

@@ -1,2 +1,2 @@
-import{t as e}from"./words-DQCM5umD.js";const t=/[a-z]/u;function n(e,t){return typeof e==`string`?r(e,t):t=>r(t,e)}function r(n,{preserveConsecutiveUppercase:r=!0}={}){return e(t.test(n)?n:n.toLowerCase()).map((e,t)=>`${t===0?e[0].toLowerCase():e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(``)}export{n as toCamelCase};
+import{t as e}from"./words-B9lX8euz.js";const t=/[a-z]/u;function n(e,t){return typeof e==`string`?r(e,t):t=>r(t,e)}function r(n,{preserveConsecutiveUppercase:r=!0}={}){return e(t.test(n)?n:n.toLowerCase()).map((e,t)=>`${t===0?e[0].toLowerCase():e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(``)}export{n as toCamelCase};
 //# sourceMappingURL=to-camel-case.js.map

package/dist/to-camel-case.js.map

@@ -1 +1 @@
-{"version":3,"file":"to-camel-case.js","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":["import type { CamelCase } from 'type-fest';\nimport type { OptionalOptionsWithDefaults } from './internal/types/optional-options-with-defaults';\nimport { words } from './internal/words';\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ninterface CamelCaseOptions {\n  readonly preserveConsecutiveUppercase?: boolean;\n}\n\ntype CamelCaseOptionsWithDefaults<Options extends CamelCaseOptions>\n  = OptionalOptionsWithDefaults<\n    CamelCaseOptions,\n    Options,\n    {\n      // We use the runtime const for the default type so they stay coupled.\n      preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;\n    }\n  >;\n\n/**\n * Converts text to **camelCase** by splitting it into words, lowercasing the\n * first word, capitalizing the rest, then joining them back together.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *PascalCase* use `capitalize(toCamelCase(data))`.\n *\n * @param data - A string.\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   P.toCamelCase(data);\n *   P.toCamelCase(data, { preserveConsecutiveUppercase });\n * @example\n *   P.toCamelCase(\"hello world\"); // \"helloWorld\"\n *   P.toCamelCase(\"__HELLO_WORLD__\"); // \"helloWorld\"\n *   P.toCamelCase(\"HasHTML\"); // \"hasHTML\"\n *   P.toCamelCase(\"HasHTML\", { preserveConsecutiveUppercase: false }); // \"hasHtml\"\n * @dataFirst\n * @category String\n */\nexport function toCamelCase<T extends string, Options extends CamelCaseOptions>(\n  data: T,\n  options?: Options,\n): CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;\n\n/**\n * Converts text to **camelCase** by splitting it into words, lowercasing the\n * first word, capitalizing the rest, then joining them back together.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *PascalCase* use `capitalize(toCamelCase(data))`.\n *\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   P.toCamelCase()(data);\n *   P.toCamelCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   P.pipe(\"hello world\", P.toCamelCase()); // \"helloWorld\"\n *   P.pipe(\"__HELLO_WORLD__\", P.toCamelCase()); // \"helloWorld\"\n *   P.pipe(\"HasHTML\", P.toCamelCase()); // \"hasHTML\"\n *   P.pipe(\n *     \"HasHTML\",\n *     P.toCamelCase({ preserveConsecutiveUppercase: false }),\n *   ); // \"hasHtml\"\n * @dataLast\n * @category String\n */\nexport function toCamelCase<Options extends CamelCaseOptions>(\n  options?: Options,\n): <T extends string>(\n  data: T,\n) => CamelCase<T, CamelCaseOptionsWithDefaults<Options>>;\n\nexport function toCamelCase(\n  dataOrOptions: CamelCaseOptions | string,\n  options?: CamelCaseOptions,\n): unknown {\n  return typeof dataOrOptions === 'string'\n    ? toCamelCaseImplementation(dataOrOptions, options)\n    : (data: string) => toCamelCaseImplementation(data, dataOrOptions);\n}\n\n// Based on the type definition from type-fest.\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/camel-case.d.ts#L76-L80\nfunction toCamelCaseImplementation(data: string, {\n  preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n}: CamelCaseOptions = {}): string {\n  return words(\n    LOWER_CASE_CHARACTER_RE.test(data)\n      ? data\n      // If the text doesn't have **any** lower case characters we also lower\n      // case everything, but if it does we need to maintain them as it\n      // affects the word boundaries.\n      : data.toLowerCase(),\n  )\n    .map(\n      (word, index) =>\n        `${\n          // The first word is uncapitalized, the rest are capitalized\n          index === 0 ? word[0]!.toLowerCase() : word[0]!.toUpperCase()\n        }${preserveConsecutiveUppercase ? word.slice(1) : word.slice(1).toLowerCase()}`,\n    )\n    .join('');\n}\n"],"mappings":"wCAIA,MAAM,EAA0B,SAiGhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAKtE,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,EAAE,CAAU,CAChC,OAAO,EACL,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,KACE,EAAM,IACL,GAEE,IAAU,EAAI,EAAK,GAAI,aAAa,CAAG,EAAK,GAAI,aAAa,GAC5D,EAA+B,EAAK,MAAM,EAAE,CAAG,EAAK,MAAM,EAAE,CAAC,aAAa,GAChF,CACA,KAAK,GAAG"}
+{"version":3,"file":"to-camel-case.js","names":[],"sources":["../src/to-camel-case.ts"],"sourcesContent":["import type {\n  CamelCaseOptions as BaseCamelCaseOptions,\n  CamelCase,\n} from 'type-fest';\nimport type { OptionalOptionsWithDefaults } from './internal/types/optional-options-with-defaults';\nimport { words } from './internal/words';\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ninterface CamelCaseOptions {\n  readonly preserveConsecutiveUppercase?: boolean;\n}\n\ntype CamelCaseOptionsWithDefaults<Options extends CamelCaseOptions>\n  = OptionalOptionsWithDefaults<\n    CamelCaseOptions,\n    Options,\n    {\n      // We use the runtime const for the default type so they stay coupled.\n      preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;\n    }\n  >;\n\n/**\n * Converts text to **camelCase** by splitting it into words, lowercasing the\n * first word, capitalizing the rest, then joining them back together.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *PascalCase* use `capitalize(toCamelCase(data))`.\n *\n * @param data - A string.\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   toCamelCase(data);\n *   toCamelCase(data, { preserveConsecutiveUppercase });\n * @example\n *   toCamelCase(\"hello world\"); // \"helloWorld\"\n *   toCamelCase(\"__HELLO_WORLD__\"); // \"helloWorld\"\n *   toCamelCase(\"HasHTML\"); // \"hasHTML\"\n *   toCamelCase(\"HasHTML\", { preserveConsecutiveUppercase: false }); // \"hasHtml\"\n * @dataFirst\n * @category String\n */\nexport function toCamelCase<T extends string, Options extends CamelCaseOptions>(\n  data: T,\n  options?: Options,\n): CamelCase<T, CamelCaseOptionsWithDefaults<Options> & BaseCamelCaseOptions>;\n\n/**\n * Converts text to **camelCase** by splitting it into words, lowercasing the\n * first word, capitalizing the rest, then joining them back together.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *PascalCase* use `capitalize(toCamelCase(data))`.\n *\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   toCamelCase()(data);\n *   toCamelCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   pipe(\"hello world\", toCamelCase()); // \"helloWorld\"\n *   pipe(\"__HELLO_WORLD__\", toCamelCase()); // \"helloWorld\"\n *   pipe(\"HasHTML\", toCamelCase()); // \"hasHTML\"\n *   pipe(\n *     \"HasHTML\",\n *     toCamelCase({ preserveConsecutiveUppercase: false }),\n *   ); // \"hasHtml\"\n * @dataLast\n * @category String\n */\nexport function toCamelCase<Options extends CamelCaseOptions>(\n  options?: Options,\n): <T extends string>(\n  data: T,\n) => CamelCase<T, CamelCaseOptionsWithDefaults<Options> & BaseCamelCaseOptions>;\n\nexport function toCamelCase(\n  dataOrOptions: CamelCaseOptions | string,\n  options?: CamelCaseOptions,\n): unknown {\n  return typeof dataOrOptions === 'string'\n    ? toCamelCaseImplementation(dataOrOptions, options)\n    : (data: string) => toCamelCaseImplementation(data, dataOrOptions);\n}\n\n// Based on the type definition from type-fest.\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/camel-case.d.ts#L76-L80\nfunction toCamelCaseImplementation(data: string, {\n  preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n}: CamelCaseOptions = {}): string {\n  return words(\n    LOWER_CASE_CHARACTER_RE.test(data)\n      ? data\n      : // If the text doesn't have **any** lower case characters we also lower\n        // case everything, but if it does we need to maintain them as it\n        // affects the word boundaries.\n        data.toLowerCase(),\n  )\n    .map(\n      (word, index) =>\n        `${\n          // The first word is uncapitalized, the rest are capitalized\n          index === 0 ? word[0]!.toLowerCase() : word[0]!.toUpperCase()\n        }${preserveConsecutiveUppercase ? word.slice(1) : word.slice(1).toLowerCase()}`,\n    )\n    .join('');\n}\n"],"mappings":"wCAOA,MAAM,EAA0B,SAiGhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAKtE,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,EAAE,CAAU,CAChC,OAAO,EACL,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,KACE,EAAM,IACL,GAEE,IAAU,EAAI,EAAK,GAAI,aAAa,CAAG,EAAK,GAAI,aAAa,GAC5D,EAA+B,EAAK,MAAM,EAAE,CAAG,EAAK,MAAM,EAAE,CAAC,aAAa,GAChF,CACA,KAAK,GAAG"}

package/dist/to-kebab-case.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./words-DRQKxzLU.cjs`);function n(...t){return e.t(r,t)}function r(e){return t.t(e).join(`-`).toLowerCase()}exports.toKebabCase=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./words-_h74qi45.cjs`);function n(...t){return e.curry(r,t)}function r(e){return t.t(e).join(`-`).toLowerCase()}exports.toKebabCase=n;
+//# sourceMappingURL=to-kebab-case.cjs.map

package/dist/to-kebab-case.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-kebab-case.cjs","names":["curry","words"],"sources":["../src/to-kebab-case.ts"],"sourcesContent":["import type { Join, Words } from 'type-fest';\nimport { curry } from './curry';\nimport { words } from './internal/words';\n\ntype KebabCase<S extends string> = string extends S\n  ? string\n  : Lowercase<Join<Words<S>, '-'>>;\n\n/**\n * Converts text to **kebab-case** by splitting it into words and joining them\n * back together with hyphens (`-`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.\n *\n * @param data - A string.\n * @signature\n *   toKebabCase(data);\n * @example\n *   toKebabCase(\"hello world\"); // \"hello-world\"\n *   toKebabCase(\"__HELLO_WORLD__\"); // \"hello-world\"\n * @dataFirst\n * @category String\n */\nexport function toKebabCase<S extends string>(data: S): KebabCase<S>;\n\n/**\n * Converts text to **kebab-case** by splitting it into words and joining them\n * back together with hyphens (`-`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.\n *\n * @signature\n *   toKebabCase()(data);\n * @example\n *   pipe(\"hello world\", toKebabCase()); // \"hello-world\"\n *   pipe(\"__HELLO_WORLD__\", toKebabCase()); // \"hello-world\"\n * @dataLast\n * @category String\n */\nexport function toKebabCase(): <S extends string>(data: S) => KebabCase<S>;\n\nexport function toKebabCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toKebabCaseImplementation, args);\n}\n\nfunction toKebabCaseImplementation<S extends string>(data: S): KebabCase<S> {\n  // @ts-expect-error [ts2322] -- To avoid importing our own utilities for this\n  // we are using the built-in `join` and `toLowerCase` functions which aren't\n  // typed as well. This is equivalent to `toLowerCase(join(words(data), \"-\"))`\n  // which TypeScript infers correctly as KebabCase.\n  return words(data).join('-').toLowerCase();\n}\n"],"mappings":"oIA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAK1E,OAAOC,EAAAA,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}

package/dist/to-kebab-case.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./words-DQCM5umD.js";function n(...t){return e(r,t)}function r(e){return t(e).join(`-`).toLowerCase()}export{n as toKebabCase};
+import{curry as e}from"./curry.js";import{t}from"./words-B9lX8euz.js";function n(...t){return e(r,t)}function r(e){return t(e).join(`-`).toLowerCase()}export{n as toKebabCase};
 //# sourceMappingURL=to-kebab-case.js.map

package/dist/to-kebab-case.js.map

@@ -1 +1 @@
-{"version":3,"file":"to-kebab-case.js","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":["import type { Join, Words } from 'type-fest';\nimport { curry } from './curry';\nimport { words } from './internal/words';\n\ntype KebabCase<S extends string> = string extends S\n  ? string\n  : Lowercase<Join<Words<S>, '-'>>;\n\n/**\n * Converts text to **kebab-case** by splitting it into words and joining them\n * back together with hyphens (`-`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.\n *\n * @param data - A string.\n * @signature\n *   P.toKebabCase(data);\n * @example\n *   P.toKebabCase(\"hello world\"); // \"hello-world\"\n *   P.toKebabCase(\"__HELLO_WORLD__\"); // \"hello-world\"\n * @dataFirst\n * @category String\n */\nexport function toKebabCase<S extends string>(data: S): KebabCase<S>;\n\n/**\n * Converts text to **kebab-case** by splitting it into words and joining them\n * back together with hyphens (`-`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.\n *\n * @signature\n *   P.toKebabCase()(data);\n * @example\n *   P.pipe(\"hello world\", P.toKebabCase()); // \"hello-world\"\n *   P.pipe(\"__HELLO_WORLD__\", P.toKebabCase()); // \"hello-world\"\n * @dataLast\n * @category String\n */\nexport function toKebabCase(): <S extends string>(data: S) => KebabCase<S>;\n\nexport function toKebabCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toKebabCaseImplementation, args);\n}\n\nfunction toKebabCaseImplementation<S extends string>(data: S): KebabCase<S> {\n  // @ts-expect-error [ts2322] -- To avoid importing our own utilities for this\n  // we are using the built-in `join` and `toLowerCase` functions which aren't\n  // typed as well. This is equivalent to `toLowerCase(join(words(data), \"-\"))`\n  // which TypeScript infers correctly as KebabCase.\n  return words(data).join('-').toLowerCase();\n}\n"],"mappings":"2EA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAK1E,OAAO,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}
+{"version":3,"file":"to-kebab-case.js","names":[],"sources":["../src/to-kebab-case.ts"],"sourcesContent":["import type { Join, Words } from 'type-fest';\nimport { curry } from './curry';\nimport { words } from './internal/words';\n\ntype KebabCase<S extends string> = string extends S\n  ? string\n  : Lowercase<Join<Words<S>, '-'>>;\n\n/**\n * Converts text to **kebab-case** by splitting it into words and joining them\n * back together with hyphens (`-`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.\n *\n * @param data - A string.\n * @signature\n *   toKebabCase(data);\n * @example\n *   toKebabCase(\"hello world\"); // \"hello-world\"\n *   toKebabCase(\"__HELLO_WORLD__\"); // \"hello-world\"\n * @dataFirst\n * @category String\n */\nexport function toKebabCase<S extends string>(data: S): KebabCase<S>;\n\n/**\n * Converts text to **kebab-case** by splitting it into words and joining them\n * back together with hyphens (`-`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * For *COBOL-CASE* use `toUpperCase(toKebabCase(data))`.\n *\n * @signature\n *   toKebabCase()(data);\n * @example\n *   pipe(\"hello world\", toKebabCase()); // \"hello-world\"\n *   pipe(\"__HELLO_WORLD__\", toKebabCase()); // \"hello-world\"\n * @dataLast\n * @category String\n */\nexport function toKebabCase(): <S extends string>(data: S) => KebabCase<S>;\n\nexport function toKebabCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toKebabCaseImplementation, args);\n}\n\nfunction toKebabCaseImplementation<S extends string>(data: S): KebabCase<S> {\n  // @ts-expect-error [ts2322] -- To avoid importing our own utilities for this\n  // we are using the built-in `join` and `toLowerCase` functions which aren't\n  // typed as well. This is equivalent to `toLowerCase(join(words(data), \"-\"))`\n  // which TypeScript infers correctly as KebabCase.\n  return words(data).join('-').toLowerCase();\n}\n"],"mappings":"sEA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAK1E,OAAO,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}

package/dist/to-lower-case.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){return e.toLowerCase()}exports.toLowerCase=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){return e.toLowerCase()}exports.toLowerCase=t;
+//# sourceMappingURL=to-lower-case.cjs.map

package/dist/to-lower-case.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-lower-case.cjs","names":["curry"],"sources":["../src/to-lower-case.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Replaces all uppercase characters with their lowercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   toLowerCase(data);\n * @example\n *   toLowerCase(\"Hello World\"); // \"hello world\"\n * @dataFirst\n * @category String\n */\nexport function toLowerCase<T extends string>(data: T): Lowercase<T>;\n\n/**\n * Replaces all uppercase characters with their lowercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   toLowerCase()(data);\n * @example\n *   pipe(\"Hello World\", toLowerCase()); // \"hello world\"\n * @dataLast\n * @category String\n */\nexport function toLowerCase(): <T extends string>(data: T) => Lowercase<T>;\n\nexport function toLowerCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toLowerCaseImplementation, args);\n}\n\nfunction toLowerCaseImplementation<T extends string>(data: T): Lowercase<T> {\n  return data.toLowerCase();\n}\n"],"mappings":"kGAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,aAAa"}

package/dist/to-lower-case.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){return e.toLowerCase()}export{t as toLowerCase};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){return e.toLowerCase()}export{t as toLowerCase};
 //# sourceMappingURL=to-lower-case.js.map

package/dist/to-lower-case.js.map

@@ -1 +1 @@
-{"version":3,"file":"to-lower-case.js","names":[],"sources":["../src/to-lower-case.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Replaces all uppercase characters with their lowercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   P.toLowerCase(data);\n * @example\n *   P.toLowerCase(\"Hello World\"); // \"hello world\"\n * @dataFirst\n * @category String\n */\nexport function toLowerCase<T extends string>(data: T): Lowercase<T>;\n\n/**\n * Replaces all uppercase characters with their lowercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   P.toLowerCase()(data);\n * @example\n *   P.pipe(\"Hello World\", P.toLowerCase()); // \"hello world\"\n * @dataLast\n * @category String\n */\nexport function toLowerCase(): <T extends string>(data: T) => Lowercase<T>;\n\nexport function toLowerCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toLowerCaseImplementation, args);\n}\n\nfunction toLowerCaseImplementation<T extends string>(data: T): Lowercase<T> {\n  // @ts-expect-error [ts2322] -- TypeScript can't infer this from the code...\n  return data.toLowerCase();\n}\n"],"mappings":"wCAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAE1E,OAAO,EAAK,aAAa"}
+{"version":3,"file":"to-lower-case.js","names":[],"sources":["../src/to-lower-case.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Replaces all uppercase characters with their lowercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   toLowerCase(data);\n * @example\n *   toLowerCase(\"Hello World\"); // \"hello world\"\n * @dataFirst\n * @category String\n */\nexport function toLowerCase<T extends string>(data: T): Lowercase<T>;\n\n/**\n * Replaces all uppercase characters with their lowercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and for display purposes use CSS [`text-transform: lowercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   toLowerCase()(data);\n * @example\n *   pipe(\"Hello World\", toLowerCase()); // \"hello world\"\n * @dataLast\n * @category String\n */\nexport function toLowerCase(): <T extends string>(data: T) => Lowercase<T>;\n\nexport function toLowerCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toLowerCaseImplementation, args);\n}\n\nfunction toLowerCaseImplementation<T extends string>(data: T): Lowercase<T> {\n  return data.toLowerCase();\n}\n"],"mappings":"mCAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,aAAa"}

package/dist/to-single-BunGuk7o.cjs

@@ -0,0 +1,2 @@
+function e(e){return Object.assign(e,{single:!0})}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});
+//# sourceMappingURL=to-single-BunGuk7o.cjs.map

package/dist/to-single-BunGuk7o.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-single-BunGuk7o.cjs","names":[],"sources":["../src/internal/to-single.ts"],"sourcesContent":["import type { StrictFunction } from './types/strict-function';\n\ntype Single<Func> = Func & { readonly single: true };\n\nexport function toSingle<Func extends StrictFunction>(fn: Func): Single<Func> {\n  return Object.assign(fn, { single: true as const });\n}\n"],"mappings":"AAIA,SAAgB,EAAsC,EAAwB,CAC5E,OAAO,OAAO,OAAO,EAAI,CAAE,OAAQ,GAAe,CAAC"}

package/dist/to-single-XEXXW73e.js

@@ -0,0 +1,2 @@
+function e(e){return Object.assign(e,{single:!0})}export{e as t};
+//# sourceMappingURL=to-single-XEXXW73e.js.map

package/dist/to-single-XEXXW73e.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-single-XEXXW73e.js","names":[],"sources":["../src/internal/to-single.ts"],"sourcesContent":["import type { StrictFunction } from './types/strict-function';\n\ntype Single<Func> = Func & { readonly single: true };\n\nexport function toSingle<Func extends StrictFunction>(fn: Func): Single<Func> {\n  return Object.assign(fn, { single: true as const });\n}\n"],"mappings":"AAIA,SAAgB,EAAsC,EAAwB,CAC5E,OAAO,OAAO,OAAO,EAAI,CAAE,OAAQ,GAAe,CAAC"}

package/dist/to-snake-case.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./words-DRQKxzLU.cjs`);function n(...t){return e.t(r,t)}function r(e){return t.t(e).join(`_`).toLowerCase()}exports.toSnakeCase=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./words-_h74qi45.cjs`);function n(...t){return e.curry(r,t)}function r(e){return t.t(e).join(`_`).toLowerCase()}exports.toSnakeCase=n;
+//# sourceMappingURL=to-snake-case.cjs.map

package/dist/to-snake-case.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-snake-case.cjs","names":["curry","words"],"sources":["../src/to-snake-case.ts"],"sourcesContent":["import type { Join, Words } from 'type-fest';\nimport { curry } from './curry';\nimport { words } from './internal/words';\n\ntype SnakeCase<S extends string> = string extends S\n  ? string\n  : Lowercase<Join<Words<S>, '_'>>;\n\n/**\n * Converts text to **snake_case** by splitting it into words and joining them\n * back together with underscores (`_`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.\n *\n * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.\n *\n * @param data - A string.\n * @signature\n *   toSnakeCase(data);\n * @example\n *   toSnakeCase(\"hello world\"); // \"hello_world\"\n *   toSnakeCase(\"__HELLO_WORLD__\"); // \"hello_world\"\n * @dataFirst\n * @category String\n */\nexport function toSnakeCase<S extends string>(data: S): SnakeCase<S>;\n\n/**\n * Converts text to **snake_case** by splitting it into words and joining them\n * back together with underscores (`_`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.\n *\n * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.\n *\n * @signature\n *   toSnakeCase()(data);\n * @example\n *   pipe(\"hello world\", toSnakeCase()); // \"hello_world\"\n *   pipe(\"__HELLO_WORLD__\", toSnakeCase()); // \"hello_world\"\n * @dataLast\n * @category String\n */\nexport function toSnakeCase(): <S extends string>(data: S) => SnakeCase<S>;\n\nexport function toSnakeCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toSnakeCaseImplementation, args);\n}\n\nfunction toSnakeCaseImplementation<S extends string>(data: S): SnakeCase<S> {\n  return words(data).join('_').toLowerCase();\n}\n"],"mappings":"oIA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAOC,EAAAA,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}

package/dist/to-snake-case.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./words-DQCM5umD.js";function n(...t){return e(r,t)}function r(e){return t(e).join(`_`).toLowerCase()}export{n as toSnakeCase};
+import{curry as e}from"./curry.js";import{t}from"./words-B9lX8euz.js";function n(...t){return e(r,t)}function r(e){return t(e).join(`_`).toLowerCase()}export{n as toSnakeCase};
 //# sourceMappingURL=to-snake-case.js.map

package/dist/to-snake-case.js.map

@@ -1 +1 @@
-{"version":3,"file":"to-snake-case.js","names":[],"sources":["../src/to-snake-case.ts"],"sourcesContent":["import type { Join, Words } from 'type-fest';\nimport { curry } from './curry';\nimport { words } from './internal/words';\n\ntype SnakeCase<S extends string> = string extends S\n  ? string\n  : Lowercase<Join<Words<S>, '_'>>;\n\n/**\n * Converts text to **snake_case** by splitting it into words and joining them\n * back together with underscores (`_`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.\n *\n * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.\n *\n * @param data - A string.\n * @signature\n *   P.toSnakeCase(data);\n * @example\n *   P.toSnakeCase(\"hello world\"); // \"hello_world\"\n *   P.toSnakeCase(\"__HELLO_WORLD__\"); // \"hello_world\"\n * @dataFirst\n * @category String\n */\nexport function toSnakeCase<S extends string>(data: S): SnakeCase<S>;\n\n/**\n * Converts text to **snake_case** by splitting it into words and joining them\n * back together with underscores (`_`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.\n *\n * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.\n *\n * @signature\n *   P.toSnakeCase()(data);\n * @example\n *   P.pipe(\"hello world\", P.toSnakeCase()); // \"hello_world\"\n *   P.pipe(\"__HELLO_WORLD__\", P.toSnakeCase()); // \"hello_world\"\n * @dataLast\n * @category String\n */\nexport function toSnakeCase(): <S extends string>(data: S) => SnakeCase<S>;\n\nexport function toSnakeCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toSnakeCaseImplementation, args);\n}\n\nfunction toSnakeCaseImplementation<S extends string>(data: S): SnakeCase<S> {\n  // @ts-expect-error [ts2322] -- To avoid importing our own utilities for this\n  // we are using the built-in `join` and `toLowerCase` functions which aren't\n  // typed as well. This is equivalent to `toLowerCase(join(words(data), \"_\"))`\n  // which TypeScript infers correctly as SnakeCase.\n  return words(data).join('_').toLowerCase();\n}\n"],"mappings":"2EA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAK1E,OAAO,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}
+{"version":3,"file":"to-snake-case.js","names":[],"sources":["../src/to-snake-case.ts"],"sourcesContent":["import type { Join, Words } from 'type-fest';\nimport { curry } from './curry';\nimport { words } from './internal/words';\n\ntype SnakeCase<S extends string> = string extends S\n  ? string\n  : Lowercase<Join<Words<S>, '_'>>;\n\n/**\n * Converts text to **snake_case** by splitting it into words and joining them\n * back together with underscores (`_`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.\n *\n * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.\n *\n * @param data - A string.\n * @signature\n *   toSnakeCase(data);\n * @example\n *   toSnakeCase(\"hello world\"); // \"hello_world\"\n *   toSnakeCase(\"__HELLO_WORLD__\"); // \"hello_world\"\n * @dataFirst\n * @category String\n */\nexport function toSnakeCase<S extends string>(data: S): SnakeCase<S>;\n\n/**\n * Converts text to **snake_case** by splitting it into words and joining them\n * back together with underscores (`_`), then lowercasing the result.\n *\n * Because it uses [`toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase),\n * the function shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_\n * too, making it best suited for simple strings like identifiers and internal\n * keys. For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters), and\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toTitleCase`.\n *\n * For *CONSTANT_CASE* use `toUpperCase(toSnakeCase(data))`.\n *\n * @signature\n *   toSnakeCase()(data);\n * @example\n *   pipe(\"hello world\", toSnakeCase()); // \"hello_world\"\n *   pipe(\"__HELLO_WORLD__\", toSnakeCase()); // \"hello_world\"\n * @dataLast\n * @category String\n */\nexport function toSnakeCase(): <S extends string>(data: S) => SnakeCase<S>;\n\nexport function toSnakeCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toSnakeCaseImplementation, args);\n}\n\nfunction toSnakeCaseImplementation<S extends string>(data: S): SnakeCase<S> {\n  return words(data).join('_').toLowerCase();\n}\n"],"mappings":"sEA+DA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAM,EAAK,CAAC,KAAK,IAAI,CAAC,aAAa"}

package/dist/to-title-case.cjs

@@ -1 +1,2 @@
-const e=require(`./words-DRQKxzLU.cjs`),t=/[a-z]/u,n=!0;function r(e,t){return typeof e==`string`?i(e,t):t=>i(t,e)}function i(n,{preserveConsecutiveUppercase:r=!0}={}){return e.t(t.test(n)?n:n.toLowerCase()).map(e=>`${e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(` `)}exports.toTitleCase=r;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./words-_h74qi45.cjs`),t=/[a-z]/u;function n(e,t){return typeof e==`string`?r(e,t):t=>r(t,e)}function r(n,{preserveConsecutiveUppercase:r=!0}={}){return e.t(t.test(n)?n:n.toLowerCase()).map(e=>`${e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(` `)}exports.toTitleCase=n;
+//# sourceMappingURL=to-title-case.cjs.map

package/dist/to-title-case.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-title-case.cjs","names":["words"],"sources":["../src/to-title-case.ts"],"sourcesContent":["import type { IsEqual, IsLiteral, Join, Words } from 'type-fest';\nimport type { OptionalOptionsWithDefaults } from './internal/types/optional-options-with-defaults';\nimport { words } from './internal/words';\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ninterface TitleCaseOptions {\n  readonly preserveConsecutiveUppercase?: boolean;\n}\n\ntype TitleCaseOptionsWithDefaults<Options extends TitleCaseOptions>\n  = OptionalOptionsWithDefaults<\n    TitleCaseOptions,\n    Options,\n    {\n      // We use the runtime const for the default type so they stay coupled.\n      preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;\n    }\n  >;\n\ntype TitleCase<S extends string, Options extends TitleCaseOptions>\n  = IsLiteral<S> extends true\n    ? Join<\n      TitleCasedArray<\n        Words<IsEqual<S, Uppercase<S>> extends true ? Lowercase<S> : S>,\n        TitleCaseOptionsWithDefaults<Options>\n      >,\n      ' '\n    >\n    : string;\n\ntype TitleCasedArray<\n  T extends ReadonlyArray<string>,\n  Options extends TitleCaseOptions,\n> = {\n  [I in keyof T]: Capitalize<\n    Options['preserveConsecutiveUppercase'] extends true\n      ? T[I]\n      : Lowercase<T[I]>\n  >;\n};\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,\n * making it best suited for simple strings like identifiers and internal keys.\n * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\n *\n * @param data - A string.\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   toTitleCase(data);\n *   toTitleCase(data, { preserveConsecutiveUppercase });\n * @example\n *   toTitleCase(\"hello world\"); // \"Hello World\"\n *   toTitleCase(\"--foo-bar--\"); // \"Foo Bar\"\n *   toTitleCase(\"fooBar\"); // \"Foo Bar\"\n *   toTitleCase(\"__FOO_BAR__\"); // \"Foo Bar\"\n *   toTitleCase(\"XMLHttpRequest\"); // \"XML Http Request\"\n *   toTitleCase(\"XMLHttpRequest\", { preserveConsecutiveUppercase: false }); // \"Xml Http Request\"\n * @dataFirst\n * @category String\n */\nexport function toTitleCase<S extends string, Options extends TitleCaseOptions>(\n  data: S,\n  options?: Options,\n): TitleCase<S, Options>;\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,\n * making it best suited for simple strings like identifiers and internal keys.\n * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\n *\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   toTitleCase()(data);\n *   toTitleCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   pipe(\"hello world\", toTitleCase()); // \"Hello World\"\n *   pipe(\"--foo-bar--\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"fooBar\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"__FOO_BAR__\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"XMLHttpRequest\", toTitleCase()); // \"XML Http Request\"\n *   pipe(\n *     \"XMLHttpRequest\",\n *     toTitleCase({ preserveConsecutiveUppercase: false }),\n *   ); // \"Xml Http Request\"\n * @dataLast\n * @category String\n */\nexport function toTitleCase<Options extends TitleCaseOptions>(\n  options?: Options,\n): <S extends string>(data: S) => TitleCase<S, Options>;\n\nexport function toTitleCase(\n  dataOrOptions?: TitleCaseOptions | string,\n  options?: TitleCaseOptions,\n): unknown {\n  return typeof dataOrOptions === 'string'\n    ? toTitleCaseImplementation(dataOrOptions, options)\n    : (data: string) => toTitleCaseImplementation(data, dataOrOptions);\n}\n\n// Similar to the implementation used in toCamelCase\nfunction toTitleCaseImplementation(data: string, {\n  preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n}: TitleCaseOptions = {}): string {\n  return words(\n    LOWER_CASE_CHARACTER_RE.test(data)\n      ? data\n      : // If the text doesn't have **any** lowercase characters, we lowercase\n        // everything; otherwise we maintain existing case as it affects word\n        // boundaries.\n        data.toLowerCase(),\n  )\n    .map(\n      (word) =>\n        `${word[0]!.toUpperCase()}${\n          preserveConsecutiveUppercase\n            ? word.slice(1)\n            : word.slice(1).toLowerCase()\n        }`,\n    )\n    .join(' ');\n}\n"],"mappings":"2GAIM,EAA0B,SAqHhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAItE,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,EAAE,CAAU,CAChC,OAAOA,EAAAA,EACL,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,IACE,GACC,GAAG,EAAK,GAAI,aAAa,GACvB,EACI,EAAK,MAAM,EAAE,CACb,EAAK,MAAM,EAAE,CAAC,aAAa,GAEpC,CACA,KAAK,IAAI"}

package/dist/to-title-case.js

@@ -1,2 +1,2 @@
-import{t as e}from"./words-DQCM5umD.js";const t=/[a-z]/u;function n(e,t){return typeof e==`string`?r(e,t):t=>r(t,e)}function r(n,{preserveConsecutiveUppercase:r=!0}={}){return e(t.test(n)?n:n.toLowerCase()).map(e=>`${e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(` `)}export{n as toTitleCase};
+import{t as e}from"./words-B9lX8euz.js";const t=/[a-z]/u;function n(e,t){return typeof e==`string`?r(e,t):t=>r(t,e)}function r(n,{preserveConsecutiveUppercase:r=!0}={}){return e(t.test(n)?n:n.toLowerCase()).map(e=>`${e[0].toUpperCase()}${r?e.slice(1):e.slice(1).toLowerCase()}`).join(` `)}export{n as toTitleCase};
 //# sourceMappingURL=to-title-case.js.map

package/dist/to-title-case.js.map

@@ -1 +1 @@
-{"version":3,"file":"to-title-case.js","names":[],"sources":["../src/to-title-case.ts"],"sourcesContent":["import type { IsEqual, IsLiteral, Join, Words } from 'type-fest';\nimport type { OptionalOptionsWithDefaults } from './internal/types/optional-options-with-defaults';\nimport { words } from './internal/words';\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ninterface TitleCaseOptions {\n  readonly preserveConsecutiveUppercase?: boolean;\n}\n\ntype TitleCaseOptionsWithDefaults<Options extends TitleCaseOptions>\n  = OptionalOptionsWithDefaults<\n    TitleCaseOptions,\n    Options,\n    {\n      // We use the runtime const for the default type so they stay coupled.\n      preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;\n    }\n  >;\n\ntype TitleCase<S extends string, Options extends TitleCaseOptions>\n  = IsLiteral<S> extends true\n    ? Join<\n      TitleCasedArray<\n        Words<IsEqual<S, Uppercase<S>> extends true ? Lowercase<S> : S>,\n        TitleCaseOptionsWithDefaults<Options>\n      >,\n      ' '\n    >\n    : string;\n\ntype TitleCasedArray<\n  T extends ReadonlyArray<string>,\n  Options extends TitleCaseOptions,\n> = {\n  [I in keyof T]: Capitalize<\n    Options['preserveConsecutiveUppercase'] extends true\n      ? T[I]\n      : Lowercase<T[I]>\n  >;\n};\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,\n * making it best suited for simple strings like identifiers and internal keys.\n * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\n *\n * @param data - A string.\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   R.toTitleCase(data);\n *   R.toTitleCase(data, { preserveConsecutiveUppercase });\n * @example\n *   R.toTitleCase(\"hello world\"); // \"Hello World\"\n *   R.toTitleCase(\"--foo-bar--\"); // \"Foo Bar\"\n *   R.toTitleCase(\"fooBar\"); // \"Foo Bar\"\n *   R.toTitleCase(\"__FOO_BAR__\"); // \"Foo Bar\"\n *   R.toTitleCase(\"XMLHttpRequest\"); // \"XML Http Request\"\n *   R.toTitleCase(\"XMLHttpRequest\", { preserveConsecutiveUppercase: false }); // \"Xml Http Request\"\n * @dataFirst\n * @category String\n */\nexport function toTitleCase<S extends string, Options extends TitleCaseOptions>(\n  data: S,\n  options?: Options,\n): TitleCase<S, Options>;\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,\n * making it best suited for simple strings like identifiers and internal keys.\n * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\n *\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   R.toTitleCase()(data);\n *   R.toTitleCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   R.pipe(\"hello world\", R.toTitleCase()); // \"Hello World\"\n *   R.pipe(\"--foo-bar--\", R.toTitleCase()); // \"Foo Bar\"\n *   R.pipe(\"fooBar\", R.toTitleCase()); // \"Foo Bar\"\n *   R.pipe(\"__FOO_BAR__\", R.toTitleCase()); // \"Foo Bar\"\n *   R.pipe(\"XMLHttpRequest\", R.toTitleCase()); // \"XML Http Request\"\n *   R.pipe(\n *     \"XMLHttpRequest\",\n *     R.toTitleCase({ preserveConsecutiveUppercase: false }),\n *   ); // \"Xml Http Request\"\n * @dataLast\n * @category String\n */\nexport function toTitleCase<Options extends TitleCaseOptions>(\n  options?: Options,\n): <S extends string>(data: S) => TitleCase<S, Options>;\n\nexport function toTitleCase(\n  dataOrOptions?: TitleCaseOptions | string,\n  options?: TitleCaseOptions,\n): unknown {\n  return typeof dataOrOptions === 'string'\n    ? toTitleCaseImplementation(dataOrOptions, options)\n    : (data: string) => toTitleCaseImplementation(data, dataOrOptions);\n}\n\n// Similar to the implementation used in toCamelCase\nfunction toTitleCaseImplementation(data: string, {\n  preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n}: TitleCaseOptions = {}): string {\n  return words(\n    LOWER_CASE_CHARACTER_RE.test(data)\n      ? data\n      // If the text doesn't have **any** lowercase characters, we lowercase\n      // everything; otherwise we maintain existing case as it affects word\n      // boundaries.\n      : data.toLowerCase(),\n  )\n    .map(\n      (word) =>\n        `${word[0]!.toUpperCase()}${\n          preserveConsecutiveUppercase\n            ? word.slice(1)\n            : word.slice(1).toLowerCase()\n        }`,\n    )\n    .join(' ');\n}\n"],"mappings":"wCAIA,MAAM,EAA0B,SAqHhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAItE,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,EAAE,CAAU,CAChC,OAAO,EACL,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,IACE,GACC,GAAG,EAAK,GAAI,aAAa,GACvB,EACI,EAAK,MAAM,EAAE,CACb,EAAK,MAAM,EAAE,CAAC,aAAa,GAEpC,CACA,KAAK,IAAI"}
+{"version":3,"file":"to-title-case.js","names":[],"sources":["../src/to-title-case.ts"],"sourcesContent":["import type { IsEqual, IsLiteral, Join, Words } from 'type-fest';\nimport type { OptionalOptionsWithDefaults } from './internal/types/optional-options-with-defaults';\nimport { words } from './internal/words';\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ninterface TitleCaseOptions {\n  readonly preserveConsecutiveUppercase?: boolean;\n}\n\ntype TitleCaseOptionsWithDefaults<Options extends TitleCaseOptions>\n  = OptionalOptionsWithDefaults<\n    TitleCaseOptions,\n    Options,\n    {\n      // We use the runtime const for the default type so they stay coupled.\n      preserveConsecutiveUppercase: typeof DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE;\n    }\n  >;\n\ntype TitleCase<S extends string, Options extends TitleCaseOptions>\n  = IsLiteral<S> extends true\n    ? Join<\n      TitleCasedArray<\n        Words<IsEqual<S, Uppercase<S>> extends true ? Lowercase<S> : S>,\n        TitleCaseOptionsWithDefaults<Options>\n      >,\n      ' '\n    >\n    : string;\n\ntype TitleCasedArray<\n  T extends ReadonlyArray<string>,\n  Options extends TitleCaseOptions,\n> = {\n  [I in keyof T]: Capitalize<\n    Options['preserveConsecutiveUppercase'] extends true\n      ? T[I]\n      : Lowercase<T[I]>\n  >;\n};\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,\n * making it best suited for simple strings like identifiers and internal keys.\n * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\n *\n * @param data - A string.\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   toTitleCase(data);\n *   toTitleCase(data, { preserveConsecutiveUppercase });\n * @example\n *   toTitleCase(\"hello world\"); // \"Hello World\"\n *   toTitleCase(\"--foo-bar--\"); // \"Foo Bar\"\n *   toTitleCase(\"fooBar\"); // \"Foo Bar\"\n *   toTitleCase(\"__FOO_BAR__\"); // \"Foo Bar\"\n *   toTitleCase(\"XMLHttpRequest\"); // \"XML Http Request\"\n *   toTitleCase(\"XMLHttpRequest\", { preserveConsecutiveUppercase: false }); // \"Xml Http Request\"\n * @dataFirst\n * @category String\n */\nexport function toTitleCase<S extends string, Options extends TitleCaseOptions>(\n  data: S,\n  options?: Options,\n): TitleCase<S, Options>;\n\n/**\n * Converts text to **Title Case** by splitting it into words, capitalizing the\n * first letter of each word, then joining them back together with spaces.\n *\n * Because it uses the built-in case conversion methods, the function shares\n * their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_,\n * making it best suited for simple strings like identifiers and internal keys.\n * For linguistic text processing, use [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter)\n * with [`granularity: \"word\"`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#parameters),\n * [`toLocaleLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase),\n * and [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase)\n * which are purpose-built to handle nuances in languages and locales.\n *\n * For other case manipulations see: `toLowerCase`, `toUpperCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, and `toSnakeCase`.\n *\n * @param options - An _optional_ object with the _optional_ property\n * `preserveConsecutiveUppercase` that can be used to change the way consecutive\n * uppercase characters are handled. Defaults to `true`.\n * @signature\n *   toTitleCase()(data);\n *   toTitleCase({ preserveConsecutiveUppercase })(data);\n * @example\n *   pipe(\"hello world\", toTitleCase()); // \"Hello World\"\n *   pipe(\"--foo-bar--\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"fooBar\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"__FOO_BAR__\", toTitleCase()); // \"Foo Bar\"\n *   pipe(\"XMLHttpRequest\", toTitleCase()); // \"XML Http Request\"\n *   pipe(\n *     \"XMLHttpRequest\",\n *     toTitleCase({ preserveConsecutiveUppercase: false }),\n *   ); // \"Xml Http Request\"\n * @dataLast\n * @category String\n */\nexport function toTitleCase<Options extends TitleCaseOptions>(\n  options?: Options,\n): <S extends string>(data: S) => TitleCase<S, Options>;\n\nexport function toTitleCase(\n  dataOrOptions?: TitleCaseOptions | string,\n  options?: TitleCaseOptions,\n): unknown {\n  return typeof dataOrOptions === 'string'\n    ? toTitleCaseImplementation(dataOrOptions, options)\n    : (data: string) => toTitleCaseImplementation(data, dataOrOptions);\n}\n\n// Similar to the implementation used in toCamelCase\nfunction toTitleCaseImplementation(data: string, {\n  preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n}: TitleCaseOptions = {}): string {\n  return words(\n    LOWER_CASE_CHARACTER_RE.test(data)\n      ? data\n      : // If the text doesn't have **any** lowercase characters, we lowercase\n        // everything; otherwise we maintain existing case as it affects word\n        // boundaries.\n        data.toLowerCase(),\n  )\n    .map(\n      (word) =>\n        `${word[0]!.toUpperCase()}${\n          preserveConsecutiveUppercase\n            ? word.slice(1)\n            : word.slice(1).toLowerCase()\n        }`,\n    )\n    .join(' ');\n}\n"],"mappings":"wCAIA,MAAM,EAA0B,SAqHhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAItE,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,EAAE,CAAU,CAChC,OAAO,EACL,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,IACE,GACC,GAAG,EAAK,GAAI,aAAa,GACvB,EACI,EAAK,MAAM,EAAE,CACb,EAAK,MAAM,EAAE,CAAC,aAAa,GAEpC,CACA,KAAK,IAAI"}

package/dist/to-upper-case.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){return e.toUpperCase()}exports.toUpperCase=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){return e.toUpperCase()}exports.toUpperCase=t;
+//# sourceMappingURL=to-upper-case.cjs.map

package/dist/to-upper-case.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-upper-case.cjs","names":["curry"],"sources":["../src/to-upper-case.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   toUpperCase(data);\n * @example\n *   toUpperCase(\"Hello World\"); // \"HELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function toUpperCase<T extends string>(data: T): Uppercase<T>;\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   toUpperCase()(data);\n * @example\n *   pipe(\"Hello World\", toUpperCase()); // \"HELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function toUpperCase(): <T extends string>(data: T) => Uppercase<T>;\n\nexport function toUpperCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toUpperCaseImplementation, args);\n}\n\nfunction toUpperCaseImplementation<T extends string>(data: T): Uppercase<T> {\n  return data.toUpperCase();\n}\n"],"mappings":"kGAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,aAAa"}

package/dist/to-upper-case.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){return e.toUpperCase()}export{t as toUpperCase};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){return e.toUpperCase()}export{t as toUpperCase};
 //# sourceMappingURL=to-upper-case.js.map

package/dist/to-upper-case.js.map

@@ -1 +1 @@
-{"version":3,"file":"to-upper-case.js","names":[],"sources":["../src/to-upper-case.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   P.toUpperCase(data);\n * @example\n *   P.toUpperCase(\"Hello World\"); // \"HELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function toUpperCase<T extends string>(data: T): Uppercase<T>;\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   P.toUpperCase()(data);\n * @example\n *   P.pipe(\"Hello World\", P.toUpperCase()); // \"HELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function toUpperCase(): <T extends string>(data: T) => Uppercase<T>;\n\nexport function toUpperCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toUpperCaseImplementation, args);\n}\n\nfunction toUpperCaseImplementation<T extends string>(data: T): Uppercase<T> {\n  // @ts-expect-error [ts2322] -- TypeScript can't infer this from the code...\n  return data.toUpperCase();\n}\n"],"mappings":"wCAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAE1E,OAAO,EAAK,aAAa"}
+{"version":3,"file":"to-upper-case.js","names":[],"sources":["../src/to-upper-case.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   toUpperCase(data);\n * @example\n *   toUpperCase(\"Hello World\"); // \"HELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function toUpperCase<T extends string>(data: T): Uppercase<T>;\n\n/**\n * Replaces all lowercase characters with their uppercase equivalents.\n *\n * This function is a wrapper around the built-in\n * [`String.prototype.toUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)\n * method and shares its _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase#description)_.\n *\n * For a more linguistically accurate transformation use [`toLocaleUpperCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase),\n * and for display purposes use CSS [`text-transform: uppercase;`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform)\n * which *is* locale-aware.\n *\n * For other case manipulations see: `toLowerCase`, `capitalize`,\n * `uncapitalize`, `toCamelCase`, `toKebabCase`, `toSnakeCase`, and\n * `toTitleCase`.\n *\n * @signature\n *   toUpperCase()(data);\n * @example\n *   pipe(\"Hello World\", toUpperCase()); // \"HELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function toUpperCase(): <T extends string>(data: T) => Uppercase<T>;\n\nexport function toUpperCase(...args: ReadonlyArray<unknown>): unknown {\n  return curry(toUpperCaseImplementation, args);\n}\n\nfunction toUpperCaseImplementation<T extends string>(data: T): Uppercase<T> {\n  return data.toUpperCase();\n}\n"],"mappings":"mCAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA4C,EAAuB,CAC1E,OAAO,EAAK,aAAa"}

package/dist/truncate.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,n,r){return typeof e==`string`?t(e,n,r):r=>t(r,e,n)}function t(e,t,{omission:n=`...`,separator:r}={}){if(e.length<=t)return e;if(t<=0)return``;if(t<n.length)return n.slice(0,t);let i=t-n.length;if(typeof r==`string`){let t=e.lastIndexOf(r,i);t!==-1&&(i=t)}else if(r!==void 0){let t=r.flags.includes(`g`)?r:new RegExp(r.source,`${r.flags}g`),n;for(let{index:r}of e.matchAll(t)){if(r>i)break;n=r}n!==void 0&&(i=n)}return`${e.slice(0,i)}${n}`}exports.truncate=e;
+//# sourceMappingURL=truncate.cjs.map