@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/for-each-CYTR5H9O.d.cts

@@ -1,54 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { Writable } from "type-fest";
-
-//#region src/for-each.d.ts
-
-/**
- * Executes a provided function once for each array element. Equivalent to
- * `Array.prototype.forEach`.
- *
- * The dataLast version returns the original array (instead of not returning
- * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the
- * returned array is equal to the input array (by reference), and not a shallow
- * copy of it!
- *
- * @param data - The values that would be iterated on.
- * @param callbackfn - A function to execute for each element in the array.
- * @signature
- *    P.forEach(data, callbackfn)
- * @example
- *    P.forEach([1, 2, 3], x => {
- *      console.log(x)
- *    });
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function forEach<T extends IterableContainer>(data: T, callbackfn: (value: T[number], index: number, data: T) => void): void;
-/**
- * Executes a provided function once for each array element. Equivalent to
- * `Array.prototype.forEach`.
- *
- * The dataLast version returns the original array (instead of not returning
- * anything (`void`)) to allow using it in a pipe. The returned array is the
- * same reference as the input array, and not a shallow copy of it!
- *
- * @param callbackfn - A function to execute for each element in the array.
- * @returns The original array (the ref itself, not a shallow copy of it).
- * @signature
- *    P.forEach(callbackfn)(data)
- * @example
- *    P.pipe(
- *      [1, 2, 3],
- *      P.forEach(x => {
- *        console.log(x)
- *      })
- *    ) // => [1, 2, 3]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function forEach<T extends IterableContainer>(callbackfn: (value: T[number], index: number, data: T) => void): (data: T) => Writable<T>;
-//#endregion
-export { forEach };
-//# sourceMappingURL=for-each-CYTR5H9O.d.cts.map

package/dist/for-each-CYTR5H9O.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-each-CYTR5H9O.d.cts","names":[],"sources":["../src/for-each.ts"],"sourcesContent":[],"mappings":";;;;;;;AA4BA;;;;;;;AA4BA;;;;;;;;;;;;iBA5BgB,kBAAkB,yBAC1B,uBACc,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;iBA0BtC,kBAAkB,uCACZ,gCAAgC,oBAC5C,MAAM,SAAS"}

package/dist/for-each-ClKbAv3A.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t,r)}function n(e,t){return e.forEach(t),e}function r(e){return(t,n,r)=>(e(t,n,r),{done:!1,hasNext:!0,next:t})}export{t as forEach};
-//# sourceMappingURL=for-each-ClKbAv3A.js.map

package/dist/for-each-ClKbAv3A.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-each-ClKbAv3A.js","names":[],"sources":["../src/for-each.ts"],"sourcesContent":["import type { Writable } from 'type-fest';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curry } from './curry';\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the\n * returned array is equal to the input array (by reference), and not a shallow\n * copy of it!\n *\n * @param data - The values that would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    P.forEach(data, callbackfn)\n * @example\n *    P.forEach([1, 2, 3], x => {\n *      console.log(x)\n *    });\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  data: T,\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): void;\n\n/**\n * Executes a provided function once for each array element. Equivalent to\n * `Array.prototype.forEach`.\n *\n * The dataLast version returns the original array (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned array is the\n * same reference as the input array, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original array (the ref itself, not a shallow copy of it).\n * @signature\n *    P.forEach(callbackfn)(data)\n * @example\n *    P.pipe(\n *      [1, 2, 3],\n *      P.forEach(x => {\n *        console.log(x)\n *      })\n *    ) // => [1, 2, 3]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function forEach<T extends IterableContainer>(\n  callbackfn: (value: T[number], index: number, data: T) => void,\n): (data: T) => Writable<T>;\n\nexport function forEach(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachImplementation, args, lazyImplementation);\n}\n\nfunction forEachImplementation<T>(\n  data: ReadonlyArray<T>,\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): Array<T> {\n  data.forEach(callbackfn);\n  // @ts-expect-error [ts4104] - Because the dataFirst signature returns void this is only a problem when the dataLast function is used **outside** of a pipe; for these cases we warn the user that this is happening.\n  return data;\n}\n\nfunction lazyImplementation<T>(\n  callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => void,\n): LazyEvaluator<T> {\n  return (value, index, data) => {\n    callbackfn(value, index, data);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"4CA4DA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAM,EAAmB,CAG/D,SAAS,EACP,EACA,EACU,CAGV,OAFA,EAAK,QAAQ,EAAW,CAEjB,EAGT,SAAS,EACP,EACkB,CAClB,OAAQ,EAAO,EAAO,KACpB,EAAW,EAAO,EAAO,EAAK,CACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/for-each-DIxtfnNY.d.ts

@@ -1,54 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { Writable } from "type-fest";
-
-//#region src/for-each.d.ts
-
-/**
- * Executes a provided function once for each array element. Equivalent to
- * `Array.prototype.forEach`.
- *
- * The dataLast version returns the original array (instead of not returning
- * anything (`void`)) to allow using it in a pipe. When not used in a `pipe` the
- * returned array is equal to the input array (by reference), and not a shallow
- * copy of it!
- *
- * @param data - The values that would be iterated on.
- * @param callbackfn - A function to execute for each element in the array.
- * @signature
- *    P.forEach(data, callbackfn)
- * @example
- *    P.forEach([1, 2, 3], x => {
- *      console.log(x)
- *    });
- * @dataFirst
- * @lazy
- * @category Array
- */
-declare function forEach<T extends IterableContainer>(data: T, callbackfn: (value: T[number], index: number, data: T) => void): void;
-/**
- * Executes a provided function once for each array element. Equivalent to
- * `Array.prototype.forEach`.
- *
- * The dataLast version returns the original array (instead of not returning
- * anything (`void`)) to allow using it in a pipe. The returned array is the
- * same reference as the input array, and not a shallow copy of it!
- *
- * @param callbackfn - A function to execute for each element in the array.
- * @returns The original array (the ref itself, not a shallow copy of it).
- * @signature
- *    P.forEach(callbackfn)(data)
- * @example
- *    P.pipe(
- *      [1, 2, 3],
- *      P.forEach(x => {
- *        console.log(x)
- *      })
- *    ) // => [1, 2, 3]
- * @dataLast
- * @lazy
- * @category Array
- */
-declare function forEach<T extends IterableContainer>(callbackfn: (value: T[number], index: number, data: T) => void): (data: T) => Writable<T>;
-//#endregion
-export { forEach };
-//# sourceMappingURL=for-each-DIxtfnNY.d.ts.map

package/dist/for-each-DIxtfnNY.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-each-DIxtfnNY.d.ts","names":[],"sources":["../src/for-each.ts"],"sourcesContent":[],"mappings":";;;;;;;AA4BA;;;;;;;AA4BA;;;;;;;;;;;;iBA5BgB,kBAAkB,yBAC1B,uBACc,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;iBA0BtC,kBAAkB,uCACZ,gCAAgC,oBAC5C,MAAM,SAAS"}

package/dist/for-each-obj-B6BJwtgs.cjs

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

package/dist/for-each-obj-CJFU3pj_.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){for(let[n,r]of Object.entries(e))t(r,n,e);return e}export{t as forEachObj};
-//# sourceMappingURL=for-each-obj-CJFU3pj_.js.map

package/dist/for-each-obj-CJFU3pj_.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-each-obj-CJFU3pj_.js","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param data - The object who'se entries would be iterated on.\n * @param callbackfn - A function to execute for each element in the array.\n * @signature\n *    P.forEachObj(object, fn)\n * @example\n *    P.forEachObj({a: 1}, (val, key, obj) => {\n *      console.log(`${key}: ${val}`)\n *    }) // \"a: 1\"\n * @dataFirst\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  data: T,\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): void;\n\n/**\n * Iterate an object using a defined callback function.\n *\n * The dataLast version returns the original object (instead of not returning\n * anything (`void`)) to allow using it in a pipe. The returned object is the\n * same reference as the input object, and not a shallow copy of it!\n *\n * @param callbackfn - A function to execute for each element in the array.\n * @returns The original object (the ref itself, not a shallow copy of it).\n * @signature\n *    P.forEachObj(fn)(object)\n * @example\n *    P.pipe(\n *      {a: 1},\n *      P.forEachObj((val, key) => console.log(`${key}: ${val}`))\n *    ) // \"a: 1\"\n * @dataLast\n * @category Object\n */\nexport function forEachObj<T extends object>(\n  callbackfn: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    obj: T,\n  ) => void,\n): (object: T) => T;\n\nexport function forEachObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(forEachObjImplementation, args);\n}\n\nfunction forEachObjImplementation<T extends object>(\n  data: T,\n  fn: (value: unknown, key: string, data: T) => void,\n): T {\n  for (const [key, value] of Object.entries(data)) {\n    fn(value, key, data);\n  }\n  return data;\n}\n"],"mappings":"4CA0DA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EACP,EACA,EACG,CACH,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAC7C,EAAG,EAAO,EAAK,EAAK,CAEtB,OAAO"}

package/dist/for-each-obj-DRgFFti8.d.ts

@@ -1,47 +0,0 @@
-import { EnumerableStringKeyOf } from "./enumerable-string-key-of-DKzYIarp.js";
-import { EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-Bf_owt8O.js";
-
-//#region src/for-each-obj.d.ts
-
-/**
- * Iterate an object using a defined callback function.
- *
- * The dataLast version returns the original object (instead of not returning
- * anything (`void`)) to allow using it in a pipe. The returned object is the
- * same reference as the input object, and not a shallow copy of it!
- *
- * @param data - The object who'se entries would be iterated on.
- * @param callbackfn - A function to execute for each element in the array.
- * @signature
- *    P.forEachObj(object, fn)
- * @example
- *    P.forEachObj({a: 1}, (val, key, obj) => {
- *      console.log(`${key}: ${val}`)
- *    }) // "a: 1"
- * @dataFirst
- * @category Object
- */
-declare function forEachObj<T extends object>(data: T, callbackfn: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, obj: T) => void): void;
-/**
- * Iterate an object using a defined callback function.
- *
- * The dataLast version returns the original object (instead of not returning
- * anything (`void`)) to allow using it in a pipe. The returned object is the
- * same reference as the input object, and not a shallow copy of it!
- *
- * @param callbackfn - A function to execute for each element in the array.
- * @returns The original object (the ref itself, not a shallow copy of it).
- * @signature
- *    P.forEachObj(fn)(object)
- * @example
- *    P.pipe(
- *      {a: 1},
- *      P.forEachObj((val, key) => console.log(`${key}: ${val}`))
- *    ) // "a: 1"
- * @dataLast
- * @category Object
- */
-declare function forEachObj<T extends object>(callbackfn: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, obj: T) => void): (object: T) => T;
-//#endregion
-export { forEachObj };
-//# sourceMappingURL=for-each-obj-DRgFFti8.d.ts.map

package/dist/for-each-obj-DRgFFti8.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-each-obj-DRgFFti8.d.ts","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsBA;;;;;;;;;AA4BA;;;;;;;AAMY,iBAlCI,UAkCJ,CAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAjCJ,CAiCI,EAAA,UAAA,EAAA,CAAA,KAAA,EA/BD,4BA+BC,CA/B4B,CA+B5B,CAAA,EAAA,GAAA,EA9BH,qBA8BG,CA9BmB,CA8BnB,CAAA,EAAA,GAAA,EA7BH,CA6BG,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA;;;;;;;;;;;;;;;;;;;;iBANI,iDAEL,6BAA6B,SAC/B,sBAAsB,SACtB,sBAEG,MAAM"}

package/dist/for-each-obj-yV90UbvE.d.cts

@@ -1,47 +0,0 @@
-import { EnumerableStringKeyOf } from "./enumerable-string-key-of-D2OpyD6n.cjs";
-import { EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-aov5dXss.cjs";
-
-//#region src/for-each-obj.d.ts
-
-/**
- * Iterate an object using a defined callback function.
- *
- * The dataLast version returns the original object (instead of not returning
- * anything (`void`)) to allow using it in a pipe. The returned object is the
- * same reference as the input object, and not a shallow copy of it!
- *
- * @param data - The object who'se entries would be iterated on.
- * @param callbackfn - A function to execute for each element in the array.
- * @signature
- *    P.forEachObj(object, fn)
- * @example
- *    P.forEachObj({a: 1}, (val, key, obj) => {
- *      console.log(`${key}: ${val}`)
- *    }) // "a: 1"
- * @dataFirst
- * @category Object
- */
-declare function forEachObj<T extends object>(data: T, callbackfn: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, obj: T) => void): void;
-/**
- * Iterate an object using a defined callback function.
- *
- * The dataLast version returns the original object (instead of not returning
- * anything (`void`)) to allow using it in a pipe. The returned object is the
- * same reference as the input object, and not a shallow copy of it!
- *
- * @param callbackfn - A function to execute for each element in the array.
- * @returns The original object (the ref itself, not a shallow copy of it).
- * @signature
- *    P.forEachObj(fn)(object)
- * @example
- *    P.pipe(
- *      {a: 1},
- *      P.forEachObj((val, key) => console.log(`${key}: ${val}`))
- *    ) // "a: 1"
- * @dataLast
- * @category Object
- */
-declare function forEachObj<T extends object>(callbackfn: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, obj: T) => void): (object: T) => T;
-//#endregion
-export { forEachObj };
-//# sourceMappingURL=for-each-obj-yV90UbvE.d.cts.map

package/dist/for-each-obj-yV90UbvE.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-each-obj-yV90UbvE.d.cts","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsBA;;;;;;;;;AA4BA;;;;;;;AAMY,iBAlCI,UAkCJ,CAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAjCJ,CAiCI,EAAA,UAAA,EAAA,CAAA,KAAA,EA/BD,4BA+BC,CA/B4B,CA+B5B,CAAA,EAAA,GAAA,EA9BH,qBA8BG,CA9BmB,CA8BnB,CAAA,EAAA,GAAA,EA7BH,CA6BG,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA;;;;;;;;;;;;;;;;;;;;iBANI,iDAEL,6BAA6B,SAC/B,sBAAsB,SACtB,sBAEG,MAAM"}

package/dist/from-entries-BqW53CyR.d.ts

@@ -1,68 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { PerkakasTypeError } from "./perkakas-type-error-Da3ni385.js";
-import { Simplify } from "type-fest";
-
-//#region src/from-entries.d.ts
-type FromEntriesError<Message extends string> = PerkakasTypeError<'fromEntries', Message>;
-type Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [key: Key, value: Value];
-type FromEntries<Entries> = Entries extends readonly [infer First, ...infer Tail] ? FromEntriesTuple<First, Tail> : Entries extends readonly [...infer Head, infer Last] ? FromEntriesTuple<Last, Head> : Entries extends IterableContainer<Entry> ? FromEntriesArray<Entries> : FromEntriesError<'Entries array-like could not be inferred'>;
-type FromEntriesTuple<E, Rest> = E extends Entry ? FromEntries<Rest> & Record<E[0], E[1]> : FromEntriesError<'Array-like contains a non-entry element'>;
-type FromEntriesArray<Entries extends IterableContainer<Entry>> = string extends AllKeys<Entries> ? Record<string, Entries[number][1]> : number extends AllKeys<Entries> ? Record<number, Entries[number][1]> : symbol extends AllKeys<Entries> ? Record<symbol, Entries[number][1]> : FromEntriesArrayWithLiteralKeys<Entries>;
-type FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>> = { [P in AllKeys<Entries>]?: ValueForKey<Entries, P> };
-type AllKeys<Entries extends IterableContainer<Entry>> = Extract<Entries[number], Entry>[0];
-type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey> = (Extract<Entries[number], Entry<K>> extends never ? Entries[number] : Extract<Entries[number], Entry<K>>)[1];
-/**
- * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
- * If a tuple is not supplied for any element in the array, the element will be ignored
- * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
- *
- * The strict option supports more sophisticated use-cases like those that would
- * result when calling the strict `toPairs` function.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * - `fromKeys`: Builds an object from an array of *keys* and a mapper for values.
- * - `indexBy`: Builds an object from an array of *values* and a mapper for keys.
- * - `pullObject`: Builds an object from an array of items with mappers for *both* keys and values.
- * - `mapToObj`: Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param entries - An array of key-value pairs.
- * @signature
- *   P.fromEntries(tuples)
- * @example
- *   P.fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}
- * @dataFirst
- * @category Object
- */
-declare function fromEntries<Entries extends IterableContainer<Entry>>(entries: Entries): Simplify<FromEntries<Entries>>;
-/**
- * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
- * If a tuple is not supplied for any element in the array, the element will be ignored
- * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
- *
- * The strict option supports more sophisticated use-cases like those that would
- * result when calling the strict `toPairs` function.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
- * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @signature
- *   P.fromEntries()(tuples)
- * @example
- *   P.pipe(
- *     [['a', 'b'], ['c', 'd']] as const,
- *     P.fromEntries(),
- *   ); // => {a: 'b', c: 'd'}
- * @dataLast
- * @category Object
- */
-declare function fromEntries(): <Entries extends IterableContainer<Entry>>(entries: Entries) => Simplify<FromEntries<Entries>>;
-//#endregion
-export { fromEntries };
-//# sourceMappingURL=from-entries-BqW53CyR.d.ts.map

package/dist/from-entries-BqW53CyR.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-entries-BqW53CyR.d.ts","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,2CAA2C,iCAE9C;KAGG,kBAAkB,cAAc,0CALhC,GAAA,EAME,GANF,EAAgB,KAAA,EAOZ,KAPY;KAiBhB,WAjB2C,CAAA,OAAA,CAAA,GAiBpB,OAjBoB,SAAA,SAAA,CAAiB,KAAA,MAAA,EAK5D,GAAA,KAAK,KAAA,CAAA,GAgBN,gBAhBM,CAgBW,KAhBX,EAgBkB,IAhBlB,CAAA,GAiBN,OAjBM,SAAA,SAAA,CAAA,GAAA,KAAA,KAAA,EAAA,KAAA,KAAA,CAAA,GAkBJ,gBAlBI,CAkBa,IAlBb,EAkBmB,IAlBnB,CAAA,GAmBJ,OAnBI,SAmBY,iBAnBZ,CAmB8B,KAnB9B,CAAA,GAoBF,gBApBE,CAoBe,OApBf,CAAA,GAqBF,gBArBE,CAAA,0CAAA,CAAA;KA0BL,gBA1BkB,CAAA,CAAA,EAAA,IAAA,CAAA,GA0BU,CA1BV,SA0BoB,KA1BpB,GA2BnB,WA3BmB,CA2BP,IA3BO,CAAA,GA2BC,MA3BD,CA2BQ,CA3BR,CAAA,CAAA,CAAA,EA2Bc,CA3Bd,CAAA,CAAA,CAAA,CAAA,GA4BnB,gBA5BmB,CAAA,yCAAA,CAAA;KAwClB,gBAxCgC,CAAA,gBAwCC,iBAxCD,CAwCmB,KAxCnB,CAAA,CAAA,GAAA,MAAA,SAyClB,OAzCkB,CAyCV,OAzCU,CAAA,GA0C/B,MA1C+B,CAAA,MAAA,EA0ChB,OA1CgB,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SA2ChB,OA3CgB,CA2CR,OA3CQ,CAAA,GA4C7B,MA5C6B,CAAA,MAAA,EA4Cd,OA5Cc,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SA6Cd,OA7Cc,CA6CN,OA7CM,CAAA,GA8C3B,MA9C2B,CAAA,MAAA,EA8CZ,OA9CY,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GA+C3B,+BA/C2B,CA+CK,OA/CL,CAAA;KAsDhC,+BArDE,CAAA,gBAqD8C,iBArD9C,CAqDgE,KArDhE,CAAA,CAAA,GAAA,QAuDG,OAtDD,CAsDS,OAtDT,CAAA,IAsDqB,WAtDrB,CAsDiC,OAtDjC,EAsD0C,CAtD1C,CAAA,EAAK;AAAA,KAyDT,OA/CA,CAAA,gBA+CwB,iBA/Cb,CA+C+B,KA/C/B,CAAA,CAAA,GA+CyC,OA/CzC,CAgDd,OAhDc,CAAA,MAAA,CAAA,EAiDd,KAjDc,CAAA,CAAA,CAAA,CAAA;KA0DX,WA1DW,CAAA,gBA2DE,iBA3DF,CA2DoB,KA3DpB,CAAA,EAAA,UA4DJ,WA5DI,CAAA,GAAA,CA6DX,OA7DW,CA6DH,OA7DG,CAAA,MAAA,CAAA,EA6Dc,KA7Dd,CA6DoB,CA7DpB,CAAA,CAAA,SAAA,KAAA,GA8DZ,OA9DY,CAAA,MAAA,CAAA,GA+DZ,OA/DY,CA+DJ,OA/DI,CAAA,MAAA,CAAA,EA+Da,KA/Db,CA+DmB,CA/DnB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;AASQ;;;;;;;;;AAOpB,iBAyEY,WAzEZ,CAAA,gBAyEwC,iBAzExC,CAyE0D,KAzE1D,CAAA,CAAA,CAAA,OAAA,EA0EO,OA1EP,CAAA,EA2ED,QA3EC,CA2EQ,WA3ER,CA2EoB,OA3EpB,CAAA,CAAA;;AAAgB;;;;;;;;;;;;;;;;;;;AAmBqB;;;;;;AASC,iBA2E1B,WAAA,CAAA,CA3E0B,EAAA,CAAA,gBA2EM,iBA3EN,CA2EwB,KA3ExB,CAAA,CAAA,CAAA,OAAA,EA4E/B,OA5E+B,EAAA,GA6ErC,QA7EqC,CA6E5B,WA7E4B,CA6EhB,OA7EgB,CAAA,CAAA"}

package/dist/from-entries-CToFI5yO.d.cts

@@ -1,68 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { PerkakasTypeError } from "./perkakas-type-error-0tHtaPbi.cjs";
-import { Simplify } from "type-fest";
-
-//#region src/from-entries.d.ts
-type FromEntriesError<Message extends string> = PerkakasTypeError<'fromEntries', Message>;
-type Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [key: Key, value: Value];
-type FromEntries<Entries> = Entries extends readonly [infer First, ...infer Tail] ? FromEntriesTuple<First, Tail> : Entries extends readonly [...infer Head, infer Last] ? FromEntriesTuple<Last, Head> : Entries extends IterableContainer<Entry> ? FromEntriesArray<Entries> : FromEntriesError<'Entries array-like could not be inferred'>;
-type FromEntriesTuple<E, Rest> = E extends Entry ? FromEntries<Rest> & Record<E[0], E[1]> : FromEntriesError<'Array-like contains a non-entry element'>;
-type FromEntriesArray<Entries extends IterableContainer<Entry>> = string extends AllKeys<Entries> ? Record<string, Entries[number][1]> : number extends AllKeys<Entries> ? Record<number, Entries[number][1]> : symbol extends AllKeys<Entries> ? Record<symbol, Entries[number][1]> : FromEntriesArrayWithLiteralKeys<Entries>;
-type FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>> = { [P in AllKeys<Entries>]?: ValueForKey<Entries, P> };
-type AllKeys<Entries extends IterableContainer<Entry>> = Extract<Entries[number], Entry>[0];
-type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey> = (Extract<Entries[number], Entry<K>> extends never ? Entries[number] : Extract<Entries[number], Entry<K>>)[1];
-/**
- * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
- * If a tuple is not supplied for any element in the array, the element will be ignored
- * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
- *
- * The strict option supports more sophisticated use-cases like those that would
- * result when calling the strict `toPairs` function.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * - `fromKeys`: Builds an object from an array of *keys* and a mapper for values.
- * - `indexBy`: Builds an object from an array of *values* and a mapper for keys.
- * - `pullObject`: Builds an object from an array of items with mappers for *both* keys and values.
- * - `mapToObj`: Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param entries - An array of key-value pairs.
- * @signature
- *   P.fromEntries(tuples)
- * @example
- *   P.fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}
- * @dataFirst
- * @category Object
- */
-declare function fromEntries<Entries extends IterableContainer<Entry>>(entries: Entries): Simplify<FromEntries<Entries>>;
-/**
- * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
- * If a tuple is not supplied for any element in the array, the element will be ignored
- * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.
- *
- * The strict option supports more sophisticated use-cases like those that would
- * result when calling the strict `toPairs` function.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.
- * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @signature
- *   P.fromEntries()(tuples)
- * @example
- *   P.pipe(
- *     [['a', 'b'], ['c', 'd']] as const,
- *     P.fromEntries(),
- *   ); // => {a: 'b', c: 'd'}
- * @dataLast
- * @category Object
- */
-declare function fromEntries(): <Entries extends IterableContainer<Entry>>(entries: Entries) => Simplify<FromEntries<Entries>>;
-//#endregion
-export { fromEntries };
-//# sourceMappingURL=from-entries-CToFI5yO.d.cts.map

package/dist/from-entries-CToFI5yO.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-entries-CToFI5yO.d.cts","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,2CAA2C,iCAE9C;KAGG,kBAAkB,cAAc,0CALhC,GAAA,EAME,GANF,EAAgB,KAAA,EAOZ,KAPY;KAiBhB,WAjB2C,CAAA,OAAA,CAAA,GAiBpB,OAjBoB,SAAA,SAAA,CAAiB,KAAA,MAAA,EAK5D,GAAA,KAAK,KAAA,CAAA,GAgBN,gBAhBM,CAgBW,KAhBX,EAgBkB,IAhBlB,CAAA,GAiBN,OAjBM,SAAA,SAAA,CAAA,GAAA,KAAA,KAAA,EAAA,KAAA,KAAA,CAAA,GAkBJ,gBAlBI,CAkBa,IAlBb,EAkBmB,IAlBnB,CAAA,GAmBJ,OAnBI,SAmBY,iBAnBZ,CAmB8B,KAnB9B,CAAA,GAoBF,gBApBE,CAoBe,OApBf,CAAA,GAqBF,gBArBE,CAAA,0CAAA,CAAA;KA0BL,gBA1BkB,CAAA,CAAA,EAAA,IAAA,CAAA,GA0BU,CA1BV,SA0BoB,KA1BpB,GA2BnB,WA3BmB,CA2BP,IA3BO,CAAA,GA2BC,MA3BD,CA2BQ,CA3BR,CAAA,CAAA,CAAA,EA2Bc,CA3Bd,CAAA,CAAA,CAAA,CAAA,GA4BnB,gBA5BmB,CAAA,yCAAA,CAAA;KAwClB,gBAxCgC,CAAA,gBAwCC,iBAxCD,CAwCmB,KAxCnB,CAAA,CAAA,GAAA,MAAA,SAyClB,OAzCkB,CAyCV,OAzCU,CAAA,GA0C/B,MA1C+B,CAAA,MAAA,EA0ChB,OA1CgB,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SA2ChB,OA3CgB,CA2CR,OA3CQ,CAAA,GA4C7B,MA5C6B,CAAA,MAAA,EA4Cd,OA5Cc,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SA6Cd,OA7Cc,CA6CN,OA7CM,CAAA,GA8C3B,MA9C2B,CAAA,MAAA,EA8CZ,OA9CY,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GA+C3B,+BA/C2B,CA+CK,OA/CL,CAAA;KAsDhC,+BArDE,CAAA,gBAqD8C,iBArD9C,CAqDgE,KArDhE,CAAA,CAAA,GAAA,QAuDG,OAtDD,CAsDS,OAtDT,CAAA,IAsDqB,WAtDrB,CAsDiC,OAtDjC,EAsD0C,CAtD1C,CAAA,EAAK;AAAA,KAyDT,OA/CA,CAAA,gBA+CwB,iBA/Cb,CA+C+B,KA/C/B,CAAA,CAAA,GA+CyC,OA/CzC,CAgDd,OAhDc,CAAA,MAAA,CAAA,EAiDd,KAjDc,CAAA,CAAA,CAAA,CAAA;KA0DX,WA1DW,CAAA,gBA2DE,iBA3DF,CA2DoB,KA3DpB,CAAA,EAAA,UA4DJ,WA5DI,CAAA,GAAA,CA6DX,OA7DW,CA6DH,OA7DG,CAAA,MAAA,CAAA,EA6Dc,KA7Dd,CA6DoB,CA7DpB,CAAA,CAAA,SAAA,KAAA,GA8DZ,OA9DY,CAAA,MAAA,CAAA,GA+DZ,OA/DY,CA+DJ,OA/DI,CAAA,MAAA,CAAA,EA+Da,KA/Db,CA+DmB,CA/DnB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;AASQ;;;;;;;;;AAOpB,iBAyEY,WAzEZ,CAAA,gBAyEwC,iBAzExC,CAyE0D,KAzE1D,CAAA,CAAA,CAAA,OAAA,EA0EO,OA1EP,CAAA,EA2ED,QA3EC,CA2EQ,WA3ER,CA2EoB,OA3EpB,CAAA,CAAA;;AAAgB;;;;;;;;;;;;;;;;;;;AAmBqB;;;;;;AASC,iBA2E1B,WAAA,CAAA,CA3E0B,EAAA,CAAA,gBA2EM,iBA3EN,CA2EwB,KA3ExB,CAAA,CAAA,CAAA,OAAA,EA4E/B,OA5E+B,EAAA,GA6ErC,QA7EqC,CA6E5B,WA7E4B,CA6EhB,OA7EgB,CAAA,CAAA"}

package/dist/from-entries-D6f6Bd0l.js

@@ -1,2 +0,0 @@
-import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(Object.fromEntries,t)}export{t as fromEntries};
-//# sourceMappingURL=from-entries-D6f6Bd0l.js.map

package/dist/from-entries-D6f6Bd0l.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-entries-D6f6Bd0l.js","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\n\nimport type { PerkakasTypeError } from './internal/types/perkakas-type-error';\nimport { curry } from './curry';\n\ntype FromEntriesError<Message extends string> = PerkakasTypeError<\n  'fromEntries',\n  Message\n>;\n\ntype Entry<Key extends PropertyKey = PropertyKey, Value = unknown> = readonly [\n  key: Key,\n  value: Value,\n];\n\n// The 2 kinds of arrays we accept result in different kinds of outputs:\n// 1. If the input is a *tuple*, we know exactly what entries it would hold,\n// and thus can type the result so that the keys are required. We will then run\n// recursively on the rest of the tuple.\n// 2. If the input is an *array* then any keys defined in the array might not\n// actually show up in runtime, and thus need to be optional. (e.g. if the input\n// is an empty array).\ntype FromEntries<Entries> = Entries extends readonly [\n  infer First,\n  ...infer Tail,\n]\n  ? FromEntriesTuple<First, Tail>\n  : Entries extends readonly [...infer Head, infer Last]\n    ? FromEntriesTuple<Last, Head>\n    : Entries extends IterableContainer<Entry>\n      ? FromEntriesArray<Entries>\n      : FromEntriesError<'Entries array-like could not be inferred'>;\n\n// For strict tuples we build the result by intersecting each entry as a record\n// between it's key and value, recursively. The recursion goes through our main\n// type so that we support tuples which also contain rest parts.\ntype FromEntriesTuple<E, Rest> = E extends Entry\n  ? FromEntries<Rest> & Record<E[0], E[1]>\n  : FromEntriesError<'Array-like contains a non-entry element'>;\n\n// For the array case we also need to handle what kind of keys it defines:\n// 1. If it defines a *broad* key (one that has an infinite set of values, like\n// number or string) then the result is a simple record.\n// 2. If the keys are *literals* then we need to make the record partial\n// (because those props are explicit), and we need to match each key it's\n// specific possible value, as defined by the entries.\n//\n// Note that this destination between keys is the result of how typescript\n// considers Record<string, unknown> to be **implicitly** partial, whereas\n// Record<\"a\", unknown> is not.\ntype FromEntriesArray<Entries extends IterableContainer<Entry>>\n  = string extends AllKeys<Entries>\n    ? Record<string, Entries[number][1]>\n    : number extends AllKeys<Entries>\n      ? Record<number, Entries[number][1]>\n      : symbol extends AllKeys<Entries>\n        ? Record<symbol, Entries[number][1]>\n        : FromEntriesArrayWithLiteralKeys<Entries>;\n\n// This type is largely copied from `objectFromEntries` in the repo:\n// *sindresorhus/ts-extras* but makes all properties of the output optional,\n// which is more correct because we can't assure that an entry will exist for\n// every possible prop/key of the input.\n// @see https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-from-entries.ts)\ntype FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>>\n  = {\n    [P in AllKeys<Entries>]?: ValueForKey<Entries, P>;\n  };\n\ntype AllKeys<Entries extends IterableContainer<Entry>> = Extract<\n  Entries[number],\n  Entry\n>[0];\n\n// I tried and failed to simplify the type here! What the ternary does here is\n// to support the cases where the entries are defined by a single type that\n// defines all entries, but it defines the keys as a union of literals\n// (`['a' | 'b', number]`); which is different from the output of toPairs\n// which would define a separate tuple literal for each key (`['a', number] |\n// ['b', number]`). We need to support both cases!\ntype ValueForKey<\n  Entries extends IterableContainer<Entry>,\n  K extends PropertyKey,\n> = (Extract<Entries[number], Entry<K>> extends never\n  ? Entries[number]\n  : Extract<Entries[number], Entry<K>>)[1];\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * - `fromKeys`: Builds an object from an array of *keys* and a mapper for values.\n * - `indexBy`: Builds an object from an array of *values* and a mapper for keys.\n * - `pullObject`: Builds an object from an array of items with mappers for *both* keys and values.\n * - `mapToObj`: Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param entries - An array of key-value pairs.\n * @signature\n *   P.fromEntries(tuples)\n * @example\n *   P.fromEntries([['a', 'b'], ['c', 'd']]); // => {a: 'b', c: 'd'}\n * @dataFirst\n * @category Object\n */\nexport function fromEntries<Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n): Simplify<FromEntries<Entries>>;\n\n/**\n * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.\n * If a tuple is not supplied for any element in the array, the element will be ignored\n * If duplicate keys exist, the tuple with the greatest index in the input array will be preferred.\n *\n * The strict option supports more sophisticated use-cases like those that would\n * result when calling the strict `toPairs` function.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `fromKeys` - Builds an object from an array of *keys* and a mapper for values.\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @signature\n *   P.fromEntries()(tuples)\n * @example\n *   P.pipe(\n *     [['a', 'b'], ['c', 'd']] as const,\n *     P.fromEntries(),\n *   ); // => {a: 'b', c: 'd'}\n * @dataLast\n * @category Object\n */\nexport function fromEntries(): <Entries extends IterableContainer<Entry>>(\n  entries: Entries,\n) => Simplify<FromEntries<Entries>>;\n\nexport function fromEntries(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.fromEntries, args);\n}\n"],"mappings":"4CAmJA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,OAAO,YAAa,EAAK"}

package/dist/from-entries-DDkKcu-p.cjs

@@ -1 +0,0 @@
-const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(Object.fromEntries,t)}Object.defineProperty(exports,`fromEntries`,{enumerable:!0,get:function(){return t}});

package/dist/from-keys-BYHfvCLR.d.ts

@@ -1,60 +0,0 @@
-import { IterableContainer } from "./iterable-container-wtkYslN_.js";
-import { BoundedPartial } from "./bounded-partial-TshEjJC1.js";
-import { Simplify } from "type-fest";
-
-//#region src/from-keys.d.ts
-type ExactlyOneKey<T, V> = T extends PropertyKey ? { [P in T]: V } : never;
-type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? BoundedPartial<Record<T[number], V>> : never;
-/**
- * Creates an object that maps each key in `data` to the result of `mapper` for
- * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
- * for each item in `data`.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param data - An array of keys of the output object. All items in the array
- * would be keys in the output array.
- * @param mapper - Takes a key and returns the value that would be associated
- * with that key.
- * @signature
- *   P.fromKeys(data, mapper);
- * @example
- *   P.fromKeys(["cat", "dog"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
- *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
- * @dataFirst
- * @category Object
- */
-declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(data: T, mapper: (item: T[number], index: number, data: T) => V): Simplify<FromKeys<T, V>>;
-/**
- * Creates an object that maps each key in `data` to the result of `mapper` for
- * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
- * for each item in `data`.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param mapper - Takes a key and returns the value that would be associated
- * with that key.
- * @signature
- *   P.fromKeys(mapper)(data);
- * @example
- *   P.pipe(["cat", "dog"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
- *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
- * @dataLast
- * @category Object
- */
-declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(mapper: (item: T[number], index: number, data: T) => V): (data: T) => Simplify<FromKeys<T, V>>;
-//#endregion
-export { fromKeys };
-//# sourceMappingURL=from-keys-BYHfvCLR.d.ts.map

package/dist/from-keys-BYHfvCLR.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-keys-BYHfvCLR.d.ts","names":[],"sources":["../src/from-keys.ts"],"sourcesContent":[],"mappings":";;;;;KAUK,sBAAsB,UAAU,sBAAsB,IAAI,GANc,GAMxE,KAAA;KAEA,QAFa,CAAA,UAEM,iBAFN,EAAA,CAAA,CAAA,GAE8B,CAF9B,SAAA,SAAA,EAAA,GAAA,CAAA,CAAA,GAKd,CALc,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAMZ,aANY,CAME,IANF,EAMQ,CANR,CAAA,GAMa,QANb,CAMsB,IANtB,EAM4B,CAN5B,CAAA,GAOZ,CAPY,CAAA,MAAA,CAAA,SAOM,WAPN,GAQV,cARU,CAQK,MARL,CAQY,CARZ,CAAA,MAAA,CAAA,EAQuB,CARvB,CAAA,CAAA,GAAA,KAAA;;;;;;AAA8C;;;;;;;;;;;;;;;;;;AAoChE;;AAAqD,iBAArC,QAAqC,CAAA,UAAlB,iBAAkB,CAAA,WAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAC7C,CAD6C,EAAA,MAAA,EAAA,CAAA,IAAA,EAEpC,CAFoC,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAEJ,CAFI,EAAA,GAEE,CAFF,CAAA,EAGlD,QAHkD,CAGzC,QAHyC,CAGhC,CAHgC,EAG7B,CAH6B,CAAA,CAAA;;;;;;;;;;;AA4BrD;;;;;;;;;;;;;iBAAgB,mBAAmB,kBAAkB,gCACpC,gCAAgC,MAAM,WAC7C,MAAM,SAAS,SAAS,GAAG"}

package/dist/from-keys-CI2PJlIM.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 e.entries())n[i]=t(i,r,e);return n}Object.defineProperty(exports,`fromKeys`,{enumerable:!0,get:function(){return t}});

package/dist/from-keys-DJe8xU7b.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 e.entries())n[i]=t(i,r,e);return n}export{t as fromKeys};
-//# sourceMappingURL=from-keys-DJe8xU7b.js.map

package/dist/from-keys-DJe8xU7b.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-keys-DJe8xU7b.js","names":["result: Partial<FromKeys<T, V>>"],"sources":["../src/from-keys.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\n\nimport type { BoundedPartial } from './internal/types/bounded-partial';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n// Takes a union of literals and creates a union of records with the value V for\n// each key **separately**\n// @example ExactlyOneKey<\"cat\" | \"dog\", boolean> // { cat: boolean } | { dog: boolean }\ntype ExactlyOneKey<T, V> = T extends PropertyKey ? { [P in T]: V } : never;\n\ntype FromKeys<T extends IterableContainer, V> = T extends readonly []\n  // eslint-disable-next-line ts/no-empty-object-type -- We want to return an empty object type here, but it's not trivial to build that in Typescript, other fixer suggestions like Record<PropertyKey, never> or Record<PropertyKey, unknown> both break our type tests so they don't do what we need here. Because the result is mutable this might be the correct type after all...\n  ? {}\n  : T extends readonly [infer Head, ...infer Rest]\n    ? ExactlyOneKey<Head, V> & FromKeys<Rest, V>\n    : T[number] extends PropertyKey\n      ? BoundedPartial<Record<T[number], V>>\n      : never;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param data - An array of keys of the output object. All items in the array\n * would be keys in the output array.\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   P.fromKeys(data, mapper);\n * @example\n *   P.fromKeys([\"cat\", \"dog\"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataFirst\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): Simplify<FromKeys<T, V>>;\n\n/**\n * Creates an object that maps each key in `data` to the result of `mapper` for\n * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run\n * for each item in `data`.\n *\n * There are several other functions that could be used to build an object from\n * an array:\n * `indexBy` - Builds an object from an array of *values* and a mapper for keys.\n * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.\n * `fromEntries` - Builds an object from an array of key-value pairs.\n * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.\n * Refer to the docs for more details.\n *\n * @param mapper - Takes a key and returns the value that would be associated\n * with that key.\n * @signature\n *   P.fromKeys(mapper)(data);\n * @example\n *   P.pipe([\"cat\", \"dog\"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<\"cat\" | \"dog\", number>>)\n *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)\n * @dataLast\n * @category Object\n */\nexport function fromKeys<T extends IterableContainer<PropertyKey>, V>(\n  mapper: (item: T[number], index: number, data: T) => V,\n): (data: T) => Simplify<FromKeys<T, V>>;\n\nexport function fromKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(fromKeysImplementation, args);\n}\n\nfunction fromKeysImplementation<T extends IterableContainer<PropertyKey>, V>(\n  data: T,\n  mapper: (item: T[number], index: number, data: T) => V,\n): FromKeys<T, V> {\n  const result: Partial<FromKeys<T, V>> = {};\n\n  for (const [index, key] of data.entries()) {\n    // @ts-expect-error [ts7053] - There's no easy way to make Typescript aware that the items in T would be keys in the output object because it's type is built recursively and the \"being an item of an array\" property of a type is not \"carried over\" in the recursive type definition.\n    result[key] = mapper(key, index, data);\n  }\n\n  return result as FromKeys<T, V>;\n}\n"],"mappings":"4CA8EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EACgB,CAChB,IAAMA,EAAkC,EAAE,CAE1C,IAAK,GAAM,CAAC,EAAO,KAAQ,EAAK,SAAS,CAEvC,EAAO,GAAO,EAAO,EAAK,EAAO,EAAK,CAGxC,OAAO"}

package/dist/from-keys-Ds1mndVk.d.cts

@@ -1,60 +0,0 @@
-import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
-import { BoundedPartial } from "./bounded-partial-A89bt7Kj.cjs";
-import { Simplify } from "type-fest";
-
-//#region src/from-keys.d.ts
-type ExactlyOneKey<T, V> = T extends PropertyKey ? { [P in T]: V } : never;
-type FromKeys<T extends IterableContainer, V> = T extends readonly [] ? {} : T extends readonly [infer Head, ...infer Rest] ? ExactlyOneKey<Head, V> & FromKeys<Rest, V> : T[number] extends PropertyKey ? BoundedPartial<Record<T[number], V>> : never;
-/**
- * Creates an object that maps each key in `data` to the result of `mapper` for
- * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
- * for each item in `data`.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param data - An array of keys of the output object. All items in the array
- * would be keys in the output array.
- * @param mapper - Takes a key and returns the value that would be associated
- * with that key.
- * @signature
- *   P.fromKeys(data, mapper);
- * @example
- *   P.fromKeys(["cat", "dog"], P.length()); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
- *   P.fromKeys([1, 2], P.add(1)); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
- * @dataFirst
- * @category Object
- */
-declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(data: T, mapper: (item: T[number], index: number, data: T) => V): Simplify<FromKeys<T, V>>;
-/**
- * Creates an object that maps each key in `data` to the result of `mapper` for
- * that key. Duplicate keys are overwritten, guaranteeing that `mapper` is run
- * for each item in `data`.
- *
- * There are several other functions that could be used to build an object from
- * an array:
- * `indexBy` - Builds an object from an array of *values* and a mapper for keys.
- * `pullObject` - Builds an object from an array of items with mappers for *both* keys and values.
- * `fromEntries` - Builds an object from an array of key-value pairs.
- * `mapToObj` - Builds an object from an array of items and a single mapper for key-value pairs.
- * Refer to the docs for more details.
- *
- * @param mapper - Takes a key and returns the value that would be associated
- * with that key.
- * @signature
- *   P.fromKeys(mapper)(data);
- * @example
- *   P.pipe(["cat", "dog"], P.fromKeys(P.length())); // { cat: 3, dog: 3 } (typed as Partial<Record<"cat" | "dog", number>>)
- *   P.pipe([1, 2], P.fromKeys(P.add(1))); // { 1: 2, 2: 3 } (typed as Partial<Record<1 | 2, number>>)
- * @dataLast
- * @category Object
- */
-declare function fromKeys<T extends IterableContainer<PropertyKey>, V>(mapper: (item: T[number], index: number, data: T) => V): (data: T) => Simplify<FromKeys<T, V>>;
-//#endregion
-export { fromKeys };
-//# sourceMappingURL=from-keys-Ds1mndVk.d.cts.map

package/dist/from-keys-Ds1mndVk.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"from-keys-Ds1mndVk.d.cts","names":[],"sources":["../src/from-keys.ts"],"sourcesContent":[],"mappings":";;;;;KAUK,sBAAsB,UAAU,sBAAsB,IAAI,GANc,GAMxE,KAAA;KAEA,QAFa,CAAA,UAEM,iBAFN,EAAA,CAAA,CAAA,GAE8B,CAF9B,SAAA,SAAA,EAAA,GAAA,CAAA,CAAA,GAKd,CALc,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAMZ,aANY,CAME,IANF,EAMQ,CANR,CAAA,GAMa,QANb,CAMsB,IANtB,EAM4B,CAN5B,CAAA,GAOZ,CAPY,CAAA,MAAA,CAAA,SAOM,WAPN,GAQV,cARU,CAQK,MARL,CAQY,CARZ,CAAA,MAAA,CAAA,EAQuB,CARvB,CAAA,CAAA,GAAA,KAAA;;;;;;AAA8C;;;;;;;;;;;;;;;;;;AAoChE;;AAAqD,iBAArC,QAAqC,CAAA,UAAlB,iBAAkB,CAAA,WAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EAC7C,CAD6C,EAAA,MAAA,EAAA,CAAA,IAAA,EAEpC,CAFoC,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAEJ,CAFI,EAAA,GAEE,CAFF,CAAA,EAGlD,QAHkD,CAGzC,QAHyC,CAGhC,CAHgC,EAG7B,CAH6B,CAAA,CAAA;;;;;;;;;;;AA4BrD;;;;;;;;;;;;;iBAAgB,mBAAmB,kBAAkB,gCACpC,gCAAgC,MAAM,WAC7C,MAAM,SAAS,SAAS,GAAG"}