@vinicunca/perkakas 1.9.0 → 1.12.0

package/dist/flat.d.cts

@@ -1,3 +1,53 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { flat } from "./flat-CJrZ3ALE.cjs";
-export { flat };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { IsNumericLiteral } from "type-fest";
+
+//#region src/flat.d.ts
+type FlatArray<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = []> = Depth extends Iteration['length'] ? T : T extends readonly [] ? [] : T extends readonly [infer Item, ...infer Rest] ? [...(Item extends IterableContainer ? FlatArray<Item, Depth, [...Iteration, unknown]> : [Item]), ...FlatArray<Rest, Depth, Iteration>] : Array<FlatSimpleArrayItems<T, Depth, Iteration>>;
+type FlatSimpleArrayItems<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = [], IsDone extends boolean = false> = {
+  done: T;
+  recur: T extends ReadonlyArray<infer InnerArr> ? FlatSimpleArrayItems<InnerArr, Depth, [...Iteration, unknown], Iteration['length'] extends Depth ? true : false> : T;
+}[IsDone extends true ? 'done' : 'recur'];
+/**
+ * Creates a new array with all sub-array elements concatenated into it
+ * recursively up to the specified depth. Equivalent to the built-in
+ * `Array.prototype.flat` method.
+ *
+ * @param data - The items to flatten.
+ * @param depth - The depth level specifying how deep a nested array structure
+ * should be flattened. Defaults to 1. Non literal values (those typed as
+ * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and
+ * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For
+ * "unlimited" depth use a literal value that would exceed your expected
+ * practical maximum nesting level.
+ * @signature
+ *   P.flat(data)
+ *   P.flat(data, depth)
+ * @example
+ *   P.flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]
+ *   P.flat([[[1]], [[2]]], 2); // => [1, 2]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function flat<T extends IterableContainer, Depth extends number = 1>(data: T, depth?: IsNumericLiteral<Depth> extends true ? Depth : never): FlatArray<T, Depth>;
+/**
+ * Creates a new array with all sub-array elements concatenated into it
+ * recursively up to the specified depth. Equivalent to the built-in
+ * `Array.prototype.flat` method.
+ *
+ * @param depth - The depth level specifying how deep a nested array structure
+ * should be flattened. Defaults to 1.
+ * @signature
+ *   P.flat()(data)
+ *   P.flat(depth)(data)
+ * @example
+ *   P.pipe([[1, 2], [3, 4], [5], [[6]]], P.flat()); // => [1, 2, 3, 4, 5, [6]]
+ *   P.pipe([[[1]], [[2]]], P.flat(2)); // => [1, 2]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function flat<Depth extends number = 1>(depth?: IsNumericLiteral<Depth> extends true ? Depth : never): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;
+//#endregion
+export { flat };
+//# sourceMappingURL=flat.d.cts.map

package/dist/flat.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat.d.cts","names":[],"sources":["../src/flat.ts"],"sourcesContent":[],"mappings":";;;;KASK,qDAGe,+BAChB,cAAc,sBAEd,IACA,6BAGE,mEAKqB,oBAEb,UAAU,MAAM,WAAW,wBAE1B,QAnBV,GAqBQ,SArBC,CAqBS,IArBT,EAqBe,KArBf,EAqBsB,SArBtB,CAAA,CAGM,GAqBZ,KArBY,CAqBN,oBArBM,CAqBe,CArBf,EAqBkB,KArBlB,EAqByB,SArBzB,CAAA,CAAA;KA2Bf,oBA1BD,CAAA,CAAA,EAAA,cAAA,MAAA,EAAA,kBA6BgB,aA7BhB,CAAA,OAAA,CAAA,GAAA,EAAA,EAAA,eAAA,OAAA,GAAA,KAAA,CAAA,GAAA;EAAc,IAAA,EAgCV,CAhCU;EAEd,KAAA,EA+BK,CA/BL,SA+Be,aA/Bf,CAAA,KAAA,SAAA,CAAA,GAgCE,oBAhCF,CAiCE,QAjCF,EAkCE,KAlCF,EAAA,CACA,GAkCM,SAlCN,EAGE,OAAA,CAKqB,EA6BrB,SA7BqB,CAAA,QAAA,CAAA,SA6BO,KA7BP,GAAA,IAAA,GAAA,KAAA,CAAA,GA+BrB,CA/BqB;CAEH,CA8BtB,MA9BsB,SAAA,IAAA,GAAA,MAAA,GAAA,OAAA,CAAA;;;;;;;;;;;;;;;AAOX;;;;;;;;AAoBP,iBA2BU,IA3BV,CAAA,UA4BM,iBA5BN,EAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,IAAA,EA+BE,CA/BF,EAAA,KAAA,CAAA,EAgCI,gBAhCJ,CAgCqB,KAhCrB,CAAA,SAAA,IAAA,GAgC2C,KAhC3C,GAAA,KAAA,CAAA,EAiCH,SAjCG,CAiCO,CAjCP,EAiCU,KAjCV,CAAA;;;;;;AA2BN;;;;;;;;;;AAyBA;;AACU,iBADM,IACN,CAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,KAAA,CAAA,EAAA,gBAAA,CAAiB,KAAjB,CAAA,SAAA,IAAA,GAAuC,KAAvC,GAAA,KAAA,CAAA,EAAA,CAAA,UACI,iBADJ,CAAA,CAAA,IAAA,EAC6B,CAD7B,EAAA,GACmC,SADnC,CAC6C,CAD7C,EACgD,KADhD,CAAA"}

package/dist/flat.d.ts

@@ -1,3 +1,53 @@
-import "./iterable-container-F9CDF7ym.js";
-import { flat } from "./flat-CfT3an2x.js";
-export { flat };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+import { IsNumericLiteral } from "type-fest";
+
+//#region src/flat.d.ts
+type FlatArray<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = []> = Depth extends Iteration['length'] ? T : T extends readonly [] ? [] : T extends readonly [infer Item, ...infer Rest] ? [...(Item extends IterableContainer ? FlatArray<Item, Depth, [...Iteration, unknown]> : [Item]), ...FlatArray<Rest, Depth, Iteration>] : Array<FlatSimpleArrayItems<T, Depth, Iteration>>;
+type FlatSimpleArrayItems<T, Depth extends number, Iteration extends ReadonlyArray<unknown> = [], IsDone extends boolean = false> = {
+  done: T;
+  recur: T extends ReadonlyArray<infer InnerArr> ? FlatSimpleArrayItems<InnerArr, Depth, [...Iteration, unknown], Iteration['length'] extends Depth ? true : false> : T;
+}[IsDone extends true ? 'done' : 'recur'];
+/**
+ * Creates a new array with all sub-array elements concatenated into it
+ * recursively up to the specified depth. Equivalent to the built-in
+ * `Array.prototype.flat` method.
+ *
+ * @param data - The items to flatten.
+ * @param depth - The depth level specifying how deep a nested array structure
+ * should be flattened. Defaults to 1. Non literal values (those typed as
+ * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and
+ * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For
+ * "unlimited" depth use a literal value that would exceed your expected
+ * practical maximum nesting level.
+ * @signature
+ *   P.flat(data)
+ *   P.flat(data, depth)
+ * @example
+ *   P.flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]
+ *   P.flat([[[1]], [[2]]], 2); // => [1, 2]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function flat<T extends IterableContainer, Depth extends number = 1>(data: T, depth?: IsNumericLiteral<Depth> extends true ? Depth : never): FlatArray<T, Depth>;
+/**
+ * Creates a new array with all sub-array elements concatenated into it
+ * recursively up to the specified depth. Equivalent to the built-in
+ * `Array.prototype.flat` method.
+ *
+ * @param depth - The depth level specifying how deep a nested array structure
+ * should be flattened. Defaults to 1.
+ * @signature
+ *   P.flat()(data)
+ *   P.flat(depth)(data)
+ * @example
+ *   P.pipe([[1, 2], [3, 4], [5], [[6]]], P.flat()); // => [1, 2, 3, 4, 5, [6]]
+ *   P.pipe([[[1]], [[2]]], P.flat(2)); // => [1, 2]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function flat<Depth extends number = 1>(depth?: IsNumericLiteral<Depth> extends true ? Depth : never): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;
+//#endregion
+export { flat };
+//# sourceMappingURL=flat.d.ts.map

package/dist/flat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat.d.ts","names":[],"sources":["../src/flat.ts"],"sourcesContent":[],"mappings":";;;;KASK,qDAGe,+BAChB,cAAc,sBAEd,IACA,6BAGE,mEAKqB,oBAEb,UAAU,MAAM,WAAW,wBAE1B,QAnBV,GAqBQ,SArBC,CAqBS,IArBT,EAqBe,KArBf,EAqBsB,SArBtB,CAAA,CAGM,GAqBZ,KArBY,CAqBN,oBArBM,CAqBe,CArBf,EAqBkB,KArBlB,EAqByB,SArBzB,CAAA,CAAA;KA2Bf,oBA1BD,CAAA,CAAA,EAAA,cAAA,MAAA,EAAA,kBA6BgB,aA7BhB,CAAA,OAAA,CAAA,GAAA,EAAA,EAAA,eAAA,OAAA,GAAA,KAAA,CAAA,GAAA;EAAc,IAAA,EAgCV,CAhCU;EAEd,KAAA,EA+BK,CA/BL,SA+Be,aA/Bf,CAAA,KAAA,SAAA,CAAA,GAgCE,oBAhCF,CAiCE,QAjCF,EAkCE,KAlCF,EAAA,CACA,GAkCM,SAlCN,EAGE,OAAA,CAKqB,EA6BrB,SA7BqB,CAAA,QAAA,CAAA,SA6BO,KA7BP,GAAA,IAAA,GAAA,KAAA,CAAA,GA+BrB,CA/BqB;CAEH,CA8BtB,MA9BsB,SAAA,IAAA,GAAA,MAAA,GAAA,OAAA,CAAA;;;;;;;;;;;;;;;AAOX;;;;;;;;AAoBP,iBA2BU,IA3BV,CAAA,UA4BM,iBA5BN,EAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,IAAA,EA+BE,CA/BF,EAAA,KAAA,CAAA,EAgCI,gBAhCJ,CAgCqB,KAhCrB,CAAA,SAAA,IAAA,GAgC2C,KAhC3C,GAAA,KAAA,CAAA,EAiCH,SAjCG,CAiCO,CAjCP,EAiCU,KAjCV,CAAA;;;;;;AA2BN;;;;;;;;;;AAyBA;;AACU,iBADM,IACN,CAAA,cAAA,MAAA,GAAA,CAAA,CAAA,CAAA,KAAA,CAAA,EAAA,gBAAA,CAAiB,KAAjB,CAAA,SAAA,IAAA,GAAuC,KAAvC,GAAA,KAAA,CAAA,EAAA,CAAA,UACI,iBADJ,CAAA,CAAA,IAAA,EAC6B,CAD7B,EAAA,GACmC,SADnC,CAC6C,CAD7C,EACgD,KADhD,CAAA"}

package/dist/flat.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./utility-evaluators-CnQVdcZv.js";import{flat as e}from"./flat-Cd7pIXar.js";export{e as flat};
+import{t as e}from"./lazy-data-last-impl-DW5TXWv8.js";import{r as t}from"./utility-evaluators-BwYLtB8b.js";function n(t,n){return typeof t==`object`?r(t,n):e(r,t===void 0?[]:[t],i)}function r(e,t){return t===void 0?e.flat():e.flat(t)}function i(e){return e===void 0||e===1?a:e<=0?t:t=>Array.isArray(t)?{next:t.flat(e-1),hasNext:!0,hasMany:!0,done:!1}:{next:t,hasNext:!0,done:!1}}function a(e){return Array.isArray(e)?{next:e,hasNext:!0,hasMany:!0,done:!1}:{next:e,hasNext:!0,done:!1}}export{n as flat};
+//# sourceMappingURL=flat.js.map

package/dist/flat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat.js","names":[],"sources":["../src/flat.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport type { LazyResult } from './internal/types/lazy-result';\n\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\nimport { lazyIdentityEvaluator } from './internal/utility-evaluators';\n\ntype FlatArray<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = Depth extends Iteration['length']\n  // Stopping condition for the recursion when the array is a tuple.\n  ? T\n  : T extends readonly []\n    // Trivial result when the array is empty.\n    ? []\n    : T extends readonly [infer Item, ...infer Rest]\n      // Tuples could be special-cased by \"iterating\" over each item\n      // separately so that we maintain more information from the input type,\n      // instead of putting all values in a union.\n      ? [\n          ...(Item extends IterableContainer\n            // If the item itself is an array we continue going deeper\n            ? FlatArray<Item, Depth, [...Iteration, unknown]>\n            // But if it isn't we add it to the output tuple\n            : [Item]),\n          // And we merge this with the result from the rest of the tuple.\n          ...FlatArray<Rest, Depth, Iteration>,\n        ]\n      // For simple arrays we compute the item type, and wrap it with an array.\n      : Array<FlatSimpleArrayItems<T, Depth, Iteration>>;\n\n// This type is based on the built-in type for `Array.prototype.flat` from the\n// ES2019 Array typescript library, but we improved it to handle any depth\n// (avoiding the fixed `20` in the built-in type).\n// @see https://github.com/microsoft/TypeScript/blob/main/src/lib/es2019.array.d.ts#L1-L5\ntype FlatSimpleArrayItems<\n  T,\n  Depth extends number,\n  Iteration extends ReadonlyArray<unknown> = [],\n  IsDone extends boolean = false,\n> = {\n  done: T;\n  recur: T extends ReadonlyArray<infer InnerArr>\n    ? FlatSimpleArrayItems<\n      InnerArr,\n      Depth,\n      [...Iteration, unknown],\n      // This trick allows us to continue 1 iteration more than the depth,\n      // which is required to flatten the array up to depth.\n      Iteration['length'] extends Depth ? true : false\n    >\n    : T;\n}[IsDone extends true ? 'done' : 'recur'];\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param data - The items to flatten.\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1. Non literal values (those typed as\n * `number`cannot be used. `Infinity`, `Number.POSITIVE_INFINITY` and\n * `Number.MAX_VALUE` are all typed as `number` and can't be used either. For\n * \"unlimited\" depth use a literal value that would exceed your expected\n * practical maximum nesting level.\n * @signature\n *   P.flat(data)\n *   P.flat(data, depth)\n * @example\n *   P.flat([[1, 2], [3, 4], [5], [[6]]]); // => [1, 2, 3, 4, 5, [6]]\n *   P.flat([[[1]], [[2]]], 2); // => [1, 2]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function flat<\n  T extends IterableContainer,\n  Depth extends number = 1,\n>(\n  data: T,\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): FlatArray<T, Depth>;\n\n/**\n * Creates a new array with all sub-array elements concatenated into it\n * recursively up to the specified depth. Equivalent to the built-in\n * `Array.prototype.flat` method.\n *\n * @param depth - The depth level specifying how deep a nested array structure\n * should be flattened. Defaults to 1.\n * @signature\n *   P.flat()(data)\n *   P.flat(depth)(data)\n * @example\n *   P.pipe([[1, 2], [3, 4], [5], [[6]]], P.flat()); // => [1, 2, 3, 4, 5, [6]]\n *   P.pipe([[[1]], [[2]]], P.flat(2)); // => [1, 2]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function flat<Depth extends number = 1>(\n  depth?: IsNumericLiteral<Depth> extends true ? Depth : never,\n): <T extends IterableContainer>(data: T) => FlatArray<T, Depth>;\n\nexport function flat(\n  dataOrDepth?: IterableContainer | number,\n  depth?: number,\n): unknown {\n  if (typeof dataOrDepth === 'object') {\n    return flatImplementation(dataOrDepth, depth);\n  }\n\n  return lazyDataLastImpl(\n    flatImplementation,\n    dataOrDepth === undefined ? [] : [dataOrDepth],\n    lazyImplementation,\n  );\n}\n\nfunction flatImplementation(\n  data: IterableContainer,\n  depth?: number,\n): IterableContainer {\n  return (depth === undefined ? data.flat() : data.flat(depth));\n};\n\nfunction lazyImplementation(depth?: number): LazyEvaluator {\n  if (depth === undefined || depth === 1) {\n    return lazyShallow;\n  }\n\n  if (depth <= 0) {\n    return lazyIdentityEvaluator;\n  }\n\n  return (value) =>\n    Array.isArray(value)\n      ? {\n          next: value.flat(depth - 1),\n          hasNext: true,\n          hasMany: true,\n          done: false,\n        }\n      : { next: value, hasNext: true, done: false }; ;\n}\n\n/**\n * This function is pulled out so that we don't generate a new function\n * each time. Because it doesn't need to run with recursion it could be pulled\n * out from the lazyImplementation and be reused for all invocations.\n */\nfunction lazyShallow<T>(value: T): LazyResult<T> {\n  return Array.isArray(value)\n    ? { next: value, hasNext: true, hasMany: true, done: false }\n    : { next: value, hasNext: true, done: false };\n}\n"],"mappings":"2GA6GA,SAAgB,EACd,EACA,EACS,CAKT,OAJI,OAAO,GAAgB,SAClB,EAAmB,EAAa,EAAM,CAGxC,EACL,EACA,IAAgB,IAAA,GAAY,EAAE,CAAG,CAAC,EAAY,CAC9C,EACD,CAGH,SAAS,EACP,EACA,EACmB,CACnB,OAAQ,IAAU,IAAA,GAAY,EAAK,MAAM,CAAG,EAAK,KAAK,EAAM,CAG9D,SAAS,EAAmB,EAA+B,CASzD,OARI,IAAU,IAAA,IAAa,IAAU,EAC5B,EAGL,GAAS,EACJ,EAGD,GACN,MAAM,QAAQ,EAAM,CAChB,CACE,KAAM,EAAM,KAAK,EAAQ,EAAE,CAC3B,QAAS,GACT,QAAS,GACT,KAAM,GACP,CACD,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO,CAQnD,SAAS,EAAe,EAAyB,CAC/C,OAAO,MAAM,QAAQ,EAAM,CACvB,CAAE,KAAM,EAAO,QAAS,GAAM,QAAS,GAAM,KAAM,GAAO,CAC1D,CAAE,KAAM,EAAO,QAAS,GAAM,KAAM,GAAO"}

package/dist/floor.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./with-precision-BgF-Y_mF.cjs`);const e=require(`./floor-Bj0O0YjY.cjs`);exports.floor=e.floor;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./with-precision-dQAYLrgr.cjs`);function n(...n){return e.t(t.t(Math.floor),n)}exports.floor=n;

package/dist/floor.d.cts

@@ -1,2 +1,39 @@
-import { floor } from "./floor-bA1oX38x.cjs";
-export { floor };
+//#region src/floor.d.ts
+/**
+ * Rounds down a given number to a specific precision.
+ * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.floor` instead, as it won't incur the additional library overhead.
+ *
+ * @param value - The number to round down.
+ * @param precision - The precision to round down to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.floor(value, precision);
+ * @example
+ *    P.floor(123.9876, 3) // => 123.987
+ *    P.floor(483.22243, 1) // => 483.2
+ *    P.floor(8541, -1) // => 8540
+ *    P.floor(456789, -3) // => 456000
+ * @dataFirst
+ * @category Number
+ */
+declare function floor(value: number, precision: number): number;
+/**
+ * Rounds down a given number to a specific precision.
+ * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.floor` instead, as it won't incur the additional library overhead.
+ *
+ * @param precision - The precision to round down to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.floor(precision)(value);
+ * @example
+ *    P.floor(3)(123.9876) // => 123.987
+ *    P.floor(1)(483.22243) // => 483.2
+ *    P.floor(-1)(8541) // => 8540
+ *    P.floor(-3)(456789) // => 456000
+ * @dataLast
+ * @category Number
+ */
+declare function floor(precision: number): (value: number) => number;
+//#endregion
+export { floor };
+//# sourceMappingURL=floor.d.cts.map

package/dist/floor.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor.d.cts","names":[],"sources":["../src/floor.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,KAAA;;;;;;;;;;;;;;;;;iBAkBA,KAAA"}

package/dist/floor.d.ts

@@ -1,2 +1,39 @@
-import { floor } from "./floor-DTUexUEb.js";
-export { floor };
+//#region src/floor.d.ts
+/**
+ * Rounds down a given number to a specific precision.
+ * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.floor` instead, as it won't incur the additional library overhead.
+ *
+ * @param value - The number to round down.
+ * @param precision - The precision to round down to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.floor(value, precision);
+ * @example
+ *    P.floor(123.9876, 3) // => 123.987
+ *    P.floor(483.22243, 1) // => 483.2
+ *    P.floor(8541, -1) // => 8540
+ *    P.floor(456789, -3) // => 456000
+ * @dataFirst
+ * @category Number
+ */
+declare function floor(value: number, precision: number): number;
+/**
+ * Rounds down a given number to a specific precision.
+ * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),
+ * use `Math.floor` instead, as it won't incur the additional library overhead.
+ *
+ * @param precision - The precision to round down to. Must be an integer between -15 and 15.
+ * @signature
+ *    P.floor(precision)(value);
+ * @example
+ *    P.floor(3)(123.9876) // => 123.987
+ *    P.floor(1)(483.22243) // => 483.2
+ *    P.floor(-1)(8541) // => 8540
+ *    P.floor(-3)(456789) // => 456000
+ * @dataLast
+ * @category Number
+ */
+declare function floor(precision: number): (value: number) => number;
+//#endregion
+export { floor };
+//# sourceMappingURL=floor.d.ts.map

package/dist/floor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor.d.ts","names":[],"sources":["../src/floor.ts"],"sourcesContent":[],"mappings":";;AAoBA;AAkBA;;;;;;;;;;;;;;;iBAlBgB,KAAA;;;;;;;;;;;;;;;;;iBAkBA,KAAA"}

package/dist/floor.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./with-precision-BoiuafbM.js";import{floor as e}from"./floor-C_xareFD.js";export{e as floor};
+import{t as e}from"./curry-BcQ8Up1_.js";import{t}from"./with-precision-CWWiMmxZ.js";function n(...n){return e(t(Math.floor),n)}export{n as floor};
+//# sourceMappingURL=floor.js.map

package/dist/floor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor.js","names":[],"sources":["../src/floor.ts"],"sourcesContent":["import { curry } from './curry';\nimport { withPrecision } from './internal/with-precision';\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param value - The number to round down.\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    P.floor(value, precision);\n * @example\n *    P.floor(123.9876, 3) // => 123.987\n *    P.floor(483.22243, 1) // => 483.2\n *    P.floor(8541, -1) // => 8540\n *    P.floor(456789, -3) // => 456000\n * @dataFirst\n * @category Number\n */\nexport function floor(value: number, precision: number): number;\n\n/**\n * Rounds down a given number to a specific precision.\n * If you'd like to round down to an integer (i.e. use this function with constant `precision === 0`),\n * use `Math.floor` instead, as it won't incur the additional library overhead.\n *\n * @param precision - The precision to round down to. Must be an integer between -15 and 15.\n * @signature\n *    P.floor(precision)(value);\n * @example\n *    P.floor(3)(123.9876) // => 123.987\n *    P.floor(1)(483.22243) // => 483.2\n *    P.floor(-1)(8541) // => 8540\n *    P.floor(-3)(456789) // => 456000\n * @dataLast\n * @category Number\n */\nexport function floor(precision: number): (value: number) => number;\n\nexport function floor(...args: ReadonlyArray<unknown>): unknown {\n  return curry(withPrecision(Math.floor), args);\n}\n"],"mappings":"oFAwCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAc,KAAK,MAAM,CAAE,EAAK"}

package/dist/for-each-obj.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./for-each-obj-B6BJwtgs.cjs`);exports.forEachObj=e.forEachObj;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){for(let[n,r]of Object.entries(e))t(r,n,e);return e}exports.forEachObj=t;

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

@@ -1,5 +1,47 @@
-import "./to-string-gK5yUyfp.cjs";
-import "./enumerable-string-key-of-D2OpyD6n.cjs";
-import "./enumerable-string-keyed-value-of-aov5dXss.cjs";
-import { forEachObj } from "./for-each-obj-yV90UbvE.cjs";
-export { forEachObj };
+import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-FUg082M_.cjs";
+import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-CEclDoqe.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.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"for-each-obj.d.cts","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsBA;;;;;;;;AA4BA;;;;;;;;AAMmB,iBAlCH,UAkCG,CAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAjCX,CAiCW,EAAA,UAAA,EAAA,CAAA,KAAA,EA/BR,4BA+BQ,CA/BqB,CA+BrB,CAAA,EAAA,GAAA,EA9BV,qBA8BU,CA9BY,CA8BZ,CAAA,EAAA,GAAA,EA7BV,CA6BU,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA;;;;;;;;;;;;;;;;;;;;iBANH,iDAEL,6BAA6B,SAC/B,sBAAsB,SACtB,sBAEG,MAAM"}

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

@@ -1,5 +1,47 @@
-import "./to-string-B9YWszXY.js";
-import "./enumerable-string-key-of-nnI9DYHk.js";
-import "./enumerable-string-keyed-value-of-D0kMm_yz.js";
-import { forEachObj } from "./for-each-obj-q_fip-TI.js";
-export { forEachObj };
+import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-DMAkBhMk.js";
+import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-B2F2aTB7.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.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"for-each-obj.d.ts","names":[],"sources":["../src/for-each-obj.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsBA;;;;;;;;AA4BA;;;;;;;;AAMmB,iBAlCH,UAkCG,CAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAjCX,CAiCW,EAAA,UAAA,EAAA,CAAA,KAAA,EA/BR,4BA+BQ,CA/BqB,CA+BrB,CAAA,EAAA,GAAA,EA9BV,qBA8BU,CA9BY,CA8BZ,CAAA,EAAA,GAAA,EA7BV,CA6BU,EAAA,GAAA,IAAA,CAAA,EAAA,IAAA;;;;;;;;;;;;;;;;;;;;iBANH,iDAEL,6BAA6B,SAC/B,sBAAsB,SACtB,sBAEG,MAAM"}

package/dist/for-each-obj.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{forEachObj as e}from"./for-each-obj-CJFU3pj_.js";export{e as forEachObj};
+import{t as e}from"./curry-BcQ8Up1_.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.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"for-each-obj.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":"wCA0DA,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.cjs

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

package/dist/for-each.d.cts

@@ -1,3 +1,54 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { forEach } from "./for-each-CYTR5H9O.cjs";
-export { forEach };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.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.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"for-each.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.d.ts

@@ -1,3 +1,54 @@
-import "./iterable-container-F9CDF7ym.js";
-import { forEach } from "./for-each-C0JwQxWw.js";
-export { forEach };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.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.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"for-each.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.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{forEach as e}from"./for-each-ClKbAv3A.js";export{e as forEach};
+import{t as e}from"./curry-BcQ8Up1_.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.js.map

package/dist/for-each.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-each.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":"wCA4DA,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/from-entries.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./from-entries-DDkKcu-p.cjs`);exports.fromEntries=e.fromEntries;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(Object.fromEntries,t)}exports.fromEntries=t;

package/dist/from-entries.d.cts

@@ -1,4 +1,68 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import "./perkakas-type-error-0tHtaPbi.cjs";
-import { fromEntries } from "./from-entries-CToFI5yO.cjs";
-export { fromEntries };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { t as PerkakasTypeError } from "./perkakas-type-error-BERl_sWR.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.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"from-entries.d.cts","names":[],"sources":["../src/from-entries.ts"],"sourcesContent":[],"mappings":";;;;;KAOK,2CAA2C,iCAE9C;KAGG,kBAAkB,cAAc,0CALhC,GAAA,EAME,GANF,EAKA,KAAA,EAEI,KAFC,CAAa;KAYlB,WAZgC,CAAA,OAAA,CAAA,GAYT,OAZS,SAAA,SAAA,CAC9B,KAAA,MAAA,EACE,GAAA,KAAA,KAAA,CAAK,GAcV,gBAdU,CAcO,KAdP,EAcc,IAdd,CAAA,GAeV,OAfU,SAAA,SAAA,CAAA,GAAA,KAAA,KAAA,EAAA,KAAA,KAAA,CAAA,GAgBR,gBAhBQ,CAgBS,IAhBT,EAgBe,IAhBf,CAAA,GAiBR,OAjBQ,SAiBQ,iBAjBR,CAiB0B,KAjB1B,CAAA,GAkBN,gBAlBM,CAkBW,OAlBX,CAAA,GAmBN,gBAnBM,CAAA,0CAAA,CAAA;AAAA,KAwBT,gBAdW,CAAA,CAAA,EAAA,IAAA,CAAA,GAciB,CAdjB,SAc2B,KAd3B,GAeZ,WAfY,CAeA,IAfA,CAAA,GAeQ,MAfR,CAee,CAff,CAAA,CAAA,CAAA,EAeqB,CAfrB,CAAA,CAAA,CAAA,CAAA,GAgBZ,gBAhBY,CAAA,yCAAA,CAAA;KA4BX,gBA5BuB,CAAA,gBA4BU,iBA5BV,CA4B4B,KA5B5B,CAAA,CAAA,GAAA,MAAA,SA6BT,OA7BS,CA6BD,OA7BC,CAAA,GA8BtB,MA9BsB,CAAA,MAAA,EA8BP,OA9BO,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SA+BP,OA/BO,CA+BC,OA/BD,CAAA,GAgCpB,MAhCoB,CAAA,MAAA,EAgCL,OAhCK,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,MAAA,SAiCL,OAjCK,CAiCG,OAjCH,CAAA,GAkClB,MAlCkB,CAAA,MAAA,EAkCH,OAlCG,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,GAmClB,+BAnCkB,CAmCc,OAnCd,CAAA;KA0CvB,+BAtCgB,CAAA,gBAsCgC,iBAtChC,CAsCkD,KAtClD,CAAA,CAAA,GAAA,QAwCX,OAxCkB,CAwCV,OAxCU,CAAA,IAwCE,WAxCF,CAwCc,OAxCd,EAwCuB,CAxCvB,CAAA,EAAxB;KA2CC,OA1CD,CAAA,gBA0CyB,iBA1CzB,CA0C2C,KA1C3C,CAAA,CAAA,GA0CqD,OA1CrD,CA2CF,OA3CE,CAAA,MAAA,CAAA,EA4CF,KA5CE,CAAA,CAAA,CAAA,CAAA;KAqDC,WApDkB,CAAA,gBAqDL,iBArDK,CAqDa,KArDb,CAAA,EAAA,UAsDX,WAtDW,CAAA,GAAA,CAuDlB,OAvDkB,CAuDV,OAvDU,CAAA,MAAA,CAAA,EAuDO,KAvDP,CAuDa,CAvDb,CAAA,CAAA,SAAA,KAAA,GAwDnB,OAxDmB,CAAA,MAAA,CAAA,GAyDnB,OAzDmB,CAyDX,OAzDW,CAAA,MAAA,CAAA,EAyDM,KAzDN,CAyDY,CAzDZ,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;;;;;;;;;;AAGC;;;;;;;;;;AAOJ;;;;;AAcC,iBA2DL,WA3DK,CAAA,gBA2DuB,iBA3DvB,CA2DyC,KA3DzC,CAAA,CAAA,CAAA,OAAA,EA4DV,OA5DU,CAAA,EA6DlB,QA7DkB,CA6DT,WA7DS,CA6DG,OA7DH,CAAA,CAAA;;;;;;;;;;;;;AAKoB;;;;;;;;;AASA;;;;;AAGgB,iBAwEzC,WAAA,CAAA,CAxEyC,EAAA,CAAA,gBAwET,iBAxES,CAwES,KAxET,CAAA,CAAA,CAAA,OAAA,EAyE9C,OAzE8C,EAAA,GA0EpD,QA1EoD,CA0E3C,WA1E2C,CA0E/B,OA1E+B,CAAA,CAAA"}