@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/subtract-gGSDVCQa.d.cts

@@ -1,35 +0,0 @@
-//#region src/subtract.d.ts
-/**
- * Subtracts two numbers.
- *
- * @param value - The number.
- * @param subtrahend - The number to subtract from the value.
- * @signature
- *    P.subtract(value, subtrahend);
- * @example
- *    P.subtract(10, 5) // => 5
- *    P.subtract(10, -5) // => 15
- *    P.reduce([1, 2, 3, 4], P.subtract, 20) // => 10
- * @dataFirst
- * @category Number
- */
-declare function subtract(value: bigint, subtrahend: bigint): bigint;
-declare function subtract(value: number, subtrahend: number): number;
-/**
- * Subtracts two numbers.
- *
- * @param subtrahend - The number to subtract from the value.
- * @signature
- *    P.subtract(subtrahend)(value);
- * @example
- *    P.subtract(5)(10) // => 5
- *    P.subtract(-5)(10) // => 15
- *    P.map([1, 2, 3, 4], P.subtract(1)) // => [0, 1, 2, 3]
- * @dataLast
- * @category Number
- */
-declare function subtract(subtrahend: bigint): (value: bigint) => bigint;
-declare function subtract(subtrahend: number): (value: number) => number;
-//#endregion
-export { subtract };
-//# sourceMappingURL=subtract-gGSDVCQa.d.cts.map

package/dist/subtract-gGSDVCQa.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"subtract-gGSDVCQa.d.cts","names":[],"sources":["../src/subtract.ts"],"sourcesContent":[],"mappings":";;AAgBA;AACA;AAeA;AACA;;;;;;;;;;iBAjBgB,QAAA;iBACA,QAAA;;;;;;;;;;;;;;iBAeA,QAAA;iBACA,QAAA"}

package/dist/subtract-y93SO1gw.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e-t}Object.defineProperty(exports,`subtract`,{enumerable:!0,get:function(){return t}});

package/dist/sum-B69a1sb5.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e){let t=typeof e[0]==`bigint`?0n:0;for(let n of e)t+=n;return t}Object.defineProperty(exports,`sum`,{enumerable:!0,get:function(){return t}});

package/dist/sum-BHYsbVr5.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.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-BHYsbVr5.js.map

package/dist/sum-BHYsbVr5.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sum-BHYsbVr5.js","names":[],"sources":["../src/sum.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\n\nimport { curry } from './curry';\n\ntype Sum<T extends IterableContainer<bigint> | IterableContainer<number>>\n  // Empty arrays would always result in a product of (a non-bigint) 1\n  = T extends readonly []\n    ? 0\n    // Non-empty bigint arrays will always result in a bigint sum.\n    : T extends readonly [bigint, ...ReadonlyArray<unknown>]\n      ? bigint\n      // But an empty bigint array would result in a non-bigint 0.\n      : T[number] extends bigint\n        ? 0 | bigint\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 *   P.sum(data);\n * @example\n *   P.sum([1, 2, 3]); // => 6\n *   P.sum([1n, 2n, 3n]); // => 6n\n *   P.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 *   P.sum()(data);\n * @example\n *   P.pipe([1, 2, 3], P.sum()); // => 6\n *   P.pipe([1n, 2n, 3n], R.sum()); // => 6n\n *   P.pipe([], P.sum()); // => 0\n * @dataLast\n * @category Number\n */\nexport function sum(): <\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(\n  data: T,\n) => Sum<T>;\n\nexport function sum(...args: ReadonlyArray<unknown>): unknown {\n  return curry(sumImplementation, args);\n}\n\nfunction sumImplementation<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): T[number] {\n  let out = typeof data[0] === 'bigint' ? 0n : 0;\n  for (const value of data) {\n    // @ts-expect-error [ts2365] -- Typescript can't infer that all elements will be a number of the same type.\n\n    out += value;\n  }\n  return out;\n}\n"],"mappings":"4CAoEA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAK,CAGvC,SAAS,EAEP,EAAoB,CACpB,IAAI,EAAM,OAAO,EAAK,IAAO,SAAW,GAAK,EAC7C,IAAK,IAAM,KAAS,EAGlB,GAAO,EAET,OAAO"}

package/dist/sum-CEgbjhbj.d.ts

@@ -1,50 +0,0 @@
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-
-//#region src/sum.d.ts
-type Sum<T extends IterableContainer<bigint> | IterableContainer<number>> = T extends readonly [] ? 0 : T extends readonly [bigint, ...ReadonlyArray<unknown>] ? bigint : T[number] extends bigint ? 0 | bigint : number;
-/**
- * Sums the numbers in the array, or return 0 for an empty array.
- *
- * Works for both `number` and `bigint` arrays, but not arrays that contain both
- * types.
- *
- * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
- * the type of the array; to avoid adding this to the return type for cases
- * where the array is known to be non-empty you can use `hasAtLeast` or
- * `isEmpty` to guard against this case.
- *
- * @param data - The array of numbers.
- * @signature
- *   P.sum(data);
- * @example
- *   P.sum([1, 2, 3]); // => 6
- *   P.sum([1n, 2n, 3n]); // => 6n
- *   P.sum([]); // => 0
- * @dataFirst
- * @category Number
- */
-declare function sum<T extends IterableContainer<bigint> | IterableContainer<number>>(data: T): Sum<T>;
-/**
- * Sums the numbers in the array, or return 0 for an empty array.
- *
- * Works for both `number` and `bigint` arrays, but not arrays that contain both
- * types.
- *
- * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
- * the type of the array; to avoid adding this to the return type for cases
- * where the array is known to be non-empty you can use `hasAtLeast` or
- * `isEmpty`to guard against this case.
- *
- * @signature
- *   P.sum()(data);
- * @example
- *   P.pipe([1, 2, 3], P.sum()); // => 6
- *   P.pipe([1n, 2n, 3n], R.sum()); // => 6n
- *   P.pipe([], P.sum()); // => 0
- * @dataLast
- * @category Number
- */
-declare function sum(): <T extends IterableContainer<bigint> | IterableContainer<number>>(data: T) => Sum<T>;
-//#endregion
-export { sum };
-//# sourceMappingURL=sum-CEgbjhbj.d.ts.map

package/dist/sum-CEgbjhbj.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sum-CEgbjhbj.d.ts","names":[],"sources":["../src/sum.ts"],"sourcesContent":[],"mappings":";;;KAIK,cAAc,4BAA4B,6BAE3C,4BAGE,+BAA+B,mCAG7B;;AAZqE;;;;;;;;;AAsC7E;;;;;;;;AAwBA;;;AACwC,iBAzBxB,GAyBwB,CAAA,UAxB5B,iBAwB4B,CAAA,MAAA,CAAA,GAxBA,iBAwBA,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAvBhC,CAuBgC,CAAA,EAvB5B,GAuB4B,CAvBxB,CAuBwB,CAAA;;;;;;;;;;;;;;;;;;;;;iBADxB,GAAA,CAAA,cACJ,4BAA4B,iCAEhC,MACH,IAAI"}

package/dist/sum-CyC38gTv.d.cts

@@ -1,50 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-
-//#region src/sum.d.ts
-type Sum<T extends IterableContainer<bigint> | IterableContainer<number>> = T extends readonly [] ? 0 : T extends readonly [bigint, ...ReadonlyArray<unknown>] ? bigint : T[number] extends bigint ? 0 | bigint : number;
-/**
- * Sums the numbers in the array, or return 0 for an empty array.
- *
- * Works for both `number` and `bigint` arrays, but not arrays that contain both
- * types.
- *
- * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
- * the type of the array; to avoid adding this to the return type for cases
- * where the array is known to be non-empty you can use `hasAtLeast` or
- * `isEmpty` to guard against this case.
- *
- * @param data - The array of numbers.
- * @signature
- *   P.sum(data);
- * @example
- *   P.sum([1, 2, 3]); // => 6
- *   P.sum([1n, 2n, 3n]); // => 6n
- *   P.sum([]); // => 0
- * @dataFirst
- * @category Number
- */
-declare function sum<T extends IterableContainer<bigint> | IterableContainer<number>>(data: T): Sum<T>;
-/**
- * Sums the numbers in the array, or return 0 for an empty array.
- *
- * Works for both `number` and `bigint` arrays, but not arrays that contain both
- * types.
- *
- * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
- * the type of the array; to avoid adding this to the return type for cases
- * where the array is known to be non-empty you can use `hasAtLeast` or
- * `isEmpty`to guard against this case.
- *
- * @signature
- *   P.sum()(data);
- * @example
- *   P.pipe([1, 2, 3], P.sum()); // => 6
- *   P.pipe([1n, 2n, 3n], R.sum()); // => 6n
- *   P.pipe([], P.sum()); // => 0
- * @dataLast
- * @category Number
- */
-declare function sum(): <T extends IterableContainer<bigint> | IterableContainer<number>>(data: T) => Sum<T>;
-//#endregion
-export { sum };
-//# sourceMappingURL=sum-CyC38gTv.d.cts.map

package/dist/sum-CyC38gTv.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sum-CyC38gTv.d.cts","names":[],"sources":["../src/sum.ts"],"sourcesContent":[],"mappings":";;;KAIK,cAAc,4BAA4B,6BAE3C,4BAGE,+BAA+B,mCAG7B;;AAZqE;;;;;;;;;AAsC7E;;;;;;;;AAwBA;;;AACwC,iBAzBxB,GAyBwB,CAAA,UAxB5B,iBAwB4B,CAAA,MAAA,CAAA,GAxBA,iBAwBA,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAvBhC,CAuBgC,CAAA,EAvB5B,GAuB4B,CAvBxB,CAuBwB,CAAA;;;;;;;;;;;;;;;;;;;;;iBADxB,GAAA,CAAA,cACJ,4BAA4B,iCAEhC,MACH,IAAI"}

package/dist/sum-by-CTPKc8na.d.ts

@@ -1,57 +0,0 @@
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-
-//#region src/sum-by.d.ts
-type SumBy<T extends IterableContainer, U extends bigint | number> = T extends readonly [] ? 0 : T extends readonly [unknown, ...ReadonlyArray<unknown>] ? U : 0 | U;
-/**
- * Returns the sum of the elements of an array using the provided mapper.
- *
- * Works for both `number` and `bigint` mappers, but not mappers that return both
- * types.
- *
- * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
- * the type of the mapper; to avoid adding this to the return type for cases
- * where the array is known to be non-empty you can use `hasAtLeast` or
- * `isEmpty` to guard against this case.
- *
- *
- * @param callbackfn - Predicate function.
- * @signature
- *   P.sumBy(fn)(array)
- * @example
- *    P.pipe(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      P.sumBy(x => x.a)
- *    ) // 9
- * @dataLast
- * @category Array
- */
-declare function sumBy<T extends IterableContainer>(callbackfn: (value: T[number], index: number, data: T) => number): (items: T) => SumBy<T, number>;
-declare function sumBy<T extends IterableContainer>(callbackfn: (value: T[number], index: number, data: T) => bigint): (items: T) => SumBy<T, bigint>;
-/**
- * Returns the sum of the elements of an array using the provided mapper.
- *
- * Works for both `number` and `bigint` mappers, but not mappers that can return both
- * types.
- *
- * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
- * the type of the mapper; to avoid adding this to the return type for cases
- * where the array is known to be non-empty you can use `hasAtLeast` or
- * `isEmpty` to guard against this case.
- *
- * @param data - The array.
- * @param callbackfn - Predicate function.
- * @signature
- *   P.sumBy(array, fn)
- * @example
- *    P.sumBy(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      x => x.a
- *    ) // 9
- * @dataFirst
- * @category Array
- */
-declare function sumBy<T extends IterableContainer>(data: T, callbackfn: (value: T[number], index: number, data: T) => number): SumBy<T, number>;
-declare function sumBy<T extends IterableContainer>(data: T, callbackfn: (value: T[number], index: number, data: T) => bigint): SumBy<T, bigint>;
-//#endregion
-export { sumBy };
-//# sourceMappingURL=sum-by-CTPKc8na.d.ts.map

package/dist/sum-by-CTPKc8na.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sum-by-CTPKc8na.d.ts","names":[],"sources":["../src/sum-by.ts"],"sourcesContent":[],"mappings":";;;KAGK,gBACO,gDAER,4BAEA,gCAAgC,0BAC9B,QACI;;AAVmE;;;;;;;;;AAmC7E;;;;;;;;;AAGA;;;;AACsD,iBAJtC,KAIsC,CAAA,UAJtB,iBAIsB,CAAA,CAAA,UAAA,EAAA,CAAA,KAAA,EAHhC,CAGgC,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAHA,CAGA,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EAF3C,CAE2C,EAAA,GAFrC,KAEqC,CAF/B,CAE+B,EAAA,MAAA,CAAA;AAC3C,iBAFK,KAEL,CAAA,UAFqB,iBAErB,CAAA,CAAA,UAAA,EAAA,CAAA,KAAA,EADW,CACX,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAD2C,CAC3C,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EAAA,CAAA,EAAA,GAAM,KAAN,CAAY,CAAZ,EAAA,MAAA,CAAA;;;;AAyBX;;;;;;;;;AAIA;;;;;;;;;;;iBAJgB,gBAAgB,yBACxB,uBACc,gCAAgC,eACnD,MAAM;iBACO,gBAAgB,yBACxB,uBACc,gCAAgC,eACnD,MAAM"}

package/dist/sum-by-Cke8ybTY.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function 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}Object.defineProperty(exports,`sumBy`,{enumerable:!0,get:function(){return t}});

package/dist/sum-by-DH-LAQQ3.d.cts

@@ -1,57 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-
-//#region src/sum-by.d.ts
-type SumBy<T extends IterableContainer, U extends bigint | number> = T extends readonly [] ? 0 : T extends readonly [unknown, ...ReadonlyArray<unknown>] ? U : 0 | U;
-/**
- * Returns the sum of the elements of an array using the provided mapper.
- *
- * Works for both `number` and `bigint` mappers, but not mappers that return both
- * types.
- *
- * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
- * the type of the mapper; to avoid adding this to the return type for cases
- * where the array is known to be non-empty you can use `hasAtLeast` or
- * `isEmpty` to guard against this case.
- *
- *
- * @param callbackfn - Predicate function.
- * @signature
- *   P.sumBy(fn)(array)
- * @example
- *    P.pipe(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      P.sumBy(x => x.a)
- *    ) // 9
- * @dataLast
- * @category Array
- */
-declare function sumBy<T extends IterableContainer>(callbackfn: (value: T[number], index: number, data: T) => number): (items: T) => SumBy<T, number>;
-declare function sumBy<T extends IterableContainer>(callbackfn: (value: T[number], index: number, data: T) => bigint): (items: T) => SumBy<T, bigint>;
-/**
- * Returns the sum of the elements of an array using the provided mapper.
- *
- * Works for both `number` and `bigint` mappers, but not mappers that can return both
- * types.
- *
- * IMPORTANT: The result for empty arrays would be 0 (`number`) regardless of
- * the type of the mapper; to avoid adding this to the return type for cases
- * where the array is known to be non-empty you can use `hasAtLeast` or
- * `isEmpty` to guard against this case.
- *
- * @param data - The array.
- * @param callbackfn - Predicate function.
- * @signature
- *   P.sumBy(array, fn)
- * @example
- *    P.sumBy(
- *      [{a: 5}, {a: 1}, {a: 3}],
- *      x => x.a
- *    ) // 9
- * @dataFirst
- * @category Array
- */
-declare function sumBy<T extends IterableContainer>(data: T, callbackfn: (value: T[number], index: number, data: T) => number): SumBy<T, number>;
-declare function sumBy<T extends IterableContainer>(data: T, callbackfn: (value: T[number], index: number, data: T) => bigint): SumBy<T, bigint>;
-//#endregion
-export { sumBy };
-//# sourceMappingURL=sum-by-DH-LAQQ3.d.cts.map

package/dist/sum-by-DH-LAQQ3.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sum-by-DH-LAQQ3.d.cts","names":[],"sources":["../src/sum-by.ts"],"sourcesContent":[],"mappings":";;;KAGK,gBACO,gDAER,4BAEA,gCAAgC,0BAC9B,QACI;;AAVmE;;;;;;;;;AAmC7E;;;;;;;;;AAGA;;;;AACsD,iBAJtC,KAIsC,CAAA,UAJtB,iBAIsB,CAAA,CAAA,UAAA,EAAA,CAAA,KAAA,EAHhC,CAGgC,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAHA,CAGA,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EAF3C,CAE2C,EAAA,GAFrC,KAEqC,CAF/B,CAE+B,EAAA,MAAA,CAAA;AAC3C,iBAFK,KAEL,CAAA,UAFqB,iBAErB,CAAA,CAAA,UAAA,EAAA,CAAA,KAAA,EADW,CACX,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAD2C,CAC3C,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EAAA,CAAA,EAAA,GAAM,KAAN,CAAY,CAAZ,EAAA,MAAA,CAAA;;;;AAyBX;;;;;;;;;AAIA;;;;;;;;;;;iBAJgB,gBAAgB,yBACxB,uBACc,gCAAgC,eACnD,MAAM;iBACO,gBAAgB,yBACxB,uBACc,gCAAgC,eACnD,MAAM"}

package/dist/sum-by-DKfgHdcr.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function 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=sum-by-DKfgHdcr.js.map

package/dist/sum-by-DKfgHdcr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sum-by-DKfgHdcr.js","names":[],"sources":["../src/sum-by.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype SumBy<\n  T extends IterableContainer,\n  U extends bigint | number,\n> = T extends readonly []\n  ? 0\n  : T extends readonly [unknown, ...ReadonlyArray<unknown>]\n    ? U\n    : 0 | U;\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 *\n * @param callbackfn - Predicate function.\n * @signature\n *   P.sumBy(fn)(array)\n * @example\n *    P.pipe(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      P.sumBy(x => x.a)\n *    ) // 9\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 *   P.sumBy(array, fn)\n * @example\n *    P.sumBy(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      x => x.a\n *    ) // 9\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: ReadonlyArray<unknown>): unknown {\n  return curry(sumByImplementation, args);\n}\n\n// eslint-disable-next-line sonar/function-return-type\nfunction sumByImplementation<T>(\n  array: ReadonlyArray<T>,\n  callbackfn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>\n  ) => 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    sum += summand;\n  }\n\n  return sum;\n};\n"],"mappings":"4CA0EA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAIzC,SAAS,EACP,EACA,EAKiB,CACjB,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,CAG9C,GAAO,EAGT,OAAO"}

package/dist/swap-in-place-BBqaxzzG.js

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

package/dist/swap-in-place-BBqaxzzG.js.map

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

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

@@ -1 +0,0 @@
-function e(e,t,n){[e[t],e[n]]=[e[n],e[t]]}Object.defineProperty(exports,`swapInPlace`,{enumerable:!0,get:function(){return e}});

package/dist/swap-indices-CsuHWDbY.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n){return typeof e==`string`?r([...e],t,n).join(``):r(e,t,n)}function r(e,t,n){let r=[...e];if(Number.isNaN(t)||Number.isNaN(n))return r;let i=t<0?e.length+t:t,a=n<0?e.length+n:n;return i<0||i>e.length||a<0||a>e.length?r:(r[i]=e[a],r[a]=e[i],r)}Object.defineProperty(exports,`swapIndices`,{enumerable:!0,get:function(){return t}});

package/dist/swap-indices-DWG9tWCr.d.cts

@@ -1,61 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { Join } from "type-fest";
-
-//#region src/swap-indices.d.ts
-
-/**
- * @see https://github.com/sindresorhus/type-fest/blob/main/source/is-equal.d.ts
- */
-type isEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends (<G>() => G extends B ? 1 : 2) ? true : false;
-type Difference<A extends number, B extends number> = TupleOfLength<A> extends [...infer U, ...TupleOfLength<B>] ? U['length'] : never;
-type isLessThan<A extends number, B extends number> = isEqual<A, B> extends true ? false : 0 extends A ? true : 0 extends B ? false : isLessThan<Difference<A, 1>, Difference<B, 1>>;
-type TupleOfLength<L extends number, T extends IterableContainer = []> = T['length'] extends L ? T : TupleOfLength<L, [...T, unknown]>;
-type IsNonNegative<T extends number> = number extends T ? false : `${T}` extends `-${string}` ? false : true;
-type CharactersTuple<T extends string> = string extends T ? Array<string> : T extends `${infer C}${infer R}` ? [C, ...CharactersTuple<R>] : [];
-type SwapArrayInternal<T extends IterableContainer, Index1 extends number, Index2 extends number, Position extends ReadonlyArray<unknown> = [], Original extends IterableContainer = T> = T extends readonly [infer AtPosition, ...infer Rest] ? [Position['length'] extends Index1 ? Original[Index2] : Position['length'] extends Index2 ? Original[Index1] : AtPosition, ...SwapArrayInternal<Rest, Index1, Index2, [unknown, ...Position], Original>] : T;
-type SwapString<T extends string, K1 extends number, K2 extends number> = Join<SwapArray<CharactersTuple<T>, K1, K2>, ''>;
-type SwapArray<T extends IterableContainer, K1 extends number, K2 extends number> = IsNonNegative<K1> extends false ? Array<T[number]> : IsNonNegative<K2> extends false ? Array<T[number]> : isLessThan<K1, T['length']> extends false ? T : isLessThan<K2, T['length']> extends false ? T : SwapArrayInternal<T, K1, K2>;
-type SwappedIndices<T extends IterableContainer | string, K1 extends number, K2 extends number> = T extends string ? SwapString<T, K1, K2> : T extends IterableContainer ? SwapArray<T, K1, K2> : never;
-/**
- * Swaps the positions of two elements in an array or string at the provided indices.
- *
- * 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.
- *
- * If either index is out of bounds the result would be a shallow copy of the input, as-is.
- *
- * @param data - The item to be manipulated. This can be an array, or a string.
- * @param index1 - The first index.
- * @param index2 - The second index.
- * @returns Returns the manipulated array or string.
- * @signature
- *   swapIndices(data, index1, index2)
- * @example
- *   swapIndices(['a', 'b', 'c'], 0, 1) // => ['b', 'a', 'c']
- *   swapIndices(['a', 'b', 'c'], 1, -1) // => ['a', 'c', 'b']
- *   swapIndices('abc', 0, 1) // => 'bac'
- * @dataFirst
- * @category Array
- */
-declare function swapIndices<T extends IterableContainer | string, K1 extends number, K2 extends number>(data: T, index1: K1, index2: K2): SwappedIndices<T, K1, K2>;
-/**
- * Swaps the positions of two elements in an array or string at the provided indices.
- *
- * 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.
- *
- * If either index is out of bounds the result would be a shallow copy of the input, as-is.
- *
- * @param index1 - The first index.
- * @param index2 - The second index.
- * @returns Returns the manipulated array or string.
- * @signature
- *   swapIndices(index1, index2)(data)
- * @example
- *   swapIndices(0, 1)(['a', 'b', 'c']) // => ['b', 'a', 'c']
- *   swapIndices(0, -1)('abc') // => 'cba'
- * @dataLast
- * @category Array
- */
-declare function swapIndices<K1 extends number, K2 extends number>(index1: K1, index2: K2): <T extends IterableContainer | string>(data: T) => SwappedIndices<T, K1, K2>;
-//#endregion
-export { swapIndices };
-//# sourceMappingURL=swap-indices-DWG9tWCr.d.cts.map

package/dist/swap-indices-DWG9tWCr.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swap-indices-DWG9tWCr.d.cts","names":[],"sources":["../src/swap-indices.ts"],"sourcesContent":[],"mappings":";;;;;;;AAE6E;KAOxE,OAAO,CAAA,CAAA,EAAA,CAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA,GAAA,GACE,CADF,SACY,CADZ,GAAA,CAAA,GAAA,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,GAAA,GACwC,CADxC,SACkD,CADlD,GAAA,CAAA,GAAA,CAAA,IAAA,IAAA,GAAA,KAAA;KAKP,UAJS,CAAA,UAAA,MAAA,EAAA,UAAA,MAAA,CAAA,GAKV,aALU,CAKI,CALJ,CAAA,SAAA,CAAA,GAAA,KAAA,EAAA,EAAA,GAK+B,aAL/B,CAK6C,CAL7C,CAAA,CAAA,GAMR,CANQ,CAAA,QAAA,CAAA,GAAA,KAAA;KAST,UATmB,CAAA,UAAA,MAAA,EAAA,UAAA,MAAA,CAAA,GAUpB,OAVoB,CAUZ,CAVY,EAUT,CAVS,CAAA,SAAA,IAAA,GAAA,KAAA,GAAA,CAAA,SAYR,CAZQ,GAAA,IAAA,GAAA,CAAA,SAcN,CAdM,GAAA,KAAA,GAgBd,UAhBc,CAgBH,UAhBG,CAgBQ,CAhBR,EAAA,CAAA,CAAA,EAgBe,UAhBf,CAgB0B,CAhB1B,EAAA,CAAA,CAAA,CAAA;KAkBnB,aAlB+C,CAAA,UAAA,MAAA,EAAA,UAoBxC,iBApBwC,GAAA,EAAA,CAAA,GAqBhD,CArBgD,CAAA,QAAA,CAAA,SAqB5B,CArB4B,GAqBxB,CArBwB,GAqBpB,aArBoB,CAqBN,CArBM,EAAA,CAAA,GAqBC,CArBD,EAAA,OAAA,CAAA,CAAA;KAuB/C,aAvByD,CAAA,UAAA,MAAA,CAAA,GAAA,MAAA,SAuBR,CAvBQ,GAAA,KAAA,GAAA,GAyBvD,CAzBuD,EAAA,SAAA,IAAA,MAAA,EAAA,GAAA,KAAA,GAAA,IAAA;KA6BzD,eA7B0D,CAAA,UAAA,MAAA,CAAA,GAAA,MAAA,SA6BP,CA7BO,GA8B3D,KA9B2D,CAAA,MAAA,CAAA,GA+B3D,CA/B2D,SAAA,GAAA,KAAA,EAAA,GAAA,KAAA,EAAA,EAAA,GAAA,CAgCxD,CAhCwD,EAAA,GAgClD,eAhCkD,CAgClC,CAhCkC,CAAA,CAAA,GAAA,EAAA;AAAA,KAmC1D,iBA/BU,CAAA,UAgCH,iBAhCG,EAAA,eAAA,MAAA,EAAA,eAAA,MAAA,EAAA,iBAmCI,aAnCJ,CAAA,OAAA,CAAA,GAAA,EAAA,EAAA,iBAoCI,iBApCJ,GAoCwB,CApCxB,CAAA,GAqCX,CArCW,SAAA,SAAA,CAAA,KAAA,WAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAAA,CAuCT,QAvCS,CAAA,QAAA,CAAA,SAuCkB,MAvClB,GAwCL,QAxCK,CAwCI,MAxCJ,CAAA,GAyCL,QAzCK,CAAA,QAAA,CAAA,SAyCsB,MAzCtB,GA0CH,QA1CG,CA0CM,MA1CN,CAAA,GA2CH,UA3CG,KA4CN,iBA3CS,CA4CV,IA5CU,EA6CV,MA7CU,EA8CV,MA9CU,EAAA,CAAd,OAAA,EAAuD,GA+CtC,QA/CsC,GAgDnD,QAhDqC,CAAA,IAmDzC;KAEC,UApDE,CAAA,UAAA,MAAA,EAAA,WAAA,MAAA,EAAA,WAAA,MAAA,CAAA,GAoDmE,IApDnE,CAqDL,SArDK,CAqDK,eArDL,CAqDqB,CArDrB,CAAA,EAqDyB,EArDzB,EAqD6B,EArD7B,CAAA,EAAA,EAAA,CAAA;AAAA,KAyDF,SAtDA,CAAA,UAuDO,iBAvDG,EAAA,WAAA,MAAA,EAAA,WAAA,MAAA,CAAA,GAiEX,aAjEW,CAiEG,EAjEH,CAAA,SAAA,KAAA,GAkET,KAlES,CAkEH,CAlEG,CAAA,MAAA,CAAA,CAAA,GAmET,aAnES,CAmEK,EAnEL,CAAA,SAAA,KAAA,GAoEP,KApEO,CAoED,CApEC,CAAA,MAAA,CAAA,CAAA,GAuET,UAvES,CAuEE,EAvEF,EAuEM,CAvEN,CAAA,QAAA,CAAA,CAAA,SAAA,KAAA,GAwEL,CAxEK,GAyEL,UAzEK,CAyEM,EAzEN,EAyEU,CAzEV,CAAA,QAAA,CAAA,CAAA,SAAA,KAAA,GA0EH,CA1EG,GA2EH,iBA3EG,CA2Ee,CA3Ef,EA2EkB,EA3ElB,EA2EsB,EA3EtB,CAAA;KA6EV,cA7EU,CAAA,UA8EH,iBA9EG,GAAA,MAAA,EAAA,WAAA,MAAA,EAAA,WAAA,MAAA,CAAA,GAiFX,CAjFW,SAAA,MAAA,GAkFX,UAlFW,CAkFA,CAlFA,EAkFG,EAlFH,EAkFO,EAlFP,CAAA,GAmFX,CAnFW,SAmFD,iBAnFC,GAoFT,SApFS,CAoFC,CApFD,EAoFI,EApFJ,EAoFQ,EApFR,CAAA,GAAA,KAAA;;;;;;;;;;;;AAOK;;;;;;;;;AAKyB,iBA+F7B,WA/F6B,CAAA,UAgGjC,iBAhGiC,GAAA,MAAA,EAAA,WAAA,MAAA,EAAA,WAAA,MAAA,CAAA,CAAA,IAAA,EAmGrC,CAnGqC,EAAA,MAAA,EAmG1B,EAnG0B,EAAA,MAAA,EAmGd,EAnGc,CAAA,EAmGT,cAnGS,CAmGM,CAnGN,EAmGS,EAnGT,EAmGa,EAnGb,CAAA;AAAA;;;;;AAIrC;;;;;;;;;AAOoB;;;;AAQT,iBAoGH,WApGG,CAAA,WAAA,MAAA,EAAA,WAAA,MAAA,CAAA,CAAA,MAAA,EAqGT,EArGS,EAAA,MAAA,EAsGT,EAtGS,CAAA,EAAA,CAAA,UAuGL,iBAvGK,GAAA,MAAA,CAAA,CAAA,IAAA,EAuG6B,CAvG7B,EAAA,GAuGmC,cAvGnC,CAuGkD,CAvGlD,EAuGqD,EAvGrD,EAuGyD,EAvGzD,CAAA"}

package/dist/swap-indices-DWsQg1W8.d.ts

@@ -1,61 +0,0 @@
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-import { Join } from "type-fest";
-
-//#region src/swap-indices.d.ts
-
-/**
- * @see https://github.com/sindresorhus/type-fest/blob/main/source/is-equal.d.ts
- */
-type isEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends (<G>() => G extends B ? 1 : 2) ? true : false;
-type Difference<A extends number, B extends number> = TupleOfLength<A> extends [...infer U, ...TupleOfLength<B>] ? U['length'] : never;
-type isLessThan<A extends number, B extends number> = isEqual<A, B> extends true ? false : 0 extends A ? true : 0 extends B ? false : isLessThan<Difference<A, 1>, Difference<B, 1>>;
-type TupleOfLength<L extends number, T extends IterableContainer = []> = T['length'] extends L ? T : TupleOfLength<L, [...T, unknown]>;
-type IsNonNegative<T extends number> = number extends T ? false : `${T}` extends `-${string}` ? false : true;
-type CharactersTuple<T extends string> = string extends T ? Array<string> : T extends `${infer C}${infer R}` ? [C, ...CharactersTuple<R>] : [];
-type SwapArrayInternal<T extends IterableContainer, Index1 extends number, Index2 extends number, Position extends ReadonlyArray<unknown> = [], Original extends IterableContainer = T> = T extends readonly [infer AtPosition, ...infer Rest] ? [Position['length'] extends Index1 ? Original[Index2] : Position['length'] extends Index2 ? Original[Index1] : AtPosition, ...SwapArrayInternal<Rest, Index1, Index2, [unknown, ...Position], Original>] : T;
-type SwapString<T extends string, K1 extends number, K2 extends number> = Join<SwapArray<CharactersTuple<T>, K1, K2>, ''>;
-type SwapArray<T extends IterableContainer, K1 extends number, K2 extends number> = IsNonNegative<K1> extends false ? Array<T[number]> : IsNonNegative<K2> extends false ? Array<T[number]> : isLessThan<K1, T['length']> extends false ? T : isLessThan<K2, T['length']> extends false ? T : SwapArrayInternal<T, K1, K2>;
-type SwappedIndices<T extends IterableContainer | string, K1 extends number, K2 extends number> = T extends string ? SwapString<T, K1, K2> : T extends IterableContainer ? SwapArray<T, K1, K2> : never;
-/**
- * Swaps the positions of two elements in an array or string at the provided indices.
- *
- * 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.
- *
- * If either index is out of bounds the result would be a shallow copy of the input, as-is.
- *
- * @param data - The item to be manipulated. This can be an array, or a string.
- * @param index1 - The first index.
- * @param index2 - The second index.
- * @returns Returns the manipulated array or string.
- * @signature
- *   swapIndices(data, index1, index2)
- * @example
- *   swapIndices(['a', 'b', 'c'], 0, 1) // => ['b', 'a', 'c']
- *   swapIndices(['a', 'b', 'c'], 1, -1) // => ['a', 'c', 'b']
- *   swapIndices('abc', 0, 1) // => 'bac'
- * @dataFirst
- * @category Array
- */
-declare function swapIndices<T extends IterableContainer | string, K1 extends number, K2 extends number>(data: T, index1: K1, index2: K2): SwappedIndices<T, K1, K2>;
-/**
- * Swaps the positions of two elements in an array or string at the provided indices.
- *
- * 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.
- *
- * If either index is out of bounds the result would be a shallow copy of the input, as-is.
- *
- * @param index1 - The first index.
- * @param index2 - The second index.
- * @returns Returns the manipulated array or string.
- * @signature
- *   swapIndices(index1, index2)(data)
- * @example
- *   swapIndices(0, 1)(['a', 'b', 'c']) // => ['b', 'a', 'c']
- *   swapIndices(0, -1)('abc') // => 'cba'
- * @dataLast
- * @category Array
- */
-declare function swapIndices<K1 extends number, K2 extends number>(index1: K1, index2: K2): <T extends IterableContainer | string>(data: T) => SwappedIndices<T, K1, K2>;
-//#endregion
-export { swapIndices };
-//# sourceMappingURL=swap-indices-DWsQg1W8.d.ts.map

package/dist/swap-indices-DWsQg1W8.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swap-indices-DWsQg1W8.d.ts","names":[],"sources":["../src/swap-indices.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/swap-indices-inhV1_Nb.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t,n){return typeof e==`string`?r([...e],t,n).join(``):r(e,t,n)}function r(e,t,n){let r=[...e];if(Number.isNaN(t)||Number.isNaN(n))return r;let i=t<0?e.length+t:t,a=n<0?e.length+n:n;return i<0||i>e.length||a<0||a>e.length?r:(r[i]=e[a],r[a]=e[i],r)}export{t as swapIndices};
-//# sourceMappingURL=swap-indices-inhV1_Nb.js.map

package/dist/swap-indices-inhV1_Nb.js.map

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

package/dist/swap-props-BRHZP2h5.d.cts

@@ -1,34 +0,0 @@
-//#region src/swap-props.d.ts
-type SwappedProps<T, K1 extends keyof T, K2 extends keyof T> = { [K in keyof T]: T[K1 extends K ? K2 : K2 extends K ? K1 : K] };
-/**
- * Swaps the positions of two properties in an object based on the provided keys.
- *
- * @param data - The object to be manipulated.
- * @param key1 - The first property key.
- * @param key2 - The second property key.
- * @returns Returns the manipulated object.
- * @signature
- *   swap(data, key1, key2)
- * @example
- *   swap({a: 1, b: 2, c: 3}, 'a', 'b') // => {a: 2, b: 1, c: 3}
- * @dataFirst
- * @category Object
- */
-declare function swapProps<T extends object, K1 extends keyof T, K2 extends keyof T>(data: T, key1: K1, key2: K2): SwappedProps<T, K1, K2>;
-/**
- * Swaps the positions of two properties in an object based on the provided keys.
- *
- * @param key1 - The first property key.
- * @param key2 - The second property key.
- * @returns Returns the manipulated object.
- * @signature
- *   swap(key1, key2)(data)
- * @example
- *   swap('a', 'b')({a: 1, b: 2, c: 3}) // => {a: 2, b: 1, c: 3}
- * @dataLast
- * @category Object
- */
-declare function swapProps<T extends object, K1 extends keyof T, K2 extends keyof T>(key1: K1, key2: K2): (data: T) => SwappedProps<T, K1, K2>;
-//#endregion
-export { swapProps };
-//# sourceMappingURL=swap-props-BRHZP2h5.d.cts.map

package/dist/swap-props-BRHZP2h5.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swap-props-BRHZP2h5.d.cts","names":[],"sources":["../src/swap-props.ts"],"sourcesContent":[],"mappings":";KAEK,iCAAiC,oBAAoB,aAArD,MACS,CADT,GACa,CADD,CACG,EADH,SACc,CADd,GACkB,EADlB,GACuB,EADvB,SACkC,CADlC,GACsC,EADtC,GAC2C,CAD3C,CAAA,EAAA;;;;;;;;;;;;;AAkBjB;;AAEmB,iBAFH,SAEG,CAAA,UAAA,MAAA,EAAA,WAAA,MAAA,CAAA,EAAA,WAAA,MACA,CADA,CAAA,CAAA,IAAA,EAEX,CAFW,EAAA,IAAA,EAEF,EAFE,EAAA,IAAA,EAEQ,EAFR,CAAA,EAEa,YAFb,CAE0B,CAF1B,EAE6B,EAF7B,EAEiC,EAFjC,CAAA;;;;;;;;;;AAiBnB;;;;AAIQ,iBAJQ,SAIR,CAAA,UAAA,MAAA,EAAA,WAAA,MAFW,CAEX,EAAA,WAAA,MADW,CACX,CAAA,CAAA,IAAA,EAAA,EAAA,EAAA,IAAA,EAAU,EAAV,CAAA,EAAA,CAAA,IAAA,EAAsB,CAAtB,EAAA,GAA4B,YAA5B,CAAyC,CAAzC,EAA4C,EAA5C,EAAgD,EAAhD,CAAA"}

package/dist/swap-props-mp8Z9OU_.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.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=swap-props-mp8Z9OU_.js.map

package/dist/swap-props-mp8Z9OU_.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"swap-props-mp8Z9OU_.js","names":[],"sources":["../src/swap-props.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype SwappedProps<T, K1 extends keyof T, K2 extends keyof T> = {\n  [K in keyof T]: T[K1 extends K ? K2 : K2 extends K ? K1 : K];\n};\n\n/**\n * Swaps the positions 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 *   swap(data, key1, key2)\n * @example\n *   swap({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 positions 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 *   swap(key1, key2)(data)\n * @example\n *   swap('a', 'b')({a: 1, b: 2, c: 3}) // => {a: 2, b: 1, c: 3}\n * @dataLast\n * @category Object\n */\nexport function swapProps<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(key1: K1, key2: K2): (data: T) => SwappedProps<T, K1, K2>;\n\nexport function swapProps(...args: ReadonlyArray<unknown>): unknown {\n  return curry(swapPropsImplementation, args);\n}\n\nfunction swapPropsImplementation<\n  T extends object,\n  K1 extends keyof T,\n  K2 extends keyof T,\n>(\n  obj: T,\n  key1: K1,\n  key2: K2,\n): {\n  [K in PropertyKey]: unknown;\n} {\n  const { [key1]: value1, [key2]: value2 } = obj;\n  return {\n    ...obj,\n    [key1]: value2,\n    [key2]: value1,\n  };\n}\n"],"mappings":"4CA6CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EAKP,EACA,EACA,EAGA,CACA,GAAM,EAAG,GAAO,GAAS,GAAO,GAAW,EAC3C,MAAO,CACL,GAAG,GACF,GAAO,GACP,GAAO,EACT"}

package/dist/swap-props-pgUf_Wxo.d.ts

@@ -1,34 +0,0 @@
-//#region src/swap-props.d.ts
-type SwappedProps<T, K1 extends keyof T, K2 extends keyof T> = { [K in keyof T]: T[K1 extends K ? K2 : K2 extends K ? K1 : K] };
-/**
- * Swaps the positions of two properties in an object based on the provided keys.
- *
- * @param data - The object to be manipulated.
- * @param key1 - The first property key.
- * @param key2 - The second property key.
- * @returns Returns the manipulated object.
- * @signature
- *   swap(data, key1, key2)
- * @example
- *   swap({a: 1, b: 2, c: 3}, 'a', 'b') // => {a: 2, b: 1, c: 3}
- * @dataFirst
- * @category Object
- */
-declare function swapProps<T extends object, K1 extends keyof T, K2 extends keyof T>(data: T, key1: K1, key2: K2): SwappedProps<T, K1, K2>;
-/**
- * Swaps the positions of two properties in an object based on the provided keys.
- *
- * @param key1 - The first property key.
- * @param key2 - The second property key.
- * @returns Returns the manipulated object.
- * @signature
- *   swap(key1, key2)(data)
- * @example
- *   swap('a', 'b')({a: 1, b: 2, c: 3}) // => {a: 2, b: 1, c: 3}
- * @dataLast
- * @category Object
- */
-declare function swapProps<T extends object, K1 extends keyof T, K2 extends keyof T>(key1: K1, key2: K2): (data: T) => SwappedProps<T, K1, K2>;
-//#endregion
-export { swapProps };
-//# sourceMappingURL=swap-props-pgUf_Wxo.d.ts.map

package/dist/swap-props-pgUf_Wxo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swap-props-pgUf_Wxo.d.ts","names":[],"sources":["../src/swap-props.ts"],"sourcesContent":[],"mappings":";KAEK,iCAAiC,oBAAoB,aAArD,MACS,CADT,GACa,CADD,CACG,EADH,SACc,CADd,GACkB,EADlB,GACuB,EADvB,SACkC,CADlC,GACsC,EADtC,GAC2C,CAD3C,CAAA,EAAA;;;;;;;;;;;;;AAkBjB;;AAEmB,iBAFH,SAEG,CAAA,UAAA,MAAA,EAAA,WAAA,MAAA,CAAA,EAAA,WAAA,MACA,CADA,CAAA,CAAA,IAAA,EAEX,CAFW,EAAA,IAAA,EAEF,EAFE,EAAA,IAAA,EAEQ,EAFR,CAAA,EAEa,YAFb,CAE0B,CAF1B,EAE6B,EAF7B,EAEiC,EAFjC,CAAA;;;;;;;;;;AAiBnB;;;;AAIQ,iBAJQ,SAIR,CAAA,UAAA,MAAA,EAAA,WAAA,MAFW,CAEX,EAAA,WAAA,MADW,CACX,CAAA,CAAA,IAAA,EAAA,EAAA,EAAA,IAAA,EAAU,EAAV,CAAA,EAAA,CAAA,IAAA,EAAsB,CAAtB,EAAA,GAA4B,YAA5B,CAAyC,CAAzC,EAA4C,EAA5C,EAAgD,EAAhD,CAAA"}

package/dist/swap-props-zfImAv9P.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n){let{[t]:r,[n]:i}=e;return{...e,[t]:i,[n]:r}}Object.defineProperty(exports,`swapProps`,{enumerable:!0,get:function(){return t}});

package/dist/take-BXMJXDQ_.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./utility-evaluators-DqJcWENu.cjs`);function n(...t){return e.curry(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t.lazyEmptyEvaluator;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}Object.defineProperty(exports,`take`,{enumerable:!0,get:function(){return n}});