@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/divide-BI9ShWGE.js

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

package/dist/divide-BI9ShWGE.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"divide-BI9ShWGE.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":"4CAiCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAAqB,EAAe,EAAyB,CACpE,OAAO,EAAQ"}

package/dist/divide-Bsz0OPIK.d.ts

@@ -1,33 +0,0 @@
-//#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-Bsz0OPIK.d.ts.map

package/dist/divide-Bsz0OPIK.d.ts.map

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

package/dist/divide-C8COFm-b.d.cts

@@ -1,33 +0,0 @@
-//#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-C8COFm-b.d.cts.map

package/dist/divide-C8COFm-b.d.cts.map

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

package/dist/divide-ZFT5ZqJ0.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e/t}Object.defineProperty(exports,`divide`,{enumerable:!0,get:function(){return t}});

package/dist/do-nothing-Be29JGDG.js

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

package/dist/do-nothing-Be29JGDG.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"do-nothing-Be29JGDG.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/do-nothing-BvLrwjB7.d.ts

@@ -1,28 +0,0 @@
-//#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-BvLrwjB7.d.ts.map

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

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

package/dist/do-nothing-Cc1faYu6.cjs

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

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

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

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

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

package/dist/drop-Bmm5QDJI.d.cts

@@ -1,40 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { PartialArray } from "./partial-array-CzOnr197.cjs";
-import { TupleParts } from "./tuple-parts-BIyABPYv.cjs";
-import { ClampedIntegerSubtract } from "./clamped-integer-subtract-DId0tRjp.cjs";
-import { CoercedArray } from "./coerced-array-kVJtBrMl.cjs";
-import { IsInteger, IsNegative, Writable } from "type-fest";
-
-//#region src/drop.d.ts
-type Drop<T extends IterableContainer, N extends number> = IsNegative<N> extends true ? Writable<T> : IsInteger<N> extends false ? Array<T[number]> : ClampedIntegerSubtract<N, TupleParts<T>['required']['length']> extends infer RemainingPrefix extends number ? RemainingPrefix extends 0 ? [...DropFixedTuple<TupleParts<T>['required'], N>, ...PartialArray<TupleParts<T>['optional']>, ...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']] : ClampedIntegerSubtract<RemainingPrefix, TupleParts<T>['optional']['length']> extends infer RemainingOptional extends number ? RemainingOptional extends 0 ? [...PartialArray<DropFixedTuple<TupleParts<T>['optional'], RemainingPrefix>>, ...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']] : [...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']] | Exclude<DropFixedTuple<TupleParts<T>['suffix'], RemainingOptional, true>, TupleParts<T>['suffix']> : never : never;
-type DropFixedTuple<T, N, IncludePrefixes = false, Dropped extends Array<unknown> = []> = Dropped['length'] extends N ? T : T extends readonly [unknown, ...infer Rest] ? DropFixedTuple<Rest, N, IncludePrefixes, [...Dropped, unknown]> | (true extends IncludePrefixes ? T : never) : [];
-/**
- * Removes first `n` elements from the `array`.
- *
- * @param array - The target array.
- * @param n - The number of elements to skip.
- * @signature
- *    P.drop(array, n)
- * @example
- *    P.drop([1, 2, 3, 4, 5], 2) // => [3, 4, 5]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function drop<T extends IterableContainer, N extends number>(array: T, n: N): Drop<T, N>;
-/**
- * Removes first `n` elements from the `array`.
- *
- * @param n - The number of elements to skip.
- * @signature
- *    P.drop(n)(array)
- * @example
- *    P.drop(2)([1, 2, 3, 4, 5]) // => [3, 4, 5]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function drop<N extends number>(n: N): <T extends IterableContainer>(array: T) => Drop<T, N>;
-//#endregion
-export { drop };
-//# sourceMappingURL=drop-Bmm5QDJI.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"drop-Bmm5QDJI.d.cts","names":[],"sources":["../src/drop.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAUK,eAAe,uCAChB,WAAW,kBAGT,SAAS,KACT,UAAU,mBAMR,MAAM,aACN,uBACA,GACA,WAAW,yEAET,gCAKO,eAAe,WAAW,gBAAgB,IArBtD,GAsBY,YAtBR,CAsBqB,UAtBrB,CAsBgC,CAtBhC,CAAA,CAAA,UAAA,CAAA,CAAA,EAAA,GAuBQ,YAvBR,CAuBqB,UAvBrB,CAuBgC,CAvBhC,CAAA,CAAA,MAAA,CAAA,CAAA,KAwBQ,UAxBG,CAwBQ,CAxBR,CAAA,CAAA,QAAA,CAAA,IA0BR,sBAzBG,CA0BH,eA1BG,EA2BH,UA3BG,CA2BQ,CA3BR,CAAA,CAAA,UAAA,CAAA,CAAA,QAAA,CAAA,CAAA,SAAA,KAAA,2BAAA,MAAA,GA6BD,iBA7BC,SAAA,CAAA,GAAA,IAmCM,YAnCjB,CAoCgB,cApChB,CAoC+B,UApC/B,CAoC0C,CApC1C,CAAA,CAAA,UAAA,CAAA,EAoC0D,eApC1D,CAAA,CAAA,KAsCiB,YAnCN,CAmCmB,UAnCnB,CAmC8B,CAnC9B,CAAA,CAAA,MAAA,CAAA,CAAA,KAoCM,UApCf,CAoC0B,CApC1B,CAAA,CAAA,QAAA,CAAA,QA8Ca,YA7Cb,CA6C0B,UA7C1B,CA6CqC,CA7CrC,CAAA,CAAA,MAAA,CAAA,CAAA,KA8Ca,UAxCL,CAwCgB,CAxChB,CAAA,CAAA,QAAA,CAAA,IAiDE,OAjDR,CAkDU,cAlDV,CAmDY,UAnDZ,CAmDuB,CAnDvB,CAAA,CAAA,QAAA,CAAA,EAoDY,iBApDZ,EAAA,IAAA,CAAA,EAuDU,UAvDV,CAuDqB,CAvDrB,CAAA,CAAA,QAAA,CAAA,CAAA,GAAA,KAAA,GAAA,KAAA;KA4DH,cA1DG,CAAA,CAAA,EAAA,CAAA,EAAA,kBAAA,KAAA,EAAA,gBAgEU,KAhEV,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAiEJ,OAjEI,CAAA,QAAA,CAAA,SAiEsB,CAjEtB,GAkEJ,CAlEI,GAmEJ,CAnEI,SAAA,SAAA,CAAA,OAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAoEA,cApEA,CAoEe,IApEf,EAoEqB,CApErB,EAoEwB,eApExB,EAAA,CAAA,GAoE6C,OApE7C,EAAA,OAAA,CAAA,CAAA,GAAA,CAAA,IAAA,SAqEY,eArEZ,GAqE8B,CArE9B,GAAA,KAAA,CAAA,GAAA,EAAA;;;;;;;;;;;;;;AAUS,iBA2ED,IA3EC,CAAA,UA2Ec,iBA3Ed,EAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EA4ER,CA5EQ,EAAA,CAAA,EA6EZ,CA7EY,CAAA,EA8Ed,IA9Ec,CA8ET,CA9ES,EA8EN,CA9EM,CAAA;;;;;;;;;;;;;AAgB4B,iBA4E7B,IA5E6B,CAAA,UAAA,MAAA,CAAA,CAAA,CAAA,EA6ExC,CA7EwC,CAAA,EAAA,CAAA,UA8E/B,iBA9E+B,CAAA,CAAA,KAAA,EA8EL,CA9EK,EAAA,GA8EC,IA9ED,CA8EM,CA9EN,EA8ES,CA9ET,CAAA"}

package/dist/drop-BvsV-rBc.js

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

package/dist/drop-BvsV-rBc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"drop-BvsV-rBc.js","names":[],"sources":["../src/drop.ts"],"sourcesContent":["import type { IsInteger, IsNegative, Writable } from 'type-fest';\nimport type { ClampedIntegerSubtract } from './internal/types/clamped-integer-subtract';\nimport type { CoercedArray } from './internal/types/coerced-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { PartialArray } from './internal/types/partial-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\nimport { lazyIdentityEvaluator, SKIP_ITEM } from './internal/utility-evaluators';\n\ntype Drop<T extends IterableContainer, N extends number>\n  = IsNegative<N> extends true\n    // Negative numbers result in nothing being dropped, we return a shallow\n    // clone of the array.\n    ? Writable<T>\n    : IsInteger<N> extends false\n      // We can't compute accurate types for non-integer numbers so we\n      // fallback to the \"legacy\" typing where we convert our output to a\n      // simple array. This is also the case when N is not a literal value\n      // (e.g. it is `number`).\n      // TODO: We can improve this type by returning a union of all possible dropped shapes (e.g. the equivalent of Drop<T, 1> | Drop<T, 2> | Drop<T, 3> | ...).\n      ? Array<T[number]>\n      : ClampedIntegerSubtract<\n        N,\n        TupleParts<T>['required']['length']\n      > extends infer RemainingPrefix extends number\n        ? RemainingPrefix extends 0\n          // The drop will occur within the required part of the tuple, we\n          // simply remove those elements from it and reconstruct the rest of\n          // the tuple.\n          ? [\n              ...DropFixedTuple<TupleParts<T>['required'], N>,\n              ...PartialArray<TupleParts<T>['optional']>,\n              ...CoercedArray<TupleParts<T>['item']>,\n              ...TupleParts<T>['suffix'],\n            ]\n          : ClampedIntegerSubtract<\n            RemainingPrefix,\n            TupleParts<T>['optional']['length']\n          > extends infer RemainingOptional extends number\n            ? RemainingOptional extends 0\n              // The drop will occur within the optional part of the tuple, we\n              // completely remove the required part, remove enough elements\n              // from the optional part, and reconstruct the rest of the\n              // tuple.\n              ? [\n                  ...PartialArray<\n                    DropFixedTuple<TupleParts<T>['optional'], RemainingPrefix>\n                  >,\n                  ...CoercedArray<TupleParts<T>['item']>,\n                  ...TupleParts<T>['suffix'],\n                ]\n              // The drop will occur within the rest element or the suffix.\n              // Because the suffix can contain any number of elements this\n              // case adds more complexity as we need to consider all possible\n              // (relevant) lengths. We start by considering the case where\n              // there are enough elements within the rest param; this means\n              // we still maintain the rest element as it could contain even\n              // more elements, and we add the suffix untouched.\n              : | [\n                ...CoercedArray<TupleParts<T>['item']>,\n                ...TupleParts<T>['suffix'],\n              ]\n                  // Additionally, we need to consider the case where the rest\n                  // element has up to the same number of elements as the\n                  // suffix; this will result in removing the rest element\n                  // entirely, and dropping elements from the suffix. We do this\n                  // for all possible values from 0 to N where N is the\n                  // remaining value after we handled the prefix. We can exclude\n                  // the 0 case because it is contained in the previous case.\n              | Exclude<\n                  DropFixedTuple<\n                    TupleParts<T>['suffix'],\n                    RemainingOptional,\n                    true\n                  >,\n                  TupleParts<T>['suffix']\n                >\n            : never\n        : never;\n\ntype DropFixedTuple<\n  T,\n  N,\n  // This flag controls if we want a union of all possible prefixes, or just the\n  // final tuple with all N items dropped.\n  IncludePrefixes = false,\n  Dropped extends Array<unknown> = [],\n> = Dropped['length'] extends N\n  ? T\n  : T extends readonly [unknown, ...infer Rest]\n    ? | DropFixedTuple<Rest, N, IncludePrefixes, [...Dropped, unknown]>\n    | (true extends IncludePrefixes ? T : never)\n    : [];\n\n/**\n * Removes first `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.drop(array, n)\n * @example\n *    P.drop([1, 2, 3, 4, 5], 2) // => [3, 4, 5]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function drop<T extends IterableContainer, N extends number>(\n  array: T,\n  n: N,\n): Drop<T, N>;\n\n/**\n * Removes first `n` elements from the `array`.\n *\n * @param n - The number of elements to skip.\n * @signature\n *    P.drop(n)(array)\n * @example\n *    P.drop(2)([1, 2, 3, 4, 5]) // => [3, 4, 5]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function drop<N extends number>(\n  n: N,\n): <T extends IterableContainer>(array: T) => Drop<T, N>;\n\nexport function drop(...args: ReadonlyArray<unknown>): unknown {\n  return curry(dropImplementation, args, lazyImplementation);\n}\n\nfunction dropImplementation<T extends IterableContainer>(\n  array: T,\n  n: number,\n): Array<T[number]> {\n  return (n < 0 ? [...array] : array.slice(n));\n}\n\nfunction lazyImplementation<T>(n: number): LazyEvaluator<T> {\n  if (n <= 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  let left = n;\n  return (value) => {\n    if (left > 0) {\n      left -= 1;\n      return SKIP_ITEM;\n    }\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"oIAiIA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,EAAmB,CAG5D,SAAS,EACP,EACA,EACkB,CAClB,OAAQ,EAAI,EAAI,CAAC,GAAG,EAAM,CAAG,EAAM,MAAM,EAAE,CAG7C,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAO,EAGT,IAAI,EAAO,EACX,MAAQ,IACF,EAAO,GACT,IACO,GAEF,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/drop-C-tVyU4K.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./utility-evaluators-DqJcWENu.cjs`);function n(...t){return e.curry(r,t,i)}function r(e,t){return t<0?[...e]:e.slice(t)}function i(e){if(e<=0)return t.lazyIdentityEvaluator;let n=e;return e=>n>0?(--n,t.SKIP_ITEM):{done:!1,hasNext:!0,next:e}}Object.defineProperty(exports,`drop`,{enumerable:!0,get:function(){return n}});

package/dist/drop-DTeHYc-D.d.ts

@@ -1,40 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { PartialArray } from "./partial-array-IoGI5gCo.js";
-import { TupleParts } from "./tuple-parts-BxpZLJ7r.js";
-import { ClampedIntegerSubtract } from "./clamped-integer-subtract-CQL8aT__.js";
-import { CoercedArray } from "./coerced-array-DyA0Yc12.js";
-import { IsInteger, IsNegative, Writable } from "type-fest";
-
-//#region src/drop.d.ts
-type Drop<T extends IterableContainer, N extends number> = IsNegative<N> extends true ? Writable<T> : IsInteger<N> extends false ? Array<T[number]> : ClampedIntegerSubtract<N, TupleParts<T>['required']['length']> extends infer RemainingPrefix extends number ? RemainingPrefix extends 0 ? [...DropFixedTuple<TupleParts<T>['required'], N>, ...PartialArray<TupleParts<T>['optional']>, ...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']] : ClampedIntegerSubtract<RemainingPrefix, TupleParts<T>['optional']['length']> extends infer RemainingOptional extends number ? RemainingOptional extends 0 ? [...PartialArray<DropFixedTuple<TupleParts<T>['optional'], RemainingPrefix>>, ...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']] : [...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']] | Exclude<DropFixedTuple<TupleParts<T>['suffix'], RemainingOptional, true>, TupleParts<T>['suffix']> : never : never;
-type DropFixedTuple<T, N, IncludePrefixes = false, Dropped extends Array<unknown> = []> = Dropped['length'] extends N ? T : T extends readonly [unknown, ...infer Rest] ? DropFixedTuple<Rest, N, IncludePrefixes, [...Dropped, unknown]> | (true extends IncludePrefixes ? T : never) : [];
-/**
- * Removes first `n` elements from the `array`.
- *
- * @param array - The target array.
- * @param n - The number of elements to skip.
- * @signature
- *    P.drop(array, n)
- * @example
- *    P.drop([1, 2, 3, 4, 5], 2) // => [3, 4, 5]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function drop<T extends IterableContainer, N extends number>(array: T, n: N): Drop<T, N>;
-/**
- * Removes first `n` elements from the `array`.
- *
- * @param n - The number of elements to skip.
- * @signature
- *    P.drop(n)(array)
- * @example
- *    P.drop(2)([1, 2, 3, 4, 5]) // => [3, 4, 5]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function drop<N extends number>(n: N): <T extends IterableContainer>(array: T) => Drop<T, N>;
-//#endregion
-export { drop };
-//# sourceMappingURL=drop-DTeHYc-D.d.ts.map

package/dist/drop-DTeHYc-D.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drop-DTeHYc-D.d.ts","names":[],"sources":["../src/drop.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAUK,eAAe,uCAChB,WAAW,kBAGT,SAAS,KACT,UAAU,mBAMR,MAAM,aACN,uBACA,GACA,WAAW,yEAET,gCAKO,eAAe,WAAW,gBAAgB,IArBtD,GAsBY,YAtBR,CAsBqB,UAtBrB,CAsBgC,CAtBhC,CAAA,CAAA,UAAA,CAAA,CAAA,EAAA,GAuBQ,YAvBR,CAuBqB,UAvBrB,CAuBgC,CAvBhC,CAAA,CAAA,MAAA,CAAA,CAAA,KAwBQ,UAxBG,CAwBQ,CAxBR,CAAA,CAAA,QAAA,CAAA,IA0BR,sBAzBG,CA0BH,eA1BG,EA2BH,UA3BG,CA2BQ,CA3BR,CAAA,CAAA,UAAA,CAAA,CAAA,QAAA,CAAA,CAAA,SAAA,KAAA,2BAAA,MAAA,GA6BD,iBA7BC,SAAA,CAAA,GAAA,IAmCM,YAnCjB,CAoCgB,cApChB,CAoC+B,UApC/B,CAoC0C,CApC1C,CAAA,CAAA,UAAA,CAAA,EAoC0D,eApC1D,CAAA,CAAA,KAsCiB,YAnCN,CAmCmB,UAnCnB,CAmC8B,CAnC9B,CAAA,CAAA,MAAA,CAAA,CAAA,KAoCM,UApCf,CAoC0B,CApC1B,CAAA,CAAA,QAAA,CAAA,QA8Ca,YA7Cb,CA6C0B,UA7C1B,CA6CqC,CA7CrC,CAAA,CAAA,MAAA,CAAA,CAAA,KA8Ca,UAxCL,CAwCgB,CAxChB,CAAA,CAAA,QAAA,CAAA,IAiDE,OAjDR,CAkDU,cAlDV,CAmDY,UAnDZ,CAmDuB,CAnDvB,CAAA,CAAA,QAAA,CAAA,EAoDY,iBApDZ,EAAA,IAAA,CAAA,EAuDU,UAvDV,CAuDqB,CAvDrB,CAAA,CAAA,QAAA,CAAA,CAAA,GAAA,KAAA,GAAA,KAAA;KA4DH,cA1DG,CAAA,CAAA,EAAA,CAAA,EAAA,kBAAA,KAAA,EAAA,gBAgEU,KAhEV,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAiEJ,OAjEI,CAAA,QAAA,CAAA,SAiEsB,CAjEtB,GAkEJ,CAlEI,GAmEJ,CAnEI,SAAA,SAAA,CAAA,OAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAoEA,cApEA,CAoEe,IApEf,EAoEqB,CApErB,EAoEwB,eApExB,EAAA,CAAA,GAoE6C,OApE7C,EAAA,OAAA,CAAA,CAAA,GAAA,CAAA,IAAA,SAqEY,eArEZ,GAqE8B,CArE9B,GAAA,KAAA,CAAA,GAAA,EAAA;;;;;;;;;;;;;;AAUS,iBA2ED,IA3EC,CAAA,UA2Ec,iBA3Ed,EAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EA4ER,CA5EQ,EAAA,CAAA,EA6EZ,CA7EY,CAAA,EA8Ed,IA9Ec,CA8ET,CA9ES,EA8EN,CA9EM,CAAA;;;;;;;;;;;;;AAgB4B,iBA4E7B,IA5E6B,CAAA,UAAA,MAAA,CAAA,CAAA,CAAA,EA6ExC,CA7EwC,CAAA,EAAA,CAAA,UA8E/B,iBA9E+B,CAAA,CAAA,KAAA,EA8EL,CA9EK,EAAA,GA8EC,IA9ED,CA8EM,CA9EN,EA8ES,CA9ET,CAAA"}

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

@@ -1,41 +0,0 @@
-import { NonEmptyArray } from "./non-empty-array-D3ZRHApS.cjs";
-import { OrderRule } from "./curry-order-rules-1zjlAgqa.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-CSqeAzwS.d.cts.map

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"drop-first-by-Cclqg5G_.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":"gJAmDA,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-first-by-DJOgP-yE.cjs

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

package/dist/drop-first-by-dH-OI2It.d.ts

@@ -1,41 +0,0 @@
-import { NonEmptyArray } from "./non-empty-array-D3HWDPMt.js";
-import { OrderRule } from "./curry-order-rules-Cthu8rj4.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-dH-OI2It.d.ts.map

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

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

package/dist/drop-last-CX8JXA1b.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return t>0?e.slice(0,Math.max(0,e.length-t)):[...e]}Object.defineProperty(exports,`dropLast`,{enumerable:!0,get:function(){return t}});

package/dist/drop-last-CuCKuM4n.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.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-CuCKuM4n.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"drop-last-CuCKuM4n.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":"4CAoCA,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-last-oiDr5Owj.d.cts

@@ -1,32 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.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-oiDr5Owj.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"drop-last-oiDr5Owj.d.cts","names":[],"sources":["../src/drop-last.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;;AAgBA;;;AAEwC,iBAlBxB,QAkBwB,CAAA,UAlBL,iBAkBK,CAAA,CAAA,KAAA,EAjB/B,CAiB+B,EAAA,CAAA,EAAA,MAAA,CAAA,EAfrC,KAeqC,CAf/B,CAe+B,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;iBAFxB,QAAA,wBAEF,0BAA0B,MAAM,MAAM"}

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

@@ -1,32 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.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-vbp5oZaK.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"drop-last-vbp5oZaK.d.ts","names":[],"sources":["../src/drop-last.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;;AAgBA;;;AAEwC,iBAlBxB,QAkBwB,CAAA,UAlBL,iBAkBK,CAAA,CAAA,KAAA,EAjB/B,CAiB+B,EAAA,CAAA,EAAA,MAAA,CAAA,EAfrC,KAeqC,CAf/B,CAe+B,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;iBAFxB,QAAA,wBAEF,0BAA0B,MAAM,MAAM"}

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

@@ -1,36 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.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-BbasDoJh.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"drop-last-while-BbasDoJh.d.ts","names":[],"sources":["../src/drop-last-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;;;;;;;;;AAkBA;;;AACoB,iBAnBJ,aAmBI,CAAA,UAnBoB,iBAmBpB,CAAA,CAAA,IAAA,EAlBZ,CAkBY,EAAA,SAAA,EAAA,CAAA,IAAA,EAjBA,CAiBA,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAjBgC,CAiBhC,EAAA,GAAA,OAAA,CAAA,EAhBjB,KAgBiB,CAhBX,CAgBW,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;iBADJ,wBAAwB,qCACpB,gCAAgC,uBAC1C,MAAM,MAAM"}

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

@@ -1,36 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.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-C_hHfAhU.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"drop-last-while-C_hHfAhU.d.cts","names":[],"sources":["../src/drop-last-while.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;;;;;;;;;AAkBA;;;AACoB,iBAnBJ,aAmBI,CAAA,UAnBoB,iBAmBpB,CAAA,CAAA,IAAA,EAlBZ,CAkBY,EAAA,SAAA,EAAA,CAAA,IAAA,EAjBA,CAiBA,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAjBgC,CAiBhC,EAAA,GAAA,OAAA,CAAA,EAhBjB,KAgBiB,CAhBX,CAgBW,CAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;iBADJ,wBAAwB,qCACpB,gCAAgC,uBAC1C,MAAM,MAAM"}

package/dist/drop-last-while-DMzZWC3Y.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(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[]}Object.defineProperty(exports,`dropLastWhile`,{enumerable:!0,get:function(){return t}});

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

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.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-StSGe_bf.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"drop-last-while-StSGe_bf.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":"4CAwCA,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-while-BCln-hAn.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.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-BCln-hAn.js.map

package/dist/drop-while-BCln-hAn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"drop-while-BCln-hAn.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":"4CAuCA,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"}

package/dist/drop-while-BGbJsU8z.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){for(let[n,r]of e.entries())if(!t(r,n,e))return e.slice(n);return[]}Object.defineProperty(exports,`dropWhile`,{enumerable:!0,get:function(){return t}});