@vinicunca/perkakas 0.5.4 → 1.0.1

package/dist/split.d.cts

@@ -0,0 +1,60 @@
+import { IsFloat, ArraySlice, Split as Split$1, NonNegative } from 'type-fest';
+
+type Split<S extends string, Separator extends string, N extends number | undefined = undefined> = string extends S ? Array<string> : string extends Separator ? Array<string> : number extends N ? Array<string> : IsFloat<N> extends true ? Array<string> : ArraySlice<Split$1<S, Separator>, 0, N extends number ? NonNegative<N> : never>;
+/**
+ * Takes a pattern and divides this string into an ordered list of substrings by
+ * searching for the pattern, puts these substrings into an array, and returns
+ * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+ * method.
+ *
+ * @param data - The string to split.
+ * @param separator - The pattern describing where each split should occur. Can
+ * be a string, or a regular expression.
+ * @param limit - A non-negative integer specifying a limit on the number of
+ * substrings to be included in the array. If provided, splits the string at
+ * each occurrence of the specified separator, but stops when limit entries have
+ * been placed in the array. Any leftover text is not included in the array at
+ * all. The array may contain fewer entries than limit if the end of the string
+ * is reached before the limit is reached. If limit is 0, [] is returned.
+ * @returns An Array of strings, split at each point where the separator occurs
+ * in the given string.
+ * @signature
+ *   R.split(data, separator, limit);
+ * @example
+ *   R.split("a,b,c", ","); //=> ["a", "b", "c"]
+ *   R.split("a,b,c", ",", 2); //=> ["a", "b"]
+ *   R.split("a1b2c3d", /\d/u); //=> ["a", "b", "c", "d"]
+ * @dataFirst
+ * @category String
+ */
+declare function split(data: string, separator: RegExp, limit?: number): Array<string>;
+declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(data: S, separator: Separator, limit?: N): Split<S, Separator, N>;
+/**
+ * Takes a pattern and divides this string into an ordered list of substrings by
+ * searching for the pattern, puts these substrings into an array, and returns
+ * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+ * method.
+ *
+ * @param separator - The pattern describing where each split should occur. Can
+ * be a string, or a regular expression.
+ * @param limit - A non-negative integer specifying a limit on the number of
+ * substrings to be included in the array. If provided, splits the string at
+ * each occurrence of the specified separator, but stops when limit entries have
+ * been placed in the array. Any leftover text is not included in the array at
+ * all. The array may contain fewer entries than limit if the end of the string
+ * is reached before the limit is reached. If limit is 0, [] is returned.
+ * @returns An Array of strings, split at each point where the separator occurs
+ * in the given string.
+ * @signature
+ *   R.split(separator, limit)(data);
+ * @example
+ *   R.pipe("a,b,c", R.split(",")); //=> ["a", "b", "c"]
+ *   R.pipe("a,b,c", R.split(",", 2)); //=> ["a", "b"]
+ *   R.pipe("a1b2c3d", R.split(/\d/u)); //=> ["a", "b", "c", "d"]
+ * @dataLast
+ * @category String
+ */
+declare function split(separator: RegExp, limit?: number): (data: string) => Array<string>;
+declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(separator: Separator, limit?: N): (data: S) => Split<S, Separator, N>;
+
+export { split };

package/dist/split.d.ts

@@ -0,0 +1,60 @@
+import { IsFloat, ArraySlice, Split as Split$1, NonNegative } from 'type-fest';
+
+type Split<S extends string, Separator extends string, N extends number | undefined = undefined> = string extends S ? Array<string> : string extends Separator ? Array<string> : number extends N ? Array<string> : IsFloat<N> extends true ? Array<string> : ArraySlice<Split$1<S, Separator>, 0, N extends number ? NonNegative<N> : never>;
+/**
+ * Takes a pattern and divides this string into an ordered list of substrings by
+ * searching for the pattern, puts these substrings into an array, and returns
+ * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+ * method.
+ *
+ * @param data - The string to split.
+ * @param separator - The pattern describing where each split should occur. Can
+ * be a string, or a regular expression.
+ * @param limit - A non-negative integer specifying a limit on the number of
+ * substrings to be included in the array. If provided, splits the string at
+ * each occurrence of the specified separator, but stops when limit entries have
+ * been placed in the array. Any leftover text is not included in the array at
+ * all. The array may contain fewer entries than limit if the end of the string
+ * is reached before the limit is reached. If limit is 0, [] is returned.
+ * @returns An Array of strings, split at each point where the separator occurs
+ * in the given string.
+ * @signature
+ *   R.split(data, separator, limit);
+ * @example
+ *   R.split("a,b,c", ","); //=> ["a", "b", "c"]
+ *   R.split("a,b,c", ",", 2); //=> ["a", "b"]
+ *   R.split("a1b2c3d", /\d/u); //=> ["a", "b", "c", "d"]
+ * @dataFirst
+ * @category String
+ */
+declare function split(data: string, separator: RegExp, limit?: number): Array<string>;
+declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(data: S, separator: Separator, limit?: N): Split<S, Separator, N>;
+/**
+ * Takes a pattern and divides this string into an ordered list of substrings by
+ * searching for the pattern, puts these substrings into an array, and returns
+ * the array. This function mirrors the built-in [`String.prototype.split`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split)
+ * method.
+ *
+ * @param separator - The pattern describing where each split should occur. Can
+ * be a string, or a regular expression.
+ * @param limit - A non-negative integer specifying a limit on the number of
+ * substrings to be included in the array. If provided, splits the string at
+ * each occurrence of the specified separator, but stops when limit entries have
+ * been placed in the array. Any leftover text is not included in the array at
+ * all. The array may contain fewer entries than limit if the end of the string
+ * is reached before the limit is reached. If limit is 0, [] is returned.
+ * @returns An Array of strings, split at each point where the separator occurs
+ * in the given string.
+ * @signature
+ *   R.split(separator, limit)(data);
+ * @example
+ *   R.pipe("a,b,c", R.split(",")); //=> ["a", "b", "c"]
+ *   R.pipe("a,b,c", R.split(",", 2)); //=> ["a", "b"]
+ *   R.pipe("a1b2c3d", R.split(/\d/u)); //=> ["a", "b", "c", "d"]
+ * @dataLast
+ * @category String
+ */
+declare function split(separator: RegExp, limit?: number): (data: string) => Array<string>;
+declare function split<S extends string, Separator extends string, N extends number | undefined = undefined>(separator: Separator, limit?: N): (data: S) => Split<S, Separator, N>;
+
+export { split };

package/dist/split.js

@@ -0,0 +1 @@
+import{a}from"./chunk-RBODUO3Q.js";export{a as split};

package/dist/string-to-path.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkVRZNQSZNcjs = require('./chunk-VRZNQSZN.cjs');exports.stringToPath = _chunkVRZNQSZNcjs.a;

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

@@ -0,0 +1,22 @@
+type StringToPath<T extends string> = string extends T ? never : T extends '' ? [] : T extends `${infer Head}[${infer Nest}].${infer Tail}` ? [...StringToPath<Head>, Nest, ...StringToPath<Tail>] : T extends `${infer Head}[${infer Nest}]` ? [...StringToPath<Head>, Nest] : T extends `${infer Head}.${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Tail>] : [T];
+/**
+ * Converts a path string to an array of string keys (including array index
+ * access keys).
+ *
+ * ! IMPORTANT: Attempting to pass a simple `string` type will result in the
+ * result being inferred as `never`. This is intentional to help with type-
+ * safety as this function is primarily intended to help with other "object path
+ * access" functions like `pathOr` or `setPath`.
+ *
+ * @param path - A string path.
+ *
+ * @signature
+ *    P.stringToPathArray(path)
+ * @example
+ *    P.stringToPathArray('a.b[0].c') // => ['a', 'b', '0', 'c']
+ * @dataFirst
+ * @category Utility
+ */
+declare function stringToPath<Path extends string>(path: Path): StringToPath<Path>;
+
+export { stringToPath };

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

@@ -0,0 +1,22 @@
+type StringToPath<T extends string> = string extends T ? never : T extends '' ? [] : T extends `${infer Head}[${infer Nest}].${infer Tail}` ? [...StringToPath<Head>, Nest, ...StringToPath<Tail>] : T extends `${infer Head}[${infer Nest}]` ? [...StringToPath<Head>, Nest] : T extends `${infer Head}.${infer Tail}` ? [...StringToPath<Head>, ...StringToPath<Tail>] : [T];
+/**
+ * Converts a path string to an array of string keys (including array index
+ * access keys).
+ *
+ * ! IMPORTANT: Attempting to pass a simple `string` type will result in the
+ * result being inferred as `never`. This is intentional to help with type-
+ * safety as this function is primarily intended to help with other "object path
+ * access" functions like `pathOr` or `setPath`.
+ *
+ * @param path - A string path.
+ *
+ * @signature
+ *    P.stringToPathArray(path)
+ * @example
+ *    P.stringToPathArray('a.b[0].c') // => ['a', 'b', '0', 'c']
+ * @dataFirst
+ * @category Utility
+ */
+declare function stringToPath<Path extends string>(path: Path): StringToPath<Path>;
+
+export { stringToPath };

package/dist/string-to-path.js

@@ -0,0 +1 @@
+import{a}from"./chunk-CZLV6ZLZ.js";export{a as stringToPath};

package/dist/subtract.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkJMS6POBOcjs = require('./chunk-JMS6POBO.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.subtract = _chunkJMS6POBOcjs.a;

package/dist/subtract.d.cts

@@ -0,0 +1,33 @@
+/**
+ * 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;
+
+export { subtract };

package/dist/subtract.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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;
+
+export { subtract };

package/dist/subtract.js

@@ -0,0 +1 @@
+import{a}from"./chunk-AEN2DN32.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as subtract};

package/dist/sum-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkCGK7KN32cjs = require('./chunk-CGK7KN32.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.sumBy = _chunkCGK7KN32cjs.a;

package/dist/sum-by.d.cts

@@ -0,0 +1,33 @@
+/**
+ * Returns the sum of the elements of an array using the provided predicate.
+ *
+ * @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>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => number): (items: ReadonlyArray<T>) => number;
+/**
+ * Returns the sum of the elements of an array using the provided predicate.
+ *
+ * @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>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => number): number;
+
+export { sumBy };

package/dist/sum-by.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Returns the sum of the elements of an array using the provided predicate.
+ *
+ * @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>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => number): (items: ReadonlyArray<T>) => number;
+/**
+ * Returns the sum of the elements of an array using the provided predicate.
+ *
+ * @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>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => number): number;
+
+export { sumBy };

package/dist/sum-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-ZX74SXNB.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as sumBy};

package/dist/sum.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk6TRXWRYJcjs = require('./chunk-6TRXWRYJ.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.sum = _chunk6TRXWRYJcjs.a;

package/dist/sum.d.cts

@@ -0,0 +1,49 @@
+import { I as IterableContainer } from './types-BMu1PIvo.cjs';
+import 'type-fest';
+
+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>;
+
+export { sum };

package/dist/sum.d.ts

@@ -0,0 +1,49 @@
+import { I as IterableContainer } from './types-BMu1PIvo.js';
+import 'type-fest';
+
+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>;
+
+export { sum };

package/dist/sum.js

@@ -0,0 +1 @@
+import{a}from"./chunk-2T576V7A.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as sum};

package/dist/swap-indices.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkGIJKULXCcjs = require('./chunk-GIJKULXC.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.swapIndices = _chunkGIJKULXCcjs.a;

package/dist/swap-indices.d.cts

@@ -0,0 +1,64 @@
+import { Join } from 'type-fest';
+import { I as IterableContainer } from './types-BMu1PIvo.cjs';
+
+/**
+ * @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) // => ['c', 'b', 'a']
+ *   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>;
+
+export { swapIndices };

package/dist/swap-indices.d.ts

@@ -0,0 +1,64 @@
+import { Join } from 'type-fest';
+import { I as IterableContainer } from './types-BMu1PIvo.js';
+
+/**
+ * @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) // => ['c', 'b', 'a']
+ *   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>;
+
+export { swapIndices };

package/dist/swap-indices.js

@@ -0,0 +1 @@
+import{a}from"./chunk-FKSROXF4.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as swapIndices};

package/dist/swap-props.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkKBGFDQ5Tcjs = require('./chunk-KBGFDQ5T.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.swapProps = _chunkKBGFDQ5Tcjs.a;

package/dist/swap-props.d.cts

@@ -0,0 +1,34 @@
+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>;
+
+export { swapProps };

package/dist/swap-props.d.ts

@@ -0,0 +1,34 @@
+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>;
+
+export { swapProps };

package/dist/swap-props.js

@@ -0,0 +1 @@
+import{a}from"./chunk-3T7K3EKS.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as swapProps};