@depup/remeda 2.33.6-depup.0

package/dist/subtract.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtract.cjs","names":["purry"],"sources":["../src/subtract.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Subtracts two numbers.\n *\n * @param value - The number.\n * @param subtrahend - The number to subtract from the value.\n * @signature\n *    subtract(value, subtrahend);\n * @example\n *    subtract(10, 5) // => 5\n *    subtract(10, -5) // => 15\n *    reduce([1, 2, 3, 4], subtract, 20) // => 10\n * @dataFirst\n * @category Number\n */\nexport function subtract(value: bigint, subtrahend: bigint): bigint;\nexport function subtract(value: number, subtrahend: number): number;\n\n/**\n * Subtracts two numbers.\n *\n * @param subtrahend - The number to subtract from the value.\n * @signature\n *    subtract(subtrahend)(value);\n * @example\n *    subtract(5)(10) // => 5\n *    subtract(-5)(10) // => 15\n *    map([1, 2, 3, 4], subtract(1)) // => [0, 1, 2, 3]\n * @dataLast\n * @category Number\n */\nexport function subtract(subtrahend: bigint): (value: bigint) => bigint;\nexport function subtract(subtrahend: number): (value: number) => number;\n\nexport function subtract(...args: readonly unknown[]): unknown {\n  return purry(subtractImplementation, args);\n}\n\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and subtrahend would be of the same\n// type.\nconst subtractImplementation = (value: number, subtrahend: number): number =>\n  value - subtrahend;\n"],"mappings":"kGAmCA,SAAgB,EAAS,GAAG,EAAmC,CAC7D,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAM5C,MAAM,GAA0B,EAAe,IAC7C,EAAQ"}

package/dist/subtract.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}const n=(e,t)=>e-t;export{t as subtract};
+//# sourceMappingURL=subtract.js.map

package/dist/subtract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtract.js","names":[],"sources":["../src/subtract.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Subtracts two numbers.\n *\n * @param value - The number.\n * @param subtrahend - The number to subtract from the value.\n * @signature\n *    subtract(value, subtrahend);\n * @example\n *    subtract(10, 5) // => 5\n *    subtract(10, -5) // => 15\n *    reduce([1, 2, 3, 4], subtract, 20) // => 10\n * @dataFirst\n * @category Number\n */\nexport function subtract(value: bigint, subtrahend: bigint): bigint;\nexport function subtract(value: number, subtrahend: number): number;\n\n/**\n * Subtracts two numbers.\n *\n * @param subtrahend - The number to subtract from the value.\n * @signature\n *    subtract(subtrahend)(value);\n * @example\n *    subtract(5)(10) // => 5\n *    subtract(-5)(10) // => 15\n *    map([1, 2, 3, 4], subtract(1)) // => [0, 1, 2, 3]\n * @dataLast\n * @category Number\n */\nexport function subtract(subtrahend: bigint): (value: bigint) => bigint;\nexport function subtract(subtrahend: number): (value: number) => number;\n\nexport function subtract(...args: readonly unknown[]): unknown {\n  return purry(subtractImplementation, args);\n}\n\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and subtrahend would be of the same\n// type.\nconst subtractImplementation = (value: number, subtrahend: number): number =>\n  value - subtrahend;\n"],"mappings":"mCAmCA,SAAgB,EAAS,GAAG,EAAmC,CAC7D,OAAO,EAAM,EAAwB,EAAK,CAM5C,MAAM,GAA0B,EAAe,IAC7C,EAAQ"}

package/dist/sum.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}function n(e){let t=typeof e[0]==`bigint`?0n:0;for(let n of e)t+=n;return t}exports.sum=t;
+//# sourceMappingURL=sum.cjs.map

package/dist/sum.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sum.cjs","names":["purry"],"sources":["../src/sum.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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, ...(readonly 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: readonly unknown[]): unknown {\n  return purry(sumImplementation, args);\n}\n\nfunction sumImplementation<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): T[number] {\n  // eslint-disable-next-line @typescript-eslint/no-magic-numbers -- The rule differentiates 0 and 0n :(\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    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    out += value;\n  }\n  return out;\n}\n"],"mappings":"kGAmEA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAOA,EAAAA,MAAM,EAAmB,EAAK,CAGvC,SAAS,EAEP,EAAoB,CAEpB,IAAI,EAAM,OAAO,EAAK,IAAO,SAAW,GAAK,EAC7C,IAAK,IAAM,KAAS,EAGlB,GAAO,EAET,OAAO"}

package/dist/sum.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e){let t=typeof e[0]==`bigint`?0n:0;for(let n of e)t+=n;return t}export{t as sum};
+//# sourceMappingURL=sum.js.map

package/dist/sum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sum.js","names":[],"sources":["../src/sum.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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, ...(readonly 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: readonly unknown[]): unknown {\n  return purry(sumImplementation, args);\n}\n\nfunction sumImplementation<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): T[number] {\n  // eslint-disable-next-line @typescript-eslint/no-magic-numbers -- The rule differentiates 0 and 0n :(\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    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    out += value;\n  }\n  return out;\n}\n"],"mappings":"mCAmEA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EAEP,EAAoB,CAEpB,IAAI,EAAM,OAAO,EAAK,IAAO,SAAW,GAAK,EAC7C,IAAK,IAAM,KAAS,EAGlB,GAAO,EAET,OAAO"}

package/dist/sumBy.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}const n=(e,t)=>{let n=e.entries(),r=n.next();if(`done`in r&&r.done)return 0;let{value:[,i]}=r,a=t(i,0,e);for(let[r,i]of n){let n=t(i,r,e);a+=n}return a};exports.sumBy=t;
+//# sourceMappingURL=sumBy.cjs.map

package/dist/sumBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sumBy.cjs","names":["purry"],"sources":["../src/sumBy.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\n\ntype SumBy<\n  T extends IterableContainer,\n  U extends bigint | number,\n> = T extends readonly []\n  ? 0\n  : T extends readonly [unknown, ...(readonly unknown[])]\n    ? U\n    : U | 0;\n\n/**\n * Returns the sum of the elements of an array using the provided mapper.\n *\n * Works for both `number` and `bigint` mappers, but not mappers that return both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of\n * the type of the mapper; 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 callbackfn - Predicate function.\n * @signature\n *   sumBy(fn)(array)\n * @example\n *    pipe(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      sumBy(x => x.a)\n *    ) // 9\n *\n *    pipe(\n *      [{a: 5n}, {a: 1n}, {a: 3n}],\n *      sumBy(x => x.a)\n *    ) // 9n\n * @dataLast\n * @category Array\n */\nexport function sumBy<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => number,\n): (items: T) => SumBy<T, number>;\nexport function sumBy<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => bigint,\n): (items: T) => SumBy<T, bigint>;\n\n/**\n * Returns the sum of the elements of an array using the provided mapper.\n *\n * Works for both `number` and `bigint` mappers, but not mappers that can return both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of\n * the type of the mapper; 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.\n * @param callbackfn - Predicate function.\n * @signature\n *   sumBy(array, fn)\n * @example\n *    sumBy(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      x => x.a\n *    ) // 9\n *    sumBy(\n *      [{a: 5n}, {a: 1n}, {a: 3n}],\n *      x => x.a\n *    ) // 9n\n * @dataFirst\n * @category Array\n */\nexport function sumBy<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => number,\n): SumBy<T, number>;\nexport function sumBy<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => bigint,\n): SumBy<T, bigint>;\n\nexport function sumBy(...args: readonly unknown[]): unknown {\n  return purry(sumByImplementation, args);\n}\n\nconst sumByImplementation = <T>(\n  array: readonly T[],\n  callbackfn: (value: T, index: number, data: readonly T[]) => bigint | number,\n): bigint | number => {\n  const iter = array.entries();\n\n  const firstEntry = iter.next();\n  if (\"done\" in firstEntry && firstEntry.done) {\n    return 0;\n  }\n\n  const {\n    value: [, firstValue],\n  } = firstEntry;\n  let sum = callbackfn(firstValue, 0, array);\n  for (const [index, item] of iter) {\n    const summand = callbackfn(item, index, array);\n\n    // @ts-expect-error [ts2365] -- Typescript can't infer that all elements will be a number of the same type.\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    sum += summand;\n  }\n  return sum;\n};\n"],"mappings":"kGAkFA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,MAAM,GACJ,EACA,IACoB,CACpB,IAAM,EAAO,EAAM,SAAS,CAEtB,EAAa,EAAK,MAAM,CAC9B,GAAI,SAAU,GAAc,EAAW,KACrC,MAAO,GAGT,GAAM,CACJ,MAAO,EAAG,IACR,EACA,EAAM,EAAW,EAAY,EAAG,EAAM,CAC1C,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,CAChC,IAAM,EAAU,EAAW,EAAM,EAAO,EAAM,CAI9C,GAAO,EAET,OAAO"}

package/dist/sumBy.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}const n=(e,t)=>{let n=e.entries(),r=n.next();if(`done`in r&&r.done)return 0;let{value:[,i]}=r,a=t(i,0,e);for(let[r,i]of n){let n=t(i,r,e);a+=n}return a};export{t as sumBy};
+//# sourceMappingURL=sumBy.js.map

package/dist/sumBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sumBy.js","names":[],"sources":["../src/sumBy.ts"],"sourcesContent":["import { purry } from \"./purry\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\n\ntype SumBy<\n  T extends IterableContainer,\n  U extends bigint | number,\n> = T extends readonly []\n  ? 0\n  : T extends readonly [unknown, ...(readonly unknown[])]\n    ? U\n    : U | 0;\n\n/**\n * Returns the sum of the elements of an array using the provided mapper.\n *\n * Works for both `number` and `bigint` mappers, but not mappers that return both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of\n * the type of the mapper; 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 callbackfn - Predicate function.\n * @signature\n *   sumBy(fn)(array)\n * @example\n *    pipe(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      sumBy(x => x.a)\n *    ) // 9\n *\n *    pipe(\n *      [{a: 5n}, {a: 1n}, {a: 3n}],\n *      sumBy(x => x.a)\n *    ) // 9n\n * @dataLast\n * @category Array\n */\nexport function sumBy<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => number,\n): (items: T) => SumBy<T, number>;\nexport function sumBy<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => bigint,\n): (items: T) => SumBy<T, bigint>;\n\n/**\n * Returns the sum of the elements of an array using the provided mapper.\n *\n * Works for both `number` and `bigint` mappers, but not mappers that can return both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of\n * the type of the mapper; 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.\n * @param callbackfn - Predicate function.\n * @signature\n *   sumBy(array, fn)\n * @example\n *    sumBy(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      x => x.a\n *    ) // 9\n *    sumBy(\n *      [{a: 5n}, {a: 1n}, {a: 3n}],\n *      x => x.a\n *    ) // 9n\n * @dataFirst\n * @category Array\n */\nexport function sumBy<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => number,\n): SumBy<T, number>;\nexport function sumBy<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => bigint,\n): SumBy<T, bigint>;\n\nexport function sumBy(...args: readonly unknown[]): unknown {\n  return purry(sumByImplementation, args);\n}\n\nconst sumByImplementation = <T>(\n  array: readonly T[],\n  callbackfn: (value: T, index: number, data: readonly T[]) => bigint | number,\n): bigint | number => {\n  const iter = array.entries();\n\n  const firstEntry = iter.next();\n  if (\"done\" in firstEntry && firstEntry.done) {\n    return 0;\n  }\n\n  const {\n    value: [, firstValue],\n  } = firstEntry;\n  let sum = callbackfn(firstValue, 0, array);\n  for (const [index, item] of iter) {\n    const summand = callbackfn(item, index, array);\n\n    // @ts-expect-error [ts2365] -- Typescript can't infer that all elements will be a number of the same type.\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    sum += summand;\n  }\n  return sum;\n};\n"],"mappings":"mCAkFA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAO,EAAM,EAAqB,EAAK,CAGzC,MAAM,GACJ,EACA,IACoB,CACpB,IAAM,EAAO,EAAM,SAAS,CAEtB,EAAa,EAAK,MAAM,CAC9B,GAAI,SAAU,GAAc,EAAW,KACrC,MAAO,GAGT,GAAM,CACJ,MAAO,EAAG,IACR,EACA,EAAM,EAAW,EAAY,EAAG,EAAM,CAC1C,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,CAChC,IAAM,EAAU,EAAW,EAAM,EAAO,EAAM,CAI9C,GAAO,EAET,OAAO"}

package/dist/swapInPlace-BrVgf3c3.js

@@ -0,0 +1,2 @@
+function e(e,t,n){[e[t],e[n]]=[e[n],e[t]]}export{e as t};
+//# sourceMappingURL=swapInPlace-BrVgf3c3.js.map

package/dist/swapInPlace-BrVgf3c3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapInPlace-BrVgf3c3.js","names":[],"sources":["../src/internal/swapInPlace.ts"],"sourcesContent":["/**\n * An efficient hack to swap the values at two indices in an array *in-place*.\n */\nexport function swapInPlace(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional\n  data: 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,EAEd,EACA,EACA,EACM,CAGN,CAAC,EAAK,GAAI,EAAK,IAAM,CAAC,EAAK,GAAI,EAAK,GAAG"}

package/dist/swapInPlace-IOnMIay9.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=swapInPlace-IOnMIay9.cjs.map

package/dist/swapInPlace-IOnMIay9.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapInPlace-IOnMIay9.cjs","names":[],"sources":["../src/internal/swapInPlace.ts"],"sourcesContent":["/**\n * An efficient hack to swap the values at two indices in an array *in-place*.\n */\nexport function swapInPlace(\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentional\n  data: 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,EAEd,EACA,EACA,EACM,CAGN,CAAC,EAAK,GAAI,EAAK,IAAM,CAAC,EAAK,GAAI,EAAK,GAAG"}

package/dist/swapIndices.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}const n=(e,t,n)=>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=swapIndices.cjs.map

package/dist/swapIndices.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapIndices.cjs","names":["purry"],"sources":["../src/swapIndices.ts"],"sourcesContent":["import type { And, IsEqual, Join } from \"type-fest\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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  ? 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 readonly 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    : // 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      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: readonly unknown[]): unknown {\n  return purry(swapIndicesImplementation, args);\n}\n\nconst swapIndicesImplementation = (\n  data: IterableContainer | string,\n  index1: number,\n  index2: number,\n): unknown =>\n  typeof data === \"string\"\n    ? // eslint-disable-next-line @typescript-eslint/no-misused-spread -- TODO: I'm not sure what the right way to split the string here, there are multiple \"correct\" answers and each one is meaningfully different: https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2521\n      swapArray([...data], index1, index2).join(\"\")\n    : swapArray(data, index1, index2);\n\nfunction swapArray(\n  data: readonly unknown[],\n  index1: number,\n  index2: number,\n): 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,EAAmC,CAChE,OAAOA,EAAAA,MAAM,EAA2B,EAAK,CAG/C,MAAM,GACJ,EACA,EACA,IAEA,OAAO,GAAS,SAEZ,EAAU,CAAC,GAAG,EAAK,CAAE,EAAQ,EAAO,CAAC,KAAK,GAAG,CAC7C,EAAU,EAAM,EAAQ,EAAO,CAErC,SAAS,EACP,EACA,EACA,EACW,CACX,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"}

package/dist/swapIndices.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}const n=(e,t,n)=>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)}export{t as swapIndices};
+//# sourceMappingURL=swapIndices.js.map

package/dist/swapIndices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapIndices.js","names":[],"sources":["../src/swapIndices.ts"],"sourcesContent":["import type { And, IsEqual, Join } from \"type-fest\";\nimport type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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  ? 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 readonly 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    : // 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      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: readonly unknown[]): unknown {\n  return purry(swapIndicesImplementation, args);\n}\n\nconst swapIndicesImplementation = (\n  data: IterableContainer | string,\n  index1: number,\n  index2: number,\n): unknown =>\n  typeof data === \"string\"\n    ? // eslint-disable-next-line @typescript-eslint/no-misused-spread -- TODO: I'm not sure what the right way to split the string here, there are multiple \"correct\" answers and each one is meaningfully different: https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2521\n      swapArray([...data], index1, index2).join(\"\")\n    : swapArray(data, index1, index2);\n\nfunction swapArray(\n  data: readonly unknown[],\n  index1: number,\n  index2: number,\n): 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,EAAmC,CAChE,OAAO,EAAM,EAA2B,EAAK,CAG/C,MAAM,GACJ,EACA,EACA,IAEA,OAAO,GAAS,SAEZ,EAAU,CAAC,GAAG,EAAK,CAAE,EAAQ,EAAO,CAAC,KAAK,GAAG,CAC7C,EAAU,EAAM,EAAQ,EAAO,CAErC,SAAS,EACP,EACA,EACA,EACW,CACX,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"}

package/dist/swapProps.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}function n(e,t,n){let{[t]:r,[n]:i}=e;return{...e,[t]:i,[n]:r}}exports.swapProps=t;
+//# sourceMappingURL=swapProps.cjs.map

package/dist/swapProps.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapProps.cjs","names":["purry"],"sources":["../src/swapProps.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(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,EAAmC,CAC9D,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"}

package/dist/swapProps.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e,t,n){let{[t]:r,[n]:i}=e;return{...e,[t]:i,[n]:r}}export{t as swapProps};
+//# sourceMappingURL=swapProps.js.map

package/dist/swapProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swapProps.js","names":[],"sources":["../src/swapProps.ts"],"sourcesContent":["import { purry } from \"./purry\";\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: readonly unknown[]): unknown {\n  return purry(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,EAAmC,CAC9D,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"}

package/dist/take.cjs

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

package/dist/take.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.cjs","names":["purry","lazyEmptyEvaluator"],"sources":["../src/take.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { LazyEvaluator } from \"./internal/types/LazyEvaluator\";\nimport { lazyEmptyEvaluator } from \"./internal/utilityEvaluators\";\nimport { purry } from \"./purry\";\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): 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) => T[number][];\n\nexport function take(...args: readonly unknown[]): unknown {\n  return purry(takeImplementation, args, lazyImplementation);\n}\n\nconst takeImplementation = <T extends IterableContainer>(\n  array: T,\n  n: number,\n): T[number][] => (n < 0 ? [] : array.slice(0, 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":"gJAuCA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAOA,EAAAA,MAAM,EAAoB,EAAM,EAAmB,CAG5D,MAAM,GACJ,EACA,IACiB,EAAI,EAAI,EAAE,CAAG,EAAM,MAAM,EAAG,EAAE,CAEjD,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAOC,EAAAA,EAGT,IAAI,EAAY,EAChB,MAAQ,KACN,IACO,CAAE,KAAM,GAAa,EAAG,QAAS,GAAM,KAAM,EAAO"}

package/dist/take.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";import{n as t}from"./utilityEvaluators-BQqW5Ir5.js";function n(...t){return e(r,t,i)}const r=(e,t)=>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

@@ -0,0 +1 @@
+{"version":3,"file":"take.js","names":[],"sources":["../src/take.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { LazyEvaluator } from \"./internal/types/LazyEvaluator\";\nimport { lazyEmptyEvaluator } from \"./internal/utilityEvaluators\";\nimport { purry } from \"./purry\";\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): 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) => T[number][];\n\nexport function take(...args: readonly unknown[]): unknown {\n  return purry(takeImplementation, args, lazyImplementation);\n}\n\nconst takeImplementation = <T extends IterableContainer>(\n  array: T,\n  n: number,\n): T[number][] => (n < 0 ? [] : array.slice(0, 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":"uFAuCA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAO,EAAM,EAAoB,EAAM,EAAmB,CAG5D,MAAM,GACJ,EACA,IACiB,EAAI,EAAI,EAAE,CAAG,EAAM,MAAM,EAAG,EAAE,CAEjD,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAO,EAGT,IAAI,EAAY,EAChB,MAAQ,KACN,IACO,CAAE,KAAM,GAAa,EAAG,QAAS,GAAM,KAAM,EAAO"}

package/dist/takeFirstBy.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./heap-14xVkDB1.cjs`),t=require(`./purryOrderRules-B8pzD03D.cjs`);function n(...e){return t.n(r,e)}function r(t,n,r){if(r<=0)return[];if(r>=t.length)return[...t];let i=t.slice(0,r);e.n(i,n);let a=t.slice(r);for(let t of a)e.t(i,n,t);return i}exports.takeFirstBy=n;
+//# sourceMappingURL=takeFirstBy.cjs.map

package/dist/takeFirstBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeFirstBy.cjs","names":["purryOrderRulesWithArgument"],"sources":["../src/takeFirstBy.ts"],"sourcesContent":["import { heapify, heapMaybeInsert } from \"./internal/heap\";\nimport {\n  purryOrderRulesWithArgument,\n  type OrderRule,\n} from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\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); // => ['a', 'aa']\n * @dataFirst\n * @category Array\n */\nexport function takeFirstBy<T>(\n  data: readonly T[],\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): 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)); // => ['a', 'aa']\n * @dataLast\n * @category Array\n */\nexport function takeFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: readonly T[]) => T[];\n\nexport function takeFirstBy(...args: readonly unknown[]): unknown {\n  return purryOrderRulesWithArgument(takeFirstByImplementation, args);\n}\n\nfunction takeFirstByImplementation<T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n  n: number,\n): 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":"sJAkDA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAOA,EAAAA,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACK,CACL,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"}

package/dist/takeFirstBy.js

@@ -0,0 +1,2 @@
+import{n as e,t}from"./heap-OOe_F8_z.js";import{n}from"./purryOrderRules-4JgY6z4X.js";function r(...e){return n(i,e)}function i(n,r,i){if(i<=0)return[];if(i>=n.length)return[...n];let a=n.slice(0,i);e(a,r);let o=n.slice(i);for(let e of o)t(a,r,e);return a}export{r as takeFirstBy};
+//# sourceMappingURL=takeFirstBy.js.map

package/dist/takeFirstBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeFirstBy.js","names":[],"sources":["../src/takeFirstBy.ts"],"sourcesContent":["import { heapify, heapMaybeInsert } from \"./internal/heap\";\nimport {\n  purryOrderRulesWithArgument,\n  type OrderRule,\n} from \"./internal/purryOrderRules\";\nimport type { CompareFunction } from \"./internal/types/CompareFunction\";\nimport type { NonEmptyArray } from \"./internal/types/NonEmptyArray\";\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); // => ['a', 'aa']\n * @dataFirst\n * @category Array\n */\nexport function takeFirstBy<T>(\n  data: readonly T[],\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): 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)); // => ['a', 'aa']\n * @dataLast\n * @category Array\n */\nexport function takeFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: readonly T[]) => T[];\n\nexport function takeFirstBy(...args: readonly unknown[]): unknown {\n  return purryOrderRulesWithArgument(takeFirstByImplementation, args);\n}\n\nfunction takeFirstByImplementation<T>(\n  data: readonly T[],\n  compareFn: CompareFunction<T>,\n  n: number,\n): 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":"sFAkDA,SAAgB,EAAY,GAAG,EAAmC,CAChE,OAAO,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACK,CACL,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"}

package/dist/takeLast.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}const n=(e,t)=>t>0?e.slice(Math.max(0,e.length-t)):[];exports.takeLast=t;
+//# sourceMappingURL=takeLast.cjs.map

package/dist/takeLast.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeLast.cjs","names":["purry"],"sources":["../src/takeLast.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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): 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) => T[number][];\n\nexport function takeLast(...args: readonly unknown[]): unknown {\n  return purry(takeLastImplementation, args);\n}\n\nconst takeLastImplementation = <T extends IterableContainer>(\n  array: T,\n  n: number,\n): T[number][] => (n > 0 ? array.slice(Math.max(0, array.length - n)) : []);\n"],"mappings":"kGAmCA,SAAgB,EAAS,GAAG,EAAmC,CAC7D,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAG5C,MAAM,GACJ,EACA,IACiB,EAAI,EAAI,EAAM,MAAM,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,EAAE"}

package/dist/takeLast.js

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

package/dist/takeLast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeLast.js","names":[],"sources":["../src/takeLast.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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): 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) => T[number][];\n\nexport function takeLast(...args: readonly unknown[]): unknown {\n  return purry(takeLastImplementation, args);\n}\n\nconst takeLastImplementation = <T extends IterableContainer>(\n  array: T,\n  n: number,\n): T[number][] => (n > 0 ? array.slice(Math.max(0, array.length - n)) : []);\n"],"mappings":"mCAmCA,SAAgB,EAAS,GAAG,EAAmC,CAC7D,OAAO,EAAM,EAAwB,EAAK,CAG5C,MAAM,GACJ,EACA,IACiB,EAAI,EAAI,EAAM,MAAM,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,EAAE"}

package/dist/takeLastWhile.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(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=takeLastWhile.cjs.map

package/dist/takeLastWhile.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeLastWhile.cjs","names":["purry"],"sources":["../src/takeLastWhile.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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): S[];\nexport function takeLastWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): 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) => S[];\nexport function takeLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => T[number][];\n\nexport function takeLastWhile(...args: readonly unknown[]): unknown {\n  return purry(takeLastWhileImplementation, args);\n}\n\nfunction takeLastWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): 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,EAAmC,CAClE,OAAOA,EAAAA,MAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACa,CACb,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"}

package/dist/takeLastWhile.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(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]}export{t as takeLastWhile};
+//# sourceMappingURL=takeLastWhile.js.map

package/dist/takeLastWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeLastWhile.js","names":[],"sources":["../src/takeLastWhile.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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): S[];\nexport function takeLastWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): 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) => S[];\nexport function takeLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => T[number][];\n\nexport function takeLastWhile(...args: readonly unknown[]): unknown {\n  return purry(takeLastWhileImplementation, args);\n}\n\nfunction takeLastWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): 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,EAAmC,CAClE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACa,CACb,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"}

package/dist/takeWhile.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(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=takeWhile.cjs.map

package/dist/takeWhile.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeWhile.cjs","names":["purry"],"sources":["../src/takeWhile.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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): S[];\nexport function takeWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): 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) => S[];\nexport function takeWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (array: T) => T[number][];\n\nexport function takeWhile(...args: readonly unknown[]): unknown {\n  return purry(takeWhileImplementation, args);\n}\n\nfunction takeWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): T[number][] {\n  const ret: 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,EAAmC,CAC9D,OAAOA,EAAAA,MAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACa,CACb,IAAM,EAAmB,EAAE,CAC3B,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,GAAI,CAAC,EAAU,EAAM,EAAO,EAAK,CAC/B,MAEF,EAAI,KAAK,EAAK,CAEhB,OAAO"}

package/dist/takeWhile.js

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

package/dist/takeWhile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeWhile.js","names":[],"sources":["../src/takeWhile.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\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): S[];\nexport function takeWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): 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) => S[];\nexport function takeWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (array: T) => T[number][];\n\nexport function takeWhile(...args: readonly unknown[]): unknown {\n  return purry(takeWhileImplementation, args);\n}\n\nfunction takeWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): T[number][] {\n  const ret: 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,EAAmC,CAC9D,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACa,CACb,IAAM,EAAmB,EAAE,CAC3B,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,GAAI,CAAC,EAAU,EAAM,EAAO,EAAK,CAC/B,MAEF,EAAI,KAAK,EAAK,CAEhB,OAAO"}

package/dist/tap.cjs

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

package/dist/tap.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.cjs","names":["purry"],"sources":["../src/tap.ts"],"sourcesContent":["import { purry } from \"./purry\";\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  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- TODO: This is solvable by inlining F and wrapping the T parameter with `NoInfer` (e.g. `(value: NoInfer<T>) => unknown`); to prevent typescript from inferring it as `unknown`. This is only available in TS 5.4, which is above what we currently support (5.1).\n  F extends (value: T) => unknown,\n>(fn: F): (value: T) => T;\n\nexport function tap(...args: readonly unknown[]): unknown {\n  return purry(tapImplementation, args);\n}\n\nfunction tapImplementation<T>(value: T, fn: (value: T) => void): T {\n  fn(value);\n  return value;\n}\n"],"mappings":"kGA8CA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAOA,EAAAA,MAAM,EAAmB,EAAK,CAGvC,SAAS,EAAqB,EAAU,EAA2B,CAEjE,OADA,EAAG,EAAM,CACF"}

package/dist/tap.js

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

package/dist/tap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.js","names":[],"sources":["../src/tap.ts"],"sourcesContent":["import { purry } from \"./purry\";\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  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- TODO: This is solvable by inlining F and wrapping the T parameter with `NoInfer` (e.g. `(value: NoInfer<T>) => unknown`); to prevent typescript from inferring it as `unknown`. This is only available in TS 5.4, which is above what we currently support (5.1).\n  F extends (value: T) => unknown,\n>(fn: F): (value: T) => T;\n\nexport function tap(...args: readonly unknown[]): unknown {\n  return purry(tapImplementation, args);\n}\n\nfunction tapImplementation<T>(value: T, fn: (value: T) => void): T {\n  fn(value);\n  return value;\n}\n"],"mappings":"mCA8CA,SAAgB,EAAI,GAAG,EAAmC,CACxD,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EAAqB,EAAU,EAA2B,CAEjE,OADA,EAAG,EAAM,CACF"}

package/dist/times.cjs

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

package/dist/times.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"times.cjs","names":["purry"],"sources":["../src/times.ts"],"sourcesContent":["import type { GreaterThan } from \"type-fest\";\nimport { purry } from \"./purry\";\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 readonly unknown[] = [],\n> = number extends N\n  ? // N is not a literal number, we can't deduce the type\n    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>, ...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: readonly unknown[]): unknown {\n  return purry(timesImplementation, args);\n}\n\nfunction timesImplementation<T>(count: number, fn: (index: number) => T): 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,EAAmC,CAC1D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,SAAS,EAAuB,EAAe,EAA+B,CAC5E,GAAI,EAAQ,EAEV,MAAO,EAAE,CAMX,IAAM,EAAS,OAAO,UAAU,EAAM,CAAG,EAAQ,KAAK,MAAM,EAAM,CAG5D,EAAU,MAAS,EAAO,CAEhC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAI,GAAK,EAAG,EAAE,CAGhB,OAAO"}

package/dist/times.js

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

package/dist/times.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"times.js","names":[],"sources":["../src/times.ts"],"sourcesContent":["import type { GreaterThan } from \"type-fest\";\nimport { purry } from \"./purry\";\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 readonly unknown[] = [],\n> = number extends N\n  ? // N is not a literal number, we can't deduce the type\n    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>, ...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: readonly unknown[]): unknown {\n  return purry(timesImplementation, args);\n}\n\nfunction timesImplementation<T>(count: number, fn: (index: number) => T): 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,EAAmC,CAC1D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EAAuB,EAAe,EAA+B,CAC5E,GAAI,EAAQ,EAEV,MAAO,EAAE,CAMX,IAAM,EAAS,OAAO,UAAU,EAAM,CAAG,EAAQ,KAAK,MAAM,EAAM,CAG5D,EAAU,MAAS,EAAO,CAEhC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAI,GAAK,EAAG,EAAE,CAGhB,OAAO"}

package/dist/toCamelCase.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./words-CDCUnuNz.cjs`),t=/[a-z]/u;function n(e,t){return typeof e==`string`?r(e,t):t=>r(t,e)}const r=(n,{preserveConsecutiveUppercase:r=!0}={})=>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=toCamelCase.cjs.map

package/dist/toCamelCase.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelCase.cjs","names":["words"],"sources":["../src/toCamelCase.ts"],"sourcesContent":["import type {\n  CamelCase,\n  CamelCaseOptions as BaseCamelCaseOptions,\n} from \"type-fest\";\nimport type { OptionalOptionsWithDefaults } from \"./internal/types/OptionalOptionsWithDefaults\";\nimport { words } from \"./internal/words\";\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ntype 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\nconst toCamelCaseImplementation = (\n  data: string,\n  {\n    preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n  }: CamelCaseOptions = {},\n): string =>\n  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"],"mappings":"2GAOM,EAA0B,SAiGhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAKtE,MAAM,GACJ,EACA,CACE,+BAA+B,IACX,EAAE,GAExBA,EAAAA,EACE,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,KACE,EAAM,IACL,GAEE,IAAU,EAAI,EAAK,GAAI,aAAa,CAAG,EAAK,GAAI,aAAa,GAC5D,EAA+B,EAAK,MAAM,EAAE,CAAG,EAAK,MAAM,EAAE,CAAC,aAAa,GAChF,CACA,KAAK,GAAG"}

package/dist/toCamelCase.js

@@ -0,0 +1,2 @@
+import{t as e}from"./words-Dv8LmnKC.js";const t=/[a-z]/u;function n(e,t){return typeof e==`string`?r(e,t):t=>r(t,e)}const r=(n,{preserveConsecutiveUppercase:r=!0}={})=>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=toCamelCase.js.map

package/dist/toCamelCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelCase.js","names":[],"sources":["../src/toCamelCase.ts"],"sourcesContent":["import type {\n  CamelCase,\n  CamelCaseOptions as BaseCamelCaseOptions,\n} from \"type-fest\";\nimport type { OptionalOptionsWithDefaults } from \"./internal/types/OptionalOptionsWithDefaults\";\nimport { words } from \"./internal/words\";\n\nconst LOWER_CASE_CHARACTER_RE = /[a-z]/u;\n\nconst DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE = true;\n\ntype 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\nconst toCamelCaseImplementation = (\n  data: string,\n  {\n    preserveConsecutiveUppercase = DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE,\n  }: CamelCaseOptions = {},\n): string =>\n  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"],"mappings":"wCAOA,MAAM,EAA0B,SAiGhC,SAAgB,EACd,EACA,EACS,CACT,OAAO,OAAO,GAAkB,SAC5B,EAA0B,EAAe,EAAQ,CAChD,GAAiB,EAA0B,EAAM,EAAc,CAKtE,MAAM,GACJ,EACA,CACE,+BAA+B,IACX,EAAE,GAExB,EACE,EAAwB,KAAK,EAAK,CAC9B,EAIA,EAAK,aAAa,CACvB,CACE,KACE,EAAM,IACL,GAEE,IAAU,EAAI,EAAK,GAAI,aAAa,CAAG,EAAK,GAAI,aAAa,GAC5D,EAA+B,EAAK,MAAM,EAAE,CAAG,EAAK,MAAM,EAAE,CAAC,aAAa,GAChF,CACA,KAAK,GAAG"}

package/dist/toKebabCase.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./words-CDCUnuNz.cjs`);function n(...t){return e.purry(r,t)}const r=e=>t.t(e).join(`-`).toLowerCase();exports.toKebabCase=n;
+//# sourceMappingURL=toKebabCase.cjs.map

package/dist/toKebabCase.cjs.map

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

package/dist/toKebabCase.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";import{t}from"./words-Dv8LmnKC.js";function n(...t){return e(r,t)}const r=e=>t(e).join(`-`).toLowerCase();export{n as toKebabCase};
+//# sourceMappingURL=toKebabCase.js.map

package/dist/toKebabCase.js.map

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

package/dist/toLowerCase.cjs

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

package/dist/toLowerCase.cjs.map

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

package/dist/toLowerCase.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}const n=e=>e.toLowerCase();export{t as toLowerCase};
+//# sourceMappingURL=toLowerCase.js.map

package/dist/toLowerCase.js.map

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

package/dist/toSingle-qs9PC5sP.js

@@ -0,0 +1,2 @@
+const e=e=>Object.assign(e,{single:!0});export{e as t};
+//# sourceMappingURL=toSingle-qs9PC5sP.js.map

package/dist/toSingle-qs9PC5sP.js.map

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

package/dist/toSingle-z9yHVHGr.cjs

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

package/dist/toSingle-z9yHVHGr.cjs.map

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

package/dist/toSnakeCase.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./words-CDCUnuNz.cjs`);function n(...t){return e.purry(r,t)}const r=e=>t.t(e).join(`_`).toLowerCase();exports.toSnakeCase=n;
+//# sourceMappingURL=toSnakeCase.cjs.map

package/dist/toSnakeCase.cjs.map

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

package/dist/toSnakeCase.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";import{t}from"./words-Dv8LmnKC.js";function n(...t){return e(r,t)}const r=e=>t(e).join(`_`).toLowerCase();export{n as toSnakeCase};
+//# sourceMappingURL=toSnakeCase.js.map

package/dist/toSnakeCase.js.map

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

package/dist/toTitleCase.cjs

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