@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/divide.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./divide-ZFT5ZqJ0.cjs`);exports.divide=e.divide;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return e/t}exports.divide=t;

package/dist/divide.d.cts

@@ -1,2 +1,33 @@
-import { divide } from "./divide-C8COFm-b.cjs";
-export { divide };
+//#region src/divide.d.ts
+/**
+ * Divides two numbers.
+ *
+ * @param value - The number.
+ * @param divisor - The number to divide the value by.
+ * @signature
+ *    P.divide(value, divisor);
+ * @example
+ *    P.divide(12, 3) // => 4
+ *    P.reduce([1, 2, 3, 4], P.divide, 24) // => 1
+ * @dataFirst
+ * @category Number
+ */
+declare function divide(value: bigint, divisor: bigint): bigint;
+declare function divide(value: number, divisor: number): number;
+/**
+ * Divides two numbers.
+ *
+ * @param divisor - The number to divide the value by.
+ * @signature
+ *    P.divide(divisor)(value);
+ * @example
+ *    P.divide(3)(12) // => 4
+ *    P.map([2, 4, 6, 8], P.divide(2)) // => [1, 2, 3, 4]
+ * @dataLast
+ * @category Number
+ */
+declare function divide(divisor: bigint): (value: bigint) => bigint;
+declare function divide(divisor: number): (value: number) => number;
+//#endregion
+export { divide };
+//# sourceMappingURL=divide.d.cts.map

package/dist/divide.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"divide.d.cts","names":[],"sources":["../src/divide.ts"],"sourcesContent":[],"mappings":";;AAeA;AACA;AAcA;AACA;;;;;;;;;iBAhBgB,MAAA;iBACA,MAAA;;;;;;;;;;;;;iBAcA,MAAA;iBACA,MAAA"}

package/dist/divide.d.ts

@@ -1,2 +1,33 @@
-import { divide } from "./divide-Bsz0OPIK.js";
-export { divide };
+//#region src/divide.d.ts
+/**
+ * Divides two numbers.
+ *
+ * @param value - The number.
+ * @param divisor - The number to divide the value by.
+ * @signature
+ *    P.divide(value, divisor);
+ * @example
+ *    P.divide(12, 3) // => 4
+ *    P.reduce([1, 2, 3, 4], P.divide, 24) // => 1
+ * @dataFirst
+ * @category Number
+ */
+declare function divide(value: bigint, divisor: bigint): bigint;
+declare function divide(value: number, divisor: number): number;
+/**
+ * Divides two numbers.
+ *
+ * @param divisor - The number to divide the value by.
+ * @signature
+ *    P.divide(divisor)(value);
+ * @example
+ *    P.divide(3)(12) // => 4
+ *    P.map([2, 4, 6, 8], P.divide(2)) // => [1, 2, 3, 4]
+ * @dataLast
+ * @category Number
+ */
+declare function divide(divisor: bigint): (value: bigint) => bigint;
+declare function divide(divisor: number): (value: number) => number;
+//#endregion
+export { divide };
+//# sourceMappingURL=divide.d.ts.map

package/dist/divide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"divide.d.ts","names":[],"sources":["../src/divide.ts"],"sourcesContent":[],"mappings":";;AAeA;AACA;AAcA;AACA;;;;;;;;;iBAhBgB,MAAA;iBACA,MAAA;;;;;;;;;;;;;iBAcA,MAAA;iBACA,MAAA"}

package/dist/divide.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{divide as e}from"./divide-BI9ShWGE.js";export{e as divide};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){return e/t}export{t as divide};
+//# sourceMappingURL=divide.js.map

package/dist/divide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"divide.js","names":[],"sources":["../src/divide.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Divides two numbers.\n *\n * @param value - The number.\n * @param divisor - The number to divide the value by.\n * @signature\n *    P.divide(value, divisor);\n * @example\n *    P.divide(12, 3) // => 4\n *    P.reduce([1, 2, 3, 4], P.divide, 24) // => 1\n * @dataFirst\n * @category Number\n */\nexport function divide(value: bigint, divisor: bigint): bigint;\nexport function divide(value: number, divisor: number): number;\n\n/**\n * Divides two numbers.\n *\n * @param divisor - The number to divide the value by.\n * @signature\n *    P.divide(divisor)(value);\n * @example\n *    P.divide(3)(12) // => 4\n *    P.map([2, 4, 6, 8], P.divide(2)) // => [1, 2, 3, 4]\n * @dataLast\n * @category Number\n */\nexport function divide(divisor: bigint): (value: bigint) => bigint;\nexport function divide(divisor: number): (value: number) => number;\n\nexport function divide(...args: ReadonlyArray<unknown>): unknown {\n  return curry(divideImplementation, args);\n}\n\nfunction divideImplementation(value: number, divisor: number): number {\n  return value / divisor;\n}\n"],"mappings":"wCAiCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAAqB,EAAe,EAAyB,CACpE,OAAO,EAAQ"}

package/dist/do-nothing.cjs

@@ -1 +1 @@
-const e=require(`./do-nothing-Cc1faYu6.cjs`);exports.doNothing=e.doNothing;
+function e(){return t}function t(...e){}exports.doNothing=e;

package/dist/do-nothing.d.cts

@@ -1,2 +1,28 @@
-import { doNothing } from "./do-nothing-xUCzRm4m.cjs";
-export { doNothing };
+//#region src/do-nothing.d.ts
+/**
+ * A function that takes any arguments and does nothing with them. This is
+ * useful as a placeholder for any function or API that requires a **void**
+ * function (a function that doesn't return a value). This could also be used in
+ * combination with a ternary or other conditional execution to allow disabling
+ * a function call for a specific case.
+ *
+ * Notice that this is a dataLast impl where the function needs to be invoked
+ * to get the "do nothing" function.
+ *
+ * See also:
+ * `constant` - A function that ignores it's arguments and returns the same value on every invocation.
+ * `identity` - A function that returns the first argument it receives.
+ *
+ * @signature
+ *   P.doNothing();
+ * @example
+ *   myApi({ onSuccess: handleSuccess, onError: P.doNothing() });
+ *   myApi({ onSuccess: isDemoMode ? P.doNothing(): handleSuccess });
+ * @dataLast
+ * @category Function
+ */
+declare function doNothing(): typeof doesNothing;
+declare function doesNothing<Args extends ReadonlyArray<unknown>>(..._args: Args): void;
+//#endregion
+export { doNothing };
+//# sourceMappingURL=do-nothing.d.cts.map

package/dist/do-nothing.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"do-nothing.d.cts","names":[],"sources":["../src/do-nothing.ts"],"sourcesContent":[],"mappings":";;AAsBA;AAQC;;;;;;;;;;;;;;;;;;;;iBARe,SAAA,CAAA,UAAoB;iBAU3B,yBAAyB,kCACtB"}

package/dist/do-nothing.d.ts

@@ -1,2 +1,28 @@
-import { doNothing } from "./do-nothing-BvLrwjB7.js";
-export { doNothing };
+//#region src/do-nothing.d.ts
+/**
+ * A function that takes any arguments and does nothing with them. This is
+ * useful as a placeholder for any function or API that requires a **void**
+ * function (a function that doesn't return a value). This could also be used in
+ * combination with a ternary or other conditional execution to allow disabling
+ * a function call for a specific case.
+ *
+ * Notice that this is a dataLast impl where the function needs to be invoked
+ * to get the "do nothing" function.
+ *
+ * See also:
+ * `constant` - A function that ignores it's arguments and returns the same value on every invocation.
+ * `identity` - A function that returns the first argument it receives.
+ *
+ * @signature
+ *   P.doNothing();
+ * @example
+ *   myApi({ onSuccess: handleSuccess, onError: P.doNothing() });
+ *   myApi({ onSuccess: isDemoMode ? P.doNothing(): handleSuccess });
+ * @dataLast
+ * @category Function
+ */
+declare function doNothing(): typeof doesNothing;
+declare function doesNothing<Args extends ReadonlyArray<unknown>>(..._args: Args): void;
+//#endregion
+export { doNothing };
+//# sourceMappingURL=do-nothing.d.ts.map

package/dist/do-nothing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"do-nothing.d.ts","names":[],"sources":["../src/do-nothing.ts"],"sourcesContent":[],"mappings":";;AAsBA;AAQC;;;;;;;;;;;;;;;;;;;;iBARe,SAAA,CAAA,UAAoB;iBAU3B,yBAAyB,kCACtB"}

package/dist/do-nothing.js

@@ -1 +1,2 @@
-import{doNothing as e}from"./do-nothing-Be29JGDG.js";export{e as doNothing};
+function e(){return t}function t(...e){}export{e as doNothing};
+//# sourceMappingURL=do-nothing.js.map

package/dist/do-nothing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"do-nothing.js","names":[],"sources":["../src/do-nothing.ts"],"sourcesContent":["/**\n * A function that takes any arguments and does nothing with them. This is\n * useful as a placeholder for any function or API that requires a **void**\n * function (a function that doesn't return a value). This could also be used in\n * combination with a ternary or other conditional execution to allow disabling\n * a function call for a specific case.\n *\n * Notice that this is a dataLast impl where the function needs to be invoked\n * to get the \"do nothing\" function.\n *\n * See also:\n * `constant` - A function that ignores it's arguments and returns the same value on every invocation.\n * `identity` - A function that returns the first argument it receives.\n *\n * @signature\n *   P.doNothing();\n * @example\n *   myApi({ onSuccess: handleSuccess, onError: P.doNothing() });\n *   myApi({ onSuccess: isDemoMode ? P.doNothing(): handleSuccess });\n * @dataLast\n * @category Function\n */\nexport function doNothing(): typeof doesNothing {\n  /**\n   * Notice that the exported identity function is just the \"factory\" for the\n   * function. We do it this way so that all \"Function\" utilities have a similar\n   * API where the function is called, and not just used \"headless\". e.g.\n   * `doNothing()` and not `doNothing`, just like the API for `constant(1)`.\n   */\n  return doesNothing;\n}\n\nfunction doesNothing<Args extends ReadonlyArray<unknown>>(\n  ..._args: Args\n): void {\n  /* do nothing */\n}\n"],"mappings":"AAsBA,SAAgB,GAAgC,CAO9C,OAAO,EAGT,SAAS,EACP,GAAG,EACG"}

package/dist/drop-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(`./drop-first-by-DJOgP-yE.cjs`);exports.dropFirstBy=e.dropFirstBy;
+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>=e.length)return[];if(r<=0)return[...e];let i=e.slice(0,r);t.n(i,n);let a=[],o=e.slice(r);for(let e of o){let r=t.t(i,n,e);a.push(r??e)}return a}exports.dropFirstBy=n;

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

@@ -1,4 +1,41 @@
-import "./non-empty-array-D3ZRHApS.cjs";
-import "./curry-order-rules-1zjlAgqa.cjs";
-import { dropFirstBy } from "./drop-first-by-CSqeAzwS.cjs";
-export { dropFirstBy };
+import { t as NonEmptyArray } from "./non-empty-array-CFG7wGD-.cjs";
+import { t as OrderRule } from "./curry-order-rules-cezUWcSx.cjs";
+
+//#region src/drop-first-by.d.ts
+
+/**
+ * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
+ *
+ * @param data - The input array.
+ * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items 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.dropFirstBy(data, n, ...rules);
+ * @example
+ *   P.dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']
+ * @dataFirst
+ * @category Array
+ */
+declare function dropFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
+ *
+ * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items 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.dropFirstBy(n, ...rules)(data);
+ * @example
+ *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']
+ * @dataLast
+ * @category Array
+ */
+declare function dropFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+//#endregion
+export { dropFirstBy };
+//# sourceMappingURL=drop-first-by.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-first-by.d.cts","names":[],"sources":["../src/drop-first-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AAyBA;;;;;;;;;;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/drop-first-by.d.ts

@@ -1,4 +1,41 @@
-import "./non-empty-array-D3HWDPMt.js";
-import "./curry-order-rules-Cthu8rj4.js";
-import { dropFirstBy } from "./drop-first-by-dH-OI2It.js";
-export { dropFirstBy };
+import { t as NonEmptyArray } from "./non-empty-array-DXkY7ynY.js";
+import { t as OrderRule } from "./curry-order-rules-BCcwbNxd.js";
+
+//#region src/drop-first-by.d.ts
+
+/**
+ * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
+ *
+ * @param data - The input array.
+ * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items 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.dropFirstBy(data, n, ...rules);
+ * @example
+ *   P.dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']
+ * @dataFirst
+ * @category Array
+ */
+declare function dropFirstBy<T>(data: ReadonlyArray<T>, n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): Array<T>;
+/**
+ * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping the items. The complexity of this function is *O(Nlogn)* where `N` is the length of the array.
+ *
+ * For the opposite operation (to keep `n` elements) see `takeFirstBy`.
+ *
+ * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items 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.dropFirstBy(n, ...rules)(data);
+ * @example
+ *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']
+ * @dataLast
+ * @category Array
+ */
+declare function dropFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<OrderRule<T>>>): (data: ReadonlyArray<T>) => Array<T>;
+//#endregion
+export { dropFirstBy };
+//# sourceMappingURL=drop-first-by.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-first-by.d.ts","names":[],"sources":["../src/drop-first-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AAyBA;;;;;;;;;;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/drop-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{dropFirstBy as e}from"./drop-first-by-Cclqg5G_.js";export{e as dropFirstBy};
+import{n as e}from"./curry-order-rules-C6bwcUwC.js";import{n as t,t as n}from"./heap-bARaRULU.js";function r(...t){return e(i,t)}function i(e,r,i){if(i>=e.length)return[];if(i<=0)return[...e];let a=e.slice(0,i);t(a,r);let o=[],s=e.slice(i);for(let e of s){let t=n(a,r,e);o.push(t??e)}return o}export{r as dropFirstBy};
+//# sourceMappingURL=drop-first-by.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-first-by.js","names":[],"sources":["../src/drop-first-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\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 * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping 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 keep `n` elements) see `takeFirstBy`.\n *\n * @param data - The input array.\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items 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.dropFirstBy(data, n, ...rules);\n * @example\n *   P.dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaa', 'aaaa']\n * @dataFirst\n * @category Array\n */\nexport function dropFirstBy<T>(\n  data: ReadonlyArray<T>,\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): Array<T>;\n\n/**\n * Drop the first `n` items from `data` based on the provided ordering criteria. This allows you to avoid sorting the array before dropping 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 keep `n` elements) see `takeFirstBy`.\n *\n * @param n - The number of items to drop. If `n` is non-positive no items would be dropped and a *clone* of the input would be returned, if `n` is bigger then data.length no items 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.dropFirstBy(n, ...rules)(data);\n * @example\n *   P.pipe(['aa', 'aaaa', 'a', 'aaa'], P.dropFirstBy(2, x => x.length)); // => ['aaa', 'aaaa']\n * @dataLast\n * @category Array\n */\nexport function dropFirstBy<T>(\n  n: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T>>>\n): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function dropFirstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(dropFirstByImplementation, args);\n}\n\nfunction dropFirstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  n: number,\n): Array<T> {\n  if (n >= data.length) {\n    return [];\n  }\n\n  if (n <= 0) {\n    return [...data];\n  }\n\n  const heap = data.slice(0, n);\n  heapify(heap, compareFn);\n\n  const out = [];\n\n  const rest = data.slice(n);\n  for (const item of rest) {\n    const previousHead = heapMaybeInsert(heap, compareFn, item);\n    out.push(previousHead ?? item);\n  }\n\n  return out;\n}\n"],"mappings":"kGAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAA4B,EAA2B,EAAK,CAGrE,SAAS,EACP,EACA,EACA,EACU,CACV,GAAI,GAAK,EAAK,OACZ,MAAO,EAAE,CAGX,GAAI,GAAK,EACP,MAAO,CAAC,GAAG,EAAK,CAGlB,IAAM,EAAO,EAAK,MAAM,EAAG,EAAE,CAC7B,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAM,EAAE,CAER,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAe,EAAgB,EAAM,EAAW,EAAK,CAC3D,EAAI,KAAK,GAAgB,EAAK,CAGhC,OAAO"}

package/dist/drop-last-while.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./drop-last-while-DMzZWC3Y.cjs`);exports.dropLastWhile=e.dropLastWhile;
+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(0,n+1);return[]}exports.dropLastWhile=t;

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

@@ -1,3 +1,36 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { dropLastWhile } from "./drop-last-while-C_hHfAhU.cjs";
-export { dropLastWhile };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+
+//#region src/drop-last-while.d.ts
+
+/**
+ * Removes elements from the end of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.dropLastWhile(data, predicate)
+ * @example
+ *    P.dropLastWhile([1, 2, 10, 3, 4], x => x < 10) // => [1, 2, 10]
+ * @dataFirst
+ * @category Array
+ */
+declare function dropLastWhile<T extends IterableContainer>(data: T, predicate: (item: T[number], index: number, data: T) => boolean): Array<T[number]>;
+/**
+ * Removes elements from the end of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.dropLastWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4], P.dropLastWhile(x => x < 10))  // => [1, 2, 10]
+ * @dataLast
+ * @category Array
+ */
+declare function dropLastWhile<T extends IterableContainer>(predicate: (item: T[number], index: number, data: T) => boolean): (data: T) => Array<T[number]>;
+//#endregion
+export { dropLastWhile };
+//# sourceMappingURL=drop-last-while.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-last-while.d.cts","names":[],"sources":["../src/drop-last-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;;;;;;;;AAkBA;;;;AAEU,iBApBM,aAoBN,CAAA,UApB8B,iBAoB9B,CAAA,CAAA,IAAA,EAnBF,CAmBE,EAAA,SAAA,EAAA,CAAA,IAAA,EAlBU,CAkBV,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAlB0C,CAkB1C,EAAA,GAAA,OAAA,CAAA,EAjBP,KAiBO,CAjBD,CAiBC,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;iBAFM,wBAAwB,qCACpB,gCAAgC,uBAC1C,MAAM,MAAM"}

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

@@ -1,3 +1,36 @@
-import "./iterable-container-wtkYslN_.js";
-import { dropLastWhile } from "./drop-last-while-BbasDoJh.js";
-export { dropLastWhile };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+
+//#region src/drop-last-while.d.ts
+
+/**
+ * Removes elements from the end of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.dropLastWhile(data, predicate)
+ * @example
+ *    P.dropLastWhile([1, 2, 10, 3, 4], x => x < 10) // => [1, 2, 10]
+ * @dataFirst
+ * @category Array
+ */
+declare function dropLastWhile<T extends IterableContainer>(data: T, predicate: (item: T[number], index: number, data: T) => boolean): Array<T[number]>;
+/**
+ * Removes elements from the end of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.dropLastWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4], P.dropLastWhile(x => x < 10))  // => [1, 2, 10]
+ * @dataLast
+ * @category Array
+ */
+declare function dropLastWhile<T extends IterableContainer>(predicate: (item: T[number], index: number, data: T) => boolean): (data: T) => Array<T[number]>;
+//#endregion
+export { dropLastWhile };
+//# sourceMappingURL=drop-last-while.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-last-while.d.ts","names":[],"sources":["../src/drop-last-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;;;;;;;;AAkBA;;;;AAEU,iBApBM,aAoBN,CAAA,UApB8B,iBAoB9B,CAAA,CAAA,IAAA,EAnBF,CAmBE,EAAA,SAAA,EAAA,CAAA,IAAA,EAlBU,CAkBV,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAlB0C,CAkB1C,EAAA,GAAA,OAAA,CAAA,EAjBP,KAiBO,CAjBD,CAiBC,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;iBAFM,wBAAwB,qCACpB,gCAAgC,uBAC1C,MAAM,MAAM"}

package/dist/drop-last-while.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{dropLastWhile as e}from"./drop-last-while-StSGe_bf.js";export{e as dropLastWhile};
+import{t as e}from"./curry-BcQ8Up1_.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(0,n+1);return[]}export{t as dropLastWhile};
+//# sourceMappingURL=drop-last-while.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-last-while.js","names":[],"sources":["../src/drop-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\n\nimport { curry } from './curry';\n\n/**\n * Removes elements from the end of the array until the predicate returns false.\n *\n * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    P.dropLastWhile(data, predicate)\n * @example\n *    P.dropLastWhile([1, 2, 10, 3, 4], x => x < 10) // => [1, 2, 10]\n * @dataFirst\n * @category Array\n */\nexport function dropLastWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]>;\n\n/**\n * Removes elements from the end of the array until the predicate returns false.\n *\n * The predicate is applied to each element in the array starting from the end and moving towards the beginning, until the predicate returns false. The returned array includes elements from the beginning of the array, up to and including the element that produced false for the predicate.\n *\n * @param predicate - The predicate.\n * @signature\n *    P.dropLastWhile(predicate)(data)\n * @example\n *    P.pipe([1, 2, 10, 3, 4], P.dropLastWhile(x => x < 10))  // => [1, 2, 10]\n * @dataLast\n * @category Array\n */\nexport function dropLastWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => Array<T[number]>;\n\nexport function dropLastWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(dropLastWhileImplementation, args);\n}\n\nfunction dropLastWhileImplementation<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(0, i + 1);\n    }\n  }\n  return [];\n}\n"],"mappings":"wCAwCA,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,EAAG,EAAI,EAAE,CAG/B,MAAO,EAAE"}

package/dist/drop-last.cjs

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

package/dist/drop-last.d.cts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-last.d.cts","names":[],"sources":["../src/drop-last.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;AAgBA;;;;AAE8C,iBAlB9B,QAkB8B,CAAA,UAlBX,iBAkBW,CAAA,CAAA,KAAA,EAjBrC,CAiBqC,EAAA,CAAA,EAAA,MAAA,CAAA,EAf3C,KAe2C,CAfrC,CAeqC,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;iBAF9B,QAAA,wBAEF,0BAA0B,MAAM,MAAM"}

package/dist/drop-last.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-last.d.ts","names":[],"sources":["../src/drop-last.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;AAgBA;;;;AAE8C,iBAlB9B,QAkB8B,CAAA,UAlBX,iBAkBW,CAAA,CAAA,KAAA,EAjBrC,CAiBqC,EAAA,CAAA,EAAA,MAAA,CAAA,EAf3C,KAe2C,CAfrC,CAeqC,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;iBAF9B,QAAA,wBAEF,0BAA0B,MAAM,MAAM"}

package/dist/drop-last.js

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

package/dist/drop-last.js.map

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

package/dist/drop-while.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./drop-while-BGbJsU8z.cjs`);exports.dropWhile=e.dropWhile;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){for(let[n,r]of e.entries())if(!t(r,n,e))return e.slice(n);return[]}exports.dropWhile=t;

package/dist/drop-while.d.cts

@@ -1,3 +1,36 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { dropWhile } from "./drop-while-T3z_MbtJ.cjs";
-export { dropWhile };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+
+//#region src/drop-while.d.ts
+
+/**
+ * Removes elements from the beginning of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array, until the predicate returns false. The returned array includes the rest of the elements, starting with the element that produced false for the predicate.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.dropWhile(data, predicate)
+ * @example
+ *    P.dropWhile([1, 2, 10, 3, 4], x => x < 10) // => [10, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function dropWhile<T extends IterableContainer>(data: T, predicate: (item: T[number], index: number, data: T) => boolean): Array<T[number]>;
+/**
+ * Removes elements from the beginning of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array, until the predicate returns false. The returned array includes the rest of the elements, starting with the element that produced false for the predicate.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.dropWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4], P.dropWhile(x => x < 10))  // => [10, 3, 4]
+ * @dataLast
+ * @category Array
+ */
+declare function dropWhile<T extends IterableContainer>(predicate: (item: T[number], index: number, data: T) => boolean): (data: T) => Array<T[number]>;
+//#endregion
+export { dropWhile };
+//# sourceMappingURL=drop-while.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-while.d.cts","names":[],"sources":["../src/drop-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;;AAkBA;;;;AAEU,iBApBM,SAoBN,CAAA,UApB0B,iBAoB1B,CAAA,CAAA,IAAA,EAnBF,CAmBE,EAAA,SAAA,EAAA,CAAA,IAAA,EAlBU,CAkBV,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAlB0C,CAkB1C,EAAA,GAAA,OAAA,CAAA,EAjBP,KAiBO,CAjBD,CAiBC,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;iBAFM,oBAAoB,qCAChB,gCAAgC,uBAC1C,MAAM,MAAM"}

package/dist/drop-while.d.ts

@@ -1,3 +1,36 @@
-import "./iterable-container-wtkYslN_.js";
-import { dropWhile } from "./drop-while-CzvSV4z7.js";
-export { dropWhile };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+
+//#region src/drop-while.d.ts
+
+/**
+ * Removes elements from the beginning of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array, until the predicate returns false. The returned array includes the rest of the elements, starting with the element that produced false for the predicate.
+ *
+ * @param data - The array.
+ * @param predicate - The predicate.
+ * @signature
+ *    P.dropWhile(data, predicate)
+ * @example
+ *    P.dropWhile([1, 2, 10, 3, 4], x => x < 10) // => [10, 3, 4]
+ * @dataFirst
+ * @category Array
+ */
+declare function dropWhile<T extends IterableContainer>(data: T, predicate: (item: T[number], index: number, data: T) => boolean): Array<T[number]>;
+/**
+ * Removes elements from the beginning of the array until the predicate returns false.
+ *
+ * The predicate is applied to each element in the array, until the predicate returns false. The returned array includes the rest of the elements, starting with the element that produced false for the predicate.
+ *
+ * @param predicate - The predicate.
+ * @signature
+ *    P.dropWhile(predicate)(data)
+ * @example
+ *    P.pipe([1, 2, 10, 3, 4], P.dropWhile(x => x < 10))  // => [10, 3, 4]
+ * @dataLast
+ * @category Array
+ */
+declare function dropWhile<T extends IterableContainer>(predicate: (item: T[number], index: number, data: T) => boolean): (data: T) => Array<T[number]>;
+//#endregion
+export { dropWhile };
+//# sourceMappingURL=drop-while.d.ts.map

package/dist/drop-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-while.d.ts","names":[],"sources":["../src/drop-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAiBA;;;;;;;;AAkBA;;;;AAEU,iBApBM,SAoBN,CAAA,UApB0B,iBAoB1B,CAAA,CAAA,IAAA,EAnBF,CAmBE,EAAA,SAAA,EAAA,CAAA,IAAA,EAlBU,CAkBV,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAlB0C,CAkB1C,EAAA,GAAA,OAAA,CAAA,EAjBP,KAiBO,CAjBD,CAiBC,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;iBAFM,oBAAoB,qCAChB,gCAAgC,uBAC1C,MAAM,MAAM"}

package/dist/drop-while.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{dropWhile as e}from"./drop-while-BCln-hAn.js";export{e as dropWhile};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){for(let[n,r]of e.entries())if(!t(r,n,e))return e.slice(n);return[]}export{t as dropWhile};
+//# sourceMappingURL=drop-while.js.map

package/dist/drop-while.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-while.js","names":[],"sources":["../src/drop-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Removes elements from the beginning of the array until the predicate returns false.\n *\n * The predicate is applied to each element in the array, until the predicate returns false. The returned array includes the rest of the elements, starting with the element that produced false for the predicate.\n *\n * @param data - The array.\n * @param predicate - The predicate.\n * @signature\n *    P.dropWhile(data, predicate)\n * @example\n *    P.dropWhile([1, 2, 10, 3, 4], x => x < 10) // => [10, 3, 4]\n * @dataFirst\n * @category Array\n */\nexport function dropWhile<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]>;\n\n/**\n * Removes elements from the beginning of the array until the predicate returns false.\n *\n * The predicate is applied to each element in the array, until the predicate returns false. The returned array includes the rest of the elements, starting with the element that produced false for the predicate.\n *\n * @param predicate - The predicate.\n * @signature\n *    P.dropWhile(predicate)(data)\n * @example\n *    P.pipe([1, 2, 10, 3, 4], P.dropWhile(x => x < 10))  // => [10, 3, 4]\n * @dataLast\n * @category Array\n */\nexport function dropWhile<T extends IterableContainer>(\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): (data: T) => Array<T[number]>;\n\nexport function dropWhile(...args: ReadonlyArray<unknown>): unknown {\n  return curry(dropWhileImplementation, args);\n}\n\nfunction dropWhileImplementation<T extends IterableContainer>(\n  data: T,\n  predicate: (item: T[number], index: number, data: T) => boolean,\n): Array<T[number]> {\n  for (const [index, item] of data.entries()) {\n    if (!predicate(item, index, data)) {\n      return data.slice(index);\n    }\n  }\n  return [];\n}\n"],"mappings":"wCAuCA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACkB,CAClB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CACxC,GAAI,CAAC,EAAU,EAAM,EAAO,EAAK,CAC/B,OAAO,EAAK,MAAM,EAAM,CAG5B,MAAO,EAAE"}