@vinicunca/perkakas 1.15.0 → 1.16.0

package/dist/difference-with.js.map

@@ -1 +1 @@
-{"version":3,"file":"difference-with.js","names":[],"sources":["../src/difference-with.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEqual<T, Other> = (data: T, other: Other) => boolean;\n\n/**\n * Excludes the values from `other` array.\n * Elements are compared by custom comparator isEquals.\n *\n * @param data - The source array.\n * @param other - The values to exclude.\n * @param isEqual - The comparator.\n * @signature\n *    differenceWith(data, other, isEqual)\n * @example\n *    differenceWith(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }],\n *      [2, 5, 3],\n *      ({ a }, b) => a === b,\n *    ); //=> [{ a: 1 }, { a: 4 }]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function differenceWith<T, Other>(\n  data: ReadonlyArray<T>,\n  other: ReadonlyArray<Other>,\n  isEqual: IsEqual<T, Other>,\n): Array<T>;\n\n/**\n * Excludes the values from `other` array.\n * Elements are compared by custom comparator isEquals.\n *\n * @param other - The values to exclude.\n * @param isEqual - The comparator.\n * @signature\n *    differenceWith(other, isEqual)(data)\n * @example\n *    pipe(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }, { a: 6 }],\n *      differenceWith([2, 3], ({ a }, b) => a === b),\n *    ); //=> [{ a: 1 }, { a: 4 }, { a: 5 }, { a: 6 }]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function differenceWith<T, Other>(\n  other: ReadonlyArray<Other>,\n  isEqual: IsEqual<T, Other>,\n): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function differenceWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T, Other>(other: ReadonlyArray<Other>, isEqual: IsEqual<T, Other>): LazyEvaluator<T> {\n  return (value) =>\n    other.every((otherValue) => !isEqual(value, otherValue))\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"kGAqDA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAA6B,EAA6B,EAA8C,CAC/G,MAAQ,IACN,EAAM,MAAO,GAAe,CAAC,EAAQ,EAAO,EAAW,CAAC,CACpD,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3C"}
+{"version":3,"file":"difference-with.js","names":[],"sources":["../src/difference-with.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEqual<T, Other> = (data: T, other: Other) => boolean;\n\n/**\n * Excludes the values from `other` array.\n * Elements are compared by custom comparator isEquals.\n *\n * @param data - The source array.\n * @param other - The values to exclude.\n * @param isEqual - The comparator.\n * @signature\n *    differenceWith(data, other, isEqual)\n * @example\n *    differenceWith(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }],\n *      [2, 5, 3],\n *      ({ a }, b) => a === b,\n *    ); //=> [{ a: 1 }, { a: 4 }]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function differenceWith<T, Other>(\n  data: ReadonlyArray<T>,\n  other: ReadonlyArray<Other>,\n  isEqual: IsEqual<T, Other>,\n): Array<T>;\n\n/**\n * Excludes the values from `other` array.\n * Elements are compared by custom comparator isEquals.\n *\n * @param other - The values to exclude.\n * @param isEqual - The comparator.\n * @signature\n *    differenceWith(other, isEqual)(data)\n * @example\n *    pipe(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }, { a: 6 }],\n *      differenceWith([2, 3], ({ a }, b) => a === b),\n *    ); //=> [{ a: 1 }, { a: 4 }, { a: 5 }, { a: 6 }]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function differenceWith<T, Other>(\n  other: ReadonlyArray<Other>,\n  isEqual: IsEqual<T, Other>,\n): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function differenceWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T, Other>(other: ReadonlyArray<Other>, isEqual: IsEqual<T, Other>): LazyEvaluator<T> {\n  return (value) =>\n    other.every((otherValue) => !isEqual(value, otherValue))\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"kGAqDA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAO,EAAc,EAAoB,CAAI,CAC/C,CAEA,SAAS,EAA6B,EAA6B,EAA8C,CAC/G,MAAQ,IACN,EAAM,MAAO,GAAe,CAAC,EAAQ,EAAO,CAAU,CAAC,EACnD,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EAC1C,CACR"}

package/dist/difference.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utility-evaluators-C8koSp9T.cjs`),t=require(`./curry-from-lazy-BvN_VKlH.cjs`);function n(...e){return t.t(r,e)}function r(t){if(t.length===0)return e.r;let n=new Map;for(let e of t)n.set(e,(n.get(e)??0)+1);return t=>{let r=n.get(t);return r===void 0||r===0?{done:!1,hasNext:!0,next:t}:(n.set(t,r-1),e.t)}}exports.difference=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utility-evaluators-BGM19SpK.cjs"),t=require("./curry-from-lazy-mdjeRP1g.cjs");function n(...e){return t.t(r,e)}function r(t){if(t.length===0)return e.r;let n=new Map;for(let e of t)n.set(e,(n.get(e)??0)+1);return t=>{let r=n.get(t);return r===void 0||r===0?{done:!1,hasNext:!0,next:t}:(n.set(t,r-1),e.t)}}exports.difference=n;
 //# sourceMappingURL=difference.cjs.map

package/dist/difference.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"difference.cjs","names":["curryFromLazy","lazyIdentityEvaluator","SKIP_ITEM"],"sources":["../src/difference.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { lazyIdentityEvaluator, SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param data - The input items.\n * @param other - The values to exclude.\n * @signature\n *    difference(data, other)\n * @example\n *    difference([1, 2, 3, 4], [2, 5, 3]); // => [1, 4]\n *    difference([1, 1, 2, 2], [1]); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(data: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param other - The values to exclude.\n * @signature\n *    difference(other)(data)\n * @example\n *    pipe([1, 2, 3, 4], difference([2, 5, 3])); // => [1, 4]\n *    pipe([1, 1, 2, 2], difference([1])); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(other: ReadonlyArray<T>): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function difference(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(other: ReadonlyArray<T>): LazyEvaluator<T> {\n  if (other.length === 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  // We need to build a more efficient data structure that would allow us to\n  // keep track of the number of times we've seen a value in the other array.\n  const remaining = new Map<T, number>();\n  for (const value of other) {\n    remaining.set(value, (remaining.get(value) ?? 0) + 1);\n  }\n\n  return (value) => {\n    const copies = remaining.get(value);\n\n    if (copies === undefined || copies === 0) {\n      // The item is either not part of the other array or we've dropped enough\n      // copies of it so we return it.\n      return { done: false, hasNext: true, next: value };\n    }\n\n    // The item is equal to an item in the other array and there are still\n    // copies of it to \"account\" for so we skip this one and remove it from our\n    // ongoing tally.\n    remaining.set(value, copies - 1);\n    return SKIP_ITEM;\n  };\n}\n"],"mappings":"oKAuCA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAA2C,CACxE,GAAI,EAAM,SAAW,EACnB,OAAOC,EAAAA,EAKT,IAAM,EAAY,IAAI,IACtB,IAAK,IAAM,KAAS,EAClB,EAAU,IAAI,GAAQ,EAAU,IAAI,EAAM,EAAI,GAAK,EAAE,CAGvD,MAAQ,IAAU,CAChB,IAAM,EAAS,EAAU,IAAI,EAAM,CAYnC,OAVI,IAAW,IAAA,IAAa,IAAW,EAG9B,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,EAMpD,EAAU,IAAI,EAAO,EAAS,EAAE,CACzBC,EAAAA"}
+{"version":3,"file":"difference.cjs","names":["curryFromLazy","lazyIdentityEvaluator","SKIP_ITEM"],"sources":["../src/difference.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { lazyIdentityEvaluator, SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param data - The input items.\n * @param other - The values to exclude.\n * @signature\n *    difference(data, other)\n * @example\n *    difference([1, 2, 3, 4], [2, 5, 3]); // => [1, 4]\n *    difference([1, 1, 2, 2], [1]); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(data: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param other - The values to exclude.\n * @signature\n *    difference(other)(data)\n * @example\n *    pipe([1, 2, 3, 4], difference([2, 5, 3])); // => [1, 4]\n *    pipe([1, 1, 2, 2], difference([1])); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(other: ReadonlyArray<T>): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function difference(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(other: ReadonlyArray<T>): LazyEvaluator<T> {\n  if (other.length === 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  // We need to build a more efficient data structure that would allow us to\n  // keep track of the number of times we've seen a value in the other array.\n  const remaining = new Map<T, number>();\n  for (const value of other) {\n    remaining.set(value, (remaining.get(value) ?? 0) + 1);\n  }\n\n  return (value) => {\n    const copies = remaining.get(value);\n\n    if (copies === undefined || copies === 0) {\n      // The item is either not part of the other array or we've dropped enough\n      // copies of it so we return it.\n      return { done: false, hasNext: true, next: value };\n    }\n\n    // The item is equal to an item in the other array and there are still\n    // copies of it to \"account\" for so we skip this one and remove it from our\n    // ongoing tally.\n    remaining.set(value, copies - 1);\n    return SKIP_ITEM;\n  };\n}\n"],"mappings":"oKAuCA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,EAAc,EAAoB,CAAI,CAC/C,CAEA,SAAS,EAAsB,EAA2C,CACxE,GAAI,EAAM,SAAW,EACnB,OAAOC,EAAAA,EAKT,IAAM,EAAY,IAAI,IACtB,IAAK,IAAM,KAAS,EAClB,EAAU,IAAI,GAAQ,EAAU,IAAI,CAAK,GAAK,GAAK,CAAC,EAGtD,MAAQ,IAAU,CAChB,IAAM,EAAS,EAAU,IAAI,CAAK,EAYlC,OAVI,IAAW,IAAA,IAAa,IAAW,EAG9B,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,GAMnD,EAAU,IAAI,EAAO,EAAS,CAAC,EACxBC,EAAAA,EACT,CACF"}

package/dist/difference.js

@@ -1,2 +1,2 @@
-import{r as e,t}from"./utility-evaluators-ZAaUtL2Z.js";import{t as n}from"./curry-from-lazy-CtH1dp14.js";function r(...e){return n(i,e)}function i(n){if(n.length===0)return e;let r=new Map;for(let e of n)r.set(e,(r.get(e)??0)+1);return e=>{let n=r.get(e);return n===void 0||n===0?{done:!1,hasNext:!0,next:e}:(r.set(e,n-1),t)}}export{r as difference};
+import{r as e,t}from"./utility-evaluators-DDW55xeL.js";import{t as n}from"./curry-from-lazy-BoPMn2L_.js";function r(...e){return n(i,e)}function i(n){if(n.length===0)return e;let r=new Map;for(let e of n)r.set(e,(r.get(e)??0)+1);return e=>{let n=r.get(e);return n===void 0||n===0?{done:!1,hasNext:!0,next:e}:(r.set(e,n-1),t)}}export{r as difference};
 //# sourceMappingURL=difference.js.map

package/dist/difference.js.map

@@ -1 +1 @@
-{"version":3,"file":"difference.js","names":[],"sources":["../src/difference.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { lazyIdentityEvaluator, SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param data - The input items.\n * @param other - The values to exclude.\n * @signature\n *    difference(data, other)\n * @example\n *    difference([1, 2, 3, 4], [2, 5, 3]); // => [1, 4]\n *    difference([1, 1, 2, 2], [1]); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(data: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param other - The values to exclude.\n * @signature\n *    difference(other)(data)\n * @example\n *    pipe([1, 2, 3, 4], difference([2, 5, 3])); // => [1, 4]\n *    pipe([1, 1, 2, 2], difference([1])); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(other: ReadonlyArray<T>): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function difference(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(other: ReadonlyArray<T>): LazyEvaluator<T> {\n  if (other.length === 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  // We need to build a more efficient data structure that would allow us to\n  // keep track of the number of times we've seen a value in the other array.\n  const remaining = new Map<T, number>();\n  for (const value of other) {\n    remaining.set(value, (remaining.get(value) ?? 0) + 1);\n  }\n\n  return (value) => {\n    const copies = remaining.get(value);\n\n    if (copies === undefined || copies === 0) {\n      // The item is either not part of the other array or we've dropped enough\n      // copies of it so we return it.\n      return { done: false, hasNext: true, next: value };\n    }\n\n    // The item is equal to an item in the other array and there are still\n    // copies of it to \"account\" for so we skip this one and remove it from our\n    // ongoing tally.\n    remaining.set(value, copies - 1);\n    return SKIP_ITEM;\n  };\n}\n"],"mappings":"yGAuCA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAA2C,CACxE,GAAI,EAAM,SAAW,EACnB,OAAO,EAKT,IAAM,EAAY,IAAI,IACtB,IAAK,IAAM,KAAS,EAClB,EAAU,IAAI,GAAQ,EAAU,IAAI,EAAM,EAAI,GAAK,EAAE,CAGvD,MAAQ,IAAU,CAChB,IAAM,EAAS,EAAU,IAAI,EAAM,CAYnC,OAVI,IAAW,IAAA,IAAa,IAAW,EAG9B,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,EAMpD,EAAU,IAAI,EAAO,EAAS,EAAE,CACzB"}
+{"version":3,"file":"difference.js","names":[],"sources":["../src/difference.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { lazyIdentityEvaluator, SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param data - The input items.\n * @param other - The values to exclude.\n * @signature\n *    difference(data, other)\n * @example\n *    difference([1, 2, 3, 4], [2, 5, 3]); // => [1, 4]\n *    difference([1, 1, 2, 2], [1]); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(data: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T>;\n\n/**\n * Excludes the values from `other` array. The output maintains the same order\n * as the input. The inputs are treated as multi-sets/bags (multiple copies of\n * items are treated as unique items).\n *\n * @param other - The values to exclude.\n * @signature\n *    difference(other)(data)\n * @example\n *    pipe([1, 2, 3, 4], difference([2, 5, 3])); // => [1, 4]\n *    pipe([1, 1, 2, 2], difference([1])); // => [1, 2, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function difference<T>(other: ReadonlyArray<T>): (data: ReadonlyArray<T>) => Array<T>;\n\nexport function difference(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(other: ReadonlyArray<T>): LazyEvaluator<T> {\n  if (other.length === 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  // We need to build a more efficient data structure that would allow us to\n  // keep track of the number of times we've seen a value in the other array.\n  const remaining = new Map<T, number>();\n  for (const value of other) {\n    remaining.set(value, (remaining.get(value) ?? 0) + 1);\n  }\n\n  return (value) => {\n    const copies = remaining.get(value);\n\n    if (copies === undefined || copies === 0) {\n      // The item is either not part of the other array or we've dropped enough\n      // copies of it so we return it.\n      return { done: false, hasNext: true, next: value };\n    }\n\n    // The item is equal to an item in the other array and there are still\n    // copies of it to \"account\" for so we skip this one and remove it from our\n    // ongoing tally.\n    remaining.set(value, copies - 1);\n    return SKIP_ITEM;\n  };\n}\n"],"mappings":"yGAuCA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAc,EAAoB,CAAI,CAC/C,CAEA,SAAS,EAAsB,EAA2C,CACxE,GAAI,EAAM,SAAW,EACnB,OAAO,EAKT,IAAM,EAAY,IAAI,IACtB,IAAK,IAAM,KAAS,EAClB,EAAU,IAAI,GAAQ,EAAU,IAAI,CAAK,GAAK,GAAK,CAAC,EAGtD,MAAQ,IAAU,CAChB,IAAM,EAAS,EAAU,IAAI,CAAK,EAYlC,OAVI,IAAW,IAAA,IAAa,IAAW,EAG9B,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,GAMnD,EAAU,IAAI,EAAO,EAAS,CAAC,EACxB,EACT,CACF"}

package/dist/divide.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e/t}exports.divide=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){return e/t}exports.divide=t;
 //# sourceMappingURL=divide.cjs.map

package/dist/divide.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"divide.cjs","names":["curry"],"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 *    divide(value, divisor);\n * @example\n *    divide(12, 3) // => 4\n *    reduce([1, 2, 3, 4], 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 *    divide(divisor)(value);\n * @example\n *    divide(3)(12) // => 4\n *    map([2, 4, 6, 8], 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\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and divisor would be of the same\n// type.\nfunction divideImplementation(value: number, divisor: number): number {\n  return value / divisor;\n}\n"],"mappings":"kGAiCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAM1C,SAAS,EAAqB,EAAe,EAAyB,CACpE,OAAO,EAAQ"}
+{"version":3,"file":"divide.cjs","names":["curry"],"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 *    divide(value, divisor);\n * @example\n *    divide(12, 3) // => 4\n *    reduce([1, 2, 3, 4], 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 *    divide(divisor)(value);\n * @example\n *    divide(3)(12) // => 4\n *    map([2, 4, 6, 8], 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\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and divisor would be of the same\n// type.\nfunction divideImplementation(value: number, divisor: number): number {\n  return value / divisor;\n}\n"],"mappings":"kGAiCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,CAAI,CACzC,CAKA,SAAS,EAAqB,EAAe,EAAyB,CACpE,OAAO,EAAQ,CACjB"}

package/dist/divide.js.map

@@ -1 +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 *    divide(value, divisor);\n * @example\n *    divide(12, 3) // => 4\n *    reduce([1, 2, 3, 4], 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 *    divide(divisor)(value);\n * @example\n *    divide(3)(12) // => 4\n *    map([2, 4, 6, 8], 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\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and divisor would be of the same\n// type.\nfunction divideImplementation(value: number, divisor: number): number {\n  return value / divisor;\n}\n"],"mappings":"mCAiCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAM1C,SAAS,EAAqB,EAAe,EAAyB,CACpE,OAAO,EAAQ"}
+{"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 *    divide(value, divisor);\n * @example\n *    divide(12, 3) // => 4\n *    reduce([1, 2, 3, 4], 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 *    divide(divisor)(value);\n * @example\n *    divide(3)(12) // => 4\n *    map([2, 4, 6, 8], 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\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and divisor would be of the same\n// type.\nfunction divideImplementation(value: number, divisor: number): number {\n  return value / divisor;\n}\n"],"mappings":"mCAiCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,CAAI,CACzC,CAKA,SAAS,EAAqB,EAAe,EAAyB,CACpE,OAAO,EAAQ,CACjB"}

package/dist/do-nothing.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"do-nothing.cjs","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 *   doNothing();\n * @example\n *   myApi({ onSuccess: handleSuccess, onError: doNothing() });\n *   myApi({ onSuccess: isDemoMode ? doNothing(): handleSuccess });\n * @dataLast\n * @category Function\n */\nexport function doNothing(): typeof doesNothing {\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  return doesNothing;\n}\n\nfunction doesNothing<Args extends ReadonlyArray<unknown>>(..._args: Args): void {\n  /* do nothing */\n}\n"],"mappings":"mEAsBA,SAAgB,GAAgC,CAK9C,OAAO,EAGT,SAAS,EAAiD,GAAG,EAAmB"}
+{"version":3,"file":"do-nothing.cjs","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 *   doNothing();\n * @example\n *   myApi({ onSuccess: handleSuccess, onError: doNothing() });\n *   myApi({ onSuccess: isDemoMode ? doNothing(): handleSuccess });\n * @dataLast\n * @category Function\n */\nexport function doNothing(): typeof doesNothing {\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  return doesNothing;\n}\n\nfunction doesNothing<Args extends ReadonlyArray<unknown>>(..._args: Args): void {\n  /* do nothing */\n}\n"],"mappings":"mEAsBA,SAAgB,GAAgC,CAK9C,OAAO,CACT,CAEA,SAAS,EAAiD,GAAG,EAAmB,CAEhF"}

package/dist/do-nothing.js.map

@@ -1 +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 *   doNothing();\n * @example\n *   myApi({ onSuccess: handleSuccess, onError: doNothing() });\n *   myApi({ onSuccess: isDemoMode ? doNothing(): handleSuccess });\n * @dataLast\n * @category Function\n */\nexport function doNothing(): typeof doesNothing {\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  return doesNothing;\n}\n\nfunction doesNothing<Args extends ReadonlyArray<unknown>>(..._args: Args): void {\n  /* do nothing */\n}\n"],"mappings":"AAsBA,SAAgB,GAAgC,CAK9C,OAAO,EAGT,SAAS,EAAiD,GAAG,EAAmB"}
+{"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 *   doNothing();\n * @example\n *   myApi({ onSuccess: handleSuccess, onError: doNothing() });\n *   myApi({ onSuccess: isDemoMode ? doNothing(): handleSuccess });\n * @dataLast\n * @category Function\n */\nexport function doNothing(): typeof doesNothing {\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  return doesNothing;\n}\n\nfunction doesNothing<Args extends ReadonlyArray<unknown>>(..._args: Args): void {\n  /* do nothing */\n}\n"],"mappings":"AAsBA,SAAgB,GAAgC,CAK9C,OAAO,CACT,CAEA,SAAS,EAAiD,GAAG,EAAmB,CAEhF"}

package/dist/drop-first-by.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry-order-rules-DsJSy3gX.cjs`),t=require(`./heap-C0zPQGC0.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;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry-order-rules-CacOTzfW.cjs"),t=require("./heap-BK0Y5t1Y.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;
 //# sourceMappingURL=drop-first-by.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"drop-first-by.cjs","names":["curryOrderRulesWithArgument","heapMaybeInsert"],"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 *   dropFirstBy(data, n, ...rules);\n * @example\n *   dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaaa', 'aaa']\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 *   dropFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], dropFirstBy(2, x => x.length)); // => ['aaaa', 'aaa']\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":"wJAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,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,EAAA,EAAQ,EAAM,EAAU,CAExB,IAAM,EAAM,EAAE,CAER,EAAO,EAAK,MAAM,EAAE,CAC1B,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAeC,EAAAA,EAAgB,EAAM,EAAW,EAAK,CAC3D,EAAI,KAAK,GAAgB,EAAK,CAGhC,OAAO"}
+{"version":3,"file":"drop-first-by.cjs","names":["curryOrderRulesWithArgument","heapMaybeInsert"],"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 *   dropFirstBy(data, n, ...rules);\n * @example\n *   dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaaa', 'aaa']\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 *   dropFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], dropFirstBy(2, x => x.length)); // => ['aaaa', 'aaa']\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":"wJAmDA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,EAA4B,EAA2B,CAAI,CACpE,CAEA,SAAS,EACP,EACA,EACA,EACU,CACV,GAAI,GAAK,EAAK,OACZ,MAAO,CAAC,EAGV,GAAI,GAAK,EACP,MAAO,CAAC,GAAG,CAAI,EAGjB,IAAM,EAAO,EAAK,MAAM,EAAG,CAAC,EAC5B,EAAA,EAAQ,EAAM,CAAS,EAEvB,IAAM,EAAM,CAAC,EAEP,EAAO,EAAK,MAAM,CAAC,EACzB,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAeC,EAAAA,EAAgB,EAAM,EAAW,CAAI,EAC1D,EAAI,KAAK,GAAgB,CAAI,CAC/B,CAEA,OAAO,CACT"}

package/dist/drop-first-by.js

@@ -1,2 +1,2 @@
-import{n as e}from"./curry-order-rules-BLyCSMdZ.js";import{n as t,t as n}from"./heap-M6D40vkc.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};
+import{n as e}from"./curry-order-rules-Dage-BeC.js";import{n as t,t as n}from"./heap-CL5ahv5n.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

@@ -1 +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 *   dropFirstBy(data, n, ...rules);\n * @example\n *   dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaaa', 'aaa']\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 *   dropFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], dropFirstBy(2, x => x.length)); // => ['aaaa', 'aaa']\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"}
+{"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 *   dropFirstBy(data, n, ...rules);\n * @example\n *   dropFirstBy(['aa', 'aaaa', 'a', 'aaa'], 2, x => x.length); // => ['aaaa', 'aaa']\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 *   dropFirstBy(n, ...rules)(data);\n * @example\n *   pipe(['aa', 'aaaa', 'a', 'aaa'], dropFirstBy(2, x => x.length)); // => ['aaaa', 'aaa']\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,CAAI,CACpE,CAEA,SAAS,EACP,EACA,EACA,EACU,CACV,GAAI,GAAK,EAAK,OACZ,MAAO,CAAC,EAGV,GAAI,GAAK,EACP,MAAO,CAAC,GAAG,CAAI,EAGjB,IAAM,EAAO,EAAK,MAAM,EAAG,CAAC,EAC5B,EAAQ,EAAM,CAAS,EAEvB,IAAM,EAAM,CAAC,EAEP,EAAO,EAAK,MAAM,CAAC,EACzB,IAAK,IAAM,KAAQ,EAAM,CACvB,IAAM,EAAe,EAAgB,EAAM,EAAW,CAAI,EAC1D,EAAI,KAAK,GAAgB,CAAI,CAC/B,CAEA,OAAO,CACT"}

package/dist/drop-last-while.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.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[]}exports.dropLastWhile=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.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[]}exports.dropLastWhile=t;
 //# sourceMappingURL=drop-last-while.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"drop-last-while.cjs","names":["curry"],"sources":["../src/drop-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\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 *    dropLastWhile(data, predicate)\n * @example\n *    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 *    dropLastWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4], 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":"kGAuCA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,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"}
+{"version":3,"file":"drop-last-while.cjs","names":["curry"],"sources":["../src/drop-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\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 *    dropLastWhile(data, predicate)\n * @example\n *    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 *    dropLastWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4], 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":"kGAuCA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,EAA6B,CAAI,CAChD,CAEA,SAAS,EACP,EACA,EACkB,CAClB,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,CAAC,EAAU,EAAK,GAAI,EAAG,CAAI,EAC7B,OAAO,EAAK,MAAM,EAAG,EAAI,CAAC,EAG9B,MAAO,CAAC,CACV"}

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

@@ -1 +1 @@
-{"version":3,"file":"drop-last-while.js","names":[],"sources":["../src/drop-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\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 *    dropLastWhile(data, predicate)\n * @example\n *    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 *    dropLastWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4], 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":"mCAuCA,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"}
+{"version":3,"file":"drop-last-while.js","names":[],"sources":["../src/drop-last-while.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\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 *    dropLastWhile(data, predicate)\n * @example\n *    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 *    dropLastWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4], 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":"mCAuCA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA6B,CAAI,CAChD,CAEA,SAAS,EACP,EACA,EACkB,CAClB,IAAK,IAAI,EAAI,EAAK,OAAS,EAAG,GAAK,EAAG,IACpC,GAAI,CAAC,EAAU,EAAK,GAAI,EAAG,CAAI,EAC7B,OAAO,EAAK,MAAM,EAAG,EAAI,CAAC,EAG9B,MAAO,CAAC,CACV"}

package/dist/drop-last.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.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]}exports.dropLast=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.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]}exports.dropLast=t;
 //# sourceMappingURL=drop-last.cjs.map

package/dist/drop-last.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"drop-last.cjs","names":["curry"],"sources":["../src/drop-last.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\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 *    dropLast(array, n)\n * @example\n *    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 *    dropLast(n)(array)\n * @example\n *    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>(array: T, n: number): Array<T[number]> {\n  return n > 0 ? array.slice(0, Math.max(0, array.length - n)) : [...array];\n}\n"],"mappings":"kGAmCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAG5C,SAAS,EAAoD,EAAU,EAA6B,CAClG,OAAO,EAAI,EAAI,EAAM,MAAM,EAAG,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,CAAC,GAAG,EAAM"}
+{"version":3,"file":"drop-last.cjs","names":["curry"],"sources":["../src/drop-last.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Removes last `n` elements from the `array`.\n *\n * Related operations:\n * - `drop` - same, but from the start of the array.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `takeLast` - to keep the last `n` instead.\n *\n * @param array - The target array.\n * @param n - The number of elements to skip.\n * @signature\n *    dropLast(array, n)\n * @example\n *    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 * Related operations:\n * - `drop` - same, but from the start of the array.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `takeLast` - to keep the last `n` instead.\n *\n * @param n - The number of elements to skip.\n * @signature\n *    dropLast(n)(array)\n * @example\n *    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>(array: T, n: number): Array<T[number]> {\n  return n > 0 ? array.slice(0, Math.max(0, array.length - n)) : [...array];\n}\n"],"mappings":"kGA6CA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EAAoD,EAAU,EAA6B,CAClG,OAAO,EAAI,EAAI,EAAM,MAAM,EAAG,KAAK,IAAI,EAAG,EAAM,OAAS,CAAC,CAAC,EAAI,CAAC,GAAG,CAAK,CAC1E"}

package/dist/drop-last.js.map

@@ -1 +1 @@
-{"version":3,"file":"drop-last.js","names":[],"sources":["../src/drop-last.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\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 *    dropLast(array, n)\n * @example\n *    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 *    dropLast(n)(array)\n * @example\n *    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>(array: T, n: number): Array<T[number]> {\n  return n > 0 ? array.slice(0, Math.max(0, array.length - n)) : [...array];\n}\n"],"mappings":"mCAmCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EAAoD,EAAU,EAA6B,CAClG,OAAO,EAAI,EAAI,EAAM,MAAM,EAAG,KAAK,IAAI,EAAG,EAAM,OAAS,EAAE,CAAC,CAAG,CAAC,GAAG,EAAM"}
+{"version":3,"file":"drop-last.js","names":[],"sources":["../src/drop-last.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Removes last `n` elements from the `array`.\n *\n * Related operations:\n * - `drop` - same, but from the start of the array.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `takeLast` - to keep the last `n` instead.\n *\n * @param array - The target array.\n * @param n - The number of elements to skip.\n * @signature\n *    dropLast(array, n)\n * @example\n *    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 * Related operations:\n * - `drop` - same, but from the start of the array.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `takeLast` - to keep the last `n` instead.\n *\n * @param n - The number of elements to skip.\n * @signature\n *    dropLast(n)(array)\n * @example\n *    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>(array: T, n: number): Array<T[number]> {\n  return n > 0 ? array.slice(0, Math.max(0, array.length - n)) : [...array];\n}\n"],"mappings":"mCA6CA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EAAoD,EAAU,EAA6B,CAClG,OAAO,EAAI,EAAI,EAAM,MAAM,EAAG,KAAK,IAAI,EAAG,EAAM,OAAS,CAAC,CAAC,EAAI,CAAC,GAAG,CAAK,CAC1E"}

package/dist/drop-while.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.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[]}exports.dropWhile=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.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[]}exports.dropWhile=t;
 //# sourceMappingURL=drop-while.cjs.map

package/dist/drop-while.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"drop-while.cjs","names":["curry"],"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 *    dropWhile(data, predicate)\n * @example\n *    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 *    dropWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4], 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":"kGAuCA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,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"}
+{"version":3,"file":"drop-while.cjs","names":["curry"],"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 *    dropWhile(data, predicate)\n * @example\n *    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 *    dropWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4], 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":"kGAuCA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,EAAyB,CAAI,CAC5C,CAEA,SAAS,EACP,EACA,EACkB,CAClB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,QAAQ,EACvC,GAAI,CAAC,EAAU,EAAM,EAAO,CAAI,EAC9B,OAAO,EAAK,MAAM,CAAK,EAG3B,MAAO,CAAC,CACV"}

package/dist/drop-while.js.map

@@ -1 +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 *    dropWhile(data, predicate)\n * @example\n *    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 *    dropWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4], 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":"mCAuCA,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"}
+{"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 *    dropWhile(data, predicate)\n * @example\n *    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 *    dropWhile(predicate)(data)\n * @example\n *    pipe([1, 2, 10, 3, 4], 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":"mCAuCA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,CAAI,CAC5C,CAEA,SAAS,EACP,EACA,EACkB,CAClB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,QAAQ,EACvC,GAAI,CAAC,EAAU,EAAM,EAAO,CAAI,EAC9B,OAAO,EAAK,MAAM,CAAK,EAG3B,MAAO,CAAC,CACV"}

package/dist/drop.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./utility-evaluators-C8koSp9T.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.r;let n=e;return e=>n>0?(--n,t.t):{done:!1,hasNext:!0,next:e}}exports.drop=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs"),t=require("./utility-evaluators-BGM19SpK.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.r;let n=e;return e=>n>0?(--n,t.t):{done:!1,hasNext:!0,next:e}}exports.drop=n;
 //# sourceMappingURL=drop.cjs.map

package/dist/drop.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"drop.cjs","names":["curry","lazyIdentityEvaluator","SKIP_ITEM"],"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 true\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\n            // possible (relevant) lengths. We start by considering the\n            // case where there are enough elements within the rest\n            // param; this means we still maintain the rest element as it\n            // could contain even more elements, and we add the suffix\n            // 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      : // 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\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    ?\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 *    drop(array, n)\n * @example\n *    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 *    drop(n)(array)\n * @example\n *    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>(array: T, n: number): 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":"iJAmIA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAM,EAAmB,CAG5D,SAAS,EAAgD,EAAU,EAA6B,CAC9F,OAAO,EAAI,EAAI,CAAC,GAAG,EAAM,CAAG,EAAM,MAAM,EAAE,CAG5C,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAOC,EAAAA,EAGT,IAAI,EAAO,EACX,MAAQ,IACF,EAAO,GACT,IACOC,EAAAA,GAEF,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"drop.cjs","names":["curry","lazyIdentityEvaluator","SKIP_ITEM"],"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 true\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\n            // possible (relevant) lengths. We start by considering the\n            // case where there are enough elements within the rest\n            // param; this means we still maintain the rest element as it\n            // could contain even more elements, and we add the suffix\n            // 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      : // 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\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    ?\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 * Related operations:\n * - `dropLast` - same, but from the end of the array.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `take` - to keep the first `n` instead.\n *\n * @param array - The target array.\n * @param n - The number of elements to skip.\n * @signature\n *    drop(array, n)\n * @example\n *    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 * Related operations:\n * - `dropLast` - same, but from the end of the array.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `take` - to keep the first `n` instead.\n *\n * @param n - The number of elements to skip.\n * @signature\n *    drop(n)(array)\n * @example\n *    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>(array: T, n: number): 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":"iJA6IA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAM,CAAkB,CAC3D,CAEA,SAAS,EAAgD,EAAU,EAA6B,CAC9F,OAAO,EAAI,EAAI,CAAC,GAAG,CAAK,EAAI,EAAM,MAAM,CAAC,CAC3C,CAEA,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAOC,EAAAA,EAGT,IAAI,EAAO,EACX,MAAQ,IACF,EAAO,GACT,IACOC,EAAAA,GAEF,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,CAErD"}

package/dist/drop.js

@@ -1,2 +1,2 @@
-import{curry as e}from"./curry.js";import{r as t,t as n}from"./utility-evaluators-ZAaUtL2Z.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 t;let r=e;return e=>r>0?(--r,n):{done:!1,hasNext:!0,next:e}}export{r as drop};
+import{curry as e}from"./curry.js";import{r as t,t as n}from"./utility-evaluators-DDW55xeL.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 t;let r=e;return e=>r>0?(--r,n):{done:!1,hasNext:!0,next:e}}export{r as drop};
 //# sourceMappingURL=drop.js.map

package/dist/drop.js.map

@@ -1 +1 @@
-{"version":3,"file":"drop.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 true\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\n            // possible (relevant) lengths. We start by considering the\n            // case where there are enough elements within the rest\n            // param; this means we still maintain the rest element as it\n            // could contain even more elements, and we add the suffix\n            // 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      : // 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\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    ?\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 *    drop(array, n)\n * @example\n *    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 *    drop(n)(array)\n * @example\n *    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>(array: T, n: number): 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":"+FAmIA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,EAAmB,CAG5D,SAAS,EAAgD,EAAU,EAA6B,CAC9F,OAAO,EAAI,EAAI,CAAC,GAAG,EAAM,CAAG,EAAM,MAAM,EAAE,CAG5C,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"}
+{"version":3,"file":"drop.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 true\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\n            // possible (relevant) lengths. We start by considering the\n            // case where there are enough elements within the rest\n            // param; this means we still maintain the rest element as it\n            // could contain even more elements, and we add the suffix\n            // 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      : // 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\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    ?\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 * Related operations:\n * - `dropLast` - same, but from the end of the array.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `take` - to keep the first `n` instead.\n *\n * @param array - The target array.\n * @param n - The number of elements to skip.\n * @signature\n *    drop(array, n)\n * @example\n *    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 * Related operations:\n * - `dropLast` - same, but from the end of the array.\n * - `splice` - to remove or insert at an arbitrary index.\n * - `take` - to keep the first `n` instead.\n *\n * @param n - The number of elements to skip.\n * @signature\n *    drop(n)(array)\n * @example\n *    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>(array: T, n: number): 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":"+FA6IA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAM,CAAkB,CAC3D,CAEA,SAAS,EAAgD,EAAU,EAA6B,CAC9F,OAAO,EAAI,EAAI,CAAC,GAAG,CAAK,EAAI,EAAM,MAAM,CAAC,CAC3C,CAEA,SAAS,EAAsB,EAA6B,CAC1D,GAAI,GAAK,EACP,OAAO,EAGT,IAAI,EAAO,EACX,MAAQ,IACF,EAAO,GACT,IACO,GAEF,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,CAErD"}

package/dist/ends-with.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e.endsWith(t)}exports.endsWith=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){return e.endsWith(t)}exports.endsWith=t;
 //# sourceMappingURL=ends-with.cjs.map

package/dist/ends-with.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ends-with.cjs","names":["curry"],"sources":["../src/ends-with.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether a string ends with the provided suffix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)\n * method, but doesn't expose the `endPosition` parameter. To check only up to a\n * specific position, use `endsWith(sliceString(data, 0, endPosition), suffix)`.\n *\n * @param data - The input string.\n * @param suffix - The string to check for at the end.\n * @signature\n *   endsWith(data, suffix);\n * @example\n *   endsWith(\"hello world\", \"hello\"); // false\n *   endsWith(\"hello world\", \"world\"); // true\n * @dataFirst\n * @category String\n */\nexport function endsWith<T extends string, Suffix extends string>(\n  data: T,\n  suffix: string extends Suffix ? never : Suffix,\n): data is T & `${string}${Suffix}`;\nexport function endsWith(data: string, suffix: string): boolean;\n\n/**\n * Determines whether a string ends with the provided suffix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)\n * method, but doesn't expose the `endPosition` parameter. To check only up to a\n * specific position, use `endsWith(sliceString(data, 0, endPosition), suffix)`.\n *\n * @param suffix - The string to check for at the end.\n * @signature\n *   endsWith(suffix)(data);\n * @example\n *   pipe(\"hello world\", endsWith(\"hello\")); // false\n *   pipe(\"hello world\", endsWith(\"world\")); // true\n * @dataLast\n * @category String\n */\nexport function endsWith<Suffix extends string>(\n  suffix: string extends Suffix ? never : Suffix,\n): <T extends string>(data: T) => data is T & `${string}${Suffix}`;\nexport function endsWith(suffix: string): (data: string) => boolean;\n\nexport function endsWith(...args: ReadonlyArray<unknown>): unknown {\n  return curry(endsWithImplementation, args);\n}\n\nfunction endsWithImplementation(data: string, suffix: string): boolean {\n  return data.endsWith(suffix);\n}\n"],"mappings":"kGAgDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAG5C,SAAS,EAAuB,EAAc,EAAyB,CACrE,OAAO,EAAK,SAAS,EAAO"}
+{"version":3,"file":"ends-with.cjs","names":["curry"],"sources":["../src/ends-with.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether a string ends with the provided suffix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)\n * method, but doesn't expose the `endPosition` parameter. To check only up to a\n * specific position, use `endsWith(sliceString(data, 0, endPosition), suffix)`.\n *\n * @param data - The input string.\n * @param suffix - The string to check for at the end.\n * @signature\n *   endsWith(data, suffix);\n * @example\n *   endsWith(\"hello world\", \"hello\"); // false\n *   endsWith(\"hello world\", \"world\"); // true\n * @dataFirst\n * @category String\n */\nexport function endsWith<T extends string, Suffix extends string>(\n  data: T,\n  suffix: string extends Suffix ? never : Suffix,\n): data is T & `${string}${Suffix}`;\nexport function endsWith(data: string, suffix: string): boolean;\n\n/**\n * Determines whether a string ends with the provided suffix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)\n * method, but doesn't expose the `endPosition` parameter. To check only up to a\n * specific position, use `endsWith(sliceString(data, 0, endPosition), suffix)`.\n *\n * @param suffix - The string to check for at the end.\n * @signature\n *   endsWith(suffix)(data);\n * @example\n *   pipe(\"hello world\", endsWith(\"hello\")); // false\n *   pipe(\"hello world\", endsWith(\"world\")); // true\n * @dataLast\n * @category String\n */\nexport function endsWith<Suffix extends string>(\n  suffix: string extends Suffix ? never : Suffix,\n): <T extends string>(data: T) => data is T & `${string}${Suffix}`;\nexport function endsWith(suffix: string): (data: string) => boolean;\n\nexport function endsWith(...args: ReadonlyArray<unknown>): unknown {\n  return curry(endsWithImplementation, args);\n}\n\nfunction endsWithImplementation(data: string, suffix: string): boolean {\n  return data.endsWith(suffix);\n}\n"],"mappings":"kGAgDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EAAuB,EAAc,EAAyB,CACrE,OAAO,EAAK,SAAS,CAAM,CAC7B"}

package/dist/ends-with.js.map

@@ -1 +1 @@
-{"version":3,"file":"ends-with.js","names":[],"sources":["../src/ends-with.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether a string ends with the provided suffix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)\n * method, but doesn't expose the `endPosition` parameter. To check only up to a\n * specific position, use `endsWith(sliceString(data, 0, endPosition), suffix)`.\n *\n * @param data - The input string.\n * @param suffix - The string to check for at the end.\n * @signature\n *   endsWith(data, suffix);\n * @example\n *   endsWith(\"hello world\", \"hello\"); // false\n *   endsWith(\"hello world\", \"world\"); // true\n * @dataFirst\n * @category String\n */\nexport function endsWith<T extends string, Suffix extends string>(\n  data: T,\n  suffix: string extends Suffix ? never : Suffix,\n): data is T & `${string}${Suffix}`;\nexport function endsWith(data: string, suffix: string): boolean;\n\n/**\n * Determines whether a string ends with the provided suffix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)\n * method, but doesn't expose the `endPosition` parameter. To check only up to a\n * specific position, use `endsWith(sliceString(data, 0, endPosition), suffix)`.\n *\n * @param suffix - The string to check for at the end.\n * @signature\n *   endsWith(suffix)(data);\n * @example\n *   pipe(\"hello world\", endsWith(\"hello\")); // false\n *   pipe(\"hello world\", endsWith(\"world\")); // true\n * @dataLast\n * @category String\n */\nexport function endsWith<Suffix extends string>(\n  suffix: string extends Suffix ? never : Suffix,\n): <T extends string>(data: T) => data is T & `${string}${Suffix}`;\nexport function endsWith(suffix: string): (data: string) => boolean;\n\nexport function endsWith(...args: ReadonlyArray<unknown>): unknown {\n  return curry(endsWithImplementation, args);\n}\n\nfunction endsWithImplementation(data: string, suffix: string): boolean {\n  return data.endsWith(suffix);\n}\n"],"mappings":"mCAgDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EAAuB,EAAc,EAAyB,CACrE,OAAO,EAAK,SAAS,EAAO"}
+{"version":3,"file":"ends-with.js","names":[],"sources":["../src/ends-with.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether a string ends with the provided suffix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)\n * method, but doesn't expose the `endPosition` parameter. To check only up to a\n * specific position, use `endsWith(sliceString(data, 0, endPosition), suffix)`.\n *\n * @param data - The input string.\n * @param suffix - The string to check for at the end.\n * @signature\n *   endsWith(data, suffix);\n * @example\n *   endsWith(\"hello world\", \"hello\"); // false\n *   endsWith(\"hello world\", \"world\"); // true\n * @dataFirst\n * @category String\n */\nexport function endsWith<T extends string, Suffix extends string>(\n  data: T,\n  suffix: string extends Suffix ? never : Suffix,\n): data is T & `${string}${Suffix}`;\nexport function endsWith(data: string, suffix: string): boolean;\n\n/**\n * Determines whether a string ends with the provided suffix, and refines the\n * output type if possible.\n *\n * This function is a wrapper around the built-in [`String.prototype.endsWith`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith)\n * method, but doesn't expose the `endPosition` parameter. To check only up to a\n * specific position, use `endsWith(sliceString(data, 0, endPosition), suffix)`.\n *\n * @param suffix - The string to check for at the end.\n * @signature\n *   endsWith(suffix)(data);\n * @example\n *   pipe(\"hello world\", endsWith(\"hello\")); // false\n *   pipe(\"hello world\", endsWith(\"world\")); // true\n * @dataLast\n * @category String\n */\nexport function endsWith<Suffix extends string>(\n  suffix: string extends Suffix ? never : Suffix,\n): <T extends string>(data: T) => data is T & `${string}${Suffix}`;\nexport function endsWith(suffix: string): (data: string) => boolean;\n\nexport function endsWith(...args: ReadonlyArray<unknown>): unknown {\n  return curry(endsWithImplementation, args);\n}\n\nfunction endsWithImplementation(data: string, suffix: string): boolean {\n  return data.endsWith(suffix);\n}\n"],"mappings":"mCAgDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,CAAI,CAC3C,CAEA,SAAS,EAAuB,EAAc,EAAyB,CACrE,OAAO,EAAK,SAAS,CAAM,CAC7B"}

package/dist/entries.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(Object.entries,t)}exports.entries=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(Object.entries,t)}exports.entries=t;
 //# sourceMappingURL=entries.cjs.map

package/dist/entries.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"entries.cjs","names":["curry"],"sources":["../src/entries.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\nimport type { Simplify, ValueOf } from 'type-fest';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Entry<T> = Simplify<\n  ValueOf<{\n    // `Object.entries` only returns enumerable keys, skipping symbols.\n    [P in Exclude<keyof T, symbol>]-?: [\n      // and all keys are converted to strings.\n      key: ToString<P>,\n      // Optionality doesn't play a factor in the result of entries because its\n      // a typing thing, not a runtime thing. We need to remove any `undefined`\n      // added just because the prop is optional.\n      value: Required<T>[P],\n    ];\n  }>\n>;\n\n/**\n * Returns an array of key/values of the enumerable properties of an object.\n *\n * @param data - Object to return keys and values of.\n * @signature\n *    entries(object)\n * @example\n *    entries({ a: 1, b: 2, c: 3 }); // => [['a', 1], ['b', 2], ['c', 3]]\n * @dataFirst\n * @category Object\n */\nexport function entries<T extends {}>(data: T): Array<Entry<T>>;\n\n/**\n * Returns an array of key/values of the enumerable properties of an object.\n *\n * @signature\n *    entries()(object)\n * @example\n *    pipe({ a: 1, b: 2, c: 3 }, entries()); // => [['a', 1], ['b', 2], ['c', 3]]\n * @dataLast\n * @category Object\n */\nexport function entries(): <T extends {}>(data: T) => Array<Entry<T>>;\n\nexport function entries(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.entries, args);\n}\n"],"mappings":"kGA+CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,OAAO,QAAS,EAAK"}
+{"version":3,"file":"entries.cjs","names":["curry"],"sources":["../src/entries.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\nimport type { Simplify, ValueOf } from 'type-fest';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Entry<T> = Simplify<\n  ValueOf<{\n    // `Object.entries` only returns enumerable keys, skipping symbols.\n    [P in Exclude<keyof T, symbol>]-?: [\n      // and all keys are converted to strings.\n      key: ToString<P>,\n      // Optionality doesn't play a factor in the result of entries because its\n      // a typing thing, not a runtime thing. We need to remove any `undefined`\n      // added just because the prop is optional.\n      value: Required<T>[P],\n    ];\n  }>\n>;\n\n/**\n * Returns an array of key/values of the enumerable properties of an object.\n *\n * @param data - Object to return keys and values of.\n * @signature\n *    entries(object)\n * @example\n *    entries({ a: 1, b: 2, c: 3 }); // => [['a', 1], ['b', 2], ['c', 3]]\n * @dataFirst\n * @category Object\n */\nexport function entries<T extends {}>(data: T): Array<Entry<T>>;\n\n/**\n * Returns an array of key/values of the enumerable properties of an object.\n *\n * @signature\n *    entries()(object)\n * @example\n *    pipe({ a: 1, b: 2, c: 3 }, entries()); // => [['a', 1], ['b', 2], ['c', 3]]\n * @dataLast\n * @category Object\n */\nexport function entries(): <T extends {}>(data: T) => Array<Entry<T>>;\n\nexport function entries(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.entries, args);\n}\n"],"mappings":"kGA+CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,OAAO,QAAS,CAAI,CACnC"}

package/dist/entries.js.map

@@ -1 +1 @@
-{"version":3,"file":"entries.js","names":[],"sources":["../src/entries.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\nimport type { Simplify, ValueOf } from 'type-fest';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Entry<T> = Simplify<\n  ValueOf<{\n    // `Object.entries` only returns enumerable keys, skipping symbols.\n    [P in Exclude<keyof T, symbol>]-?: [\n      // and all keys are converted to strings.\n      key: ToString<P>,\n      // Optionality doesn't play a factor in the result of entries because its\n      // a typing thing, not a runtime thing. We need to remove any `undefined`\n      // added just because the prop is optional.\n      value: Required<T>[P],\n    ];\n  }>\n>;\n\n/**\n * Returns an array of key/values of the enumerable properties of an object.\n *\n * @param data - Object to return keys and values of.\n * @signature\n *    entries(object)\n * @example\n *    entries({ a: 1, b: 2, c: 3 }); // => [['a', 1], ['b', 2], ['c', 3]]\n * @dataFirst\n * @category Object\n */\nexport function entries<T extends {}>(data: T): Array<Entry<T>>;\n\n/**\n * Returns an array of key/values of the enumerable properties of an object.\n *\n * @signature\n *    entries()(object)\n * @example\n *    pipe({ a: 1, b: 2, c: 3 }, entries()); // => [['a', 1], ['b', 2], ['c', 3]]\n * @dataLast\n * @category Object\n */\nexport function entries(): <T extends {}>(data: T) => Array<Entry<T>>;\n\nexport function entries(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.entries, args);\n}\n"],"mappings":"mCA+CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,OAAO,QAAS,EAAK"}
+{"version":3,"file":"entries.js","names":[],"sources":["../src/entries.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\nimport type { Simplify, ValueOf } from 'type-fest';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Entry<T> = Simplify<\n  ValueOf<{\n    // `Object.entries` only returns enumerable keys, skipping symbols.\n    [P in Exclude<keyof T, symbol>]-?: [\n      // and all keys are converted to strings.\n      key: ToString<P>,\n      // Optionality doesn't play a factor in the result of entries because its\n      // a typing thing, not a runtime thing. We need to remove any `undefined`\n      // added just because the prop is optional.\n      value: Required<T>[P],\n    ];\n  }>\n>;\n\n/**\n * Returns an array of key/values of the enumerable properties of an object.\n *\n * @param data - Object to return keys and values of.\n * @signature\n *    entries(object)\n * @example\n *    entries({ a: 1, b: 2, c: 3 }); // => [['a', 1], ['b', 2], ['c', 3]]\n * @dataFirst\n * @category Object\n */\nexport function entries<T extends {}>(data: T): Array<Entry<T>>;\n\n/**\n * Returns an array of key/values of the enumerable properties of an object.\n *\n * @signature\n *    entries()(object)\n * @example\n *    pipe({ a: 1, b: 2, c: 3 }, entries()); // => [['a', 1], ['b', 2], ['c', 3]]\n * @dataLast\n * @category Object\n */\nexport function entries(): <T extends {}>(data: T) => Array<Entry<T>>;\n\nexport function entries(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.entries, args);\n}\n"],"mappings":"mCA+CA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,OAAO,QAAS,CAAI,CACnC"}

package/dist/evolve.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(typeof e!=`object`||!e)return e;let r={...e};for(let[e,i]of Object.entries(t))e in r&&(r[e]=typeof i==`function`?i(r[e]):n(r[e],i));return r}exports.evolve=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs");function t(...t){return e.curry(n,t)}function n(e,t){if(typeof e!=`object`||!e)return e;let r={...e};for(let[e,i]of Object.entries(t))e in r&&(r[e]=typeof i==`function`?i(r[e]):n(r[e],i));return r}exports.evolve=t;
 //# sourceMappingURL=evolve.cjs.map

package/dist/evolve.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"evolve.cjs","names":["curry"],"sources":["../src/evolve.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Basic structure of `evolver` parameter of the function `evolve`.\n */\ntype GenericEvolver = {\n  readonly [P in string]: GenericEvolver | ((data: unknown) => unknown);\n};\n\n/**\n * Creates an assumed `evolver` type from the type of `data` argument.\n *\n * @example\n * interface Data {\n *   id: number;\n *   quartile: number[];\n *   time?: { elapsed: number; remaining?: number };\n * }\n * type Nested = Evolver<Data>; //  => type Nested = {\n * //   id?: ((data: number) => unknown) | undefined;\n * //   quartile?: ((data: number[]) => unknown) | undefined;\n * //   time?:\n * //     | ((data: { elapsed: number; remaining?: number | undefined }) => unknown)\n * //     | {\n * //         elapsed?: ((data: number) => unknown) | undefined;\n * //         remaining?: ((data: number) => unknown) | undefined;\n * //       }\n * //     | undefined;\n * // };\n */\ntype Evolver<T> = T extends object\n  ? T extends IterableContainer\n    ? never\n    : {\n        readonly [K in keyof T]?: K extends symbol\n          ? never\n          : Evolver<T[K]> | ((data: Required<T>[K]) => unknown);\n      }\n  : never;\n\n/**\n * Creates return type from the type of arguments of `evolve`.\n */\ntype Evolved<T, E> = T extends object\n  ? {\n      -readonly [K in keyof T]: K extends keyof E\n        ? E[K] extends (\n        // eslint-disable-next-line ts/no-explicit-any -- Functions aren't inferred correctly when using `unknown` for the params.\n          ...arg: any\n        ) => infer R\n          ? R\n          : Evolved<T[K], E[K]>\n        : Required<T>[K];\n    }\n  : T;\n\n/**\n * Creates a new object by applying functions that is included in `evolver` object parameter\n * to the `data` object parameter according to their corresponding path.\n *\n * Functions included in `evolver` object will not be invoked\n * if its corresponding key does not exist in the `data` object.\n * Also, values included in `data` object will be kept as is\n * if its corresponding key does not exist in the `evolver` object.\n *\n * @param object - Object whose value is applied to the corresponding function\n * that is defined in `evolver` at the same path.\n * @param evolver - Object that include functions that is applied to\n * the corresponding value of `data` object at the same path.\n * @signature\n *    evolve(data, evolver)\n * @example\n *    const evolver = {\n *      count: add(1),\n *      time: { elapsed: add(1), remaining: add(-1) },\n *    };\n *    const data = {\n *      id: 10,\n *      count: 10,\n *      time: { elapsed: 100, remaining: 1400 },\n *    };\n *    evolve(data, evolver)\n *    // => {\n *    //   id: 10,\n *    //   count: 11,\n *    //   time: { elapsed: 101, remaining: 1399 },\n *    // }\n * @dataFirst\n * @category Object\n */\nexport function evolve<T extends object, E extends Evolver<T>>(\n  object: T,\n  evolver: E,\n): Evolved<T, E>;\n\n/**\n * Creates a new object by applying functions that is included in `evolver` object parameter\n * to the `data` object parameter according to their corresponding path.\n *\n * Functions included in `evolver` object will not be invoked\n * if its corresponding key does not exist in the `data` object.\n * Also, values included in `data` object will not be used\n * if its corresponding key does not exist in the `evolver` object.\n *\n * @param evolver - Object that include functions that is applied to\n * the corresponding value of `data` object at the same path.\n * @signature\n *    evolve(evolver)(data)\n * @example\n *    const evolver = {\n *      count: add(1),\n *      time: { elapsed: add(1), remaining: add(-1) },\n *    };\n *    const data = {\n *      id: 10,\n *      count: 10,\n *      time: { elapsed: 100, remaining: 1400 },\n *    };\n *    pipe(data, evolve(evolver))\n *    // => {\n *    //   id: 10,\n *    //   count: 11,\n *    //   time: { elapsed: 101, remaining: 1399 },\n *    // }\n * @dataLast\n * @category Object\n */\nexport function evolve<T extends object, E extends Evolver<T>>(\n  evolver: E,\n): (object: T) => Evolved<T, E>;\n\nexport function evolve(...args: ReadonlyArray<unknown>): unknown {\n  return curry(evolveImplementation, args);\n}\n\nfunction evolveImplementation(data: unknown, evolver: GenericEvolver): unknown {\n  if (typeof data !== 'object' || data === null) {\n    return data;\n  }\n\n  const out: Record<string, unknown> = { ...data };\n\n  for (const [key, value] of Object.entries(evolver)) {\n    if (key in out) {\n      out[key]\n        = typeof value === 'function'\n          ? value(out[key])\n          : evolveImplementation(out[key], value);\n    }\n  }\n\n  return out;\n}\n"],"mappings":"kGAoIA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EAAqB,EAAe,EAAkC,CAC7E,GAAI,OAAO,GAAS,WAAY,EAC9B,OAAO,EAGT,IAAM,EAA+B,CAAE,GAAG,EAAM,CAEhD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAQ,CAC5C,KAAO,IACT,EAAI,GACA,OAAO,GAAU,WACf,EAAM,EAAI,GAAK,CACf,EAAqB,EAAI,GAAM,EAAM,EAI/C,OAAO"}
+{"version":3,"file":"evolve.cjs","names":["curry"],"sources":["../src/evolve.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Basic structure of `evolver` parameter of the function `evolve`.\n */\ntype GenericEvolver = {\n  readonly [P in string]: GenericEvolver | ((data: unknown) => unknown);\n};\n\n/**\n * Creates an assumed `evolver` type from the type of `data` argument.\n *\n * @example\n * interface Data {\n *   id: number;\n *   quartile: number[];\n *   time?: { elapsed: number; remaining?: number };\n * }\n * type Nested = Evolver<Data>; //  => type Nested = {\n * //   id?: ((data: number) => unknown) | undefined;\n * //   quartile?: ((data: number[]) => unknown) | undefined;\n * //   time?:\n * //     | ((data: { elapsed: number; remaining?: number | undefined }) => unknown)\n * //     | {\n * //         elapsed?: ((data: number) => unknown) | undefined;\n * //         remaining?: ((data: number) => unknown) | undefined;\n * //       }\n * //     | undefined;\n * // };\n */\ntype Evolver<T> = T extends object\n  ? T extends IterableContainer\n    ? never\n    : {\n        readonly [K in keyof T]?: K extends symbol\n          ? never\n          : Evolver<T[K]> | ((data: Required<T>[K]) => unknown);\n      }\n  : never;\n\n/**\n * Creates return type from the type of arguments of `evolve`.\n */\ntype Evolved<T, E> = T extends object\n  ? {\n      -readonly [K in keyof T]: K extends keyof E\n        ? E[K] extends (\n        // eslint-disable-next-line ts/no-explicit-any -- Functions aren't inferred correctly when using `unknown` for the params.\n          ...arg: any\n        ) => infer R\n          ? R\n          : Evolved<T[K], E[K]>\n        : Required<T>[K];\n    }\n  : T;\n\n/**\n * Creates a new object by applying functions that is included in `evolver` object parameter\n * to the `data` object parameter according to their corresponding path.\n *\n * Functions included in `evolver` object will not be invoked\n * if its corresponding key does not exist in the `data` object.\n * Also, values included in `data` object will be kept as is\n * if its corresponding key does not exist in the `evolver` object.\n *\n * @param object - Object whose value is applied to the corresponding function\n * that is defined in `evolver` at the same path.\n * @param evolver - Object that include functions that is applied to\n * the corresponding value of `data` object at the same path.\n * @signature\n *    evolve(data, evolver)\n * @example\n *    const evolver = {\n *      count: add(1),\n *      time: { elapsed: add(1), remaining: add(-1) },\n *    };\n *    const data = {\n *      id: 10,\n *      count: 10,\n *      time: { elapsed: 100, remaining: 1400 },\n *    };\n *    evolve(data, evolver)\n *    // => {\n *    //   id: 10,\n *    //   count: 11,\n *    //   time: { elapsed: 101, remaining: 1399 },\n *    // }\n * @dataFirst\n * @category Object\n */\nexport function evolve<T extends object, E extends Evolver<T>>(\n  object: T,\n  evolver: E,\n): Evolved<T, E>;\n\n/**\n * Creates a new object by applying functions that is included in `evolver` object parameter\n * to the `data` object parameter according to their corresponding path.\n *\n * Functions included in `evolver` object will not be invoked\n * if its corresponding key does not exist in the `data` object.\n * Also, values included in `data` object will not be used\n * if its corresponding key does not exist in the `evolver` object.\n *\n * @param evolver - Object that include functions that is applied to\n * the corresponding value of `data` object at the same path.\n * @signature\n *    evolve(evolver)(data)\n * @example\n *    const evolver = {\n *      count: add(1),\n *      time: { elapsed: add(1), remaining: add(-1) },\n *    };\n *    const data = {\n *      id: 10,\n *      count: 10,\n *      time: { elapsed: 100, remaining: 1400 },\n *    };\n *    pipe(data, evolve(evolver))\n *    // => {\n *    //   id: 10,\n *    //   count: 11,\n *    //   time: { elapsed: 101, remaining: 1399 },\n *    // }\n * @dataLast\n * @category Object\n */\nexport function evolve<T extends object, E extends Evolver<T>>(\n  evolver: E,\n): (object: T) => Evolved<T, E>;\n\nexport function evolve(...args: ReadonlyArray<unknown>): unknown {\n  return curry(evolveImplementation, args);\n}\n\nfunction evolveImplementation(data: unknown, evolver: GenericEvolver): unknown {\n  if (typeof data !== 'object' || data === null) {\n    return data;\n  }\n\n  const out: Record<string, unknown> = { ...data };\n\n  for (const [key, value] of Object.entries(evolver)) {\n    if (key in out) {\n      out[key]\n        = typeof value === 'function'\n          ? value(out[key])\n          : evolveImplementation(out[key], value);\n    }\n  }\n\n  return out;\n}\n"],"mappings":"kGAoIA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,CAAI,CACzC,CAEA,SAAS,EAAqB,EAAe,EAAkC,CAC7E,GAAI,OAAO,GAAS,WAAY,EAC9B,OAAO,EAGT,IAAM,EAA+B,CAAE,GAAG,CAAK,EAE/C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAO,EAC3C,KAAO,IACT,EAAI,GACA,OAAO,GAAU,WACf,EAAM,EAAI,EAAI,EACd,EAAqB,EAAI,GAAM,CAAK,GAI9C,OAAO,CACT"}

package/dist/evolve.js.map

@@ -1 +1 @@
-{"version":3,"file":"evolve.js","names":[],"sources":["../src/evolve.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Basic structure of `evolver` parameter of the function `evolve`.\n */\ntype GenericEvolver = {\n  readonly [P in string]: GenericEvolver | ((data: unknown) => unknown);\n};\n\n/**\n * Creates an assumed `evolver` type from the type of `data` argument.\n *\n * @example\n * interface Data {\n *   id: number;\n *   quartile: number[];\n *   time?: { elapsed: number; remaining?: number };\n * }\n * type Nested = Evolver<Data>; //  => type Nested = {\n * //   id?: ((data: number) => unknown) | undefined;\n * //   quartile?: ((data: number[]) => unknown) | undefined;\n * //   time?:\n * //     | ((data: { elapsed: number; remaining?: number | undefined }) => unknown)\n * //     | {\n * //         elapsed?: ((data: number) => unknown) | undefined;\n * //         remaining?: ((data: number) => unknown) | undefined;\n * //       }\n * //     | undefined;\n * // };\n */\ntype Evolver<T> = T extends object\n  ? T extends IterableContainer\n    ? never\n    : {\n        readonly [K in keyof T]?: K extends symbol\n          ? never\n          : Evolver<T[K]> | ((data: Required<T>[K]) => unknown);\n      }\n  : never;\n\n/**\n * Creates return type from the type of arguments of `evolve`.\n */\ntype Evolved<T, E> = T extends object\n  ? {\n      -readonly [K in keyof T]: K extends keyof E\n        ? E[K] extends (\n        // eslint-disable-next-line ts/no-explicit-any -- Functions aren't inferred correctly when using `unknown` for the params.\n          ...arg: any\n        ) => infer R\n          ? R\n          : Evolved<T[K], E[K]>\n        : Required<T>[K];\n    }\n  : T;\n\n/**\n * Creates a new object by applying functions that is included in `evolver` object parameter\n * to the `data` object parameter according to their corresponding path.\n *\n * Functions included in `evolver` object will not be invoked\n * if its corresponding key does not exist in the `data` object.\n * Also, values included in `data` object will be kept as is\n * if its corresponding key does not exist in the `evolver` object.\n *\n * @param object - Object whose value is applied to the corresponding function\n * that is defined in `evolver` at the same path.\n * @param evolver - Object that include functions that is applied to\n * the corresponding value of `data` object at the same path.\n * @signature\n *    evolve(data, evolver)\n * @example\n *    const evolver = {\n *      count: add(1),\n *      time: { elapsed: add(1), remaining: add(-1) },\n *    };\n *    const data = {\n *      id: 10,\n *      count: 10,\n *      time: { elapsed: 100, remaining: 1400 },\n *    };\n *    evolve(data, evolver)\n *    // => {\n *    //   id: 10,\n *    //   count: 11,\n *    //   time: { elapsed: 101, remaining: 1399 },\n *    // }\n * @dataFirst\n * @category Object\n */\nexport function evolve<T extends object, E extends Evolver<T>>(\n  object: T,\n  evolver: E,\n): Evolved<T, E>;\n\n/**\n * Creates a new object by applying functions that is included in `evolver` object parameter\n * to the `data` object parameter according to their corresponding path.\n *\n * Functions included in `evolver` object will not be invoked\n * if its corresponding key does not exist in the `data` object.\n * Also, values included in `data` object will not be used\n * if its corresponding key does not exist in the `evolver` object.\n *\n * @param evolver - Object that include functions that is applied to\n * the corresponding value of `data` object at the same path.\n * @signature\n *    evolve(evolver)(data)\n * @example\n *    const evolver = {\n *      count: add(1),\n *      time: { elapsed: add(1), remaining: add(-1) },\n *    };\n *    const data = {\n *      id: 10,\n *      count: 10,\n *      time: { elapsed: 100, remaining: 1400 },\n *    };\n *    pipe(data, evolve(evolver))\n *    // => {\n *    //   id: 10,\n *    //   count: 11,\n *    //   time: { elapsed: 101, remaining: 1399 },\n *    // }\n * @dataLast\n * @category Object\n */\nexport function evolve<T extends object, E extends Evolver<T>>(\n  evolver: E,\n): (object: T) => Evolved<T, E>;\n\nexport function evolve(...args: ReadonlyArray<unknown>): unknown {\n  return curry(evolveImplementation, args);\n}\n\nfunction evolveImplementation(data: unknown, evolver: GenericEvolver): unknown {\n  if (typeof data !== 'object' || data === null) {\n    return data;\n  }\n\n  const out: Record<string, unknown> = { ...data };\n\n  for (const [key, value] of Object.entries(evolver)) {\n    if (key in out) {\n      out[key]\n        = typeof value === 'function'\n          ? value(out[key])\n          : evolveImplementation(out[key], value);\n    }\n  }\n\n  return out;\n}\n"],"mappings":"mCAoIA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAAqB,EAAe,EAAkC,CAC7E,GAAI,OAAO,GAAS,WAAY,EAC9B,OAAO,EAGT,IAAM,EAA+B,CAAE,GAAG,EAAM,CAEhD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAQ,CAC5C,KAAO,IACT,EAAI,GACA,OAAO,GAAU,WACf,EAAM,EAAI,GAAK,CACf,EAAqB,EAAI,GAAM,EAAM,EAI/C,OAAO"}
+{"version":3,"file":"evolve.js","names":[],"sources":["../src/evolve.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Basic structure of `evolver` parameter of the function `evolve`.\n */\ntype GenericEvolver = {\n  readonly [P in string]: GenericEvolver | ((data: unknown) => unknown);\n};\n\n/**\n * Creates an assumed `evolver` type from the type of `data` argument.\n *\n * @example\n * interface Data {\n *   id: number;\n *   quartile: number[];\n *   time?: { elapsed: number; remaining?: number };\n * }\n * type Nested = Evolver<Data>; //  => type Nested = {\n * //   id?: ((data: number) => unknown) | undefined;\n * //   quartile?: ((data: number[]) => unknown) | undefined;\n * //   time?:\n * //     | ((data: { elapsed: number; remaining?: number | undefined }) => unknown)\n * //     | {\n * //         elapsed?: ((data: number) => unknown) | undefined;\n * //         remaining?: ((data: number) => unknown) | undefined;\n * //       }\n * //     | undefined;\n * // };\n */\ntype Evolver<T> = T extends object\n  ? T extends IterableContainer\n    ? never\n    : {\n        readonly [K in keyof T]?: K extends symbol\n          ? never\n          : Evolver<T[K]> | ((data: Required<T>[K]) => unknown);\n      }\n  : never;\n\n/**\n * Creates return type from the type of arguments of `evolve`.\n */\ntype Evolved<T, E> = T extends object\n  ? {\n      -readonly [K in keyof T]: K extends keyof E\n        ? E[K] extends (\n        // eslint-disable-next-line ts/no-explicit-any -- Functions aren't inferred correctly when using `unknown` for the params.\n          ...arg: any\n        ) => infer R\n          ? R\n          : Evolved<T[K], E[K]>\n        : Required<T>[K];\n    }\n  : T;\n\n/**\n * Creates a new object by applying functions that is included in `evolver` object parameter\n * to the `data` object parameter according to their corresponding path.\n *\n * Functions included in `evolver` object will not be invoked\n * if its corresponding key does not exist in the `data` object.\n * Also, values included in `data` object will be kept as is\n * if its corresponding key does not exist in the `evolver` object.\n *\n * @param object - Object whose value is applied to the corresponding function\n * that is defined in `evolver` at the same path.\n * @param evolver - Object that include functions that is applied to\n * the corresponding value of `data` object at the same path.\n * @signature\n *    evolve(data, evolver)\n * @example\n *    const evolver = {\n *      count: add(1),\n *      time: { elapsed: add(1), remaining: add(-1) },\n *    };\n *    const data = {\n *      id: 10,\n *      count: 10,\n *      time: { elapsed: 100, remaining: 1400 },\n *    };\n *    evolve(data, evolver)\n *    // => {\n *    //   id: 10,\n *    //   count: 11,\n *    //   time: { elapsed: 101, remaining: 1399 },\n *    // }\n * @dataFirst\n * @category Object\n */\nexport function evolve<T extends object, E extends Evolver<T>>(\n  object: T,\n  evolver: E,\n): Evolved<T, E>;\n\n/**\n * Creates a new object by applying functions that is included in `evolver` object parameter\n * to the `data` object parameter according to their corresponding path.\n *\n * Functions included in `evolver` object will not be invoked\n * if its corresponding key does not exist in the `data` object.\n * Also, values included in `data` object will not be used\n * if its corresponding key does not exist in the `evolver` object.\n *\n * @param evolver - Object that include functions that is applied to\n * the corresponding value of `data` object at the same path.\n * @signature\n *    evolve(evolver)(data)\n * @example\n *    const evolver = {\n *      count: add(1),\n *      time: { elapsed: add(1), remaining: add(-1) },\n *    };\n *    const data = {\n *      id: 10,\n *      count: 10,\n *      time: { elapsed: 100, remaining: 1400 },\n *    };\n *    pipe(data, evolve(evolver))\n *    // => {\n *    //   id: 10,\n *    //   count: 11,\n *    //   time: { elapsed: 101, remaining: 1399 },\n *    // }\n * @dataLast\n * @category Object\n */\nexport function evolve<T extends object, E extends Evolver<T>>(\n  evolver: E,\n): (object: T) => Evolved<T, E>;\n\nexport function evolve(...args: ReadonlyArray<unknown>): unknown {\n  return curry(evolveImplementation, args);\n}\n\nfunction evolveImplementation(data: unknown, evolver: GenericEvolver): unknown {\n  if (typeof data !== 'object' || data === null) {\n    return data;\n  }\n\n  const out: Record<string, unknown> = { ...data };\n\n  for (const [key, value] of Object.entries(evolver)) {\n    if (key in out) {\n      out[key]\n        = typeof value === 'function'\n          ? value(out[key])\n          : evolveImplementation(out[key], value);\n    }\n  }\n\n  return out;\n}\n"],"mappings":"mCAoIA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,CAAI,CACzC,CAEA,SAAS,EAAqB,EAAe,EAAkC,CAC7E,GAAI,OAAO,GAAS,WAAY,EAC9B,OAAO,EAGT,IAAM,EAA+B,CAAE,GAAG,CAAK,EAE/C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,CAAO,EAC3C,KAAO,IACT,EAAI,GACA,OAAO,GAAU,WACf,EAAM,EAAI,EAAI,EACd,EAAqB,EAAI,GAAM,CAAK,GAI9C,OAAO,CACT"}

package/dist/filter.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./utility-evaluators-C8koSp9T.cjs`);function n(...t){return e.curry(r,t,i)}function r(e,t){return e.filter(t)}function i(e){return(n,r,i)=>e(n,r,i)?{done:!1,hasNext:!0,next:n}:t.t}exports.filter=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./curry.cjs"),t=require("./utility-evaluators-BGM19SpK.cjs");function n(...t){return e.curry(r,t,i)}function r(e,t){return e.filter(t)}function i(e){return(n,r,i)=>e(n,r,i)?{done:!1,hasNext:!0,next:n}:t.t}exports.filter=n;
 //# sourceMappingURL=filter.cjs.map

package/dist/filter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"filter.cjs","names":["curry","SKIP_ITEM"],"sources":["../src/filter.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { FilteredArray } from './internal/types/filtered-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n// When the predicate used for filter isn't refining (like a type-predicate) we\n// can narrow the result slightly if it's also trivial (it returns the same\n// result for all items). This is uncommon, but can be useful to \"short-circuit\"\n// the filter.\ntype NonRefinedFilteredArray<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n> = boolean extends IsItemIncluded\n  ? // We don't know which items of the array the predicate would allow in the\n// output so we can only safely say that the result is an array with items\n// from the input array.\n// TODO: Theoretically we could build an output shape that would take into account the **order** of elements in the input array by reconstructing it with every single element in it either included or not, but this type can grow to a union of as much as 2^n options which might not be usable in practice.\n  Array<T[number]>\n  : IsItemIncluded extends true\n    ? // If the predicate is always true we return a shallow copy of the array.\n  // If it was originally readonly we need to strip that away.\n    Writable<T>\n    : // If the predicate is always false we will always return an empty\n      // array.\n      [];\n\n/**\n * Creates a shallow copy of a portion of a given array, filtered down to just\n * the elements from the given array that pass the test implemented by the\n * provided function. Equivalent to `Array.prototype.filter`.\n *\n * @param data - The array to filter.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to keep the element in the resulting array, and `false`\n * otherwise. A type-predicate can also be used to narrow the result.\n * @returns A shallow copy of the given array containing just the elements that\n * pass the test. If no elements pass the test, an empty array is returned.\n * @signature\n *    filter(data, predicate)\n * @example\n *    filter([1, 2, 3], x => x % 2 === 1) // => [1, 3]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function filter<\n  T extends IterableContainer,\n  Condition extends T[number],\n>(\n  data: T,\n  predicate: (value: T[number], index: number, data: T) => value is Condition,\n): FilteredArray<T, Condition>;\nexport function filter<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n>(\n  data: T,\n  predicate: (value: T[number], index: number, data: T) => IsItemIncluded,\n): NonRefinedFilteredArray<T, IsItemIncluded>;\n\n/**\n * Creates a shallow copy of a portion of a given array, filtered down to just\n * the elements from the given array that pass the test implemented by the\n * provided function. Equivalent to `Array.prototype.filter`.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to keep the element in the resulting array, and `false`\n * otherwise.\n * @returns A shallow copy of the given array containing just the elements that\n * pass the test. If no elements pass the test, an empty array is returned.\n * @signature\n *    filter(predicate)(data)\n * @example\n *    pipe([1, 2, 3], filter(x => x % 2 === 1)) // => [1, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function filter<\n  T extends IterableContainer,\n  Condition extends T[number],\n>(\n  predicate: (value: T[number], index: number, data: T) => value is Condition,\n): (data: T) => FilteredArray<T, Condition>;\nexport function filter<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n>(\n  predicate: (value: T[number], index: number, data: T) => IsItemIncluded,\n): (data: T) => NonRefinedFilteredArray<T, IsItemIncluded>;\n\nexport function filter(...args: ReadonlyArray<unknown>): unknown {\n  return curry(filterImplementation, args, lazyImplementation);\n}\n\nfunction filterImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): Array<T> {\n  return data.filter(predicate);\n}\n\nfunction lazyImplementation<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): LazyEvaluator<T> {\n  return (value, index, data) =>\n    predicate(value, index, data)\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"iJA6FA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAM,EAAmB,CAG9D,SAAS,EAAwB,EAAwB,EAAoF,CAC3I,OAAO,EAAK,OAAO,EAAU,CAG/B,SAAS,EAAsB,EAA2F,CACxH,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,EAAK,CACzB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3CC,EAAAA"}
+{"version":3,"file":"filter.cjs","names":["curry","SKIP_ITEM"],"sources":["../src/filter.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { FilteredArray } from './internal/types/filtered-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n// When the predicate used for filter isn't refining (like a type-predicate) we\n// can narrow the result slightly if it's also trivial (it returns the same\n// result for all items). This is uncommon, but can be useful to \"short-circuit\"\n// the filter.\ntype NonRefinedFilteredArray<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n> = boolean extends IsItemIncluded\n  ? // We don't know which items of the array the predicate would allow in the\n// output so we can only safely say that the result is an array with items\n// from the input array.\n// TODO: Theoretically we could build an output shape that would take into account the **order** of elements in the input array by reconstructing it with every single element in it either included or not, but this type can grow to a union of as much as 2^n options which might not be usable in practice.\n  Array<T[number]>\n  : IsItemIncluded extends true\n    ? // If the predicate is always true we return a shallow copy of the array.\n  // If it was originally readonly we need to strip that away.\n    Writable<T>\n    : // If the predicate is always false we will always return an empty\n      // array.\n      [];\n\n/**\n * Creates a shallow copy of a portion of a given array, filtered down to just\n * the elements from the given array that pass the test implemented by the\n * provided function. Equivalent to `Array.prototype.filter`.\n *\n * Related operations:\n * - `splice` - to shape the array by *position* rather than by *value*.\n *\n * @param data - The array to filter.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to keep the element in the resulting array, and `false`\n * otherwise. A type-predicate can also be used to narrow the result.\n * @returns A shallow copy of the given array containing just the elements that\n * pass the test. If no elements pass the test, an empty array is returned.\n * @signature\n *    filter(data, predicate)\n * @example\n *    filter([1, 2, 3], x => x % 2 === 1) // => [1, 3]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function filter<\n  T extends IterableContainer,\n  Condition extends T[number],\n>(\n  data: T,\n  predicate: (value: T[number], index: number, data: T) => value is Condition,\n): FilteredArray<T, Condition>;\nexport function filter<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n>(\n  data: T,\n  predicate: (value: T[number], index: number, data: T) => IsItemIncluded,\n): NonRefinedFilteredArray<T, IsItemIncluded>;\n\n/**\n * Creates a shallow copy of a portion of a given array, filtered down to just\n * the elements from the given array that pass the test implemented by the\n * provided function. Equivalent to `Array.prototype.filter`.\n *\n * Related operations:\n * - `splice` - to shape the array by *position* rather than by *value*.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to keep the element in the resulting array, and `false`\n * otherwise.\n * @returns A shallow copy of the given array containing just the elements that\n * pass the test. If no elements pass the test, an empty array is returned.\n * @signature\n *    filter(predicate)(data)\n * @example\n *    pipe([1, 2, 3], filter(x => x % 2 === 1)) // => [1, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function filter<\n  T extends IterableContainer,\n  Condition extends T[number],\n>(\n  predicate: (value: T[number], index: number, data: T) => value is Condition,\n): (data: T) => FilteredArray<T, Condition>;\nexport function filter<\n  T extends IterableContainer,\n  IsItemIncluded extends boolean,\n>(\n  predicate: (value: T[number], index: number, data: T) => IsItemIncluded,\n): (data: T) => NonRefinedFilteredArray<T, IsItemIncluded>;\n\nexport function filter(...args: ReadonlyArray<unknown>): unknown {\n  return curry(filterImplementation, args, lazyImplementation);\n}\n\nfunction filterImplementation<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, array: ReadonlyArray<T>) => boolean): Array<T> {\n  return data.filter(predicate);\n}\n\nfunction lazyImplementation<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): LazyEvaluator<T> {\n  return (value, index, data) =>\n    predicate(value, index, data)\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"iJAmGA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAM,CAAkB,CAC7D,CAEA,SAAS,EAAwB,EAAwB,EAAoF,CAC3I,OAAO,EAAK,OAAO,CAAS,CAC9B,CAEA,SAAS,EAAsB,EAA2F,CACxH,OAAQ,EAAO,EAAO,IACpB,EAAU,EAAO,EAAO,CAAI,EACxB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,CAAM,EAC1CC,EAAAA,CACR"}

package/dist/filter.js

@@ -1,2 +1,2 @@
-import{curry as e}from"./curry.js";import{t}from"./utility-evaluators-ZAaUtL2Z.js";function n(...t){return e(r,t,i)}function r(e,t){return e.filter(t)}function i(e){return(n,r,i)=>e(n,r,i)?{done:!1,hasNext:!0,next:n}:t}export{n as filter};
+import{curry as e}from"./curry.js";import{t}from"./utility-evaluators-DDW55xeL.js";function n(...t){return e(r,t,i)}function r(e,t){return e.filter(t)}function i(e){return(n,r,i)=>e(n,r,i)?{done:!1,hasNext:!0,next:n}:t}export{n as filter};
 //# sourceMappingURL=filter.js.map