@vinicunca/perkakas 1.9.0 → 1.12.0

package/dist/first-CWP5DfBE.d.ts

@@ -1,40 +0,0 @@
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-
-//#region src/first.d.ts
-type First<T extends IterableContainer> = T extends [] ? undefined : T extends readonly [unknown, ...Array<unknown>] ? T[0] : T extends readonly [...infer Pre, infer Last] ? Last | Pre[0] : T[0] | undefined;
-/**
- * Gets the first element of `array`.
- *
- * @param data - The array.
- * @returns The first element of the array.
- * @signature
- *    P.first(array)
- * @example
- *    P.first([1, 2, 3]) // => 1
- *    P.first([]) // => undefined
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function first<T extends IterableContainer>(data: T): First<T>;
-/**
- * Gets the first element of `array`.
- *
- * @returns The first element of the array.
- * @signature
- *    P.first()(array)
- * @example
- *    P.pipe(
- *      [1, 2, 4, 8, 16],
- *      P.filter(x => x > 3),
- *      P.first(),
- *      x => x + 1
- *    ); // => 5
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function first(): <T extends IterableContainer>(data: T) => First<T>;
-//#endregion
-export { first };
-//# sourceMappingURL=first-CWP5DfBE.d.ts.map

package/dist/first-CWP5DfBE.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"first-CWP5DfBE.d.ts","names":[],"sources":["../src/first.ts"],"sourcesContent":[],"mappings":";;;KAKK,gBAAgB,qBAAqB,2BAEtC,gCAAgC,kBAC9B,OACA,gDACE,OAAO,SACP;;AAXqE;;;;;;;;;;;;AA2B7E;AAAqB,iBAAL,KAAK,CAAA,UAAW,iBAAX,CAAA,CAAA,IAAA,EAAoC,CAApC,CAAA,EAAwC,KAAxC,CAA8C,CAA9C,CAAA;;;;;;AAmBrB;;;;;;;;;;;;iBAAgB,KAAA,CAAA,cAAoB,yBAAyB,MAAM,MAAM"}

package/dist/first-DDQc8owl.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";import{toSingle as t}from"./to-single-bHVECPzX.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};
-//# sourceMappingURL=first-DDQc8owl.js.map

package/dist/first-DDQc8owl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"first-DDQc8owl.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":"+FAgDA,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"}

package/dist/first-Dbxt3OEg.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`),t=require(`./to-single-Bnq9l8Zp.cjs`);function n(...n){return e.curry(r,n,t.toSingle(i))}function r([e]){return e}function i(){return a}function a(e){return{hasNext:!0,next:e,done:!0}}Object.defineProperty(exports,`first`,{enumerable:!0,get:function(){return n}});

package/dist/first-by-B5IsCexF.js

@@ -1,2 +0,0 @@
-import{curryOrderRules as e}from"./curry-order-rules-BuA7D1F4.js";import{hasAtLeast as t}from"./has-at-least-6iRvhsST.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-B5IsCexF.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"first-by-B5IsCexF.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":"0HAyEA,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-by-BzxRBZ5J.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-order-rules-UcuuWkKd.cjs`),t=require(`./has-at-least-D-ahiJB6.cjs`);function n(...t){return e.curryOrderRules(r,t)}function r(e,n){if(!t.hasAtLeast(e,2))return e[0];let[r]=e,[,...i]=e;for(let e of i)n(e,r)<0&&(r=e);return r}Object.defineProperty(exports,`firstBy`,{enumerable:!0,get:function(){return n}});

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

@@ -1,60 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { NonEmptyArray } from "./non-empty-array-D3ZRHApS.cjs";
-import { OrderRule } from "./curry-order-rules-1zjlAgqa.cjs";
-
-//#region src/first-by.d.ts
-type FirstBy<T extends IterableContainer> = T[number] | (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined);
-/**
- * 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)*.
- *
- * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
- *
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The first element by the order criteria, or `undefined` if the array
- * is empty. (The function provides strong typing if the input type assures the
- * array isn't empty).
- * @signature
- *   P.firstBy(...rules)(data);
- * @example
- *   const max = P.pipe([1,2,3], P.firstBy([P.identity(), "desc"])); // => 3;
- *   const min = P.pipe([1,2,3], P.firstBy(P.identity())); // => 1;
- *
- *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
- *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, "desc"])); // => { a: "aaa" };
- *   const minBy = P.pipe(data, P.firstBy((item) => item.a.length)); // => { a: "a" };
- *
- *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
- *   const multi = P.pipe(data, P.firstBy(P.prop('type'), [P.prop('size'), 'desc'])); // => {type: "cat", size: 2}
- * @dataLast
- * @category Array
- */
-declare function firstBy<T extends IterableContainer>(...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => FirstBy<T>;
-/**
- * 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)*.
- *
- * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
- *
- * @param data - An array of items.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The first element by the order criteria, or `undefined` if the array
- * is empty. (The function provides strong typing if the input type assures the
- * array isn't empty).
- * @signature
- *   P.firstBy(data, ...rules);
- * @example
- *   const max = P.firstBy([1,2,3], [P.identity(), "desc"]); // => 3;
- *   const min = P.firstBy([1,2,3], P.identity()); // => 1;
- *
- *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
- *   const maxBy = P.firstBy(data, [(item) => item.a.length, "desc"]); // => { a: "aaa" };
- *   const minBy = P.firstBy(data, (item) => item.a.length); // => { a: "a" };
- *
- *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
- *   const multi = P.firstBy(data, P.prop('type'), [P.prop('size'), 'desc']); // => {type: "cat", size: 2}
- * @dataFirst
- * @category Array
- */
-declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
-//#endregion
-export { firstBy };
-//# sourceMappingURL=first-by-Dm9iyhMz.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"first-by-Dm9iyhMz.d.cts","names":[],"sources":["../src/first-by.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,kBAAkB,qBACjB,aACC,gCAAgC,kCAE/B,uBAAuB;;AARuC;;;;;;;;;AAoCtE;;;;;;;;;;;AA6BA;;;AACQ,iBA9BQ,OA8BR,CAAA,UA9B0B,iBA8B1B,CAAA,CAAA,GAAA,KAAA,EA7BI,QA6BJ,CA7Ba,aA6Bb,CA7B2B,SA6B3B,CA7BqC,CA6BrC,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,IAAA,EA5BE,CA4BF,EAAA,GA5BQ,OA4BR,CA5BgB,CA4BhB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;iBADQ,kBAAkB,yBAC1B,aACI,SAAS,cAAc,UAAU,eAC1C,QAAQ"}

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

@@ -1,60 +0,0 @@
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-import { NonEmptyArray } from "./non-empty-array-BfTfvDYg.js";
-import { OrderRule } from "./curry-order-rules-D2zI7gpB.js";
-
-//#region src/first-by.d.ts
-type FirstBy<T extends IterableContainer> = T[number] | (T extends readonly [unknown, ...ReadonlyArray<unknown>] ? never : T extends readonly [...ReadonlyArray<unknown>, unknown] ? never : undefined);
-/**
- * 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)*.
- *
- * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
- *
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The first element by the order criteria, or `undefined` if the array
- * is empty. (The function provides strong typing if the input type assures the
- * array isn't empty).
- * @signature
- *   P.firstBy(...rules)(data);
- * @example
- *   const max = P.pipe([1,2,3], P.firstBy([P.identity(), "desc"])); // => 3;
- *   const min = P.pipe([1,2,3], P.firstBy(P.identity())); // => 1;
- *
- *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
- *   const maxBy = P.pipe(data, P.firstBy([(item) => item.a.length, "desc"])); // => { a: "aaa" };
- *   const minBy = P.pipe(data, P.firstBy((item) => item.a.length)); // => { a: "a" };
- *
- *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
- *   const multi = P.pipe(data, P.firstBy(P.prop('type'), [P.prop('size'), 'desc'])); // => {type: "cat", size: 2}
- * @dataLast
- * @category Array
- */
-declare function firstBy<T extends IterableContainer>(...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => FirstBy<T>;
-/**
- * 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)*.
- *
- * Use `nthBy` if you need an element other that the first, or `takeFirstBy` if you more than just the first element.
- *
- * @param data - An array of items.
- * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, "desc"]` for descending order.
- * @returns The first element by the order criteria, or `undefined` if the array
- * is empty. (The function provides strong typing if the input type assures the
- * array isn't empty).
- * @signature
- *   P.firstBy(data, ...rules);
- * @example
- *   const max = P.firstBy([1,2,3], [P.identity(), "desc"]); // => 3;
- *   const min = P.firstBy([1,2,3], P.identity()); // => 1;
- *
- *   const data = [{ a: "a" }, { a: "aa" }, { a: "aaa" }] as const;
- *   const maxBy = P.firstBy(data, [(item) => item.a.length, "desc"]); // => { a: "aaa" };
- *   const minBy = P.firstBy(data, (item) => item.a.length); // => { a: "a" };
- *
- *   const data = [{type: "cat", size: 1}, {type: "cat", size: 2}, {type: "dog", size: 3}] as const;
- *   const multi = P.firstBy(data, P.prop('type'), [P.prop('size'), 'desc']); // => {type: "cat", size: 2}
- * @dataFirst
- * @category Array
- */
-declare function firstBy<T extends IterableContainer>(data: T, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): FirstBy<T>;
-//#endregion
-export { firstBy };
-//# sourceMappingURL=first-by-DopEPVKr.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"first-by-DopEPVKr.d.ts","names":[],"sources":["../src/first-by.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,kBAAkB,qBACjB,aACC,gCAAgC,kCAE/B,uBAAuB;;AARuC;;;;;;;;;AAoCtE;;;;;;;;;;;AA6BA;;;AACQ,iBA9BQ,OA8BR,CAAA,UA9B0B,iBA8B1B,CAAA,CAAA,GAAA,KAAA,EA7BI,QA6BJ,CA7Ba,aA6Bb,CA7B2B,SA6B3B,CA7BqC,CA6BrC,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAA,IAAA,EA5BE,CA4BF,EAAA,GA5BQ,OA4BR,CA5BgB,CA4BhB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;iBADQ,kBAAkB,yBAC1B,aACI,SAAS,cAAc,UAAU,eAC1C,QAAQ"}

package/dist/flat-BayJJsR-.cjs

@@ -1 +0,0 @@
-const e=require(`./lazy-data-last-impl-3PAFkslW.cjs`),t=require(`./utility-evaluators-DqJcWENu.cjs`);function n(t,n){return typeof t==`object`?r(t,n):e.lazyDataLastImpl(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.lazyIdentityEvaluator: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}}Object.defineProperty(exports,`flat`,{enumerable:!0,get:function(){return n}});

package/dist/flat-CJrZ3ALE.d.cts

@@ -1,53 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { IsNumericLiteral } from "type-fest";
-
-//#region src/flat.d.ts
-type FlatArray<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = []> = Depth extends Iteration['length'] ? T : T extends readonly [] ? [] : T extends readonly [infer Item, ...infer Rest] ? [...(Item extends IterableContainer ? FlatArray<Item, Depth, [...Iteration, unknown]> : [Item]), ...FlatArray<Rest, Depth, Iteration>] : Array<FlatSimpleArrayItems<T, Depth, Iteration>>;
-type FlatSimpleArrayItems<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = [], IsDone extends boolean = false> = {
-  done: T;
-  recur: T extends ReadonlyArray<infer InnerArr> ? FlatSimpleArrayItems<InnerArr, Depth, [...Iteration, unknown], Iteration['length'] extends Depth ? true : false> : T;
-}[IsDone extends true ? 'done' : 'recur'];
-/**
- * Creates a new array with all sub-array elements concatenated into it
- * recursively up to the specified depth. Equivalent to the built-in
- * `Array.prototype.flat` method.
- *
- * @param data - The items to flatten.
- * @param depth - The depth level specifying how deep a nested array structure
- * should be flattened. Defaults to 1. Non literal values (those typed as
- * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and
- * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For
- * "unlimited" depth use a literal value that would exceed your expected
- * practical maximum nesting level.
- * @signature
- *   P.flat(data)
- *   P.flat(data, depth)
- * @example
- *   P.flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]
- *   P.flat([[[1]], [[2]]], 2); // => [1, 2]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function flat<T extends IterableContainer, Depth extends number = 1>(data: T, depth?: IsNumericLiteral<Depth> extends true ? Depth : never): FlatArray<T, Depth>;
-/**
- * Creates a new array with all sub-array elements concatenated into it
- * recursively up to the specified depth. Equivalent to the built-in
- * `Array.prototype.flat` method.
- *
- * @param depth - The depth level specifying how deep a nested array structure
- * should be flattened. Defaults to 1.
- * @signature
- *   P.flat()(data)
- *   P.flat(depth)(data)
- * @example
- *   P.pipe([[1, 2], [3, 4], [5], [[6]]], P.flat()); // => [1, 2, 3, 4, 5, [6]]
- *   P.pipe([[[1]], [[2]]], P.flat(2)); // => [1, 2]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function flat<Depth extends number = 1>(depth?: IsNumericLiteral<Depth> extends true ? Depth : never): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;
-//#endregion
-export { flat };
-//# sourceMappingURL=flat-CJrZ3ALE.d.cts.map

package/dist/flat-CJrZ3ALE.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-CJrZ3ALE.d.cts","names":[],"sources":["../src/flat.ts"],"sourcesContent":[],"mappings":";;;;KASK,qDAGe,+BAChB,cAAc,sBAEd,IACA,6BAGE,sDAKQ,aAAa,oBAEb,UAAU,MAAM,WAAW,wBAE1B,QAnBV,GAqBQ,SArBC,CAqBS,IArBT,EAqBe,KArBf,EAqBsB,SArBtB,CAAA,CAAA,GAwBN,KAxBM,CAwBA,oBAxBA,CAwBqB,CAxBrB,EAwBwB,KAxBxB,EAwB+B,SAxB/B,CAAA,CAAA;KA8BT,oBA3Be,CAAA,CAAA,EAAA,cAAA,MAAA,EAAA,kBA8BA,aA9BA,CAAA,OAAA,CAAA,GAAA,EAAA,EAAA,eAAA,OAAA,GAAA,KAAA,CAAA,GAAA;MAChB,EAgCI,CAhCJ;OAAc,EAiCT,CAjCS,SAiCC,aAjCD,CAAA,KAAA,SAAA,CAAA,GAkCZ,oBAlCY,CAmCZ,QAnCY,EAoCZ,KApCY,EAAA,CAEd,GAmCM,SAnCN,EACA,OAAA,GAqCE,SAlCA,CAAA,QAAA,CAAA,SAkC4B,KAlC5B,GAAA,IAAA,GAAA,KAAA,CAAA,GAoCA,CApCA;EAqCJ,MAhCY,SAAA,IAAA,GAAA,MAAA,GAAA,OAAA,CAAA;;;;;;;;;;;;;;;;;AASD;;;;;;AAeP,iBAgCU,IAhCV,CAAA,UAiCM,iBAjCN,EAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,IAAA,EAoCE,CApCF,EAAA,KAAA,CAAA,EAqCI,gBArCJ,CAqCqB,KArCrB,CAAA,SAAA,IAAA,GAqC2C,KArC3C,GAAA,KAAA,CAAA,EAsCH,SAtCG,CAsCO,CAtCP,EAsCU,KAtCV,CAAA;;;;;;;;;AAgCN;;;;;;;;;AAMG,iBAmBa,IAnBb,CAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,KAAA,CAAA,EAoBO,gBApBP,CAoBwB,KApBxB,CAAA,SAAA,IAAA,GAoB8C,KApB9C,GAAA,KAAA,CAAA,EAAA,CAAA,UAqBW,iBArBX,CAAA,CAAA,IAAA,EAqBoC,CArBpC,EAAA,GAqB0C,SArB1C,CAqBoD,CArBpD,EAqBuD,KArBvD,CAAA"}

package/dist/flat-Cd7pIXar.js

@@ -1,2 +0,0 @@
-import{lazyDataLastImpl as e}from"./lazy-data-last-impl-7QfM1xXg.js";import{lazyIdentityEvaluator as t}from"./utility-evaluators-CnQVdcZv.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-Cd7pIXar.js.map

package/dist/flat-Cd7pIXar.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-Cd7pIXar.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":"8IA6GA,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"}

package/dist/flat-CfT3an2x.d.ts

@@ -1,53 +0,0 @@
-import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
-import { IsNumericLiteral } from "type-fest";
-
-//#region src/flat.d.ts
-type FlatArray<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = []> = Depth extends Iteration['length'] ? T : T extends readonly [] ? [] : T extends readonly [infer Item, ...infer Rest] ? [...(Item extends IterableContainer ? FlatArray<Item, Depth, [...Iteration, unknown]> : [Item]), ...FlatArray<Rest, Depth, Iteration>] : Array<FlatSimpleArrayItems<T, Depth, Iteration>>;
-type FlatSimpleArrayItems<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = [], IsDone extends boolean = false> = {
-  done: T;
-  recur: T extends ReadonlyArray<infer InnerArr> ? FlatSimpleArrayItems<InnerArr, Depth, [...Iteration, unknown], Iteration['length'] extends Depth ? true : false> : T;
-}[IsDone extends true ? 'done' : 'recur'];
-/**
- * Creates a new array with all sub-array elements concatenated into it
- * recursively up to the specified depth. Equivalent to the built-in
- * `Array.prototype.flat` method.
- *
- * @param data - The items to flatten.
- * @param depth - The depth level specifying how deep a nested array structure
- * should be flattened. Defaults to 1. Non literal values (those typed as
- * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and
- * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For
- * "unlimited" depth use a literal value that would exceed your expected
- * practical maximum nesting level.
- * @signature
- *   P.flat(data)
- *   P.flat(data, depth)
- * @example
- *   P.flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]
- *   P.flat([[[1]], [[2]]], 2); // => [1, 2]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function flat<T extends IterableContainer, Depth extends number = 1>(data: T, depth?: IsNumericLiteral<Depth> extends true ? Depth : never): FlatArray<T, Depth>;
-/**
- * Creates a new array with all sub-array elements concatenated into it
- * recursively up to the specified depth. Equivalent to the built-in
- * `Array.prototype.flat` method.
- *
- * @param depth - The depth level specifying how deep a nested array structure
- * should be flattened. Defaults to 1.
- * @signature
- *   P.flat()(data)
- *   P.flat(depth)(data)
- * @example
- *   P.pipe([[1, 2], [3, 4], [5], [[6]]], P.flat()); // => [1, 2, 3, 4, 5, [6]]
- *   P.pipe([[[1]], [[2]]], P.flat(2)); // => [1, 2]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function flat<Depth extends number = 1>(depth?: IsNumericLiteral<Depth> extends true ? Depth : never): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;
-//#endregion
-export { flat };
-//# sourceMappingURL=flat-CfT3an2x.d.ts.map

package/dist/flat-CfT3an2x.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-CfT3an2x.d.ts","names":[],"sources":["../src/flat.ts"],"sourcesContent":[],"mappings":";;;;KASK,qDAGe,+BAChB,cAAc,sBAEd,IACA,6BAGE,sDAKQ,aAAa,oBAEb,UAAU,MAAM,WAAW,wBAE1B,QAnBV,GAqBQ,SArBC,CAqBS,IArBT,EAqBe,KArBf,EAqBsB,SArBtB,CAAA,CAAA,GAwBN,KAxBM,CAwBA,oBAxBA,CAwBqB,CAxBrB,EAwBwB,KAxBxB,EAwB+B,SAxB/B,CAAA,CAAA;KA8BT,oBA3Be,CAAA,CAAA,EAAA,cAAA,MAAA,EAAA,kBA8BA,aA9BA,CAAA,OAAA,CAAA,GAAA,EAAA,EAAA,eAAA,OAAA,GAAA,KAAA,CAAA,GAAA;MAChB,EAgCI,CAhCJ;OAAc,EAiCT,CAjCS,SAiCC,aAjCD,CAAA,KAAA,SAAA,CAAA,GAkCZ,oBAlCY,CAmCZ,QAnCY,EAoCZ,KApCY,EAAA,CAEd,GAmCM,SAnCN,EACA,OAAA,GAqCE,SAlCA,CAAA,QAAA,CAAA,SAkC4B,KAlC5B,GAAA,IAAA,GAAA,KAAA,CAAA,GAoCA,CApCA;EAqCJ,MAhCY,SAAA,IAAA,GAAA,MAAA,GAAA,OAAA,CAAA;;;;;;;;;;;;;;;;;AASD;;;;;;AAeP,iBAgCU,IAhCV,CAAA,UAiCM,iBAjCN,EAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,IAAA,EAoCE,CApCF,EAAA,KAAA,CAAA,EAqCI,gBArCJ,CAqCqB,KArCrB,CAAA,SAAA,IAAA,GAqC2C,KArC3C,GAAA,KAAA,CAAA,EAsCH,SAtCG,CAsCO,CAtCP,EAsCU,KAtCV,CAAA;;;;;;;;;AAgCN;;;;;;;;;AAMG,iBAmBa,IAnBb,CAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,KAAA,CAAA,EAoBO,gBApBP,CAoBwB,KApBxB,CAAA,SAAA,IAAA,GAoB8C,KApB9C,GAAA,KAAA,CAAA,EAAA,CAAA,UAqBW,iBArBX,CAAA,CAAA,IAAA,EAqBoC,CArBpC,EAAA,GAqB0C,SArB1C,CAqBoD,CArBpD,EAqBuD,KArBvD,CAAA"}

package/dist/flat-map-1WAgW39N.js

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

package/dist/flat-map-1WAgW39N.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-map-1WAgW39N.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":"4CA8DA,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"}

package/dist/flat-map-BI-sJd2B.cjs

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

package/dist/flat-map-Do5YLueq.d.cts

@@ -1,47 +0,0 @@
-//#region src/flat-map.d.ts
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param data - The items to map and flatten.
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(data, callbackfn)
- * @example
- *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(data: ReadonlyArray<T>, callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U>;
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(callbackfn)(data)
- * @example
- *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): (data: ReadonlyArray<T>) => Array<U>;
-//#endregion
-export { flatMap };
-//# sourceMappingURL=flat-map-Do5YLueq.d.cts.map

package/dist/flat-map-Do5YLueq.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-map-Do5YLueq.d.cts","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":[],"mappings":";;AAyBA;;;;;;;;;;;;;AA6BA;;;;;;;AAK0B,iBAlCV,OAkCU,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAjClB,aAiCkB,CAjCJ,CAiCI,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EA/Bf,CA+Be,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA7BhB,aA6BgB,CA7BF,CA6BE,CAAA,EAAA,GA5BnB,aA4BmB,CA5BL,CA4BK,CAAA,GA5BA,CA4BA,CAAA,EA3BvB,KA2BuB,CA3BjB,CA2BiB,CAAA;;;;;;;;;;;;;;;;;;;;;iBALV,kCAEL,wBAED,cAAc,OACjB,cAAc,KAAK,WAChB,cAAc,OAAO,MAAM"}

package/dist/flat-map-jJBhHtYT.d.ts

@@ -1,47 +0,0 @@
-//#region src/flat-map.d.ts
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param data - The items to map and flatten.
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(data, callbackfn)
- * @example
- *    P.flatMap([1, 2, 3], x => [x, x * 10]) // => [1, 10, 2, 20, 3, 30]
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(data: ReadonlyArray<T>, callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): Array<U>;
-/**
- * Returns a new array formed by applying a given callback function to each
- * element of the array, and then flattening the result by one level. It is
- * identical to a `map` followed by a `flat` of depth 1
- * (`flat(map(data, ...args))`), but slightly more efficient than calling those
- * two methods separately. Equivalent to `Array.prototype.flatMap`.
- *
- * @param callbackfn - A function to execute for each element in the array. It
- * should return an array containing new elements of the new array, or a single
- * non-array value to be added to the new array.
- * @returns A new array with each element being the result of the callback
- * function and flattened by a depth of 1.
- * @signature
- *    P.flatMap(callbackfn)(data)
- * @example
- *    P.pipe([1, 2, 3], P.flatMap(x => [x, x * 10])) // => [1, 10, 2, 20, 3, 30]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function flatMap<T, U>(callbackfn: (input: T, index: number, data: ReadonlyArray<T>) => ReadonlyArray<U> | U): (data: ReadonlyArray<T>) => Array<U>;
-//#endregion
-export { flatMap };
-//# sourceMappingURL=flat-map-jJBhHtYT.d.ts.map

package/dist/flat-map-jJBhHtYT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-map-jJBhHtYT.d.ts","names":[],"sources":["../src/flat-map.ts"],"sourcesContent":[],"mappings":";;AAyBA;;;;;;;;;;;;;AA6BA;;;;;;;AAK0B,iBAlCV,OAkCU,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAjClB,aAiCkB,CAjCJ,CAiCI,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EA/Bf,CA+Be,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA7BhB,aA6BgB,CA7BF,CA6BE,CAAA,EAAA,GA5BnB,aA4BmB,CA5BL,CA4BK,CAAA,GA5BA,CA4BA,CAAA,EA3BvB,KA2BuB,CA3BjB,CA2BiB,CAAA;;;;;;;;;;;;;;;;;;;;;iBALV,kCAEL,wBAED,cAAc,OACjB,cAAc,KAAK,WAChB,cAAc,OAAO,MAAM"}

package/dist/floor-Bj0O0YjY.cjs

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

package/dist/floor-C_xareFD.js

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

package/dist/floor-C_xareFD.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"floor-C_xareFD.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":"yGAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAc,KAAK,MAAM,CAAE,EAAK"}

package/dist/floor-DTUexUEb.d.ts

@@ -1,39 +0,0 @@
-//#region src/floor.d.ts
-/**
- * Rounds down a given number to a specific precision.
- * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.floor` instead, as it won't incur the additional library overhead.
- *
- * @param value - The number to round down.
- * @param precision - The precision to round down to. Must be an integer between -15 and 15.
- * @signature
- *    P.floor(value, precision);
- * @example
- *    P.floor(123.9876, 3) // => 123.987
- *    P.floor(483.22243, 1) // => 483.2
- *    P.floor(8541, -1) // => 8540
- *    P.floor(456789, -3) // => 456000
- * @dataFirst
- * @category Number
- */
-declare function floor(value: number, precision: number): number;
-/**
- * Rounds down a given number to a specific precision.
- * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.floor` instead, as it won't incur the additional library overhead.
- *
- * @param precision - The precision to round down to. Must be an integer between -15 and 15.
- * @signature
- *    P.floor(precision)(value);
- * @example
- *    P.floor(3)(123.9876) // => 123.987
- *    P.floor(1)(483.22243) // => 483.2
- *    P.floor(-1)(8541) // => 8540
- *    P.floor(-3)(456789) // => 456000
- * @dataLast
- * @category Number
- */
-declare function floor(precision: number): (value: number) => number;
-//#endregion
-export { floor };
-//# sourceMappingURL=floor-DTUexUEb.d.ts.map

package/dist/floor-DTUexUEb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"floor-DTUexUEb.d.ts","names":[],"sources":["../src/floor.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,KAAA;;;;;;;;;;;;;;;;;iBAkBA,KAAA"}

package/dist/floor-bA1oX38x.d.cts

@@ -1,39 +0,0 @@
-//#region src/floor.d.ts
-/**
- * Rounds down a given number to a specific precision.
- * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.floor` instead, as it won't incur the additional library overhead.
- *
- * @param value - The number to round down.
- * @param precision - The precision to round down to. Must be an integer between -15 and 15.
- * @signature
- *    P.floor(value, precision);
- * @example
- *    P.floor(123.9876, 3) // => 123.987
- *    P.floor(483.22243, 1) // => 483.2
- *    P.floor(8541, -1) // => 8540
- *    P.floor(456789, -3) // => 456000
- * @dataFirst
- * @category Number
- */
-declare function floor(value: number, precision: number): number;
-/**
- * Rounds down a given number to a specific precision.
- * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
- * use `Math.floor` instead, as it won't incur the additional library overhead.
- *
- * @param precision - The precision to round down to. Must be an integer between -15 and 15.
- * @signature
- *    P.floor(precision)(value);
- * @example
- *    P.floor(3)(123.9876) // => 123.987
- *    P.floor(1)(483.22243) // => 483.2
- *    P.floor(-1)(8541) // => 8540
- *    P.floor(-3)(456789) // => 456000
- * @dataLast
- * @category Number
- */
-declare function floor(precision: number): (value: number) => number;
-//#endregion
-export { floor };
-//# sourceMappingURL=floor-bA1oX38x.d.cts.map

package/dist/floor-bA1oX38x.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"floor-bA1oX38x.d.cts","names":[],"sources":["../src/floor.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,KAAA;;;;;;;;;;;;;;;;;iBAkBA,KAAA"}

package/dist/for-each-BtbPzNDc.cjs

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