@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/swap-indices.d.ts

@@ -1,3 +1,61 @@
-import "./iterable-container-F9CDF7ym.js";
-import { swapIndices } from "./swap-indices-DWsQg1W8.js";
-export { swapIndices };
+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

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

package/dist/swap-indices.js

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

package/dist/swap-indices.js.map

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

package/dist/swap-props.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./swap-props-zfImAv9P.cjs`);exports.swapProps=e.swapProps;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t,n){let{[t]:r,[n]:i}=e;return{...e,[t]:i,[n]:r}}exports.swapProps=t;

package/dist/swap-props.d.cts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"swap-props.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,EAAqB;;;;;;;;;;;;AAkBtC;;;AAIQ,iBAJQ,SAIR,CAAA,UAAA,MAAA,EAAA,WAAA,MAFW,CAEX,EAAA,WAAA,MADW,CACX,CAAA,CAAA,IAAA,EAAA,CAAA,EAAA,IAAA,EAAS,EAAT,EAAA,IAAA,EAAmB,EAAnB,CAAA,EAAwB,YAAxB,CAAqC,CAArC,EAAwC,EAAxC,EAA4C,EAA5C,CAAA;;;;;;;;AAeR;;;;;;AAIiD,iBAJjC,SAIiC,CAAA,UAAA,MAAA,EAAA,WAAA,MAF9B,CAE8B,EAAA,WAAA,MAD9B,CAC8B,CAAA,CAAA,IAAA,EAAzC,EAAyC,EAAA,IAAA,EAA/B,EAA+B,CAAA,EAAA,CAAA,IAAA,EAAnB,CAAmB,EAAA,GAAb,YAAa,CAAA,CAAA,EAAG,EAAH,EAAO,EAAP,CAAA"}

package/dist/swap-props.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"swap-props.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,EAAqB;;;;;;;;;;;;AAkBtC;;;AAIQ,iBAJQ,SAIR,CAAA,UAAA,MAAA,EAAA,WAAA,MAFW,CAEX,EAAA,WAAA,MADW,CACX,CAAA,CAAA,IAAA,EAAA,CAAA,EAAA,IAAA,EAAS,EAAT,EAAA,IAAA,EAAmB,EAAnB,CAAA,EAAwB,YAAxB,CAAqC,CAArC,EAAwC,EAAxC,EAA4C,EAA5C,CAAA;;;;;;;;AAeR;;;;;;AAIiD,iBAJjC,SAIiC,CAAA,UAAA,MAAA,EAAA,WAAA,MAF9B,CAE8B,EAAA,WAAA,MAD9B,CAC8B,CAAA,CAAA,IAAA,EAAzC,EAAyC,EAAA,IAAA,EAA/B,EAA+B,CAAA,EAAA,CAAA,IAAA,EAAnB,CAAmB,EAAA,GAAb,YAAa,CAAA,CAAA,EAAG,EAAH,EAAO,EAAP,CAAA"}

package/dist/swap-props.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{swapProps as e}from"./swap-props-mp8Z9OU_.js";export{e as swapProps};
+import{t as e}from"./curry-NmniqyJ0.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.js.map

package/dist/swap-props.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap-props.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":"wCA6CA,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/take-first-by.cjs

@@ -1 +1 @@
-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-DpgN2xxt.cjs`);exports.takeFirstBy=e.takeFirstBy;
+const e=require(`./curry-order-rules-ClqHrs8_.cjs`),t=require(`./heap-DWDhbxfx.cjs`);function n(...t){return e.n(r,t)}function r(e,n,r){if(r<=0)return[];if(r>=e.length)return[...e];let i=e.slice(0,r);t.n(i,n);let a=e.slice(r);for(let e of a)t.t(i,n,e);return i}exports.takeFirstBy=n;

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

@@ -1,4 +1,41 @@
-import "./non-empty-array-D3ZRHApS.cjs";
-import "./curry-order-rules-1zjlAgqa.cjs";
-import { takeFirstBy } from "./take-first-by-CBMKdWli.cjs";
-export { takeFirstBy };
+import { t as NonEmptyArray } from "./non-empty-array-NDjbHRjk.cjs";
+import { t as OrderRule } from "./curry-order-rules-BoF09Dq2.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.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-first-by.d.cts","names":[],"sources":["../src/take-first-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;;;;;;AAqBA;;;;AAEY,iBAvBI,WAuBJ,CAAA,CAAA,CAAA,CAAA,IAAA,EAtBJ,aAsBI,CAtBU,CAsBV,CAAA,EAAA,CAAA,EAAA,MAAA,EAAA,GAAA,KAAA,EApBA,QAoBA,CApBS,aAoBT,CApBuB,SAoBvB,CApBiC,CAoBjC,CAAA,CAAA,CAAA,CAAA,EAnBT,KAmBS,CAnBH,CAmBG,CAAA;;;;;;;;;;;;;;;;iBAFI,oCAEJ,SAAS,cAAc,UAAU,cACnC,cAAc,OAAO,MAAM"}

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

@@ -1,4 +1,41 @@
-import "./non-empty-array-BfTfvDYg.js";
-import "./curry-order-rules-D2zI7gpB.js";
-import { takeFirstBy } from "./take-first-by-CHK8ZUbR.js";
-export { takeFirstBy };
+import { t as NonEmptyArray } from "./non-empty-array-DHAKSw6t.js";
+import { t as OrderRule } from "./curry-order-rules-CoO4bk5I.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.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-first-by.d.ts","names":[],"sources":["../src/take-first-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;;;;;;AAqBA;;;;AAEY,iBAvBI,WAuBJ,CAAA,CAAA,CAAA,CAAA,IAAA,EAtBJ,aAsBI,CAtBU,CAsBV,CAAA,EAAA,CAAA,EAAA,MAAA,EAAA,GAAA,KAAA,EApBA,QAoBA,CApBS,aAoBT,CApBuB,SAoBvB,CApBiC,CAoBjC,CAAA,CAAA,CAAA,CAAA,EAnBT,KAmBS,CAnBH,CAmBG,CAAA;;;;;;;;;;;;;;;;iBAFI,oCAEJ,SAAS,cAAc,UAAU,cACnC,cAAc,OAAO,MAAM"}

package/dist/take-first-by.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./curry-order-rules-BuA7D1F4.js";import"./has-at-least-6iRvhsST.js";import"./swap-in-place-BBqaxzzG.js";import"./heap-BrQEhV5W.js";import{takeFirstBy as e}from"./take-first-by-DkMHTJNU.js";export{e as takeFirstBy};
+import{n as e}from"./curry-order-rules-DwrF-_P1.js";import{n as t,t as n}from"./heap-BhpfhYWj.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);t(a,r);let o=e.slice(i);for(let e of o)n(a,r,e);return a}export{r as takeFirstBy};
+//# sourceMappingURL=take-first-by.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-first-by.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":"kGAoDA,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-last-while.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./take-last-while-BX9WWFOz.cjs`);exports.takeLastWhile=e.takeLastWhile;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){for(let n=e.length-1;n>=0;n--)if(!t(e[n],n,e))return e.slice(n+1);return[...e]}exports.takeLastWhile=t;

package/dist/take-last-while.d.cts

@@ -1,3 +1,36 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { takeLastWhile } from "./take-last-while-Cegja0hc.cjs";
-export { takeLastWhile };
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+
+//#region src/take-last-while.d.ts
+
+/**
+ * Returns elements from the end of the array until the predicate returns false.
+ * The returned elements will be in the same order as in the original array.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeLastWhile(data, predicate)
+ * @example
+ *    P.takeLastWhile([1, 2, 10, 3, 4, 5], x => x < 10) // => [3, 4, 5]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeLastWhile<T extends IterableContainer, S extends T[number]>(data: T, predicate: (item: T[number], index: number, data: T) => item is S): Array<S>;
+declare function takeLastWhile<T extends IterableContainer>(data: T, predicate: (item: T[number], index: number, data: T) => boolean): Array<T[number]>;
+/**
+ * Returns elements from the end of the array until the predicate returns false.
+ * The returned elements will be in the same order as in the original array.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeLastWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4, 5], P.takeLastWhile(x => x < 10))  // => [3, 4, 5]
+ * @dataLast
+ * @category Array
+ */
+declare function takeLastWhile<T extends IterableContainer, S extends T[number]>(predicate: (item: T[number], index: number, data: T) => item is S): (array: T) => Array<S>;
+declare function takeLastWhile<T extends IterableContainer>(predicate: (item: T[number], index: number, data: T) => boolean): (data: T) => Array<T[number]>;
+//#endregion
+export { takeLastWhile };
+//# sourceMappingURL=take-last-while.d.cts.map

package/dist/take-last-while.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-last-while.d.cts","names":[],"sources":["../src/take-last-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;;;;AAIA;AAAwC,iBAJxB,aAIwB,CAAA,UAJA,iBAIA,EAAA,UAJ6B,CAI7B,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAHhC,CAGgC,EAAA,SAAA,EAAA,CAAA,IAAA,EAFpB,CAEoB,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAFY,CAEZ,EAAA,GAAA,IAAA,IAF0B,CAE1B,CAAA,EADrC,KACqC,CAD/B,CAC+B,CAAA;AAChC,iBADQ,aACR,CAAA,UADgC,iBAChC,CAAA,CAAA,IAAA,EAAA,CAAA,EAAA,SAAA,EAAA,CAAA,IAAA,EACY,CADZ,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAC4C,CAD5C,EAAA,GAAA,OAAA,CAAA,EAEL,KAFK,CAEC,CAFD,CAAA,MAAA,CAAA,CAAA;;;;;;AAgBR;;;;;;;AAEuB,iBAFP,aAEO,CAAA,UAFiB,iBAEjB,EAAA,UAF8C,CAE9C,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EADH,CACG,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAD6B,CAC7B,EAAA,GAAA,IAAA,IAD2C,CAC3C,CAAA,EAAA,CAAA,KAAA,EAAZ,CAAY,EAAA,GAAN,KAAM,CAAA,CAAA,CAAA;AAAN,iBACD,aADC,CAAA,UACuB,iBADvB,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAEG,CAFH,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAEmC,CAFnC,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAGP,CAHO,EAAA,GAGD,KAHC,CAGK,CAHL,CAAA,MAAA,CAAA,CAAA"}

package/dist/take-last-while.d.ts

@@ -1,3 +1,36 @@
-import "./iterable-container-F9CDF7ym.js";
-import { takeLastWhile } from "./take-last-while-CT3sSTp3.js";
-export { takeLastWhile };
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+
+//#region src/take-last-while.d.ts
+
+/**
+ * Returns elements from the end of the array until the predicate returns false.
+ * The returned elements will be in the same order as in the original array.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeLastWhile(data, predicate)
+ * @example
+ *    P.takeLastWhile([1, 2, 10, 3, 4, 5], x => x < 10) // => [3, 4, 5]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeLastWhile<T extends IterableContainer, S extends T[number]>(data: T, predicate: (item: T[number], index: number, data: T) => item is S): Array<S>;
+declare function takeLastWhile<T extends IterableContainer>(data: T, predicate: (item: T[number], index: number, data: T) => boolean): Array<T[number]>;
+/**
+ * Returns elements from the end of the array until the predicate returns false.
+ * The returned elements will be in the same order as in the original array.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeLastWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4, 5], P.takeLastWhile(x => x < 10))  // => [3, 4, 5]
+ * @dataLast
+ * @category Array
+ */
+declare function takeLastWhile<T extends IterableContainer, S extends T[number]>(predicate: (item: T[number], index: number, data: T) => item is S): (array: T) => Array<S>;
+declare function takeLastWhile<T extends IterableContainer>(predicate: (item: T[number], index: number, data: T) => boolean): (data: T) => Array<T[number]>;
+//#endregion
+export { takeLastWhile };
+//# sourceMappingURL=take-last-while.d.ts.map

package/dist/take-last-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-last-while.d.ts","names":[],"sources":["../src/take-last-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;;;;AAIA;AAAwC,iBAJxB,aAIwB,CAAA,UAJA,iBAIA,EAAA,UAJ6B,CAI7B,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAHhC,CAGgC,EAAA,SAAA,EAAA,CAAA,IAAA,EAFpB,CAEoB,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAFY,CAEZ,EAAA,GAAA,IAAA,IAF0B,CAE1B,CAAA,EADrC,KACqC,CAD/B,CAC+B,CAAA;AAChC,iBADQ,aACR,CAAA,UADgC,iBAChC,CAAA,CAAA,IAAA,EAAA,CAAA,EAAA,SAAA,EAAA,CAAA,IAAA,EACY,CADZ,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAC4C,CAD5C,EAAA,GAAA,OAAA,CAAA,EAEL,KAFK,CAEC,CAFD,CAAA,MAAA,CAAA,CAAA;;;;;;AAgBR;;;;;;;AAEuB,iBAFP,aAEO,CAAA,UAFiB,iBAEjB,EAAA,UAF8C,CAE9C,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EADH,CACG,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAD6B,CAC7B,EAAA,GAAA,IAAA,IAD2C,CAC3C,CAAA,EAAA,CAAA,KAAA,EAAZ,CAAY,EAAA,GAAN,KAAM,CAAA,CAAA,CAAA;AAAN,iBACD,aADC,CAAA,UACuB,iBADvB,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAEG,CAFH,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAEmC,CAFnC,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAGP,CAHO,EAAA,GAGD,KAHC,CAGK,CAHL,CAAA,MAAA,CAAA,CAAA"}

package/dist/take-last-while.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{takeLastWhile as e}from"./take-last-while-t3GonJ5e.js";export{e as takeLastWhile};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){for(let n=e.length-1;n>=0;n--)if(!t(e[n],n,e))return e.slice(n+1);return[...e]}export{t as takeLastWhile};
+//# sourceMappingURL=take-last-while.js.map

package/dist/take-last-while.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-last-while.js","names":[],"sources":["../src/take-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\n\nimport { curry } from './curry';\n\n/**\n * Returns elements from the end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    P.takeLastWhile(data, predicate)\n * @example\n *    P.takeLastWhile([1, 2, 10, 3, 4, 5], x => x < 10) // => [3, 4, 5]\n * @dataFirst\n * @category Array\n */\nexport function takeLastWhile<T extends IterableContainer, S extends T[number]>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): Array<S>;\nexport function takeLastWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]>;\n\n/**\n * Returns elements from the end of the array until the predicate returns false.\n * The returned elements will be in the same order as in the original array.\n *\n * @param predicate - The predicate.\n * @signature\n *    P.takeLastWhile(predicate)(data)\n * @example\n *    P.pipe([1, 2, 10, 3, 4, 5], P.takeLastWhile(x => x < 10))  // => [3, 4, 5]\n * @dataLast\n * @category Array\n */\nexport function takeLastWhile<T extends IterableContainer, S extends T[number]>(\n  predicate: (item: T[number], index: number, data: T) => item is S,\n): (array: T) => Array<S>;\nexport function takeLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => Array<T[number]>;\n\nexport function takeLastWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeLastWhileImplementation, args);\n}\n\nfunction takeLastWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  for (let i = data.length - 1; i >= 0; i--) {\n    if (!predicate(data[i], i, data)) {\n      return data.slice(i + 1);\n    }\n  }\n  return [...data];\n}\n"],"mappings":"wCA6CA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,EAAK,CAGjD,SAAS,EACP,EACA,EACkB,CAClB,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,CAAC,EAAU,EAAK,GAAI,EAAG,EAAK,CAC9B,OAAO,EAAK,MAAM,EAAI,EAAE,CAG5B,MAAO,CAAC,GAAG,EAAK"}

package/dist/take-last.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./take-last-C8Ig0Lip.cjs`);exports.takeLast=e.takeLast;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return t>0?e.slice(Math.max(0,e.length-t)):[]}exports.takeLast=t;

package/dist/take-last.d.cts

@@ -1,3 +1,32 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { takeLast } from "./take-last-BHz1vsOl.cjs";
-export { takeLast };
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+
+//#region src/take-last.d.ts
+
+/**
+ * Takes the last `n` elements from the `array`.
+ *
+ * @param array - The target array.
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.takeLast(array, n)
+ * @example
+ *    P.takeLast([1, 2, 3, 4, 5], 2) // => [4, 5]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeLast<T extends IterableContainer>(array: T, n: number): Array<T[number]>;
+/**
+ * Take the last `n` elements from the `array`.
+ *
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.takeLast(n)(array)
+ * @example
+ *    P.takeLast(2)([1, 2, 3, 4, 5]) // => [4, 5]
+ * @dataLast
+ * @category Array
+ */
+declare function takeLast<T extends IterableContainer>(n: number): (array: T) => Array<T[number]>;
+//#endregion
+export { takeLast };
+//# sourceMappingURL=take-last.d.cts.map

package/dist/take-last.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-last.d.cts","names":[],"sources":["../src/take-last.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;AAeA;;;;AAEiB,iBAjBD,QAiBC,CAAA,UAjBkB,iBAiBlB,CAAA,CAAA,KAAA,EAhBR,CAgBQ,EAAA,CAAA,EAAA,MAAA,CAAA,EAdd,KAcc,CAdR,CAcQ,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;iBAFD,mBAAmB,uCAExB,MAAM,MAAM"}

package/dist/take-last.d.ts

@@ -1,3 +1,32 @@
-import "./iterable-container-F9CDF7ym.js";
-import { takeLast } from "./take-last-F6ZCTILY.js";
-export { takeLast };
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+
+//#region src/take-last.d.ts
+
+/**
+ * Takes the last `n` elements from the `array`.
+ *
+ * @param array - The target array.
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.takeLast(array, n)
+ * @example
+ *    P.takeLast([1, 2, 3, 4, 5], 2) // => [4, 5]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeLast<T extends IterableContainer>(array: T, n: number): Array<T[number]>;
+/**
+ * Take the last `n` elements from the `array`.
+ *
+ * @param n - The number of elements to take.
+ * @signature
+ *    P.takeLast(n)(array)
+ * @example
+ *    P.takeLast(2)([1, 2, 3, 4, 5]) // => [4, 5]
+ * @dataLast
+ * @category Array
+ */
+declare function takeLast<T extends IterableContainer>(n: number): (array: T) => Array<T[number]>;
+//#endregion
+export { takeLast };
+//# sourceMappingURL=take-last.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-last.d.ts","names":[],"sources":["../src/take-last.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;AAeA;;;;AAEiB,iBAjBD,QAiBC,CAAA,UAjBkB,iBAiBlB,CAAA,CAAA,KAAA,EAhBR,CAgBQ,EAAA,CAAA,EAAA,MAAA,CAAA,EAdd,KAcc,CAdR,CAcQ,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;iBAFD,mBAAmB,uCAExB,MAAM,MAAM"}

package/dist/take-last.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{takeLast as e}from"./take-last-BySlnmMM.js";export{e as takeLast};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return t>0?e.slice(Math.max(0,e.length-t)):[]}export{t as takeLast};
+//# sourceMappingURL=take-last.js.map

package/dist/take-last.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-last.js","names":[],"sources":["../src/take-last.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\n\nimport { curry } from './curry';\n\n/**\n * Takes the last `n` elements from the `array`.\n *\n * @param array - The target array.\n * @param n - The number of elements to take.\n * @signature\n *    P.takeLast(array, n)\n * @example\n *    P.takeLast([1, 2, 3, 4, 5], 2) // => [4, 5]\n * @dataFirst\n * @category Array\n */\nexport function takeLast<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]>;\n/**\n * Take the last `n` elements from the `array`.\n *\n * @param n - The number of elements to take.\n * @signature\n *    P.takeLast(n)(array)\n * @example\n *    P.takeLast(2)([1, 2, 3, 4, 5]) // => [4, 5]\n * @dataLast\n * @category Array\n */\nexport function takeLast<T extends IterableContainer>(\n  n: number,\n): (array: T) => Array<T[number]>;\n\nexport function takeLast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(takeLastImplementation, args);\n}\n\nfunction takeLastImplementation<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]> {\n  return n > 0 ? array.slice(Math.max(0, array.length - n)) : [];\n}\n"],"mappings":"wCAmCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACkB,CAClB,OAAO,EAAI,EAAI,EAAM,MAAM,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,EAAE"}

package/dist/take-while.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./take-while-ygIVi5-P.cjs`);exports.takeWhile=e.takeWhile;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n=[];for(let[r,i]of e.entries()){if(!t(i,r,e))break;n.push(i)}return n}exports.takeWhile=t;

package/dist/take-while.d.cts

@@ -1,3 +1,34 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { takeWhile } from "./take-while--cm-kJ_K.cjs";
-export { takeWhile };
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+
+//#region src/take-while.d.ts
+
+/**
+ * Returns elements from the array until predicate returns false.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeWhile(data, predicate)
+ * @example
+ *    P.takeWhile([1, 2, 3, 4, 3, 2, 1], x => x !== 4) // => [1, 2, 3]
+ * @dataFirst
+ * @category Array
+ */
+declare function takeWhile<T extends IterableContainer, S extends T[number]>(data: T, predicate: (item: T[number], index: number, data: T) => item is S): Array<S>;
+declare function takeWhile<T extends IterableContainer>(data: T, predicate: (item: T[number], index: number, data: T) => boolean): Array<T[number]>;
+/**
+ * Returns elements from the array until predicate returns false.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.takeWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 3, 4, 3, 2, 1], P.takeWhile(x => x !== 4))  // => [1, 2, 3]
+ * @dataLast
+ * @category Array
+ */
+declare function takeWhile<T extends IterableContainer, S extends T[number]>(predicate: (item: T[number], index: number, data: T) => item is S): (array: T) => Array<S>;
+declare function takeWhile<T extends IterableContainer>(predicate: (item: T[number], index: number, data: T) => boolean): (array: T) => Array<T[number]>;
+//#endregion
+export { takeWhile };
+//# sourceMappingURL=take-while.d.cts.map

package/dist/take-while.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.d.cts","names":[],"sources":["../src/take-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;;;;;AAIgB,iBAJA,SAIS,CAAA,UAJW,iBAIX,EAAA,UAJwC,CAIxC,CAAA,MAAA,CAAA,CAAA,CAAA,IAAA,EAHjB,CAGiB,EAAA,SAAA,EAAA,CAAA,IAAA,EAFL,CAEK,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAF2B,CAE3B,EAAA,GAAA,IAAA,IAFyC,CAEzC,CAAA,EADtB,KACsB,CADhB,CACgB,CAAA;AAAW,iBAApB,SAAoB,CAAA,UAAA,iBAAA,CAAA,CAAA,IAAA,EAC5B,CAD4B,EAAA,SAAA,EAAA,CAAA,IAAA,EAEhB,CAFgB,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAEgB,CAFhB,EAAA,GAAA,OAAA,CAAA,EAGjC,KAHiC,CAG3B,CAH2B,CAAA,MAAA,CAAA,CAAA;;;;;;;AAgBpC;;;;;AACkE,iBADlD,SACkD,CAAA,UAD9B,iBAC8B,EAAA,UADD,CACC,CAAA,MAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAA9C,CAA8C,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAAd,CAAc,EAAA,GAAA,IAAA,IAAA,CAAA,CAAA,EAAA,CAAA,KAAA,EACvD,CADuD,EAAA,GACjD,KADiD,CAC3C,CAD2C,CAAA;AACvD,iBACK,SADL,CAAA,UACyB,iBADzB,CAAA,CAAA,SAAA,EAAA,CAAA,IAAA,EAES,CAFT,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAEyC,CAFzC,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,KAAA,EAGA,CAHA,EAAA,GAGM,KAHN,CAGY,CAHZ,CAAA,MAAA,CAAA,CAAA"}