@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/path-or.d.ts

@@ -1,89 +1,2 @@
-/**
- * Given a union of indexable types `T`, we derive an indexable type
- * containing all of the keys of each variant of `T`. If a key is
- * present in multiple variants of `T`, then the corresponding type in
- * `Pathable<T>` will be the intersection of all types for that key.
- *
- * @example
- *    type T1 = Pathable<{a: number} | {a: string; b: boolean}>
- *    // {a: number | string; b: boolean}
- *
- *    type T2 = Pathable<{a?: {b: string}}
- *    // {a: {b: string} | undefined}
- *
- *    type T3 = Pathable<{a: string} | number>
- *    // {a: string}
- *
- *    type T4 = Pathable<{a: number} | {a: string} | {b: boolean}>
- *    // {a: number | string; b: boolean}
- *
- * This type lets us answer the questions:
- * - Given some object of type `T`, what keys might this object have?
- * - If this object did happen to have a particular key, what values
- *   might that key have?
- */
-type Pathable<T> = {
-    [K in AllKeys<T>]: TypesForKey<T, K>;
-};
-type AllKeys<T> = T extends infer I ? keyof I : never;
-type TypesForKey<T, K extends PropertyKey> = T extends infer I ? K extends keyof I ? I[K] : never : never;
-type StrictlyRequired<T> = {
-    [K in keyof T]-?: NonNullable<T[K]>;
-};
-/**
- * Given some `A` which is a key of at least one variant of `T`, derive
- * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not
- * null or undefined.
- */
-type PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<Pathable<T>>[A];
-/** All possible options after successfully reaching `T[A]`. */
-type Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;
-/** As `PathValue1`, but for `T[A][B]`. */
-type PathValue2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = StrictlyRequired<Pathable1<T, A>>[B];
-/** As `Pathable1`, but for `T[A][B]`. */
-type Pathable2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = Pathable<PathValue2<T, A, B>>;
-/** As `PathValue1`, but for `T[A][B][C]`. */
-type PathValue3<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>> = StrictlyRequired<Pathable2<T, A, B>>[C];
-/**
- * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.
- *
- * Prefer `prop` over this function as it provides better typing and is more
- * flexible when building solutions. To provide a default value using `prop`
- * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- * after the call.
- *
- * @param object - The target object.
- * @param path - The path of the property to get.
- * @param defaultValue - The default value.
- * @signature P.pathOr(object, array, defaultValue)
- * @example
- *    P.pathOr({x: 10}, ['y'], 2) // 2
- *    P.pathOr({y: 10}, ['y'], 2) // 10
- * @dataFirst
- * @category Object
- */
-declare function pathOr<T, A extends keyof Pathable<T>>(object: T, path: readonly [A], defaultValue: PathValue1<T, A>): PathValue1<T, A>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(object: T, path: readonly [A, B], defaultValue: PathValue2<T, A, B>): PathValue2<T, A, B>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(object: T, path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): PathValue3<T, A, B, C>;
-/**
- * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.
- *
- * Prefer `prop` over this function as it provides better typing and is more
- * flexible when building solutions. To provide a default value using `prop`
- * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- * after the call.
- *
- * @param path - The path of the property to get.
- * @param defaultValue - The default value.
- * @signature P.pathOr(array, defaultValue)(object)
- * @example
- *    P.pipe({x: 10}, P.pathOr(['y'], 2)) // 2
- *    P.pipe({y: 10}, P.pathOr(['y'], 2)) // 10
- * @dataLast
- * @category Object
- */
-declare function pathOr<T, A extends keyof Pathable<T>>(path: readonly [A], defaultValue: PathValue1<T, A>): (object: T) => PathValue1<T, A>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(path: readonly [A, B], defaultValue: PathValue2<T, A, B>): (object: T) => PathValue2<T, A, B>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): (object: T) => PathValue3<T, A, B, C>;
-
-export { pathOr };
+import { pathOr } from "./path-or-ld_fRiaZ.js";
+export { pathOr };

package/dist/path-or.js

@@ -1 +1 @@
-import{a}from"./chunk-N6GBVESU.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as pathOr};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{pathOr as e}from"./path-or-D2Gn-2iU.js";export{e as pathOr};

package/dist/perkakas-type-error-0tHtaPbi.d.cts

@@ -0,0 +1,19 @@
+import { Tagged } from "type-fest";
+
+//#region src/internal/types/perkakas-type-error.d.ts
+declare const PerkakasErrorSymbol: unique symbol;
+interface PerkakasTypeErrorOptions {
+  type?: unknown;
+  metadata?: unknown;
+}
+/**
+ * Used for reporting type errors in a more useful way than `never`.
+ */
+type PerkakasTypeError<FunctionName extends string, Message extends number | string, Options extends PerkakasTypeErrorOptions = {}> = Tagged<Options extends {
+  type: infer T;
+} ? T : typeof PerkakasErrorSymbol, `PerkakasTypeError(${FunctionName}): ${Message}.`, Options extends {
+  metadata: infer Metadata;
+} ? Metadata : never>;
+//#endregion
+export { PerkakasTypeError };
+//# sourceMappingURL=perkakas-type-error-0tHtaPbi.d.cts.map

package/dist/perkakas-type-error-0tHtaPbi.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perkakas-type-error-0tHtaPbi.d.cts","names":[],"sources":["../src/internal/types/perkakas-type-error.ts"],"sourcesContent":[],"mappings":";;;cAIM;UAEI,wBAAA;EAFJ,IAAA,CAAA,EAAA,OAAA;EAEI,QAAA,CAAA,EAAA,OAAA;AAQV;;;;AAQsC,KAR1B,iBAQ0B,CAAA,qBAAA,MAAA,EAAA,gBAAA,MAAA,GAAA,MAAA,EAAA,gBAFpB,wBAEoB,GAAA,CAAA,CAAA,CAAA,GADlC,MACkC,CAApC,OAAoC,SAAA;MAAW,EAAA,KAAA,EAAA;IAAX,IACf,OAD0B,mBAC1B,EAAA,qBAAA,YAAA,MAAkB,OAAlB,GAAA,EACrB,OADqB,SAAA;UAAkB,EAAA,KAAA,SAAA;IACQ,QAA/C,GAAA,KAAA,CAAA"}

package/dist/perkakas-type-error-2yBU0Drj.d.ts

@@ -0,0 +1,19 @@
+import { Tagged } from "type-fest";
+
+//#region src/internal/types/perkakas-type-error.d.ts
+declare const PerkakasErrorSymbol: unique symbol;
+interface PerkakasTypeErrorOptions {
+  type?: unknown;
+  metadata?: unknown;
+}
+/**
+ * Used for reporting type errors in a more useful way than `never`.
+ */
+type PerkakasTypeError<FunctionName extends string, Message extends number | string, Options extends PerkakasTypeErrorOptions = {}> = Tagged<Options extends {
+  type: infer T;
+} ? T : typeof PerkakasErrorSymbol, `PerkakasTypeError(${FunctionName}): ${Message}.`, Options extends {
+  metadata: infer Metadata;
+} ? Metadata : never>;
+//#endregion
+export { PerkakasTypeError };
+//# sourceMappingURL=perkakas-type-error-2yBU0Drj.d.ts.map

package/dist/perkakas-type-error-2yBU0Drj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perkakas-type-error-2yBU0Drj.d.ts","names":[],"sources":["../src/internal/types/perkakas-type-error.ts"],"sourcesContent":[],"mappings":";;;cAIM;UAEI,wBAAA;EAFJ,IAAA,CAAA,EAAA,OAAA;EAEI,QAAA,CAAA,EAAA,OAAA;AAQV;;;;AAQsC,KAR1B,iBAQ0B,CAAA,qBAAA,MAAA,EAAA,gBAAA,MAAA,GAAA,MAAA,EAAA,gBAFpB,wBAEoB,GAAA,CAAA,CAAA,CAAA,GADlC,MACkC,CAApC,OAAoC,SAAA;MAAW,EAAA,KAAA,EAAA;IAAX,IACf,OAD0B,mBAC1B,EAAA,qBAAA,YAAA,MAAkB,OAAlB,GAAA,EACrB,OADqB,SAAA;UAAkB,EAAA,KAAA,SAAA;IACQ,QAA/C,GAAA,KAAA,CAAA"}

package/dist/pick-ChVH4t7j.d.cts

@@ -0,0 +1,66 @@
+import { IsUnion } from "./is-union-BEGCMhOi.cjs";
+import { TupleParts } from "./tuple-parts-BIyABPYv.cjs";
+import { IsBounded, IsBoundedRecord } from "./is-bounded-record-kpsb1wQA.cjs";
+import { EmptyObject, IsNever, KeysOfUnion, Writable } from "type-fest";
+
+//#region src/pick.d.ts
+type PickFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>> = T extends unknown ? Keys extends unknown ? IsNever<Extract<Keys[number], keyof T>> extends true ? EmptyObject : Writable<IsBoundedRecord<T> extends true ? PickBoundedFromArray<T, Keys> : PickUnbounded<T, Extract<Keys[number], keyof T>>> : never : never;
+/**
+ * Bounded records have bounded keys and result in a bounded output. The only
+ * question left is whether to add the prop as-is, or make it optional. This
+ * can be determined by the part of the keys array the prop is defined in, and
+ * the way that element is defined: if the array contains a singular literal
+ * key in either the required prefix or the suffix, we know that prop should be
+ * picked as-is, otherwise, the key might not be present in the keys array so it
+ * can only be picked optionally.
+ */
+type PickBoundedFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>> = Pick<T, Extract<ItemsByUnion<TupleParts<Keys>['required']>['singular'] | ItemsByUnion<TupleParts<Keys>['suffix']>['singular'], keyof T>> & Partial<Pick<T, Extract<ItemsByUnion<TupleParts<Keys>['required']>['union'] | TupleParts<Keys>['optional'][number] | TupleParts<Keys>['item'] | ItemsByUnion<TupleParts<Keys>['suffix']>['union'], keyof T>>>;
+/**
+ * We split the fixed tuple item types into **singular** props (e.g., `"a"`),
+ * and unions of several props (e.g., `"a" | "b"`).
+ *
+ * We assume that T is a fixed tuple (no optional or rest elements), and that
+ * all elements in it are bounded (as defined by `IsBounded`).
+ */
+type ItemsByUnion<T, Singular = never, Union = never> = T extends readonly [infer Head, ...infer Rest] ? IsUnion<Head> extends true ? ItemsByUnion<Rest, Singular, Union | Head> : ItemsByUnion<Rest, Singular | Head, Union> : {
+  singular: Singular;
+  union: Union;
+};
+/**
+ * The built-in `Pick` is weird when it comes to picking bounded keys from
+ * unbounded records. It reconstructs the output object regardless of the shape
+ * of the input: `Pick<Record<string, "world">, "hello">` results in the type
+ * `{ hello: "world" }`, but you'd expect it to be optional because we don't
+ * know if the record contains a `hello` prop or not!
+ *
+ * !Important: We assume T is unbounded and don't test for it!
+ *
+ * See: https://www.typescriptlang.org/play/?#code/PTAEE0HsFcHIBNQFMAeAHJBjALqAGqNpKAEZKigAGA3qABZIA2jkA-AFygBEA7pAE6N4XUAF9KAGlLRcAQ0ayAzgChsATwz5QAXlAAFAJaYA1gB4ASlgHxTi7PwMA7AOZTeAoVwB8bhs0jeANzKIBSgAHqsykA.
+ */
+type PickUnbounded<T, Keys extends keyof T> = IsBounded<Keys> extends true ? Partial<Pick<T, Keys>> : Pick<T, Keys>;
+/**
+ * Creates an object composed of the picked `data` properties.
+ *
+ * @param keys - The property names.
+ * @signature P.pick([prop1, prop2])(object)
+ * @example
+ *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.pick(['a', 'd'])) // => { a: 1, d: 4 }
+ * @dataLast
+ * @category Object
+ */
+declare function pick<T extends object, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(keys: Keys): (data: T) => PickFromArray<T, Keys>;
+/**
+ * Creates an object composed of the picked `data` properties.
+ *
+ * @param data - The target object.
+ * @param keys - The property names.
+ * @signature P.pick(object, [prop1, prop2])
+ * @example
+ *    P.pick({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { a: 1, d: 4 }
+ * @dataFirst
+ * @category Object
+ */
+declare function pick<T extends object, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(data: T, keys: Keys): PickFromArray<T, Keys>;
+//#endregion
+export { pick };
+//# sourceMappingURL=pick-ChVH4t7j.d.cts.map

package/dist/pick-ChVH4t7j.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-ChVH4t7j.d.cts","names":[],"sources":["../src/pick.ts"],"sourcesContent":[],"mappings":";;;;;;KAOK,8BAA8B,cAAc,YAAY,OAEzD,oBACE,uBAOE,QAAQ,QAAQ,oBAAoB,mBAClC,cAIA,SACE,gBAAgB,kBACZ,qBAAqB,GAAG,QACxB,cAAc,GAAG,QAAQ,oBAAoB;AArBE;;;;;;;;;KAmC1D,oBAtBW,CAAA,CAAA,EAAA,aAsB0B,aAtB1B,CAsBwC,WAtBxC,CAsBoD,CAtBpD,CAAA,CAAA,CAAA,GAwBZ,IAxBY,CAyBZ,CAzBY,EA4BZ,OA5BY,CA6BR,YA7BQ,CA6BK,UA7BL,CA6BgB,IA7BhB,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,GA8BR,YA9BQ,CA8BK,UA9BL,CA8BgB,IA9BhB,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,UAAA,CAAA,EAAA,MA+BJ,CA/BI,CAAA,CAAA,GAmCZ,OAnCY,CAoCV,IApCU,CAqCR,CArCQ,EAwCR,OAxCQ,CAyCJ,YAzCI,CAyCS,UAzCT,CAyCoB,IAzCpB,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,OAAA,CAAA,GA2CJ,UA3CI,CA2CO,IA3CP,CAAA,CAAA,UAAA,CAAA,CAAA,MAAA,CAAA,GA4CJ,UA5CI,CA4CO,IA5CP,CAAA,CAAA,MAAA,CAAA,GA6CJ,YA7CI,CA6CS,UA7CT,CA6CoB,IA7CpB,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,OAAA,CAAA,EAAA,MA8CA,CA9CA,CAAA,CAAA,CAAA;;;;;;;;KA0DX,YAlDyB,CAAA,CAAA,EAAA,WAAA,KAAA,EAAA,QAAA,KAAA,CAAA,GAkD0B,CAlD1B,SAAA,SAAA,MAAW,KAAA,KAAoB,KAAA,KAAA,IAsDzD,OAtD6B,CAsDrB,IAtDqB,CAAA,SAAA,IAAA,GAuD3B,YAvD2B,CAuDd,IAvDc,EAuDR,QAvDQ,EAuDE,KAvDF,GAuDU,IAvDV,CAAA,GAwD3B,YAxD2B,CAwDd,IAxDc,EAwDR,QAxDQ,GAwDG,IAxDH,EAwDS,KAxDT,CAAA,GAAA;UAAjB,EAyDA,QAzDA;OAHN,EA4DuB,KA5DvB;CAAQ;AAAA;;;;;;;;;;;KAyEb,aAhDG,CAAA,CAAA,EAAA,aAAA,MAgDiC,CAhDjC,CAAA,GAgDsC,SAhDtC,CAgDgD,IAhDhD,CAAA,SAAA,IAAA,GAgDqE,OAhDrE,CAgD6E,IAhD7E,CAgDkF,CAhDlF,EAgDqF,IAhDrF,CAAA,CAAA,GAgD8F,IAhD9F,CAgDmG,CAhDnG,EAgDsG,IAhDtG,CAAA;;;;;;;;;;;AAcI,iBA8CI,IA9CJ,CAAA,UAAA,MAAA,EAAA,mBAgDS,aAhDT,CAgDuB,WAhDvB,CAgDmC,CAhDnC,CAAA,CAAA,CAAA,CAAA,IAAA,EAiDJ,IAjDI,CAAA,EAAA,CAAA,IAAA,EAiDU,CAjDV,EAAA,GAiDgB,aAjDhB,CAiD8B,CAjD9B,EAiDiC,IAjDjC,CAAA;;;;;;;;;AATD;;;AA2BC,iBA4CI,IA5CJ,CAAA,UAAA,MAAA,EAAA,mBA8CS,aA9CT,CA8CuB,WA9CvB,CA8CmC,CA9CnC,CAAA,CAAA,CAAA,CAAA,IAAA,EA+CJ,CA/CI,EAAA,IAAA,EA+CK,IA/CL,CAAA,EA+CY,aA/CZ,CA+C0B,CA/C1B,EA+C6B,IA/C7B,CAAA"}

package/dist/pick-DH_wjXvd.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n={};for(let r of t)r in e&&(n[r]=e[r]);return n}Object.defineProperty(exports,`pick`,{enumerable:!0,get:function(){return t}});

package/dist/pick-DeXJU-DB.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let r of t)r in e&&(n[r]=e[r]);return n}export{t as pick};
+//# sourceMappingURL=pick-DeXJU-DB.js.map

package/dist/pick-DeXJU-DB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-DeXJU-DB.js","names":["out: Partial<Pick<T, Keys[number]>>"],"sources":["../src/pick.ts"],"sourcesContent":["import type { EmptyObject, IsNever, KeysOfUnion, Writable } from 'type-fest';\nimport type { IsBounded } from './internal/types/is-bounded';\nimport type { IsBoundedRecord } from './internal/types/is-bounded-record';\nimport type { IsUnion } from './internal/types/is-union';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\ntype PickFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>>\n  // Distribute unions for both object types and key arrays.\n  = T extends unknown\n    ? Keys extends unknown\n      // When T is a union (or when Keys is empty) the picked props might\n      // not exist in some of its sub-types, e.g.,\n      //   `pick(... as { a: string } | { b: number }, ['a'])`,\n      // if we simply let the regular \"constructive\" logic run, the\n      // resulting type would be `{}` which doesn't behave like an empty\n      // object! instead, we want to use a more explicit *empty* type.\n      ? IsNever<Extract<Keys[number], keyof T>> extends true\n        ? EmptyObject\n        // Remove `readonly` modifiers from picked props since we return a\n        // new, mutable, object. We don't wrap the result with `Simplify` to\n        // flatten it because `Writable` does the same thing implicitly.\n        : Writable<\n            IsBoundedRecord<T> extends true\n              ? PickBoundedFromArray<T, Keys>\n              : PickUnbounded<T, Extract<Keys[number], keyof T>>\n          >\n      : never\n    : never;\n\n/**\n * Bounded records have bounded keys and result in a bounded output. The only\n * question left is whether to add the prop as-is, or make it optional. This\n * can be determined by the part of the keys array the prop is defined in, and\n * the way that element is defined: if the array contains a singular literal\n * key in either the required prefix or the suffix, we know that prop should be\n * picked as-is, otherwise, the key might not be present in the keys array so it\n * can only be picked optionally.\n */\ntype PickBoundedFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>>\n  // Literal keys in the prefix/suffix are guaranteed present.\n  = Pick<\n    T,\n    // When T is a union the keys need to be narrowed to just those that are\n    // keys of the specific sub-type being built\n    Extract<\n      | ItemsByUnion<TupleParts<Keys>['required']>['singular']\n      | ItemsByUnion<TupleParts<Keys>['suffix']>['singular'],\n      keyof T\n    >\n  >\n    // Union keys, optional elements, and rest elements are optional.\n  & Partial<\n      Pick<\n        T,\n        // When T is a union the keys need to be narrowed to just those that are\n        // keys of the specific sub-type being built.\n        Extract<\n          | ItemsByUnion<TupleParts<Keys>['required']>['union']\n          // TODO: the optional part of the keys array will always be empty because its impossible to provide the pick function with a tuple with optional elements; this is because optional elements are always implicitly `undefined` too; which breaks the constraint that all keys are keys of T (`undefined` is not a key of anything). We can lift this restriction by supporting `undefined` in the runtime and relaxing the type constraint to allow it, but this relaxed constraint enables a niche feature (optional tuple elements) at the expense of better type-safety for the more common cases of fixed tuples and arrays. Anyway... if we ever change it, this part of the output type will ensure the output is still correct:\n          | TupleParts<Keys>['optional'][number]\n          | TupleParts<Keys>['item']\n          | ItemsByUnion<TupleParts<Keys>['suffix']>['union'],\n          keyof T\n        >\n      >\n    >;\n\n/**\n * We split the fixed tuple item types into **singular** props (e.g., `\"a\"`),\n * and unions of several props (e.g., `\"a\" | \"b\"`).\n *\n * We assume that T is a fixed tuple (no optional or rest elements), and that\n * all elements in it are bounded (as defined by `IsBounded`).\n */\ntype ItemsByUnion<T, Singular = never, Union = never> = T extends readonly [\n  infer Head,\n  ...infer Rest,\n]\n  ? IsUnion<Head> extends true\n    ? ItemsByUnion<Rest, Singular, Union | Head>\n    : ItemsByUnion<Rest, Singular | Head, Union>\n  : { singular: Singular; union: Union };\n\n/**\n * The built-in `Pick` is weird when it comes to picking bounded keys from\n * unbounded records. It reconstructs the output object regardless of the shape\n * of the input: `Pick<Record<string, \"world\">, \"hello\">` results in the type\n * `{ hello: \"world\" }`, but you'd expect it to be optional because we don't\n * know if the record contains a `hello` prop or not!\n *\n * !Important: We assume T is unbounded and don't test for it!\n *\n * See: https://www.typescriptlang.org/play/?#code/PTAEE0HsFcHIBNQFMAeAHJBjALqAGqNpKAEZKigAGA3qABZIA2jkA-AFygBEA7pAE6N4XUAF9KAGlLRcAQ0ayAzgChsATwz5QAXlAAFAJaYA1gB4ASlgHxTi7PwMA7AOZTeAoVwB8bhs0jeANzKIBSgAHqsykA.\n */\ntype PickUnbounded<T, Keys extends keyof T> = IsBounded<Keys> extends true ? Partial<Pick<T, Keys>> : Pick<T, Keys>;\n\n/**\n * Creates an object composed of the picked `data` properties.\n *\n * @param keys - The property names.\n * @signature P.pick([prop1, prop2])(object)\n * @example\n *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.pick(['a', 'd'])) // => { a: 1, d: 4 }\n * @dataLast\n * @category Object\n */\nexport function pick<\n  T extends object,\n  const Keys extends ReadonlyArray<KeysOfUnion<T>>,\n>(keys: Keys): (data: T) => PickFromArray<T, Keys>;\n\n/**\n * Creates an object composed of the picked `data` properties.\n *\n * @param data - The target object.\n * @param keys - The property names.\n * @signature P.pick(object, [prop1, prop2])\n * @example\n *    P.pick({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { a: 1, d: 4 }\n * @dataFirst\n * @category Object\n */\nexport function pick<\n  T extends object,\n  const Keys extends ReadonlyArray<KeysOfUnion<T>>,\n>(data: T, keys: Keys): PickFromArray<T, Keys>;\n\nexport function pick(...args: ReadonlyArray<unknown>): unknown {\n  return curry(pickImplementation, args);\n}\n\nfunction pickImplementation<\n  T extends object,\n  Keys extends ReadonlyArray<keyof T>,\n>(object: T, keys: Keys): PickFromArray<T, Keys> {\n  const out: Partial<Pick<T, Keys[number]>> = {};\n  for (const key of keys) {\n    if (key in object) {\n      out[key] = object[key];\n    }\n  }\n  // @ts-expect-error [ts2322] - We build the type incrementally, there's no way to make typescript infer that we \"finished\" building the object and to treat it as such.\n  return out;\n}\n"],"mappings":"4CAgIA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EAGP,EAAW,EAAoC,CAC/C,IAAMA,EAAsC,EAAE,CAC9C,IAAK,IAAM,KAAO,EACZ,KAAO,IACT,EAAI,GAAO,EAAO,IAItB,OAAO"}

package/dist/pick-DvCrGRHa.d.ts

@@ -0,0 +1,66 @@
+import { IsUnion } from "./is-union-J33UR5By.js";
+import { TupleParts } from "./tuple-parts-Du2iVN8H.js";
+import { IsBounded, IsBoundedRecord } from "./is-bounded-record-DEQ2a3_Y.js";
+import { EmptyObject, IsNever, KeysOfUnion, Writable } from "type-fest";
+
+//#region src/pick.d.ts
+type PickFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>> = T extends unknown ? Keys extends unknown ? IsNever<Extract<Keys[number], keyof T>> extends true ? EmptyObject : Writable<IsBoundedRecord<T> extends true ? PickBoundedFromArray<T, Keys> : PickUnbounded<T, Extract<Keys[number], keyof T>>> : never : never;
+/**
+ * Bounded records have bounded keys and result in a bounded output. The only
+ * question left is whether to add the prop as-is, or make it optional. This
+ * can be determined by the part of the keys array the prop is defined in, and
+ * the way that element is defined: if the array contains a singular literal
+ * key in either the required prefix or the suffix, we know that prop should be
+ * picked as-is, otherwise, the key might not be present in the keys array so it
+ * can only be picked optionally.
+ */
+type PickBoundedFromArray<T, Keys extends ReadonlyArray<KeysOfUnion<T>>> = Pick<T, Extract<ItemsByUnion<TupleParts<Keys>['required']>['singular'] | ItemsByUnion<TupleParts<Keys>['suffix']>['singular'], keyof T>> & Partial<Pick<T, Extract<ItemsByUnion<TupleParts<Keys>['required']>['union'] | TupleParts<Keys>['optional'][number] | TupleParts<Keys>['item'] | ItemsByUnion<TupleParts<Keys>['suffix']>['union'], keyof T>>>;
+/**
+ * We split the fixed tuple item types into **singular** props (e.g., `"a"`),
+ * and unions of several props (e.g., `"a" | "b"`).
+ *
+ * We assume that T is a fixed tuple (no optional or rest elements), and that
+ * all elements in it are bounded (as defined by `IsBounded`).
+ */
+type ItemsByUnion<T, Singular = never, Union = never> = T extends readonly [infer Head, ...infer Rest] ? IsUnion<Head> extends true ? ItemsByUnion<Rest, Singular, Union | Head> : ItemsByUnion<Rest, Singular | Head, Union> : {
+  singular: Singular;
+  union: Union;
+};
+/**
+ * The built-in `Pick` is weird when it comes to picking bounded keys from
+ * unbounded records. It reconstructs the output object regardless of the shape
+ * of the input: `Pick<Record<string, "world">, "hello">` results in the type
+ * `{ hello: "world" }`, but you'd expect it to be optional because we don't
+ * know if the record contains a `hello` prop or not!
+ *
+ * !Important: We assume T is unbounded and don't test for it!
+ *
+ * See: https://www.typescriptlang.org/play/?#code/PTAEE0HsFcHIBNQFMAeAHJBjALqAGqNpKAEZKigAGA3qABZIA2jkA-AFygBEA7pAE6N4XUAF9KAGlLRcAQ0ayAzgChsATwz5QAXlAAFAJaYA1gB4ASlgHxTi7PwMA7AOZTeAoVwB8bhs0jeANzKIBSgAHqsykA.
+ */
+type PickUnbounded<T, Keys extends keyof T> = IsBounded<Keys> extends true ? Partial<Pick<T, Keys>> : Pick<T, Keys>;
+/**
+ * Creates an object composed of the picked `data` properties.
+ *
+ * @param keys - The property names.
+ * @signature P.pick([prop1, prop2])(object)
+ * @example
+ *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.pick(['a', 'd'])) // => { a: 1, d: 4 }
+ * @dataLast
+ * @category Object
+ */
+declare function pick<T extends object, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(keys: Keys): (data: T) => PickFromArray<T, Keys>;
+/**
+ * Creates an object composed of the picked `data` properties.
+ *
+ * @param data - The target object.
+ * @param keys - The property names.
+ * @signature P.pick(object, [prop1, prop2])
+ * @example
+ *    P.pick({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { a: 1, d: 4 }
+ * @dataFirst
+ * @category Object
+ */
+declare function pick<T extends object, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(data: T, keys: Keys): PickFromArray<T, Keys>;
+//#endregion
+export { pick };
+//# sourceMappingURL=pick-DvCrGRHa.d.ts.map

package/dist/pick-DvCrGRHa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-DvCrGRHa.d.ts","names":[],"sources":["../src/pick.ts"],"sourcesContent":[],"mappings":";;;;;;KAOK,8BAA8B,cAAc,YAAY,OAEzD,oBACE,uBAOE,QAAQ,QAAQ,oBAAoB,mBAClC,cAIA,SACE,gBAAgB,kBACZ,qBAAqB,GAAG,QACxB,cAAc,GAAG,QAAQ,oBAAoB;AArBE;;;;;;;;;KAmC1D,oBAtBW,CAAA,CAAA,EAAA,aAsB0B,aAtB1B,CAsBwC,WAtBxC,CAsBoD,CAtBpD,CAAA,CAAA,CAAA,GAwBZ,IAxBY,CAyBZ,CAzBY,EA4BZ,OA5BY,CA6BR,YA7BQ,CA6BK,UA7BL,CA6BgB,IA7BhB,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,GA8BR,YA9BQ,CA8BK,UA9BL,CA8BgB,IA9BhB,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,UAAA,CAAA,EAAA,MA+BJ,CA/BI,CAAA,CAAA,GAmCZ,OAnCY,CAoCV,IApCU,CAqCR,CArCQ,EAwCR,OAxCQ,CAyCJ,YAzCI,CAyCS,UAzCT,CAyCoB,IAzCpB,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,OAAA,CAAA,GA2CJ,UA3CI,CA2CO,IA3CP,CAAA,CAAA,UAAA,CAAA,CAAA,MAAA,CAAA,GA4CJ,UA5CI,CA4CO,IA5CP,CAAA,CAAA,MAAA,CAAA,GA6CJ,YA7CI,CA6CS,UA7CT,CA6CoB,IA7CpB,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,OAAA,CAAA,EAAA,MA8CA,CA9CA,CAAA,CAAA,CAAA;;;;;;;;KA0DX,YAlDyB,CAAA,CAAA,EAAA,WAAA,KAAA,EAAA,QAAA,KAAA,CAAA,GAkD0B,CAlD1B,SAAA,SAAA,MAAW,KAAA,KAAoB,KAAA,KAAA,IAsDzD,OAtD6B,CAsDrB,IAtDqB,CAAA,SAAA,IAAA,GAuD3B,YAvD2B,CAuDd,IAvDc,EAuDR,QAvDQ,EAuDE,KAvDF,GAuDU,IAvDV,CAAA,GAwD3B,YAxD2B,CAwDd,IAxDc,EAwDR,QAxDQ,GAwDG,IAxDH,EAwDS,KAxDT,CAAA,GAAA;UAAjB,EAyDA,QAzDA;OAHN,EA4DuB,KA5DvB;CAAQ;AAAA;;;;;;;;;;;KAyEb,aAhDG,CAAA,CAAA,EAAA,aAAA,MAgDiC,CAhDjC,CAAA,GAgDsC,SAhDtC,CAgDgD,IAhDhD,CAAA,SAAA,IAAA,GAgDqE,OAhDrE,CAgD6E,IAhD7E,CAgDkF,CAhDlF,EAgDqF,IAhDrF,CAAA,CAAA,GAgD8F,IAhD9F,CAgDmG,CAhDnG,EAgDsG,IAhDtG,CAAA;;;;;;;;;;;AAcI,iBA8CI,IA9CJ,CAAA,UAAA,MAAA,EAAA,mBAgDS,aAhDT,CAgDuB,WAhDvB,CAgDmC,CAhDnC,CAAA,CAAA,CAAA,CAAA,IAAA,EAiDJ,IAjDI,CAAA,EAAA,CAAA,IAAA,EAiDU,CAjDV,EAAA,GAiDgB,aAjDhB,CAiD8B,CAjD9B,EAiDiC,IAjDjC,CAAA;;;;;;;;;AATD;;;AA2BC,iBA4CI,IA5CJ,CAAA,UAAA,MAAA,EAAA,mBA8CS,aA9CT,CA8CuB,WA9CvB,CA8CmC,CA9CnC,CAAA,CAAA,CAAA,CAAA,IAAA,EA+CJ,CA/CI,EAAA,IAAA,EA+CK,IA/CL,CAAA,EA+CY,aA/CZ,CA+C0B,CA/C1B,EA+C6B,IA/C7B,CAAA"}

package/dist/pick-by-BuU3hu7X.d.ts

@@ -0,0 +1,68 @@
+import { IsBoundedRecord } from "./is-bounded-record-DEQ2a3_Y.js";
+import { ToString } from "./to-string-B9YWszXY.js";
+import { EnumerableStringKeyOf } from "./enumerable-string-key-of-nnI9DYHk.js";
+import { EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-D0kMm_yz.js";
+import { IsNever, Simplify } from "type-fest";
+
+//#region src/pick-by.d.ts
+type EnumeratedPartial<T> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? { -readonly [P in keyof T as ToString<P>]?: Required<T>[P] } : Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>> : never;
+type EnumeratedPartialNarrowed<T, S> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? ExactProps<T, S> & PartialProps<T, S> : Record<EnumerableStringKeyOf<T>, Extract<EnumerableStringKeyedValueOf<T>, S>>> : never;
+type ExactProps<T, S> = { -readonly [P in keyof T as ToString<IsExactProp<T, P, S> extends true ? P : never>]: Extract<Required<T>[P], S> };
+type PartialProps<T, S> = { -readonly [P in keyof T as ToString<IsPartialProp<T, P, S> extends true ? P : never>]?: IsNever<Extract<T[P], S>> extends true ? S extends T[P] ? S : never : Extract<T[P], S> };
+type IsExactProp<T, P extends keyof T, S> = T[P] extends Extract<T[P], S> ? true : false;
+type IsPartialProp<T, P extends keyof T, S> = IsExactProp<T, P, S> extends true ? false : IsNever<Extract<T[P], S>> extends true ? S extends T[P] ? true : false : true;
+/**
+ * Iterates over the entries of `data` and reconstructs the object using only
+ * entries that `predicate` accepts. Symbol keys are not passed to the predicate
+ * and would be filtered out from the output object.
+ *
+ * See `omitBy` for a complementary function which starts with a shallow copy of
+ * the input object and removes the entries that the predicate rejects. Because
+ * it is subtractive symbol keys would be copied over to the output object.
+ * See also `entries`, `filter`, and `fromEntries` which could be used to build
+ * your own version of `pickBy` if you need more control (though the resulting
+ * type might be less precise).
+ *
+ * @param data - The target object.
+ * @param predicate - A function that takes the value, key, and the data itself
+ * and returns true if the entry should be part of the output object, or `false`
+ * to remove it. If the function is a type-guard on the value the output type
+ * would be narrowed accordingly.
+ * @returns A shallow copy of the input object with the rejected entries
+ * removed.
+ * @signature P.pickBy(data, predicate)
+ * @example
+ *    P.pickBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {A: 3, B: 4}
+ * @dataFirst
+ * @category Object
+ */
+declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): EnumeratedPartialNarrowed<T, S>;
+declare function pickBy<T extends object>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): EnumeratedPartial<T>;
+/**
+ * Iterates over the entries of `data` and reconstructs the object using only
+ * entries that `predicate` accepts. Symbol keys are not passed to the predicate
+ * and would be filtered out from the output object.
+ *
+ * See `omitBy` for a complementary function which starts with a shallow copy of
+ * the input object and removes the entries that the predicate rejects. Because
+ * it is subtractive symbol keys would be copied over to the output object.
+ * See also `entries`, `filter`, and `fromEntries` which could be used to build
+ * your own version of `pickBy` if you need more control (though the resulting
+ * type might be less precise).
+ *
+ * @param predicate - A function that takes the value, key, and the data itself
+ * and returns true if the entry should be part of the output object, or `false`
+ * to remove it. If the function is a type-guard on the value the output type
+ * would be narrowed accordingly.
+ * @signature
+ *   P.pickBy(predicate)(data)
+ * @example
+ *    P.pipe({a: 1, b: 2, A: 3, B: 4}, pickBy((val, key) => key.toUpperCase() === key)); // => {A: 3, B: 4}
+ * @dataLast
+ * @category Object
+ */
+declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): (data: T) => EnumeratedPartialNarrowed<T, S>;
+declare function pickBy<T extends object>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): (data: T) => EnumeratedPartial<T>;
+//#endregion
+export { pickBy };
+//# sourceMappingURL=pick-by-BuU3hu7X.d.ts.map

package/dist/pick-by-BuU3hu7X.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-by-BuU3hu7X.d.ts","names":[],"sources":["../src/pick-by.ts"],"sourcesContent":[],"mappings":";;;;;;;KAUK,uBAAuB,oBACxB,SACE,gBAAgB,0CAGY,KAAK,SAAS,MAAM,SAAS,GAAG,IAXP,GAmBjD,MAbL,CAaY,qBAbK,CAaiB,CAbjB,CAAA,EAaqB,4BAbrB,CAakD,CAblD,CAAA,CAAA,CAAA,GAAA,KAAA;KA2BjB,yBA3BiB,CAAA,CAAA,EAAA,CAAA,CAAA,GA2BiB,CA3BjB,SAAA,OAAA,GA4BlB,QA5BkB,CA6BhB,eA7BgB,CA6BA,CA7BA,CAAA,SAAA,IAAA,GA8BZ,UA9BY,CA8BD,CA9BC,EA8BE,CA9BF,CAAA,GA8BO,YA9BP,CA8BoB,CA9BpB,EA8BuB,CA9BvB,CAAA,GAmCZ,MAnCY,CAoCV,qBApCU,CAoCY,CApCZ,CAAA,EAqCV,OArCU,CAqCF,4BArCE,CAqC2B,CArC3B,CAAA,EAqC+B,CArC/B,CAAA,CAAA,CAAA,GAAA,KAAA;KA2CjB,UA3CuB,CAAA,CAAA,EAAA,CAAA,CAAA,GAAA,kBAEN,MA2CE,CA3CF,IA2CO,QA3CP,CA4ClB,WA5CkB,CA4CN,CA5CM,EA4CH,CA5CG,EA4CA,CA5CA,CAAA,SAAA,IAAA,GA4CkB,CA5ClB,GAAA,KAAA,CAAA,GA6ChB,OA7CgB,CA6CR,QA7CQ,CA6CC,CA7CD,CAAA,CA6CI,CA7CJ,CAAA,EA6CQ,CA7CR,CAAA;KAkDjB,YA/C6B,CAAA,CAAA,EAAA,CAAA,CAAA,GAAA,kBAAc,MAiDxB,CAjDwB,IAiDnB,QAjDmB,CAkD5C,aAlD4C,CAkD9B,CAlD8B,EAkD3B,CAlD2B,EAkDxB,CAlDwB,CAAA,SAAA,IAAA,GAkDN,CAlDM,GAAA,KAAA,CAAA,IAmDzC,OAnDyC,CAmDjC,OAnDiC,CAmDzB,CAnDyB,CAmDvB,CAnDuB,CAAA,EAmDnB,CAnDmB,CAAA,CAAA,SAAA,IAAA,GAyD1C,CAzD0C,SAyDhC,CAzDgC,CAyD9B,CAzD8B,CAAA,GA0DxC,CA1DwC,GAAA,KAAA,GA4D1C,OA5D0C,CA4DlC,CA5DkC,CA4DhC,CA5DgC,CAAA,EA4D5B,CA5D4B,CAAA;KAkE3C,WAlE0D,CAAA,CAAA,EAAA,UAAA,MAkE3B,CAlE2B,EAAA,CAAA,CAAA,GAmE3D,CAnE2D,CAmEzD,CAnEyD,CAAA,SAmE9C,OAnE8C,CAmEtC,CAnEsC,CAmEpC,CAnEoC,CAAA,EAmEhC,CAnEgC,CAAA,GAAA,IAAA,GAAA,KAAA;KA0E1D,aA1EiD,CAAA,CAAA,EAAA,UAAA,MA0EhB,CA1EgB,EAAA,CAAA,CAAA,GA2ElD,WA3EkD,CA2EtC,CA3EsC,EA2EnC,CA3EmC,EA2EhC,CA3EgC,CAAA,SAAA,IAAA,GAAA,KAAA,GA6EhD,OA7EgD,CA6ExC,OA7EwC,CA6EhC,CA7EgC,CA6E9B,CA7E8B,CAAA,EA6E1B,CA7E0B,CAAA,CAAA,SAAA,IAAA,GA8E9C,CA9E8C,SA8EpC,CA9EoC,CA8ElC,CA9EkC,CAAA,GAAA,IAAA,GAAA,KAAA,GAAA,IAAA;;;;;;;;;AAJ1C;;;;;;;;;;;;;;;;;AAkCF,iBAmFM,MAnFN,CAAA,UAAA,MAAA,EAAA,UAqFE,4BArFF,CAqF+B,CArF/B,CAAA,CAAA,CAAA,IAAA,EAuFF,CAvFE,EAAA,SAAA,EAAA,CAAA,KAAA,EAyFC,4BAzFD,CAyF8B,CAzF9B,CAAA,EAAA,GAAA,EA0FD,qBA1FC,CA0FqB,CA1FrB,CAAA,EAAA,IAAA,EA2FA,CA3FA,EAAA,GAAA,KAAA,IA4FM,CA5FN,CAAA,EA6FP,yBA7FO,CA6FmB,CA7FnB,EA6FsB,CA7FtB,CAAA;AAPN,iBAqGY,MArGZ,CAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAsGI,CAtGJ,EAAA,SAAA,EAAA,CAAA,KAAA,EAwGO,4BAxGP,CAwGoC,CAxGpC,CAAA,EAAA,GAAA,EAyGK,qBAzGL,CAyG2B,CAzG3B,CAAA,EAAA,IAAA,EA0GM,CA1GN,EAAA,GAAA,OAAA,CAAA,EA4GD,iBA5GC,CA4GiB,CA5GjB,CAAA;;AAAQ;;;;;;;;;;;;;;;AAmBC;;;;;;;AAQ6B,iBA0G1B,MA1G0B,CAAA,UAAA,MAAA,EAAA,UA4G9B,4BA5G8B,CA4GD,CA5GC,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EA+G/B,4BA/G+B,CA+GF,CA/GE,CAAA,EAAA,GAAA,EAgHjC,qBAhHiC,CAgHX,CAhHW,CAAA,EAAA,IAAA,EAiHhC,CAjHgC,EAAA,GAAA,KAAA,IAkH1B,CAlH0B,CAAA,EAAA,CAAA,IAAA,EAmHhC,CAnHgC,EAAA,GAmH1B,yBAnH0B,CAmHA,CAnHA,EAmHG,CAnHH,CAAA;AADb,iBAqHb,MArHa,CAAA,UAAA,MAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAuHlB,4BAvHkB,CAuHW,CAvHX,CAAA,EAAA,GAAA,EAwHpB,qBAxHoB,CAwHE,CAxHF,CAAA,EAAA,IAAA,EAyHnB,CAzHmB,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EA2HnB,CA3HmB,EAAA,GA2Hb,iBA3Ha,CA2HK,CA3HL,CAAA"}

package/dist/pick-by-CKRuN-_s.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e))t(i,r,e)&&(n[r]=i);return n}Object.defineProperty(exports,`pickBy`,{enumerable:!0,get:function(){return t}});

package/dist/pick-by-CM_x6iCC.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e))t(i,r,e)&&(n[r]=i);return n}export{t as pickBy};
+//# sourceMappingURL=pick-by-CM_x6iCC.js.map

package/dist/pick-by-CM_x6iCC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-by-CM_x6iCC.js","names":["out: Partial<Record<string, unknown>>"],"sources":["../src/pick-by.ts"],"sourcesContent":["import type { IsNever, Simplify } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IsBoundedRecord } from './internal/types/is-bounded-record';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\n// When the predicate isn't a type-guard we don't know which properties would be\n// part of the output and which wouldn't so we can only safely downgrade the\n// whole object to a Partial of the input.\ntype EnumeratedPartial<T> = T extends unknown\n  ? Simplify<\n      IsBoundedRecord<T> extends true\n        ? {\n            // Object.entries returns keys as strings.\n            -readonly [P in keyof T as ToString<P>]?: Required<T>[P];\n          }\n        // For unbounded records (a simple Record with primitive `string` or\n        // `number` keys) the return type here could technically be T; but for\n        // cases where the record is unbounded but is more complex (like\n        // `symbol` keys) we want to \"reconstruct\" the record from just its\n        // enumerable components (which are the ones accessible via\n        // `Object.entries`).\n        : Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>\n    >\n  : never;\n\n// When the predicate is a type-guard we have more information to work with when\n// constructing the type of the output object. We can safely remove any property\n// which value would never come up true for the predicate, AND we can also\n// assume that properties that match the predicate perfectly would **always**\n// show up in the output object. Hence to build the output object we need to\n// build and merge 2 output objects: One for the properties which have a value\n// of at type that would always yield a `true` result from the predicate, these\n// are the \"matches\", which would not change the \"optionality\" of the input\n// object's props, and one for partial matches which would also make the props\n// optional (as they could have a value that would be filtered out).\ntype EnumeratedPartialNarrowed<T, S> = T extends unknown\n  ? Simplify<\n      IsBoundedRecord<T> extends true\n        ? ExactProps<T, S> & PartialProps<T, S>\n        // For unbounded records we need to \"reconstruct\" the record and\n        // narrow the value types. Similar to the non-narrowed case, we need\n        // to also ignore `symbol` keys and any values that are only relevant\n        // to them.\n        : Record<\n            EnumerableStringKeyOf<T>,\n            Extract<EnumerableStringKeyedValueOf<T>, S>\n          >\n    >\n  : never;\n\n// The exact case, props here would always be part of the output object\ntype ExactProps<T, S> = {\n  // Object.entries returns keys as strings.\n  -readonly [P in keyof T as ToString<\n    IsExactProp<T, P, S> extends true ? P : never\n  >]: Extract<Required<T>[P], S>;\n};\n\n// The partial case, props here might be part of the output object, but might\n// not be, hence they are optional.\ntype PartialProps<T, S> = {\n  // Object.entries returns keys as strings.\n  -readonly [P in keyof T as ToString<\n    IsPartialProp<T, P, S> extends true ? P : never\n  >]?: IsNever<Extract<T[P], S>> extends true\n    // If the result of extracting S from T[P] is never but S still extends\n    // it, it means that T[P] is too wide and S can't be extracted from it:\n    // e.g. if T[P] is `number` S is `1` then `Extract<number, 1> === never`.\n    // For these cases we can return S directly as the type as it's already\n    // very narrowed compared to T[P].\n    ? S extends T[P]\n      ? S\n      : never\n    : Extract<T[P], S>;\n};\n\n// If the input object's value type extends itself when the type-guard is\n// extracted from it we can safely assume that the predicate would always return\n// true for any value of that property.\ntype IsExactProp<T, P extends keyof T, S>\n  = T[P] extends Extract<T[P], S> ? true : false;\n\n// ...and if the input object's value type isn't an exact match, but still has\n// some partial match (i.g. the extracted type-guard isn't completely disjoint)\n// then we can assume that the property can sometimes return true, and sometimes\n// false when passed to the predicate, hence it should be optional in the\n// output.\ntype IsPartialProp<T, P extends keyof T, S>\n  = IsExactProp<T, P, S> extends true\n    ? false\n    : IsNever<Extract<T[P], S>> extends true\n      ? S extends T[P]\n        // If the result of extracting S from T[P] is never but S still\n        // extends it, it means that T[P] is too wide and S can't be\n        // extracted from it: e.g. if T[P] is `number` S is `1` then\n        // `Extract<number, 1> === never`, but `1` extends `number`. We need\n        // to handle these cases when we extract the value too (see above).\n        ? true\n        : false\n      : true;\n\n/**\n * Iterates over the entries of `data` and reconstructs the object using only\n * entries that `predicate` accepts. Symbol keys are not passed to the predicate\n * and would be filtered out from the output object.\n *\n * See `omitBy` for a complementary function which starts with a shallow copy of\n * the input object and removes the entries that the predicate rejects. Because\n * it is subtractive symbol keys would be copied over to the output object.\n * See also `entries`, `filter`, and `fromEntries` which could be used to build\n * your own version of `pickBy` if you need more control (though the resulting\n * type might be less precise).\n *\n * @param data - The target object.\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns true if the entry should be part of the output object, or `false`\n * to remove it. If the function is a type-guard on the value the output type\n * would be narrowed accordingly.\n * @returns A shallow copy of the input object with the rejected entries\n * removed.\n * @signature P.pickBy(data, predicate)\n * @example\n *    P.pickBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {A: 3, B: 4}\n * @dataFirst\n * @category Object\n */\nexport function pickBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): EnumeratedPartialNarrowed<T, S>;\nexport function pickBy<T extends object>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): EnumeratedPartial<T>;\n\n/**\n * Iterates over the entries of `data` and reconstructs the object using only\n * entries that `predicate` accepts. Symbol keys are not passed to the predicate\n * and would be filtered out from the output object.\n *\n * See `omitBy` for a complementary function which starts with a shallow copy of\n * the input object and removes the entries that the predicate rejects. Because\n * it is subtractive symbol keys would be copied over to the output object.\n * See also `entries`, `filter`, and `fromEntries` which could be used to build\n * your own version of `pickBy` if you need more control (though the resulting\n * type might be less precise).\n *\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns true if the entry should be part of the output object, or `false`\n * to remove it. If the function is a type-guard on the value the output type\n * would be narrowed accordingly.\n * @signature\n *   P.pickBy(predicate)(data)\n * @example\n *    P.pipe({a: 1, b: 2, A: 3, B: 4}, pickBy((val, key) => key.toUpperCase() === key)); // => {A: 3, B: 4}\n * @dataLast\n * @category Object\n */\nexport function pickBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): (data: T) => EnumeratedPartialNarrowed<T, S>;\nexport function pickBy<T extends object>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): (data: T) => EnumeratedPartial<T>;\n\nexport function pickBy(...args: ReadonlyArray<unknown>): unknown {\n  return curry(pickByImplementation, args);\n}\n\nfunction pickByImplementation<T extends object>(\n  data: T,\n  predicate: (value: unknown, key: string, data: T) => boolean,\n): Record<string, unknown> {\n  const out: Partial<Record<string, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    if (predicate(value, key, data)) {\n      out[key] = value;\n    }\n  }\n\n  return out;\n}\n"],"mappings":"4CA6LA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACyB,CACzB,IAAMA,EAAwC,EAAE,CAEhD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CACzC,EAAU,EAAO,EAAK,EAAK,GAC7B,EAAI,GAAO,GAIf,OAAO"}

package/dist/pick-by-WPJjBk-W.d.cts

@@ -0,0 +1,68 @@
+import { IsBoundedRecord } from "./is-bounded-record-kpsb1wQA.cjs";
+import { ToString } from "./to-string-gK5yUyfp.cjs";
+import { EnumerableStringKeyOf } from "./enumerable-string-key-of-D2OpyD6n.cjs";
+import { EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-aov5dXss.cjs";
+import { IsNever, Simplify } from "type-fest";
+
+//#region src/pick-by.d.ts
+type EnumeratedPartial<T> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? { -readonly [P in keyof T as ToString<P>]?: Required<T>[P] } : Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>> : never;
+type EnumeratedPartialNarrowed<T, S> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? ExactProps<T, S> & PartialProps<T, S> : Record<EnumerableStringKeyOf<T>, Extract<EnumerableStringKeyedValueOf<T>, S>>> : never;
+type ExactProps<T, S> = { -readonly [P in keyof T as ToString<IsExactProp<T, P, S> extends true ? P : never>]: Extract<Required<T>[P], S> };
+type PartialProps<T, S> = { -readonly [P in keyof T as ToString<IsPartialProp<T, P, S> extends true ? P : never>]?: IsNever<Extract<T[P], S>> extends true ? S extends T[P] ? S : never : Extract<T[P], S> };
+type IsExactProp<T, P extends keyof T, S> = T[P] extends Extract<T[P], S> ? true : false;
+type IsPartialProp<T, P extends keyof T, S> = IsExactProp<T, P, S> extends true ? false : IsNever<Extract<T[P], S>> extends true ? S extends T[P] ? true : false : true;
+/**
+ * Iterates over the entries of `data` and reconstructs the object using only
+ * entries that `predicate` accepts. Symbol keys are not passed to the predicate
+ * and would be filtered out from the output object.
+ *
+ * See `omitBy` for a complementary function which starts with a shallow copy of
+ * the input object and removes the entries that the predicate rejects. Because
+ * it is subtractive symbol keys would be copied over to the output object.
+ * See also `entries`, `filter`, and `fromEntries` which could be used to build
+ * your own version of `pickBy` if you need more control (though the resulting
+ * type might be less precise).
+ *
+ * @param data - The target object.
+ * @param predicate - A function that takes the value, key, and the data itself
+ * and returns true if the entry should be part of the output object, or `false`
+ * to remove it. If the function is a type-guard on the value the output type
+ * would be narrowed accordingly.
+ * @returns A shallow copy of the input object with the rejected entries
+ * removed.
+ * @signature P.pickBy(data, predicate)
+ * @example
+ *    P.pickBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {A: 3, B: 4}
+ * @dataFirst
+ * @category Object
+ */
+declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): EnumeratedPartialNarrowed<T, S>;
+declare function pickBy<T extends object>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): EnumeratedPartial<T>;
+/**
+ * Iterates over the entries of `data` and reconstructs the object using only
+ * entries that `predicate` accepts. Symbol keys are not passed to the predicate
+ * and would be filtered out from the output object.
+ *
+ * See `omitBy` for a complementary function which starts with a shallow copy of
+ * the input object and removes the entries that the predicate rejects. Because
+ * it is subtractive symbol keys would be copied over to the output object.
+ * See also `entries`, `filter`, and `fromEntries` which could be used to build
+ * your own version of `pickBy` if you need more control (though the resulting
+ * type might be less precise).
+ *
+ * @param predicate - A function that takes the value, key, and the data itself
+ * and returns true if the entry should be part of the output object, or `false`
+ * to remove it. If the function is a type-guard on the value the output type
+ * would be narrowed accordingly.
+ * @signature
+ *   P.pickBy(predicate)(data)
+ * @example
+ *    P.pipe({a: 1, b: 2, A: 3, B: 4}, pickBy((val, key) => key.toUpperCase() === key)); // => {A: 3, B: 4}
+ * @dataLast
+ * @category Object
+ */
+declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): (data: T) => EnumeratedPartialNarrowed<T, S>;
+declare function pickBy<T extends object>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): (data: T) => EnumeratedPartial<T>;
+//#endregion
+export { pickBy };
+//# sourceMappingURL=pick-by-WPJjBk-W.d.cts.map

package/dist/pick-by-WPJjBk-W.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-by-WPJjBk-W.d.cts","names":[],"sources":["../src/pick-by.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/pick-by.cjs

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

package/dist/pick-by.d.cts

@@ -1,72 +1,6 @@
-import { Simplify, IfNever } from 'type-fest';
-import { E as EnumerableStringKeyOf } from './enumerable-string-key-of-D8w_3Yg8.cjs';
-import { E as EnumerableStringKeyedValueOf } from './enumerable-string-keyed-value-of-BU9R_cEk.cjs';
-import { I as IsBoundedRecord } from './is-bounded-record-C9WAwfA8.cjs';
-import { T as ToString } from './to-string-DO8zw6jS.cjs';
-
-type EnumeratedPartial<T> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? {
-    -readonly [P in keyof T as ToString<P>]?: Required<T>[P];
-} : Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>> : never;
-type EnumeratedPartialNarrowed<T, S> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? ExactProps<T, S> & PartialProps<T, S> : Record<EnumerableStringKeyOf<T>, Extract<EnumerableStringKeyedValueOf<T>, S>>> : never;
-type ExactProps<T, S> = {
-    -readonly [P in keyof T as ToString<IsExactProp<T, P, S> extends true ? P : never>]: Extract<Required<T>[P], S>;
-};
-type PartialProps<T, S> = {
-    -readonly [P in keyof T as ToString<IsPartialProp<T, P, S> extends true ? P : never>]?: IfNever<Extract<T[P], S>, S extends T[P] ? S : never, Extract<T[P], S>>;
-};
-type IsExactProp<T, P extends keyof T, S> = T[P] extends Extract<T[P], S> ? true : false;
-type IsPartialProp<T, P extends keyof T, S> = IsExactProp<T, P, S> extends true ? false : IfNever<Extract<T[P], S>, S extends T[P] ? true : false, true>;
-/**
- * Iterates over the entries of `data` and reconstructs the object using only
- * entries that `predicate` accepts. Symbol keys are not passed to the predicate
- * and would be filtered out from the output object.
- *
- * See `omitBy` for a complementary function which starts with a shallow copy of
- * the input object and removes the entries that the predicate rejects. Because
- * it is subtractive symbol keys would be copied over to the output object.
- * See also `entries`, `filter`, and `fromEntries` which could be used to build
- * your own version of `pickBy` if you need more control (though the resulting
- * type might be less precise).
- *
- * @param data - The target object.
- * @param predicate - A function that takes the value, key, and the data itself
- * and returns true if the entry should be part of the output object, or `false`
- * to remove it. If the function is a type-guard on the value the output type
- * would be narrowed accordingly.
- * @returns A shallow copy of the input object with the rejected entries
- * removed.
- * @signature P.pickBy(data, predicate)
- * @example
- *    P.pickBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {A: 3, B: 4}
- * @dataFirst
- * @category Object
- */
-declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): EnumeratedPartialNarrowed<T, S>;
-declare function pickBy<T extends object>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): EnumeratedPartial<T>;
-/**
- * Iterates over the entries of `data` and reconstructs the object using only
- * entries that `predicate` accepts. Symbol keys are not passed to the predicate
- * and would be filtered out from the output object.
- *
- * See `omitBy` for a complementary function which starts with a shallow copy of
- * the input object and removes the entries that the predicate rejects. Because
- * it is subtractive symbol keys would be copied over to the output object.
- * See also `entries`, `filter`, and `fromEntries` which could be used to build
- * your own version of `pickBy` if you need more control (though the resulting
- * type might be less precise).
- *
- * @param predicate - A function that takes the value, key, and the data itself
- * and returns true if the entry should be part of the output object, or `false`
- * to remove it. If the function is a type-guard on the value the output type
- * would be narrowed accordingly.
- * @signature
- *   P.pickBy(predicate)(data)
- * @example
- *    P.pipe({a: 1, b: 2, A: 3, B: 4}, pickBy((val, key) => key.toUpperCase() === key)); // => {A: 3, B: 4}
- * @dataLast
- * @category Object
- */
-declare function pickBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): (data: T) => EnumeratedPartialNarrowed<T, S>;
-declare function pickBy<T extends object>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): (data: T) => EnumeratedPartial<T>;
-
-export { pickBy };
+import "./is-bounded-record-kpsb1wQA.cjs";
+import "./to-string-gK5yUyfp.cjs";
+import "./enumerable-string-key-of-D2OpyD6n.cjs";
+import "./enumerable-string-keyed-value-of-aov5dXss.cjs";
+import { pickBy } from "./pick-by-WPJjBk-W.cjs";
+export { pickBy };