@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/partition.d.cts

@@ -1,2 +1,51 @@
-import { partition } from "./partition-BRCPpbRh.cjs";
-export { partition };
+//#region src/partition.d.ts
+/**
+ * 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>];
+//#endregion
+export { partition };
+//# sourceMappingURL=partition.d.cts.map

package/dist/partition.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.cts","names":[],"sources":["../src/partition.ts"],"sourcesContent":[],"mappings":";;AAwBA;;;;;;;;;;;;;;;AAIA;;;;;;AAGU,iBAPM,SAON,CAAA,CAAA,EAAA,UAP6B,CAO7B,CAAA,CAAA,IAAA,EANF,aAME,CANY,CAMZ,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EALW,CAKX,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EALmC,aAKnC,CALiD,CAKjD,CAAA,EAAA,GAAA,KAAA,IALiE,CAKjE,CAAA,EAAA,CAJN,KAIM,CAJA,CAIA,CAAA,EAJI,KAIJ,CAJU,OAIV,CAJkB,CAIlB,EAJqB,CAIrB,CAAA,CAAA,CAAA;AAAN,iBAHY,SAGZ,CAAA,CAAA,CAAA,CAAA,IAAA,EAFI,aAEJ,CAFkB,CAElB,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EADiB,CACjB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADyC,aACzC,CADuD,CACvD,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,KAAA,CAAM,CAAN,CAAA,EAAU,KAAV,CAAgB,CAAhB,CAAA,CAAA;;;;AAuBJ;;;;;;;;;;;;;;;AAGA;;;AAC6C,iBAJ7B,SAI6B,CAAA,CAAA,EAAA,UAJN,CAIM,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAHxB,CAGwB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAHA,aAGA,CAHc,CAGd,CAAA,EAAA,GAAA,KAAA,IAH8B,CAG9B,CAAA,EAAA,CAAA,IAAA,EAFnC,aAEmC,CAFrB,CAEqB,CAAA,EAAA,GAAA,CAFb,KAEa,CAFP,CAEO,CAAA,EAFH,KAEG,CAFG,OAEH,CAFW,CAEX,EAFc,CAEd,CAAA,CAAA,CAAA;AACrB,iBAFR,SAEQ,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EADH,CACG,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADqB,aACrB,CADmC,CACnC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAAd,aAAc,CAAA,CAAA,CAAA,EAAA,GAAA,CAAQ,KAAR,CAAc,CAAd,CAAA,EAAkB,KAAlB,CAAwB,CAAxB,CAAA,CAAA"}

package/dist/partition.d.ts

@@ -1,2 +1,51 @@
-import { partition } from "./partition-TVQP5mCe.js";
-export { partition };
+//#region src/partition.d.ts
+/**
+ * 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>];
+//#endregion
+export { partition };
+//# sourceMappingURL=partition.d.ts.map

package/dist/partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","names":[],"sources":["../src/partition.ts"],"sourcesContent":[],"mappings":";;AAwBA;;;;;;;;;;;;;;;AAIA;;;;;;AAGU,iBAPM,SAON,CAAA,CAAA,EAAA,UAP6B,CAO7B,CAAA,CAAA,IAAA,EANF,aAME,CANY,CAMZ,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EALW,CAKX,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EALmC,aAKnC,CALiD,CAKjD,CAAA,EAAA,GAAA,KAAA,IALiE,CAKjE,CAAA,EAAA,CAJN,KAIM,CAJA,CAIA,CAAA,EAJI,KAIJ,CAJU,OAIV,CAJkB,CAIlB,EAJqB,CAIrB,CAAA,CAAA,CAAA;AAAN,iBAHY,SAGZ,CAAA,CAAA,CAAA,CAAA,IAAA,EAFI,aAEJ,CAFkB,CAElB,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EADiB,CACjB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADyC,aACzC,CADuD,CACvD,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,KAAA,CAAM,CAAN,CAAA,EAAU,KAAV,CAAgB,CAAhB,CAAA,CAAA;;;;AAuBJ;;;;;;;;;;;;;;;AAGA;;;AAC6C,iBAJ7B,SAI6B,CAAA,CAAA,EAAA,UAJN,CAIM,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAHxB,CAGwB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAHA,aAGA,CAHc,CAGd,CAAA,EAAA,GAAA,KAAA,IAH8B,CAG9B,CAAA,EAAA,CAAA,IAAA,EAFnC,aAEmC,CAFrB,CAEqB,CAAA,EAAA,GAAA,CAFb,KAEa,CAFP,CAEO,CAAA,EAFH,KAEG,CAFG,OAEH,CAFW,CAEX,EAFc,CAEd,CAAA,CAAA,CAAA;AACrB,iBAFR,SAEQ,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EADH,CACG,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADqB,aACrB,CADmC,CACnC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAAd,aAAc,CAAA,CAAA,CAAA,EAAA,GAAA,CAAQ,KAAR,CAAc,CAAd,CAAA,EAAkB,KAAlB,CAAwB,CAAxB,CAAA,CAAA"}

package/dist/partition.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{partition as e}from"./partition-BmC5u4fI.js";export{e as partition};
+import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){let n=[[],[]];for(let[r,i]of e.entries())n[t(i,r,e)?0:1].push(i);return n}export{t as partition};
+//# sourceMappingURL=partition.js.map

package/dist/partition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.js","names":["ret: [Array<T>, Array<T>]"],"sources":["../src/partition.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Splits a collection into two groups, the first of which contains elements the\n * `predicate` type guard passes, and the second one containing the rest.\n *\n * @param data - The items to split.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to add the element to the first partition, and and\n * `false` to add the element to the other partition. A type-predicate can also\n * be used to narrow the result.\n * @returns A 2-tuple of arrays where the first array contains the elements that\n * passed the predicate, and the second array contains the elements that did\n * not. The items are in the same order as they were in the original array.\n * @signature\n *    P.partition(data, predicate)\n * @example\n *    P.partition(\n *      ['one', 'two', 'forty two'],\n *      x => x.length === 3,\n *    ); // => [['one', 'two'], ['forty two']]\n * @dataFirst\n * @category Array\n */\nexport function partition<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): [Array<S>, Array<Exclude<T, S>>];\nexport function partition<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): [Array<T>, Array<T>];\n\n/**\n * Splits a collection into two groups, the first of which contains elements the\n * `predicate` type guard passes, and the second one containing the rest.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to add the element to the first partition, and and\n * `false` to add the element to the other partition. A type-predicate can also\n * be used to narrow the result.\n * @returns A 2-tuple of arrays where the first array contains the elements that\n * passed the predicate, and the second array contains the elements that did\n * not. The items are in the same order as they were in the original array.\n * @signature\n *    P.partition(predicate)(data)\n * @example\n *    P.pipe(\n *      ['one', 'two', 'forty two'],\n *      P.partition(x => x.length === 3),\n *    ); // => [['one', 'two'], ['forty two']]\n * @dataLast\n * @category Array\n */\nexport function partition<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];\nexport function partition<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => [Array<T>, Array<T>];\n\nexport function partition(...args: ReadonlyArray<unknown>): unknown {\n  return curry(partitionImplementation, args);\n}\n\nfunction partitionImplementation<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): [Array<T>, Array<T>] {\n  const ret: [Array<T>, Array<T>] = [[], []];\n  for (const [index, item] of data.entries()) {\n    const matches = predicate(item, index, data);\n    ret[matches ? 0 : 1].push(item);\n  }\n  return ret;\n};\n"],"mappings":"wCA6DA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACsB,CACtB,IAAMA,EAA4B,CAAC,EAAE,CAAE,EAAE,CAAC,CAC1C,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAExC,EADgB,EAAU,EAAM,EAAO,EAAK,CAC9B,EAAI,GAAG,KAAK,EAAK,CAEjC,OAAO"}

package/dist/path-or.cjs

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

package/dist/path-or.d.cts

@@ -1,2 +1,87 @@
-import { pathOr } from "./path-or-mXO0iY19.cjs";
-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.cts.map

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

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

package/dist/path-or.d.ts

@@ -1,2 +1,87 @@
-import { pathOr } from "./path-or-Cly_jEXS.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-BY4Gf2OC.js";export{e as pathOr};
+import{t as e}from"./curry-BcQ8Up1_.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-BERl_sWR.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-BERl_sWR.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"perkakas-type-error-BERl_sWR.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/perkakas-type-error-DmmsEmEF.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-DmmsEmEF.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"perkakas-type-error-DmmsEmEF.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/pick-by.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./pick-by-CVILzj6i.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-DVekF8fN.cjs";
-export { pickBy };
+import { t as IsBoundedRecord } from "./is-bounded-record-D9YK_OC8.cjs";
+import { t as ToString } from "./to-string-Se4KcQka.cjs";
+import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-FUg082M_.cjs";
+import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-CEclDoqe.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":";;;;;;;KAUK,uBAAuB,oBACxB,SACE,gBAAgB,0CAGY,KAAK,SAAS,MAAM,SAAS,GAAG,IAXP,GAmBjD,MAbL,CAaY,qBAbK,CAaiB,CAbjB,CAAA,EAaqB,4BAbrB,CAakD,CAblD,CAAA,CAAA,CAAA,GAAA,KAAA;KA2BjB,yBA3BuB,CAAA,CAAA,EAAA,CAAA,CAAA,GA2BW,CA3BX,SAAA,OAAA,GA4BxB,QA5BwB,CA6BtB,eA7BsB,CA6BN,CA7BM,CAAA,SAAA,IAAA,GA8BlB,UA9BkB,CA8BP,CA9BO,EA8BJ,CA9BI,CAAA,GA8BC,YA9BD,CA8Bc,CA9Bd,EA8BiB,CA9BjB,CAAA,GAmClB,MAnCkB,CAoChB,qBApCgB,CAoCM,CApCN,CAAA,EAqChB,OArCgB,CAqCR,4BArCQ,CAqCqB,CArCrB,CAAA,EAqCyB,CArCzB,CAAA,CAAA,CAAA,GAAA,KAAA;KA2CvB,UAzCiB,CAAA,CAAA,EAAA,CAAA,CAAA,GAAA,kBAAhB,MA2CkB,CA3ClB,IA2CuB,QA3CvB,CA4CF,WA5CE,CA4CU,CA5CV,EA4Ca,CA5Cb,EA4CgB,CA5ChB,CAAA,SAAA,IAAA,GA4CkC,CA5ClC,GAAA,KAAA,CAAA,GA6CA,OA7CA,CA6CQ,QA7CR,CA6CiB,CA7CjB,CAAA,CA6CoB,CA7CpB,CAAA,EA6CwB,CA7CxB,CAAA,EAG4B;KA+C7B,YA/C2C,CAAA,CAAA,EAAA,CAAA,CAAA,GAAA,kBAAT,MAiDf,CAjDe,IAiDV,QAjDU,CAkDnC,aAlDmC,CAkDrB,CAlDqB,EAkDlB,CAlDkB,EAkDf,CAlDe,CAAA,SAAA,IAAA,GAkDG,CAlDH,GAAA,KAAA,CAAA,IAmDhC,OAnDgC,CAmDxB,OAnDwB,CAmDhB,CAnDgB,CAmDd,CAnDc,CAAA,EAmDV,CAnDU,CAAA,CAAA,SAAA,IAAA,GAyDjC,CAzDiC,SAyDvB,CAzDuB,CAyDrB,CAzDqB,CAAA,GA0D/B,CA1D+B,GAAA,KAAA,GA4DjC,OA5DiC,CA4DzB,CA5DyB,CA4DvB,CA5DuB,CAAA,EA4DnB,CA5DmB,CAAA,EAAwB;KAkE1D,WAlEiD,CAAA,CAAA,EAAA,YAAA,MAkElB,CAlEkB,EAAA,CAAA,CAAA,GAmElD,CAnEkD,CAmEhD,GAnEgD,CAAA,SAmErC,OAnEqC,CAmE7B,CAnE6B,CAmE3B,GAnE2B,CAAA,EAmEvB,CAnEuB,CAAA,GAAA,IAAA,GAAA,KAAA;KA0EjD,aA1E6D,CAAA,CAAA,EAAA,YAAA,MA0E5B,CA1E4B,EAAA,CAAA,CAAA,GA2E9D,WA3E8D,CA2ElD,CA3EkD,EA2E/C,GA3E+C,EA2E5C,CA3E4C,CAAA,SAAA,IAAA,GAAA,KAAA,GA6E5D,OA7E4D,CA6EpD,OA7EoD,CA6E5C,CA7E4C,CA6E1C,GA7E0C,CAAA,EA6EtC,CA7EsC,CAAA,CAAA,SAAA,IAAA,GA8E1D,CA9E0D,SA8EhD,CA9EgD,CA8E9C,GA9E8C,CAAA,GAAA,IAAA,GAAA,KAAA,GAAA,IAAA;;;;;;;;AAJtD;;;;;;;;;;;;;;;;;;AA2BA,iBA0FI,MA1FJ,CAAA,UAAA,MAAA,EAAA,UA4FA,4BA5FA,CA4F6B,CA5F7B,CAAA,CAAA,CAAA,IAAA,EA8FJ,CA9FI,EAAA,SAAA,EAAA,CAAA,KAAA,EAgGD,4BAhGC,CAgG4B,CAhG5B,CAAA,EAAA,GAAA,EAiGH,qBAjGG,CAiGmB,CAjGnB,CAAA,EAAA,IAAA,EAkGF,CAlGE,EAAA,GAAA,KAAA,IAmGI,CAnGJ,CAAA,EAoGT,yBApGS,CAoGiB,CApGjB,EAoGoB,CApGpB,CAAA;AAeP,iBAsFW,MAtFD,CAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAuFP,CAvFO,EAAA,SAAA,EAAA,CAAA,KAAA,EAyFJ,4BAzFI,CAyFyB,CAzFzB,CAAA,EAAA,GAAA,EA0FN,qBA1FM,CA0FgB,CA1FhB,CAAA,EAAA,IAAA,EA2FL,CA3FK,EAAA,GAAA,OAAA,CAAA,EA6FZ,iBA7FY,CA6FM,CA7FN,CAAA;;;;;;;;;;;;;;AAIF;;;;;;;;;;AASgB,iBAyGb,MAzGa,CAAA,UAAA,MAAA,EAAA,UA2GjB,4BA3GiB,CA2GY,CA3GZ,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EA8GlB,4BA9GkB,CA8GW,CA9GX,CAAA,EAAA,GAAA,EA+GpB,qBA/GoB,CA+GE,CA/GF,CAAA,EAAA,IAAA,EAgHnB,CAhHmB,EAAA,GAAA,KAAA,IAiHb,CAjHa,CAAA,EAAA,CAAA,IAAA,EAkHnB,CAlHmB,EAAA,GAkHb,yBAlHa,CAkHa,CAlHb,EAkHgB,CAlHhB,CAAA;AAAd,iBAmHC,MAnHD,CAAA,UAAA,MAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAqHJ,4BArHI,CAqHyB,CArHzB,CAAA,EAAA,GAAA,EAsHN,qBAtHM,CAsHgB,CAtHhB,CAAA,EAAA,IAAA,EAuHL,CAvHK,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAyHL,CAzHK,EAAA,GAyHC,iBAzHD,CAyHmB,CAzHnB,CAAA"}

package/dist/pick-by.d.ts

@@ -1,6 +1,68 @@
-import "./is-bounded-record-DCEYRY41.js";
-import "./to-string-RweoJgSy.js";
-import "./enumerable-string-key-of-DKzYIarp.js";
-import "./enumerable-string-keyed-value-of-Bf_owt8O.js";
-import { pickBy } from "./pick-by-CmgAp9Gv.js";
-export { pickBy };
+import { t as IsBoundedRecord } from "./is-bounded-record-BGclJjRX.js";
+import { t as ToString } from "./to-string-C6_OnZ6e.js";
+import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-DMAkBhMk.js";
+import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-B2F2aTB7.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-D6ACT8QA.js";export{e as pickBy};
+import{t as e}from"./curry-BcQ8Up1_.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"}