@vinicunca/perkakas 1.13.2 → 1.15.0

package/dist/split.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"split.d.ts","names":[],"sources":["../src/split.ts"],"sourcesContent":[],"mappings":";;;KAOK,+GAIc,IACf,+BACe,YACb,+BACe,IACb,gBAEA,QAAQ,kBACN,gBACA,WAIA,MAAU,GAAG,eAIb,mBAAmB,YAAY;;AAvBtB;;;;;;;;;;;;;;;;;;AAoDnB;AAKA;;;;;;AAIiE,iBATjD,KAAA,CASiD,IAAA,EAAA,MAAA,EAAA,SAAA,EAPpD,MAOoD,EAAA,KAAA,CAAA,EAAA,MAAA,CAAA,EAL9D,KAK8D,CAAA,MAAA,CAAA;AAApB,iBAJ7B,KAI6B,CAAA,UAAA,MAAA,EAAA,kBAAA,MAAA,EAAA,UAAA,MAAA,GAAA,SAAA,GAAA,SAAA,CAAA,CAAA,IAAA,EAArC,CAAqC,EAAA,SAAA,EAAvB,SAAuB,EAAA,KAAA,CAAA,EAAJ,CAAI,CAAA,EAAA,OAAA,CAAM,CAAN,EAAS,SAAT,EAAoB,CAApB,CAAA;;AA2B7C;AAIA;;;;;;;;;;;;;;;;;;;;;;;iBAJgB,KAAA,YACH,2CAEQ;iBACL,uGAIH,mBAAmB,WAAW,MAAM,QAAM,GAAG,WAAW"}

package/dist/strict-function-BBgKFNUw.d.ts

@@ -1,26 +0,0 @@
-//#region src/internal/types/strict-function.d.ts
-/**
- * TypeScript compares function parameters using [contra-variance and not
- * co-variance](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)#Function_types).
- * To accept all functions we **can't** use `readonly unknown[]` (which only
- * accepts functions with an actual variadic param). Instead, contrary to
- * intuition, we need to use `never` (which extends **everything!** and thus
- * would catch all cases). Another way to think about it is that a function
- * with `never` parameters is effectively un-callable, making functions that
- * take anything else callable, and thus are "extensions" of it.
- *
- * It's important to note that the resulting type is "academic", but not very
- * useful because of a known, and [reported](https://github.com/microsoft/TypeScript/issues/61750), limitation of TypeScript that stems
- * from the fact that TypeScript infers types parameterized by generic types
- * too eagerly, making it impossible to rely on parts of a generic type
- * generically too. Internally use `@ts-expect-error` in those cases and
- * explain what the expected type should have been, this is so that if the issue
- * is resolved in future versions of TypeScript we can easily find these places
- * and fix them.
- *
- * @see https://www.typescriptlang.org/play/?#code/C4TwDgpgBA6glsAFgJQgQwCYHsB2AbEAVRwGscsB3HAHgBUA+KAXilqggA9gIcMBnKAAoAdKLQAnAOZ8AXFHHps+EFACupclQDaAXQCUzRurKUcAKChQA-FGDjVEC1DkAzNHj4QA3GbOhIsAiIAII4IHSMLGyc3LwCImJSslBoYQZMRhqm1rb20K7unj5+4NDwSAByEABuEOIRzKzsXDz8QqLCEtJyODV16ZkmVDl2Ds5Qbh7evv7QtBB8wABi6gDGjYJoPaoAtgBG-YZQi+JwOJLFs1AAGgAMjeUoirgExEM084srOKv0PgD0-0sUAAelYZqUbgBGB5BULhT7LNZ-MyA4FgiEBa4AJlhlT69UR31+AKBljBQA
- */
-type StrictFunction = (...args: never) => unknown;
-//#endregion
-export { StrictFunction as t };
-//# sourceMappingURL=strict-function-BBgKFNUw.d.ts.map

package/dist/strict-function-BBgKFNUw.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict-function-BBgKFNUw.d.ts","names":[],"sources":["../src/internal/types/strict-function.ts"],"sourcesContent":[],"mappings":";;AAqBA;;;;;;;;;;;;;;;;;;;;KAAY,cAAA"}

package/dist/strict-function-CPTwDgnZ.d.cts

@@ -1,26 +0,0 @@
-//#region src/internal/types/strict-function.d.ts
-/**
- * TypeScript compares function parameters using [contra-variance and not
- * co-variance](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)#Function_types).
- * To accept all functions we **can't** use `readonly unknown[]` (which only
- * accepts functions with an actual variadic param). Instead, contrary to
- * intuition, we need to use `never` (which extends **everything!** and thus
- * would catch all cases). Another way to think about it is that a function
- * with `never` parameters is effectively un-callable, making functions that
- * take anything else callable, and thus are "extensions" of it.
- *
- * It's important to note that the resulting type is "academic", but not very
- * useful because of a known, and [reported](https://github.com/microsoft/TypeScript/issues/61750), limitation of TypeScript that stems
- * from the fact that TypeScript infers types parameterized by generic types
- * too eagerly, making it impossible to rely on parts of a generic type
- * generically too. Internally use `@ts-expect-error` in those cases and
- * explain what the expected type should have been, this is so that if the issue
- * is resolved in future versions of TypeScript we can easily find these places
- * and fix them.
- *
- * @see https://www.typescriptlang.org/play/?#code/C4TwDgpgBA6glsAFgJQgQwCYHsB2AbEAVRwGscsB3HAHgBUA+KAXilqggA9gIcMBnKAAoAdKLQAnAOZ8AXFHHps+EFACupclQDaAXQCUzRurKUcAKChQA-FGDjVEC1DkAzNHj4QA3GbOhIsAiIAII4IHSMLGyc3LwCImJSslBoYQZMRhqm1rb20K7unj5+4NDwSAByEABuEOIRzKzsXDz8QqLCEtJyODV16ZkmVDl2Ds5Qbh7evv7QtBB8wABi6gDGjYJoPaoAtgBG-YZQi+JwOJLFs1AAGgAMjeUoirgExEM084srOKv0PgD0-0sUAAelYZqUbgBGB5BULhT7LNZ-MyA4FgiEBa4AJlhlT69UR31+AKBljBQA
- */
-type StrictFunction = (...args: never) => unknown;
-//#endregion
-export { StrictFunction as t };
-//# sourceMappingURL=strict-function-CPTwDgnZ.d.cts.map

package/dist/strict-function-CPTwDgnZ.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict-function-CPTwDgnZ.d.cts","names":[],"sources":["../src/internal/types/strict-function.ts"],"sourcesContent":[],"mappings":";;AAqBA;;;;;;;;;;;;;;;;;;;;KAAY,cAAA"}

package/dist/string-to-path.d.cts

@@ -1,39 +0,0 @@
-import { IsNumericLiteral, IsStringLiteral } from "type-fest";
-
-//#region src/string-to-path.d.ts
-type StringToPath<S> = IsStringLiteral<S> extends true ? StringToPathImpl<S> : Array<string | number>;
-type StringToPathImpl<S> = S extends `${infer Head}['${infer Quoted}']${infer Tail}` ? [...StringToPath<Head>, Quoted, ...StringToPath<Tail>] : S extends `${infer Head}["${infer DoubleQuoted}"]${infer Tail}` ? [...StringToPath<Head>, DoubleQuoted, ...StringToPath<Tail>] : S extends `${infer Head}[${infer Unquoted}]${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Unquoted>, ...StringToPath<Tail>] : S extends `${infer Head}.${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Tail>] : '' extends S ? [] : S extends `${infer N extends number}` ? [IsNumericLiteral<N> extends true ? N : S] : [S];
-/**
- * A utility to allow JSONPath-like strings to be used in other utilities which
- * take an array of path segments as input (e.g. `pathOr`, `setPath`, etc...).
- * The main purpose of this utility is to act as a bridge between the runtime
- * implementation that converts the path to an array, and the type-system that
- * parses the path string **type** into an array **type**. This type allows us
- * to return fine-grained types and to enforce correctness at the type-level.
- *
- * We **discourage** using this utility for new code. This utility is for legacy
- * code that already contains path strings (which are accepted by Lodash). We
- * strongly recommend using *path arrays* instead as they provide better
- * developer experience via significantly faster type-checking, fine-grained
- * error messages, and automatic typeahead suggestions for each segment of the
- * path.
- *
- * There are a bunch of limitations to this utility derived from the
- * limitations of the type itself, these are usually edge-cases around deeply
- * nested paths, escaping, whitespaces, and empty segments. This is true even
- * in cases where the runtime implementation can better handle them, this is
- * intentional. See the tests for this utility for more details and the
- * expected outputs*.
- *
- * @param path - A string path.
- * @signature
- *   P.stringToPath(path)
- * @example
- *   P.stringToPath('a.b[0].c') // => ['a', 'b', 0, 'c']
- * @dataFirst
- * @category Utility
- */
-declare function stringToPath<const Path extends string>(path: Path): StringToPath<Path>;
-//#endregion
-export { stringToPath };
-//# sourceMappingURL=string-to-path.d.cts.map

package/dist/string-to-path.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"string-to-path.d.cts","names":[],"sources":["../src/string-to-path.ts"],"sourcesContent":[],"mappings":";;;KASK,kBAGD,gBAAgB,kBACd,iBAAiB,KACjB;KAED,sBAMD,gEACM,aAAa,OAAO,WAAW,aAAa,SAChD,sEACM,aAAa,OAAO,iBAAiB,aAAa,SAGtD,6DAnBH,GAqBU,YArBE,CAqBW,IArBX,CAAA,EAGG,GAmBL,YAnBK,CAmBQ,QAnBR,CAAA,EAAhB,GAoBW,YApBX,CAoBwB,IApBxB,CAAA,CACmB,GAwBb,CAxBa,SAAA,GAAA,KAAA,KAAA,IAAA,KAAA,KAAA,EAAA,GAAA,CAAA,GAyBP,YAzBO,CAyBM,IAzBN,CAAA,EAAA,GAyBgB,YAzBhB,CAyB6B,IAzB7B,CAAA,CAAA,GAAA,EAAA,SA2BA,CA3BA,GAAA,EAAA,GAsCT,CAtCS,SAAA,GAAA,KAAA,WAAA,MAAA,EAAA,GAAA,CA4CL,gBA5CZ,CA4C6B,CA5C7B,CAAA,SAAA,IAAA,GAAA,CAAA,GA4CmD,CA5CnD,CACA,GAAA,CA8CW,CA9CX,CAAA;;AAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2C8C,iBAmCzC,YAnCyC,CAAA,mBAAA,MAAA,CAAA,CAAA,IAAA,EAoCjD,IApCiD,CAAA,EAqCtD,YArCsD,CAqCzC,IArCyC,CAAA"}

package/dist/string-to-path.d.ts

@@ -1,39 +0,0 @@
-import { IsNumericLiteral, IsStringLiteral } from "type-fest";
-
-//#region src/string-to-path.d.ts
-type StringToPath<S> = IsStringLiteral<S> extends true ? StringToPathImpl<S> : Array<string | number>;
-type StringToPathImpl<S> = S extends `${infer Head}['${infer Quoted}']${infer Tail}` ? [...StringToPath<Head>, Quoted, ...StringToPath<Tail>] : S extends `${infer Head}["${infer DoubleQuoted}"]${infer Tail}` ? [...StringToPath<Head>, DoubleQuoted, ...StringToPath<Tail>] : S extends `${infer Head}[${infer Unquoted}]${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Unquoted>, ...StringToPath<Tail>] : S extends `${infer Head}.${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Tail>] : '' extends S ? [] : S extends `${infer N extends number}` ? [IsNumericLiteral<N> extends true ? N : S] : [S];
-/**
- * A utility to allow JSONPath-like strings to be used in other utilities which
- * take an array of path segments as input (e.g. `pathOr`, `setPath`, etc...).
- * The main purpose of this utility is to act as a bridge between the runtime
- * implementation that converts the path to an array, and the type-system that
- * parses the path string **type** into an array **type**. This type allows us
- * to return fine-grained types and to enforce correctness at the type-level.
- *
- * We **discourage** using this utility for new code. This utility is for legacy
- * code that already contains path strings (which are accepted by Lodash). We
- * strongly recommend using *path arrays* instead as they provide better
- * developer experience via significantly faster type-checking, fine-grained
- * error messages, and automatic typeahead suggestions for each segment of the
- * path.
- *
- * There are a bunch of limitations to this utility derived from the
- * limitations of the type itself, these are usually edge-cases around deeply
- * nested paths, escaping, whitespaces, and empty segments. This is true even
- * in cases where the runtime implementation can better handle them, this is
- * intentional. See the tests for this utility for more details and the
- * expected outputs*.
- *
- * @param path - A string path.
- * @signature
- *   P.stringToPath(path)
- * @example
- *   P.stringToPath('a.b[0].c') // => ['a', 'b', 0, 'c']
- * @dataFirst
- * @category Utility
- */
-declare function stringToPath<const Path extends string>(path: Path): StringToPath<Path>;
-//#endregion
-export { stringToPath };
-//# sourceMappingURL=string-to-path.d.ts.map

package/dist/string-to-path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"string-to-path.d.ts","names":[],"sources":["../src/string-to-path.ts"],"sourcesContent":[],"mappings":";;;KASK,kBAGD,gBAAgB,kBACd,iBAAiB,KACjB;KAED,sBAMD,gEACM,aAAa,OAAO,WAAW,aAAa,SAChD,sEACM,aAAa,OAAO,iBAAiB,aAAa,SAGtD,6DAnBH,GAqBU,YArBE,CAqBW,IArBX,CAAA,EAGG,GAmBL,YAnBK,CAmBQ,QAnBR,CAAA,EAAhB,GAoBW,YApBX,CAoBwB,IApBxB,CAAA,CACmB,GAwBb,CAxBa,SAAA,GAAA,KAAA,KAAA,IAAA,KAAA,KAAA,EAAA,GAAA,CAAA,GAyBP,YAzBO,CAyBM,IAzBN,CAAA,EAAA,GAyBgB,YAzBhB,CAyB6B,IAzB7B,CAAA,CAAA,GAAA,EAAA,SA2BA,CA3BA,GAAA,EAAA,GAsCT,CAtCS,SAAA,GAAA,KAAA,WAAA,MAAA,EAAA,GAAA,CA4CL,gBA5CZ,CA4C6B,CA5C7B,CAAA,SAAA,IAAA,GAAA,CAAA,GA4CmD,CA5CnD,CACA,GAAA,CA8CW,CA9CX,CAAA;;AAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2C8C,iBAmCzC,YAnCyC,CAAA,mBAAA,MAAA,CAAA,CAAA,IAAA,EAoCjD,IApCiD,CAAA,EAqCtD,YArCsD,CAqCzC,IArCyC,CAAA"}

package/dist/subtract.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.d.cts.map

package/dist/subtract.d.cts.map

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

package/dist/subtract.d.ts

@@ -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.d.ts.map

package/dist/subtract.d.ts.map

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

package/dist/sum-by.d.cts

@@ -1,57 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.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.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sum-by.d.cts","names":[],"sources":["../src/sum-by.ts"],"sourcesContent":[],"mappings":";;;KAGK,gBACO,gDAER,4BAEA,gCAAgC,0BAC9B,QACI;;AAVmE;;;;;;;;AAmC7E;;;;;;;;AAGA;;;;;;AAEiB,iBALD,KAKC,CAAA,UALe,iBAKf,CAAA,CAAA,UAAA,EAAA,CAAA,KAAA,EAJK,CAIL,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAJqC,CAIrC,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EAHN,CAGM,EAAA,GAHA,KAGA,CAHM,CAGN,EAAA,MAAA,CAAA;AAAK,iBAFN,KAEM,CAAA,UAFU,iBAEV,CAAA,CAAA,UAAA,EAAA,CAAA,KAAA,EADA,CACA,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADgC,CAChC,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EAAX,CAAW,EAAA,GAAL,KAAK,CAAC,CAAD,EAAA,MAAA,CAAA;AAyBtB;;;;;;;;AAIA;;;;;;;;;;;;;;;iBAJgB,gBAAgB,yBACxB,uBACc,gCAAgC,eACnD,MAAM;iBACO,gBAAgB,yBACxB,uBACc,gCAAgC,eACnD,MAAM"}

package/dist/sum-by.d.ts

@@ -1,57 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-Dv5vSKht.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.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sum-by.d.ts","names":[],"sources":["../src/sum-by.ts"],"sourcesContent":[],"mappings":";;;KAGK,gBACO,gDAER,4BAEA,gCAAgC,0BAC9B,QACI;;AAVmE;;;;;;;;AAmC7E;;;;;;;;AAGA;;;;;;AAEiB,iBALD,KAKC,CAAA,UALe,iBAKf,CAAA,CAAA,UAAA,EAAA,CAAA,KAAA,EAJK,CAIL,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAJqC,CAIrC,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EAHN,CAGM,EAAA,GAHA,KAGA,CAHM,CAGN,EAAA,MAAA,CAAA;AAAK,iBAFN,KAEM,CAAA,UAFU,iBAEV,CAAA,CAAA,UAAA,EAAA,CAAA,KAAA,EADA,CACA,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADgC,CAChC,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EAAX,CAAW,EAAA,GAAL,KAAK,CAAC,CAAD,EAAA,MAAA,CAAA;AAyBtB;;;;;;;;AAIA;;;;;;;;;;;;;;;iBAJgB,gBAAgB,yBACxB,uBACc,gCAAgC,eACnD,MAAM;iBACO,gBAAgB,yBACxB,uBACc,gCAAgC,eACnD,MAAM"}

package/dist/sum.d.cts

@@ -1,50 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.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.d.cts.map

package/dist/sum.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sum.d.cts","names":[],"sources":["../src/sum.ts"],"sourcesContent":[],"mappings":";;;KAIK,cAAc,4BAA4B,6BAE3C,4BAGE,+BAA+B,mCAG7B;;AAZqE;;;;;;;;AAsC7E;;;;;;;AAwBA;;;;;AAIK,iBA5BW,GA4BX,CAAA,UA3BO,iBA2BP,CAAA,MAAA,CAAA,GA3BmC,iBA2BnC,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EA1BG,CA0BH,CAAA,EA1BO,GA0BP,CA1BW,CA0BX,CAAA;;;;;;;;;;;;;;;;;;;;;iBAJW,GAAA,CAAA,cACJ,4BAA4B,iCAEhC,MACH,IAAI"}

package/dist/sum.d.ts

@@ -1,50 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-Dv5vSKht.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.d.ts.map

package/dist/sum.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sum.d.ts","names":[],"sources":["../src/sum.ts"],"sourcesContent":[],"mappings":";;;KAIK,cAAc,4BAA4B,6BAE3C,4BAGE,+BAA+B,mCAG7B;;AAZqE;;;;;;;;AAsC7E;;;;;;;AAwBA;;;;;AAIK,iBA5BW,GA4BX,CAAA,UA3BO,iBA2BP,CAAA,MAAA,CAAA,GA3BmC,iBA2BnC,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EA1BG,CA0BH,CAAA,EA1BO,GA0BP,CA1BW,CA0BX,CAAA;;;;;;;;;;;;;;;;;;;;;iBAJW,GAAA,CAAA,cACJ,4BAA4B,iCAEhC,MACH,IAAI"}

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"swap-in-place-C_jXKHuD.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-indices.d.cts

@@ -1,61 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.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.d.cts.map

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

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

package/dist/swap-indices.d.ts

@@ -1,61 +0,0 @@
-import { t as IterableContainer } from "./iterable-container-Dv5vSKht.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.d.ts.map

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

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