@vinicunca/perkakas 1.7.1 → 1.8.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"swap-indices-KQ4fsLkb.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.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkIVO53H3Jcjs = require('./chunk-IVO53H3J.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.swapIndices = _chunkIVO53H3Jcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./swap-indices-CRAsQaXi.cjs`);exports.swapIndices=e.swapIndices;

package/dist/swap-indices.d.cts

@@ -1,64 +1,3 @@
-import { Join } from 'type-fest';
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.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) // => ['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>;
-
-export { swapIndices };
+import "./iterable-container-V5sa0V_H.cjs";
+import { swapIndices } from "./swap-indices-KQ4fsLkb.cjs";
+export { swapIndices };

package/dist/swap-indices.d.ts

@@ -1,64 +1,3 @@
-import { Join } from 'type-fest';
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.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) // => ['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>;
-
-export { swapIndices };
+import "./iterable-container-wtkYslN_.js";
+import { swapIndices } from "./swap-indices-CdclLgV-.js";
+export { swapIndices };

package/dist/swap-indices.js

@@ -1 +1 @@
-import{a}from"./chunk-CL7YONGV.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as swapIndices};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{swapIndices as e}from"./swap-indices-CMgMD_dW.js";export{e as swapIndices};

package/dist/swap-props-BQ2a9nZO.cjs

@@ -0,0 +1 @@
+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/swap-props-D-buo88H.d.ts

@@ -0,0 +1,34 @@
+//#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-D-buo88H.d.ts.map

package/dist/swap-props-D-buo88H.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap-props-D-buo88H.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-D7be4C3M.d.cts

@@ -0,0 +1,34 @@
+//#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-D7be4C3M.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swap-props-D7be4C3M.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-sxLIvQ4Y.js

@@ -0,0 +1,2 @@
+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-sxLIvQ4Y.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"swap-props-sxLIvQ4Y.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.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkZ6K5VISMcjs = require('./chunk-Z6K5VISM.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.swapProps = _chunkZ6K5VISMcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./swap-props-BQ2a9nZO.cjs`);exports.swapProps=e.swapProps;

package/dist/swap-props.d.cts

@@ -1,34 +1,2 @@
-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 };
+import { swapProps } from "./swap-props-D7be4C3M.cjs";
+export { swapProps };

package/dist/swap-props.d.ts

@@ -1,34 +1,2 @@
-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 };
+import { swapProps } from "./swap-props-D-buo88H.js";
+export { swapProps };

package/dist/swap-props.js

@@ -1 +1 @@
-import{a}from"./chunk-RLJFMTDS.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as swapProps};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{swapProps as e}from"./swap-props-sxLIvQ4Y.js";export{e as swapProps};

package/dist/take-BV-ctBqK.d.cts

@@ -0,0 +1,34 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+
+//#region src/take.d.ts
+
+/**
+ * Returns the first `n` elements of `array`.
+ *
+ * @param array - The array.
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.take(array, n)
+ * @example
+ *    P.take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function take<T extends IterableContainer>(array: T, n: number): Array<T[number]>;
+/**
+ * Returns the first `n` elements of `array`.
+ *
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.take(n)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.take(n)) // => [1, 2, 3]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function take(n: number): <T extends IterableContainer>(array: T) => Array<T[number]>;
+//#endregion
+export { take };
+//# sourceMappingURL=take-BV-ctBqK.d.cts.map

package/dist/take-BV-ctBqK.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-BV-ctBqK.d.cts","names":[],"sources":["../src/take.ts"],"sourcesContent":[],"mappings":";;;;;;AAmBA;;;;;;;AAiBA;;;;AAEoD,iBAnBpC,IAmBoC,CAAA,UAnBrB,iBAmBqB,CAAA,CAAA,KAAA,EAlB3C,CAkB2C,EAAA,CAAA,EAAA,MAAA,CAAA,EAhBjD,KAgBiD,CAhB3C,CAgB2C,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;iBAFpC,IAAA,wBAEF,0BAA0B,MAAM,MAAM"}

package/dist/take-Cn0xLGe4.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";import{lazyEmptyEvaluator as t}from"./utility-evaluators-CnQVdcZv.js";function n(...t){return e(r,t,i)}function r(e,t){return t<0?[]:e.slice(0,t)}function i(e){if(e<=0)return t;let n=e;return e=>(--n,{done:n<=0,hasNext:!0,next:e})}export{n as take};
+//# sourceMappingURL=take-Cn0xLGe4.js.map

package/dist/take-Cn0xLGe4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-Cn0xLGe4.js","names":[],"sources":["../src/take.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curry } from './curry';\nimport { lazyEmptyEvaluator } from './internal/utility-evaluators';\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param array - The array.\n * @param n - The number of elements to take.\n * @signature\n *    P.take(array, n)\n * @example\n *    P.take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function take<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]>;\n\n/**\n * Returns the first `n` elements of `array`.\n *\n * @param n - The number of elements to take.\n * @signature\n *    P.take(n)(array)\n * @example\n *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.take(n)) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function take(\n  n: number,\n): <T extends IterableContainer>(array: T) => Array<T[number]>;\n\nexport function take(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeImplementation, args, lazyImplementation);\n}\n\nfunction takeImplementation<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]> {\n  return n < 0 ? [] : array.slice(0, n);\n}\n\nfunction lazyImplementation<T>(n: number): LazyEvaluator<T> {\n  if (n <= 0) {\n    return lazyEmptyEvaluator;\n  }\n\n  let remaining = n;\n  return (value) => {\n    remaining -= 1;\n    return { done: remaining <= 0, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kHAwCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,EAAmB,CAG5D,SAAS,EACP,EACA,EACkB,CAClB,OAAO,EAAI,EAAI,EAAE,CAAG,EAAM,MAAM,EAAG,EAAE,CAGvC,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAO,EAGT,IAAI,EAAY,EAChB,MAAQ,KACN,IACO,CAAE,KAAM,GAAa,EAAG,QAAS,GAAM,KAAM,EAAO"}

package/dist/take-CnVckkWV.d.ts

@@ -0,0 +1,34 @@
+import { IterableContainer } from "./iterable-container-wtkYslN_.js";
+
+//#region src/take.d.ts
+
+/**
+ * Returns the first `n` elements of `array`.
+ *
+ * @param array - The array.
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.take(array, n)
+ * @example
+ *    P.take([1, 2, 3, 4, 3, 2, 1], 3) // => [1, 2, 3]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function take<T extends IterableContainer>(array: T, n: number): Array<T[number]>;
+/**
+ * Returns the first `n` elements of `array`.
+ *
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.take(n)(array)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.take(n)) // => [1, 2, 3]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function take(n: number): <T extends IterableContainer>(array: T) => Array<T[number]>;
+//#endregion
+export { take };
+//# sourceMappingURL=take-CnVckkWV.d.ts.map

package/dist/take-CnVckkWV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-CnVckkWV.d.ts","names":[],"sources":["../src/take.ts"],"sourcesContent":[],"mappings":";;;;;;AAmBA;;;;;;;AAiBA;;;;AAEoD,iBAnBpC,IAmBoC,CAAA,UAnBrB,iBAmBqB,CAAA,CAAA,KAAA,EAlB3C,CAkB2C,EAAA,CAAA,EAAA,MAAA,CAAA,EAhBjD,KAgBiD,CAhB3C,CAgB2C,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;iBAFpC,IAAA,wBAEF,0BAA0B,MAAM,MAAM"}

package/dist/take-DwT7ymnA.cjs

@@ -0,0 +1 @@
+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}});

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

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

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

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

package/dist/take-first-by-BgONSKvT.d.ts

@@ -0,0 +1,41 @@
+import { NonEmptyArray } from "./non-empty-array-D3HWDPMt.js";
+import { OrderRule } from "./curry-order-rules-Cthu8rj4.js";
+
+//#region src/take-first-by.d.ts
+
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @param data - The input array.
+ * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns A subset of the input array.
+ * @signature
+ *   P.takeFirstBy(data, n, ...rules);
+ * @example
+ *   P.takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['a', 'aa']
+ * @dataFirst
+ * @category Array
+ */
+declare function takeFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns A subset of the input array.
+ * @signature
+ *   P.takeFirstBy(n, ...rules)(data);
+ * @example
+ *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.takeFirstBy(2, x => x.length)); // => ['a', 'aa']
+ * @dataLast
+ * @category Array
+ */
+declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+//#endregion
+export { takeFirstBy };
+//# sourceMappingURL=take-first-by-BgONSKvT.d.ts.map

package/dist/take-first-by-BgONSKvT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-first-by-BgONSKvT.d.ts","names":[],"sources":["../src/take-first-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;;;;;;;AAqBA;;;AAEmC,iBAvBnB,WAuBmB,CAAA,CAAA,CAAA,CAAA,IAAA,EAtB3B,aAsB2B,CAtBb,CAsBa,CAAA,EAAA,CAAA,EAAA,MAAA,EAAA,GAAA,KAAA,EApBvB,QAoBuB,CApBd,aAoBc,CApBA,SAoBA,CApBU,CAoBV,CAAA,CAAA,CAAA,CAAA,EAnBhC,KAmBgC,CAnB1B,CAmB0B,CAAA;;;;;;;;;;;;;;;;iBAFnB,oCAEJ,SAAS,cAAc,UAAU,cACnC,cAAc,OAAO,MAAM"}

package/dist/take-first-by-Cpgu4Dll.d.cts

@@ -0,0 +1,41 @@
+import { NonEmptyArray } from "./non-empty-array-D3ZRHApS.cjs";
+import { OrderRule } from "./curry-order-rules-1zjlAgqa.cjs";
+
+//#region src/take-first-by.d.ts
+
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @param data - The input array.
+ * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns A subset of the input array.
+ * @signature
+ *   P.takeFirstBy(data, n, ...rules);
+ * @example
+ *   P.takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['a', 'aa']
+ * @dataFirst
+ * @category Array
+ */
+declare function takeFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
+ *
+ * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
+ * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
+ * @returns A subset of the input array.
+ * @signature
+ *   P.takeFirstBy(n, ...rules)(data);
+ * @example
+ *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.takeFirstBy(2, x => x.length)); // => ['a', 'aa']
+ * @dataLast
+ * @category Array
+ */
+declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+//#endregion
+export { takeFirstBy };
+//# sourceMappingURL=take-first-by-Cpgu4Dll.d.cts.map

package/dist/take-first-by-Cpgu4Dll.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-first-by-Cpgu4Dll.d.cts","names":[],"sources":["../src/take-first-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;;;;;;;AAqBA;;;AAEmC,iBAvBnB,WAuBmB,CAAA,CAAA,CAAA,CAAA,IAAA,EAtB3B,aAsB2B,CAtBb,CAsBa,CAAA,EAAA,CAAA,EAAA,MAAA,EAAA,GAAA,KAAA,EApBvB,QAoBuB,CApBd,aAoBc,CApBA,SAoBA,CApBU,CAoBV,CAAA,CAAA,CAAA,CAAA,EAnBhC,KAmBgC,CAnB1B,CAmB0B,CAAA;;;;;;;;;;;;;;;;iBAFnB,oCAEJ,SAAS,cAAc,UAAU,cACnC,cAAc,OAAO,MAAM"}

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

@@ -0,0 +1 @@
+const e=require(`./curry-order-rules-UcuuWkKd.cjs`),t=require(`./heap-CpdbyWAN.cjs`);function n(...t){return e.curryOrderRulesWithArgument(r,t)}function r(e,n,r){if(r<=0)return[];if(r>=e.length)return[...e];let i=e.slice(0,r);t.heapify(i,n);let a=e.slice(r);for(let e of a)t.heapMaybeInsert(i,n,e);return i}Object.defineProperty(exports,`takeFirstBy`,{enumerable:!0,get:function(){return n}});

package/dist/take-first-by.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkRTFVY5D4cjs = require('./chunk-RTFVY5D4.cjs');require('./chunk-JHFSYEXB.cjs');require('./chunk-Z6OOXW67.cjs');require('./chunk-EROXO3T4.cjs');require('./chunk-66JP4PUG.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.takeFirstBy = _chunkRTFVY5D4cjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./curry-order-rules-UcuuWkKd.cjs`),require(`./has-at-least-D-ahiJB6.cjs`),require(`./swap-in-place-CJrU2n1_.cjs`),require(`./heap-CpdbyWAN.cjs`);const e=require(`./take-first-by-CtrznSxG.cjs`);exports.takeFirstBy=e.takeFirstBy;

package/dist/take-first-by.d.cts

@@ -1,38 +1,4 @@
-import { O as OrderRule } from './curry-order-rules-BKXCPBNx.cjs';
-import { N as NonEmptyArray } from './non-empty-array-C9Od1wmF.cjs';
-
-/**
- * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
- *
- * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
- *
- * @param data - The input array.
- * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns A subset of the input array.
- * @signature
- *   P.takeFirstBy(data, n, ...rules);
- * @example
- *   P.takeFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['a', 'aa']
- * @dataFirst
- * @category Array
- */
-declare function takeFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
-/**
- * Take the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before taking the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
- *
- * For the opposite operation (to drop `n` elements) see `dropFirstBy`.
- *
- * @param n - The number of items to take. If `n` is non-positive no items would be returned, if `n` is bigger then data.length a *clone* of `data` would be returned.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns A subset of the input array.
- * @signature
- *   P.takeFirstBy(n, ...rules)(data);
- * @example
- *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.takeFirstBy(2, x => x.length)); // => ['a', 'aa']
- * @dataLast
- * @category Array
- */
-declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
-
-export { takeFirstBy };
+import "./non-empty-array-D3ZRHApS.cjs";
+import "./curry-order-rules-1zjlAgqa.cjs";
+import { takeFirstBy } from "./take-first-by-Cpgu4Dll.cjs";
+export { takeFirstBy };