@vinicunca/perkakas 1.14.0 → 1.16.0

package/dist/sum.js.map

@@ -1 +1 @@
-{"version":3,"file":"sum.js","names":[],"sources":["../src/sum.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Sum<T extends IterableContainer<bigint> | IterableContainer<number>>\n  // Empty arrays would always result in a sum of (a non-bigint) 0.\n  = T extends readonly []\n    ? 0\n    : // Non-empty bigint arrays will always result in a bigint sum.\n    T extends readonly [bigint, ...(ReadonlyArray<unknown>)]\n      ? bigint\n      : // But an empty bigint array would result in a non-bigint 0.\n      T[number] extends bigint\n        ? bigint | 0\n        : // Non-bigint arrays are always handled correctly.\n        number;\n\n/**\n * Sums the numbers in the array, or return 0 for an empty array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   sum(data);\n * @example\n *   sum([1, 2, 3]); // => 6\n *   sum([1n, 2n, 3n]); // => 6n\n *   sum([]); // => 0\n * @dataFirst\n * @category Number\n */\nexport function sum<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): Sum<T>;\n\n/**\n * Sums the numbers in the array, or return 0 for an empty array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty`to guard against this case.\n *\n * @signature\n *   sum()(data);\n * @example\n *   pipe([1, 2, 3], sum()); // => 6\n *   pipe([1n, 2n, 3n], sum()); // => 6n\n *   pipe([], sum()); // => 0\n * @dataLast\n * @category Number\n */\nexport function sum(): <\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(\n  data: T,\n) => Sum<T>;\n\nexport function sum(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sumImplementation, args);\n}\n\nfunction sumImplementation<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): T[number] {\n  let out = typeof data[0] === 'bigint' ? 0n : 0;\n  for (const value of data) {\n    // @ts-expect-error [ts2365] -- Typescript can't infer that all elements will be a number of the same type.\n    out += value;\n  }\n  return out;\n}\n"],"mappings":"mCAmEA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EAEP,EAAoB,CACpB,IAAI,EAAM,OAAO,EAAK,IAAO,SAAW,GAAK,EAC7C,IAAK,IAAM,KAAS,EAElB,GAAO,EAET,OAAO"}
+{"version":3,"file":"sum.js","names":[],"sources":["../src/sum.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Sum<T extends IterableContainer<bigint> | IterableContainer<number>>\n  // Empty arrays would always result in a sum of (a non-bigint) 0.\n  = T extends readonly []\n    ? 0\n    : // Non-empty bigint arrays will always result in a bigint sum.\n    T extends readonly [bigint, ...(ReadonlyArray<unknown>)]\n      ? bigint\n      : // But an empty bigint array would result in a non-bigint 0.\n      T[number] extends bigint\n        ? bigint | 0\n        : // Non-bigint arrays are always handled correctly.\n        number;\n\n/**\n * Sums the numbers in the array, or return 0 for an empty array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   sum(data);\n * @example\n *   sum([1, 2, 3]); // => 6\n *   sum([1n, 2n, 3n]); // => 6n\n *   sum([]); // => 0\n * @dataFirst\n * @category Number\n */\nexport function sum<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): Sum<T>;\n\n/**\n * Sums the numbers in the array, or return 0 for an empty array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty`to guard against this case.\n *\n * @signature\n *   sum()(data);\n * @example\n *   pipe([1, 2, 3], sum()); // => 6\n *   pipe([1n, 2n, 3n], sum()); // => 6n\n *   pipe([], sum()); // => 0\n * @dataLast\n * @category Number\n */\nexport function sum(): <\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(\n  data: T,\n) => Sum<T>;\n\nexport function sum(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sumImplementation, args);\n}\n\nfunction sumImplementation<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): T[number] {\n  let out = typeof data[0] === 'bigint' ? 0n : 0;\n  for (const value of data) {\n    // @ts-expect-error [ts2365] -- Typescript can't infer that all elements will be a number of the same type.\n    out += value;\n  }\n  return out;\n}\n"],"mappings":"mCAmEA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,CAAI,CACtC,CAEA,SAAS,EAEP,EAAoB,CACpB,IAAI,EAAM,OAAO,EAAK,IAAO,SAAW,GAAK,EAC7C,IAAK,IAAM,KAAS,EAElB,GAAO,EAET,OAAO,CACT"}

package/dist/swap-in-place-CllcD0HG.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n){[e[t],e[n]]=[e[n],e[t]]}Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return e}});
+//# sourceMappingURL=swap-in-place-CllcD0HG.cjs.map

package/dist/{swap-in-place-D1vasegg.cjs.map → swap-in-place-CllcD0HG.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"swap-in-place-D1vasegg.cjs","names":[],"sources":["../src/internal/swap-in-place.ts"],"sourcesContent":["/**\n * An efficient hack to swap the values at two indices in an array *in-place*.\n */\nexport function swapInPlace(\n  data: Array<unknown>,\n  i: number,\n  j: number,\n): void {\n  // We use destructuring to perform an in-place swap *without* needing a\n  // temporary variable\n  [data[i], data[j]] = [data[j], data[i]];\n}\n"],"mappings":"AAGA,SAAgB,EACd,EACA,EACA,EACM,CAGN,CAAC,EAAK,GAAI,EAAK,IAAM,CAAC,EAAK,GAAI,EAAK,GAAG"}
+{"version":3,"file":"swap-in-place-CllcD0HG.cjs","names":[],"sources":["../src/internal/swap-in-place.ts"],"sourcesContent":["/**\n * An efficient hack to swap the values at two indices in an array *in-place*.\n */\nexport function swapInPlace(\n  data: Array<unknown>,\n  i: number,\n  j: number,\n): void {\n  // We use destructuring to perform an in-place swap *without* needing a\n  // temporary variable\n  [data[i], data[j]] = [data[j], data[i]];\n}\n"],"mappings":"AAGA,SAAgB,EACd,EACA,EACA,EACM,CAGN,CAAC,EAAK,GAAI,EAAK,IAAM,CAAC,EAAK,GAAI,EAAK,EAAE,CACxC"}

package/dist/{swap-in-place-BzNaxwB3.js → swap-in-place-ubtnp8en.js}

@@ -1,2 +1,2 @@
 function e(e,t,n){[e[t],e[n]]=[e[n],e[t]]}export{e as t};
-//# sourceMappingURL=swap-in-place-BzNaxwB3.js.map
+//# sourceMappingURL=swap-in-place-ubtnp8en.js.map

package/dist/{swap-in-place-BzNaxwB3.js.map → swap-in-place-ubtnp8en.js.map}

@@ -1 +1 @@
-{"version":3,"file":"swap-in-place-BzNaxwB3.js","names":[],"sources":["../src/internal/swap-in-place.ts"],"sourcesContent":["/**\n * An efficient hack to swap the values at two indices in an array *in-place*.\n */\nexport function swapInPlace(\n  data: Array<unknown>,\n  i: number,\n  j: number,\n): void {\n  // We use destructuring to perform an in-place swap *without* needing a\n  // temporary variable\n  [data[i], data[j]] = [data[j], data[i]];\n}\n"],"mappings":"AAGA,SAAgB,EACd,EACA,EACA,EACM,CAGN,CAAC,EAAK,GAAI,EAAK,IAAM,CAAC,EAAK,GAAI,EAAK,GAAG"}
+{"version":3,"file":"swap-in-place-ubtnp8en.js","names":[],"sources":["../src/internal/swap-in-place.ts"],"sourcesContent":["/**\n * An efficient hack to swap the values at two indices in an array *in-place*.\n */\nexport function swapInPlace(\n  data: Array<unknown>,\n  i: number,\n  j: number,\n): void {\n  // We use destructuring to perform an in-place swap *without* needing a\n  // temporary variable\n  [data[i], data[j]] = [data[j], data[i]];\n}\n"],"mappings":"AAGA,SAAgB,EACd,EACA,EACA,EACM,CAGN,CAAC,EAAK,GAAI,EAAK,IAAM,CAAC,EAAK,GAAI,EAAK,EAAE,CACxC"}

package/dist/swap-indices.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n){return typeof e==`string`?r([...e],t,n).join(``):r(e,t,n)}function r(e,t,n){let r=[...e];if(Number.isNaN(t)||Number.isNaN(n))return r;let i=t<0?e.length+t:t,a=n<0?e.length+n:n;return i<0||i>e.length||a<0||a>e.length?r:(r[i]=e[a],r[a]=e[i],r)}exports.swapIndices=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,n){return typeof e==`string`?r([...e],t,n).join(``):r(e,t,n)}function r(e,t,n){let r=[...e];if(Number.isNaN(t)||Number.isNaN(n))return r;let i=t<0?e.length+t:t,a=n<0?e.length+n:n;return i<0||i>e.length||a<0||a>e.length?r:(r[i]=e[a],r[a]=e[i],r)}exports.swapIndices=t;
 //# sourceMappingURL=swap-indices.cjs.map

package/dist/swap-indices.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"swap-indices.cjs","names":["curry"],"sources":["../src/swap-indices.ts"],"sourcesContent":["import type { And, IsEqual, Join } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Difference<A extends number, B extends number>\n  = TupleOfLength<A> extends [...infer U, ...TupleOfLength<B>]\n    ? U['length']\n    : never;\n\ntype isLessThan<A extends number, B extends number>\n  = IsEqual<A, B> extends true\n    ? false\n    : 0 extends A\n      ? true\n      : 0 extends B\n        ? false\n        : isLessThan<Difference<A, 1>, Difference<B, 1>>;\n\ntype TupleOfLength<\n  L extends number,\n  T extends IterableContainer = [],\n> = T['length'] extends L ? T : TupleOfLength<L, [...T, unknown]>;\n\ntype IsNonNegative<T extends number> = number extends T\n  ? false\n  : `${T}` extends `-${string}`\n    ? false\n    : true;\n\ntype CharactersTuple<T extends string> = string extends T\n  ? Array<string>\n  : T extends `${infer C}${infer R}`\n    ? [C, ...CharactersTuple<R>]\n    : [];\n\ntype SwapArrayInternal<\n  T extends IterableContainer,\n  Index1 extends number,\n  Index2 extends number,\n  Position extends ReadonlyArray<unknown> = [],\n  Original extends IterableContainer = T,\n> = T extends readonly [infer AtPosition, ...infer Rest]\n  ? [\n      Position['length'] extends Index1\n        ? Original[Index2]\n        : Position['length'] extends Index2\n          ? Original[Index1]\n          : AtPosition,\n      ...SwapArrayInternal<\n        Rest,\n        Index1,\n        Index2,\n        [unknown, ...Position],\n        Original\n      >,\n    ]\n  : T;\n\ntype SwapString<T extends string, K1 extends number, K2 extends number> = Join<\n  SwapArray<CharactersTuple<T>, K1, K2>,\n  ''\n>;\n\ntype SwapArray<\n  T extends IterableContainer,\n  K1 extends number,\n  K2 extends number,\n>\n  = And<IsNonNegative<K1>, IsNonNegative<K2>> extends true\n    ? And<isLessThan<K1, T['length']>, isLessThan<K2, T['length']>> extends true\n      ? SwapArrayInternal<T, K1, K2>\n      : // If the indices are not within the input arrays range the result would\n    // be trivially the same as the input array.\n      T\n    :\n    Array<T[number]>;\n\ntype SwappedIndices<\n  T extends IterableContainer | string,\n  K1 extends number,\n  K2 extends number,\n> = T extends string\n  ? SwapString<T, K1, K2>\n  : T extends IterableContainer\n    ? SwapArray<T, K1, K2>\n    : never;\n\n/**\n * Swaps the positions of two elements in an array or string at the provided indices.\n *\n * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.\n *\n * If either index is out of bounds the result would be a shallow copy of the input, as-is.\n *\n * @param data - The item to be manipulated. This can be an array, or a string.\n * @param index1 - The first index.\n * @param index2 - The second index.\n * @returns Returns the manipulated array or string.\n * @signature\n *   swapIndices(data, index1, index2)\n * @example\n *   swapIndices(['a', 'b', 'c'], 0, 1) // => ['b', 'a', 'c']\n *   swapIndices(['a', 'b', 'c'], 1, -1) // => ['a', 'c', 'b']\n *   swapIndices('abc', 0, 1) // => 'bac'\n * @dataFirst\n * @category Array\n */\nexport function swapIndices<\n  T extends IterableContainer | string,\n  K1 extends number,\n  K2 extends number,\n>(data: T, index1: K1, index2: K2): SwappedIndices<T, K1, K2>;\n\n/**\n * Swaps the positions of two elements in an array or string at the provided indices.\n *\n * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.\n *\n * If either index is out of bounds the result would be a shallow copy of the input, as-is.\n *\n * @param index1 - The first index.\n * @param index2 - The second index.\n * @returns Returns the manipulated array or string.\n * @signature\n *   swapIndices(index1, index2)(data)\n * @example\n *   swapIndices(0, 1)(['a', 'b', 'c']) // => ['b', 'a', 'c']\n *   swapIndices(0, -1)('abc') // => 'cba'\n * @dataLast\n * @category Array\n */\nexport function swapIndices<K1 extends number, K2 extends number>(\n  index1: K1,\n  index2: K2,\n): <T extends IterableContainer | string>(data: T) => SwappedIndices<T, K1, K2>;\n\nexport function swapIndices(...args: ReadonlyArray<unknown>): unknown {\n  return curry(swapIndicesImplementation, args);\n}\n\nfunction swapIndicesImplementation(data: IterableContainer | string, index1: number, index2: number): unknown {\n  return typeof data === 'string'\n    ? swapArray([...data], index1, index2).join('')\n    : swapArray(data, index1, index2);\n}\n\nfunction swapArray(\n  data: ReadonlyArray<unknown>,\n  index1: number,\n  index2: number,\n): Array<unknown> {\n  const result = [...data];\n\n  if (Number.isNaN(index1) || Number.isNaN(index2)) {\n    return result;\n  }\n\n  const positiveIndexA = index1 < 0 ? data.length + index1 : index1;\n  const positiveIndexB = index2 < 0 ? data.length + index2 : index2;\n\n  if (positiveIndexA < 0 || positiveIndexA > data.length) {\n    return result;\n  }\n\n  if (positiveIndexB < 0 || positiveIndexB > data.length) {\n    return result;\n  }\n\n  result[positiveIndexA] = data[positiveIndexB];\n  result[positiveIndexB] = data[positiveIndexA];\n\n  return result;\n}\n"],"mappings":"kGAwIA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,SAAS,EAA0B,EAAkC,EAAgB,EAAyB,CAC5G,OAAO,OAAO,GAAS,SACnB,EAAU,CAAC,GAAG,EAAK,CAAE,EAAQ,EAAO,CAAC,KAAK,GAAG,CAC7C,EAAU,EAAM,EAAQ,EAAO,CAGrC,SAAS,EACP,EACA,EACA,EACgB,CAChB,IAAM,EAAS,CAAC,GAAG,EAAK,CAExB,GAAI,OAAO,MAAM,EAAO,EAAI,OAAO,MAAM,EAAO,CAC9C,OAAO,EAGT,IAAM,EAAiB,EAAS,EAAI,EAAK,OAAS,EAAS,EACrD,EAAiB,EAAS,EAAI,EAAK,OAAS,EAAS,EAa3D,OAXI,EAAiB,GAAK,EAAiB,EAAK,QAI5C,EAAiB,GAAK,EAAiB,EAAK,OACvC,GAGT,EAAO,GAAkB,EAAK,GAC9B,EAAO,GAAkB,EAAK,GAEvB"}
+{"version":3,"file":"swap-indices.cjs","names":["curry"],"sources":["../src/swap-indices.ts"],"sourcesContent":["import type { IsEqual, Join } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Difference<A extends number, B extends number>\n  = TupleOfLength<A> extends [...infer U, ...TupleOfLength<B>]\n    ? U['length']\n    : never;\n\ntype isLessThan<A extends number, B extends number>\n  = IsEqual<A, B> extends true\n    ? false\n    : 0 extends A\n      ? true\n      : 0 extends B\n        ? false\n        : isLessThan<Difference<A, 1>, Difference<B, 1>>;\n\ntype TupleOfLength<\n  L extends number,\n  T extends IterableContainer = [],\n> = T['length'] extends L ? T : TupleOfLength<L, [...T, unknown]>;\n\ntype IsNonNegative<T extends number> = number extends T\n  ? false\n  : `${T}` extends `-${string}`\n    ? false\n    : true;\n\ntype CharactersTuple<T extends string> = string extends T\n  ? Array<string>\n  : T extends `${infer C}${infer R}`\n    ? [C, ...CharactersTuple<R>]\n    : [];\n\ntype SwapArrayInternal<\n  T extends IterableContainer,\n  Index1 extends number,\n  Index2 extends number,\n  Position extends ReadonlyArray<unknown> = [],\n  Original extends IterableContainer = T,\n> = T extends readonly [infer AtPosition, ...infer Rest]\n  ? [\n      Position['length'] extends Index1\n        ? Original[Index2]\n        : Position['length'] extends Index2\n          ? Original[Index1]\n          : AtPosition,\n      ...SwapArrayInternal<\n        Rest,\n        Index1,\n        Index2,\n        [unknown, ...Position],\n        Original\n      >,\n    ]\n  : T;\n\ntype SwapString<T extends string, K1 extends number, K2 extends number> = Join<\n  SwapArray<CharactersTuple<T>, K1, K2>,\n  ''\n>;\n\ntype SwapArray<\n  T extends IterableContainer,\n  K1 extends number,\n  K2 extends number,\n>\n  = IsNonNegative<K1> extends true\n    ? IsNonNegative<K2> extends true\n      ? isLessThan<K1, T['length']> extends true\n        ? isLessThan<K2, T['length']> extends true\n          ? SwapArrayInternal<T, K1, K2>\n          : // If the indices are not within the input arrays range the result\n        // would be trivially the same as the input array.\n          T\n        : T\n      : // TODO [>3]: Because of limitations on the typescript version used in Remeda we can't build a proper Absolute number type so we can't implement proper typing for negative indices and have to opt for a less-strict type instead. Check out the history for the PR that introduced this TODO to see how it could be implemented.\n      Array<T[number]>\n    : Array<T[number]>;\n\ntype SwappedIndices<\n  T extends IterableContainer | string,\n  K1 extends number,\n  K2 extends number,\n> = T extends string\n  ? SwapString<T, K1, K2>\n  : T extends IterableContainer\n    ? SwapArray<T, K1, K2>\n    : never;\n\n/**\n * Swaps the positions of two elements in an array or string at the provided indices.\n *\n * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.\n *\n * If either index is out of bounds the result would be a shallow copy of the input, as-is.\n *\n * Related operations:\n * - `splice` - for more general positional edits (remove a slice, insert at an index).\n *\n * @param data - The item to be manipulated. This can be an array, or a string.\n * @param index1 - The first index.\n * @param index2 - The second index.\n * @returns Returns the manipulated array or string.\n * @signature\n *   swapIndices(data, index1, index2)\n * @example\n *   swapIndices(['a', 'b', 'c'], 0, 1) // => ['b', 'a', 'c']\n *   swapIndices(['a', 'b', 'c'], 1, -1) // => ['a', 'c', 'b']\n *   swapIndices('abc', 0, 1) // => 'bac'\n * @dataFirst\n * @category Array\n */\nexport function swapIndices<\n  T extends IterableContainer | string,\n  K1 extends number,\n  K2 extends number,\n>(data: T, index1: K1, index2: K2): SwappedIndices<T, K1, K2>;\n\n/**\n * Swaps the positions of two elements in an array or string at the provided indices.\n *\n * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.\n *\n * If either index is out of bounds the result would be a shallow copy of the input, as-is.\n *\n * Related operations:\n * - `splice` - for more general positional edits (remove a slice, insert at an index).\n *\n * @param index1 - The first index.\n * @param index2 - The second index.\n * @returns Returns the manipulated array or string.\n * @signature\n *   swapIndices(index1, index2)(data)\n * @example\n *   swapIndices(0, 1)(['a', 'b', 'c']) // => ['b', 'a', 'c']\n *   swapIndices(0, -1)('abc') // => 'cba'\n * @dataLast\n * @category Array\n */\nexport function swapIndices<K1 extends number, K2 extends number>(\n  index1: K1,\n  index2: K2,\n): <T extends IterableContainer | string>(data: T) => SwappedIndices<T, K1, K2>;\n\nexport function swapIndices(...args: ReadonlyArray<unknown>): unknown {\n  return curry(swapIndicesImplementation, args);\n}\n\nfunction swapIndicesImplementation(data: IterableContainer | string, index1: number, index2: number): unknown {\n  return typeof data === 'string'\n    ? swapArray([...data], index1, index2).join('')\n    : swapArray(data, index1, index2);\n}\n\nfunction swapArray(\n  data: ReadonlyArray<unknown>,\n  index1: number,\n  index2: number,\n): Array<unknown> {\n  const result = [...data];\n\n  if (Number.isNaN(index1) || Number.isNaN(index2)) {\n    return result;\n  }\n\n  const positiveIndexA = index1 < 0 ? data.length + index1 : index1;\n  const positiveIndexB = index2 < 0 ? data.length + index2 : index2;\n\n  if (positiveIndexA < 0 || positiveIndexA > data.length) {\n    return result;\n  }\n\n  if (positiveIndexB < 0 || positiveIndexB > data.length) {\n    return result;\n  }\n\n  result[positiveIndexA] = data[positiveIndexB];\n  result[positiveIndexB] = data[positiveIndexA];\n\n  return result;\n}\n"],"mappings":"kGAkJA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAA0B,EAAkC,EAAgB,EAAyB,CAC5G,OAAO,OAAO,GAAS,SACnB,EAAU,CAAC,GAAG,CAAI,EAAG,EAAQ,CAAM,CAAC,CAAC,KAAK,EAAE,EAC5C,EAAU,EAAM,EAAQ,CAAM,CACpC,CAEA,SAAS,EACP,EACA,EACA,EACgB,CAChB,IAAM,EAAS,CAAC,GAAG,CAAI,EAEvB,GAAI,OAAO,MAAM,CAAM,GAAK,OAAO,MAAM,CAAM,EAC7C,OAAO,EAGT,IAAM,EAAiB,EAAS,EAAI,EAAK,OAAS,EAAS,EACrD,EAAiB,EAAS,EAAI,EAAK,OAAS,EAAS,EAa3D,OAXI,EAAiB,GAAK,EAAiB,EAAK,QAI5C,EAAiB,GAAK,EAAiB,EAAK,OACvC,GAGT,EAAO,GAAkB,EAAK,GAC9B,EAAO,GAAkB,EAAK,GAEvB,EACT"}

package/dist/swap-indices.js.map

@@ -1 +1 @@
-{"version":3,"file":"swap-indices.js","names":[],"sources":["../src/swap-indices.ts"],"sourcesContent":["import type { And, IsEqual, Join } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Difference<A extends number, B extends number>\n  = TupleOfLength<A> extends [...infer U, ...TupleOfLength<B>]\n    ? U['length']\n    : never;\n\ntype isLessThan<A extends number, B extends number>\n  = IsEqual<A, B> extends true\n    ? false\n    : 0 extends A\n      ? true\n      : 0 extends B\n        ? false\n        : isLessThan<Difference<A, 1>, Difference<B, 1>>;\n\ntype TupleOfLength<\n  L extends number,\n  T extends IterableContainer = [],\n> = T['length'] extends L ? T : TupleOfLength<L, [...T, unknown]>;\n\ntype IsNonNegative<T extends number> = number extends T\n  ? false\n  : `${T}` extends `-${string}`\n    ? false\n    : true;\n\ntype CharactersTuple<T extends string> = string extends T\n  ? Array<string>\n  : T extends `${infer C}${infer R}`\n    ? [C, ...CharactersTuple<R>]\n    : [];\n\ntype SwapArrayInternal<\n  T extends IterableContainer,\n  Index1 extends number,\n  Index2 extends number,\n  Position extends ReadonlyArray<unknown> = [],\n  Original extends IterableContainer = T,\n> = T extends readonly [infer AtPosition, ...infer Rest]\n  ? [\n      Position['length'] extends Index1\n        ? Original[Index2]\n        : Position['length'] extends Index2\n          ? Original[Index1]\n          : AtPosition,\n      ...SwapArrayInternal<\n        Rest,\n        Index1,\n        Index2,\n        [unknown, ...Position],\n        Original\n      >,\n    ]\n  : T;\n\ntype SwapString<T extends string, K1 extends number, K2 extends number> = Join<\n  SwapArray<CharactersTuple<T>, K1, K2>,\n  ''\n>;\n\ntype SwapArray<\n  T extends IterableContainer,\n  K1 extends number,\n  K2 extends number,\n>\n  = And<IsNonNegative<K1>, IsNonNegative<K2>> extends true\n    ? And<isLessThan<K1, T['length']>, isLessThan<K2, T['length']>> extends true\n      ? SwapArrayInternal<T, K1, K2>\n      : // If the indices are not within the input arrays range the result would\n    // be trivially the same as the input array.\n      T\n    :\n    Array<T[number]>;\n\ntype SwappedIndices<\n  T extends IterableContainer | string,\n  K1 extends number,\n  K2 extends number,\n> = T extends string\n  ? SwapString<T, K1, K2>\n  : T extends IterableContainer\n    ? SwapArray<T, K1, K2>\n    : never;\n\n/**\n * Swaps the positions of two elements in an array or string at the provided indices.\n *\n * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.\n *\n * If either index is out of bounds the result would be a shallow copy of the input, as-is.\n *\n * @param data - The item to be manipulated. This can be an array, or a string.\n * @param index1 - The first index.\n * @param index2 - The second index.\n * @returns Returns the manipulated array or string.\n * @signature\n *   swapIndices(data, index1, index2)\n * @example\n *   swapIndices(['a', 'b', 'c'], 0, 1) // => ['b', 'a', 'c']\n *   swapIndices(['a', 'b', 'c'], 1, -1) // => ['a', 'c', 'b']\n *   swapIndices('abc', 0, 1) // => 'bac'\n * @dataFirst\n * @category Array\n */\nexport function swapIndices<\n  T extends IterableContainer | string,\n  K1 extends number,\n  K2 extends number,\n>(data: T, index1: K1, index2: K2): SwappedIndices<T, K1, K2>;\n\n/**\n * Swaps the positions of two elements in an array or string at the provided indices.\n *\n * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.\n *\n * If either index is out of bounds the result would be a shallow copy of the input, as-is.\n *\n * @param index1 - The first index.\n * @param index2 - The second index.\n * @returns Returns the manipulated array or string.\n * @signature\n *   swapIndices(index1, index2)(data)\n * @example\n *   swapIndices(0, 1)(['a', 'b', 'c']) // => ['b', 'a', 'c']\n *   swapIndices(0, -1)('abc') // => 'cba'\n * @dataLast\n * @category Array\n */\nexport function swapIndices<K1 extends number, K2 extends number>(\n  index1: K1,\n  index2: K2,\n): <T extends IterableContainer | string>(data: T) => SwappedIndices<T, K1, K2>;\n\nexport function swapIndices(...args: ReadonlyArray<unknown>): unknown {\n  return curry(swapIndicesImplementation, args);\n}\n\nfunction swapIndicesImplementation(data: IterableContainer | string, index1: number, index2: number): unknown {\n  return typeof data === 'string'\n    ? swapArray([...data], index1, index2).join('')\n    : swapArray(data, index1, index2);\n}\n\nfunction swapArray(\n  data: ReadonlyArray<unknown>,\n  index1: number,\n  index2: number,\n): Array<unknown> {\n  const result = [...data];\n\n  if (Number.isNaN(index1) || Number.isNaN(index2)) {\n    return result;\n  }\n\n  const positiveIndexA = index1 < 0 ? data.length + index1 : index1;\n  const positiveIndexB = index2 < 0 ? data.length + index2 : index2;\n\n  if (positiveIndexA < 0 || positiveIndexA > data.length) {\n    return result;\n  }\n\n  if (positiveIndexB < 0 || positiveIndexB > data.length) {\n    return result;\n  }\n\n  result[positiveIndexA] = data[positiveIndexB];\n  result[positiveIndexB] = data[positiveIndexA];\n\n  return result;\n}\n"],"mappings":"mCAwIA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAA0B,EAAkC,EAAgB,EAAyB,CAC5G,OAAO,OAAO,GAAS,SACnB,EAAU,CAAC,GAAG,EAAK,CAAE,EAAQ,EAAO,CAAC,KAAK,GAAG,CAC7C,EAAU,EAAM,EAAQ,EAAO,CAGrC,SAAS,EACP,EACA,EACA,EACgB,CAChB,IAAM,EAAS,CAAC,GAAG,EAAK,CAExB,GAAI,OAAO,MAAM,EAAO,EAAI,OAAO,MAAM,EAAO,CAC9C,OAAO,EAGT,IAAM,EAAiB,EAAS,EAAI,EAAK,OAAS,EAAS,EACrD,EAAiB,EAAS,EAAI,EAAK,OAAS,EAAS,EAa3D,OAXI,EAAiB,GAAK,EAAiB,EAAK,QAI5C,EAAiB,GAAK,EAAiB,EAAK,OACvC,GAGT,EAAO,GAAkB,EAAK,GAC9B,EAAO,GAAkB,EAAK,GAEvB"}
+{"version":3,"file":"swap-indices.js","names":[],"sources":["../src/swap-indices.ts"],"sourcesContent":["import type { IsEqual, Join } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Difference<A extends number, B extends number>\n  = TupleOfLength<A> extends [...infer U, ...TupleOfLength<B>]\n    ? U['length']\n    : never;\n\ntype isLessThan<A extends number, B extends number>\n  = IsEqual<A, B> extends true\n    ? false\n    : 0 extends A\n      ? true\n      : 0 extends B\n        ? false\n        : isLessThan<Difference<A, 1>, Difference<B, 1>>;\n\ntype TupleOfLength<\n  L extends number,\n  T extends IterableContainer = [],\n> = T['length'] extends L ? T : TupleOfLength<L, [...T, unknown]>;\n\ntype IsNonNegative<T extends number> = number extends T\n  ? false\n  : `${T}` extends `-${string}`\n    ? false\n    : true;\n\ntype CharactersTuple<T extends string> = string extends T\n  ? Array<string>\n  : T extends `${infer C}${infer R}`\n    ? [C, ...CharactersTuple<R>]\n    : [];\n\ntype SwapArrayInternal<\n  T extends IterableContainer,\n  Index1 extends number,\n  Index2 extends number,\n  Position extends ReadonlyArray<unknown> = [],\n  Original extends IterableContainer = T,\n> = T extends readonly [infer AtPosition, ...infer Rest]\n  ? [\n      Position['length'] extends Index1\n        ? Original[Index2]\n        : Position['length'] extends Index2\n          ? Original[Index1]\n          : AtPosition,\n      ...SwapArrayInternal<\n        Rest,\n        Index1,\n        Index2,\n        [unknown, ...Position],\n        Original\n      >,\n    ]\n  : T;\n\ntype SwapString<T extends string, K1 extends number, K2 extends number> = Join<\n  SwapArray<CharactersTuple<T>, K1, K2>,\n  ''\n>;\n\ntype SwapArray<\n  T extends IterableContainer,\n  K1 extends number,\n  K2 extends number,\n>\n  = IsNonNegative<K1> extends true\n    ? IsNonNegative<K2> extends true\n      ? isLessThan<K1, T['length']> extends true\n        ? isLessThan<K2, T['length']> extends true\n          ? SwapArrayInternal<T, K1, K2>\n          : // If the indices are not within the input arrays range the result\n        // would be trivially the same as the input array.\n          T\n        : T\n      : // TODO [>3]: Because of limitations on the typescript version used in Remeda we can't build a proper Absolute number type so we can't implement proper typing for negative indices and have to opt for a less-strict type instead. Check out the history for the PR that introduced this TODO to see how it could be implemented.\n      Array<T[number]>\n    : Array<T[number]>;\n\ntype SwappedIndices<\n  T extends IterableContainer | string,\n  K1 extends number,\n  K2 extends number,\n> = T extends string\n  ? SwapString<T, K1, K2>\n  : T extends IterableContainer\n    ? SwapArray<T, K1, K2>\n    : never;\n\n/**\n * Swaps the positions of two elements in an array or string at the provided indices.\n *\n * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.\n *\n * If either index is out of bounds the result would be a shallow copy of the input, as-is.\n *\n * Related operations:\n * - `splice` - for more general positional edits (remove a slice, insert at an index).\n *\n * @param data - The item to be manipulated. This can be an array, or a string.\n * @param index1 - The first index.\n * @param index2 - The second index.\n * @returns Returns the manipulated array or string.\n * @signature\n *   swapIndices(data, index1, index2)\n * @example\n *   swapIndices(['a', 'b', 'c'], 0, 1) // => ['b', 'a', 'c']\n *   swapIndices(['a', 'b', 'c'], 1, -1) // => ['a', 'c', 'b']\n *   swapIndices('abc', 0, 1) // => 'bac'\n * @dataFirst\n * @category Array\n */\nexport function swapIndices<\n  T extends IterableContainer | string,\n  K1 extends number,\n  K2 extends number,\n>(data: T, index1: K1, index2: K2): SwappedIndices<T, K1, K2>;\n\n/**\n * Swaps the positions of two elements in an array or string at the provided indices.\n *\n * Negative indices are supported and would be treated as an offset from the end of the array. The resulting type thought would be less strict than when using positive indices.\n *\n * If either index is out of bounds the result would be a shallow copy of the input, as-is.\n *\n * Related operations:\n * - `splice` - for more general positional edits (remove a slice, insert at an index).\n *\n * @param index1 - The first index.\n * @param index2 - The second index.\n * @returns Returns the manipulated array or string.\n * @signature\n *   swapIndices(index1, index2)(data)\n * @example\n *   swapIndices(0, 1)(['a', 'b', 'c']) // => ['b', 'a', 'c']\n *   swapIndices(0, -1)('abc') // => 'cba'\n * @dataLast\n * @category Array\n */\nexport function swapIndices<K1 extends number, K2 extends number>(\n  index1: K1,\n  index2: K2,\n): <T extends IterableContainer | string>(data: T) => SwappedIndices<T, K1, K2>;\n\nexport function swapIndices(...args: ReadonlyArray<unknown>): unknown {\n  return curry(swapIndicesImplementation, args);\n}\n\nfunction swapIndicesImplementation(data: IterableContainer | string, index1: number, index2: number): unknown {\n  return typeof data === 'string'\n    ? swapArray([...data], index1, index2).join('')\n    : swapArray(data, index1, index2);\n}\n\nfunction swapArray(\n  data: ReadonlyArray<unknown>,\n  index1: number,\n  index2: number,\n): Array<unknown> {\n  const result = [...data];\n\n  if (Number.isNaN(index1) || Number.isNaN(index2)) {\n    return result;\n  }\n\n  const positiveIndexA = index1 < 0 ? data.length + index1 : index1;\n  const positiveIndexB = index2 < 0 ? data.length + index2 : index2;\n\n  if (positiveIndexA < 0 || positiveIndexA > data.length) {\n    return result;\n  }\n\n  if (positiveIndexB < 0 || positiveIndexB > data.length) {\n    return result;\n  }\n\n  result[positiveIndexA] = data[positiveIndexB];\n  result[positiveIndexB] = data[positiveIndexA];\n\n  return result;\n}\n"],"mappings":"mCAkJA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,CAAI,CAC9C,CAEA,SAAS,EAA0B,EAAkC,EAAgB,EAAyB,CAC5G,OAAO,OAAO,GAAS,SACnB,EAAU,CAAC,GAAG,CAAI,EAAG,EAAQ,CAAM,CAAC,CAAC,KAAK,EAAE,EAC5C,EAAU,EAAM,EAAQ,CAAM,CACpC,CAEA,SAAS,EACP,EACA,EACA,EACgB,CAChB,IAAM,EAAS,CAAC,GAAG,CAAI,EAEvB,GAAI,OAAO,MAAM,CAAM,GAAK,OAAO,MAAM,CAAM,EAC7C,OAAO,EAGT,IAAM,EAAiB,EAAS,EAAI,EAAK,OAAS,EAAS,EACrD,EAAiB,EAAS,EAAI,EAAK,OAAS,EAAS,EAa3D,OAXI,EAAiB,GAAK,EAAiB,EAAK,QAI5C,EAAiB,GAAK,EAAiB,EAAK,OACvC,GAGT,EAAO,GAAkB,EAAK,GAC9B,EAAO,GAAkB,EAAK,GAEvB,EACT"}

package/dist/swap-props.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n){let{[t]:r,[n]:i}=e;return{...e,[t]:i,[n]:r}}exports.swapProps=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,n){let{[t]:r,[n]:i}=e;return{...e,[t]:i,[n]:r}}exports.swapProps=t;
 //# sourceMappingURL=swap-props.cjs.map

package/dist/swap-props.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"swap-props.cjs","names":["curry"],"sources":["../src/swap-props.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype SwappedProps<T, K1 extends keyof T, K2 extends keyof T> = {\n  [K in keyof T]: T[K1 extends K ? K2 : K2 extends K ? K1 : K];\n};\n\n/**\n * Swaps the values of two properties in an object based on the provided keys.\n *\n * @param data - The object to be manipulated.\n * @param key1 - The first property key.\n * @param key2 - The second property key.\n * @returns Returns the manipulated object.\n * @signature\n *   swapProps(data, key1, key2)\n * @example\n *   swapProps({a: 1, b: 2, c: 3}, 'a', 'b') // => {a: 2, b: 1, c: 3}\n * @dataFirst\n * @category Object\n */\nexport function swapProps<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(data: T, key1: K1, key2: K2): SwappedProps<T, K1, K2>;\n\n/**\n * Swaps the values of two properties in an object based on the provided keys.\n *\n * @param key1 - The first property key.\n * @param key2 - The second property key.\n * @returns Returns the manipulated object.\n * @signature\n *   swapProps(key1, key2)(data)\n * @example\n *   swapProps('a', 'b')({a: 1, b: 2, c: 3}) // => {a: 2, b: 1, c: 3}\n * @dataLast\n * @category Object\n */\nexport function swapProps<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(key1: K1, key2: K2): (data: T) => SwappedProps<T, K1, K2>;\n\nexport function swapProps(...args: ReadonlyArray<unknown>): unknown {\n  return curry(swapPropsImplementation, args);\n}\n\nfunction swapPropsImplementation<T extends object>(\n  obj: T,\n  key1: keyof T,\n  key2: keyof T,\n): Record<PropertyKey, unknown> {\n  const { [key1]: value1, [key2]: value2 } = obj;\n  return {\n    ...obj,\n    [key1]: value2,\n    [key2]: value1,\n  };\n}\n"],"mappings":"kGA6CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACA,EAC8B,CAC9B,GAAM,EAAG,GAAO,GAAS,GAAO,GAAW,EAC3C,MAAO,CACL,GAAG,GACF,GAAO,GACP,GAAO,EACT"}
+{"version":3,"file":"swap-props.cjs","names":["curry"],"sources":["../src/swap-props.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype SwappedProps<T, K1 extends keyof T, K2 extends keyof T> = {\n  [K in keyof T]: T[K1 extends K ? K2 : K2 extends K ? K1 : K];\n};\n\n/**\n * Swaps the values of two properties in an object based on the provided keys.\n *\n * @param data - The object to be manipulated.\n * @param key1 - The first property key.\n * @param key2 - The second property key.\n * @returns Returns the manipulated object.\n * @signature\n *   swapProps(data, key1, key2)\n * @example\n *   swapProps({a: 1, b: 2, c: 3}, 'a', 'b') // => {a: 2, b: 1, c: 3}\n * @dataFirst\n * @category Object\n */\nexport function swapProps<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(data: T, key1: K1, key2: K2): SwappedProps<T, K1, K2>;\n\n/**\n * Swaps the values of two properties in an object based on the provided keys.\n *\n * @param key1 - The first property key.\n * @param key2 - The second property key.\n * @returns Returns the manipulated object.\n * @signature\n *   swapProps(key1, key2)(data)\n * @example\n *   swapProps('a', 'b')({a: 1, b: 2, c: 3}) // => {a: 2, b: 1, c: 3}\n * @dataLast\n * @category Object\n */\nexport function swapProps<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(key1: K1, key2: K2): (data: T) => SwappedProps<T, K1, K2>;\n\nexport function swapProps(...args: ReadonlyArray<unknown>): unknown {\n  return curry(swapPropsImplementation, args);\n}\n\nfunction swapPropsImplementation<T extends object>(\n  obj: T,\n  key1: keyof T,\n  key2: keyof T,\n): Record<PropertyKey, unknown> {\n  const { [key1]: value1, [key2]: value2 } = obj;\n  return {\n    ...obj,\n    [key1]: value2,\n    [key2]: value1,\n  };\n}\n"],"mappings":"kGA6CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,EAAyB,CAAI,CAC5C,CAEA,SAAS,EACP,EACA,EACA,EAC8B,CAC9B,GAAM,EAAG,GAAO,GAAS,GAAO,GAAW,EAC3C,MAAO,CACL,GAAG,GACF,GAAO,GACP,GAAO,CACV,CACF"}

package/dist/swap-props.js.map

@@ -1 +1 @@
-{"version":3,"file":"swap-props.js","names":[],"sources":["../src/swap-props.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype SwappedProps<T, K1 extends keyof T, K2 extends keyof T> = {\n  [K in keyof T]: T[K1 extends K ? K2 : K2 extends K ? K1 : K];\n};\n\n/**\n * Swaps the values of two properties in an object based on the provided keys.\n *\n * @param data - The object to be manipulated.\n * @param key1 - The first property key.\n * @param key2 - The second property key.\n * @returns Returns the manipulated object.\n * @signature\n *   swapProps(data, key1, key2)\n * @example\n *   swapProps({a: 1, b: 2, c: 3}, 'a', 'b') // => {a: 2, b: 1, c: 3}\n * @dataFirst\n * @category Object\n */\nexport function swapProps<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(data: T, key1: K1, key2: K2): SwappedProps<T, K1, K2>;\n\n/**\n * Swaps the values of two properties in an object based on the provided keys.\n *\n * @param key1 - The first property key.\n * @param key2 - The second property key.\n * @returns Returns the manipulated object.\n * @signature\n *   swapProps(key1, key2)(data)\n * @example\n *   swapProps('a', 'b')({a: 1, b: 2, c: 3}) // => {a: 2, b: 1, c: 3}\n * @dataLast\n * @category Object\n */\nexport function swapProps<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(key1: K1, key2: K2): (data: T) => SwappedProps<T, K1, K2>;\n\nexport function swapProps(...args: ReadonlyArray<unknown>): unknown {\n  return curry(swapPropsImplementation, args);\n}\n\nfunction swapPropsImplementation<T extends object>(\n  obj: T,\n  key1: keyof T,\n  key2: keyof T,\n): Record<PropertyKey, unknown> {\n  const { [key1]: value1, [key2]: value2 } = obj;\n  return {\n    ...obj,\n    [key1]: value2,\n    [key2]: value1,\n  };\n}\n"],"mappings":"mCA6CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACA,EAC8B,CAC9B,GAAM,EAAG,GAAO,GAAS,GAAO,GAAW,EAC3C,MAAO,CACL,GAAG,GACF,GAAO,GACP,GAAO,EACT"}
+{"version":3,"file":"swap-props.js","names":[],"sources":["../src/swap-props.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype SwappedProps<T, K1 extends keyof T, K2 extends keyof T> = {\n  [K in keyof T]: T[K1 extends K ? K2 : K2 extends K ? K1 : K];\n};\n\n/**\n * Swaps the values of two properties in an object based on the provided keys.\n *\n * @param data - The object to be manipulated.\n * @param key1 - The first property key.\n * @param key2 - The second property key.\n * @returns Returns the manipulated object.\n * @signature\n *   swapProps(data, key1, key2)\n * @example\n *   swapProps({a: 1, b: 2, c: 3}, 'a', 'b') // => {a: 2, b: 1, c: 3}\n * @dataFirst\n * @category Object\n */\nexport function swapProps<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(data: T, key1: K1, key2: K2): SwappedProps<T, K1, K2>;\n\n/**\n * Swaps the values of two properties in an object based on the provided keys.\n *\n * @param key1 - The first property key.\n * @param key2 - The second property key.\n * @returns Returns the manipulated object.\n * @signature\n *   swapProps(key1, key2)(data)\n * @example\n *   swapProps('a', 'b')({a: 1, b: 2, c: 3}) // => {a: 2, b: 1, c: 3}\n * @dataLast\n * @category Object\n */\nexport function swapProps<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(key1: K1, key2: K2): (data: T) => SwappedProps<T, K1, K2>;\n\nexport function swapProps(...args: ReadonlyArray<unknown>): unknown {\n  return curry(swapPropsImplementation, args);\n}\n\nfunction swapPropsImplementation<T extends object>(\n  obj: T,\n  key1: keyof T,\n  key2: keyof T,\n): Record<PropertyKey, unknown> {\n  const { [key1]: value1, [key2]: value2 } = obj;\n  return {\n    ...obj,\n    [key1]: value2,\n    [key2]: value1,\n  };\n}\n"],"mappings":"mCA6CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,CAAI,CAC5C,CAEA,SAAS,EACP,EACA,EACA,EAC8B,CAC9B,GAAM,EAAG,GAAO,GAAS,GAAO,GAAW,EAC3C,MAAO,CACL,GAAG,GACF,GAAO,GACP,GAAO,CACV,CACF"}

package/dist/take-first-by.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry-order-rules-DsJSy3gX.cjs`),t=require(`./heap-C0zPQGC0.cjs`);function n(...t){return e.n(r,t)}function r(e,n,r){if(r<=0)return[];if(r>=e.length)return[...e];let i=e.slice(0,r);t.n(i,n);let a=e.slice(r);for(let e of a)t.t(i,n,e);return i}exports.takeFirstBy=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry-order-rules-CacOTzfW.cjs"),t=require("./heap-BK0Y5t1Y.cjs");function n(...t){return e.n(r,t)}function r(e,n,r){if(r<=0)return[];if(r>=e.length)return[...e];let i=e.slice(0,r);t.n(i,n);let a=e.slice(r);for(let e of a)t.t(i,n,e);return i}exports.takeFirstBy=n;
 //# sourceMappingURL=take-first-by.cjs.map

package/dist/take-first-by.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"take-first-by.cjs","names":["curryOrderRulesWithArgument"],"sources":["../src/take-first-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\nimport { heapify, heapMaybeInsert } from './internal/heap';\n\n/**\n * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to drop `n` elements) see `dropFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   takeFirstBy(data, n, ...rules);\n * @example\n *   takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aa', 'a']\n * @dataFirst\n * @category Array\n */\nexport function takeFirstBy<T>(\n  data: ReadonlyArray<T>,\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): Array<T>;\n\n/**\n * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to drop `n` elements) see `dropFirstBy`.\n *\n * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   takeFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], takeFirstBy(2, x => x.length)); // => ['aa', 'a']\n * @dataLast\n * @category Array\n */\nexport function takeFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function takeFirstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(takeFirstByImplementation, args);\n}\n\nfunction takeFirstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  n: number,\n): Array<T> {\n  if (n <= 0) {\n    return [];\n  }\n\n  if (n >= data.length) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    heapMaybeInsert(heap, compareFn, item);\n  }\n\n  return heap;\n}\n"],"mappings":"wJAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACU,CACV,GAAI,GAAK,EACP,MAAO,EAAE,CAGX,GAAI,GAAK,EAAK,OACZ,MAAO,CAAC,GAAG,EAAK,CAGlB,IAAM,EAAO,EAAK,MAAM,EAAG,EAAE,CAC7B,EAAA,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EACjB,EAAA,EAAgB,EAAM,EAAW,EAAK,CAGxC,OAAO"}
+{"version":3,"file":"take-first-by.cjs","names":["curryOrderRulesWithArgument"],"sources":["../src/take-first-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\nimport { heapify, heapMaybeInsert } from './internal/heap';\n\n/**\n * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to drop `n` elements) see `dropFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   takeFirstBy(data, n, ...rules);\n * @example\n *   takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aa', 'a']\n * @dataFirst\n * @category Array\n */\nexport function takeFirstBy<T>(\n  data: ReadonlyArray<T>,\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): Array<T>;\n\n/**\n * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to drop `n` elements) see `dropFirstBy`.\n *\n * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   takeFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], takeFirstBy(2, x => x.length)); // => ['aa', 'a']\n * @dataLast\n * @category Array\n */\nexport function takeFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function takeFirstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(takeFirstByImplementation, args);\n}\n\nfunction takeFirstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  n: number,\n): Array<T> {\n  if (n <= 0) {\n    return [];\n  }\n\n  if (n >= data.length) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    heapMaybeInsert(heap, compareFn, item);\n  }\n\n  return heap;\n}\n"],"mappings":"wJAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,EAA4B,EAA2B,CAAI,CACpE,CAEA,SAAS,EACP,EACA,EACA,EACU,CACV,GAAI,GAAK,EACP,MAAO,CAAC,EAGV,GAAI,GAAK,EAAK,OACZ,MAAO,CAAC,GAAG,CAAI,EAGjB,IAAM,EAAO,EAAK,MAAM,EAAG,CAAC,EAC5B,EAAA,EAAQ,EAAM,CAAS,EAEvB,IAAM,EAAO,EAAK,MAAM,CAAC,EACzB,IAAK,IAAM,KAAQ,EACjB,EAAA,EAAgB,EAAM,EAAW,CAAI,EAGvC,OAAO,CACT"}

package/dist/take-first-by.js

@@ -1,2 +1,2 @@
-import{n as e}from"./curry-order-rules-BLyCSMdZ.js";import{n as t,t as n}from"./heap-M6D40vkc.js";function r(...t){return e(i,t)}function i(e,r,i){if(i<=0)return[];if(i>=e.length)return[...e];let a=e.slice(0,i);t(a,r);let o=e.slice(i);for(let e of o)n(a,r,e);return a}export{r as takeFirstBy};
+import{n as e}from"./curry-order-rules-Dage-BeC.js";import{n as t,t as n}from"./heap-CL5ahv5n.js";function r(...t){return e(i,t)}function i(e,r,i){if(i<=0)return[];if(i>=e.length)return[...e];let a=e.slice(0,i);t(a,r);let o=e.slice(i);for(let e of o)n(a,r,e);return a}export{r as takeFirstBy};
 //# sourceMappingURL=take-first-by.js.map

package/dist/take-first-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"take-first-by.js","names":[],"sources":["../src/take-first-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\nimport { heapify, heapMaybeInsert } from './internal/heap';\n\n/**\n * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to drop `n` elements) see `dropFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   takeFirstBy(data, n, ...rules);\n * @example\n *   takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aa', 'a']\n * @dataFirst\n * @category Array\n */\nexport function takeFirstBy<T>(\n  data: ReadonlyArray<T>,\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): Array<T>;\n\n/**\n * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to drop `n` elements) see `dropFirstBy`.\n *\n * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   takeFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], takeFirstBy(2, x => x.length)); // => ['aa', 'a']\n * @dataLast\n * @category Array\n */\nexport function takeFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function takeFirstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(takeFirstByImplementation, args);\n}\n\nfunction takeFirstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  n: number,\n): Array<T> {\n  if (n <= 0) {\n    return [];\n  }\n\n  if (n >= data.length) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    heapMaybeInsert(heap, compareFn, item);\n  }\n\n  return heap;\n}\n"],"mappings":"kGAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACU,CACV,GAAI,GAAK,EACP,MAAO,EAAE,CAGX,GAAI,GAAK,EAAK,OACZ,MAAO,CAAC,GAAG,EAAK,CAGlB,IAAM,EAAO,EAAK,MAAM,EAAG,EAAE,CAC7B,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EACjB,EAAgB,EAAM,EAAW,EAAK,CAGxC,OAAO"}
+{"version":3,"file":"take-first-by.js","names":[],"sources":["../src/take-first-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\nimport { heapify, heapMaybeInsert } from './internal/heap';\n\n/**\n * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to drop `n` elements) see `dropFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   takeFirstBy(data, n, ...rules);\n * @example\n *   takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aa', 'a']\n * @dataFirst\n * @category Array\n */\nexport function takeFirstBy<T>(\n  data: ReadonlyArray<T>,\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): Array<T>;\n\n/**\n * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.\n *\n * For the opposite operation (to drop `n` elements) see `dropFirstBy`.\n *\n * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns A subset of the input array.\n * @signature\n *   takeFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], takeFirstBy(2, x => x.length)); // => ['aa', 'a']\n * @dataLast\n * @category Array\n */\nexport function takeFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function takeFirstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(takeFirstByImplementation, args);\n}\n\nfunction takeFirstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  n: number,\n): Array<T> {\n  if (n <= 0) {\n    return [];\n  }\n\n  if (n >= data.length) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    heapMaybeInsert(heap, compareFn, item);\n  }\n\n  return heap;\n}\n"],"mappings":"kGAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAA4B,EAA2B,CAAI,CACpE,CAEA,SAAS,EACP,EACA,EACA,EACU,CACV,GAAI,GAAK,EACP,MAAO,CAAC,EAGV,GAAI,GAAK,EAAK,OACZ,MAAO,CAAC,GAAG,CAAI,EAGjB,IAAM,EAAO,EAAK,MAAM,EAAG,CAAC,EAC5B,EAAQ,EAAM,CAAS,EAEvB,IAAM,EAAO,EAAK,MAAM,CAAC,EACzB,IAAK,IAAM,KAAQ,EACjB,EAAgB,EAAM,EAAW,CAAI,EAGvC,OAAO,CACT"}

package/dist/take-last-while.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){for(let n=e.length-1;n>=0;n--)if(!t(e[n],n,e))return e.slice(n+1);return[...e]}exports.takeLastWhile=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){for(let n=e.length-1;n>=0;n--)if(!t(e[n],n,e))return e.slice(n+1);return[...e]}exports.takeLastWhile=t;
 //# sourceMappingURL=take-last-while.cjs.map

package/dist/take-last-while.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"take-last-while.cjs","names":["curry"],"sources":["../src/take-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Returns elements from the end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    takeLastWhile(data, predicate)\n * @example\n *    takeLastWhile([1, 2, 10, 3, 4, 5], x => x < 10) // => [3, 4, 5]\n * @dataFirst\n * @category Array\n */\nexport function takeLastWhile<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 takeLastWhile<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 end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param predicate - The predicate.\n * @signature\n *    takeLastWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4, 5], takeLastWhile(x => x < 10))  // => [3, 4, 5]\n * @dataLast\n * @category Array\n */\nexport function takeLastWhile<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 takeLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => Array<T[number]>;\n\nexport function takeLastWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeLastWhileImplementation, args);\n}\n\nfunction takeLastWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (!predicate(data[i], i, data)) {\n      return data.slice(i + 1);\n    }\n  }\n  return [...data];\n}\n"],"mappings":"kGA4CA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACkB,CAClB,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,CAAC,EAAU,EAAK,GAAI,EAAG,EAAK,CAC9B,OAAO,EAAK,MAAM,EAAI,EAAE,CAG5B,MAAO,CAAC,GAAG,EAAK"}
+{"version":3,"file":"take-last-while.cjs","names":["curry"],"sources":["../src/take-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Returns elements from the end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    takeLastWhile(data, predicate)\n * @example\n *    takeLastWhile([1, 2, 10, 3, 4, 5], x => x < 10) // => [3, 4, 5]\n * @dataFirst\n * @category Array\n */\nexport function takeLastWhile<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 takeLastWhile<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 end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param predicate - The predicate.\n * @signature\n *    takeLastWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4, 5], takeLastWhile(x => x < 10))  // => [3, 4, 5]\n * @dataLast\n * @category Array\n */\nexport function takeLastWhile<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 takeLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => Array<T[number]>;\n\nexport function takeLastWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeLastWhileImplementation, args);\n}\n\nfunction takeLastWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (!predicate(data[i], i, data)) {\n      return data.slice(i + 1);\n    }\n  }\n  return [...data];\n}\n"],"mappings":"kGA4CA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,EAA6B,CAAI,CAChD,CAEA,SAAS,EACP,EACA,EACkB,CAClB,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,CAAC,EAAU,EAAK,GAAI,EAAG,CAAI,EAC7B,OAAO,EAAK,MAAM,EAAI,CAAC,EAG3B,MAAO,CAAC,GAAG,CAAI,CACjB"}

package/dist/take-last-while.js.map

@@ -1 +1 @@
-{"version":3,"file":"take-last-while.js","names":[],"sources":["../src/take-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Returns elements from the end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    takeLastWhile(data, predicate)\n * @example\n *    takeLastWhile([1, 2, 10, 3, 4, 5], x => x < 10) // => [3, 4, 5]\n * @dataFirst\n * @category Array\n */\nexport function takeLastWhile<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 takeLastWhile<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 end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param predicate - The predicate.\n * @signature\n *    takeLastWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4, 5], takeLastWhile(x => x < 10))  // => [3, 4, 5]\n * @dataLast\n * @category Array\n */\nexport function takeLastWhile<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 takeLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => Array<T[number]>;\n\nexport function takeLastWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeLastWhileImplementation, args);\n}\n\nfunction takeLastWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (!predicate(data[i], i, data)) {\n      return data.slice(i + 1);\n    }\n  }\n  return [...data];\n}\n"],"mappings":"mCA4CA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACkB,CAClB,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,CAAC,EAAU,EAAK,GAAI,EAAG,EAAK,CAC9B,OAAO,EAAK,MAAM,EAAI,EAAE,CAG5B,MAAO,CAAC,GAAG,EAAK"}
+{"version":3,"file":"take-last-while.js","names":[],"sources":["../src/take-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Returns elements from the end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    takeLastWhile(data, predicate)\n * @example\n *    takeLastWhile([1, 2, 10, 3, 4, 5], x => x < 10) // => [3, 4, 5]\n * @dataFirst\n * @category Array\n */\nexport function takeLastWhile<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 takeLastWhile<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 end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param predicate - The predicate.\n * @signature\n *    takeLastWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4, 5], takeLastWhile(x => x < 10))  // => [3, 4, 5]\n * @dataLast\n * @category Array\n */\nexport function takeLastWhile<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 takeLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => Array<T[number]>;\n\nexport function takeLastWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeLastWhileImplementation, args);\n}\n\nfunction takeLastWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (!predicate(data[i], i, data)) {\n      return data.slice(i + 1);\n    }\n  }\n  return [...data];\n}\n"],"mappings":"mCA4CA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,CAAI,CAChD,CAEA,SAAS,EACP,EACA,EACkB,CAClB,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,CAAC,EAAU,EAAK,GAAI,EAAG,CAAI,EAC7B,OAAO,EAAK,MAAM,EAAI,CAAC,EAG3B,MAAO,CAAC,GAAG,CAAI,CACjB"}

package/dist/take-last.cjs

@@ -1,2 +1,2 @@
-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>0?e.slice(Math.max(0,e.length-t)):[]}exports.takeLast=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>0?e.slice(Math.max(0,e.length-t)):[]}exports.takeLast=t;
 //# sourceMappingURL=take-last.cjs.map

package/dist/take-last.cjs.map

@@ -1 +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"}
+{"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 * Related operations:\n * - `dropLast` - to skip past the last `n` instead.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `take` - same, but from the start of 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 * Related operations:\n * - `dropLast` - to skip past the last `n` instead.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `take` - same, but from the start of 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":"kGA6CA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EAAoD,EAAU,EAA6B,CAClG,OAAO,EAAI,EAAI,EAAM,MAAM,KAAK,IAAI,EAAG,EAAM,OAAS,CAAC,CAAC,EAAI,CAAC,CAC/D"}

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';\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"}
+{"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 * Related operations:\n * - `dropLast` - to skip past the last `n` instead.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `take` - same, but from the start of 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 * Related operations:\n * - `dropLast` - to skip past the last `n` instead.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `take` - same, but from the start of 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":"mCA6CA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EAAoD,EAAU,EAA6B,CAClG,OAAO,EAAI,EAAI,EAAM,MAAM,KAAK,IAAI,EAAG,EAAM,OAAS,CAAC,CAAC,EAAI,CAAC,CAC/D"}

package/dist/take-while.cjs

@@ -1,2 +1,2 @@
-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;
+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

@@ -1 +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"}
+{"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,CAAI,CAC5C,CAEA,SAAS,EACP,EACA,EACkB,CAClB,IAAM,EAAwB,CAAC,EAC/B,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,QAAQ,EAAG,CAC1C,GAAI,CAAC,EAAU,EAAM,EAAO,CAAI,EAC9B,MAEF,EAAI,KAAK,CAAI,CACf,CACA,OAAO,CACT"}

package/dist/take-while.js.map

@@ -1 +1 @@
-{"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"}
+{"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,CAAI,CAC5C,CAEA,SAAS,EACP,EACA,EACkB,CAClB,IAAM,EAAwB,CAAC,EAC/B,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,QAAQ,EAAG,CAC1C,GAAI,CAAC,EAAU,EAAM,EAAO,CAAI,EAC9B,MAEF,EAAI,KAAK,CAAI,CACf,CACA,OAAO,CACT"}

package/dist/take.cjs

@@ -1,2 +1,2 @@
-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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs"),t=require("./utility-evaluators-BGM19SpK.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

@@ -1 +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"}
+{"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 * Related operations:\n * - `drop` - to skip past the first `n` instead.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `takeLast` - same, but from the end of the 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 * Related operations:\n * - `drop` - to skip past the first `n` instead.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `takeLast` - same, but from the end of the 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":"iJAiDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAM,CAAkB,CAC3D,CAEA,SAAS,EAAgD,EAAU,EAA6B,CAC9F,OAAO,EAAI,EAAI,CAAC,EAAI,EAAM,MAAM,EAAG,CAAC,CACtC,CAEA,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAOC,EAAAA,EAGT,IAAI,EAAY,EAChB,MAAQ,KACN,IACO,CAAE,KAAM,GAAa,EAAG,QAAS,GAAM,KAAM,CAAM,EAE9D"}

package/dist/take.js

@@ -1,2 +1,2 @@
-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};
+import{curry as e}from"./curry.js";import{n as t}from"./utility-evaluators-DDW55xeL.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';\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"}
+{"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 * Related operations:\n * - `drop` - to skip past the first `n` instead.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `takeLast` - same, but from the end of the 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 * Related operations:\n * - `drop` - to skip past the first `n` instead.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `takeLast` - same, but from the end of the 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":"wFAiDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,CAAkB,CAC3D,CAEA,SAAS,EAAgD,EAAU,EAA6B,CAC9F,OAAO,EAAI,EAAI,CAAC,EAAI,EAAM,MAAM,EAAG,CAAC,CACtC,CAEA,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAO,EAGT,IAAI,EAAY,EAChB,MAAQ,KACN,IACO,CAAE,KAAM,GAAa,EAAG,QAAS,GAAM,KAAM,CAAM,EAE9D"}

package/dist/tap.cjs

@@ -1,2 +1,2 @@
-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;
+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

@@ -1 +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"}
+{"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,CAAI,CACtC,CAEA,SAAS,EAAqB,EAAU,EAA2B,CAEjE,OADA,EAAG,CAAK,EACD,CACT"}

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 *    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"}
+{"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,CAAI,CACtC,CAEA,SAAS,EAAqB,EAAU,EAA2B,CAEjE,OADA,EAAG,CAAK,EACD,CACT"}

package/dist/times.cjs

@@ -1,2 +1,2 @@
-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;
+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

@@ -1 +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"}
+{"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,CAAI,CACxC,CAEA,SAAS,EAAuB,EAAe,EAAoC,CACjF,GAAI,EAAQ,EAEV,MAAO,CAAC,EAMV,IAAM,EAAS,OAAO,UAAU,CAAK,EAAI,EAAQ,KAAK,MAAM,CAAK,EAG3D,EAAU,MAAS,CAAM,EAE/B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAI,GAAK,EAAG,CAAC,EAGf,OAAO,CACT"}

package/dist/times.js.map

@@ -1 +1 @@
-{"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"}
+{"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,CAAI,CACxC,CAEA,SAAS,EAAuB,EAAe,EAAoC,CACjF,GAAI,EAAQ,EAEV,MAAO,CAAC,EAMV,IAAM,EAAS,OAAO,UAAU,CAAK,EAAI,EAAQ,KAAK,MAAM,CAAK,EAG3D,EAAU,MAAS,CAAM,EAE/B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAI,GAAK,EAAG,CAAC,EAGf,OAAO,CACT"}

package/dist/to-camel-case.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./words-C8Rd_80F.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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./words-B-9EXtsW.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

@@ -1 +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"}
+{"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,CAAO,EAC/C,GAAiB,EAA0B,EAAM,CAAa,CACrE,CAIA,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,CAAC,EAAW,CAChC,OAAOA,EAAAA,EACL,EAAwB,KAAK,CAAI,EAC7B,EAIA,EAAK,YAAY,CACvB,CAAC,CACE,KACE,EAAM,IACL,GAEE,IAAU,EAAI,EAAK,EAAE,CAAE,YAAY,EAAI,EAAK,EAAE,CAAE,YAAY,IAC3D,EAA+B,EAAK,MAAM,CAAC,EAAI,EAAK,MAAM,CAAC,CAAC,CAAC,YAAY,GAChF,CAAC,CACA,KAAK,EAAE,CACZ"}

package/dist/to-camel-case.js

@@ -1,2 +1,2 @@
-import{t as e}from"./words-CYZ0Lyko.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-CN1Qil5U.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 {\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"}
+{"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,CAAO,EAC/C,GAAiB,EAA0B,EAAM,CAAa,CACrE,CAIA,SAAS,EAA0B,EAAc,CAC/C,+BAA+B,IACX,CAAC,EAAW,CAChC,OAAO,EACL,EAAwB,KAAK,CAAI,EAC7B,EAIA,EAAK,YAAY,CACvB,CAAC,CACE,KACE,EAAM,IACL,GAEE,IAAU,EAAI,EAAK,EAAE,CAAE,YAAY,EAAI,EAAK,EAAE,CAAE,YAAY,IAC3D,EAA+B,EAAK,MAAM,CAAC,EAAI,EAAK,MAAM,CAAC,CAAC,CAAC,YAAY,GAChF,CAAC,CACA,KAAK,EAAE,CACZ"}

package/dist/to-kebab-case.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./words-C8Rd_80F.cjs`);function n(...t){return e.curry(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-B-9EXtsW.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