@vinicunca/perkakas 1.13.2 → 1.15.0

package/dist/first-by.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-by.cjs","names":["curryOrderRules","hasAtLeast"],"sources":["../src/first-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport { hasAtLeast } from './has-at-least';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\ntype FirstBy<T extends IterableContainer>\n  = | T[number]\n    | (T extends readonly [unknown, ...(ReadonlyArray<unknown>)]\n      ? never\n      : T extends readonly [...(ReadonlyArray<unknown>), unknown]\n        ? never\n        : undefined);\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\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 The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(...rules)(data);\n * @example\n *   const max = pipe([1,2,3], firstBy([identity(), \"desc\"])); // => 3;\n *   const min = pipe([1,2,3], firstBy(identity())); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = pipe(data, firstBy([(item) => item.a.length, \"desc\"])); // => { a: \"aaa\" };\n *   const minBy = pipe(data, firstBy((item) => item.a.length)); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = pipe(data, firstBy(prop('type'), [prop('size'), 'desc'])); // => {type: \"cat\", size: 2}\n * @dataLast\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => FirstBy<T>;\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param data - An array of items.\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 The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(data, ...rules);\n * @example\n *   const max = firstBy([1,2,3], [identity(), \"desc\"]); // => 3;\n *   const min = firstBy([1,2,3], identity()); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = firstBy(data, [(item) => item.a.length, \"desc\"]); // => { a: \"aaa\" };\n *   const minBy = firstBy(data, (item) => item.a.length); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = firstBy(data, prop('type'), [prop('size'), 'desc']); // => {type: \"cat\", size: 2}\n * @dataFirst\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  data: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): FirstBy<T>;\n\nexport function firstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(firstByImplementation, args);\n}\n\nfunction firstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  if (!hasAtLeast(data, 2)) {\n    // If we have 0 or 1 item we simply return the trivial result.\n    return data[0];\n  }\n\n  let [currentFirst] = data;\n\n  // Remove the first item, we won't compare it with itself.\n  const [, ...rest] = data;\n  for (const item of rest) {\n    if (compareFn(item, currentFirst) < 0) {\n      // item comes before currentFirst in the order.\n      currentFirst = item;\n    }\n  }\n\n  return currentFirst;\n}\n"],"mappings":"uJAyEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,EAAgB,EAAuB,EAAK,CAGrD,SAAS,EACP,EACA,EACe,CACf,GAAI,CAACC,EAAAA,WAAW,EAAM,EAAE,CAEtB,OAAO,EAAK,GAGd,GAAI,CAAC,GAAgB,EAGf,EAAG,GAAG,GAAQ,EACpB,IAAK,IAAM,KAAQ,EACb,EAAU,EAAM,EAAa,CAAG,IAElC,EAAe,GAInB,OAAO"}

package/dist/first-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-order-rules-DwrF-_P1.js";import{t}from"./has-at-least-Coy9sM-B.js";function n(...t){return e(r,t)}function r(e,n){if(!t(e,2))return e[0];let[r]=e,[,...i]=e;for(let e of i)n(e,r)<0&&(r=e);return r}export{n as firstBy};
+import{t as e}from"./curry-order-rules-BLyCSMdZ.js";import{hasAtLeast as t}from"./has-at-least.js";function n(...t){return e(r,t)}function r(e,n){if(!t(e,2))return e[0];let[r]=e,[,...i]=e;for(let e of i)n(e,r)<0&&(r=e);return r}export{n as firstBy};
 //# sourceMappingURL=first-by.js.map

package/dist/first-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"first-by.js","names":[],"sources":["../src/first-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport { hasAtLeast } from './has-at-least';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\ntype FirstBy<T extends IterableContainer>\n  = | T[number]\n    | (T extends readonly [unknown, ...ReadonlyArray<unknown>]\n      ? never\n      : T extends readonly [...ReadonlyArray<unknown>, unknown]\n        ? never\n        : undefined);\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\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 The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   P.firstBy(...rules)(data);\n * @example\n *   const max = P.pipe([1,2,3], P.firstBy([P.identity(), \"desc\"])); // => 3;\n *   const min = P.pipe([1,2,3], P.firstBy(P.identity())); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, \"desc\"])); // => { a: \"aaa\" };\n *   const minBy = P.pipe(data, P.firstBy((item) => item.a.length)); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = P.pipe(data, P.firstBy(P.prop('type'), [P.prop('size'), 'desc'])); // => {type: \"cat\", size: 2}\n * @dataLast\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => FirstBy<T>;\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `P.first(P.sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param data - An array of items.\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 The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   P.firstBy(data, ...rules);\n * @example\n *   const max = P.firstBy([1,2,3], [P.identity(), \"desc\"]); // => 3;\n *   const min = P.firstBy([1,2,3], P.identity()); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = P.firstBy(data, [(item) => item.a.length, \"desc\"]); // => { a: \"aaa\" };\n *   const minBy = P.firstBy(data, (item) => item.a.length); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = P.firstBy(data, P.prop('type'), [P.prop('size'), 'desc']); // => {type: \"cat\", size: 2}\n * @dataFirst\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  data: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): FirstBy<T>;\n\nexport function firstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(firstByImplementation, args);\n}\n\nfunction firstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  if (!hasAtLeast(data, 2)) {\n    // If we have 0 or 1 item we simply return the trivial result.\n    return data[0];\n  }\n\n  let [currentFirst] = data;\n\n  // Remove the first item, we won't compare it with itself.\n  const [, ...rest] = data;\n  for (const item of rest) {\n    if (compareFn(item, currentFirst) < 0) {\n      // item comes before currentFirst in the order.\n      currentFirst = item;\n    }\n  }\n\n  return currentFirst;\n}\n"],"mappings":"8FAyEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAgB,EAAuB,EAAK,CAGrD,SAAS,EACP,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,EAAE,CAEtB,OAAO,EAAK,GAGd,GAAI,CAAC,GAAgB,EAGf,EAAG,GAAG,GAAQ,EACpB,IAAK,IAAM,KAAQ,EACb,EAAU,EAAM,EAAa,CAAG,IAElC,EAAe,GAInB,OAAO"}
+{"version":3,"file":"first-by.js","names":[],"sources":["../src/first-by.ts"],"sourcesContent":["import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport { hasAtLeast } from './has-at-least';\nimport { curryOrderRules } from './internal/curry-order-rules';\n\ntype FirstBy<T extends IterableContainer>\n  = | T[number]\n    | (T extends readonly [unknown, ...(ReadonlyArray<unknown>)]\n      ? never\n      : T extends readonly [...(ReadonlyArray<unknown>), unknown]\n        ? never\n        : undefined);\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\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 The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(...rules)(data);\n * @example\n *   const max = pipe([1,2,3], firstBy([identity(), \"desc\"])); // => 3;\n *   const min = pipe([1,2,3], firstBy(identity())); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = pipe(data, firstBy([(item) => item.a.length, \"desc\"])); // => { a: \"aaa\" };\n *   const minBy = pipe(data, firstBy((item) => item.a.length)); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = pipe(data, firstBy(prop('type'), [prop('size'), 'desc'])); // => {type: \"cat\", size: 2}\n * @dataLast\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => FirstBy<T>;\n\n/**\n * Find the first element in the array that adheres to the order rules provided. This is a superset of what a typical `maxBy` or `minBy` function would do as it allows defining \"tie-breaker\" rules when values are equal, and allows comparing items using any logic. This function is equivalent to calling `first(sortBy(...))` but runs at *O(n)* instead of *O(nlogn)*.\n *\n * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.\n *\n * @param data - An array of items.\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 The first element by the order criteria, or `undefined` if the array\n * is empty. (The function provides strong typing if the input type assures the\n * array isn't empty).\n * @signature\n *   firstBy(data, ...rules);\n * @example\n *   const max = firstBy([1,2,3], [identity(), \"desc\"]); // => 3;\n *   const min = firstBy([1,2,3], identity()); // => 1;\n *\n *   const data = [{ a: \"a\" }, { a: \"aa\" }, { a: \"aaa\" }] as const;\n *   const maxBy = firstBy(data, [(item) => item.a.length, \"desc\"]); // => { a: \"aaa\" };\n *   const minBy = firstBy(data, (item) => item.a.length); // => { a: \"a\" };\n *\n *   const data = [{type: \"cat\", size: 1}, {type: \"cat\", size: 2}, {type: \"dog\", size: 3}] as const;\n *   const multi = firstBy(data, prop('type'), [prop('size'), 'desc']); // => {type: \"cat\", size: 2}\n * @dataFirst\n * @category Array\n */\nexport function firstBy<T extends IterableContainer>(\n  data: T,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): FirstBy<T>;\n\nexport function firstBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRules(firstByImplementation, args);\n}\n\nfunction firstByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  if (!hasAtLeast(data, 2)) {\n    // If we have 0 or 1 item we simply return the trivial result.\n    return data[0];\n  }\n\n  let [currentFirst] = data;\n\n  // Remove the first item, we won't compare it with itself.\n  const [, ...rest] = data;\n  for (const item of rest) {\n    if (compareFn(item, currentFirst) < 0) {\n      // item comes before currentFirst in the order.\n      currentFirst = item;\n    }\n  }\n\n  return currentFirst;\n}\n"],"mappings":"mGAyEA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAgB,EAAuB,EAAK,CAGrD,SAAS,EACP,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,EAAE,CAEtB,OAAO,EAAK,GAGd,GAAI,CAAC,GAAgB,EAGf,EAAG,GAAG,GAAQ,EACpB,IAAK,IAAM,KAAQ,EACb,EAAU,EAAM,EAAa,CAAG,IAElC,EAAe,GAInB,OAAO"}

package/dist/first.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./to-single-Chq_hKEk.cjs`);function n(...n){return e.t(r,n,t.t(i))}function r([e]){return e}function i(){return a}function a(e){return{hasNext:!0,next:e,done:!0}}exports.first=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`),t=require(`./to-single-BunGuk7o.cjs`);function n(...n){return e.curry(r,n,t.t(i))}const r=([e])=>e,i=()=>a;function a(e){return{hasNext:!0,next:e,done:!0}}exports.first=n;
+//# sourceMappingURL=first.cjs.map

package/dist/first.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"first.cjs","names":["curry","toSingle"],"sources":["../src/first.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\n\ntype First<T extends IterableContainer> = T extends []\n  ? undefined\n  : T extends readonly [unknown, ...Array<unknown>]\n    ? T[0]\n    : T extends readonly [...infer Pre, infer Last]\n      ? Last | Pre[0]\n      : T[0] | undefined;\n\n/**\n * Gets the first element of `array`.\n *\n * @param data - The array.\n * @returns The first element of the array.\n * @signature\n *    first(array)\n * @example\n *    first([1, 2, 3]) // => 1\n *    first([]) // => undefined\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function first<T extends IterableContainer>(data: T): First<T>;\n\n/**\n * Gets the first element of `array`.\n *\n * @returns The first element of the array.\n * @signature\n *    first()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      first(),\n *      x => x + 1\n *    ); // => 5\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function first(): <T extends IterableContainer>(data: T) => First<T>;\n\nexport function first(...args: ReadonlyArray<unknown>): unknown {\n  return curry(firstImplementation, args, toSingle(lazyImplementation));\n}\n\nconst firstImplementation = <T>([item]: ReadonlyArray<T>): T | undefined => item;\n\nconst lazyImplementation = (): LazyEvaluator => firstLazy;\n\nfunction firstLazy<T>(value: T) {\n  return ({ hasNext: true, next: value, done: true }) as const;\n}\n"],"mappings":"wIAgDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAM,EAAqB,EAAMC,EAAAA,EAAS,EAAmB,CAAC,CAGvE,MAAM,GAA0B,CAAC,KAA2C,EAEtE,MAA0C,EAEhD,SAAS,EAAa,EAAU,CAC9B,MAAQ,CAAE,QAAS,GAAM,KAAM,EAAO,KAAM,GAAM"}

package/dist/first.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./to-single-BKYbBic-.js";function n(...n){return e(r,n,t(i))}function r([e]){return e}function i(){return a}function a(e){return{hasNext:!0,next:e,done:!0}}export{n as first};
+import{curry as e}from"./curry.js";import{t}from"./to-single-XEXXW73e.js";function n(...n){return e(r,n,t(i))}const r=([e])=>e,i=()=>a;function a(e){return{hasNext:!0,next:e,done:!0}}export{n as first};
 //# sourceMappingURL=first.js.map

package/dist/first.js.map

@@ -1 +1 @@
-{"version":3,"file":"first.js","names":[],"sources":["../src/first.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\n\ntype First<T extends IterableContainer> = T extends []\n  ? undefined\n  : T extends readonly [unknown, ...Array<unknown>]\n    ? T[0]\n    : T extends readonly [...infer Pre, infer Last]\n      ? Last | Pre[0]\n      : T[0] | undefined;\n\n/**\n * Gets the first element of `array`.\n *\n * @param data - The array.\n * @returns The first element of the array.\n * @signature\n *    P.first(array)\n * @example\n *    P.first([1, 2, 3]) // => 1\n *    P.first([]) // => undefined\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function first<T extends IterableContainer>(data: T): First<T>;\n\n/**\n * Gets the first element of `array`.\n *\n * @returns The first element of the array.\n * @signature\n *    P.first()(array)\n * @example\n *    P.pipe(\n *      [1, 2, 4, 8, 16],\n *      P.filter(x => x > 3),\n *      P.first(),\n *      x => x + 1\n *    ); // => 5\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function first(): <T extends IterableContainer>(data: T) => First<T>;\n\nexport function first(...args: ReadonlyArray<unknown>): unknown {\n  return curry(firstImplementation, args, toSingle(lazyImplementation));\n}\n\nfunction firstImplementation<T>([item]: ReadonlyArray<T>): T | undefined {\n  return item;\n}\n\nfunction lazyImplementation(): LazyEvaluator {\n  return firstLazy;\n}\n\n// eslint-disable-next-line ts/explicit-function-return-type\nfunction firstLazy<T>(value: T) {\n  return ({ hasNext: true, next: value, done: true }) as const;\n}\n"],"mappings":"+EAgDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAM,EAAS,EAAmB,CAAC,CAGvE,SAAS,EAAuB,CAAC,GAAwC,CACvE,OAAO,EAGT,SAAS,GAAoC,CAC3C,OAAO,EAIT,SAAS,EAAa,EAAU,CAC9B,MAAQ,CAAE,QAAS,GAAM,KAAM,EAAO,KAAM,GAAM"}
+{"version":3,"file":"first.js","names":[],"sources":["../src/first.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\nimport { toSingle } from './internal/to-single';\n\ntype First<T extends IterableContainer> = T extends []\n  ? undefined\n  : T extends readonly [unknown, ...Array<unknown>]\n    ? T[0]\n    : T extends readonly [...infer Pre, infer Last]\n      ? Last | Pre[0]\n      : T[0] | undefined;\n\n/**\n * Gets the first element of `array`.\n *\n * @param data - The array.\n * @returns The first element of the array.\n * @signature\n *    first(array)\n * @example\n *    first([1, 2, 3]) // => 1\n *    first([]) // => undefined\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function first<T extends IterableContainer>(data: T): First<T>;\n\n/**\n * Gets the first element of `array`.\n *\n * @returns The first element of the array.\n * @signature\n *    first()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      first(),\n *      x => x + 1\n *    ); // => 5\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function first(): <T extends IterableContainer>(data: T) => First<T>;\n\nexport function first(...args: ReadonlyArray<unknown>): unknown {\n  return curry(firstImplementation, args, toSingle(lazyImplementation));\n}\n\nconst firstImplementation = <T>([item]: ReadonlyArray<T>): T | undefined => item;\n\nconst lazyImplementation = (): LazyEvaluator => firstLazy;\n\nfunction firstLazy<T>(value: T) {\n  return ({ hasNext: true, next: value, done: true }) as const;\n}\n"],"mappings":"0EAgDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAM,EAAS,EAAmB,CAAC,CAGvE,MAAM,GAA0B,CAAC,KAA2C,EAEtE,MAA0C,EAEhD,SAAS,EAAa,EAAU,CAC9B,MAAQ,CAAE,QAAS,GAAM,KAAM,EAAO,KAAM,GAAM"}

package/dist/flat-map.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t,r)}function n(e,t){return e.flatMap(t)}function r(e){return(t,n,r)=>{let i=e(t,n,r);return Array.isArray(i)?{done:!1,hasNext:!0,hasMany:!0,next:i}:{done:!1,hasNext:!0,next:i}}}exports.flatMap=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t,r)}function n(e,t){return e.flatMap(t)}function r(e){return(t,n,r)=>{let i=e(t,n,r);return Array.isArray(i)?{done:!1,hasNext:!0,hasMany:!0,next:i}:{done:!1,hasNext:!0,next:i}}}exports.flatMap=t;
+//# sourceMappingURL=flat-map.cjs.map

package/dist/flat-map.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-map.cjs","names":["curry"],"sources":["../src/flat-map.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param data - The items to map and flatten.\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(data, callbackfn)\n * @example\n *    flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): Array<U>;\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(callbackfn)(data)\n * @example\n *    pipe([1, 2, 3], flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): (data: ReadonlyArray<T>) => Array<U>;\n\nexport function flatMap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(flatMapImplementation, args, lazyImplementation);\n}\n\nfunction flatMapImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U> {\n  return data.flatMap(callbackfn);\n}\n\nfunction lazyImplementation<T, K>(callbackfn: (\n  input: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => K | ReadonlyArray<K>): LazyEvaluator<T, K> {\n  return (value, index, data) => {\n    const next = callbackfn(value, index, data);\n    return Array.isArray(next)\n      ? { done: false, hasNext: true, hasMany: true, next }\n      : { done: false, hasNext: true, next };\n  };\n}\n"],"mappings":"kGAqDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EAA4B,EAAwB,EAAiG,CAC5J,OAAO,EAAK,QAAQ,EAAW,CAGjC,SAAS,EAAyB,EAIc,CAC9C,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAO,EAAW,EAAO,EAAO,EAAK,CAC3C,OAAO,MAAM,QAAQ,EAAK,CACtB,CAAE,KAAM,GAAO,QAAS,GAAM,QAAS,GAAM,OAAM,CACnD,CAAE,KAAM,GAAO,QAAS,GAAM,OAAM"}

package/dist/flat-map.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t,r)}function n(e,t){return e.flatMap(t)}function r(e){return(t,n,r)=>{let i=e(t,n,r);return Array.isArray(i)?{done:!1,hasNext:!0,hasMany:!0,next:i}:{done:!1,hasNext:!0,next:i}}}export{t as flatMap};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t,r)}function n(e,t){return e.flatMap(t)}function r(e){return(t,n,r)=>{let i=e(t,n,r);return Array.isArray(i)?{done:!1,hasNext:!0,hasMany:!0,next:i}:{done:!1,hasNext:!0,next:i}}}export{t as flatMap};
 //# sourceMappingURL=flat-map.js.map

package/dist/flat-map.js.map

@@ -1 +1 @@
-{"version":3,"file":"flat-map.js","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curry } from './curry';\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param data - The items to map and flatten.\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    P.flatMap(data, callbackfn)\n * @example\n *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    input: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => ReadonlyArray<U> | U,\n): Array<U>;\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    P.flatMap(callbackfn)(data)\n * @example\n *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  callbackfn: (\n    input: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => ReadonlyArray<U> | U,\n): (data: ReadonlyArray<T>) => Array<U>;\n\nexport function flatMap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(flatMapImplementation, args, lazyImplementation);\n}\n\nfunction flatMapImplementation<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => ReadonlyArray<U> | U,\n): Array<U> {\n  return data.flatMap(callbackfn);\n}\n\nfunction lazyImplementation<T, K>(\n  callbackfn: (\n    input: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => K | ReadonlyArray<K>,\n): LazyEvaluator<T, K> {\n  // @ts-expect-error [ts2322] - We need to make LazyMany better so it accommodate the typing here...\n  return (value, index, data) => {\n    const next = callbackfn(value, index, data);\n    return Array.isArray(next)\n      ? { done: false, hasNext: true, hasMany: true, next }\n      : { done: false, hasNext: true, next };\n  };\n}\n"],"mappings":"wCA8DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EACP,EACA,EAKU,CACV,OAAO,EAAK,QAAQ,EAAW,CAGjC,SAAS,EACP,EAKqB,CAErB,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAO,EAAW,EAAO,EAAO,EAAK,CAC3C,OAAO,MAAM,QAAQ,EAAK,CACtB,CAAE,KAAM,GAAO,QAAS,GAAM,QAAS,GAAM,OAAM,CACnD,CAAE,KAAM,GAAO,QAAS,GAAM,OAAM"}
+{"version":3,"file":"flat-map.js","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param data - The items to map and flatten.\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(data, callbackfn)\n * @example\n *    flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  data: ReadonlyArray<T>,\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): Array<U>;\n\n/**\n * Returns a new array formed by applying a given callback function to each\n * element of the array, and then flattening the result by one level. It is\n * identical to a `map` followed by a `flat` of depth 1\n * (`flat(map(data, ...args))`), but slightly more efficient than calling those\n * two methods separately. Equivalent to `Array.prototype.flatMap`.\n *\n * @param callbackfn - A function to execute for each element in the array. It\n * should return an array containing new elements of the new array, or a single\n * non-array value to be added to the new array.\n * @returns A new array with each element being the result of the callback\n * function and flattened by a depth of 1.\n * @signature\n *    flatMap(callbackfn)(data)\n * @example\n *    pipe([1, 2, 3], flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flatMap<T, U>(\n  callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U,\n): (data: ReadonlyArray<T>) => Array<U>;\n\nexport function flatMap(...args: ReadonlyArray<unknown>): unknown {\n  return curry(flatMapImplementation, args, lazyImplementation);\n}\n\nfunction flatMapImplementation<T, U>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U> {\n  return data.flatMap(callbackfn);\n}\n\nfunction lazyImplementation<T, K>(callbackfn: (\n  input: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => K | ReadonlyArray<K>): LazyEvaluator<T, K> {\n  return (value, index, data) => {\n    const next = callbackfn(value, index, data);\n    return Array.isArray(next)\n      ? { done: false, hasNext: true, hasMany: true, next }\n      : { done: false, hasNext: true, next };\n  };\n}\n"],"mappings":"mCAqDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EAA4B,EAAwB,EAAiG,CAC5J,OAAO,EAAK,QAAQ,EAAW,CAGjC,SAAS,EAAyB,EAIc,CAC9C,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAO,EAAW,EAAO,EAAO,EAAK,CAC3C,OAAO,MAAM,QAAQ,EAAK,CACtB,CAAE,KAAM,GAAO,QAAS,GAAM,QAAS,GAAM,OAAM,CACnD,CAAE,KAAM,GAAO,QAAS,GAAM,OAAM"}

package/dist/flat.cjs

@@ -1 +1,2 @@
-const e=require(`./lazy-data-last-impl-D4kLybyP.cjs`),t=require(`./utility-evaluators-CAbODbuk.cjs`);function n(t,n){return typeof t==`object`?r(t,n):e.t(r,t===void 0?[]:[t],i)}function r(e,t){return t===void 0?e.flat():e.flat(t)}function i(e){return e===void 0||e===1?a:e<=0?t.r:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1}}function a(e){return Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1}}exports.flat=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./lazy-data-last-impl-B05ZpguF.cjs`),t=require(`./utility-evaluators-C8koSp9T.cjs`);function n(t,n){return typeof t==`object`?r(t,n):e.t(r,t===void 0?[]:[t],i)}function r(e,t){return t===void 0?e.flat():e.flat(t)}function i(e){return e===void 0||e===1?a:e<=0?t.r:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1}}function a(e){return Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1}}exports.flat=n;
+//# sourceMappingURL=flat.cjs.map

package/dist/flat.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat.cjs","names":["lazyDataLastImpl","lazyIdentityEvaluator"],"sources":["../src/flat.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\nimport { lazyIdentityEvaluator } from './internal/utility-evaluators';\n\ntype FlatArray<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = Depth extends Iteration['length']\n  ? // Stopping condition for the recursion when the array is a tuple.\n  T\n  : T extends readonly []\n    ? // Trivial result when the array is empty.\n      []\n    : T extends readonly [infer Item, ...infer Rest]\n      ? // Tuples could be special-cased by \"iterating\" over each item\n        // separately so that we maintain more information from the input type,\n        // instead of putting all values in a union.\n        [\n          ...(Item extends IterableContainer\n            ? // If the item itself is an array we continue going deeper\n            FlatArray<Item, Depth, [...Iteration, unknown]>\n            : // But if it isn't we add it to the output tuple\n              [Item]),\n          // And we merge this with the result from the rest of the tuple.\n          ...FlatArray<Rest, Depth, Iteration>,\n        ]\n      : // For simple arrays we compute the item type, and wrap it with an\n    // array.\n      Array<FlatSimpleArrayItems<T, Depth, Iteration>>;\n\n// This type is based on the built-in type for `Array.prototype.flat` from the\n// ES2019 Array typescript library, but we improved it to handle any depth\n// (avoiding the fixed `20` in the built-in type).\n// @see https://github.com/microsoft/TypeScript/blob/main/src/lib/es2019.array.d.ts#L1-L5\ntype FlatSimpleArrayItems<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n  IsDone extends boolean = false,\n> = {\n  done: T;\n  recur: T extends ReadonlyArray<infer InnerArr>\n    ? FlatSimpleArrayItems<\n      InnerArr,\n      Depth,\n      [...Iteration, unknown],\n      // This trick allows us to continue 1 iteration more than the depth,\n      // which is required to flatten the array up to depth.\n      Iteration['length'] extends Depth ? true : false\n    >\n    : T;\n}[IsDone extends true ? 'done' : 'recur'];\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param data - The items to flatten.\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1. Non literal values (those typed as\n * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and\n * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For\n * \"unlimited\" depth use a literal value that would exceed your expected\n * practical maximum nesting level.\n * @signature\n *   flat(data)\n *   flat(data, depth)\n * @example\n *   flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]\n *   flat([[[1]], [[2]]], 2); // => [1, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flat<T extends IterableContainer, Depth extends number = 1>(\n  data: T,\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): FlatArray<T, Depth>;\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1.\n * @signature\n *   flat()(data)\n *   flat(depth)(data)\n * @example\n *   pipe([[1, 2], [3, 4], [5], [[6]]], flat()); // => [1, 2, 3, 4, 5, [6]]\n *   pipe([[[1]], [[2]]], flat(2)); // => [1, 2]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flat<Depth extends number = 1>(\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;\n\nexport function flat(\n  dataOrDepth?: IterableContainer | number,\n  depth?: number,\n): unknown {\n  if (typeof dataOrDepth === 'object') {\n    return flatImplementation(dataOrDepth, depth);\n  }\n\n  return lazyDataLastImpl(\n    flatImplementation,\n    dataOrDepth === undefined ? [] : [dataOrDepth],\n    lazyImplementation,\n  );\n}\n\nfunction flatImplementation(data: IterableContainer, depth?: number): IterableContainer {\n  return depth === undefined ? data.flat() : data.flat(depth);\n}\n\nfunction lazyImplementation(depth?: number): LazyEvaluator {\n  if (depth === undefined || depth === 1) {\n    return lazyShallow;\n  }\n\n  if (depth <= 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  return (value) =>\n    Array.isArray(value)\n      ? {\n          next: value.flat(depth - 1),\n          hasNext: true,\n          hasMany: true,\n          done: false,\n        }\n      : { next: value, hasNext: true, done: false }; ;\n}\n\n// This function is pulled out so that we don't generate a new arrow function\n// each time. Because it doesn't need to run with recursion it could be pulled\n// out from the lazyImplementation and be reused for all invocations.\nfunction lazyShallow<T>(value: T): LazyResult<T> {\n  return Array.isArray(value)\n    ? { next: value, hasNext: true, hasMany: true, done: false }\n    : { next: value, hasNext: true, done: false };\n}\n"],"mappings":"wKAyGA,SAAgB,EACd,EACA,EACS,CAKT,OAJI,OAAO,GAAgB,SAClB,EAAmB,EAAa,EAAM,CAGxCA,EAAAA,EACL,EACA,IAAgB,IAAA,GAAY,EAAE,CAAG,CAAC,EAAY,CAC9C,EACD,CAGH,SAAS,EAAmB,EAAyB,EAAmC,CACtF,OAAO,IAAU,IAAA,GAAY,EAAK,MAAM,CAAG,EAAK,KAAK,EAAM,CAG7D,SAAS,EAAmB,EAA+B,CASzD,OARI,IAAU,IAAA,IAAa,IAAU,EAC5B,EAGL,GAAS,EACJC,EAAAA,EAGD,GACN,MAAM,QAAQ,EAAM,CAChB,CACE,KAAM,EAAM,KAAK,EAAQ,EAAE,CAC3B,QAAS,GACT,QAAS,GACT,KAAM,GACP,CACD,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO,CAMnD,SAAS,EAAe,EAAyB,CAC/C,OAAO,MAAM,QAAQ,EAAM,CACvB,CAAE,KAAM,EAAO,QAAS,GAAM,QAAS,GAAM,KAAM,GAAO,CAC1D,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO"}

package/dist/flat.js

@@ -1,2 +1,2 @@
-import{t as e}from"./lazy-data-last-impl-R05wr4K6.js";import{r as t}from"./utility-evaluators-Boc-TMbq.js";function n(t,n){return typeof t==`object`?r(t,n):e(r,t===void 0?[]:[t],i)}function r(e,t){return t===void 0?e.flat():e.flat(t)}function i(e){return e===void 0||e===1?a:e<=0?t:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1}}function a(e){return Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1}}export{n as flat};
+import{t as e}from"./lazy-data-last-impl-Vt_M0l7X.js";import{r as t}from"./utility-evaluators-ZAaUtL2Z.js";function n(t,n){return typeof t==`object`?r(t,n):e(r,t===void 0?[]:[t],i)}function r(e,t){return t===void 0?e.flat():e.flat(t)}function i(e){return e===void 0||e===1?a:e<=0?t:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1}}function a(e){return Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1}}export{n as flat};
 //# sourceMappingURL=flat.js.map

package/dist/flat.js.map

@@ -1 +1 @@
-{"version":3,"file":"flat.js","names":[],"sources":["../src/flat.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\n\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\nimport { lazyIdentityEvaluator } from './internal/utility-evaluators';\n\ntype FlatArray<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = Depth extends Iteration['length']\n  // Stopping condition for the recursion when the array is a tuple.\n  ? T\n  : T extends readonly []\n    // Trivial result when the array is empty.\n    ? []\n    : T extends readonly [infer Item, ...infer Rest]\n      // Tuples could be special-cased by \"iterating\" over each item\n      // separately so that we maintain more information from the input type,\n      // instead of putting all values in a union.\n      ? [\n          ...(Item extends IterableContainer\n            // If the item itself is an array we continue going deeper\n            ? FlatArray<Item, Depth, [...Iteration, unknown]>\n            // But if it isn't we add it to the output tuple\n            : [Item]),\n          // And we merge this with the result from the rest of the tuple.\n          ...FlatArray<Rest, Depth, Iteration>,\n        ]\n      // For simple arrays we compute the item type, and wrap it with an array.\n      : Array<FlatSimpleArrayItems<T, Depth, Iteration>>;\n\n// This type is based on the built-in type for `Array.prototype.flat` from the\n// ES2019 Array typescript library, but we improved it to handle any depth\n// (avoiding the fixed `20` in the built-in type).\n// @see https://github.com/microsoft/TypeScript/blob/main/src/lib/es2019.array.d.ts#L1-L5\ntype FlatSimpleArrayItems<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n  IsDone extends boolean = false,\n> = {\n  done: T;\n  recur: T extends ReadonlyArray<infer InnerArr>\n    ? FlatSimpleArrayItems<\n      InnerArr,\n      Depth,\n      [...Iteration, unknown],\n      // This trick allows us to continue 1 iteration more than the depth,\n      // which is required to flatten the array up to depth.\n      Iteration['length'] extends Depth ? true : false\n    >\n    : T;\n}[IsDone extends true ? 'done' : 'recur'];\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param data - The items to flatten.\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1. Non literal values (those typed as\n * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and\n * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For\n * \"unlimited\" depth use a literal value that would exceed your expected\n * practical maximum nesting level.\n * @signature\n *   P.flat(data)\n *   P.flat(data, depth)\n * @example\n *   P.flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]\n *   P.flat([[[1]], [[2]]], 2); // => [1, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flat<\n  T extends IterableContainer,\n  Depth extends number = 1,\n>(\n  data: T,\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): FlatArray<T, Depth>;\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1.\n * @signature\n *   P.flat()(data)\n *   P.flat(depth)(data)\n * @example\n *   P.pipe([[1, 2], [3, 4], [5], [[6]]], P.flat()); // => [1, 2, 3, 4, 5, [6]]\n *   P.pipe([[[1]], [[2]]], P.flat(2)); // => [1, 2]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flat<Depth extends number = 1>(\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;\n\nexport function flat(\n  dataOrDepth?: IterableContainer | number,\n  depth?: number,\n): unknown {\n  if (typeof dataOrDepth === 'object') {\n    return flatImplementation(dataOrDepth, depth);\n  }\n\n  return lazyDataLastImpl(\n    flatImplementation,\n    dataOrDepth === undefined ? [] : [dataOrDepth],\n    lazyImplementation,\n  );\n}\n\nfunction flatImplementation(\n  data: IterableContainer,\n  depth?: number,\n): IterableContainer {\n  return (depth === undefined ? data.flat() : data.flat(depth));\n};\n\nfunction lazyImplementation(depth?: number): LazyEvaluator {\n  if (depth === undefined || depth === 1) {\n    return lazyShallow;\n  }\n\n  if (depth <= 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  return (value) =>\n    Array.isArray(value)\n      ? {\n          next: value.flat(depth - 1),\n          hasNext: true,\n          hasMany: true,\n          done: false,\n        }\n      : { next: value, hasNext: true, done: false }; ;\n}\n\n/**\n * This function is pulled out so that we don't generate a new function\n * each time. Because it doesn't need to run with recursion it could be pulled\n * out from the lazyImplementation and be reused for all invocations.\n */\nfunction lazyShallow<T>(value: T): LazyResult<T> {\n  return Array.isArray(value)\n    ? { next: value, hasNext: true, hasMany: true, done: false }\n    : { next: value, hasNext: true, done: false };\n}\n"],"mappings":"2GA6GA,SAAgB,EACd,EACA,EACS,CAKT,OAJI,OAAO,GAAgB,SAClB,EAAmB,EAAa,EAAM,CAGxC,EACL,EACA,IAAgB,IAAA,GAAY,EAAE,CAAG,CAAC,EAAY,CAC9C,EACD,CAGH,SAAS,EACP,EACA,EACmB,CACnB,OAAQ,IAAU,IAAA,GAAY,EAAK,MAAM,CAAG,EAAK,KAAK,EAAM,CAG9D,SAAS,EAAmB,EAA+B,CASzD,OARI,IAAU,IAAA,IAAa,IAAU,EAC5B,EAGL,GAAS,EACJ,EAGD,GACN,MAAM,QAAQ,EAAM,CAChB,CACE,KAAM,EAAM,KAAK,EAAQ,EAAE,CAC3B,QAAS,GACT,QAAS,GACT,KAAM,GACP,CACD,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO,CAQnD,SAAS,EAAe,EAAyB,CAC/C,OAAO,MAAM,QAAQ,EAAM,CACvB,CAAE,KAAM,EAAO,QAAS,GAAM,QAAS,GAAM,KAAM,GAAO,CAC1D,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO"}
+{"version":3,"file":"flat.js","names":[],"sources":["../src/flat.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\nimport { lazyIdentityEvaluator } from './internal/utility-evaluators';\n\ntype FlatArray<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = Depth extends Iteration['length']\n  ? // Stopping condition for the recursion when the array is a tuple.\n  T\n  : T extends readonly []\n    ? // Trivial result when the array is empty.\n      []\n    : T extends readonly [infer Item, ...infer Rest]\n      ? // Tuples could be special-cased by \"iterating\" over each item\n        // separately so that we maintain more information from the input type,\n        // instead of putting all values in a union.\n        [\n          ...(Item extends IterableContainer\n            ? // If the item itself is an array we continue going deeper\n            FlatArray<Item, Depth, [...Iteration, unknown]>\n            : // But if it isn't we add it to the output tuple\n              [Item]),\n          // And we merge this with the result from the rest of the tuple.\n          ...FlatArray<Rest, Depth, Iteration>,\n        ]\n      : // For simple arrays we compute the item type, and wrap it with an\n    // array.\n      Array<FlatSimpleArrayItems<T, Depth, Iteration>>;\n\n// This type is based on the built-in type for `Array.prototype.flat` from the\n// ES2019 Array typescript library, but we improved it to handle any depth\n// (avoiding the fixed `20` in the built-in type).\n// @see https://github.com/microsoft/TypeScript/blob/main/src/lib/es2019.array.d.ts#L1-L5\ntype FlatSimpleArrayItems<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n  IsDone extends boolean = false,\n> = {\n  done: T;\n  recur: T extends ReadonlyArray<infer InnerArr>\n    ? FlatSimpleArrayItems<\n      InnerArr,\n      Depth,\n      [...Iteration, unknown],\n      // This trick allows us to continue 1 iteration more than the depth,\n      // which is required to flatten the array up to depth.\n      Iteration['length'] extends Depth ? true : false\n    >\n    : T;\n}[IsDone extends true ? 'done' : 'recur'];\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param data - The items to flatten.\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1. Non literal values (those typed as\n * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and\n * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For\n * \"unlimited\" depth use a literal value that would exceed your expected\n * practical maximum nesting level.\n * @signature\n *   flat(data)\n *   flat(data, depth)\n * @example\n *   flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]\n *   flat([[[1]], [[2]]], 2); // => [1, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flat<T extends IterableContainer, Depth extends number = 1>(\n  data: T,\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): FlatArray<T, Depth>;\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1.\n * @signature\n *   flat()(data)\n *   flat(depth)(data)\n * @example\n *   pipe([[1, 2], [3, 4], [5], [[6]]], flat()); // => [1, 2, 3, 4, 5, [6]]\n *   pipe([[[1]], [[2]]], flat(2)); // => [1, 2]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flat<Depth extends number = 1>(\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;\n\nexport function flat(\n  dataOrDepth?: IterableContainer | number,\n  depth?: number,\n): unknown {\n  if (typeof dataOrDepth === 'object') {\n    return flatImplementation(dataOrDepth, depth);\n  }\n\n  return lazyDataLastImpl(\n    flatImplementation,\n    dataOrDepth === undefined ? [] : [dataOrDepth],\n    lazyImplementation,\n  );\n}\n\nfunction flatImplementation(data: IterableContainer, depth?: number): IterableContainer {\n  return depth === undefined ? data.flat() : data.flat(depth);\n}\n\nfunction lazyImplementation(depth?: number): LazyEvaluator {\n  if (depth === undefined || depth === 1) {\n    return lazyShallow;\n  }\n\n  if (depth <= 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  return (value) =>\n    Array.isArray(value)\n      ? {\n          next: value.flat(depth - 1),\n          hasNext: true,\n          hasMany: true,\n          done: false,\n        }\n      : { next: value, hasNext: true, done: false }; ;\n}\n\n// This function is pulled out so that we don't generate a new arrow function\n// each time. Because it doesn't need to run with recursion it could be pulled\n// out from the lazyImplementation and be reused for all invocations.\nfunction lazyShallow<T>(value: T): LazyResult<T> {\n  return Array.isArray(value)\n    ? { next: value, hasNext: true, hasMany: true, done: false }\n    : { next: value, hasNext: true, done: false };\n}\n"],"mappings":"2GAyGA,SAAgB,EACd,EACA,EACS,CAKT,OAJI,OAAO,GAAgB,SAClB,EAAmB,EAAa,EAAM,CAGxC,EACL,EACA,IAAgB,IAAA,GAAY,EAAE,CAAG,CAAC,EAAY,CAC9C,EACD,CAGH,SAAS,EAAmB,EAAyB,EAAmC,CACtF,OAAO,IAAU,IAAA,GAAY,EAAK,MAAM,CAAG,EAAK,KAAK,EAAM,CAG7D,SAAS,EAAmB,EAA+B,CASzD,OARI,IAAU,IAAA,IAAa,IAAU,EAC5B,EAGL,GAAS,EACJ,EAGD,GACN,MAAM,QAAQ,EAAM,CAChB,CACE,KAAM,EAAM,KAAK,EAAQ,EAAE,CAC3B,QAAS,GACT,QAAS,GACT,KAAM,GACP,CACD,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO,CAMnD,SAAS,EAAe,EAAyB,CAC/C,OAAO,MAAM,QAAQ,EAAM,CACvB,CAAE,KAAM,EAAO,QAAS,GAAM,QAAS,GAAM,KAAM,GAAO,CAC1D,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO"}

package/dist/floor.cjs

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

package/dist/floor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor.cjs","names":["curry","withPrecision"],"sources":["../src/floor.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round down.\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(value, precision);\n * @example\n *    floor(123.9876, 3) // => 123.987\n *    floor(483.22243, 1) // => 483.2\n *    floor(8541, -1) // => 8540\n *    floor(456789, -3) // => 456000\n * @dataFirst\n * @category Number\n */\nexport function floor(value: number, precision: number): number;\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(precision)(value);\n * @example\n *    floor(3)(123.9876) // => 123.987\n *    floor(1)(483.22243) // => 483.2\n *    floor(-1)(8541) // => 8540\n *    floor(-3)(456789) // => 456000\n * @dataLast\n * @category Number\n */\nexport function floor(precision: number): (value: number) => number;\n\nexport function floor(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.floor), args);\n}\n"],"mappings":"6IAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAOA,EAAAA,MAAMC,EAAAA,EAAc,KAAK,MAAM,CAAE,EAAK"}

package/dist/floor.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./with-precision-CQ90Walk.js";function n(...n){return e(t(Math.floor),n)}export{n as floor};
+import{curry as e}from"./curry.js";import{t}from"./with-precision-CgRuf7Wl.js";function n(...n){return e(t(Math.floor),n)}export{n as floor};
 //# sourceMappingURL=floor.js.map

package/dist/floor.js.map

@@ -1 +1 @@
-{"version":3,"file":"floor.js","names":[],"sources":["../src/floor.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round down.\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    P.floor(value, precision);\n * @example\n *    P.floor(123.9876, 3) // => 123.987\n *    P.floor(483.22243, 1) // => 483.2\n *    P.floor(8541, -1) // => 8540\n *    P.floor(456789, -3) // => 456000\n * @dataFirst\n * @category Number\n */\nexport function floor(value: number, precision: number): number;\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    P.floor(precision)(value);\n * @example\n *    P.floor(3)(123.9876) // => 123.987\n *    P.floor(1)(483.22243) // => 483.2\n *    P.floor(-1)(8541) // => 8540\n *    P.floor(-3)(456789) // => 456000\n * @dataLast\n * @category Number\n */\nexport function floor(precision: number): (value: number) => number;\n\nexport function floor(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.floor), args);\n}\n"],"mappings":"oFAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAc,KAAK,MAAM,CAAE,EAAK"}
+{"version":3,"file":"floor.js","names":[],"sources":["../src/floor.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round down.\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(value, precision);\n * @example\n *    floor(123.9876, 3) // => 123.987\n *    floor(483.22243, 1) // => 483.2\n *    floor(8541, -1) // => 8540\n *    floor(456789, -3) // => 456000\n * @dataFirst\n * @category Number\n */\nexport function floor(value: number, precision: number): number;\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    floor(precision)(value);\n * @example\n *    floor(3)(123.9876) // => 123.987\n *    floor(1)(483.22243) // => 483.2\n *    floor(-1)(8541) // => 8540\n *    floor(-3)(456789) // => 456000\n * @dataLast\n * @category Number\n */\nexport function floor(precision: number): (value: number) => number;\n\nexport function floor(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.floor), args);\n}\n"],"mappings":"+EAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAc,KAAK,MAAM,CAAE,EAAK"}

package/dist/for-each-obj.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){for(let[n,r]of Object.entries(e))t(r,n,e);return e}exports.forEachObj=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 Object.entries(e))t(r,n,e);return e}exports.forEachObj=t;
+//# sourceMappingURL=for-each-obj.cjs.map

package/dist/for-each-obj.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-each-obj.cjs","names":["curry"],"sources":["../src/for-each-obj.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param data - The object who'se entries would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEachObj(object, fn)\n * @example\n *    forEachObj({a: 1}, (val, key, obj) => {\n *      console.log(`${key}: ${val}`)\n *    }) // \"a: 1\"\n * @dataFirst\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  data: T,\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): void;\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original object (the ref itself, not a shallow copy of it).\n * @signature\n *    forEachObj(fn)(object)\n * @example\n *    pipe(\n *      {a: 1},\n *      forEachObj((val, key) => console.log(`${key}: ${val}`))\n *    ) // \"a: 1\"\n * @dataLast\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): (object: T) => T;\n\nexport function forEachObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachObjImplementation, args);\n}\n\nfunction forEachObjImplementation<T extends object>(\n  data: T,\n  fn: (value: unknown, key: string, data: T) => void,\n): T {\n  for (const [key, value] of Object.entries(data)) {\n    fn(value, key, data);\n  }\n  return data;\n}\n"],"mappings":"kGA0DA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,MAAM,EAA0B,EAAK,CAG9C,SAAS,EACP,EACA,EACG,CACH,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAC7C,EAAG,EAAO,EAAK,EAAK,CAEtB,OAAO"}

package/dist/for-each-obj.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){for(let[n,r]of Object.entries(e))t(r,n,e);return e}export{t as forEachObj};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){for(let[n,r]of Object.entries(e))t(r,n,e);return e}export{t as forEachObj};
 //# sourceMappingURL=for-each-obj.js.map

package/dist/for-each-obj.js.map

@@ -1 +1 @@
-{"version":3,"file":"for-each-obj.js","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param data - The object who'se entries would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    P.forEachObj(object, fn)\n * @example\n *    P.forEachObj({a: 1}, (val, key, obj) => {\n *      console.log(`${key}: ${val}`)\n *    }) // \"a: 1\"\n * @dataFirst\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  data: T,\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): void;\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original object (the ref itself, not a shallow copy of it).\n * @signature\n *    P.forEachObj(fn)(object)\n * @example\n *    P.pipe(\n *      {a: 1},\n *      P.forEachObj((val, key) => console.log(`${key}: ${val}`))\n *    ) // \"a: 1\"\n * @dataLast\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): (object: T) => T;\n\nexport function forEachObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachObjImplementation, args);\n}\n\nfunction forEachObjImplementation<T extends object>(\n  data: T,\n  fn: (value: unknown, key: string, data: T) => void,\n): T {\n  for (const [key, value] of Object.entries(data)) {\n    fn(value, key, data);\n  }\n  return data;\n}\n"],"mappings":"wCA0DA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EACP,EACA,EACG,CACH,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAC7C,EAAG,EAAO,EAAK,EAAK,CAEtB,OAAO"}
+{"version":3,"file":"for-each-obj.js","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param data - The object who'se entries would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEachObj(object, fn)\n * @example\n *    forEachObj({a: 1}, (val, key, obj) => {\n *      console.log(`${key}: ${val}`)\n *    }) // \"a: 1\"\n * @dataFirst\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  data: T,\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): void;\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original object (the ref itself, not a shallow copy of it).\n * @signature\n *    forEachObj(fn)(object)\n * @example\n *    pipe(\n *      {a: 1},\n *      forEachObj((val, key) => console.log(`${key}: ${val}`))\n *    ) // \"a: 1\"\n * @dataLast\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): (object: T) => T;\n\nexport function forEachObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachObjImplementation, args);\n}\n\nfunction forEachObjImplementation<T extends object>(\n  data: T,\n  fn: (value: unknown, key: string, data: T) => void,\n): T {\n  for (const [key, value] of Object.entries(data)) {\n    fn(value, key, data);\n  }\n  return data;\n}\n"],"mappings":"mCA0DA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EACP,EACA,EACG,CACH,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAC7C,EAAG,EAAO,EAAK,EAAK,CAEtB,OAAO"}

package/dist/for-each.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t,r)}function n(e,t){return e.forEach(t),e}function r(e){return(t,n,r)=>(e(t,n,r),{done:!1,hasNext:!0,next:t})}exports.forEach=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t,r)}function n(e,t){return e.forEach(t),e}function r(e){return(t,n,r)=>(e(t,n,r),{done:!1,hasNext:!0,next:t})}exports.forEach=t;
+//# sourceMappingURL=for-each.cjs.map

package/dist/for-each.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-each.cjs","names":["curry"],"sources":["../src/for-each.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the\n * returned array is equal to the input array (by reference), and not a shallow\n * copy of it!\n *\n * @param data - The values that would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEach(data, callbackfn)\n * @example\n *    forEach([1, 2, 3], x => {\n *      console.log(x)\n *    });\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): void;\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned array is the\n * same reference as the input array, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original array (the ref itself, not a shallow copy of it).\n * @signature\n *    forEach(callbackfn)(data)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      forEach(x => {\n *        console.log(x)\n *      })\n *    ) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): (data: T) => Writable<T>;\n\nexport function forEach(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachImplementation, args, lazyImplementation);\n}\n\nfunction forEachImplementation<T>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): Array<T> {\n  data.forEach(callbackfn);\n  // @ts-expect-error [ts4104] - Because the dataFirst signature returns void this is only a problem when the dataLast function is used **outside** of a pipe; for these cases we warn the user that this is happening.\n  return data;\n}\n\nfunction lazyImplementation<T>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void): LazyEvaluator<T> {\n  return (value, index, data) => {\n    callbackfn(value, index, data);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGA0DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EACP,EACA,EACU,CAGV,OAFA,EAAK,QAAQ,EAAW,CAEjB,EAGT,SAAS,EAAsB,EAAyF,CACtH,OAAQ,EAAO,EAAO,KACpB,EAAW,EAAO,EAAO,EAAK,CACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/for-each.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t,r)}function n(e,t){return e.forEach(t),e}function r(e){return(t,n,r)=>(e(t,n,r),{done:!1,hasNext:!0,next:t})}export{t as forEach};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t,r)}function n(e,t){return e.forEach(t),e}function r(e){return(t,n,r)=>(e(t,n,r),{done:!1,hasNext:!0,next:t})}export{t as forEach};
 //# sourceMappingURL=for-each.js.map

package/dist/for-each.js.map

@@ -1 +1 @@
-{"version":3,"file":"for-each.js","names":[],"sources":["../src/for-each.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curry } from './curry';\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the\n * returned array is equal to the input array (by reference), and not a shallow\n * copy of it!\n *\n * @param data - The values that would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    P.forEach(data, callbackfn)\n * @example\n *    P.forEach([1, 2, 3], x => {\n *      console.log(x)\n *    });\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): void;\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned array is the\n * same reference as the input array, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original array (the ref itself, not a shallow copy of it).\n * @signature\n *    P.forEach(callbackfn)(data)\n * @example\n *    P.pipe(\n *      [1, 2, 3],\n *      P.forEach(x => {\n *        console.log(x)\n *      })\n *    ) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): (data: T) => Writable<T>;\n\nexport function forEach(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachImplementation, args, lazyImplementation);\n}\n\nfunction forEachImplementation<T>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): Array<T> {\n  data.forEach(callbackfn);\n  // @ts-expect-error [ts4104] - Because the dataFirst signature returns void this is only a problem when the dataLast function is used **outside** of a pipe; for these cases we warn the user that this is happening.\n  return data;\n}\n\nfunction lazyImplementation<T>(\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): LazyEvaluator<T> {\n  return (value, index, data) => {\n    callbackfn(value, index, data);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"wCA4DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EACP,EACA,EACU,CAGV,OAFA,EAAK,QAAQ,EAAW,CAEjB,EAGT,SAAS,EACP,EACkB,CAClB,OAAQ,EAAO,EAAO,KACpB,EAAW,EAAO,EAAO,EAAK,CACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"for-each.js","names":[],"sources":["../src/for-each.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the\n * returned array is equal to the input array (by reference), and not a shallow\n * copy of it!\n *\n * @param data - The values that would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    forEach(data, callbackfn)\n * @example\n *    forEach([1, 2, 3], x => {\n *      console.log(x)\n *    });\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): void;\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned array is the\n * same reference as the input array, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original array (the ref itself, not a shallow copy of it).\n * @signature\n *    forEach(callbackfn)(data)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      forEach(x => {\n *        console.log(x)\n *      })\n *    ) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): (data: T) => Writable<T>;\n\nexport function forEach(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachImplementation, args, lazyImplementation);\n}\n\nfunction forEachImplementation<T>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): Array<T> {\n  data.forEach(callbackfn);\n  // @ts-expect-error [ts4104] - Because the dataFirst signature returns void this is only a problem when the dataLast function is used **outside** of a pipe; for these cases we warn the user that this is happening.\n  return data;\n}\n\nfunction lazyImplementation<T>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void): LazyEvaluator<T> {\n  return (value, index, data) => {\n    callbackfn(value, index, data);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"mCA0DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EACP,EACA,EACU,CAGV,OAFA,EAAK,QAAQ,EAAW,CAEjB,EAGT,SAAS,EAAsB,EAAyF,CACtH,OAAQ,EAAO,EAAO,KACpB,EAAW,EAAO,EAAO,EAAK,CACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/from-entries.cjs

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

package/dist/from-entries.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-entries.cjs","names":["curry"],"sources":["../src/from-entries.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { PerkakasTypeError } from './internal/types/perkakas-type-error';\nimport { curry } from './curry';\n\ntype FromEntriesError<Message extends string> = PerkakasTypeError<\n  'fromEntries',\n  Message\n>;\n\ntype Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [\n  key: Key,\n  value: Value,\n];\n\n// The 2 kinds of arrays we accept result in different kinds of outputs:\n// 1. If the input is a *tuple*, we know exactly what entries it would hold,\n// and thus can type the result so that the keys are required. We will then run\n// recursively on the rest of the tuple.\n// 2. If the input is an *array* then any keys defined in the array might not\n// actually show up in runtime, and thus need to be optional. (e.g. if the input\n// is an empty array).\ntype FromEntries<Entries> = Entries extends readonly [\n  infer First,\n  ...infer Tail,\n]\n  ? FromEntriesTuple<First, Tail>\n  : Entries extends readonly [...infer Head, infer Last]\n    ? FromEntriesTuple<Last, Head>\n    : Entries extends IterableContainer<Entry>\n      ? FromEntriesArray<Entries>\n      : FromEntriesError<'Entries array-like could not be inferred'>;\n\n// For strict tuples we build the result by intersecting each entry as a record\n// between it's key and value, recursively. The recursion goes through our main\n// type so that we support tuples which also contain rest parts.\ntype FromEntriesTuple<E, Rest> = E extends Entry\n  ? FromEntries<Rest> & Record<E[0], E[1]>\n  : FromEntriesError<'Array-like contains a non-entry element'>;\n\n// For the array case we also need to handle what kind of keys it defines:\n// 1. If it defines a *broad* key (one that has an infinite set of values, like\n// number or string) then the result is a simple record.\n// 2. If the keys are *literals* then we need to make the record partial\n// (because those props are explicit), and we need to match each key it's\n// specific possible value, as defined by the entries.\n//\n// Note that this destination between keys is the result of how typescript\n// considers Record<string, unknown> to be **implicitly** partial, whereas\n// Record<\"a\", unknown> is not.\ntype FromEntriesArray<Entries extends IterableContainer<Entry>>\n  = string extends AllKeys<Entries>\n    ? Record<string, Entries[number][1]>\n    : number extends AllKeys<Entries>\n      ? Record<number, Entries[number][1]>\n      : symbol extends AllKeys<Entries>\n        ? Record<symbol, Entries[number][1]>\n        : FromEntriesArrayWithLiteralKeys<Entries>;\n\n// This type is largely copied from `objectFromEntries` in the repo:\n// *sindresorhus/ts-extras* but makes all properties of the output optional,\n// which is more correct because we can't assure that an entry will exist for\n// every possible prop/key of the input.\n// @see https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-from-entries.ts)\ntype FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>>\n  = {\n    [P in AllKeys<Entries>]?: ValueForKey<Entries, P>;\n  };\n\ntype AllKeys<Entries extends IterableContainer<Entry>> = Extract<\n  Entries[number],\n  Entry\n>[0];\n\n// I tried and failed to simplify the type here! What the ternary does here is\n// to support the cases where the entries are defined by a single type that\n// defines all entries, but it defines the keys as a union of literals\n// (`['a' | 'b', number]`); which is different from the output of toPairs\n// which would define a separate tuple literal for each key (`['a', number] |\n// ['b', number]`). We need to support both cases!\ntype ValueForKey<\n  Entries extends IterableContainer<Entry>,\n  K extends PropertyKey,\n> = (Extract<Entries[number], Entry<K>> extends never\n  ? Entries[number]\n  : Extract<Entries[number], Entry<K>>)[1];\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * Refer to the docs for more details.\n *\n * @param entries - An array of key-value pairs.\n * @signature\n *   fromEntries(tuples)\n * @example\n *   fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}\n * @dataFirst\n * @category Object\n */\nexport function fromEntries<Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n): Simplify<FromEntries<Entries>>;\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * Refer to the docs for more details.\n *\n * @signature\n *   fromEntries()(tuples)\n * @example\n *   pipe(\n *     [['a', 'b'], ['c', 'd']] as const,\n *     fromEntries(),\n *   ); // => {a: 'b', c: 'd'}\n * @dataLast\n * @category Object\n */\nexport function fromEntries(): <Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n) => Simplify<FromEntries<Entries>>;\n\nexport function fromEntries(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.fromEntries, args);\n}\n"],"mappings":"kGA+IA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAOA,EAAAA,MAAM,OAAO,YAAa,EAAK"}

package/dist/from-entries.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(Object.fromEntries,t)}export{t as fromEntries};
+import{curry as e}from"./curry.js";function t(...t){return e(Object.fromEntries,t)}export{t as fromEntries};
 //# sourceMappingURL=from-entries.js.map

package/dist/from-entries.js.map

@@ -1 +1 @@
-{"version":3,"file":"from-entries.js","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\n\nimport type { PerkakasTypeError } from './internal/types/perkakas-type-error';\nimport { curry } from './curry';\n\ntype FromEntriesError<Message extends string> = PerkakasTypeError<\n  'fromEntries',\n  Message\n>;\n\ntype Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [\n  key: Key,\n  value: Value,\n];\n\n// The 2 kinds of arrays we accept result in different kinds of outputs:\n// 1. If the input is a *tuple*, we know exactly what entries it would hold,\n// and thus can type the result so that the keys are required. We will then run\n// recursively on the rest of the tuple.\n// 2. If the input is an *array* then any keys defined in the array might not\n// actually show up in runtime, and thus need to be optional. (e.g. if the input\n// is an empty array).\ntype FromEntries<Entries> = Entries extends readonly [\n  infer First,\n  ...infer Tail,\n]\n  ? FromEntriesTuple<First, Tail>\n  : Entries extends readonly [...infer Head, infer Last]\n    ? FromEntriesTuple<Last, Head>\n    : Entries extends IterableContainer<Entry>\n      ? FromEntriesArray<Entries>\n      : FromEntriesError<'Entries array-like could not be inferred'>;\n\n// For strict tuples we build the result by intersecting each entry as a record\n// between it's key and value, recursively. The recursion goes through our main\n// type so that we support tuples which also contain rest parts.\ntype FromEntriesTuple<E, Rest> = E extends Entry\n  ? FromEntries<Rest> & Record<E[0], E[1]>\n  : FromEntriesError<'Array-like contains a non-entry element'>;\n\n// For the array case we also need to handle what kind of keys it defines:\n// 1. If it defines a *broad* key (one that has an infinite set of values, like\n// number or string) then the result is a simple record.\n// 2. If the keys are *literals* then we need to make the record partial\n// (because those props are explicit), and we need to match each key it's\n// specific possible value, as defined by the entries.\n//\n// Note that this destination between keys is the result of how typescript\n// considers Record<string, unknown> to be **implicitly** partial, whereas\n// Record<\"a\", unknown> is not.\ntype FromEntriesArray<Entries extends IterableContainer<Entry>>\n  = string extends AllKeys<Entries>\n    ? Record<string, Entries[number][1]>\n    : number extends AllKeys<Entries>\n      ? Record<number, Entries[number][1]>\n      : symbol extends AllKeys<Entries>\n        ? Record<symbol, Entries[number][1]>\n        : FromEntriesArrayWithLiteralKeys<Entries>;\n\n// This type is largely copied from `objectFromEntries` in the repo:\n// *sindresorhus/ts-extras* but makes all properties of the output optional,\n// which is more correct because we can't assure that an entry will exist for\n// every possible prop/key of the input.\n// @see https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-from-entries.ts)\ntype FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>>\n  = {\n    [P in AllKeys<Entries>]?: ValueForKey<Entries, P>;\n  };\n\ntype AllKeys<Entries extends IterableContainer<Entry>> = Extract<\n  Entries[number],\n  Entry\n>[0];\n\n// I tried and failed to simplify the type here! What the ternary does here is\n// to support the cases where the entries are defined by a single type that\n// defines all entries, but it defines the keys as a union of literals\n// (`['a' | 'b', number]`); which is different from the output of toPairs\n// which would define a separate tuple literal for each key (`['a', number] |\n// ['b', number]`). We need to support both cases!\ntype ValueForKey<\n  Entries extends IterableContainer<Entry>,\n  K extends PropertyKey,\n> = (Extract<Entries[number], Entry<K>> extends never\n  ? Entries[number]\n  : Extract<Entries[number], Entry<K>>)[1];\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys`: Builds an object from an array of *keys* and a mapper for values.\n * - `indexBy`: Builds an object from an array of *values* and a mapper for keys.\n * - `pullObject`: Builds an object from an array of items with mappers for *both* keys and values.\n * - `mapToObj`: Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param entries - An array of key-value pairs.\n * @signature\n *   P.fromEntries(tuples)\n * @example\n *   P.fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}\n * @dataFirst\n * @category Object\n */\nexport function fromEntries<Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n): Simplify<FromEntries<Entries>>;\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @signature\n *   P.fromEntries()(tuples)\n * @example\n *   P.pipe(\n *     [['a', 'b'], ['c', 'd']] as const,\n *     P.fromEntries(),\n *   ); // => {a: 'b', c: 'd'}\n * @dataLast\n * @category Object\n */\nexport function fromEntries(): <Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n) => Simplify<FromEntries<Entries>>;\n\nexport function fromEntries(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.fromEntries, args);\n}\n"],"mappings":"wCAmJA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,OAAO,YAAa,EAAK"}
+{"version":3,"file":"from-entries.js","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { PerkakasTypeError } from './internal/types/perkakas-type-error';\nimport { curry } from './curry';\n\ntype FromEntriesError<Message extends string> = PerkakasTypeError<\n  'fromEntries',\n  Message\n>;\n\ntype Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [\n  key: Key,\n  value: Value,\n];\n\n// The 2 kinds of arrays we accept result in different kinds of outputs:\n// 1. If the input is a *tuple*, we know exactly what entries it would hold,\n// and thus can type the result so that the keys are required. We will then run\n// recursively on the rest of the tuple.\n// 2. If the input is an *array* then any keys defined in the array might not\n// actually show up in runtime, and thus need to be optional. (e.g. if the input\n// is an empty array).\ntype FromEntries<Entries> = Entries extends readonly [\n  infer First,\n  ...infer Tail,\n]\n  ? FromEntriesTuple<First, Tail>\n  : Entries extends readonly [...infer Head, infer Last]\n    ? FromEntriesTuple<Last, Head>\n    : Entries extends IterableContainer<Entry>\n      ? FromEntriesArray<Entries>\n      : FromEntriesError<'Entries array-like could not be inferred'>;\n\n// For strict tuples we build the result by intersecting each entry as a record\n// between it's key and value, recursively. The recursion goes through our main\n// type so that we support tuples which also contain rest parts.\ntype FromEntriesTuple<E, Rest> = E extends Entry\n  ? FromEntries<Rest> & Record<E[0], E[1]>\n  : FromEntriesError<'Array-like contains a non-entry element'>;\n\n// For the array case we also need to handle what kind of keys it defines:\n// 1. If it defines a *broad* key (one that has an infinite set of values, like\n// number or string) then the result is a simple record.\n// 2. If the keys are *literals* then we need to make the record partial\n// (because those props are explicit), and we need to match each key it's\n// specific possible value, as defined by the entries.\n//\n// Note that this destination between keys is the result of how typescript\n// considers Record<string, unknown> to be **implicitly** partial, whereas\n// Record<\"a\", unknown> is not.\ntype FromEntriesArray<Entries extends IterableContainer<Entry>>\n  = string extends AllKeys<Entries>\n    ? Record<string, Entries[number][1]>\n    : number extends AllKeys<Entries>\n      ? Record<number, Entries[number][1]>\n      : symbol extends AllKeys<Entries>\n        ? Record<symbol, Entries[number][1]>\n        : FromEntriesArrayWithLiteralKeys<Entries>;\n\n// This type is largely copied from `objectFromEntries` in the repo:\n// *sindresorhus/ts-extras* but makes all properties of the output optional,\n// which is more correct because we can't assure that an entry will exist for\n// every possible prop/key of the input.\n// @see https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-from-entries.ts)\ntype FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>>\n  = {\n    [P in AllKeys<Entries>]?: ValueForKey<Entries, P>;\n  };\n\ntype AllKeys<Entries extends IterableContainer<Entry>> = Extract<\n  Entries[number],\n  Entry\n>[0];\n\n// I tried and failed to simplify the type here! What the ternary does here is\n// to support the cases where the entries are defined by a single type that\n// defines all entries, but it defines the keys as a union of literals\n// (`['a' | 'b', number]`); which is different from the output of toPairs\n// which would define a separate tuple literal for each key (`['a', number] |\n// ['b', number]`). We need to support both cases!\ntype ValueForKey<\n  Entries extends IterableContainer<Entry>,\n  K extends PropertyKey,\n> = (Extract<Entries[number], Entry<K>> extends never\n  ? Entries[number]\n  : Extract<Entries[number], Entry<K>>)[1];\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * Refer to the docs for more details.\n *\n * @param entries - An array of key-value pairs.\n * @signature\n *   fromEntries(tuples)\n * @example\n *   fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}\n * @dataFirst\n * @category Object\n */\nexport function fromEntries<Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n): Simplify<FromEntries<Entries>>;\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * Refer to the docs for more details.\n *\n * @signature\n *   fromEntries()(tuples)\n * @example\n *   pipe(\n *     [['a', 'b'], ['c', 'd']] as const,\n *     fromEntries(),\n *   ); // => {a: 'b', c: 'd'}\n * @dataLast\n * @category Object\n */\nexport function fromEntries(): <Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n) => Simplify<FromEntries<Entries>>;\n\nexport function fromEntries(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.fromEntries, args);\n}\n"],"mappings":"mCA+IA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,OAAO,YAAa,EAAK"}

package/dist/from-keys.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries())n[i]=t(i,r,e);return n}exports.fromKeys=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){let n={};for(let[r,i]of e.entries())n[i]=t(i,r,e);return n}exports.fromKeys=t;
+//# sourceMappingURL=from-keys.cjs.map

package/dist/from-keys.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-keys.cjs","names":["curry"],"sources":["../src/from-keys.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n// Takes a union of literals and creates a union of records with the value V for\n// each key **separately**\n// @example ExactlyOneKey<\"cat\" | \"dog\", boolean> // { cat: boolean } | { dog: boolean }\ntype ExactlyOneKey<T, V> = T extends PropertyKey ? Record<T, V> : never;\n\ntype FromKeys<T extends IterableContainer, V> = T extends readonly []\n  ? // eslint-disable-next-line ts/no-empty-object-type -- We want to return an empty object type here, but it's not trivial to build that in Typescript, other fixer suggestions like Record<PropertyKey, never> or Record<PropertyKey, unknown> both break our type tests so they don't do what we need here. Because the result is mutable this might be the correct type after all...\n    {}\n  : T extends readonly [infer Head, ...infer Rest]\n    ? ExactlyOneKey<Head, V> & FromKeys<Rest, V>\n    : T[number] extends PropertyKey\n      ? BoundedPartial<Record<T[number], V>>\n      : never;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - An array of keys of the output object. All items in the array\n * would be keys in the output array.\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   fromKeys(data, mapper);\n * @example\n *   fromKeys([\"cat\", \"dog\"], length()); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   fromKeys([1, 2], add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataFirst\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): Simplify<FromKeys<T, V>>;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   fromKeys(mapper)(data);\n * @example\n *   pipe([\"cat\", \"dog\"], fromKeys(length())); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   pipe([1, 2], fromKeys(add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataLast\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  mapper: (item: T[number], index: number, data: T) => V,\n): (data: T) => Simplify<FromKeys<T, V>>;\n\nexport function fromKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(fromKeysImplementation, args);\n}\n\nfunction fromKeysImplementation<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): FromKeys<T, V> {\n  const result: Partial<FromKeys<T, V>> = {};\n\n  for (const [index, key] of data.entries()) {\n    // @ts-expect-error [ts7053] - There's no easy way to make Typescript aware that the items in T would be keys in the output object because it's type is built recursively and the \"being an item of an array\" property of a type is not \"carried over\" in the recursive type definition.\n    result[key] = mapper(key, index, data);\n  }\n\n  return result as FromKeys<T, V>;\n}\n"],"mappings":"kGA0EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACgB,CAChB,IAAM,EAAkC,EAAE,CAE1C,IAAK,GAAM,CAAC,EAAO,KAAQ,EAAK,SAAS,CAEvC,EAAO,GAAO,EAAO,EAAK,EAAO,EAAK,CAGxC,OAAO"}

package/dist/from-keys.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries())n[i]=t(i,r,e);return n}export{t as fromKeys};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries())n[i]=t(i,r,e);return n}export{t as fromKeys};
 //# sourceMappingURL=from-keys.js.map

package/dist/from-keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"from-keys.js","names":["result: Partial<FromKeys<T, V>>"],"sources":["../src/from-keys.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\n\nimport type { BoundedPartial } from './internal/types/bounded-partial';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n// Takes a union of literals and creates a union of records with the value V for\n// each key **separately**\n// @example ExactlyOneKey<\"cat\" | \"dog\", boolean> // { cat: boolean } | { dog: boolean }\ntype ExactlyOneKey<T, V> = T extends PropertyKey ? { [P in T]: V } : never;\n\ntype FromKeys<T extends IterableContainer, V> = T extends readonly []\n  // eslint-disable-next-line ts/no-empty-object-type -- We want to return an empty object type here, but it's not trivial to build that in Typescript, other fixer suggestions like Record<PropertyKey, never> or Record<PropertyKey, unknown> both break our type tests so they don't do what we need here. Because the result is mutable this might be the correct type after all...\n  ? {}\n  : T extends readonly [infer Head, ...infer Rest]\n    ? ExactlyOneKey<Head, V> & FromKeys<Rest, V>\n    : T[number] extends PropertyKey\n      ? BoundedPartial<Record<T[number], V>>\n      : never;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - An array of keys of the output object. All items in the array\n * would be keys in the output array.\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   P.fromKeys(data, mapper);\n * @example\n *   P.fromKeys([\"cat\", \"dog\"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataFirst\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): Simplify<FromKeys<T, V>>;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   P.fromKeys(mapper)(data);\n * @example\n *   P.pipe([\"cat\", \"dog\"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataLast\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  mapper: (item: T[number], index: number, data: T) => V,\n): (data: T) => Simplify<FromKeys<T, V>>;\n\nexport function fromKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(fromKeysImplementation, args);\n}\n\nfunction fromKeysImplementation<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): FromKeys<T, V> {\n  const result: Partial<FromKeys<T, V>> = {};\n\n  for (const [index, key] of data.entries()) {\n    // @ts-expect-error [ts7053] - There's no easy way to make Typescript aware that the items in T would be keys in the output object because it's type is built recursively and the \"being an item of an array\" property of a type is not \"carried over\" in the recursive type definition.\n    result[key] = mapper(key, index, data);\n  }\n\n  return result as FromKeys<T, V>;\n}\n"],"mappings":"wCA8EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACgB,CAChB,IAAMA,EAAkC,EAAE,CAE1C,IAAK,GAAM,CAAC,EAAO,KAAQ,EAAK,SAAS,CAEvC,EAAO,GAAO,EAAO,EAAK,EAAO,EAAK,CAGxC,OAAO"}
+{"version":3,"file":"from-keys.js","names":[],"sources":["../src/from-keys.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n// Takes a union of literals and creates a union of records with the value V for\n// each key **separately**\n// @example ExactlyOneKey<\"cat\" | \"dog\", boolean> // { cat: boolean } | { dog: boolean }\ntype ExactlyOneKey<T, V> = T extends PropertyKey ? Record<T, V> : never;\n\ntype FromKeys<T extends IterableContainer, V> = T extends readonly []\n  ? // eslint-disable-next-line ts/no-empty-object-type -- We want to return an empty object type here, but it's not trivial to build that in Typescript, other fixer suggestions like Record<PropertyKey, never> or Record<PropertyKey, unknown> both break our type tests so they don't do what we need here. Because the result is mutable this might be the correct type after all...\n    {}\n  : T extends readonly [infer Head, ...infer Rest]\n    ? ExactlyOneKey<Head, V> & FromKeys<Rest, V>\n    : T[number] extends PropertyKey\n      ? BoundedPartial<Record<T[number], V>>\n      : never;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - An array of keys of the output object. All items in the array\n * would be keys in the output array.\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   fromKeys(data, mapper);\n * @example\n *   fromKeys([\"cat\", \"dog\"], length()); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   fromKeys([1, 2], add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataFirst\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): Simplify<FromKeys<T, V>>;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * Refer to the docs for more details.\n *\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   fromKeys(mapper)(data);\n * @example\n *   pipe([\"cat\", \"dog\"], fromKeys(length())); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   pipe([1, 2], fromKeys(add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataLast\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  mapper: (item: T[number], index: number, data: T) => V,\n): (data: T) => Simplify<FromKeys<T, V>>;\n\nexport function fromKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(fromKeysImplementation, args);\n}\n\nfunction fromKeysImplementation<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): FromKeys<T, V> {\n  const result: Partial<FromKeys<T, V>> = {};\n\n  for (const [index, key] of data.entries()) {\n    // @ts-expect-error [ts7053] - There's no easy way to make Typescript aware that the items in T would be keys in the output object because it's type is built recursively and the \"being an item of an array\" property of a type is not \"carried over\" in the recursive type definition.\n    result[key] = mapper(key, index, data);\n  }\n\n  return result as FromKeys<T, V>;\n}\n"],"mappings":"mCA0EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACgB,CAChB,IAAM,EAAkC,EAAE,CAE1C,IAAK,GAAM,CAAC,EAAO,KAAQ,EAAK,SAAS,CAEvC,EAAO,GAAO,EAAO,EAAK,EAAO,EAAK,CAGxC,OAAO"}

package/dist/funnel.cjs

@@ -1 +1,2 @@
-const e=Symbol(`funnel/voidReducer`),t=()=>e;function n(n,{triggerAt:r=`end`,minQuietPeriodMs:i,maxBurstDurationMs:a,minGapMs:o,reducer:s=t}){let c,l,u,d;function f(){let t=u;t!==void 0&&(u=void 0,t===e?n():n(t),o!==void 0&&(l=setTimeout(p,o)))}function p(){clearTimeout(l),l=void 0,c===void 0&&f()}function m(){clearTimeout(c),c=void 0,d=void 0,l===void 0&&f()}return{call:(...e)=>{let t=c===void 0&&l===void 0;if((r!==`start`||t)&&(u=s(u,...e)),!(c===void 0&&!t)){if(i!==void 0||a!==void 0||o===void 0){clearTimeout(c);let e=Date.now();d??=e;let t=a===void 0?i??0:Math.min(i??a,a-(e-d));c=setTimeout(m,t)}r!==`end`&&t&&f()}},cancel:()=>{clearTimeout(c),c=void 0,d=void 0,clearTimeout(l),l=void 0,u=void 0},flush:()=>{m(),p()},get isIdle(){return c===void 0&&l===void 0}}}exports.funnel=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=Symbol(`funnel/voidReducer`),t=()=>e;function n(n,{triggerAt:r=`end`,minQuietPeriodMs:i,maxBurstDurationMs:a,minGapMs:o,reducer:s=t}){let c,l,u,d,f=()=>{let t=u;t!==void 0&&(u=void 0,t===e?n():n(t),o!==void 0&&(l=setTimeout(p,o)))};function p(){clearTimeout(l),l=void 0,c===void 0&&f()}let m=()=>{clearTimeout(c),c=void 0,d=void 0,l===void 0&&f()};return{call:(...e)=>{let t=c===void 0&&l===void 0;if((r!==`start`||t)&&(u=s(u,...e)),!(c===void 0&&!t)){if(i!==void 0||a!==void 0||o===void 0){clearTimeout(c);let e=Date.now();d??=e;let t=a===void 0?i??0:Math.min(i??a,Math.max(0,a-(e-d)));c=setTimeout(m,t)}r!==`end`&&t&&f()}},cancel:()=>{clearTimeout(c),c=void 0,d=void 0,clearTimeout(l),l=void 0,u=void 0},flush:()=>{m(),p()},get isIdle(){return c===void 0&&l===void 0}}}exports.funnel=n;
+//# sourceMappingURL=funnel.cjs.map

package/dist/funnel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"funnel.cjs","names":[],"sources":["../src/funnel.ts"],"sourcesContent":["import type { RequireAtLeastOne } from 'type-fest';\n\n// We use the value provided by the reducer to also determine if a call\n// was done during a timeout period. This means that even when no reducer\n// is provided, we still need a dummy reducer that would return something\n// other than `undefined`. It is safe to cast this to R (which might be\n// anything) because the callback would never use it as it would be typed\n// as a zero-args function.\nconst VOID_REDUCER_SYMBOL = Symbol('funnel/voidReducer');\nconst voidReducer = <R>(): R => VOID_REDUCER_SYMBOL as R;\n\ntype FunnelOptions<Args extends RestArguments, R> = {\n  readonly reducer?: (accumulator: R | undefined, ...params: Args) => R;\n} & FunnelTimingOptions;\n\n// Not all combinations of timing options are valid, there are dependencies\n// between them to ensure users can't configure the funnel in a way which would\n// cause it to never trigger.\ntype FunnelTimingOptions\n  = | ({ readonly triggerAt?: 'end' } & (\n      | ({ readonly minGapMs: number } & RequireAtLeastOne<{\n        readonly minQuietPeriodMs: number;\n        readonly maxBurstDurationMs: number;\n      }>)\n      | {\n        readonly minQuietPeriodMs?: number;\n        readonly maxBurstDurationMs?: number;\n        readonly minGapMs?: never;\n      }\n    ))\n    | {\n      readonly triggerAt: 'start' | 'both';\n      readonly minQuietPeriodMs?: number;\n      readonly maxBurstDurationMs?: number;\n      readonly minGapMs?: number;\n    };\n\n// eslint-disable-next-line ts/no-explicit-any -- TypeScript has some quirks with generic function types, and works best with `any` and not `unknown`. This follows the typing of built-in utilities like `ReturnType` and `Parameters`.\ntype RestArguments = Array<any>;\n\ninterface Funnel<Args extends RestArguments = []> {\n  /**\n   * Call the function. This might result in the `execute` function being called\n   * now or later, depending on it's configuration and it's current state.\n   *\n   * @param args - The args are defined by the `reducer` function.\n   */\n\n  readonly call: (...args: Args) => void;\n\n  /**\n   * Resets the funnel to it's initial state. Any calls made since the last\n   * invocation will be discarded.\n   */\n  readonly cancel: () => void;\n\n  /**\n   * Triggers an invocation regardless of the current state of the funnel.\n   * Like any other invocation, The funnel will also be reset to it's initial\n   * state afterwards.\n   */\n  readonly flush: () => void;\n\n  /**\n   * The funnel is in it's initial state (there are no active timeouts).\n   */\n  readonly isIdle: boolean;\n}\n\n/**\n * Creates a funnel that controls the timing and execution of `callback`. Its\n * main purpose is to manage multiple consecutive (usually fast-paced) calls,\n * reshaping them according to a defined batching strategy and timing policy.\n * This is useful when handling uncontrolled call rates, such as DOM events or\n * network traffic. It can implement strategies like debouncing, throttling,\n * batching, and more.\n *\n * An optional `reducer` function can be provided to allow passing data to the\n * callback via calls to `call` (otherwise the signature of `call` takes no\n * arguments).\n *\n * Typing is inferred from `callback`s param, and from the rest params that\n * the optional `reducer` function accepts. Use **explicit** types for these\n * to ensure that everything _else_ is well-typed.\n *\n * Notice that this function constructs a funnel **object**, and does **not**\n * execute anything when called. The returned object should be used to execute\n * the funnel via the its `call` method.\n *\n * - Debouncing: use `minQuietPeriodMs` and any `triggerAt`.\n * - Throttling: use `minGapMs` and `triggerAt: \"start\"` or `\"both\"`.\n * - Batching: See the reference implementation in [`funnel.reference-batch.test.ts`](https://github.com/vinicunca/perkakas/blob/main/src/funnel.reference-batch.test.ts).\n *\n * @param callback - The main function that would be invoked periodically based\n * on `options`. The function would take the latest result of the `reducer`; if\n * no calls where made since the last time it was invoked it will not be\n * invoked. (If a return value is needed, it should be passed via a reference or\n * via closure to the outer scope of the funnel).\n * @param options - An object that defines when `execute` should be invoked,\n * relative to the calls of `call`. An empty/missing options object is\n * equivalent to setting `minQuietPeriodMs` to `0`.\n * @param options.reducer - Combines the arguments passed to `call` with the\n * value computed on the previous call (or `undefined` on the first time). The\n * goal of the function is to extract and summarize the data needed for\n * `callback`. It should be fast and simple as it is called often and should\n * defer heavy operations to the `execute` function. If the final value\n * is `undefined`, `callback` will not be called.\n * @param options.triggerAt - At what \"edges\" of the funnel's burst window\n * would `execute` invoke:\n * - `start` - the function will be invoked immediately (within the  **same**\n * execution frame!), and any subsequent calls would be ignored until the funnel\n * is idle again. During this period `reducer` will also not be called.\n * - `end` - the function will **not** be invoked initially but the timer will\n * be started. Any calls during this time would be passed to the reducer, and\n * when the timers are done, the reduced result would trigger an invocation.\n * - `both` - the function will be invoked immediately, and then the funnel\n * would behave as if it was in the 'end' state. Default: 'end'.\n * @param options.minQuietPeriodMs - The burst timer prevents subsequent calls\n * in short succession to cause excessive invocations (aka \"debounce\"). This\n * duration represents the **minimum** amount of time that needs to pass\n * between calls (the \"quiet\" part) in order for the subsequent call to **not**\n * be considered part of the burst. In other words, as long as calls are faster\n * than this, they are considered part of the burst and the burst is extended.\n * @param options.maxBurstDurationMs - Bursts are extended every time a call is\n * made within the burst period. This means that the burst period could be\n * extended indefinitely. To prevent such cases, a maximum burst duration could\n * be defined. When `minQuietPeriodMs` is not defined and this option is, they\n * will both share the same value.\n * @param options.minGapMs - A minimum duration between calls of `execute`.\n * This is maintained regardless of the shape of the burst and is ensured even\n * if the `maxBurstDurationMs` is reached before it. (aka \"throttle\").\n * @returns A funnel with a `call` function that is used to trigger invocations.\n * In addition to it the funnel also comes with the following functions and\n * properties:\n * - `cancel` - Resets the funnel to it's initial state, discarding the current\n * `reducer` result without calling `execute` on it.\n * - `flush` - Triggers an invocation even if there are active timeouts, and\n * then resets the funnel to it's initial state.\n * - `isIdle` - Checks if there are any active timeouts.\n * @signature\n *   funnel(callback, options);\n * @example\n *   const debouncer = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minQuietPeriodMs: 100 },\n *   );\n *   debouncer.call();\n *   debouncer.call();\n *\n *   const throttle = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minGapMs: 100, triggerAt: \"start\" },\n *   );\n *   throttle.call();\n *   throttle.call();\n * @category Function\n */\nexport function funnel<Args extends RestArguments = [], R = never>(\n  callback: (data: R) => void,\n  {\n    triggerAt = 'end',\n    minQuietPeriodMs,\n    maxBurstDurationMs,\n    minGapMs,\n    reducer = voidReducer,\n  }: FunnelOptions<Args, R>,\n): Funnel<Args> {\n  // We manage execution via 2 timeouts, one to track bursts of calls, and one\n  // to track the interval between invocations. Together we refer to the period\n  // where any of these are active as a \"cool-down period\".\n  let burstTimeoutId: ReturnType<typeof setTimeout> | undefined;\n  let intervalTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // Until invoked, all calls are reduced into a single value that would be sent\n  // to the executor on invocation.\n  let preparedData: R | undefined;\n\n  // In order to be able to limit the total size of the burst (when\n  // `maxBurstDurationMs` is used) we need to track when the burst started.\n  let burstStartTimestamp: number | undefined;\n\n  const invoke = (): void => {\n    const param = preparedData;\n    if (param === undefined) {\n      // There were no calls during both cool-down periods.\n      return;\n    }\n\n    // Make sure the args aren't accidentally used again\n    preparedData = undefined;\n\n    if (param === VOID_REDUCER_SYMBOL) {\n      // @ts-expect-error [ts2554] -- R is typed as `never` because we hide the\n      // symbol that `voidReducer` returns; there's no way to make TypeScript\n      // aware of this.\n      callback();\n    } else {\n      callback(param);\n    }\n\n    if (minGapMs !== undefined) {\n      intervalTimeoutId = setTimeout(handleIntervalEnd, minGapMs);\n    }\n  };\n\n  function handleIntervalEnd(): void {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(intervalTimeoutId);\n    intervalTimeoutId = undefined;\n\n    if (burstTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  }\n\n  const handleBurstEnd = (): void => {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(burstTimeoutId);\n    burstTimeoutId = undefined;\n    burstStartTimestamp = undefined;\n\n    if (intervalTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  };\n\n  return {\n    call: (...args) => {\n      // We act based on the initial state of the timeouts before the call is\n      // handled and causes the timeouts to change.\n      const wasIdle\n        = burstTimeoutId === undefined && intervalTimeoutId === undefined;\n\n      if (triggerAt !== 'start' || wasIdle) {\n        preparedData = reducer(preparedData, ...args);\n      }\n\n      if (burstTimeoutId === undefined && !wasIdle) {\n        // We are not in an active burst period but in an interval period. We\n        // don't start a new burst window until the next invoke.\n        return;\n      }\n\n      if (\n        minQuietPeriodMs !== undefined\n        || maxBurstDurationMs !== undefined\n        || minGapMs === undefined\n      ) {\n        // The timeout tracking the burst period needs to be reset every time\n        // another call is made so that it waits the full cool-down duration\n        // before it is released.\n        clearTimeout(burstTimeoutId);\n\n        const now = Date.now();\n\n        burstStartTimestamp ??= now;\n\n        const burstRemainingMs\n          = maxBurstDurationMs === undefined\n            ? (minQuietPeriodMs ?? 0)\n            : Math.min(\n                minQuietPeriodMs ?? maxBurstDurationMs,\n                // We need to account for the time already spent so that we\n                // don't wait longer than the maxDelay.\n                Math.max(0, maxBurstDurationMs - (now - burstStartTimestamp)),\n              );\n\n        burstTimeoutId = setTimeout(handleBurstEnd, burstRemainingMs);\n      }\n\n      if (triggerAt !== 'end' && wasIdle) {\n        invoke();\n      }\n    },\n\n    cancel: () => {\n      clearTimeout(burstTimeoutId);\n      burstTimeoutId = undefined;\n      burstStartTimestamp = undefined;\n\n      clearTimeout(intervalTimeoutId);\n      intervalTimeoutId = undefined;\n\n      preparedData = undefined;\n    },\n\n    flush: () => {\n      handleBurstEnd();\n      handleIntervalEnd();\n    },\n\n    get isIdle() {\n      return burstTimeoutId === undefined && intervalTimeoutId === undefined;\n    },\n  };\n}\n"],"mappings":"mEAQA,MAAM,EAAsB,OAAO,qBAAqB,CAClD,MAA0B,EAwJhC,SAAgB,EACd,EACA,CACE,YAAY,MACZ,mBACA,qBACA,WACA,UAAU,GAEE,CAId,IAAI,EACA,EAIA,EAIA,EAEE,MAAqB,CACzB,IAAM,EAAQ,EACV,IAAU,IAAA,KAMd,EAAe,IAAA,GAEX,IAAU,EAIZ,GAAU,CAEV,EAAS,EAAM,CAGb,IAAa,IAAA,KACf,EAAoB,WAAW,EAAmB,EAAS,IAI/D,SAAS,GAA0B,CAGjC,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEhB,IAAmB,IAAA,IAOvB,GAAQ,CAGV,IAAM,MAA6B,CAGjC,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAElB,IAAsB,IAAA,IAO1B,GAAQ,EAGV,MAAO,CACL,MAAO,GAAG,IAAS,CAGjB,IAAM,EACF,IAAmB,IAAA,IAAa,IAAsB,IAAA,GAE1D,IAAI,IAAc,SAAW,KAC3B,EAAe,EAAQ,EAAc,GAAG,EAAK,EAG3C,MAAmB,IAAA,IAAa,CAAC,GAMrC,IACE,IAAqB,IAAA,IAClB,IAAuB,IAAA,IACvB,IAAa,IAAA,GAChB,CAIA,aAAa,EAAe,CAE5B,IAAM,EAAM,KAAK,KAAK,CAEtB,IAAwB,EAExB,IAAM,EACF,IAAuB,IAAA,GACpB,GAAoB,EACrB,KAAK,IACH,GAAoB,EAGpB,KAAK,IAAI,EAAG,GAAsB,EAAM,GAAqB,CAC9D,CAEP,EAAiB,WAAW,EAAgB,EAAiB,CAG3D,IAAc,OAAS,GACzB,GAAQ,GAIZ,WAAc,CACZ,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAEtB,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEpB,EAAe,IAAA,IAGjB,UAAa,CACX,GAAgB,CAChB,GAAmB,EAGrB,IAAI,QAAS,CACX,OAAO,IAAmB,IAAA,IAAa,IAAsB,IAAA,IAEhE"}

package/dist/funnel.js

@@ -1,2 +1,2 @@
-const e=Symbol(`funnel/voidReducer`),t=()=>e;function n(n,{triggerAt:r=`end`,minQuietPeriodMs:i,maxBurstDurationMs:a,minGapMs:o,reducer:s=t}){let c,l,u,d;function f(){let t=u;t!==void 0&&(u=void 0,t===e?n():n(t),o!==void 0&&(l=setTimeout(p,o)))}function p(){clearTimeout(l),l=void 0,c===void 0&&f()}function m(){clearTimeout(c),c=void 0,d=void 0,l===void 0&&f()}return{call:(...e)=>{let t=c===void 0&&l===void 0;if((r!==`start`||t)&&(u=s(u,...e)),!(c===void 0&&!t)){if(i!==void 0||a!==void 0||o===void 0){clearTimeout(c);let e=Date.now();d??=e;let t=a===void 0?i??0:Math.min(i??a,a-(e-d));c=setTimeout(m,t)}r!==`end`&&t&&f()}},cancel:()=>{clearTimeout(c),c=void 0,d=void 0,clearTimeout(l),l=void 0,u=void 0},flush:()=>{m(),p()},get isIdle(){return c===void 0&&l===void 0}}}export{n as funnel};
+const e=Symbol(`funnel/voidReducer`),t=()=>e;function n(n,{triggerAt:r=`end`,minQuietPeriodMs:i,maxBurstDurationMs:a,minGapMs:o,reducer:s=t}){let c,l,u,d,f=()=>{let t=u;t!==void 0&&(u=void 0,t===e?n():n(t),o!==void 0&&(l=setTimeout(p,o)))};function p(){clearTimeout(l),l=void 0,c===void 0&&f()}let m=()=>{clearTimeout(c),c=void 0,d=void 0,l===void 0&&f()};return{call:(...e)=>{let t=c===void 0&&l===void 0;if((r!==`start`||t)&&(u=s(u,...e)),!(c===void 0&&!t)){if(i!==void 0||a!==void 0||o===void 0){clearTimeout(c);let e=Date.now();d??=e;let t=a===void 0?i??0:Math.min(i??a,Math.max(0,a-(e-d)));c=setTimeout(m,t)}r!==`end`&&t&&f()}},cancel:()=>{clearTimeout(c),c=void 0,d=void 0,clearTimeout(l),l=void 0,u=void 0},flush:()=>{m(),p()},get isIdle(){return c===void 0&&l===void 0}}}export{n as funnel};
 //# sourceMappingURL=funnel.js.map

package/dist/funnel.js.map

@@ -1 +1 @@
-{"version":3,"file":"funnel.js","names":["burstTimeoutId: ReturnType<typeof setTimeout> | undefined","intervalTimeoutId: ReturnType<typeof setTimeout> | undefined","preparedData: R | undefined","burstStartTimestamp: number | undefined"],"sources":["../src/funnel.ts"],"sourcesContent":["import type { RequireAtLeastOne } from 'type-fest';\n\n/**\n * We use the value provided by the reducer to also determine if a call\n * was done during a timeout period. This means that even when no reducer\n * is provided, we still need a dummy reducer that would return something\n * other than `undefined`. It is safe to cast this to R (which might be\n * anything) because the callback would never use it as it would be typed\n * as a zero-args function.\n */\nconst VOID_REDUCER_SYMBOL = Symbol('funnel/voidReducer');\nconst voidReducer = <R>(): R => VOID_REDUCER_SYMBOL as R;\n\ntype FunnelOptions<Args extends RestArguments, R> = {\n  readonly reducer?: (accumulator: R | undefined, ...params: Args) => R;\n} & FunnelTimingOptions;\n\n/**\n * Not all combinations of timing options are valid, there are dependencies\n * between them to ensure users can't configure the funnel in a way which would\n * cause it to never trigger.\n */\ntype FunnelTimingOptions\n  = | ({ readonly triggerAt?: 'end' } & (\n      | ({ readonly minGapMs: number } & RequireAtLeastOne<{\n        readonly minQuietPeriodMs: number;\n        readonly maxBurstDurationMs: number;\n      }>)\n      | {\n        readonly minQuietPeriodMs?: number;\n        readonly maxBurstDurationMs?: number;\n        readonly minGapMs?: never;\n      }\n    ))\n    | {\n      readonly triggerAt: 'start' | 'both';\n      readonly minQuietPeriodMs?: number;\n      readonly maxBurstDurationMs?: number;\n      readonly minGapMs?: number;\n    };\n\n// eslint-disable-next-line ts/no-explicit-any -- TypeScript has some quirks with generic function types, and works best with `any` and not `unknown`. This follows the typing of built-in utilities like `ReturnType` and `Parameters`.\ntype RestArguments = Array<any>;\n\ninterface Funnel<Args extends RestArguments = []> {\n  /**\n   * Call the function. This might result in the `execute` function being called\n   * now or later, depending on it's configuration and it's current state.\n   *\n   * @param args - The args are defined by the `reducer` function.\n   */\n\n  readonly call: (...args: Args) => void;\n\n  /**\n   * Resets the funnel to it's initial state. Any calls made since the last\n   * invocation will be discarded.\n   */\n  readonly cancel: () => void;\n\n  /**\n   * Triggers an invocation regardless of the current state of the funnel.\n   * Like any other invocation, The funnel will also be reset to it's initial\n   * state afterwards.\n   */\n  readonly flush: () => void;\n\n  /**\n   * The funnel is in it's initial state (there are no active timeouts).\n   */\n  readonly isIdle: boolean;\n}\n\n/**\n * Creates a funnel that controls the timing and execution of `callback`. Its\n * main purpose is to manage multiple consecutive (usually fast-paced) calls,\n * reshaping them according to a defined batching strategy and timing policy.\n * This is useful when handling uncontrolled call rates, such as DOM events or\n * network traffic. It can implement strategies like debouncing, throttling,\n * batching, and more.\n *\n * An optional `reducer` function can be provided to allow passing data to the\n * callback via calls to `call` (otherwise the signature of `call` takes no\n * arguments).\n *\n * Typing is inferred from `callback`s param, and from the rest params that\n * the optional `reducer` function accepts. Use **explicit** types for these\n * to ensure that everything _else_ is well-typed.\n *\n * Notice that this function constructs a funnel **object**, and does **not**\n * execute anything when called. The returned object should be used to execute\n * the funnel via the its `call` method.\n *\n * - Debouncing: use `minQuietPeriodMs` and any `triggerAt`.\n * - Throttling: use `minGapMs` and `triggerAt: \"start\"` or `\"both\"`.\n * - Batching: See the reference implementation in [`funnel.reference-batch.test.ts`](https://github.com/vinicunca/perkakas/blob/main/src/funnel.reference-batch.test.ts).\n *\n * @param callback - The main function that would be invoked periodically based\n * on `options`. The function would take the latest result of the `reducer`; if\n * no calls where made since the last time it was invoked it will not be\n * invoked. (If a return value is needed, it should be passed via a reference or\n * via closure to the outer scope of the funnel).\n * @param options - An object that defines when `execute` should be invoked,\n * relative to the calls of `call`. An empty/missing options object is\n * equivalent to setting `minQuietPeriodMs` to `0`.\n * @param options.reducer - Combines the arguments passed to `call` with the\n * value computed on the previous call (or `undefined` on the first time). The\n * goal of the function is to extract and summarize the data needed for\n * `callback`. It should be fast and simple as it is called often and should\n * defer heavy operations to the `execute` function. If the final value\n * is `undefined`, `callback` will not be called.\n * @param options.triggerAt - At what \"edges\" of the funnel's burst window\n * would `execute` invoke:\n * - `start` - the function will be invoked immediately (within the  **same**\n * execution frame!), and any subsequent calls would be ignored until the funnel\n * is idle again. During this period `reducer` will also not be called.\n * - `end` - the function will **not** be invoked initially but the timer will\n * be started. Any calls during this time would be passed to the reducer, and\n * when the timers are done, the reduced result would trigger an invocation.\n * - `both` - the function will be invoked immediately, and then the funnel\n * would behave as if it was in the 'end' state. @default 'end'.\n * @param options.minQuietPeriodMs - The burst timer prevents subsequent calls\n * in short succession to cause excessive invocations (aka \"debounce\"). This\n * duration represents the **minimum** amount of time that needs to pass\n * between calls (the \"quiet\" part) in order for the subsequent call to **not**\n * be considered part of the burst. In other words, as long as calls are faster\n * than this, they are considered part of the burst and the burst is extended.\n * @param options.maxBurstDurationMs - Bursts are extended every time a call is\n * made within the burst period. This means that the burst period could be\n * extended indefinitely. To prevent such cases, a maximum burst duration could\n * be defined. When `minQuietPeriodMs` is not defined and this option is, they\n * will both share the same value.\n * @param options.minGapMs - A minimum duration between calls of `execute`.\n * This is maintained regardless of the shape of the burst and is ensured even\n * if the `maxBurstDurationMs` is reached before it. (aka \"throttle\").\n * @returns A funnel with a `call` function that is used to trigger invocations.\n * In addition to it the funnel also comes with the following functions and\n * properties:\n * - `cancel` - Resets the funnel to it's initial state, discarding the current\n * `reducer` result without calling `execute` on it.\n * - `flush` - Triggers an invocation even if there are active timeouts, and\n * then resets the funnel to it's initial state.\n * - `isIdle` - Checks if there are any active timeouts.\n * @signature\n *   P.funnel(callback, options);\n * @example\n *   const debouncer = P.funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minQuietPeriodMs: 100 },\n *   );\n *   debouncer.call();\n *   debouncer.call();\n *\n *   const throttle = P.funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minGapMs: 100, triggerAt: \"start\" },\n *   );\n *   throttle.call();\n *   throttle.call();\n * @category Function\n */\nexport function funnel<Args extends RestArguments = [], R = never>(\n  callback: (data: R) => void,\n  {\n    triggerAt = 'end',\n    minQuietPeriodMs,\n    maxBurstDurationMs,\n    minGapMs,\n    reducer = voidReducer,\n  }: FunnelOptions<Args, R>,\n): Funnel<Args> {\n  /**\n   * We manage execution via 2 timeouts, one to track bursts of calls, and one\n   * to track the interval between invocations. Together we refer to the period\n   * where any of these are active as a \"cool-down period\".\n   */\n  let burstTimeoutId: ReturnType<typeof setTimeout> | undefined;\n  let intervalTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  /**\n   * Until invoked, all calls are reduced into a single value that would be sent\n   * to the executor on invocation.\n   */\n  let preparedData: R | undefined;\n\n  /**\n   * In order to be able to limit the total size of the burst (when\n   * `maxBurstDurationMs` is used) we need to track when the burst started.\n   */\n  let burstStartTimestamp: number | undefined;\n\n  function invoke(): void {\n    const param = preparedData;\n    if (param === undefined) {\n      // There were no calls during both cool-down periods.\n      return;\n    }\n\n    // Make sure the args aren't accidentally used again\n    preparedData = undefined;\n\n    // eslint-disable-next-line sonar/different-types-comparison\n    if (param === VOID_REDUCER_SYMBOL) {\n      // @ts-expect-error [ts2554] -- R is typed as `never` because we hide the\n      // symbol that `voidReducer` returns; there's no way to make TypeScript\n      // aware of this.\n      callback();\n    } else {\n      callback(param);\n    }\n\n    if (minGapMs !== undefined) {\n      intervalTimeoutId = setTimeout(handleIntervalEnd, minGapMs);\n    }\n  }\n\n  function handleIntervalEnd(): void {\n    /**\n     * When called via a timeout the timeout is already cleared, but when called\n     * via `flush` we need to manually clear it.\n     */\n    clearTimeout(intervalTimeoutId);\n    intervalTimeoutId = undefined;\n\n    if (burstTimeoutId !== undefined) {\n      /**\n       * As long as one of the timeouts is active we don't invoke the function.\n       * Each timeout's end event handler has a call to invoke, so we are\n       * guaranteed to invoke the function eventually.\n       */\n      return;\n    }\n\n    invoke();\n  };\n\n  function handleBurstEnd(): void {\n    /**\n     * When called via a timeout the timeout is already cleared, but when called\n     * via `flush` we need to manually clear it.\n     */\n    clearTimeout(burstTimeoutId);\n    burstTimeoutId = undefined;\n    burstStartTimestamp = undefined;\n\n    if (intervalTimeoutId !== undefined) {\n      /**\n       * As long as one of the timeouts is active we don't invoke the function.\n       * Each timeout's end event handler has a call to invoke, so we are\n       * guaranteed to invoke the function eventually.\n       */\n      return;\n    }\n\n    invoke();\n  };\n\n  return {\n    call: (...args) => {\n      /**\n       * We act based on the initial state of the timeouts before the call is\n       * handled and causes the timeouts to change.\n       */\n      const wasIdle = burstTimeoutId === undefined && intervalTimeoutId === undefined;\n\n      if (triggerAt !== 'start' || wasIdle) {\n        preparedData = reducer(preparedData, ...args);\n      }\n\n      if (burstTimeoutId === undefined && !wasIdle) {\n        /**\n         * We are not in an active burst period but in an interval period. We\n         * don't start a new burst window until the next invoke.\n         */\n        return;\n      }\n\n      if (\n        minQuietPeriodMs !== undefined\n        || maxBurstDurationMs !== undefined\n        || minGapMs === undefined\n      ) {\n        /**\n         * The timeout tracking the burst period needs to be reset every time\n         * another call is made so that it waits the full cool-down duration\n         * before it is released.\n         */\n        clearTimeout(burstTimeoutId);\n\n        const now = Date.now();\n\n        burstStartTimestamp ??= now;\n\n        const burstRemainingMs\n          = maxBurstDurationMs === undefined\n            ? (minQuietPeriodMs ?? 0)\n            : Math.min(\n                minQuietPeriodMs ?? maxBurstDurationMs,\n                /**\n                 * We need to account for the time already spent so that we\n                 * don't wait longer than the maxDelay.\n                 */\n                maxBurstDurationMs - (now - burstStartTimestamp),\n              );\n\n        burstTimeoutId = setTimeout(handleBurstEnd, burstRemainingMs);\n      }\n\n      if (triggerAt !== 'end' && wasIdle) {\n        invoke();\n      }\n    },\n\n    cancel: () => {\n      clearTimeout(burstTimeoutId);\n      burstTimeoutId = undefined;\n      burstStartTimestamp = undefined;\n\n      clearTimeout(intervalTimeoutId);\n      intervalTimeoutId = undefined;\n\n      preparedData = undefined;\n    },\n\n    flush: () => {\n      handleBurstEnd();\n      handleIntervalEnd();\n    },\n\n    get isIdle() {\n      return burstTimeoutId === undefined && intervalTimeoutId === undefined;\n    },\n  };\n}\n"],"mappings":"AAUA,MAAM,EAAsB,OAAO,qBAAqB,CAClD,MAA0B,EA0JhC,SAAgB,EACd,EACA,CACE,YAAY,MACZ,mBACA,qBACA,WACA,UAAU,GAEE,CAMd,IAAIA,EACAC,EAMAC,EAMAC,EAEJ,SAAS,GAAe,CACtB,IAAM,EAAQ,EACV,IAAU,IAAA,KAMd,EAAe,IAAA,GAGX,IAAU,EAIZ,GAAU,CAEV,EAAS,EAAM,CAGb,IAAa,IAAA,KACf,EAAoB,WAAW,EAAmB,EAAS,GAI/D,SAAS,GAA0B,CAKjC,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEhB,IAAmB,IAAA,IASvB,GAAQ,CAGV,SAAS,GAAuB,CAK9B,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAElB,IAAsB,IAAA,IAS1B,GAAQ,CAGV,MAAO,CACL,MAAO,GAAG,IAAS,CAKjB,IAAM,EAAU,IAAmB,IAAA,IAAa,IAAsB,IAAA,GAEtE,IAAI,IAAc,SAAW,KAC3B,EAAe,EAAQ,EAAc,GAAG,EAAK,EAG3C,MAAmB,IAAA,IAAa,CAAC,GAQrC,IACE,IAAqB,IAAA,IAClB,IAAuB,IAAA,IACvB,IAAa,IAAA,GAChB,CAMA,aAAa,EAAe,CAE5B,IAAM,EAAM,KAAK,KAAK,CAEtB,IAAwB,EAExB,IAAM,EACF,IAAuB,IAAA,GACpB,GAAoB,EACrB,KAAK,IACH,GAAoB,EAKpB,GAAsB,EAAM,GAC7B,CAEP,EAAiB,WAAW,EAAgB,EAAiB,CAG3D,IAAc,OAAS,GACzB,GAAQ,GAIZ,WAAc,CACZ,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAEtB,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEpB,EAAe,IAAA,IAGjB,UAAa,CACX,GAAgB,CAChB,GAAmB,EAGrB,IAAI,QAAS,CACX,OAAO,IAAmB,IAAA,IAAa,IAAsB,IAAA,IAEhE"}
+{"version":3,"file":"funnel.js","names":[],"sources":["../src/funnel.ts"],"sourcesContent":["import type { RequireAtLeastOne } from 'type-fest';\n\n// We use the value provided by the reducer to also determine if a call\n// was done during a timeout period. This means that even when no reducer\n// is provided, we still need a dummy reducer that would return something\n// other than `undefined`. It is safe to cast this to R (which might be\n// anything) because the callback would never use it as it would be typed\n// as a zero-args function.\nconst VOID_REDUCER_SYMBOL = Symbol('funnel/voidReducer');\nconst voidReducer = <R>(): R => VOID_REDUCER_SYMBOL as R;\n\ntype FunnelOptions<Args extends RestArguments, R> = {\n  readonly reducer?: (accumulator: R | undefined, ...params: Args) => R;\n} & FunnelTimingOptions;\n\n// Not all combinations of timing options are valid, there are dependencies\n// between them to ensure users can't configure the funnel in a way which would\n// cause it to never trigger.\ntype FunnelTimingOptions\n  = | ({ readonly triggerAt?: 'end' } & (\n      | ({ readonly minGapMs: number } & RequireAtLeastOne<{\n        readonly minQuietPeriodMs: number;\n        readonly maxBurstDurationMs: number;\n      }>)\n      | {\n        readonly minQuietPeriodMs?: number;\n        readonly maxBurstDurationMs?: number;\n        readonly minGapMs?: never;\n      }\n    ))\n    | {\n      readonly triggerAt: 'start' | 'both';\n      readonly minQuietPeriodMs?: number;\n      readonly maxBurstDurationMs?: number;\n      readonly minGapMs?: number;\n    };\n\n// eslint-disable-next-line ts/no-explicit-any -- TypeScript has some quirks with generic function types, and works best with `any` and not `unknown`. This follows the typing of built-in utilities like `ReturnType` and `Parameters`.\ntype RestArguments = Array<any>;\n\ninterface Funnel<Args extends RestArguments = []> {\n  /**\n   * Call the function. This might result in the `execute` function being called\n   * now or later, depending on it's configuration and it's current state.\n   *\n   * @param args - The args are defined by the `reducer` function.\n   */\n\n  readonly call: (...args: Args) => void;\n\n  /**\n   * Resets the funnel to it's initial state. Any calls made since the last\n   * invocation will be discarded.\n   */\n  readonly cancel: () => void;\n\n  /**\n   * Triggers an invocation regardless of the current state of the funnel.\n   * Like any other invocation, The funnel will also be reset to it's initial\n   * state afterwards.\n   */\n  readonly flush: () => void;\n\n  /**\n   * The funnel is in it's initial state (there are no active timeouts).\n   */\n  readonly isIdle: boolean;\n}\n\n/**\n * Creates a funnel that controls the timing and execution of `callback`. Its\n * main purpose is to manage multiple consecutive (usually fast-paced) calls,\n * reshaping them according to a defined batching strategy and timing policy.\n * This is useful when handling uncontrolled call rates, such as DOM events or\n * network traffic. It can implement strategies like debouncing, throttling,\n * batching, and more.\n *\n * An optional `reducer` function can be provided to allow passing data to the\n * callback via calls to `call` (otherwise the signature of `call` takes no\n * arguments).\n *\n * Typing is inferred from `callback`s param, and from the rest params that\n * the optional `reducer` function accepts. Use **explicit** types for these\n * to ensure that everything _else_ is well-typed.\n *\n * Notice that this function constructs a funnel **object**, and does **not**\n * execute anything when called. The returned object should be used to execute\n * the funnel via the its `call` method.\n *\n * - Debouncing: use `minQuietPeriodMs` and any `triggerAt`.\n * - Throttling: use `minGapMs` and `triggerAt: \"start\"` or `\"both\"`.\n * - Batching: See the reference implementation in [`funnel.reference-batch.test.ts`](https://github.com/vinicunca/perkakas/blob/main/src/funnel.reference-batch.test.ts).\n *\n * @param callback - The main function that would be invoked periodically based\n * on `options`. The function would take the latest result of the `reducer`; if\n * no calls where made since the last time it was invoked it will not be\n * invoked. (If a return value is needed, it should be passed via a reference or\n * via closure to the outer scope of the funnel).\n * @param options - An object that defines when `execute` should be invoked,\n * relative to the calls of `call`. An empty/missing options object is\n * equivalent to setting `minQuietPeriodMs` to `0`.\n * @param options.reducer - Combines the arguments passed to `call` with the\n * value computed on the previous call (or `undefined` on the first time). The\n * goal of the function is to extract and summarize the data needed for\n * `callback`. It should be fast and simple as it is called often and should\n * defer heavy operations to the `execute` function. If the final value\n * is `undefined`, `callback` will not be called.\n * @param options.triggerAt - At what \"edges\" of the funnel's burst window\n * would `execute` invoke:\n * - `start` - the function will be invoked immediately (within the  **same**\n * execution frame!), and any subsequent calls would be ignored until the funnel\n * is idle again. During this period `reducer` will also not be called.\n * - `end` - the function will **not** be invoked initially but the timer will\n * be started. Any calls during this time would be passed to the reducer, and\n * when the timers are done, the reduced result would trigger an invocation.\n * - `both` - the function will be invoked immediately, and then the funnel\n * would behave as if it was in the 'end' state. Default: 'end'.\n * @param options.minQuietPeriodMs - The burst timer prevents subsequent calls\n * in short succession to cause excessive invocations (aka \"debounce\"). This\n * duration represents the **minimum** amount of time that needs to pass\n * between calls (the \"quiet\" part) in order for the subsequent call to **not**\n * be considered part of the burst. In other words, as long as calls are faster\n * than this, they are considered part of the burst and the burst is extended.\n * @param options.maxBurstDurationMs - Bursts are extended every time a call is\n * made within the burst period. This means that the burst period could be\n * extended indefinitely. To prevent such cases, a maximum burst duration could\n * be defined. When `minQuietPeriodMs` is not defined and this option is, they\n * will both share the same value.\n * @param options.minGapMs - A minimum duration between calls of `execute`.\n * This is maintained regardless of the shape of the burst and is ensured even\n * if the `maxBurstDurationMs` is reached before it. (aka \"throttle\").\n * @returns A funnel with a `call` function that is used to trigger invocations.\n * In addition to it the funnel also comes with the following functions and\n * properties:\n * - `cancel` - Resets the funnel to it's initial state, discarding the current\n * `reducer` result without calling `execute` on it.\n * - `flush` - Triggers an invocation even if there are active timeouts, and\n * then resets the funnel to it's initial state.\n * - `isIdle` - Checks if there are any active timeouts.\n * @signature\n *   funnel(callback, options);\n * @example\n *   const debouncer = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minQuietPeriodMs: 100 },\n *   );\n *   debouncer.call();\n *   debouncer.call();\n *\n *   const throttle = funnel(\n *     () => {\n *       console.log(\"Callback executed!\");\n *     },\n *     { minGapMs: 100, triggerAt: \"start\" },\n *   );\n *   throttle.call();\n *   throttle.call();\n * @category Function\n */\nexport function funnel<Args extends RestArguments = [], R = never>(\n  callback: (data: R) => void,\n  {\n    triggerAt = 'end',\n    minQuietPeriodMs,\n    maxBurstDurationMs,\n    minGapMs,\n    reducer = voidReducer,\n  }: FunnelOptions<Args, R>,\n): Funnel<Args> {\n  // We manage execution via 2 timeouts, one to track bursts of calls, and one\n  // to track the interval between invocations. Together we refer to the period\n  // where any of these are active as a \"cool-down period\".\n  let burstTimeoutId: ReturnType<typeof setTimeout> | undefined;\n  let intervalTimeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  // Until invoked, all calls are reduced into a single value that would be sent\n  // to the executor on invocation.\n  let preparedData: R | undefined;\n\n  // In order to be able to limit the total size of the burst (when\n  // `maxBurstDurationMs` is used) we need to track when the burst started.\n  let burstStartTimestamp: number | undefined;\n\n  const invoke = (): void => {\n    const param = preparedData;\n    if (param === undefined) {\n      // There were no calls during both cool-down periods.\n      return;\n    }\n\n    // Make sure the args aren't accidentally used again\n    preparedData = undefined;\n\n    if (param === VOID_REDUCER_SYMBOL) {\n      // @ts-expect-error [ts2554] -- R is typed as `never` because we hide the\n      // symbol that `voidReducer` returns; there's no way to make TypeScript\n      // aware of this.\n      callback();\n    } else {\n      callback(param);\n    }\n\n    if (minGapMs !== undefined) {\n      intervalTimeoutId = setTimeout(handleIntervalEnd, minGapMs);\n    }\n  };\n\n  function handleIntervalEnd(): void {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(intervalTimeoutId);\n    intervalTimeoutId = undefined;\n\n    if (burstTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  }\n\n  const handleBurstEnd = (): void => {\n    // When called via a timeout the timeout is already cleared, but when called\n    // via `flush` we need to manually clear it.\n    clearTimeout(burstTimeoutId);\n    burstTimeoutId = undefined;\n    burstStartTimestamp = undefined;\n\n    if (intervalTimeoutId !== undefined) {\n      // As long as one of the timeouts is active we don't invoke the function.\n      // Each timeout's end event handler has a call to invoke, so we are\n      // guaranteed to invoke the function eventually.\n      return;\n    }\n\n    invoke();\n  };\n\n  return {\n    call: (...args) => {\n      // We act based on the initial state of the timeouts before the call is\n      // handled and causes the timeouts to change.\n      const wasIdle\n        = burstTimeoutId === undefined && intervalTimeoutId === undefined;\n\n      if (triggerAt !== 'start' || wasIdle) {\n        preparedData = reducer(preparedData, ...args);\n      }\n\n      if (burstTimeoutId === undefined && !wasIdle) {\n        // We are not in an active burst period but in an interval period. We\n        // don't start a new burst window until the next invoke.\n        return;\n      }\n\n      if (\n        minQuietPeriodMs !== undefined\n        || maxBurstDurationMs !== undefined\n        || minGapMs === undefined\n      ) {\n        // The timeout tracking the burst period needs to be reset every time\n        // another call is made so that it waits the full cool-down duration\n        // before it is released.\n        clearTimeout(burstTimeoutId);\n\n        const now = Date.now();\n\n        burstStartTimestamp ??= now;\n\n        const burstRemainingMs\n          = maxBurstDurationMs === undefined\n            ? (minQuietPeriodMs ?? 0)\n            : Math.min(\n                minQuietPeriodMs ?? maxBurstDurationMs,\n                // We need to account for the time already spent so that we\n                // don't wait longer than the maxDelay.\n                Math.max(0, maxBurstDurationMs - (now - burstStartTimestamp)),\n              );\n\n        burstTimeoutId = setTimeout(handleBurstEnd, burstRemainingMs);\n      }\n\n      if (triggerAt !== 'end' && wasIdle) {\n        invoke();\n      }\n    },\n\n    cancel: () => {\n      clearTimeout(burstTimeoutId);\n      burstTimeoutId = undefined;\n      burstStartTimestamp = undefined;\n\n      clearTimeout(intervalTimeoutId);\n      intervalTimeoutId = undefined;\n\n      preparedData = undefined;\n    },\n\n    flush: () => {\n      handleBurstEnd();\n      handleIntervalEnd();\n    },\n\n    get isIdle() {\n      return burstTimeoutId === undefined && intervalTimeoutId === undefined;\n    },\n  };\n}\n"],"mappings":"AAQA,MAAM,EAAsB,OAAO,qBAAqB,CAClD,MAA0B,EAwJhC,SAAgB,EACd,EACA,CACE,YAAY,MACZ,mBACA,qBACA,WACA,UAAU,GAEE,CAId,IAAI,EACA,EAIA,EAIA,EAEE,MAAqB,CACzB,IAAM,EAAQ,EACV,IAAU,IAAA,KAMd,EAAe,IAAA,GAEX,IAAU,EAIZ,GAAU,CAEV,EAAS,EAAM,CAGb,IAAa,IAAA,KACf,EAAoB,WAAW,EAAmB,EAAS,IAI/D,SAAS,GAA0B,CAGjC,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEhB,IAAmB,IAAA,IAOvB,GAAQ,CAGV,IAAM,MAA6B,CAGjC,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAElB,IAAsB,IAAA,IAO1B,GAAQ,EAGV,MAAO,CACL,MAAO,GAAG,IAAS,CAGjB,IAAM,EACF,IAAmB,IAAA,IAAa,IAAsB,IAAA,GAE1D,IAAI,IAAc,SAAW,KAC3B,EAAe,EAAQ,EAAc,GAAG,EAAK,EAG3C,MAAmB,IAAA,IAAa,CAAC,GAMrC,IACE,IAAqB,IAAA,IAClB,IAAuB,IAAA,IACvB,IAAa,IAAA,GAChB,CAIA,aAAa,EAAe,CAE5B,IAAM,EAAM,KAAK,KAAK,CAEtB,IAAwB,EAExB,IAAM,EACF,IAAuB,IAAA,GACpB,GAAoB,EACrB,KAAK,IACH,GAAoB,EAGpB,KAAK,IAAI,EAAG,GAAsB,EAAM,GAAqB,CAC9D,CAEP,EAAiB,WAAW,EAAgB,EAAiB,CAG3D,IAAc,OAAS,GACzB,GAAQ,GAIZ,WAAc,CACZ,aAAa,EAAe,CAC5B,EAAiB,IAAA,GACjB,EAAsB,IAAA,GAEtB,aAAa,EAAkB,CAC/B,EAAoB,IAAA,GAEpB,EAAe,IAAA,IAGjB,UAAa,CACX,GAAgB,CAChB,GAAmB,EAGrB,IAAI,QAAS,CACX,OAAO,IAAmB,IAAA,IAAa,IAAsB,IAAA,IAEhE"}