@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/partition-BmC5u4fI.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"partition-BmC5u4fI.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":"4CA6DA,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/partition-TVQP5mCe.d.ts

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

package/dist/partition-TVQP5mCe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"partition-TVQP5mCe.d.ts","names":[],"sources":["../src/partition.ts"],"sourcesContent":[],"mappings":";;AAwBA;;;;;;;;;;;;;;;;AAIA;;;;;AAE2D,iBAN3C,SAM2C,CAAA,CAAA,EAAA,UANpB,CAMoB,CAAA,CAAA,IAAA,EALnD,aAKmD,CALrC,CAKqC,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAJtC,CAIsC,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAJd,aAIc,CAJA,CAIA,CAAA,EAAA,GAAA,KAAA,IAJgB,CAIhB,CAAA,EAAA,CAHvD,KAGuD,CAHjD,CAGiD,CAAA,EAH7C,KAG6C,CAHvC,OAGuC,CAH/B,CAG+B,EAH5B,CAG4B,CAAA,CAAA,CAAA;AAAd,iBAF7B,SAE6B,CAAA,CAAA,CAAA,CAAA,IAAA,EADrC,aACqC,CADvB,CACuB,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAAxB,CAAwB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAAA,aAAA,CAAc,CAAd,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CACzC,KADyC,CACnC,CADmC,CAAA,EAC/B,KAD+B,CACzB,CADyB,CAAA,CAAA;;;;;;AAwB7C;;;;;;;;;;;;;;;;AAGgB,iBAHA,SAGS,CAAA,CAAA,EAAA,UAHc,CAGd,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAFJ,CAEI,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAFoB,aAEpB,CAFkC,CAElC,CAAA,EAAA,GAAA,KAAA,IAFkD,CAElD,CAAA,EAAA,CAAA,IAAA,EADf,aACe,CADD,CACC,CAAA,EAAA,GAAA,CADO,KACP,CADa,CACb,CAAA,EADiB,KACjB,CADuB,OACvB,CAD+B,CAC/B,EADkC,CAClC,CAAA,CAAA,CAAA;AAAA,iBAAT,SAAS,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EACJ,CADI,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EACoB,aADpB,CACkC,CADlC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAEf,aAFe,CAED,CAFC,CAAA,EAAA,GAAA,CAEO,KAFP,CAEa,CAFb,CAAA,EAEiB,KAFjB,CAEuB,CAFvB,CAAA,CAAA"}

package/dist/path-or-BY4Gf2OC.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.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-BY4Gf2OC.js.map

package/dist/path-or-BY4Gf2OC.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-or-BY4Gf2OC.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":"4CA4JA,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/path-or-CVvftsB5.cjs

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

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

@@ -1,87 +0,0 @@
-//#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 extends PropertyKey> = T extends infer I ? K extends keyof I ? I[K] : never : never;
-type StrictlyRequired<T> = { [K in keyof T]-?: NonNullable<T[K]> };
-/**
- * Given some `A` which is a key of at least one variant of `T`, derive
- * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not
- * null or undefined.
- */
-type PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<Pathable<T>>[A];
-/** All possible options after successfully reaching `T[A]`. */
-type Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;
-/** As `PathValue1`, but for `T[A][B]`. */
-type PathValue2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = StrictlyRequired<Pathable1<T, A>>[B];
-/** As `Pathable1`, but for `T[A][B]`. */
-type Pathable2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = Pathable<PathValue2<T, A, B>>;
-/** As `PathValue1`, but for `T[A][B][C]`. */
-type PathValue3<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>> = StrictlyRequired<Pathable2<T, A, B>>[C];
-/**
- * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.
- *
- * Prefer `prop` over this function as it provides better typing and is more
- * flexible when building solutions. To provide a default value using `prop`
- * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- * after the call.
- *
- * @param object - The target object.
- * @param path - The path of the property to get.
- * @param defaultValue - The default value.
- * @signature P.pathOr(object, array, defaultValue)
- * @example
- *    P.pathOr({x: 10}, ['y'], 2) // 2
- *    P.pathOr({y: 10}, ['y'], 2) // 10
- * @dataFirst
- * @category Object
- */
-declare function pathOr<T, A extends keyof Pathable<T>>(object: T, path: readonly [A], defaultValue: PathValue1<T, A>): PathValue1<T, A>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(object: T, path: readonly [A, B], defaultValue: PathValue2<T, A, B>): PathValue2<T, A, B>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(object: T, path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): PathValue3<T, A, B, C>;
-/**
- * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.
- *
- * Prefer `prop` over this function as it provides better typing and is more
- * flexible when building solutions. To provide a default value using `prop`
- * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- * after the call.
- *
- * @param path - The path of the property to get.
- * @param defaultValue - The default value.
- * @signature P.pathOr(array, defaultValue)(object)
- * @example
- *    P.pipe({x: 10}, P.pathOr(['y'], 2)) // 2
- *    P.pipe({y: 10}, P.pathOr(['y'], 2)) // 10
- * @dataLast
- * @category Object
- */
-declare function pathOr<T, A extends keyof Pathable<T>>(path: readonly [A], defaultValue: PathValue1<T, A>): (object: T) => PathValue1<T, A>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(path: readonly [A, B], defaultValue: PathValue2<T, A, B>): (object: T) => PathValue2<T, A, B>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): (object: T) => PathValue3<T, A, B, C>;
-//#endregion
-export { pathOr };
-//# sourceMappingURL=path-or-Cly_jEXS.d.ts.map

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

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

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

@@ -1,87 +0,0 @@
-//#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 extends PropertyKey> = T extends infer I ? K extends keyof I ? I[K] : never : never;
-type StrictlyRequired<T> = { [K in keyof T]-?: NonNullable<T[K]> };
-/**
- * Given some `A` which is a key of at least one variant of `T`, derive
- * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not
- * null or undefined.
- */
-type PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<Pathable<T>>[A];
-/** All possible options after successfully reaching `T[A]`. */
-type Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;
-/** As `PathValue1`, but for `T[A][B]`. */
-type PathValue2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = StrictlyRequired<Pathable1<T, A>>[B];
-/** As `Pathable1`, but for `T[A][B]`. */
-type Pathable2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = Pathable<PathValue2<T, A, B>>;
-/** As `PathValue1`, but for `T[A][B][C]`. */
-type PathValue3<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>> = StrictlyRequired<Pathable2<T, A, B>>[C];
-/**
- * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.
- *
- * Prefer `prop` over this function as it provides better typing and is more
- * flexible when building solutions. To provide a default value using `prop`
- * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- * after the call.
- *
- * @param object - The target object.
- * @param path - The path of the property to get.
- * @param defaultValue - The default value.
- * @signature P.pathOr(object, array, defaultValue)
- * @example
- *    P.pathOr({x: 10}, ['y'], 2) // 2
- *    P.pathOr({y: 10}, ['y'], 2) // 10
- * @dataFirst
- * @category Object
- */
-declare function pathOr<T, A extends keyof Pathable<T>>(object: T, path: readonly [A], defaultValue: PathValue1<T, A>): PathValue1<T, A>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(object: T, path: readonly [A, B], defaultValue: PathValue2<T, A, B>): PathValue2<T, A, B>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(object: T, path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): PathValue3<T, A, B, C>;
-/**
- * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.
- *
- * Prefer `prop` over this function as it provides better typing and is more
- * flexible when building solutions. To provide a default value using `prop`
- * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- * after the call.
- *
- * @param path - The path of the property to get.
- * @param defaultValue - The default value.
- * @signature P.pathOr(array, defaultValue)(object)
- * @example
- *    P.pipe({x: 10}, P.pathOr(['y'], 2)) // 2
- *    P.pipe({y: 10}, P.pathOr(['y'], 2)) // 10
- * @dataLast
- * @category Object
- */
-declare function pathOr<T, A extends keyof Pathable<T>>(path: readonly [A], defaultValue: PathValue1<T, A>): (object: T) => PathValue1<T, A>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(path: readonly [A, B], defaultValue: PathValue2<T, A, B>): (object: T) => PathValue2<T, A, B>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): (object: T) => PathValue3<T, A, B, C>;
-//#endregion
-export { pathOr };
-//# sourceMappingURL=path-or-mXO0iY19.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"path-or-mXO0iY19.d.cts","names":[],"sources":["../src/path-or.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AA0BmD;;;;;AAEN;;;;;;;;;AAGpC;KALJ,QAUgB,CAAA,CAAA,CAAA,GAAA,QAVM,OAUc,CAVN,CAUM,CAAA,GAVD,WAUC,CAVW,CAUX,EAVc,CAUd,CAAA;KARpC,OAQwD,CAAA,CAAA,CAAA,GAR3C,CAQ2C,SAAA,KAAA,EAAA,GAAA,MARjB,CAQiB,GAAA,KAAA;KAPxD,WAO0C,CAAA,CAAA,EAAA,UAPjB,WAOiB,CAAA,GAPF,CAOE,SAAA,KAAA,EAAA,GAN3C,CAM2C,SAAA,MAN3B,CAM2B,GALzC,CAKyC,CALvC,CAKuC,CAAA,GAAA,KAAA,GAAA,KAAA;KAA1C,gBAAqD,CAAA,CAAA,CAAA,GAAA,QAOrD,MAPoC,CAO1B,KAPgC,WAOhC,CAP4C,CAO5C,CAP8C,CAO9C,CAAA,CAAA,EAAA;;;;;;KAAV,UAEH,CAAA,CAAA,EAAA,UAAA,MAFiC,QAEjC,CAF0C,CAE1C,CAAA,CAAA,GAFgD,gBAEhD,CADA,QACA,CADS,CACT,CAAA,CAAA,CAAA,CAAA,CAAA;;AAAC,KAEE,SAAA,CAAA,CAAS,EAAA,UAAA,MAAoB,QAApB,CAA6B,CAA7B,CAAA,CAAA,GAAmC,QAAnC,CAA4C,UAA5C,CAAuD,CAAvD,EAA0D,CAA1D,CAAA,CAAA;;KAGT,UAHsC,CAAA,CAAA,EAAA,UAAA,MAKzB,QALyB,CAKhB,CALgB,CAAA,EAAA,UAAA,MAMzB,SANyB,CAMf,CANe,EAMZ,CANY,CAAA,CAAA,GAOvC,gBAPuC,CAOtB,SAPsB,CAOZ,CAPY,EAOT,CAPS,CAAA,CAAA,CAOL,CAPK,CAAA;;KAStC,SATgE,CAAA,CAAA,EAAA,UAAA,MAWnD,QAXmD,CAW1C,CAX0C,CAAA,EAAA,UAAA,MAYnD,SAZmD,CAYzC,CAZyC,EAYtC,CAZsC,CAAA,CAAA,GAajE,QAbiE,CAaxD,UAbwD,CAa7C,CAb6C,EAa1C,CAb0C,EAavC,CAbuC,CAAA,CAAA;;KAgBhE,UAhBqD,CAAA,CAAA,EAAA,UAAA,MAkBxC,QAlBwC,CAkB/B,CAlB+B,CAAA,EAAA,UAAA,MAmBxC,SAnBwC,CAmB9B,CAnB8B,EAmB3B,CAnB2B,CAAA,EAAA,UAAA,MAoBxC,SApBwC,CAoB9B,CApB8B,EAoB3B,CApB2B,EAoBxB,CApBwB,CAAA,CAAA,GAqBtD,gBArBsD,CAqBrC,SArBqC,CAqB3B,CArB2B,EAqBxB,CArBwB,EAqBrB,CArBqB,CAAA,CAAA,CAqBjB,CArBiB,CAAA;;;AAAD;;;;;;;;;;;;;AAOlB;;;AAIrB,iBA8BF,MA9BE,CAAA,CAAA,EAAA,UAAA,MA8BwB,QA9BxB,CA8BiC,CA9BjC,CAAA,CAAA,CAAA,MAAA,EA+BR,CA/BQ,EAAA,IAAA,EAAA,SAAA,CAgCA,CAhCA,CAAA,EAAA,YAAA,EAiCF,UAjCE,CAiCS,CAjCT,EAiCY,CAjCZ,CAAA,CAAA,EAkCf,UAlCe,CAkCJ,CAlCI,EAkCD,CAlCC,CAAA;AACU,iBAmCZ,MAnCY,CAAA,CAAA,EAAA,UAAA,MAqCV,QArCU,CAqCD,CArCC,CAAA,EAAA,UAAA,MAsCV,SAtCU,CAsCA,CAtCA,EAsCG,CAtCH,CAAA,CAAA,CAAA,MAAA,EAwClB,CAxCkB,EAAA,IAAA,EAAA,SAAA,CAyCV,CAzCU,EAyCP,CAzCO,CAAA,EAAA,YAAA,EA0CZ,UA1CY,CA0CD,CA1CC,EA0CE,CA1CF,EA0CK,CA1CL,CAAA,CAAA,EA2CzB,UA3CyB,CA2Cd,CA3Cc,EA2CX,CA3CW,EA2CR,CA3CQ,CAAA;AAAG,iBA6Cf,MA7Ce,CAAA,CAAA,EAAA,UAAA,MA+Cb,QA/Ca,CA+CJ,CA/CI,CAAA,EAAA,UAAA,MAgDb,SAhDa,CAgDH,CAhDG,EAgDA,CAhDA,CAAA,EAAA,UAAA,MAiDb,SAjDa,CAiDH,CAjDG,EAiDA,CAjDA,EAiDG,CAjDH,CAAA,CAAA,CAAA,MAAA,EAmDrB,CAnDqB,EAAA,IAAA,EAAA,SAAA,CAoDb,CApDa,EAoDV,CApDU,EAoDP,CApDO,CAAA,EAAA,YAAA,EAqDf,UArDe,CAqDJ,CArDI,EAqDD,CArDC,EAqDE,CArDF,EAqDK,CArDL,CAAA,CAAA,EAsD5B,UAtD4B,CAsDjB,CAtDiB,EAsDd,CAtDc,EAsDX,CAtDW,EAsDR,CAtDQ,CAAA;;;;;;;;AACnB;;;;;;;;;;AAOM,iBAiEF,MAjEE,CAAA,CAAA,EAAA,UAAA,MAiEwB,QAjExB,CAiEiC,CAjEjC,CAAA,CAAA,CAAA,IAAA,EAAA,SAAA,CAkEA,CAlEA,CAAA,EAAA,YAAA,EAmEF,UAnEE,CAmES,CAnET,EAmEY,CAnEZ,CAAA,CAAA,EAAA,CAAA,MAAA,EAoEN,CApEM,EAAA,GAoEA,UApEA,CAoEW,CApEX,EAoEc,CApEd,CAAA;AACa,iBAqEf,MArEe,CAAA,CAAA,EAAA,UAAA,MAuEb,QAvEa,CAuEJ,CAvEI,CAAA,EAAA,UAAA,MAwEb,SAxEa,CAwEH,CAxEG,EAwEA,CAxEA,CAAA,CAAA,CAAA,IAAA,EAAA,SAAA,CA0Eb,CA1Ea,EA0EV,CA1EU,CAAA,EAAA,YAAA,EA2Ef,UA3Ee,CA2EJ,CA3EI,EA2ED,CA3EC,EA2EE,CA3EF,CAAA,CAAA,EAAA,CAAA,MAAA,EA4EnB,CA5EmB,EAAA,GA4Eb,UA5Ea,CA4EF,CA5EE,EA4EC,CA5ED,EA4EI,CA5EJ,CAAA;AAAG,iBA8ElB,MA9EkB,CAAA,CAAA,EAAA,UAAA,MAgFhB,QAhFgB,CAgFP,CAhFO,CAAA,EAAA,UAAA,MAiFhB,SAjFgB,CAiFN,CAjFM,EAiFH,CAjFG,CAAA,EAAA,UAAA,MAkFhB,SAlFgB,CAkFN,CAlFM,EAkFH,CAlFG,EAkFA,CAlFA,CAAA,CAAA,CAAA,IAAA,EAAA,SAAA,CAoFhB,CApFgB,EAoFb,CApFa,EAoFV,CApFU,CAAA,EAAA,YAAA,EAqFlB,UArFkB,CAqFP,CArFO,EAqFJ,CArFI,EAqFD,CArFC,EAqFE,CArFF,CAAA,CAAA,EAAA,CAAA,MAAA,EAsFtB,CAtFsB,EAAA,GAsFhB,UAtFgB,CAsFL,CAtFK,EAsFF,CAtFE,EAsFC,CAtFD,EAsFI,CAtFJ,CAAA"}

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

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

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

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

package/dist/perkakas-type-error-Da3ni385.d.ts

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

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

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

package/dist/pick--K1QxTFe.cjs

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

package/dist/pick-BeGmtZCr.d.ts

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

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

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

package/dist/pick-BuIVJICv.js

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

package/dist/pick-BuIVJICv.js.map

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

package/dist/pick-CsXZS_Xe.d.cts

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

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

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

package/dist/pick-by-CVILzj6i.cjs

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

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

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

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

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

package/dist/pick-by-D6ACT8QA.js

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