@vinicunca/perkakas 0.5.4 → 1.0.1

package/dist/only.d.cts

@@ -0,0 +1,33 @@
+import { I as IterableContainer } from './types-BMu1PIvo.cjs';
+import 'type-fest';
+
+type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown, unknown] | readonly [] | readonly [unknown, ...Array<unknown>, unknown] | readonly [unknown, unknown, ...Array<unknown>] ? undefined : T extends readonly [unknown] ? T[number] : T[number] | undefined;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ *
+ * @param array - The target array.
+ * @signature
+ *    P.only(array)
+ * @example
+ *    P.only([]) // => undefined
+ *    P.only([1]) // => 1
+ *    P.only([1, 2]) // => undefined
+ * @dataFirst
+ * @category Array
+ */
+declare function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ *
+ * @signature
+ *    P.only()(array)
+ * @example
+ *    P.pipe([], P.only()); // => undefined
+ *    P.pipe([1], P.only()); // => 1
+ *    P.pipe([1, 2], P.only()); // => undefined
+ * @dataLast
+ * @category Array
+ */
+declare function only<T extends IterableContainer>(): (array: Readonly<T>) => Only<T>;
+
+export { only };

package/dist/only.d.ts

@@ -0,0 +1,33 @@
+import { I as IterableContainer } from './types-BMu1PIvo.js';
+import 'type-fest';
+
+type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown, unknown] | readonly [] | readonly [unknown, ...Array<unknown>, unknown] | readonly [unknown, unknown, ...Array<unknown>] ? undefined : T extends readonly [unknown] ? T[number] : T[number] | undefined;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ *
+ * @param array - The target array.
+ * @signature
+ *    P.only(array)
+ * @example
+ *    P.only([]) // => undefined
+ *    P.only([1]) // => 1
+ *    P.only([1, 2]) // => undefined
+ * @dataFirst
+ * @category Array
+ */
+declare function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ *
+ * @signature
+ *    P.only()(array)
+ * @example
+ *    P.pipe([], P.only()); // => undefined
+ *    P.pipe([1], P.only()); // => 1
+ *    P.pipe([1, 2], P.only()); // => undefined
+ * @dataLast
+ * @category Array
+ */
+declare function only<T extends IterableContainer>(): (array: Readonly<T>) => Only<T>;
+
+export { only };

package/dist/only.js

@@ -0,0 +1 @@
+import{a}from"./chunk-VNU4MGEF.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as only};

package/dist/partition.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkTA5NVANUcjs = require('./chunk-TA5NVANU.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.partition = _chunkTA5NVANUcjs.a;

package/dist/partition.d.cts

@@ -0,0 +1,49 @@
+/**
+ * Splits a collection into two groups, the first of which contains elements the
+ * `predicate` type guard passes, and the second one containing the rest.
+ *
+ * @param data - The items to split.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to add the element to the first partition, and and
+ * `false` to add the element to the other partition. A type-predicate can also
+ * be used to narrow the result.
+ * @returns A 2-tuple of arrays where the first array contains the elements that
+ * passed the predicate, and the second array contains the elements that did
+ * not. The items are in the same order as they were in the original array.
+ * @signature
+ *    P.partition(data, predicate)
+ * @example
+ *    P.partition(
+ *      ['one', 'two', 'forty two'],
+ *      x => x.length === 3,
+ *    ); // => [['one', 'two'], ['forty two']]
+ * @dataFirst
+ * @category Array
+ */
+declare function partition<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): [Array<S>, Array<Exclude<T, S>>];
+declare function partition<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the
+ * `predicate` type guard passes, and the second one containing the rest.
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to add the element to the first partition, and and
+ * `false` to add the element to the other partition. A type-predicate can also
+ * be used to narrow the result.
+ * @returns A 2-tuple of arrays where the first array contains the elements that
+ * passed the predicate, and the second array contains the elements that did
+ * not. The items are in the same order as they were in the original array.
+ * @signature
+ *    P.partition(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      ['one', 'two', 'forty two'],
+ *      P.partition(x => x.length === 3),
+ *    ); // => [['one', 'two'], ['forty two']]
+ * @dataLast
+ * @category Array
+ */
+declare function partition<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];
+declare function partition<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => [Array<T>, Array<T>];
+
+export { partition };

package/dist/partition.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Splits a collection into two groups, the first of which contains elements the
+ * `predicate` type guard passes, and the second one containing the rest.
+ *
+ * @param data - The items to split.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to add the element to the first partition, and and
+ * `false` to add the element to the other partition. A type-predicate can also
+ * be used to narrow the result.
+ * @returns A 2-tuple of arrays where the first array contains the elements that
+ * passed the predicate, and the second array contains the elements that did
+ * not. The items are in the same order as they were in the original array.
+ * @signature
+ *    P.partition(data, predicate)
+ * @example
+ *    P.partition(
+ *      ['one', 'two', 'forty two'],
+ *      x => x.length === 3,
+ *    ); // => [['one', 'two'], ['forty two']]
+ * @dataFirst
+ * @category Array
+ */
+declare function partition<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): [Array<S>, Array<Exclude<T, S>>];
+declare function partition<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the
+ * `predicate` type guard passes, and the second one containing the rest.
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to add the element to the first partition, and and
+ * `false` to add the element to the other partition. A type-predicate can also
+ * be used to narrow the result.
+ * @returns A 2-tuple of arrays where the first array contains the elements that
+ * passed the predicate, and the second array contains the elements that did
+ * not. The items are in the same order as they were in the original array.
+ * @signature
+ *    P.partition(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      ['one', 'two', 'forty two'],
+ *      P.partition(x => x.length === 3),
+ *    ); // => [['one', 'two'], ['forty two']]
+ * @dataLast
+ * @category Array
+ */
+declare function partition<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];
+declare function partition<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => [Array<T>, Array<T>];
+
+export { partition };

package/dist/partition.js

@@ -0,0 +1 @@
+import{a}from"./chunk-PL6B6X5G.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as partition};

package/dist/path-or.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkJDWB2A3Scjs = require('./chunk-JDWB2A3S.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.pathOr = _chunkJDWB2A3Scjs.a;

package/dist/path-or.d.cts

@@ -0,0 +1,79 @@
+/**
+ * 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.
+ *
+ * @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.
+ *
+ * @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 };

package/dist/path-or.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 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.
+ *
+ * @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.
+ *
+ * @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 };

package/dist/path-or.js

@@ -0,0 +1 @@
+import{a}from"./chunk-D7G6PMA5.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as pathOr};

package/dist/pick-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkGXVKH5OXcjs = require('./chunk-GXVKH5OX.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.pickBy = _chunkGXVKH5OXcjs.a;

package/dist/pick-by.d.cts

@@ -0,0 +1,70 @@
+import { Simplify, IfNever } from 'type-fest';
+import { E as EnumerableStringKeyedValueOf, a as EnumerableStringKeyOf, e as IfBoundedRecord, R as ReconstructedRecord } from './types-BMu1PIvo.cjs';
+
+type EnumerableKey<T> = `${T extends number | string ? T : never}`;
+type EnumeratedPartial<T> = T extends unknown ? Simplify<IfBoundedRecord<T, {
+    -readonly [P in keyof T as EnumerableKey<P>]?: Required<T>[P];
+}, ReconstructedRecord<T>>> : never;
+type EnumeratedPartialNarrowed<T, S> = Simplify<ExactProps<T, S> & PartialProps<T, S>>;
+type ExactProps<T, S> = {
+    -readonly [P in keyof T as EnumerableKey<IsExactProp<T, P, S> extends true ? P : never>]: Extract<Required<T>[P], S>;
+};
+type PartialProps<T, S> = {
+    -readonly [P in keyof T as EnumerableKey<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 };

package/dist/pick-by.d.ts

@@ -0,0 +1,70 @@
+import { Simplify, IfNever } from 'type-fest';
+import { E as EnumerableStringKeyedValueOf, a as EnumerableStringKeyOf, e as IfBoundedRecord, R as ReconstructedRecord } from './types-BMu1PIvo.js';
+
+type EnumerableKey<T> = `${T extends number | string ? T : never}`;
+type EnumeratedPartial<T> = T extends unknown ? Simplify<IfBoundedRecord<T, {
+    -readonly [P in keyof T as EnumerableKey<P>]?: Required<T>[P];
+}, ReconstructedRecord<T>>> : never;
+type EnumeratedPartialNarrowed<T, S> = Simplify<ExactProps<T, S> & PartialProps<T, S>>;
+type ExactProps<T, S> = {
+    -readonly [P in keyof T as EnumerableKey<IsExactProp<T, P, S> extends true ? P : never>]: Extract<Required<T>[P], S>;
+};
+type PartialProps<T, S> = {
+    -readonly [P in keyof T as EnumerableKey<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 };

package/dist/pick-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-LWPEZ7RI.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as pickBy};

package/dist/pick.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkE6MBOCICcjs = require('./chunk-E6MBOCIC.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.pick = _chunkE6MBOCICcjs.a;

package/dist/pick.d.cts

@@ -0,0 +1,25 @@
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @param names - The properties 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, K extends keyof T>(names: ReadonlyArray<K>): (object: T) => Pick<T, K>;
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @param object - The target object.
+ * @param names - The properties 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, K extends keyof T>(object: T, names: ReadonlyArray<K>): Pick<T, K>;
+
+export { pick };

package/dist/pick.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @param names - The properties 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, K extends keyof T>(names: ReadonlyArray<K>): (object: T) => Pick<T, K>;
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @param object - The target object.
+ * @param names - The properties 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, K extends keyof T>(object: T, names: ReadonlyArray<K>): Pick<T, K>;
+
+export { pick };

package/dist/pick.js

@@ -0,0 +1 @@
+import{a}from"./chunk-ZUNMUNQT.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as pick};

package/dist/pipe.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkI6VXEY44cjs = require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');exports.pipe = _chunkI6VXEY44cjs.a;

package/dist/pipe.d.cts

@@ -0,0 +1,60 @@
+type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: ReadonlyArray<T>) => LazyResult<R>;
+type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
+interface LazyEmpty {
+    done: boolean;
+    hasMany?: false | undefined;
+    hasNext: false;
+    next?: undefined;
+}
+interface LazyNext<T> {
+    done: boolean;
+    hasMany?: false | undefined;
+    hasNext: true;
+    next: T;
+}
+interface LazyMany<T> {
+    done: boolean;
+    hasMany: true;
+    hasNext: true;
+    next: ReadonlyArray<T>;
+}
+type LazyFn = (value: unknown, index: number, items: ReadonlyArray<unknown>) => LazyResult<unknown>;
+interface LazyMeta {
+    readonly single?: boolean;
+}
+interface LazyDefinition {
+    readonly lazy: LazyMeta & ((...args: any) => LazyFn);
+    readonly lazyArgs: ReadonlyArray<unknown>;
+}
+/**
+ * Perform left-to-right function composition.
+ *
+ * @param value - The initial value.
+ * @param operations - The list of operations to apply.
+ * @signature P.pipe(data, op1, op2, op3)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 3, 4],
+ *      P.map(x => x * 2),
+ *      arr => [arr[0] + arr[1], arr[2] + arr[3]],
+ *    ) // => [6, 14]
+ * @dataFirst
+ * @category Function
+ */
+declare function pipe<A, B>(value: A, op1: (input: A) => B): B;
+declare function pipe<A, B, C>(value: A, op1: (input: A) => B, op2: (input: B) => C): C;
+declare function pipe<A, B, C, D>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D): D;
+declare function pipe<A, B, C, D, E>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E): E;
+declare function pipe<A, B, C, D, E, F>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F): F;
+declare function pipe<A, B, C, D, E, F, G>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G): G;
+declare function pipe<A, B, C, D, E, F, G, H>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H): H;
+declare function pipe<A, B, C, D, E, F, G, H, I>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H, op8: (input: H) => I): I;
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(value: A, op1: (input: A) => B, op2: (input: B) => C, op3: (input: C) => D, op4: (input: D) => E, op5: (input: E) => F, op6: (input: F) => G, op7: (input: G) => H, op8: (input: H) => I, op9: (input: I) => J): J;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K): K;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L): L;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M): M;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N): N;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N, op14: (input: N) => O): O;
+declare function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(value: A, op01: (input: A) => B, op02: (input: B) => C, op03: (input: C) => D, op04: (input: D) => E, op05: (input: E) => F, op06: (input: F) => G, op07: (input: G) => H, op08: (input: H) => I, op09: (input: I) => J, op10: (input: J) => K, op11: (input: K) => L, op12: (input: L) => M, op13: (input: M) => N, op14: (input: N) => O, op15: (input: O) => P): P;
+
+export { type LazyDefinition, type LazyEvaluator, type LazyResult, pipe };