@vinicunca/perkakas 1.7.1 → 1.8.0

package/dist/count-by-CYv2OHvx.d.cts

@@ -0,0 +1,42 @@
+import { BoundedPartial } from "./bounded-partial-A89bt7Kj.cjs";
+
+//#region src/count-by.d.ts
+
+/**
+ * Categorize and count elements in an array using a defined callback function.
+ * The callback function is applied to each element in the array to determine
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param data - The array.
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(data, categorizationFn)
+ * @example
+ *    P.countBy(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      toLowerCase
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataFirst
+ * @category Array
+ */
+declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): BoundedPartial<Record<K, number>>;
+/**
+ * Categorize and count elements in an array using a defined callback function.
+ * The callback function is applied to each element in the array to determine
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(categorizationFn)(data)
+ * @example
+ *    P.pipe(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      P.countBy(toLowerCase),
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataLast
+ * @category Array
+ */
+declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;
+//#endregion
+export { countBy };
+//# sourceMappingURL=count-by-CYv2OHvx.d.cts.map

package/dist/count-by-CYv2OHvx.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-by-CYv2OHvx.d.cts","names":[],"sources":["../src/count-by.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;AAyBA;;AAAqC,iBAzBrB,OAyBqB,CAAA,CAAA,EAAA,UAzBA,WAyBA,CAAA,CAAA,IAAA,EAxB7B,aAwB6B,CAxBf,CAwBe,CAAA,EAAA,gBAAA,EAAA,CAAA,KAAA,EAtB1B,CAsB0B,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EApB3B,aAoB2B,CApBb,CAoBa,CAAA,EAAA,GAnB9B,CAmB8B,GAAA,SAAA,CAAA,EAlBlC,cAkBkC,CAlBnB,MAkBmB,CAlBZ,CAkBY,EAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;iBAArB,qBAAqB,uCAE1B,wBAED,cAAc,OACjB,uBACG,cAAc,OAAO,eAAe,OAAO"}

package/dist/count-by-DUtzS9CI.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n=new Map;for(let[r,i]of e.entries()){let a=t(i,r,e);if(a!==void 0){let e=n.get(a);e===void 0?n.set(a,1):n.set(a,e+1)}}return Object.fromEntries(n)}Object.defineProperty(exports,`countBy`,{enumerable:!0,get:function(){return t}});

package/dist/count-by-DZwTr8U_.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){let n=new Map;for(let[r,i]of e.entries()){let a=t(i,r,e);if(a!==void 0){let e=n.get(a);e===void 0?n.set(a,1):n.set(a,e+1)}}return Object.fromEntries(n)}export{t as countBy};
+//# sourceMappingURL=count-by-DZwTr8U_.js.map

package/dist/count-by-DZwTr8U_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-by-DZwTr8U_.js","names":[],"sources":["../src/count-by.ts"],"sourcesContent":["import type { BoundedPartial } from './internal/types/bounded-partial';\nimport { curry } from './curry';\n\n/**\n * Categorize and count elements in an array using a defined callback function.\n * The callback function is applied to each element in the array to determine\n * its category and then counts how many elements fall into each category.\n *\n * @param data - The array.\n * @param categorizationFn - The categorization function.\n * @signature\n *   P.countBy(data, categorizationFn)\n * @example\n *    P.countBy(\n *      [\"a\", \"b\", \"c\", \"B\", \"A\", \"a\"],\n *      toLowerCase\n *    ); //=> { a: 3, b: 2, c: 1 }\n * @dataFirst\n * @category Array\n */\nexport function countBy<T, K extends PropertyKey>(\n  data: ReadonlyArray<T>,\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => K | undefined,\n): BoundedPartial<Record<K, number>>;\n\n/**\n * Categorize and count elements in an array using a defined callback function.\n * The callback function is applied to each element in the array to determine\n * its category and then counts how many elements fall into each category.\n *\n * @param categorizationFn - The categorization function.\n * @signature\n *   P.countBy(categorizationFn)(data)\n * @example\n *    P.pipe(\n *      [\"a\", \"b\", \"c\", \"B\", \"A\", \"a\"],\n *      P.countBy(toLowerCase),\n *    ); //=> { a: 3, b: 2, c: 1 }\n * @dataLast\n * @category Array\n */\nexport function countBy<T, K extends PropertyKey>(\n  categorizationFn: (\n    value: T,\n    index: number,\n    data: ReadonlyArray<T>,\n  ) => K | undefined,\n): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;\n\nexport function countBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(countByImplementation, args);\n}\n\nfunction countByImplementation<T>(data: ReadonlyArray<T>, categorizationFn: (\n  value: T,\n  index: number,\n  data: ReadonlyArray<T>,\n) => PropertyKey | undefined): BoundedPartial<Record<PropertyKey, number>> {\n  const out = new Map<PropertyKey, number>();\n\n  for (const [index, item] of data.entries()) {\n    const category = categorizationFn(item, index, data);\n    if (category !== undefined) {\n      const count = out.get(category);\n      if (count === undefined) {\n        out.set(category, 1);\n      } else {\n        out.set(category, count + 1);\n      }\n    }\n  }\n\n  return Object.fromEntries(out);\n}\n"],"mappings":"4CAqDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EAAyB,EAAwB,EAIiB,CACzE,IAAM,EAAM,IAAI,IAEhB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAAE,CAC1C,IAAM,EAAW,EAAiB,EAAM,EAAO,EAAK,CACpD,GAAI,IAAa,IAAA,GAAW,CAC1B,IAAM,EAAQ,EAAI,IAAI,EAAS,CAC3B,IAAU,IAAA,GACZ,EAAI,IAAI,EAAU,EAAE,CAEpB,EAAI,IAAI,EAAU,EAAQ,EAAE,EAKlC,OAAO,OAAO,YAAY,EAAI"}

package/dist/count-by-oQGTg_br.d.ts

@@ -0,0 +1,42 @@
+import { BoundedPartial } from "./bounded-partial-TshEjJC1.js";
+
+//#region src/count-by.d.ts
+
+/**
+ * Categorize and count elements in an array using a defined callback function.
+ * The callback function is applied to each element in the array to determine
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param data - The array.
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(data, categorizationFn)
+ * @example
+ *    P.countBy(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      toLowerCase
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataFirst
+ * @category Array
+ */
+declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): BoundedPartial<Record<K, number>>;
+/**
+ * Categorize and count elements in an array using a defined callback function.
+ * The callback function is applied to each element in the array to determine
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(categorizationFn)(data)
+ * @example
+ *    P.pipe(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      P.countBy(toLowerCase),
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataLast
+ * @category Array
+ */
+declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;
+//#endregion
+export { countBy };
+//# sourceMappingURL=count-by-oQGTg_br.d.ts.map

package/dist/count-by-oQGTg_br.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-by-oQGTg_br.d.ts","names":[],"sources":["../src/count-by.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;AAyBA;;AAAqC,iBAzBrB,OAyBqB,CAAA,CAAA,EAAA,UAzBA,WAyBA,CAAA,CAAA,IAAA,EAxB7B,aAwB6B,CAxBf,CAwBe,CAAA,EAAA,gBAAA,EAAA,CAAA,KAAA,EAtB1B,CAsB0B,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EApB3B,aAoB2B,CApBb,CAoBa,CAAA,EAAA,GAnB9B,CAmB8B,GAAA,SAAA,CAAA,EAlBlC,cAkBkC,CAlBnB,MAkBmB,CAlBZ,CAkBY,EAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;iBAArB,qBAAqB,uCAE1B,wBAED,cAAc,OACjB,uBACG,cAAc,OAAO,eAAe,OAAO"}

package/dist/count-by.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk22AQJBPWcjs = require('./chunk-22AQJBPW.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.countBy = _chunk22AQJBPWcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./count-by-DUtzS9CI.cjs`);exports.countBy=e.countBy;

package/dist/count-by.d.cts

@@ -1,41 +1,4 @@
-import { B as BoundedPartial } from './bounded-partial-BhnecV3P.cjs';
-import './is-bounded-record-C9WAwfA8.cjs';
-import 'type-fest';
-
-/**
- * Categorize and count elements in an array using a defined callback function.
- * The callback function is applied to each element in the array to determine
- * its category and then counts how many elements fall into each category.
- *
- * @param data - The array.
- * @param categorizationFn - The categorization function.
- * @signature
- *   P.countBy(data, categorizationFn)
- * @example
- *    P.countBy(
- *      ["a", "b", "c", "B", "A", "a"],
- *      toLowerCase
- *    ); //=> { a: 3, b: 2, c: 1 }
- * @dataFirst
- * @category Array
- */
-declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): BoundedPartial<Record<K, number>>;
-/**
- * Categorize and count elements in an array using a defined callback function.
- * The callback function is applied to each element in the array to determine
- * its category and then counts how many elements fall into each category.
- *
- * @param categorizationFn - The categorization function.
- * @signature
- *   P.countBy(categorizationFn)(data)
- * @example
- *    P.pipe(
- *      ["a", "b", "c", "B", "A", "a"],
- *      P.countBy(toLowerCase),
- *    ); //=> { a: 3, b: 2, c: 1 }
- * @dataLast
- * @category Array
- */
-declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;
-
-export { countBy };
+import "./is-bounded-record-kpsb1wQA.cjs";
+import "./bounded-partial-A89bt7Kj.cjs";
+import { countBy } from "./count-by-CYv2OHvx.cjs";
+export { countBy };

package/dist/count-by.d.ts

@@ -1,41 +1,4 @@
-import { B as BoundedPartial } from './bounded-partial-B15MLSAS.js';
-import './is-bounded-record-C9WAwfA8.js';
-import 'type-fest';
-
-/**
- * Categorize and count elements in an array using a defined callback function.
- * The callback function is applied to each element in the array to determine
- * its category and then counts how many elements fall into each category.
- *
- * @param data - The array.
- * @param categorizationFn - The categorization function.
- * @signature
- *   P.countBy(data, categorizationFn)
- * @example
- *    P.countBy(
- *      ["a", "b", "c", "B", "A", "a"],
- *      toLowerCase
- *    ); //=> { a: 3, b: 2, c: 1 }
- * @dataFirst
- * @category Array
- */
-declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): BoundedPartial<Record<K, number>>;
-/**
- * Categorize and count elements in an array using a defined callback function.
- * The callback function is applied to each element in the array to determine
- * its category and then counts how many elements fall into each category.
- *
- * @param categorizationFn - The categorization function.
- * @signature
- *   P.countBy(categorizationFn)(data)
- * @example
- *    P.pipe(
- *      ["a", "b", "c", "B", "A", "a"],
- *      P.countBy(toLowerCase),
- *    ); //=> { a: 3, b: 2, c: 1 }
- * @dataLast
- * @category Array
- */
-declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;
-
-export { countBy };
+import "./is-bounded-record-DCEYRY41.js";
+import "./bounded-partial-TshEjJC1.js";
+import { countBy } from "./count-by-oQGTg_br.js";
+export { countBy };

package/dist/count-by.js

@@ -1 +1 @@
-import{a}from"./chunk-CTGIT5TY.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as countBy};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{countBy as e}from"./count-by-DZwTr8U_.js";export{e as countBy};

package/dist/curry-B-8l-0vq.d.ts

@@ -0,0 +1,68 @@
+//#region src/internal/types/lazy-result.d.ts
+type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
+interface LazyEmpty {
+  done: boolean;
+  hasNext: false;
+  hasMany?: false | undefined;
+  next?: undefined;
+}
+interface LazyNext<T> {
+  done: boolean;
+  hasNext: true;
+  hasMany?: false | undefined;
+  next: T;
+}
+interface LazyMany<T> {
+  done: boolean;
+  hasNext: true;
+  hasMany: true;
+  next: ReadonlyArray<T>;
+}
+//#endregion
+//#region src/internal/types/lazy-evaluator.d.ts
+type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: ReadonlyArray<T>) => LazyResult<R>;
+//#endregion
+//#region src/curry.d.ts
+/**
+ * Creates a function with `dataFirst` and `dataLast` signatures.
+ *
+ * `curry` is a dynamic function and it's not type safe. It should be wrapped by
+ * a function that have proper typings. Refer to the example below for correct
+ * usage.
+ *
+ * !IMPORTANT: functions that simply call `curry` and return the result (like
+ * almost all functions in this library) should return `unknown` themselves if
+ * an explicit return type is required. This is because we currently don't
+ * provide a generic return type that is built from the input function, and
+ * crafting one manually isn't worthwhile as we rely on function declaration
+ * overloading to combine the types for dataFirst and dataLast invocations!
+ *
+ * @param fn - The function to curry.
+ * @param args - The arguments.
+ * @param lazy - A lazy version of the function to curry.
+ * @signature P.curry(fn, args);
+ * @example
+ *    function _findIndex(array, fn) {
+ *      for (let i = 0; i < array.length; i++) {
+ *        if (fn(array[i])) {
+ *          return i;
+ *        }
+ *      }
+ *      return -1;
+ *    }
+ *
+ *    // data-first
+ *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;
+ *
+ *    // data-last
+ *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;
+ *
+ *    function findIndex(...args: unknown[]) {
+ *      return P.curry(_findIndex, args);
+ *    }
+ * @category Function
+ */
+declare function curry(fn: (...args: any) => unknown, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+//#endregion
+export { curry };
+//# sourceMappingURL=curry-B-8l-0vq.d.ts.map

package/dist/curry-B-8l-0vq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-B-8l-0vq.d.ts","names":[],"sources":["../src/internal/types/lazy-result.ts","../src/internal/types/lazy-evaluator.ts","../src/curry.ts"],"sourcesContent":[],"mappings":";KAAY,gBAAgB,YAAY,SAAS,KAAK,SAAS;AAA/D,UAEU,SAAA,CAFY;EAAA,IAAA,EAAA,OAAA;SAAM,EAAA,KAAA;SAAqB,CAAA,EAAA,KAAA,GAAA,SAAA;MAAT,CAAA,EAAA,SAAA;;UAS9B,QAT4C,CAAA,CAAA,CAAA,CAAA;EAAQ,IAAA,EAAA,OAAA;EAEpD,OAAA,EAAA,IAAS;EAOT,OAAA,CAAA,EAAA,KAAQ,GAAA,SAIT;EAGC,IAAA,EAHF,CAGE;;UAAA,QAIY,CAAA,CAAA,CAAA,CAAA;MAAd,EAAA,OAAA;EAAa,OAAA,EAAA,IAAA;;QAAb,cAAc;;;;AApBV,KCEA,aDFU,CAAA,IAAA,OAAA,EAAA,ICEqB,CDFrB,CAAA,GAAA,CAAA,IAAA,ECGd,CDHc,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,ECKd,aDLc,CCKA,CDLA,CAAA,EAAA,GCMjB,UDNiB,CCMN,CDNM,CAAA;;;AAAtB;;;;;;;;AAAkE;AAE/C;AAWV;;;;;;;;ACXT;;;;;;;;;;;;AC0CA;;;;;;;;;iBAAgB,KAAA,sCAER,iDACmB"}

package/dist/curry-BPVIsvo3.cjs

@@ -0,0 +1 @@
+const e=require(`./lazy-data-last-impl-3PAFkslW.cjs`);function t(t,n,r){let i=t.length-n.length;if(i===0)return t(...n);if(i===1)return e.lazyDataLastImpl(t,n,r);throw Error(`Wrong number of arguments`)}Object.defineProperty(exports,`curry`,{enumerable:!0,get:function(){return t}});

package/dist/curry-CzZjDrpv.js

@@ -0,0 +1,2 @@
+import{lazyDataLastImpl as e}from"./lazy-data-last-impl-7QfM1xXg.js";function t(t,n,r){let i=t.length-n.length;if(i===0)return t(...n);if(i===1)return e(t,n,r);throw Error(`Wrong number of arguments`)}export{t as curry};
+//# sourceMappingURL=curry-CzZjDrpv.js.map

package/dist/curry-CzZjDrpv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-CzZjDrpv.js","names":[],"sources":["../src/curry.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\n/**\n * Creates a function with `dataFirst` and `dataLast` signatures.\n *\n * `curry` is a dynamic function and it's not type safe. It should be wrapped by\n * a function that have proper typings. Refer to the example below for correct\n * usage.\n *\n * !IMPORTANT: functions that simply call `curry` and return the result (like\n * almost all functions in this library) should return `unknown` themselves if\n * an explicit return type is required. This is because we currently don't\n * provide a generic return type that is built from the input function, and\n * crafting one manually isn't worthwhile as we rely on function declaration\n * overloading to combine the types for dataFirst and dataLast invocations!\n *\n * @param fn - The function to curry.\n * @param args - The arguments.\n * @param lazy - A lazy version of the function to curry.\n * @signature P.curry(fn, args);\n * @example\n *    function _findIndex(array, fn) {\n *      for (let i = 0; i < array.length; i++) {\n *        if (fn(array[i])) {\n *          return i;\n *        }\n *      }\n *      return -1;\n *    }\n *\n *    // data-first\n *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;\n *\n *    // data-last\n *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;\n *\n *    function findIndex(...args: unknown[]) {\n *      return P.curry(_findIndex, args);\n *    }\n * @category Function\n */\nexport function curry(\n  fn: (...args: any) => unknown,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n): unknown {\n  const diff = fn.length - args.length;\n  if (diff === 0) {\n    return fn(...args);\n  }\n\n  if (diff === 1) {\n    return lazyDataLastImpl(fn, args, lazy);\n  }\n\n  throw new Error('Wrong number of arguments');\n}\n"],"mappings":"qEA4CA,SAAgB,EACd,EACA,EACA,EACS,CACT,IAAM,EAAO,EAAG,OAAS,EAAK,OAC9B,GAAI,IAAS,EACX,OAAO,EAAG,GAAG,EAAK,CAGpB,GAAI,IAAS,EACX,OAAO,EAAiB,EAAI,EAAM,EAAK,CAGzC,MAAU,MAAM,4BAA4B"}

package/dist/curry-from-lazy-BDH06qZ-.cjs

@@ -0,0 +1 @@
+const e=require(`./pipe-DlFjc4Wf.cjs`);function t(t,n){let r=n.length-t.length;if(r===1){let[r,...i]=n;return e.pipe(r,{lazy:t,lazyArgs:i})}if(r===0){let r={lazy:t,lazyArgs:n};return Object.assign(t=>e.pipe(t,r),r)}throw Error(`Wrong number of arguments`)}Object.defineProperty(exports,`curryFromLazy`,{enumerable:!0,get:function(){return t}});

package/dist/curry-from-lazy-BR-hoRDR.js

@@ -0,0 +1,2 @@
+import{pipe as e}from"./pipe-CtsfTnqv.js";function t(t,n){let r=n.length-t.length;if(r===1){let[r,...i]=n;return e(r,{lazy:t,lazyArgs:i})}if(r===0){let r={lazy:t,lazyArgs:n};return Object.assign(t=>e(t,r),r)}throw Error(`Wrong number of arguments`)}export{t as curryFromLazy};
+//# sourceMappingURL=curry-from-lazy-BR-hoRDR.js.map

package/dist/curry-from-lazy-BR-hoRDR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-from-lazy-BR-hoRDR.js","names":[],"sources":["../src/internal/curry-from-lazy.ts"],"sourcesContent":["import type { LazyDefinition } from './types/lazy-definition';\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport { pipe } from '../pipe';\n\n/**\n * A version of `curry` for cases where the only meaningful implementation is a\n * lazy one. This is useful for functions that don't have a built-in\n * implementation already, and that can't be optimized to take advantage of\n * having the complete array upfront.\n *\n * Under the hood the function uses `pipe` to utilize it's built-in lazy logic\n * and wraps the pipe with the required invocations to allow using the function\n * outside of pipes too.\n *\n * @param lazy - The main lazy implementation, it assumes that data is an\n * iterable (array-like).\n * @param args - The arguments passed to the overloaded invocation.\n * @see curry\n * @see pipe\n */\nexport function curryFromLazy(\n  // eslint-disable-next-line ts/no-explicit-any\n  lazy: (...args: any) => LazyEvaluator,\n  args: ReadonlyArray<unknown>,\n): unknown {\n  const diff = args.length - lazy.length;\n\n  if (diff === 1) {\n    // dataFirst\n    const [data, ...rest] = args;\n    const lazyDefinition = { lazy, lazyArgs: rest } satisfies LazyDefinition;\n\n    // @ts-expect-error [ts2353] - Pipe expects a function which *might* also have a lazy definition. We are tricking pipe here to take our lazyDefinition without any function attached to it.\n    return pipe(data, lazyDefinition);\n  }\n\n  if (diff === 0) {\n    const lazyDefinition = { lazy, lazyArgs: args } satisfies LazyDefinition;\n\n    // @ts-expect-error [ts2353] - Pipe expects a function which *might* also have a lazy definition. We are tricking pipe here to take our lazyDefinition without any function attached to it.\n    const dataLast = (data: unknown): unknown => pipe(data, lazyDefinition);\n    return Object.assign(dataLast, lazyDefinition);\n  }\n\n  throw new Error('Wrong number of arguments');\n}\n"],"mappings":"0CAoBA,SAAgB,EAEd,EACA,EACS,CACT,IAAM,EAAO,EAAK,OAAS,EAAK,OAEhC,GAAI,IAAS,EAAG,CAEd,GAAM,CAAC,EAAM,GAAG,GAAQ,EAIxB,OAAO,EAAK,EAHW,CAAE,OAAM,SAAU,EAAM,CAGd,CAGnC,GAAI,IAAS,EAAG,CACd,IAAM,EAAiB,CAAE,OAAM,SAAU,EAAM,CAI/C,OAAO,OAAO,OADI,GAA2B,EAAK,EAAM,EAAe,CACxC,EAAe,CAGhD,MAAU,MAAM,4BAA4B"}

package/dist/curry-gLBYaLmk.d.cts

@@ -0,0 +1,68 @@
+//#region src/internal/types/lazy-result.d.ts
+type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
+interface LazyEmpty {
+  done: boolean;
+  hasNext: false;
+  hasMany?: false | undefined;
+  next?: undefined;
+}
+interface LazyNext<T> {
+  done: boolean;
+  hasNext: true;
+  hasMany?: false | undefined;
+  next: T;
+}
+interface LazyMany<T> {
+  done: boolean;
+  hasNext: true;
+  hasMany: true;
+  next: ReadonlyArray<T>;
+}
+//#endregion
+//#region src/internal/types/lazy-evaluator.d.ts
+type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: ReadonlyArray<T>) => LazyResult<R>;
+//#endregion
+//#region src/curry.d.ts
+/**
+ * Creates a function with `dataFirst` and `dataLast` signatures.
+ *
+ * `curry` is a dynamic function and it's not type safe. It should be wrapped by
+ * a function that have proper typings. Refer to the example below for correct
+ * usage.
+ *
+ * !IMPORTANT: functions that simply call `curry` and return the result (like
+ * almost all functions in this library) should return `unknown` themselves if
+ * an explicit return type is required. This is because we currently don't
+ * provide a generic return type that is built from the input function, and
+ * crafting one manually isn't worthwhile as we rely on function declaration
+ * overloading to combine the types for dataFirst and dataLast invocations!
+ *
+ * @param fn - The function to curry.
+ * @param args - The arguments.
+ * @param lazy - A lazy version of the function to curry.
+ * @signature P.curry(fn, args);
+ * @example
+ *    function _findIndex(array, fn) {
+ *      for (let i = 0; i < array.length; i++) {
+ *        if (fn(array[i])) {
+ *          return i;
+ *        }
+ *      }
+ *      return -1;
+ *    }
+ *
+ *    // data-first
+ *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;
+ *
+ *    // data-last
+ *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;
+ *
+ *    function findIndex(...args: unknown[]) {
+ *      return P.curry(_findIndex, args);
+ *    }
+ * @category Function
+ */
+declare function curry(fn: (...args: any) => unknown, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+//#endregion
+export { curry };
+//# sourceMappingURL=curry-gLBYaLmk.d.cts.map

package/dist/curry-gLBYaLmk.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-gLBYaLmk.d.cts","names":[],"sources":["../src/internal/types/lazy-result.ts","../src/internal/types/lazy-evaluator.ts","../src/curry.ts"],"sourcesContent":[],"mappings":";KAAY,gBAAgB,YAAY,SAAS,KAAK,SAAS;AAA/D,UAEU,SAAA,CAFY;EAAA,IAAA,EAAA,OAAA;SAAM,EAAA,KAAA;SAAqB,CAAA,EAAA,KAAA,GAAA,SAAA;MAAT,CAAA,EAAA,SAAA;;UAS9B,QAT4C,CAAA,CAAA,CAAA,CAAA;EAAQ,IAAA,EAAA,OAAA;EAEpD,OAAA,EAAA,IAAS;EAOT,OAAA,CAAA,EAAA,KAAQ,GAAA,SAIT;EAGC,IAAA,EAHF,CAGE;;UAAA,QAIY,CAAA,CAAA,CAAA,CAAA;MAAd,EAAA,OAAA;EAAa,OAAA,EAAA,IAAA;;QAAb,cAAc;;;;AApBV,KCEA,aDFU,CAAA,IAAA,OAAA,EAAA,ICEqB,CDFrB,CAAA,GAAA,CAAA,IAAA,ECGd,CDHc,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,ECKd,aDLc,CCKA,CDLA,CAAA,EAAA,GCMjB,UDNiB,CCMN,CDNM,CAAA;;;AAAtB;;;;;;;;AAAkE;AAE/C;AAWV;;;;;;;;ACXT;;;;;;;;;;;;AC0CA;;;;;;;;;iBAAgB,KAAA,sCAER,iDACmB"}

package/dist/curry-order-rules-1zjlAgqa.d.cts

@@ -0,0 +1,48 @@
+//#region src/internal/curry-order-rules.d.ts
+declare const COMPARATORS: {
+  readonly asc: <T>(x: T, y: T) => boolean;
+  readonly desc: <T>(x: T, y: T) => boolean;
+};
+/**
+ * An order rule defines a projection/extractor that returns a comparable from
+ * the data being compared. It would be run on each item being compared, and a
+ * comparator would then be used on the results to determine the order.
+ *
+ * There are 2 forms of the order rule, a simple one which only provides the
+ * projection function and assumes ordering is ascending, and a 2-tuple where
+ * the first element is the projection function and the second is the direction;
+ * this allows changing the direction without defining a more complex projection
+ * to simply negate the value (e.g. `(x) => -x`).
+ *
+ * We rely on the javascript implementation of `<` and `>` for comparison, which
+ * will attempt to transform both operands into a primitive comparable value via
+ * the built in `valueOf` function (and then `toString`). It's up to the caller
+ * to make sure that the projection is returning a value that makes sense for
+ * this logic.
+ *
+ * It's important to note that there is no built-in caching/memoization of
+ * projection function and therefore no guarantee that it would only be called
+ * once.
+ */
+type OrderRule<T> = Projection<T> | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];
+type Projection<T> = (x: T) => Comparable;
+type Comparable = ComparablePrimitive | {
+  [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive;
+} | {
+  toString: () => string;
+} | {
+  valueOf: () => ComparablePrimitive;
+};
+type ComparablePrimitive = bigint | boolean | number | string;
+/**
+ * Allows functions that want to handle a variadic number of order rules a
+ * a simplified API that hides most of the implementation details. The only
+ * thing users of this function need to do is provide a function that would take
+ * the data, and a compare function that can be used to determine the order
+ * between the items of the array.
+ * This functions takes care of the rest; it will parse rules, built the
+ * comparer, and manage the currying of the input arguments.
+ */
+//#endregion
+export { OrderRule };
+//# sourceMappingURL=curry-order-rules-1zjlAgqa.d.cts.map

package/dist/curry-order-rules-1zjlAgqa.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-order-rules-1zjlAgqa.d.cts","names":[],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":[],"mappings":";AAAgE,cAM1D,WAGI,EAAA;EAAA,SAAA,GAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAFI,CAEJ,EAAA,CAAA,EAFU,CAEV,EAAA,GAAA,OAAA;WAFI,IAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EACC,CADD,EAAA,CAAA,EACO,CADP,EAAA,GAAA,OAAA;;;;;AAyBd;;;;;;;;AAEgF;;;;;AAEvC;;;;;AASlB,KAbX,SAaW,CAAA,CAAA,CAAA,GAZjB,UAYiB,CAZN,CAYM,CAAA,GAAA,SAAA,CAAA,UAAA,EAXK,UAWL,CAXgB,CAWhB,CAAA,EAAA,SAAA,EAAA,MAAA,OAX4C,WAW5C,CAAA;KATlB,UASqC,CAAA,CAAA,CAAA,GAAA,CAAA,CAAA,EATjB,CASiB,EAAA,GATX,UASW;AAAA,KAJrC,UAAA,GACC,mBAOkB,GAAA;GANf,MAAA,CAAO,WAAA,qBAAgC;;;;iBAEzB;;KAIlB,mBAAA"}

package/dist/curry-order-rules-BuA7D1F4.js

@@ -0,0 +1,2 @@
+const e={asc:(e,t)=>e>t,desc:(e,t)=>e<t};function t(e,t){let[n,...a]=t;if(!i(n))return e(n,r(...a));let o=r(n,...a);return t=>e(t,o)}function n(e,[n,r,...a]){let o,s;return i(r)?(o=n,s=[r,...a]):(o=r,s=[n,...a]),t((...t)=>e(...t,o),s)}function r(t,n,...i){let a=typeof t==`function`?t:t[0],o=typeof t==`function`?`asc`:t[1],{[o]:s}=e,c=n===void 0?void 0:r(n,...i);return(e,t)=>{let n=a(e),r=a(t);return s(n,r)?1:s(r,n)?-1:c?.(e,t)??0}}function i(t){if(a(t))return!0;if(typeof t!=`object`||!Array.isArray(t))return!1;let[n,r,...i]=t;return a(n)&&typeof r==`string`&&r in e&&i.length===0}function a(e){return typeof e==`function`&&e.length===1}export{t as curryOrderRules,n as curryOrderRulesWithArgument};
+//# sourceMappingURL=curry-order-rules-BuA7D1F4.js.map

package/dist/curry-order-rules-BuA7D1F4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-order-rules-BuA7D1F4.js","names":["arg: unknown","argRemoved: ReadonlyArray<unknown>"],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":["import type { CompareFunction } from './types/compare-function';\nimport type { NonEmptyArray } from './types/non-empty-array';\n\n// We define the comparators in a global const so that they are only\n// instantiated once, and so we can couple a label (string) for them that could\n// be used in runtime to refer to them (e.g. \"asc\", \"desc\").\nconst COMPARATORS = {\n  asc: <T>(x: T, y: T) => x > y,\n  desc: <T>(x: T, y: T) => x < y,\n} as const;\n\n/**\n * An order rule defines a projection/extractor that returns a comparable from\n * the data being compared. It would be run on each item being compared, and a\n * comparator would then be used on the results to determine the order.\n *\n * There are 2 forms of the order rule, a simple one which only provides the\n * projection function and assumes ordering is ascending, and a 2-tuple where\n * the first element is the projection function and the second is the direction;\n * this allows changing the direction without defining a more complex projection\n * to simply negate the value (e.g. `(x) => -x`).\n *\n * We rely on the javascript implementation of `<` and `>` for comparison, which\n * will attempt to transform both operands into a primitive comparable value via\n * the built in `valueOf` function (and then `toString`). It's up to the caller\n * to make sure that the projection is returning a value that makes sense for\n * this logic.\n *\n * It's important to note that there is no built-in caching/memoization of\n * projection function and therefore no guarantee that it would only be called\n * once.\n */\nexport type OrderRule<T>\n  = | Projection<T>\n    | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];\n\ntype Projection<T> = (x: T) => Comparable;\n\n// We define the Comparable based on how JS coerces values into primitives when\n// used with the `<` and `>` operators.\n// @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#type_coercion\ntype Comparable\n  = | ComparablePrimitive\n    | { [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive }\n    | { toString: () => string }\n    | { valueOf: () => ComparablePrimitive };\n\n//  Notice that `boolean` is special in that it is coerced as a number (0 for\n// `false`, 1 for `true`) implicitly.\ntype ComparablePrimitive = bigint | boolean | number | string;\n\n/**\n * Allows functions that want to handle a variadic number of order rules a\n * a simplified API that hides most of the implementation details. The only\n * thing users of this function need to do is provide a function that would take\n * the data, and a compare function that can be used to determine the order\n * between the items of the array.\n * This functions takes care of the rest; it will parse rules, built the\n * comparer, and manage the currying of the input arguments.\n */\nexport function curryOrderRules<T>(\n  func: (data: ReadonlyArray<T>, compareFn: CompareFunction<T>) => unknown,\n  inputArgs: ReadonlyArray<unknown>,\n): unknown {\n  // We rely on casting blindly here, but we rely on casting blindly everywhere\n  // else when we call curry so it's fine...\n  const [dataOrRule, ...rules] = inputArgs as\n    | [\n        data: OrderRule<T> | ReadonlyArray<T>,\n        ...rules: Readonly<NonEmptyArray<OrderRule<T>>>,\n    ]\n    | Readonly<NonEmptyArray<OrderRule<T>>>;\n\n  if (!isOrderRule<T>(dataOrRule)) {\n    // dataFirst!\n\n    // @ts-expect-error [ts2556]: Typescript is failing to infer the type of rules\n    // correctly here after the type refinement above, rules should be non-empty\n    // when we get here.\n    const compareFn = orderRuleComparer(...rules);\n    return func(dataOrRule, compareFn);\n  }\n\n  // dataLast!\n\n  // Important: initialize the comparer outside of the returned function so it\n  // it's constructed and shared everywhere (it's stateless so should be safe\n  // if used multiple times).\n  const compareFn = orderRuleComparer(dataOrRule, ...rules);\n  return (data: ReadonlyArray<T>) => func(data, compareFn);\n}\n\n/**\n * Some functions need an extra number argument, this helps facilitate that.\n */\nexport function curryOrderRulesWithArgument(\n  func: <T>(\n    data: ReadonlyArray<T>,\n    compareFn: CompareFunction<T>,\n    // eslint-disable-next-line ts/no-explicit-any -- Function inference in typescript relies on `any` to work, it doesn't work with `unknown`\n    arg: any,\n  ) => unknown,\n  [first, second, ...rest]: ReadonlyArray<unknown>,\n): unknown {\n  // We need to pull the `n` argument out to make it work with curryOrderRules.\n  let arg: unknown;\n  let argRemoved: ReadonlyArray<unknown>;\n  if (isOrderRule(second)) {\n    // dataLast!\n    arg = first;\n    argRemoved = [second, ...rest];\n  } else {\n    // dataFirst!\n    arg = second;\n    argRemoved = [first, ...rest];\n  }\n\n  return curryOrderRules((...args) => func(...args, arg), argRemoved);\n}\n\nfunction orderRuleComparer<T>(\n  primaryRule: OrderRule<T>,\n  secondaryRule?: OrderRule<T>,\n  ...otherRules: ReadonlyArray<OrderRule<T>>\n): (a: T, b: T) => number {\n  const projector\n    = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];\n\n  const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];\n  const { [direction]: comparator } = COMPARATORS;\n\n  const nextComparer\n    = secondaryRule === undefined\n      ? undefined\n      : orderRuleComparer(secondaryRule, ...otherRules);\n\n  return (a, b) => {\n    const projectedA = projector(a);\n    const projectedB = projector(b);\n\n    if (comparator(projectedA, projectedB)) {\n      return 1;\n    }\n\n    if (comparator(projectedB, projectedA)) {\n      return -1;\n    }\n\n    // The elements are equal base on the current comparator and projection. So\n    // we need to check the elements using the next comparer, if one exists,\n    // otherwise we consider them as true equal (returning 0).\n    return nextComparer?.(a, b) ?? 0;\n  };\n}\n\nfunction isOrderRule<T>(x: unknown): x is OrderRule<T> {\n  if (isProjection(x)) {\n    return true;\n  }\n\n  if (typeof x !== 'object' || !Array.isArray(x)) {\n    return false;\n  }\n\n  const [maybeProjection, maybeDirection, ...rest]\n    = x as ReadonlyArray<unknown>;\n\n  return (\n    isProjection(maybeProjection)\n    && typeof maybeDirection === 'string'\n    && maybeDirection in COMPARATORS\n    // Has to be a 2-tuple\n    && rest.length === 0\n  );\n}\n\nfunction isProjection<T>(x: unknown): x is Projection<T> {\n  return typeof x === 'function' && x.length === 1;\n}\n"],"mappings":"AAMA,MAAM,EAAc,CAClB,KAAS,EAAM,IAAS,EAAI,EAC5B,MAAU,EAAM,IAAS,EAAI,EAC9B,CAmDD,SAAgB,EACd,EACA,EACS,CAGT,GAAM,CAAC,EAAY,GAAG,GAAS,EAO/B,GAAI,CAAC,EAAe,EAAW,CAO7B,OAAO,EAAK,EADM,EAAkB,GAAG,EAAM,CACX,CAQpC,IAAM,EAAY,EAAkB,EAAY,GAAG,EAAM,CACzD,MAAQ,IAA2B,EAAK,EAAM,EAAU,CAM1D,SAAgB,EACd,EAMA,CAAC,EAAO,EAAQ,GAAG,GACV,CAET,IAAIA,EACAC,EAWJ,OAVI,EAAY,EAAO,EAErB,EAAM,EACN,EAAa,CAAC,EAAQ,GAAG,EAAK,GAG9B,EAAM,EACN,EAAa,CAAC,EAAO,GAAG,EAAK,EAGxB,GAAiB,GAAG,IAAS,EAAK,GAAG,EAAM,EAAI,CAAE,EAAW,CAGrE,SAAS,EACP,EACA,EACA,GAAG,EACqB,CACxB,IAAM,EACF,OAAO,GAAgB,WAAa,EAAc,EAAY,GAE5D,EAAY,OAAO,GAAgB,WAAa,MAAQ,EAAY,GACpE,EAAG,GAAY,GAAe,EAE9B,EACF,IAAkB,IAAA,GAChB,IAAA,GACA,EAAkB,EAAe,GAAG,EAAW,CAErD,OAAQ,EAAG,IAAM,CACf,IAAM,EAAa,EAAU,EAAE,CACzB,EAAa,EAAU,EAAE,CAa/B,OAXI,EAAW,EAAY,EAAW,CAC7B,EAGL,EAAW,EAAY,EAAW,CAC7B,GAMF,IAAe,EAAG,EAAE,EAAI,GAInC,SAAS,EAAe,EAA+B,CACrD,GAAI,EAAa,EAAE,CACjB,MAAO,GAGT,GAAI,OAAO,GAAM,UAAY,CAAC,MAAM,QAAQ,EAAE,CAC5C,MAAO,GAGT,GAAM,CAAC,EAAiB,EAAgB,GAAG,GACvC,EAEJ,OACE,EAAa,EAAgB,EAC1B,OAAO,GAAmB,UAC1B,KAAkB,GAElB,EAAK,SAAW,EAIvB,SAAS,EAAgB,EAAgC,CACvD,OAAO,OAAO,GAAM,YAAc,EAAE,SAAW"}

package/dist/curry-order-rules-Cthu8rj4.d.ts

@@ -0,0 +1,48 @@
+//#region src/internal/curry-order-rules.d.ts
+declare const COMPARATORS: {
+  readonly asc: <T>(x: T, y: T) => boolean;
+  readonly desc: <T>(x: T, y: T) => boolean;
+};
+/**
+ * An order rule defines a projection/extractor that returns a comparable from
+ * the data being compared. It would be run on each item being compared, and a
+ * comparator would then be used on the results to determine the order.
+ *
+ * There are 2 forms of the order rule, a simple one which only provides the
+ * projection function and assumes ordering is ascending, and a 2-tuple where
+ * the first element is the projection function and the second is the direction;
+ * this allows changing the direction without defining a more complex projection
+ * to simply negate the value (e.g. `(x) => -x`).
+ *
+ * We rely on the javascript implementation of `<` and `>` for comparison, which
+ * will attempt to transform both operands into a primitive comparable value via
+ * the built in `valueOf` function (and then `toString`). It's up to the caller
+ * to make sure that the projection is returning a value that makes sense for
+ * this logic.
+ *
+ * It's important to note that there is no built-in caching/memoization of
+ * projection function and therefore no guarantee that it would only be called
+ * once.
+ */
+type OrderRule<T> = Projection<T> | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];
+type Projection<T> = (x: T) => Comparable;
+type Comparable = ComparablePrimitive | {
+  [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive;
+} | {
+  toString: () => string;
+} | {
+  valueOf: () => ComparablePrimitive;
+};
+type ComparablePrimitive = bigint | boolean | number | string;
+/**
+ * Allows functions that want to handle a variadic number of order rules a
+ * a simplified API that hides most of the implementation details. The only
+ * thing users of this function need to do is provide a function that would take
+ * the data, and a compare function that can be used to determine the order
+ * between the items of the array.
+ * This functions takes care of the rest; it will parse rules, built the
+ * comparer, and manage the currying of the input arguments.
+ */
+//#endregion
+export { OrderRule };
+//# sourceMappingURL=curry-order-rules-Cthu8rj4.d.ts.map

package/dist/curry-order-rules-Cthu8rj4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-order-rules-Cthu8rj4.d.ts","names":[],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":[],"mappings":";AAAgE,cAM1D,WAGI,EAAA;EAAA,SAAA,GAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAFI,CAEJ,EAAA,CAAA,EAFU,CAEV,EAAA,GAAA,OAAA;WAFI,IAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EACC,CADD,EAAA,CAAA,EACO,CADP,EAAA,GAAA,OAAA;;;;;AAyBd;;;;;;;;AAEgF;;;;;AAEvC;;;;;AASlB,KAbX,SAaW,CAAA,CAAA,CAAA,GAZjB,UAYiB,CAZN,CAYM,CAAA,GAAA,SAAA,CAAA,UAAA,EAXK,UAWL,CAXgB,CAWhB,CAAA,EAAA,SAAA,EAAA,MAAA,OAX4C,WAW5C,CAAA;KATlB,UASqC,CAAA,CAAA,CAAA,GAAA,CAAA,CAAA,EATjB,CASiB,EAAA,GATX,UASW;AAAA,KAJrC,UAAA,GACC,mBAOkB,GAAA;GANf,MAAA,CAAO,WAAA,qBAAgC;;;;iBAEzB;;KAIlB,mBAAA"}

package/dist/curry-order-rules-UcuuWkKd.cjs

@@ -0,0 +1 @@
+const e={asc:(e,t)=>e>t,desc:(e,t)=>e<t};function t(e,t){let[n,...a]=t;if(!i(n))return e(n,r(...a));let o=r(n,...a);return t=>e(t,o)}function n(e,[n,r,...a]){let o,s;return i(r)?(o=n,s=[r,...a]):(o=r,s=[n,...a]),t((...t)=>e(...t,o),s)}function r(t,n,...i){let a=typeof t==`function`?t:t[0],o=typeof t==`function`?`asc`:t[1],{[o]:s}=e,c=n===void 0?void 0:r(n,...i);return(e,t)=>{let n=a(e),r=a(t);return s(n,r)?1:s(r,n)?-1:c?.(e,t)??0}}function i(t){if(a(t))return!0;if(typeof t!=`object`||!Array.isArray(t))return!1;let[n,r,...i]=t;return a(n)&&typeof r==`string`&&r in e&&i.length===0}function a(e){return typeof e==`function`&&e.length===1}Object.defineProperty(exports,`curryOrderRules`,{enumerable:!0,get:function(){return t}}),Object.defineProperty(exports,`curryOrderRulesWithArgument`,{enumerable:!0,get:function(){return n}});

package/dist/curry.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkXR72I63Wcjs = require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.curry = _chunkXR72I63Wcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`);const e=require(`./curry-BPVIsvo3.cjs`);exports.curry=e.curry;

package/dist/curry.d.cts

@@ -1,64 +1,2 @@
-type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
-interface LazyEmpty {
-    done: boolean;
-    hasNext: false;
-    hasMany?: false | undefined;
-    next?: undefined;
-}
-interface LazyNext<T> {
-    done: boolean;
-    hasNext: true;
-    hasMany?: false | undefined;
-    next: T;
-}
-interface LazyMany<T> {
-    done: boolean;
-    hasNext: true;
-    hasMany: true;
-    next: ReadonlyArray<T>;
-}
-
-type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: ReadonlyArray<T>) => LazyResult<R>;
-
-/**
- * Creates a function with `dataFirst` and `dataLast` signatures.
- *
- * `curry` is a dynamic function and it's not type safe. It should be wrapped by
- * a function that have proper typings. Refer to the example below for correct
- * usage.
- *
- * !IMPORTANT: functions that simply call `curry` and return the result (like
- * almost all functions in this library) should return `unknown` themselves if
- * an explicit return type is required. This is because we currently don't
- * provide a generic return type that is built from the input function, and
- * crafting one manually isn't worthwhile as we rely on function declaration
- * overloading to combine the types for dataFirst and dataLast invocations!
- *
- * @param fn - The function to curry.
- * @param args - The arguments.
- * @param lazy - A lazy version of the function to curry.
- * @signature P.curry(fn, args);
- * @example
- *    function _findIndex(array, fn) {
- *      for (let i = 0; i < array.length; i++) {
- *        if (fn(array[i])) {
- *          return i;
- *        }
- *      }
- *      return -1;
- *    }
- *
- *    // data-first
- *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;
- *
- *    // data-last
- *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;
- *
- *    function findIndex(...args: unknown[]) {
- *      return P.curry(_findIndex, args);
- *    }
- * @category Function
- */
-declare function curry(fn: (...args: any) => unknown, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
-
-export { curry };
+import { curry } from "./curry-gLBYaLmk.cjs";
+export { curry };