@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/merge-CXnHl0ti.d.cts

@@ -1,57 +0,0 @@
-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-CXnHl0ti.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"merge-CXnHl0ti.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-DM3LuCr8.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){return{...e,...t}}export{t as merge};
-//# sourceMappingURL=merge-DM3LuCr8.js.map

package/dist/merge-DM3LuCr8.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-DM3LuCr8.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":"4CAwDA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACkB,CAClB,MAAQ,CAAE,GAAG,EAAM,GAAG,EAAQ"}

package/dist/merge-EO0Q1QPA.d.ts

@@ -1,57 +0,0 @@
-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-EO0Q1QPA.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"merge-EO0Q1QPA.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-all-BbdTIlUo.js

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

package/dist/merge-all-BbdTIlUo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-all-BbdTIlUo.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-all-DA-xZzpl.d.ts

@@ -1,42 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { NonEmptyArray } from "./non-empty-array-D3HWDPMt.js";
-import { TupleParts } from "./tuple-parts-BxpZLJ7r.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 };
-//# sourceMappingURL=merge-all-DA-xZzpl.d.ts.map

package/dist/merge-all-DA-xZzpl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-all-DA-xZzpl.d.ts","names":[],"sources":["../src/internal/types/disjoint-union-fields.ts","../src/merge-all.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAKK,2CAA2C,QAC9C,YAAY,UACN,kBAAkB;;AAPsC;;AAMlD,KAOF,mBAPE,CAAA,UAAA,MAAA,CAAA,GAAA,QAQN,sBARN,CAQ6B,CAR7B,CAAA,GAQkC,CARlC,SAQ4C,OAR5C,CAQoD,MARpD,CAQ2D,CAR3D,EAAA,OAAA,CAAA,CAAA,GASI,CATJ,CASM,CATN,CAAA,GAAA,KAAA;;;;AAN8D;;KCc3D,UDRS,CAAA,UCSF,iBDTE,EAAA,SAAA,MAAA,CAAA,GCWV,CDXU,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GCYV,UDZU,CCYC,IDZD,ECYO,KDZP,CCYa,MDZb,ECYqB,IDZrB,CAAA,CAAA,GCaV,MDbU;KCsBT,UDtBH,CAAA,UAAA,MAAA,CAAA,GCsBkC,QDtBlC,CCuBA,iBDvBA,CCuBkB,CDvBlB,CAAA,GCuBuB,ODvBvB,CCuB+B,mBDvB/B,CCuBmD,CDvBnD,CAAA,CAAA,CAAA;KC0BG,QDzBqB,CAAA,UCyBF,iBDzBE,CAAA,MAAA,CAAA,CAAA,GC2BtB,UD3BsB,CC2BX,CD3BW,CAAA,SAAA;MAAlB,EAAA,KAAA;IC4BF,UD9B0C,SAAA,EAAA,GC+BxC,WD/BwC,GCgCxC,UDhCwC,CCgC7B,CDhC6B,CAAA,GCiC1C,UDjC0C,CCiC/B,CDjC+B,CAAA,MAAA,CAAA,CAAA,GCiClB,WDjCkB;;AAQhD;;;;;;;;;;;;iBCwCgB,oCACL,SAAS,cAAc,MAC/B,WAAW;iBACE,mBAAmB,oCACxB,IACR,SAAS"}

package/dist/merge-all-DkmSC0ri.d.cts

@@ -1,42 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { NonEmptyArray } from "./non-empty-array-D3ZRHApS.cjs";
-import { TupleParts } from "./tuple-parts-BIyABPYv.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 };
-//# sourceMappingURL=merge-all-DkmSC0ri.d.cts.map

package/dist/merge-all-DkmSC0ri.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-all-DkmSC0ri.d.cts","names":[],"sources":["../src/internal/types/disjoint-union-fields.ts","../src/merge-all.ts"],"sourcesContent":[],"mappings":";;;;;;;;;KAKK,2CAA2C,QAC9C,YAAY,UACN,kBAAkB;;AAPsC;;AAMlD,KAOF,mBAPE,CAAA,UAAA,MAAA,CAAA,GAAA,QAQN,sBARN,CAQ6B,CAR7B,CAAA,GAQkC,CARlC,SAQ4C,OAR5C,CAQoD,MARpD,CAQ2D,CAR3D,EAAA,OAAA,CAAA,CAAA,GASI,CATJ,CASM,CATN,CAAA,GAAA,KAAA;;;;AAN8D;;KCc3D,UDRS,CAAA,UCSF,iBDTE,EAAA,SAAA,MAAA,CAAA,GCWV,CDXU,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GCYV,UDZU,CCYC,IDZD,ECYO,KDZP,CCYa,MDZb,ECYqB,IDZrB,CAAA,CAAA,GCaV,MDbU;KCsBT,UDtBH,CAAA,UAAA,MAAA,CAAA,GCsBkC,QDtBlC,CCuBA,iBDvBA,CCuBkB,CDvBlB,CAAA,GCuBuB,ODvBvB,CCuB+B,mBDvB/B,CCuBmD,CDvBnD,CAAA,CAAA,CAAA;KC0BG,QDzBqB,CAAA,UCyBF,iBDzBE,CAAA,MAAA,CAAA,CAAA,GC2BtB,UD3BsB,CC2BX,CD3BW,CAAA,SAAA;MAAlB,EAAA,KAAA;IC4BF,UD9B0C,SAAA,EAAA,GC+BxC,WD/BwC,GCgCxC,UDhCwC,CCgC7B,CDhC6B,CAAA,GCiC1C,UDjC0C,CCiC/B,CDjC+B,CAAA,MAAA,CAAA,CAAA,GCiClB,WDjCkB;;AAQhD;;;;;;;;;;;;iBCwCgB,oCACL,SAAS,cAAc,MAC/B,WAAW;iBACE,mBAAmB,oCACxB,IACR,SAAS"}

package/dist/merge-all-MOlMBgeb.cjs

@@ -1 +0,0 @@
-function e(e){let t={};for(let n of e)t={...t,...n};return t}Object.defineProperty(exports,`mergeAll`,{enumerable:!0,get:function(){return e}});

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

@@ -1,37 +0,0 @@
-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-A4Cgd47e.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"merge-deep-A4Cgd47e.d.ts","names":[],"sources":["../src/merge-deep.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;;;;;;;;AAmBA;;;AAGU,iBAtBM,SAsBN,CAAA,oBAAA,MAAA,EAAA,eAAA,MAAA,CAAA,CAAA,WAAA,EArBK,WAqBL,EAAA,MAAA,EArB0B,MAqB1B,CAAA,EApBP,SAoBO,CApBG,WAoBH,EApBgB,MAoBhB,CAAA;;;;;;;;;;;;;;;;iBAHM,yCACN,8CAEA,gBACL,UAAU,aAAa"}

package/dist/merge-deep-BcekJf0s.cjs

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

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

@@ -1,37 +0,0 @@
-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-DAfbgx82.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"merge-deep-DAfbgx82.d.cts","names":[],"sources":["../src/merge-deep.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;;;;;;;;AAmBA;;;AAGU,iBAtBM,SAsBN,CAAA,oBAAA,MAAA,EAAA,eAAA,MAAA,CAAA,CAAA,WAAA,EArBK,WAqBL,EAAA,MAAA,EArB0B,MAqB1B,CAAA,EApBP,SAoBO,CApBG,WAoBH,EApBgB,MAoBhB,CAAA;;;;;;;;;;;;;;;;iBAHM,yCACN,8CAEA,gBACL,UAAU,aAAa"}

package/dist/merge-deep-Dn1sRc5z.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";import{isPlainObject as t}from"./is-plain-object-Cnx_x0Ei.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-Dn1sRc5z.js.map

package/dist/merge-deep-Dn1sRc5z.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-deep-Dn1sRc5z.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":"0GA2CA,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/multiply-BI2VvlFd.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){return e*t}export{t as multiply};
-//# sourceMappingURL=multiply-BI2VvlFd.js.map

package/dist/multiply-BI2VvlFd.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"multiply-BI2VvlFd.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":"4CAiCA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAM5C,SAAS,EAAuB,EAAe,EAA8B,CAC3E,OAAO,EAAQ"}

package/dist/multiply-CTfXAoM_.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e*t}Object.defineProperty(exports,`multiply`,{enumerable:!0,get:function(){return t}});

package/dist/multiply-UBFQYNUD.d.ts

@@ -1,33 +0,0 @@
-//#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-UBFQYNUD.d.ts.map

package/dist/multiply-UBFQYNUD.d.ts.map

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

package/dist/multiply-gDDdmofq.d.cts

@@ -1,33 +0,0 @@
-//#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-gDDdmofq.d.cts.map

package/dist/multiply-gDDdmofq.d.cts.map

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

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

@@ -1,12 +0,0 @@
-//#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 };
-//# sourceMappingURL=n-tuple-BELi5yRe.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"n-tuple-BELi5yRe.d.ts","names":[],"sources":["../src/internal/types/n-tuple.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;AAIiD,KAJrC,MAIqC,CAAA,CAAA,EAAA,UAAA,MAAA,EAAA,eADhC,KACgC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAA7C,MAA6C,CAAA,QAAA,CAAA,SAApB,CAAoB,GAAhB,MAAgB,GAAP,MAAO,CAAA,CAAA,EAAG,CAAH,EAAA,CAAA,GAAU,MAAV,EAAkB,CAAlB,CAAA,CAAA"}

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

@@ -1,12 +0,0 @@
-//#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 };
-//# sourceMappingURL=n-tuple-Co_jgwEn.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"n-tuple-Co_jgwEn.d.cts","names":[],"sources":["../src/internal/types/n-tuple.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;AAIiD,KAJrC,MAIqC,CAAA,CAAA,EAAA,UAAA,MAAA,EAAA,eADhC,KACgC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAA7C,MAA6C,CAAA,QAAA,CAAA,SAApB,CAAoB,GAAhB,MAAgB,GAAP,MAAO,CAAA,CAAA,EAAG,CAAH,EAAA,CAAA,GAAU,MAAV,EAAkB,CAAlB,CAAA,CAAA"}

package/dist/narrowed-to-BTrqm7Xt.d.cts

@@ -1,15 +0,0 @@
-import { IsAny } from "type-fest";
-
-//#region src/internal/types/narrowed-to.d.ts
-
-/**
- * An extension of Extract for type predicates which falls back to the base
- * in order to narrow the `unknown` case.
- *
- * @example
- *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
- */
-type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
-//#endregion
-export { NarrowedTo };
-//# sourceMappingURL=narrowed-to-BTrqm7Xt.d.cts.map

package/dist/narrowed-to-BTrqm7Xt.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"narrowed-to-BTrqm7Xt.d.cts","names":[],"sources":["../src/internal/types/narrowed-to.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAEM,KAFM,UAEN,CAAA,CAAA,EAAA,IAAA,CAAA,GADF,OACE,CADM,CACN,EADS,IACT,CAAA,SAAA,KAAA,GAAA,IAAA,GACA,KADA,CACM,CADN,CAAA,SAAA,IAAA,GAEE,IAFF,GAGE,OAHF,CAGU,CAHV,EAGa,IAHb,CAAA"}

package/dist/narrowed-to-C6wP224-.d.ts

@@ -1,15 +0,0 @@
-import { IsAny } from "type-fest";
-
-//#region src/internal/types/narrowed-to.d.ts
-
-/**
- * An extension of Extract for type predicates which falls back to the base
- * in order to narrow the `unknown` case.
- *
- * @example
- *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
- */
-type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
-//#endregion
-export { NarrowedTo };
-//# sourceMappingURL=narrowed-to-C6wP224-.d.ts.map

package/dist/narrowed-to-C6wP224-.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"narrowed-to-C6wP224-.d.ts","names":[],"sources":["../src/internal/types/narrowed-to.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAEM,KAFM,UAEN,CAAA,CAAA,EAAA,IAAA,CAAA,GADF,OACE,CADM,CACN,EADS,IACT,CAAA,SAAA,KAAA,GAAA,IAAA,GACA,KADA,CACM,CADN,CAAA,SAAA,IAAA,GAEE,IAFF,GAGE,OAHF,CAGU,CAHV,EAGa,IAHb,CAAA"}

package/dist/non-empty-array-D3HWDPMt.d.ts

@@ -1,5 +0,0 @@
-//#region src/internal/types/non-empty-array.d.ts
-type NonEmptyArray<T> = [T, ...Array<T>];
-//#endregion
-export { NonEmptyArray };
-//# sourceMappingURL=non-empty-array-D3HWDPMt.d.ts.map

package/dist/non-empty-array-D3HWDPMt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"non-empty-array-D3HWDPMt.d.ts","names":[],"sources":["../src/internal/types/non-empty-array.ts"],"sourcesContent":[],"mappings":";KAAY,oBAAoB,MAAM,MAAM"}

package/dist/non-empty-array-D3ZRHApS.d.cts

@@ -1,5 +0,0 @@
-//#region src/internal/types/non-empty-array.d.ts
-type NonEmptyArray<T> = [T, ...Array<T>];
-//#endregion
-export { NonEmptyArray };
-//# sourceMappingURL=non-empty-array-D3ZRHApS.d.cts.map

package/dist/non-empty-array-D3ZRHApS.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"non-empty-array-D3ZRHApS.d.cts","names":[],"sources":["../src/internal/types/non-empty-array.ts"],"sourcesContent":[],"mappings":";KAAY,oBAAoB,MAAM,MAAM"}

package/dist/nth-by-BLlYxw3C.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-order-rules-UcuuWkKd.cjs`),t=require(`./swap-in-place-CJrU2n1_.cjs`);function n(e,t,n){return t<0||t>=e.length?void 0:r([...e],0,e.length-1,t,n)}function r(e,t,n,a,o){if(t===n)return e[t];let s=i(e,t,n,o);return a===s?e[a]:r(e,a<s?t:s+1,a<s?s-1:n,a,o)}function i(e,n,r,i){let a=e[r],o=n;for(let s=n;s<r;s++)i(e[s],a)<0&&(t.swapInPlace(e,o,s),o+=1);return t.swapInPlace(e,o,r),o}function a(...t){return e.curryOrderRulesWithArgument(o,t)}function o(e,t,r){return n(e,r>=0?r:e.length+r,t)}Object.defineProperty(exports,`nthBy`,{enumerable:!0,get:function(){return a}});

package/dist/nth-by-BR1fcwCZ.js

@@ -1,2 +0,0 @@
-import{curryOrderRulesWithArgument as e}from"./curry-order-rules-BuA7D1F4.js";import{swapInPlace as t}from"./swap-in-place-BBqaxzzG.js";function n(e,t,n){return t<0||t>=e.length?void 0:r([...e],0,e.length-1,t,n)}function r(e,t,n,a,o){if(t===n)return e[t];let s=i(e,t,n,o);return a===s?e[a]:r(e,a<s?t:s+1,a<s?s-1:n,a,o)}function i(e,n,r,i){let a=e[r],o=n;for(let s=n;s<r;s++)i(e[s],a)<0&&(t(e,o,s),o+=1);return t(e,o,r),o}function a(...t){return e(o,t)}function o(e,t,r){return n(e,r>=0?r:e.length+r,t)}export{a as nthBy};
-//# sourceMappingURL=nth-by-BR1fcwCZ.js.map

package/dist/nth-by-BR1fcwCZ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nth-by-BR1fcwCZ.js","names":[],"sources":["../src/internal/quick-select.ts","../src/nth-by.ts"],"sourcesContent":["/**\n * A simple implementation of the *QuickSelect* algorithm.\n *\n * @see https://en.wikipedia.org/wiki/Quickselect\n */\n\nimport type { CompareFunction } from './types/compare-function';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Perform QuickSelect on the given data. Notice that the data would be cloned\n * shallowly so that it could be mutated in-place, and then discarded once the\n * algorithm is done. This means that running this function multiple times on\n * the same array might be slower then sorting the array before.\n *\n * @param data - The data to perform the selection on.\n * @param index - The index of the item we are looking for.\n * @param compareFn - The compare function to use for sorting.\n * @returns The item at the given index, or `undefined` if the index is out-of-\n * bounds.\n */\nexport function quickSelect<T>(\n  data: ReadonlyArray<T>,\n  index: number,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  return index < 0 || index >= data.length\n  // Quickselect doesn't work with out-of-bound indices\n    ? undefined\n    : quickSelectImplementation(\n      // We need to clone the array because quickSelect mutates it in-place.\n        [...data],\n        0 /* left */,\n        data.length - 1 /* right */,\n        index,\n        compareFn,\n      );\n}\n\n/**\n * The actual implementation, called recursively.\n */\nfunction quickSelectImplementation<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  index: number,\n  compareFn: CompareFunction<T>,\n): T {\n  if (left === right) {\n    return data[left]!;\n  }\n\n  const pivotIndex = partition(data, left, right, compareFn);\n\n  return index === pivotIndex\n    // Once a pivot is chosen it's location is final, so if it matches the\n    // index we found out item!\n    ? data[index]!\n    : quickSelectImplementation(\n        data,\n        // We continue by recursing into the partition where index would be\n        index < pivotIndex ? left : pivotIndex + 1,\n        index < pivotIndex ? pivotIndex - 1 : right,\n        index,\n        compareFn,\n      );\n}\n\nfunction partition<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  compareFn: CompareFunction<T>,\n): number {\n  const pivot = data[right]!;\n\n  let i = left;\n  for (let j = left; j < right; j++) {\n    if (compareFn(data[j]!, pivot) < 0) {\n      // Move items smaller then the pivot to the start of the array.\n      swapInPlace(data, i, j);\n      i += 1;\n    }\n  }\n\n  swapInPlace(data, i, right);\n\n  // The location of the pivot by the end of the partition function.\n  return i;\n}\n","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 {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\nimport { quickSelect } from './internal/quick-select';\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules).at(index)` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param data - The input array.\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\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 element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   P.nthBy(data, index, ...rules);\n * @example\n *   P.nthBy([2,1,4,5,3,], 2, identity()); // => 3\n * @dataFirst\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  data: T,\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): T[number] | undefined;\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules)[index]` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\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 element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   P.nthBy(index, ...rules)(data);\n * @example\n *   P.pipe([2,1,4,5,3,], P.nthBy(2, identity())); // => 3\n * @dataLast\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => T[number] | undefined;\n\nexport function nthBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(nthByImplementation, args);\n}\n\nfunction nthByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  index: number,\n): T | undefined {\n  return quickSelect(\n    data,\n    // Allow negative indices gracefully\n    index >= 0 ? index : data.length + index,\n    compareFn,\n  );\n}\n"],"mappings":"wIAqBA,SAAgB,EACd,EACA,EACA,EACe,CACf,OAAO,EAAQ,GAAK,GAAS,EAAK,OAE9B,IAAA,GACA,EAEE,CAAC,GAAG,EAAK,CACT,EACA,EAAK,OAAS,EACd,EACA,EACD,CAMP,SAAS,EACP,EACA,EACA,EACA,EACA,EACG,CACH,GAAI,IAAS,EACX,OAAO,EAAK,GAGd,IAAM,EAAa,EAAU,EAAM,EAAM,EAAO,EAAU,CAE1D,OAAO,IAAU,EAGb,EAAK,GACL,EACE,EAEA,EAAQ,EAAa,EAAO,EAAa,EACzC,EAAQ,EAAa,EAAa,EAAI,EACtC,EACA,EACD,CAGP,SAAS,EACP,EACA,EACA,EACA,EACQ,CACR,IAAM,EAAQ,EAAK,GAEf,EAAI,EACR,IAAK,IAAI,EAAI,EAAM,EAAI,EAAO,IACxB,EAAU,EAAK,GAAK,EAAM,CAAG,IAE/B,EAAY,EAAM,EAAG,EAAE,CACvB,GAAK,GAOT,OAHA,EAAY,EAAM,EAAG,EAAM,CAGpB,ECrCT,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAA4B,EAAqB,EAAK,CAG/D,SAAS,EACP,EACA,EACA,EACe,CACf,OAAO,EACL,EAEA,GAAS,EAAI,EAAQ,EAAK,OAAS,EACnC,EACD"}

package/dist/nth-by-CKFOiBHp.d.cts

@@ -1,42 +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/nth-by.d.ts
-
-/**
- * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules).at(index)` which would run at *O(nlogn)*.
- *
- * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.
- *
- * @param data - The input array.
- * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
- * @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 element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
- * @signature
- *   P.nthBy(data, index, ...rules);
- * @example
- *   P.nthBy([2,1,4,5,3,], 2, identity()); // => 3
- * @dataFirst
- * @category Array
- */
-declare function nthBy<T extends IterableContainer>(data: T, index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): T[number] | undefined;
-/**
- * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules)[index]` which would run at *O(nlogn)*.
- *
- * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.
- *
- * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
- * @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 element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
- * @signature
- *   P.nthBy(index, ...rules)(data);
- * @example
- *   P.pipe([2,1,4,5,3,], P.nthBy(2, identity())); // => 3
- * @dataLast
- * @category Array
- */
-declare function nthBy<T extends IterableContainer>(index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => T[number] | undefined;
-//#endregion
-export { nthBy };
-//# sourceMappingURL=nth-by-CKFOiBHp.d.cts.map