@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/path-or.d.ts

@@ -1,2 +1,87 @@
-import { pathOr } from "./path-or-ld_fRiaZ.js";
-export { pathOr };
+//#region src/path-or.d.ts
+/**
+ * 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$1 extends PropertyKey> = T extends infer I ? K$1 extends keyof I ? I[K$1] : 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>;
+//#endregion
+export { pathOr };
+//# sourceMappingURL=path-or.d.ts.map

package/dist/path-or.d.ts.map

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

package/dist/path-or.js

@@ -1 +1,2 @@
-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};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t,n){let r=e;for(let e of t){if(r==null)break;r=r[e]}return r??n}export{t as pathOr};
+//# sourceMappingURL=path-or.js.map

package/dist/path-or.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-or.js","names":[],"sources":["../src/path-or.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Given a union of indexable types `T`, we derive an indexable type\n * containing all of the keys of each variant of `T`. If a key is\n * present in multiple variants of `T`, then the corresponding type in\n * `Pathable<T>` will be the intersection of all types for that key.\n *\n * @example\n *    type T1 = Pathable<{a: number} | {a: string; b: boolean}>\n *    // {a: number | string; b: boolean}\n *\n *    type T2 = Pathable<{a?: {b: string}}\n *    // {a: {b: string} | undefined}\n *\n *    type T3 = Pathable<{a: string} | number>\n *    // {a: string}\n *\n *    type T4 = Pathable<{a: number} | {a: string} | {b: boolean}>\n *    // {a: number | string; b: boolean}\n *\n * This type lets us answer the questions:\n * - Given some object of type `T`, what keys might this object have?\n * - If this object did happen to have a particular key, what values\n *   might that key have?\n */\ntype Pathable<T> = { [K in AllKeys<T>]: TypesForKey<T, K> };\n\ntype AllKeys<T> = T extends infer I ? keyof I : never;\ntype TypesForKey<T, K extends PropertyKey> = T extends infer I\n  ? K extends keyof I\n    ? I[K]\n    : never\n  : never;\n\n// Like Required<T>, but also removes explicit null and undefined typings */\ntype StrictlyRequired<T> = { [K in keyof T]-?: NonNullable<T[K]> };\n\n/**\n * Given some `A` which is a key of at least one variant of `T`, derive\n * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not\n * null or undefined.\n */\ntype PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<\n  Pathable<T>\n>[A];\n/** All possible options after successfully reaching `T[A]`. */\ntype Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;\n\n/** As `PathValue1`, but for `T[A][B]`. */\ntype PathValue2<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n> = StrictlyRequired<Pathable1<T, A>>[B];\n/** As `Pathable1`, but for `T[A][B]`. */\ntype Pathable2<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n> = Pathable<PathValue2<T, A, B>>;\n\n/** As `PathValue1`, but for `T[A][B][C]`. */\ntype PathValue3<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n> = StrictlyRequired<Pathable2<T, A, B>>[C];\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.\n *\n * Prefer `prop` over this function as it provides better typing and is more\n * flexible when building solutions. To provide a default value using `prop`\n * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)\n * after the call.\n *\n * @param object - The target object.\n * @param path - The path of the property to get.\n * @param defaultValue - The default value.\n * @signature P.pathOr(object, array, defaultValue)\n * @example\n *    P.pathOr({x: 10}, ['y'], 2) // 2\n *    P.pathOr({y: 10}, ['y'], 2) // 10\n * @dataFirst\n * @category Object\n */\nexport function pathOr<T, A extends keyof Pathable<T>>(\n  object: T,\n  path: readonly [A],\n  defaultValue: PathValue1<T, A>,\n): PathValue1<T, A>;\n\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n>(\n  object: T,\n  path: readonly [A, B],\n  defaultValue: PathValue2<T, A, B>,\n): PathValue2<T, A, B>;\n\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n>(\n  object: T,\n  path: readonly [A, B, C],\n  defaultValue: PathValue3<T, A, B, C>,\n): PathValue3<T, A, B, C>;\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.\n *\n * Prefer `prop` over this function as it provides better typing and is more\n * flexible when building solutions. To provide a default value using `prop`\n * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)\n * after the call.\n *\n * @param path - The path of the property to get.\n * @param defaultValue - The default value.\n * @signature P.pathOr(array, defaultValue)(object)\n * @example\n *    P.pipe({x: 10}, P.pathOr(['y'], 2)) // 2\n *    P.pipe({y: 10}, P.pathOr(['y'], 2)) // 10\n * @dataLast\n * @category Object\n */\nexport function pathOr<T, A extends keyof Pathable<T>>(\n  path: readonly [A],\n  defaultValue: PathValue1<T, A>,\n): (object: T) => PathValue1<T, A>;\n\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n>(\n  path: readonly [A, B],\n  defaultValue: PathValue2<T, A, B>,\n): (object: T) => PathValue2<T, A, B>;\n\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n>(\n  path: readonly [A, B, C],\n  defaultValue: PathValue3<T, A, B, C>,\n): (object: T) => PathValue3<T, A, B, C>;\n\nexport function pathOr(...args: ReadonlyArray<unknown>): unknown {\n  return curry(pathOrImplementation, args);\n}\n\nfunction pathOrImplementation(\n  data: unknown,\n  path: ReadonlyArray<PropertyKey>,\n  defaultValue: unknown,\n): unknown {\n  let current = data;\n  for (const prop of path) {\n    if (current === null || current === undefined) {\n      break;\n    }\n    current = (current as Record<PropertyKey, unknown>)[prop];\n  }\n\n  return current ?? defaultValue;\n}\n"],"mappings":"wCA4JA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACA,EACS,CACT,IAAI,EAAU,EACd,IAAK,IAAM,KAAQ,EAAM,CACvB,GAAI,GAAY,KACd,MAEF,EAAW,EAAyC,GAGtD,OAAO,GAAW"}

package/dist/perkakas-type-error-B9ULNhW0.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 as t };
+//# sourceMappingURL=perkakas-type-error-B9ULNhW0.d.ts.map

package/dist/perkakas-type-error-B9ULNhW0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perkakas-type-error-B9ULNhW0.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;;;;AASuB,KATX,iBASW,CAAA,qBAAA,MAAA,EAAA,gBAAA,MAAA,GAAA,MAAA,EAAA,gBAHL,wBAGK,GAAA,CAAA,CAAA,CAAA,GAFnB,MAEmB,CADrB,OACqB,SAAA;EAAkB,IAAA,EAAA,KAAA,EAAA;CACvC,GAAA,CAAA,GAAA,OAF+C,mBAE/C,EAAA,qBADqB,YACrB,MADuC,OACvC,GAAA,EAAA,OAAA,SAAA;EAHE,QAAA,EAAA,KAAA,SAAA;CAAM,GAAA,QAAA,GAAA,KAAA,CAAA"}

package/dist/perkakas-type-error-ClCCHBW1.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 as t };
+//# sourceMappingURL=perkakas-type-error-ClCCHBW1.d.cts.map

package/dist/perkakas-type-error-ClCCHBW1.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perkakas-type-error-ClCCHBW1.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;;;;AASuB,KATX,iBASW,CAAA,qBAAA,MAAA,EAAA,gBAAA,MAAA,GAAA,MAAA,EAAA,gBAHL,wBAGK,GAAA,CAAA,CAAA,CAAA,GAFnB,MAEmB,CADrB,OACqB,SAAA;EAAkB,IAAA,EAAA,KAAA,EAAA;CACvC,GAAA,CAAA,GAAA,OAF+C,mBAE/C,EAAA,qBADqB,YACrB,MADuC,OACvC,GAAA,EAAA,OAAA,SAAA;EAHE,QAAA,EAAA,KAAA,SAAA;CAAM,GAAA,QAAA,GAAA,KAAA,CAAA"}

package/dist/pick-by.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./pick-by-CKRuN-_s.cjs`);exports.pickBy=e.pickBy;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(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}exports.pickBy=t;

package/dist/pick-by.d.cts

@@ -1,6 +1,68 @@
-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 };
+import { t as IsBoundedRecord } from "./is-bounded-record-DV6ZQk9H.cjs";
+import { t as ToString } from "./to-string-DkC3zRUJ.cjs";
+import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-DhcNc5iz.cjs";
+import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-icm2q60J.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$1 extends keyof T, S> = T[P$1] extends Extract<T[P$1], S> ? true : false;
+type IsPartialProp<T, P$1 extends keyof T, S> = IsExactProp<T, P$1, S> extends true ? false : IsNever<Extract<T[P$1], S>> extends true ? S extends T[P$1] ? 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.d.cts.map

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

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

package/dist/pick-by.d.ts

@@ -1,6 +1,68 @@
-import "./is-bounded-record-DEQ2a3_Y.js";
-import "./to-string-B9YWszXY.js";
-import "./enumerable-string-key-of-nnI9DYHk.js";
-import "./enumerable-string-keyed-value-of-D0kMm_yz.js";
-import { pickBy } from "./pick-by-BuU3hu7X.js";
-export { pickBy };
+import { t as IsBoundedRecord } from "./is-bounded-record-Bx4n8QB0.js";
+import { t as ToString } from "./to-string-YIFx2KS6.js";
+import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-CZQf3ld_.js";
+import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-CRlVAvdp.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$1 extends keyof T, S> = T[P$1] extends Extract<T[P$1], S> ? true : false;
+type IsPartialProp<T, P$1 extends keyof T, S> = IsExactProp<T, P$1, S> extends true ? false : IsNever<Extract<T[P$1], S>> extends true ? S extends T[P$1] ? 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.d.ts.map

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

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

package/dist/pick-by.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{pickBy as e}from"./pick-by-CM_x6iCC.js";export{e as pickBy};
+import{t as e}from"./curry-NmniqyJ0.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.js.map

package/dist/pick-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-by.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":"wCA6LA,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.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./pick-DH_wjXvd.cjs`);exports.pick=e.pick;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n={};for(let r of t)r in e&&(n[r]=e[r]);return n}exports.pick=t;

package/dist/pick.d.cts

@@ -1,7 +1,55 @@
-import "./is-union-BEGCMhOi.cjs";
-import "./iterable-container-V5sa0V_H.cjs";
-import "./perkakas-type-error-0tHtaPbi.cjs";
-import "./tuple-parts-BIyABPYv.cjs";
-import "./is-bounded-record-kpsb1wQA.cjs";
-import { pick } from "./pick-ChVH4t7j.cjs";
-export { pick };
+import { t as TupleParts } from "./tuple-parts-CzQQupgi.cjs";
+import { n as IsBounded, t as IsBoundedRecord } from "./is-bounded-record-DV6ZQk9H.cjs";
+import { t as PartitionByUnion } from "./partition-by-union-BztEpKVh.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<PartitionByUnion<TupleParts<Keys>['required']>['singular'] | PartitionByUnion<TupleParts<Keys>['suffix']>['singular'], keyof T>> & Partial<Pick<T, Extract<PartitionByUnion<TupleParts<Keys>['required']>['union'] | TupleParts<Keys>['optional'][number] | TupleParts<Keys>['item'] | PartitionByUnion<TupleParts<Keys>['suffix']>['union'], keyof T>>>;
+/**
+ * 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.d.cts.map

package/dist/pick.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.d.cts","names":[],"sources":["../src/pick.ts"],"sourcesContent":[],"mappings":";;;;;;KAOK,8BAA8B,cAAc,YAAY,OAEzD,oBACE,uBAOE,QAAQ,QAAQ,oBAAoB,mBAClC,cAIA,SACA,gBAAgB,kBACZ,qBAAqB,GAAG,QACxB,cAAc,GAAG,QAAQ,oBAAoB;AArBI;;;;;;;;;KAmC1D,oBAtBG,CAAA,CAAA,EAAA,aAsBkC,aAtBlC,CAsBgD,WAtBhD,CAsB4D,CAtB5D,CAAA,CAAA,CAAA,GAwBJ,IAxBI,CAyBJ,CAzBI,EA4BJ,OA5BI,CA6BA,gBA7BA,CA6BiB,UA7BjB,CA6B4B,IA7B5B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,GA8BA,gBA9BA,CA8BiB,UA9BjB,CA8B4B,IA9B5B,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,UAAA,CAAA,EAAA,MA+BI,CA/BJ,CAAA,CAAA,GAmCJ,OAnCI,CAoCJ,IApCI,CAqCF,CArCE,EAwCF,OAxCE,CAyCE,gBAzCF,CAyCmB,UAzCnB,CAyC8B,IAzC9B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,OAAA,CAAA,GA2CE,UA3CF,CA2Ca,IA3Cb,CAAA,CAAA,UAAA,CAAA,CAAA,MAAA,CAAA,GA4CE,UA5CF,CA4Ca,IA5Cb,CAAA,CAAA,MAAA,CAAA,GA6CE,gBA7CF,CA6CmB,UA7CnB,CA6C8B,IA7C9B,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,OAAA,CAAA,EAAA,MA8CM,CA9CN,CAAA,CAAA,CAAA;;;;;;;;;;;;KA8DH,aAzDK,CAAA,CAAA,EAAA,aAAA,MAyD+B,CAzD/B,CAAA,GAyDoC,SAzDpC,CAyD8C,IAzD9C,CAAA,SAAA,IAAA,GAyDmE,OAzDnE,CAyD2E,IAzD3E,CAyDgF,CAzDhF,EAyDmF,IAzDnF,CAAA,CAAA,GAyD4F,IAzD5F,CAyDiG,CAzDjG,EAyDoG,IAzDpG,CAAA;;AAAQ;;;;;;;;;AAyBO,iBA4CT,IA5CS,CAAA,UAAA,MAAA,EAAA,mBA8CJ,aA9CI,CA8CU,WA9CV,CA8CsB,CA9CtB,CAAA,CAAA,CAAA,CAAA,IAAA,EA+CjB,IA/CiB,CAAA,EAAA,CAAA,IAAA,EA+CH,CA/CG,EAAA,GA+CG,aA/CH,CA+CiB,CA/CjB,EA+CoB,IA/CpB,CAAA;;;;;;;;;;;;AAcf,iBA8CM,IA9CN,CAAA,UAAA,MAAA,EAAA,mBAgDW,aAhDX,CAgDyB,WAhDzB,CAgDqC,CAhDrC,CAAA,CAAA,CAAA,CAAA,IAAA,EAiDF,CAjDE,EAAA,IAAA,EAiDO,IAjDP,CAAA,EAiDc,aAjDd,CAiD4B,CAjD5B,EAiD+B,IAjD/B,CAAA"}

package/dist/pick.d.ts

@@ -1,7 +1,55 @@
-import "./is-union-J33UR5By.js";
-import "./iterable-container-F9CDF7ym.js";
-import "./perkakas-type-error-2yBU0Drj.js";
-import "./tuple-parts-Du2iVN8H.js";
-import "./is-bounded-record-DEQ2a3_Y.js";
-import { pick } from "./pick-DvCrGRHa.js";
-export { pick };
+import { t as TupleParts } from "./tuple-parts-BYI4o8Vk.js";
+import { n as IsBounded, t as IsBoundedRecord } from "./is-bounded-record-Bx4n8QB0.js";
+import { t as PartitionByUnion } from "./partition-by-union-DnfiiEMU.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<PartitionByUnion<TupleParts<Keys>['required']>['singular'] | PartitionByUnion<TupleParts<Keys>['suffix']>['singular'], keyof T>> & Partial<Pick<T, Extract<PartitionByUnion<TupleParts<Keys>['required']>['union'] | TupleParts<Keys>['optional'][number] | TupleParts<Keys>['item'] | PartitionByUnion<TupleParts<Keys>['suffix']>['union'], keyof T>>>;
+/**
+ * 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.d.ts.map

package/dist/pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.d.ts","names":[],"sources":["../src/pick.ts"],"sourcesContent":[],"mappings":";;;;;;KAOK,8BAA8B,cAAc,YAAY,OAEzD,oBACE,uBAOE,QAAQ,QAAQ,oBAAoB,mBAClC,cAIA,SACA,gBAAgB,kBACZ,qBAAqB,GAAG,QACxB,cAAc,GAAG,QAAQ,oBAAoB;AArBI;;;;;;;;;KAmC1D,oBAtBG,CAAA,CAAA,EAAA,aAsBkC,aAtBlC,CAsBgD,WAtBhD,CAsB4D,CAtB5D,CAAA,CAAA,CAAA,GAwBJ,IAxBI,CAyBJ,CAzBI,EA4BJ,OA5BI,CA6BA,gBA7BA,CA6BiB,UA7BjB,CA6B4B,IA7B5B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,GA8BA,gBA9BA,CA8BiB,UA9BjB,CA8B4B,IA9B5B,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,UAAA,CAAA,EAAA,MA+BI,CA/BJ,CAAA,CAAA,GAmCJ,OAnCI,CAoCJ,IApCI,CAqCF,CArCE,EAwCF,OAxCE,CAyCE,gBAzCF,CAyCmB,UAzCnB,CAyC8B,IAzC9B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,OAAA,CAAA,GA2CE,UA3CF,CA2Ca,IA3Cb,CAAA,CAAA,UAAA,CAAA,CAAA,MAAA,CAAA,GA4CE,UA5CF,CA4Ca,IA5Cb,CAAA,CAAA,MAAA,CAAA,GA6CE,gBA7CF,CA6CmB,UA7CnB,CA6C8B,IA7C9B,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,OAAA,CAAA,EAAA,MA8CM,CA9CN,CAAA,CAAA,CAAA;;;;;;;;;;;;KA8DH,aAzDK,CAAA,CAAA,EAAA,aAAA,MAyD+B,CAzD/B,CAAA,GAyDoC,SAzDpC,CAyD8C,IAzD9C,CAAA,SAAA,IAAA,GAyDmE,OAzDnE,CAyD2E,IAzD3E,CAyDgF,CAzDhF,EAyDmF,IAzDnF,CAAA,CAAA,GAyD4F,IAzD5F,CAyDiG,CAzDjG,EAyDoG,IAzDpG,CAAA;;AAAQ;;;;;;;;;AAyBO,iBA4CT,IA5CS,CAAA,UAAA,MAAA,EAAA,mBA8CJ,aA9CI,CA8CU,WA9CV,CA8CsB,CA9CtB,CAAA,CAAA,CAAA,CAAA,IAAA,EA+CjB,IA/CiB,CAAA,EAAA,CAAA,IAAA,EA+CH,CA/CG,EAAA,GA+CG,aA/CH,CA+CiB,CA/CjB,EA+CoB,IA/CpB,CAAA;;;;;;;;;;;;AAcf,iBA8CM,IA9CN,CAAA,UAAA,MAAA,EAAA,mBAgDW,aAhDX,CAgDyB,WAhDzB,CAgDqC,CAhDrC,CAAA,CAAA,CAAA,CAAA,IAAA,EAiDF,CAjDE,EAAA,IAAA,EAiDO,IAjDP,CAAA,EAiDc,aAjDd,CAiD4B,CAjD5B,EAiD+B,IAjD/B,CAAA"}

package/dist/pick.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{pick as e}from"./pick-DeXJU-DB.js";export{e as pick};
+import{t as e}from"./curry-NmniqyJ0.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.js.map

package/dist/pick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.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 { PartitionByUnion } from './internal/types/partition-by-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      | PartitionByUnion<TupleParts<Keys>['required']>['singular']\n      | PartitionByUnion<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        | PartitionByUnion<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        | PartitionByUnion<TupleParts<Keys>['suffix']>['union'],\n        keyof T\n      >\n    >\n  >;\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":"wCAgHA,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/pipe-CB7Lufqv.cjs

@@ -0,0 +1 @@
+const e=require(`./utility-evaluators-CAbODbuk.cjs`);function t(e,...t){let a=e,o=t.map(e=>`lazy`in e?r(e):void 0),s=0;for(;s<t.length;){if(o[s]===void 0||!i(a)){let e=t[s];a=e(a),s+=1;continue}let e=[];for(let n=s;n<t.length;n++){let t=o[n];if(t===void 0||(e.push(t),t.isSingle))break}let r=[];for(let t of a)if(n(t,r,e))break;let{isSingle:c}=e.at(-1);a=c?r[0]:r,s+=e.length}return a}function n(t,r,i){if(i.length===0)return r.push(t),!1;let a=t,o=e.t,s=!1;for(let[e,t]of i.entries()){let{index:c,items:l}=t;if(l.push(a),o=t(a,c,l),t.index+=1,o.hasNext){if(o.hasMany??!1){for(let t of o.next)if(n(t,r,i.slice(e+1)))return!0;return s}a=o.next}if(!o.hasNext)break;o.done&&(s=!0)}return o.hasNext&&r.push(a),s}function r(e){let{lazy:t,lazyArgs:n}=e,r=t(...n);return Object.assign(r,{isSingle:t.single??!1,index:0,items:[]})}function i(e){return typeof e==`string`||typeof e==`object`&&!!e&&Symbol.iterator in e}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});

package/dist/pipe-CZKusDA-.js

@@ -0,0 +1,2 @@
+import{t as e}from"./utility-evaluators-Boc-TMbq.js";function t(e,...t){let a=e,o=t.map(e=>`lazy`in e?r(e):void 0),s=0;for(;s<t.length;){if(o[s]===void 0||!i(a)){let e=t[s];a=e(a),s+=1;continue}let e=[];for(let n=s;n<t.length;n++){let t=o[n];if(t===void 0||(e.push(t),t.isSingle))break}let r=[];for(let t of a)if(n(t,r,e))break;let{isSingle:c}=e.at(-1);a=c?r[0]:r,s+=e.length}return a}function n(t,r,i){if(i.length===0)return r.push(t),!1;let a=t,o=e,s=!1;for(let[e,t]of i.entries()){let{index:c,items:l}=t;if(l.push(a),o=t(a,c,l),t.index+=1,o.hasNext){if(o.hasMany??!1){for(let t of o.next)if(n(t,r,i.slice(e+1)))return!0;return s}a=o.next}if(!o.hasNext)break;o.done&&(s=!0)}return o.hasNext&&r.push(a),s}function r(e){let{lazy:t,lazyArgs:n}=e,r=t(...n);return Object.assign(r,{isSingle:t.single??!1,index:0,items:[]})}function i(e){return typeof e==`string`||typeof e==`object`&&!!e&&Symbol.iterator in e}export{t};
+//# sourceMappingURL=pipe-CZKusDA-.js.map

package/dist/pipe-CZKusDA-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe-CZKusDA-.js","names":["lazySequence: Array<PreparedLazyFunction>","accumulator: Array<unknown>","lazyResult: LazyResult<any>"],"sources":["../src/pipe.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n/* eslint-disable jsdoc/check-param-names -- we don't document the op params, it'd be redundant */\n\nimport type { LazyDefinition } from './internal/types/lazy-definition';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype PreparedLazyFunction = LazyEvaluator & {\n  readonly isSingle: boolean;\n\n  // These are intentionally mutable, they maintain the lazy piped state.\n  index: number;\n  items: Array<unknown>;\n};\n\ntype LazyFunction = LazyDefinition & ((input: unknown) => unknown);\n\n/**\n * Performs left-to-right function composition, passing data through functions\n * in sequence. Each function receives the output of the previous function,\n * creating a readable top-to-bottom data flow that matches how the\n * transformation is executed. This enables converting deeply nested function\n * calls into clear, sequential steps without temporary variables.\n *\n * When consecutive functions with a `lazy` tag (e.g., `map`, `filter`, `take`,\n * `drop`, `forEach`, etc...) are used together, they process data item-by-item\n * rather than creating intermediate arrays. This enables early termination\n * when only partial results are needed, improving performance for large\n * datasets and expensive operations.\n *\n * Functions are only evaluated lazily when their data-last form is used\n * directly in the pipe. To disable lazy evaluation, use data-first calls via\n * arrow functions: `($) => map($, callback)` instead of `map(callback)`.\n *\n * Any function can be used in pipes, not just Remeda utilities. For creating\n * custom functions with currying and lazy evaluation support, see the `purry`\n * utility.\n *\n * A \"headless\" variant `piped` is available for creating reusable pipe\n * functions without initial data.\n *\n * IMPORTANT: During lazy evaluation, callbacks using the third parameter (the\n * input array) receive only items processed up to that point, not the complete\n * array.\n *\n * @param data - The input data.\n * @param functions - A sequence of functions that take one argument and\n * return a value.\n * @signature\n *   P.pipe(data, ...functions);\n * @example\n *    P.pipe([1, 2, 3], P.map(P.multiply(3))); //=> [3, 6, 9]\n *\n *    // = Early termination with lazy evaluation =\n *    P.pipe(\n *      hugeArray,\n *      P.map(expensiveComputation),\n *      P.filter(complexPredicate),\n *      // Only processes items until 2 results are found, then stops.\n *      // Most of hugeArray never gets processed.\n *      P.take(2),\n *    );\n *\n *    // = Custom logic within a pipe =\n *    P.pipe(\n *      input,\n *      P.toLowerCase(),\n *      normalize,\n *      ($) => validate($, CONFIG),\n *      P.split(\",\"),\n *      P.unique(),\n *    );\n *\n *    // = Migrating nested transformations to pipes =\n *    // Nested\n *    const result = P.prop(\n *      P.mapValues(P.groupByProp(users, \"department\"), P.length()),\n *      \"engineering\",\n *    );\n *\n *    // Piped\n *    const result = P.pipe(\n *      users,\n *      P.groupByProp(\"department\"),\n *      P.mapValues(P.length()),\n *      P.prop(\"engineering\"),\n *    );\n *\n *    // = Using the 3rd param of a callback =\n *    // The following would print out `data` in its entirety for each value\n *    // of `data`.\n *    P.forEach([1, 2, 3, 4], (_item, _index, data) => {\n *      console.log(data);\n *    }); //=> \"[1, 2, 3, 4]\" logged 4 times\n *\n *    // But with `pipe` data would only contain the items up to the current\n *    // index\n *    P.pipe([1, 2, 3, 4], P.forEach((_item, _index, data) => {\n *      console.log(data);\n *    })); //=> \"[1]\", \"[1, 2]\", \"[1, 2, 3]\", \"[1, 2, 3, 4]\"\n * @dataFirst\n * @category Function\n */\nexport function pipe<A>(data: A): A;\n\nexport function pipe<A, B>(data: A, funcA: (input: A) => B): B;\n\nexport function pipe<A, B, C>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n): C;\n\nexport function pipe<A, B, C, D>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n): D;\n\nexport function pipe<A, B, C, D, E>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n): E;\n\nexport function pipe<A, B, C, D, E, F>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n): F;\n\nexport function pipe<A, B, C, D, E, F, G>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n): G;\n\nexport function pipe<A, B, C, D, E, F, G, H>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n): H;\n\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n): I;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n): J;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n): K;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n): L;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n): M;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n): N;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n): O;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n  funcO: (input: O) => P,\n): P;\n\nexport function pipe(\n  input: unknown,\n  ...functions: ReadonlyArray<LazyFunction | ((value: any) => unknown)>\n): any {\n  let output = input;\n\n  const lazyFunctions = functions.map((op) =>\n    'lazy' in op ? prepareLazyFunction(op) : undefined);\n\n  let functionIndex = 0;\n  while (functionIndex < functions.length) {\n    const lazyFunction = lazyFunctions[functionIndex];\n    if (lazyFunction === undefined || !isIterable(output)) {\n      const func = functions[functionIndex]!;\n      output = func(output);\n      functionIndex += 1;\n      continue;\n    }\n\n    const lazySequence: Array<PreparedLazyFunction> = [];\n    for (let index = functionIndex; index < functions.length; index++) {\n      const lazyOp = lazyFunctions[index];\n      if (lazyOp === undefined) {\n        break;\n      }\n\n      lazySequence.push(lazyOp);\n      if (lazyOp.isSingle) {\n        break;\n      }\n    }\n\n    const accumulator: Array<unknown> = [];\n\n    for (const value of output) {\n      const shouldExitEarly = processItem(value, accumulator, lazySequence);\n      if (shouldExitEarly) {\n        break;\n      }\n    }\n\n    const { isSingle } = lazySequence.at(-1)!;\n    output = isSingle ? accumulator[0] : accumulator;\n    functionIndex += lazySequence.length;\n  }\n\n  return output;\n}\n\nfunction processItem(\n  item: unknown,\n  accumulator: Array<unknown>,\n  lazySequence: ReadonlyArray<PreparedLazyFunction>,\n): boolean {\n  if (lazySequence.length === 0) {\n    accumulator.push(item);\n    return false;\n  }\n\n  let currentItem = item;\n\n  let lazyResult: LazyResult<any> = SKIP_ITEM;\n  let isDone = false;\n  for (const [functionsIndex, lazyFn] of lazySequence.entries()) {\n    const { index, items } = lazyFn;\n    items.push(currentItem);\n    lazyResult = lazyFn(currentItem, index, items);\n    lazyFn.index += 1;\n    if (lazyResult.hasNext) {\n      if (lazyResult.hasMany ?? false) {\n        for (const subItem of lazyResult.next as ReadonlyArray<unknown>) {\n          const subResult = processItem(\n            subItem,\n            accumulator,\n            lazySequence.slice(functionsIndex + 1),\n          );\n          if (subResult) {\n            return true;\n          }\n        }\n        return isDone;\n      }\n      currentItem = lazyResult.next;\n    }\n    if (!lazyResult.hasNext) {\n      break;\n    }\n    // process remaining functions in the pipe\n    // but don't process remaining elements in the input array\n    if (lazyResult.done) {\n      isDone = true;\n    }\n  }\n  if (lazyResult.hasNext) {\n    accumulator.push(currentItem);\n  }\n  return isDone;\n}\n\nfunction prepareLazyFunction(func: LazyFunction): PreparedLazyFunction {\n  const { lazy, lazyArgs } = func;\n  const fn = lazy(...lazyArgs);\n  return Object.assign(fn, {\n    isSingle: lazy.single ?? false,\n    index: 0,\n    items: [] as Array<unknown>,\n  });\n}\n\nfunction isIterable(something: unknown): something is Iterable<unknown> {\n  // Check for null and undefined to avoid errors when accessing Symbol.iterator\n  return (\n    typeof something === 'string'\n    || (typeof something === 'object'\n      && something !== null\n      && Symbol.iterator in something)\n  );\n}\n"],"mappings":"qDA2RA,SAAgB,EACd,EACA,GAAG,EACE,CACL,IAAI,EAAS,EAEP,EAAgB,EAAU,IAAK,GACnC,SAAU,EAAK,EAAoB,EAAG,CAAG,IAAA,GAAU,CAEjD,EAAgB,EACpB,KAAO,EAAgB,EAAU,QAAQ,CAEvC,GADqB,EAAc,KACd,IAAA,IAAa,CAAC,EAAW,EAAO,CAAE,CACrD,IAAM,EAAO,EAAU,GACvB,EAAS,EAAK,EAAO,CACrB,GAAiB,EACjB,SAGF,IAAMA,EAA4C,EAAE,CACpD,IAAK,IAAI,EAAQ,EAAe,EAAQ,EAAU,OAAQ,IAAS,CACjE,IAAM,EAAS,EAAc,GAM7B,GALI,IAAW,IAAA,KAIf,EAAa,KAAK,EAAO,CACrB,EAAO,UACT,MAIJ,IAAMC,EAA8B,EAAE,CAEtC,IAAK,IAAM,KAAS,EAElB,GADwB,EAAY,EAAO,EAAa,EAAa,CAEnE,MAIJ,GAAM,CAAE,YAAa,EAAa,GAAG,GAAG,CACxC,EAAS,EAAW,EAAY,GAAK,EACrC,GAAiB,EAAa,OAGhC,OAAO,EAGT,SAAS,EACP,EACA,EACA,EACS,CACT,GAAI,EAAa,SAAW,EAE1B,OADA,EAAY,KAAK,EAAK,CACf,GAGT,IAAI,EAAc,EAEdC,EAA8B,EAC9B,EAAS,GACb,IAAK,GAAM,CAAC,EAAgB,KAAW,EAAa,SAAS,CAAE,CAC7D,GAAM,CAAE,QAAO,SAAU,EAIzB,GAHA,EAAM,KAAK,EAAY,CACvB,EAAa,EAAO,EAAa,EAAO,EAAM,CAC9C,EAAO,OAAS,EACZ,EAAW,QAAS,CACtB,GAAI,EAAW,SAAW,GAAO,CAC/B,IAAK,IAAM,KAAW,EAAW,KAM/B,GALkB,EAChB,EACA,EACA,EAAa,MAAM,EAAiB,EAAE,CACvC,CAEC,MAAO,GAGX,OAAO,EAET,EAAc,EAAW,KAE3B,GAAI,CAAC,EAAW,QACd,MAIE,EAAW,OACb,EAAS,IAMb,OAHI,EAAW,SACb,EAAY,KAAK,EAAY,CAExB,EAGT,SAAS,EAAoB,EAA0C,CACrE,GAAM,CAAE,OAAM,YAAa,EACrB,EAAK,EAAK,GAAG,EAAS,CAC5B,OAAO,OAAO,OAAO,EAAI,CACvB,SAAU,EAAK,QAAU,GACzB,MAAO,EACP,MAAO,EAAE,CACV,CAAC,CAGJ,SAAS,EAAW,EAAoD,CAEtE,OACE,OAAO,GAAc,UACjB,OAAO,GAAc,YACpB,GACA,OAAO,YAAY"}

package/dist/pipe.cjs

@@ -1 +1 @@
-require(`./utility-evaluators-DqJcWENu.cjs`);const e=require(`./pipe-DlFjc4Wf.cjs`);exports.pipe=e.pipe;
+const e=require(`./pipe-CB7Lufqv.cjs`);exports.pipe=e.t;