@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/mean-by.d.cts

@@ -1,2 +1,35 @@
-import { meanBy } from "./mean-by-BnIWNvSM.cjs";
-export { meanBy };
+//#region src/mean-by.d.ts
+/**
+ * Returns the mean of the elements of an array using the provided predicate.
+ *
+ * @param fn - Predicate function.
+ * @signature
+ *   P.meanBy(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      P.meanBy(x => x.a)
+ *    ) // 3
+ * @dataLast
+ * @category Array
+ */
+declare function meanBy<T>(fn: (value: T, index: number, data: ReadonlyArray<T>) => number): (items: ReadonlyArray<T>) => number;
+/**
+ * Returns the mean of the elements of an array using the provided predicate.
+ *
+ * @param items - The array.
+ * @param fn - Predicate function.
+ * @signature
+ *   P.meanBy(array, fn)
+ * @example
+ *    P.meanBy(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      x => x.a
+ *    ) // 3
+ * @dataFirst
+ * @category Array
+ */
+declare function meanBy<T>(items: ReadonlyArray<T>, fn: (value: T, index: number, data: ReadonlyArray<T>) => number): number;
+//#endregion
+export { meanBy };
+//# sourceMappingURL=mean-by.d.cts.map

package/dist/mean-by.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mean-by.d.cts","names":[],"sources":["../src/mean-by.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;;AAoBA;;;;;;AAEmD,iBAtBnC,MAsBmC,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,KAAA,EArBrC,CAqBqC,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EArBb,aAqBa,CArBC,CAqBD,CAAA,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EApBxC,aAoBwC,CApB1B,CAoB0B,CAAA,EAAA,GAAA,MAAA;;;;;;;;;;;;;;;;iBAFnC,iBACP,cAAc,gBACT,wBAAwB,cAAc"}

package/dist/mean-by.d.ts

@@ -1,2 +1,35 @@
-import { meanBy } from "./mean-by-DMCyv3tB.js";
-export { meanBy };
+//#region src/mean-by.d.ts
+/**
+ * Returns the mean of the elements of an array using the provided predicate.
+ *
+ * @param fn - Predicate function.
+ * @signature
+ *   P.meanBy(fn)(array)
+ * @example
+ *    P.pipe(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      P.meanBy(x => x.a)
+ *    ) // 3
+ * @dataLast
+ * @category Array
+ */
+declare function meanBy<T>(fn: (value: T, index: number, data: ReadonlyArray<T>) => number): (items: ReadonlyArray<T>) => number;
+/**
+ * Returns the mean of the elements of an array using the provided predicate.
+ *
+ * @param items - The array.
+ * @param fn - Predicate function.
+ * @signature
+ *   P.meanBy(array, fn)
+ * @example
+ *    P.meanBy(
+ *      [{a: 5}, {a: 1}, {a: 3}],
+ *      x => x.a
+ *    ) // 3
+ * @dataFirst
+ * @category Array
+ */
+declare function meanBy<T>(items: ReadonlyArray<T>, fn: (value: T, index: number, data: ReadonlyArray<T>) => number): number;
+//#endregion
+export { meanBy };
+//# sourceMappingURL=mean-by.d.ts.map

package/dist/mean-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mean-by.d.ts","names":[],"sources":["../src/mean-by.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;;AAoBA;;;;;;AAEmD,iBAtBnC,MAsBmC,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,KAAA,EArBrC,CAqBqC,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EArBb,aAqBa,CArBC,CAqBD,CAAA,EAAA,GAAA,MAAA,CAAA,EAAA,CAAA,KAAA,EApBxC,aAoBwC,CApB1B,CAoB0B,CAAA,EAAA,GAAA,MAAA;;;;;;;;;;;;;;;;iBAFnC,iBACP,cAAc,gBACT,wBAAwB,cAAc"}

package/dist/mean-by.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{meanBy as e}from"./mean-by-XExXfgtG.js";export{e as meanBy};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){if(e.length===0)return NaN;let n=0;for(let[r,i]of e.entries())n+=t(i,r,e);return n/e.length}export{t as meanBy};
+//# sourceMappingURL=mean-by.js.map

package/dist/mean-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mean-by.js","names":[],"sources":["../src/mean-by.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Returns the mean of the elements of an array using the provided predicate.\n *\n * @param fn - Predicate function.\n * @signature\n *   P.meanBy(fn)(array)\n * @example\n *    P.pipe(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      P.meanBy(x => x.a)\n *    ) // 3\n * @dataLast\n * @category Array\n */\n\nexport function meanBy<T>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): (items: ReadonlyArray<T>) => number;\n\n/**\n * Returns the mean of the elements of an array using the provided predicate.\n *\n * @param items - The array.\n * @param fn - Predicate function.\n * @signature\n *   P.meanBy(array, fn)\n * @example\n *    P.meanBy(\n *      [{a: 5}, {a: 1}, {a: 3}],\n *      x => x.a\n *    ) // 3\n * @dataFirst\n * @category Array\n */\n\nexport function meanBy<T>(\n  items: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): number;\n\nexport function meanBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(meanByImplementation, args);\n}\n\nfunction meanByImplementation<T>(\n  array: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => number,\n): number {\n  if (array.length === 0) {\n    return Number.NaN;\n  }\n\n  let sum = 0;\n\n  for (const [index, item] of array.entries()) {\n    sum += fn(item, index, array);\n  }\n\n  return sum / array.length;\n};\n"],"mappings":"wCA0CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACQ,CACR,GAAI,EAAM,SAAW,EACnB,MAAO,KAGT,IAAI,EAAM,EAEV,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,GAAO,EAAG,EAAM,EAAO,EAAM,CAG/B,OAAO,EAAM,EAAM"}

package/dist/merge-all-CISawx-J.d.cts

@@ -0,0 +1,42 @@
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+import { t as NonEmptyArray } from "./non-empty-array-NDjbHRjk.cjs";
+import { t as TupleParts } from "./tuple-parts-CzQQupgi.cjs";
+import { EmptyObject, KeysOfUnion, Merge, SharedUnionFields, Simplify } from "type-fest";
+
+//#region src/internal/types/disjoint-union-fields.d.ts
+/**
+ * Gets the set of keys that are not shared by all members of a union. This is the complement of the keys of {@link SharedUnionFields}.
+ */
+type DisjointUnionFieldKeys<T extends object> = Exclude<KeysOfUnion<T>, keyof SharedUnionFields<T>>;
+/**
+ * Gets the set of fields that are not shared by all members of a union. This is the complement of {@link SharedUnionFields}.
+ */
+type DisjointUnionFields<T extends object> = { [K in DisjointUnionFieldKeys<T>]: T extends Partial<Record<K, unknown>> ? T[K] : never };
+//#endregion
+//#region src/merge-all.d.ts
+/**
+ * Merge a tuple of object types, where props from later objects override earlier props.
+ */
+type MergeTuple<T extends IterableContainer, Result = object> = T extends readonly [infer Head, ...infer Rest] ? MergeTuple<Rest, Merge<Result, Head>> : Result;
+type MergeUnion<T extends object> = Simplify<SharedUnionFields<T> & Partial<DisjointUnionFields<T>>>;
+type MergeAll<T extends IterableContainer<object>> = TupleParts<T> extends {
+  item: never;
+} ? T extends readonly [] ? EmptyObject : MergeTuple<T> : MergeUnion<T[number]> | EmptyObject;
+/**
+ * Merges a list of objects into a single object.
+ *
+ * @param objects - The array of objects.
+ * @returns A new object merged with all of the objects in the list. If the list is empty, an empty object is returned.
+ * @signature
+ *    P.mergeAll(objects)
+ * @example
+ *    P.mergeAll([{ a: 1, b: 1 }, { b: 2, c: 3 }, { d: 10 }]) // => { a: 1, b: 2, c: 3, d: 10 }
+ *    P.mergeAll([]) // => {}
+ * @dataFirst
+ * @category Array
+ */
+declare function mergeAll<T extends object>(objects: Readonly<NonEmptyArray<T>>): MergeUnion<T>;
+declare function mergeAll<T extends IterableContainer<object>>(objects: T): MergeAll<T>;
+//#endregion
+export { mergeAll as t };
+//# sourceMappingURL=merge-all-CISawx-J.d.cts.map

package/dist/merge-all-CISawx-J.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-all-CISawx-J.d.cts","names":[],"sources":["../src/internal/types/disjoint-union-fields.ts","../src/merge-all.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAKK,2CAA2C,QAC9C,YAAY,UACN,kBAAkB;;AAPsC;;AAM9D,KAOU,mBAPV,CAAA,UAAA,MAAA,CAAA,GAAA,QAQM,sBAPkB,CAOK,CAPL,CAAA,GAOU,CAPV,SAOoB,OAPpB,CAO4B,MAP5B,CAOmC,CAPnC,EAAA,OAAA,CAAA,CAAA,GAQpB,CARoB,CAQlB,CARkB,CAAA,GAAA,KAAA,EAAlB;;;;AAPwD;;KCc3D,UDRH,CAAA,UCSU,iBDTV,EAAA,SAAA,MAAA,CAAA,GCWE,CDXF,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GCYE,UDZF,CCYa,IDZb,ECYmB,KDZnB,CCYyB,MDZzB,ECYiC,IDZjC,CAAA,CAAA,GCaE,MDbF;KCsBG,UDrBqB,CAAA,UAAA,MAAA,CAAA,GCqBU,QDrBV,CCsBxB,iBDtBwB,CCsBN,CDtBM,CAAA,GCsBD,ODtBC,CCsBO,mBDtBP,CCsB2B,CDtB3B,CAAA,CAAA,CAAA;KCyBrB,QDzBG,CAAA,UCyBgB,iBDzBhB,CAAA,MAAA,CAAA,CAAA,GC2BJ,UD3BI,CC2BO,CD3BP,CAAA,SAAA;EAFwC,IAAA,EAAA,KAAA;CAAO,GC8BjD,CD9BiD,SAAA,SAAA,EAAA,GC+B/C,WD/B+C,GCgC/C,UDhC+C,CCgCpC,CDhCoC,CAAA,GCiCjD,UDjCiD,CCiCtC,CDjCsC,CAAA,MAAA,CAAA,CAAA,GCiCzB,WDjCyB;AAQvD;;;;;;;;;;;;;ACCK,iBAuCW,QAvCD,CAAA,UAAA,MAAA,CAAA,CAAA,OAAA,EAwCJ,QAxCI,CAwCK,aAxCL,CAwCmB,CAxCnB,CAAA,CAAA,CAAA,EAyCZ,UAzCY,CAyCD,CAzCC,CAAA;AACH,iBAyCI,QAzCJ,CAAA,UAyCuB,iBAzCvB,CAAA,MAAA,CAAA,CAAA,CAAA,OAAA,EA0CD,CA1CC,CAAA,EA2CT,QA3CS,CA2CA,CA3CA,CAAA"}

package/dist/merge-all-DJ6n7R1b.d.ts

@@ -0,0 +1,42 @@
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+import { t as NonEmptyArray } from "./non-empty-array-DHAKSw6t.js";
+import { t as TupleParts } from "./tuple-parts-BYI4o8Vk.js";
+import { EmptyObject, KeysOfUnion, Merge, SharedUnionFields, Simplify } from "type-fest";
+
+//#region src/internal/types/disjoint-union-fields.d.ts
+/**
+ * Gets the set of keys that are not shared by all members of a union. This is the complement of the keys of {@link SharedUnionFields}.
+ */
+type DisjointUnionFieldKeys<T extends object> = Exclude<KeysOfUnion<T>, keyof SharedUnionFields<T>>;
+/**
+ * Gets the set of fields that are not shared by all members of a union. This is the complement of {@link SharedUnionFields}.
+ */
+type DisjointUnionFields<T extends object> = { [K in DisjointUnionFieldKeys<T>]: T extends Partial<Record<K, unknown>> ? T[K] : never };
+//#endregion
+//#region src/merge-all.d.ts
+/**
+ * Merge a tuple of object types, where props from later objects override earlier props.
+ */
+type MergeTuple<T extends IterableContainer, Result = object> = T extends readonly [infer Head, ...infer Rest] ? MergeTuple<Rest, Merge<Result, Head>> : Result;
+type MergeUnion<T extends object> = Simplify<SharedUnionFields<T> & Partial<DisjointUnionFields<T>>>;
+type MergeAll<T extends IterableContainer<object>> = TupleParts<T> extends {
+  item: never;
+} ? T extends readonly [] ? EmptyObject : MergeTuple<T> : MergeUnion<T[number]> | EmptyObject;
+/**
+ * Merges a list of objects into a single object.
+ *
+ * @param objects - The array of objects.
+ * @returns A new object merged with all of the objects in the list. If the list is empty, an empty object is returned.
+ * @signature
+ *    P.mergeAll(objects)
+ * @example
+ *    P.mergeAll([{ a: 1, b: 1 }, { b: 2, c: 3 }, { d: 10 }]) // => { a: 1, b: 2, c: 3, d: 10 }
+ *    P.mergeAll([]) // => {}
+ * @dataFirst
+ * @category Array
+ */
+declare function mergeAll<T extends object>(objects: Readonly<NonEmptyArray<T>>): MergeUnion<T>;
+declare function mergeAll<T extends IterableContainer<object>>(objects: T): MergeAll<T>;
+//#endregion
+export { mergeAll as t };
+//# sourceMappingURL=merge-all-DJ6n7R1b.d.ts.map

package/dist/merge-all-DJ6n7R1b.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-all-DJ6n7R1b.d.ts","names":[],"sources":["../src/internal/types/disjoint-union-fields.ts","../src/merge-all.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAKK,2CAA2C,QAC9C,YAAY,UACN,kBAAkB;;AAPsC;;AAM9D,KAOU,mBAPV,CAAA,UAAA,MAAA,CAAA,GAAA,QAQM,sBAPkB,CAOK,CAPL,CAAA,GAOU,CAPV,SAOoB,OAPpB,CAO4B,MAP5B,CAOmC,CAPnC,EAAA,OAAA,CAAA,CAAA,GAQpB,CARoB,CAQlB,CARkB,CAAA,GAAA,KAAA,EAAlB;;;;AAPwD;;KCc3D,UDRH,CAAA,UCSU,iBDTV,EAAA,SAAA,MAAA,CAAA,GCWE,CDXF,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GCYE,UDZF,CCYa,IDZb,ECYmB,KDZnB,CCYyB,MDZzB,ECYiC,IDZjC,CAAA,CAAA,GCaE,MDbF;KCsBG,UDrBqB,CAAA,UAAA,MAAA,CAAA,GCqBU,QDrBV,CCsBxB,iBDtBwB,CCsBN,CDtBM,CAAA,GCsBD,ODtBC,CCsBO,mBDtBP,CCsB2B,CDtB3B,CAAA,CAAA,CAAA;KCyBrB,QDzBG,CAAA,UCyBgB,iBDzBhB,CAAA,MAAA,CAAA,CAAA,GC2BJ,UD3BI,CC2BO,CD3BP,CAAA,SAAA;EAFwC,IAAA,EAAA,KAAA;CAAO,GC8BjD,CD9BiD,SAAA,SAAA,EAAA,GC+B/C,WD/B+C,GCgC/C,UDhC+C,CCgCpC,CDhCoC,CAAA,GCiCjD,UDjCiD,CCiCtC,CDjCsC,CAAA,MAAA,CAAA,CAAA,GCiCzB,WDjCyB;AAQvD;;;;;;;;;;;;;ACCK,iBAuCW,QAvCD,CAAA,UAAA,MAAA,CAAA,CAAA,OAAA,EAwCJ,QAxCI,CAwCK,aAxCL,CAwCmB,CAxCnB,CAAA,CAAA,CAAA,EAyCZ,UAzCY,CAyCD,CAzCC,CAAA;AACH,iBAyCI,QAzCJ,CAAA,UAyCuB,iBAzCvB,CAAA,MAAA,CAAA,CAAA,CAAA,OAAA,EA0CD,CA1CC,CAAA,EA2CT,QA3CS,CA2CA,CA3CA,CAAA"}

package/dist/merge-all.cjs

@@ -1 +1 @@
-const e=require(`./merge-all-B8XyKhEY.cjs`);exports.mergeAll=e.mergeAll;
+function e(e){let t={};for(let n of e)t={...t,...n};return t}exports.mergeAll=e;

package/dist/merge-all.d.cts

@@ -1,6 +1,2 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import "./non-empty-array-D3ZRHApS.cjs";
-import "./perkakas-type-error-0tHtaPbi.cjs";
-import "./tuple-parts-BIyABPYv.cjs";
-import { mergeAll } from "./merge-all-DtHtd1Pc.cjs";
+import { t as mergeAll } from "./merge-all-CISawx-J.cjs";
 export { mergeAll };

package/dist/merge-all.d.ts

@@ -1,6 +1,2 @@
-import "./iterable-container-F9CDF7ym.js";
-import "./non-empty-array-BfTfvDYg.js";
-import "./perkakas-type-error-2yBU0Drj.js";
-import "./tuple-parts-Du2iVN8H.js";
-import { mergeAll } from "./merge-all-CxK7_hBZ.js";
+import { t as mergeAll } from "./merge-all-DJ6n7R1b.js";
 export { mergeAll };

package/dist/merge-all.js

@@ -1 +1,2 @@
-import{mergeAll as e}from"./merge-all-TsJlQ-YU.js";export{e as mergeAll};
+function e(e){let t={};for(let n of e)t={...t,...n};return t}export{e as mergeAll};
+//# sourceMappingURL=merge-all.js.map

package/dist/merge-all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-all.js","names":[],"sources":["../src/merge-all.ts"],"sourcesContent":["import type {\n  EmptyObject,\n  Merge,\n  SharedUnionFields,\n  Simplify,\n} from 'type-fest';\nimport type { DisjointUnionFields } from './internal/types/disjoint-union-fields';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport type { TupleParts } from './internal/types/tuple-parts';\n\n/**\n * Merge a tuple of object types, where props from later objects override earlier props.\n */\ntype MergeTuple<\n  T extends IterableContainer,\n  Result = object, // no-op for the first iteration in the successive merges, also infers object as type by default if an empty tuple is used\n> = T extends readonly [infer Head, ...infer Rest]\n  ? MergeTuple<Rest, Merge<Result, Head>>\n  : Result;\n\n// In the context of a heterogeneous array, the array may not have objects from every type of the union.\n// This means some fields may be missing in the final object, so we make them optional.\n// If there is a non-optional field shared among all members of the union, then we know that if the array is not empty, the field must be present and avoid becoming optional.\n// If the field is already optional, this doesn't really matter.\n// If the array is empty, we know that the loop won't run so we'll just get the empty object.\n// Since we don't know the order of the items in the array, when we merge common fields, we don't know what the final type for the field will be, but we do know that it is one of the many possible types that are available across the members of the union for that field.\n// We represent these possibilities by combining the field's different types across the union members into a union.\ntype MergeUnion<T extends object> = Simplify<\n  SharedUnionFields<T> & Partial<DisjointUnionFields<T>>\n>;\n\ntype MergeAll<T extends IterableContainer<object>>\n  // determine if it's a tuple or array\n  = TupleParts<T> extends { item: never }\n    ? T extends readonly []\n      ? EmptyObject\n      : MergeTuple<T>\n    : MergeUnion<T[number]> | EmptyObject;\n\n/**\n * Merges a list of objects into a single object.\n *\n * @param objects - The array of objects.\n * @returns A new object merged with all of the objects in the list. If the list is empty, an empty object is returned.\n * @signature\n *    P.mergeAll(objects)\n * @example\n *    P.mergeAll([{ a: 1, b: 1 }, { b: 2, c: 3 }, { d: 10 }]) // => { a: 1, b: 2, c: 3, d: 10 }\n *    P.mergeAll([]) // => {}\n * @dataFirst\n * @category Array\n */\nexport function mergeAll<T extends object>(\n  objects: Readonly<NonEmptyArray<T>>,\n): MergeUnion<T>;\nexport function mergeAll<T extends IterableContainer<object>>(\n  objects: T,\n): MergeAll<T>;\nexport function mergeAll(objects: ReadonlyArray<object>): object {\n  let out = {};\n\n  for (const item of objects) {\n    out = { ...out, ...item };\n  }\n\n  return out;\n}\n"],"mappings":"AA2DA,SAAgB,EAAS,EAAwC,CAC/D,IAAI,EAAM,EAAE,CAEZ,IAAK,IAAM,KAAQ,EACjB,EAAM,CAAE,GAAG,EAAK,GAAG,EAAM,CAG3B,OAAO"}

package/dist/merge-deep.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./is-plain-object-D0HZzwPq.cjs`);const e=require(`./merge-deep-_Ie14BHM.cjs`);exports.mergeDeep=e.mergeDeep;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./is-plain-object.cjs`);function n(...t){return e.t(r,t)}function r(e,n){let i={...e,...n};for(let a in n){if(!(a in e))continue;let{[a]:o}=e;if(!t.isPlainObject(o))continue;let{[a]:s}=n;t.isPlainObject(s)&&(i[a]=r(o,s))}return i}exports.mergeDeep=n;

package/dist/merge-deep.d.cts

@@ -1,2 +1,37 @@
-import { mergeDeep } from "./merge-deep-kkzayvS3.cjs";
-export { mergeDeep };
+import { MergeDeep } from "type-fest";
+
+//#region src/merge-deep.d.ts
+
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param destination - The object to merge into. In general, this object would have it's values overridden.
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns The merged object.
+ * @signature
+ *    P.mergeDeep(destination, source)
+ * @example
+ *    P.mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function mergeDeep<Destination extends object, Source extends object>(destination: Destination, source: Source): MergeDeep<Destination, Source>;
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns The merged object.
+ * @signature
+ *    P.mergeDeep(source)(destination)
+ * @example
+ *    P.pipe(
+ *      { foo: 'bar', x: 1 },
+ *      P.mergeDeep({ foo: 'baz', y: 2 }),
+ *    );  // => { foo: 'baz', x: 1, y: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function mergeDeep<Source extends object>(source: Source): <Destination extends object>(target: Destination) => MergeDeep<Destination, Source>;
+//#endregion
+export { mergeDeep };
+//# sourceMappingURL=merge-deep.d.cts.map

package/dist/merge-deep.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-deep.d.cts","names":[],"sources":["../src/merge-deep.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;;;;;;;AAmBA;;;;AAI4B,iBAvBZ,SAuBY,CAAA,oBAAA,MAAA,EAAA,eAAA,MAAA,CAAA,CAAA,WAAA,EAtBb,WAsBa,EAAA,MAAA,EAtBQ,MAsBR,CAAA,EArBzB,SAqByB,CArBf,WAqBe,EArBF,MAqBE,CAAA;;;;;;;;;;;;;;;;iBAJZ,yCACN,8CAEA,gBACL,UAAU,aAAa"}

package/dist/merge-deep.d.ts

@@ -1,2 +1,37 @@
-import { mergeDeep } from "./merge-deep-DAnh57IN.js";
-export { mergeDeep };
+import { MergeDeep } from "type-fest";
+
+//#region src/merge-deep.d.ts
+
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param destination - The object to merge into. In general, this object would have it's values overridden.
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns The merged object.
+ * @signature
+ *    P.mergeDeep(destination, source)
+ * @example
+ *    P.mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function mergeDeep<Destination extends object, Source extends object>(destination: Destination, source: Source): MergeDeep<Destination, Source>;
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns The merged object.
+ * @signature
+ *    P.mergeDeep(source)(destination)
+ * @example
+ *    P.pipe(
+ *      { foo: 'bar', x: 1 },
+ *      P.mergeDeep({ foo: 'baz', y: 2 }),
+ *    );  // => { foo: 'baz', x: 1, y: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function mergeDeep<Source extends object>(source: Source): <Destination extends object>(target: Destination) => MergeDeep<Destination, Source>;
+//#endregion
+export { mergeDeep };
+//# sourceMappingURL=merge-deep.d.ts.map

package/dist/merge-deep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-deep.d.ts","names":[],"sources":["../src/merge-deep.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;;;;;;;AAmBA;;;;AAI4B,iBAvBZ,SAuBY,CAAA,oBAAA,MAAA,EAAA,eAAA,MAAA,CAAA,CAAA,WAAA,EAtBb,WAsBa,EAAA,MAAA,EAtBQ,MAsBR,CAAA,EArBzB,SAqByB,CArBf,WAqBe,EArBF,MAqBE,CAAA;;;;;;;;;;;;;;;;iBAJZ,yCACN,8CAEA,gBACL,UAAU,aAAa"}

package/dist/merge-deep.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./is-plain-object-DOXTHODS.js";import{mergeDeep as e}from"./merge-deep-CB4Q8rQS.js";export{e as mergeDeep};
+import{t as e}from"./curry-NmniqyJ0.js";import{isPlainObject as t}from"./is-plain-object.js";function n(...t){return e(r,t)}function r(e,n){let i={...e,...n};for(let a in n){if(!(a in e))continue;let{[a]:o}=e;if(!t(o))continue;let{[a]:s}=n;t(s)&&(i[a]=r(o,s))}return i}export{n as mergeDeep};
+//# sourceMappingURL=merge-deep.js.map

package/dist/merge-deep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-deep.js","names":[],"sources":["../src/merge-deep.ts"],"sourcesContent":["import type { MergeDeep } from 'type-fest';\n\nimport { curry } from './curry';\nimport { isPlainObject } from './is-plain-object';\n\n/**\n * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).\n *\n * @param destination - The object to merge into. In general, this object would have it's values overridden.\n * @param source - The object to merge from. In general, shared keys would be taken from this object.\n * @returns The merged object.\n * @signature\n *    P.mergeDeep(destination, source)\n * @example\n *    P.mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mergeDeep<Destination extends object, Source extends object>(\n  destination: Destination, source: Source\n): MergeDeep<Destination, Source>;\n\n/**\n * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).\n *\n * @param source - The object to merge from. In general, shared keys would be taken from this object.\n * @returns The merged object.\n * @signature\n *    P.mergeDeep(source)(destination)\n * @example\n *    P.pipe(\n *      { foo: 'bar', x: 1 },\n *      P.mergeDeep({ foo: 'baz', y: 2 }),\n *    );  // => { foo: 'baz', x: 1, y: 2 }\n * @dataLast\n * @category Object\n */\nexport function mergeDeep<Source extends object>(\n  source: Source,\n): <Destination extends object>(\n  target: Destination,\n) => MergeDeep<Destination, Source>;\n\nexport function mergeDeep(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mergeDeepImplementation, args);\n}\n\nfunction mergeDeepImplementation<\n  Destination extends object,\n  Source extends object,\n>(destination: Destination, source: Source): MergeDeep<Destination, Source> {\n  // At this point the output is already merged, simply not deeply merged.\n  const output = { ...destination, ...source } as Record<\n    keyof Destination | keyof Source,\n    unknown\n  >;\n\n  // now just scan the output and look for values that should have been deep-merged\n  // eslint-disable-next-line no-restricted-syntax\n  for (const key in source) {\n    if (!(key in destination)) {\n      // They don't share this key.\n      continue;\n    }\n\n    const { [key]: destinationValue } = destination;\n    if (!isPlainObject(destinationValue)) {\n      // The value in destination is not a mergable object so the value from\n      // source (which was already copied in the shallow merge) would be used\n      // as-is.\n      continue;\n    }\n\n    const { [key]: sourceValue } = source;\n    if (!isPlainObject(sourceValue)) {\n      // The value in source is not a mergable object either, so it will\n      // override the object in destination.\n      continue;\n    }\n\n    // Both destination and source have a mergable object for this key, so we\n    // recursively merge them.\n    output[key] = mergeDeepImplementation(destinationValue, sourceValue);\n  }\n\n  // @ts-expect-error [ts2322] - We build the output object iteratively, I don't think it's possible to improve the types here so that typescript infers the right type.\n  return output;\n}\n"],"mappings":"6FA2CA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EAGP,EAA0B,EAAgD,CAE1E,IAAM,EAAS,CAAE,GAAG,EAAa,GAAG,EAAQ,CAO5C,IAAK,IAAM,KAAO,EAAQ,CACxB,GAAI,EAAE,KAAO,GAEX,SAGF,GAAM,EAAG,GAAM,GAAqB,EACpC,GAAI,CAAC,EAAc,EAAiB,CAIlC,SAGF,GAAM,EAAG,GAAM,GAAgB,EAC1B,EAAc,EAAY,GAQ/B,EAAO,GAAO,EAAwB,EAAkB,EAAY,EAItE,OAAO"}

package/dist/merge.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./merge-InCPrnnC.cjs`);exports.merge=e.merge;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return{...e,...t}}exports.merge=t;

package/dist/merge.d.cts

@@ -1,2 +1,57 @@
-import { merge } from "./merge-C7r_ADfR.cjs";
-export { merge };
+import { Merge } from "type-fest";
+
+//#region src/merge.d.ts
+
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param data - The destination object, serving as the basis for the merge.
+ * Properties from this object are included in the new object, but will be
+ * overwritten by properties from the source object with matching keys.
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    P.merge(data, source)
+ * @example
+ *    P.merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function merge<T, Source>(data: T, source: Source): Merge<T, Source>;
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    P.merge(source)(data)
+ * @example
+ *    P.pipe(
+ *      { x: 1, y: 2 },
+ *      P.merge({ y: 10, z: 2 }),
+ *    ); // => { x: 1, y: 10, z: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;
+//#endregion
+export { merge };
+//# sourceMappingURL=merge.d.cts.map

package/dist/merge.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.cts","names":[],"sources":["../src/merge.ts"],"sourcesContent":[],"mappings":";;;;;;AA4BA;;;;;;;AA0BA;;;;;;;;;;;;;;;iBA1BgB,uBAAuB,WAAW,SAAS,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BpD,sBAAsB,mBAAmB,MAAM,MAAM,GAAG"}

package/dist/merge.d.ts

@@ -1,2 +1,57 @@
-import { merge } from "./merge-D1COnjDQ.js";
-export { merge };
+import { Merge } from "type-fest";
+
+//#region src/merge.d.ts
+
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param data - The destination object, serving as the basis for the merge.
+ * Properties from this object are included in the new object, but will be
+ * overwritten by properties from the source object with matching keys.
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    P.merge(data, source)
+ * @example
+ *    P.merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function merge<T, Source>(data: T, source: Source): Merge<T, Source>;
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    P.merge(source)(data)
+ * @example
+ *    P.pipe(
+ *      { x: 1, y: 2 },
+ *      P.merge({ y: 10, z: 2 }),
+ *    ); // => { x: 1, y: 10, z: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;
+//#endregion
+export { merge };
+//# sourceMappingURL=merge.d.ts.map

package/dist/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","names":[],"sources":["../src/merge.ts"],"sourcesContent":[],"mappings":";;;;;;AA4BA;;;;;;;AA0BA;;;;;;;;;;;;;;;iBA1BgB,uBAAuB,WAAW,SAAS,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BpD,sBAAsB,mBAAmB,MAAM,MAAM,GAAG"}

package/dist/merge.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{merge as e}from"./merge-CbaUe6Ce.js";export{e as merge};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return{...e,...t}}export{t as merge};
+//# sourceMappingURL=merge.js.map

package/dist/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.js","names":[],"sources":["../src/merge.ts"],"sourcesContent":["import type { Merge } from 'type-fest';\n\nimport { curry } from './curry';\n\n/**\n * Merges two objects into one by combining their properties, effectively\n * creating a new object that incorporates elements from both. The merge\n * operation prioritizes the second object's properties, allowing them to\n * overwrite those from the first object with the same names.\n *\n * Equivalent to `{ ...data, ...source }`.\n *\n * @param data - The destination object, serving as the basis for the merge.\n * Properties from this object are included in the new object, but will be\n * overwritten by properties from the source object with matching keys.\n * @param source - The source object, whose properties will be included in the\n * new object. If properties in this object share keys with properties in the\n * destination object, the values from the source object will be used in the\n * new object.\n * @returns An object fully containing `source`, and any properties from `data`\n * that don't share a name with any property in `source`.\n * @signature\n *    P.merge(data, source)\n * @example\n *    P.merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }\n * @dataFirst\n * @category Object\n */\nexport function merge<T, Source>(data: T, source: Source): Merge<T, Source>;\n\n/**\n * Merges two objects into one by combining their properties, effectively\n * creating a new object that incorporates elements from both. The merge\n * operation prioritizes the second object's properties, allowing them to\n * overwrite those from the first object with the same names.\n *\n * Equivalent to `{ ...data, ...source }`.\n *\n * @param source - The source object, whose properties will be included in the\n * new object. If properties in this object share keys with properties in the\n * destination object, the values from the source object will be used in the\n * new object.\n * @returns An object fully containing `source`, and any properties from `data`\n * that don't share a name with any property in `source`.\n * @signature\n *    P.merge(source)(data)\n * @example\n *    P.pipe(\n *      { x: 1, y: 2 },\n *      P.merge({ y: 10, z: 2 }),\n *    ); // => { x: 1, y: 10, z: 2 }\n * @dataLast\n * @category Object\n */\nexport function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;\n\nexport function merge(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mergeImplementation, args);\n}\n\nfunction mergeImplementation<T, Source>(\n  data: T,\n  source: Source,\n): Merge<T, Source> {\n  return ({ ...data, ...source });\n}\n"],"mappings":"wCAwDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACkB,CAClB,MAAQ,CAAE,GAAG,EAAM,GAAG,EAAQ"}

package/dist/multiply.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./multiply-BT0u3zsh.cjs`);exports.multiply=e.multiply;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return e*t}exports.multiply=t;

package/dist/multiply.d.cts

@@ -1,2 +1,33 @@
-import { multiply } from "./multiply-Bo8j2rQi.cjs";
-export { multiply };
+//#region src/multiply.d.ts
+/**
+ * Multiplies two numbers.
+ *
+ * @param value - The number.
+ * @param multiplicand - The number to multiply the value by.
+ * @signature
+ *    P.multiply(value, multiplicand);
+ * @example
+ *    P.multiply(3, 4) // => 12
+ *    P.reduce([1, 2, 3, 4], P.multiply, 1) // => 24
+ * @dataFirst
+ * @category Number
+ */
+declare function multiply(value: bigint, multiplicand: bigint): bigint;
+declare function multiply(value: number, multiplicand: number): number;
+/**
+ * Multiplies two numbers.
+ *
+ * @param multiplicand - The number to multiply the value by.
+ * @signature
+ *    P.multiply(multiplicand)(value);
+ * @example
+ *    P.multiply(4)(3) // => 12
+ *    P.map([1, 2, 3, 4], P.multiply(2)) // => [2, 4, 6, 8]
+ * @dataLast
+ * @category Number
+ */
+declare function multiply(multiplicand: bigint): (value: bigint) => bigint;
+declare function multiply(multiplicand: number): (value: number) => number;
+//#endregion
+export { multiply };
+//# sourceMappingURL=multiply.d.cts.map

package/dist/multiply.d.cts.map

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

package/dist/multiply.d.ts

@@ -1,2 +1,33 @@
-import { multiply } from "./multiply-CBpoZQpr.js";
-export { multiply };
+//#region src/multiply.d.ts
+/**
+ * Multiplies two numbers.
+ *
+ * @param value - The number.
+ * @param multiplicand - The number to multiply the value by.
+ * @signature
+ *    P.multiply(value, multiplicand);
+ * @example
+ *    P.multiply(3, 4) // => 12
+ *    P.reduce([1, 2, 3, 4], P.multiply, 1) // => 24
+ * @dataFirst
+ * @category Number
+ */
+declare function multiply(value: bigint, multiplicand: bigint): bigint;
+declare function multiply(value: number, multiplicand: number): number;
+/**
+ * Multiplies two numbers.
+ *
+ * @param multiplicand - The number to multiply the value by.
+ * @signature
+ *    P.multiply(multiplicand)(value);
+ * @example
+ *    P.multiply(4)(3) // => 12
+ *    P.map([1, 2, 3, 4], P.multiply(2)) // => [2, 4, 6, 8]
+ * @dataLast
+ * @category Number
+ */
+declare function multiply(multiplicand: bigint): (value: bigint) => bigint;
+declare function multiply(multiplicand: number): (value: number) => number;
+//#endregion
+export { multiply };
+//# sourceMappingURL=multiply.d.ts.map

package/dist/multiply.d.ts.map

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

package/dist/multiply.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{multiply as e}from"./multiply-1PF_OS8E.js";export{e as multiply};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return e*t}export{t as multiply};
+//# sourceMappingURL=multiply.js.map

package/dist/multiply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiply.js","names":[],"sources":["../src/multiply.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Multiplies two numbers.\n *\n * @param value - The number.\n * @param multiplicand - The number to multiply the value by.\n * @signature\n *    P.multiply(value, multiplicand);\n * @example\n *    P.multiply(3, 4) // => 12\n *    P.reduce([1, 2, 3, 4], P.multiply, 1) // => 24\n * @dataFirst\n * @category Number\n */\nexport function multiply(value: bigint, multiplicand: bigint): bigint;\nexport function multiply(value: number, multiplicand: number): number;\n\n/**\n * Multiplies two numbers.\n *\n * @param multiplicand - The number to multiply the value by.\n * @signature\n *    P.multiply(multiplicand)(value);\n * @example\n *    P.multiply(4)(3) // => 12\n *    P.map([1, 2, 3, 4], P.multiply(2)) // => [2, 4, 6, 8]\n * @dataLast\n * @category Number\n */\nexport function multiply(multiplicand: bigint): (value: bigint) => bigint;\nexport function multiply(multiplicand: number): (value: number) => number;\n\nexport function multiply(...args: ReadonlyArray<unknown>): unknown {\n  return curry(multiplyImplementation, args);\n}\n\n// The implementation only uses `number` types, but that's just because it's\n// hard to tell typescript that both value and multiplicand would be of the same\n// type.\nfunction multiplyImplementation(value: number, multiplicand: number): number {\n  return value * multiplicand;\n}\n"],"mappings":"wCAiCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAM5C,SAAS,EAAuB,EAAe,EAA8B,CAC3E,OAAO,EAAQ"}

package/dist/n-tuple-BkMobYQ9.d.cts

@@ -0,0 +1,12 @@
+//#region src/internal/types/n-tuple.d.ts
+/**
+ * An array with *exactly* N elements in it.
+ *
+ * Only literal N values are supported. For very large N the type might result
+ * in a recurse depth error. For negative N the type would result in an infinite
+ * recursion. None of these have protections because this is an internal type!
+ */
+type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
+//#endregion
+export { NTuple as t };
+//# sourceMappingURL=n-tuple-BkMobYQ9.d.cts.map

package/dist/n-tuple-BkMobYQ9.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n-tuple-BkMobYQ9.d.cts","names":[],"sources":["../src/internal/types/n-tuple.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;AAIoD,KAJxC,MAIwC,CAAA,CAAA,EAAA,UAAA,MAAA,EAAA,eADnC,KACmC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAhD,MAAgD,CAAA,QAAA,CAAA,SAAvB,CAAuB,GAAnB,MAAmB,GAAV,MAAU,CAAH,CAAG,EAAA,CAAA,EAAA,CAAA,GAAO,MAAP,EAAe,CAAf,CAAA,CAAA"}

package/dist/n-tuple-zo5g_mSL.d.ts

@@ -0,0 +1,12 @@
+//#region src/internal/types/n-tuple.d.ts
+/**
+ * An array with *exactly* N elements in it.
+ *
+ * Only literal N values are supported. For very large N the type might result
+ * in a recurse depth error. For negative N the type would result in an infinite
+ * recursion. None of these have protections because this is an internal type!
+ */
+type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
+//#endregion
+export { NTuple as t };
+//# sourceMappingURL=n-tuple-zo5g_mSL.d.ts.map

package/dist/n-tuple-zo5g_mSL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n-tuple-zo5g_mSL.d.ts","names":[],"sources":["../src/internal/types/n-tuple.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;AAIoD,KAJxC,MAIwC,CAAA,CAAA,EAAA,UAAA,MAAA,EAAA,eADnC,KACmC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAhD,MAAgD,CAAA,QAAA,CAAA,SAAvB,CAAuB,GAAnB,MAAmB,GAAV,MAAU,CAAH,CAAG,EAAA,CAAA,EAAA,CAAA,GAAO,MAAP,EAAe,CAAf,CAAA,CAAA"}