@vinicunca/perkakas 1.8.0 → 1.12.0

package/dist/intersection-with.d.ts

@@ -1,2 +1,54 @@
-import { intersectionWith } from "./intersection-with-COmRebRq.js";
-export { intersectionWith };
+//#region src/intersection-with.d.ts
+type Comparator<TFirst, TSecond> = (a: TFirst, b: TSecond) => boolean;
+/**
+ * Returns a list of intersecting values based on a custom
+ * comparator function that compares elements of both arrays.
+ *
+ * @param array - The source array.
+ * @param other - The second array.
+ * @param comparator - The custom comparator.
+ * @signature
+ *    P.intersectionWith(array, other, comparator)
+ * @example
+ *    P.intersectionWith(
+ *      [
+ *        { id: 1, name: 'Ryan' },
+ *        { id: 3, name: 'Emma' },
+ *      ],
+ *      [3, 5],
+ *      (a, b) => a.id === b,
+ *    ) // => [{ id: 3, name: 'Emma' }]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function intersectionWith<TFirst, TSecond>(array: ReadonlyArray<TFirst>, other: ReadonlyArray<TSecond>, comparator: Comparator<TFirst, TSecond>): Array<TFirst>;
+/**
+ * Returns a list of intersecting values based on a custom
+ * comparator function that compares elements of both arrays.
+ *
+ * @param other - The second array.
+ * @param comparator - The custom comparator.
+ * @signature
+ *    P.intersectionWith(other, comparator)(array)
+ * @example
+ *    P.intersectionWith(
+ *      [3, 5],
+ *      (a, b) => a.id === b
+ *      )([
+ *        { id: 1, name: 'Ryan' },
+ *        { id: 3, name: 'Emma' },
+ *      ]); // => [{ id: 3, name: 'Emma' }]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function intersectionWith<TFirst, TSecond>(other: ReadonlyArray<TSecond>,
+/**
+ * Type inference doesn't work properly for the comparator's first parameter
+ * in data last variant.
+ */
+comparator: Comparator<TFirst, TSecond>): (array: ReadonlyArray<TFirst>) => Array<TFirst>;
+//#endregion
+export { intersectionWith };
+//# sourceMappingURL=intersection-with.d.ts.map

package/dist/intersection-with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection-with.d.ts","names":[],"sources":["../src/intersection-with.ts"],"sourcesContent":[],"mappings":";KAKK,kCAAkC,WAAW;;AAwBlD;;;;;;;;;;;AA0BA;;;;;;;;;;AAO0C,iBAjC1B,gBAiC0B,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,KAAA,EAhCjC,aAgCiC,CAhCnB,MAgCmB,CAAA,EAAA,KAAA,EA/BjC,aA+BiC,CA/BnB,OA+BmB,CAAA,EAAA,UAAA,EA9B5B,UA8B4B,CA9BjB,MA8BiB,EA9BT,OA8BS,CAAA,CAAA,EA7BvC,KA6BuC,CA7BjC,MA6BiC,CAAA;;;;;;;;;;;;;;;;;;;;;iBAP1B,yCACP,cAAc;;;;;YAKT,WAAW,QAAQ,mBACtB,cAAc,YAAY,MAAM"}

package/dist/intersection-with.js

@@ -1 +1,2 @@
-import"./utility-evaluators-CnQVdcZv.js";import"./pipe-CtsfTnqv.js";import"./curry-from-lazy-BR-hoRDR.js";import{intersectionWith as e}from"./intersection-with-DlHJvAUn.js";export{e as intersectionWith};
+import{t as e}from"./utility-evaluators-BwYLtB8b.js";import{t}from"./curry-from-lazy-CYtJvyas.js";function n(...e){return t(r,e)}function r(t,n){return r=>t.some(e=>n(r,e))?{done:!1,hasNext:!0,next:r}:e}export{n as intersectionWith};
+//# sourceMappingURL=intersection-with.js.map

package/dist/intersection-with.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection-with.js","names":[],"sources":["../src/intersection-with.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype Comparator<TFirst, TSecond> = (a: TFirst, b: TSecond) => boolean;\n\n/**\n * Returns a list of intersecting values based on a custom\n * comparator function that compares elements of both arrays.\n *\n * @param array - The source array.\n * @param other - The second array.\n * @param comparator - The custom comparator.\n * @signature\n *    P.intersectionWith(array, other, comparator)\n * @example\n *    P.intersectionWith(\n *      [\n *        { id: 1, name: 'Ryan' },\n *        { id: 3, name: 'Emma' },\n *      ],\n *      [3, 5],\n *      (a, b) => a.id === b,\n *    ) // => [{ id: 3, name: 'Emma' }]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function intersectionWith<TFirst, TSecond>(\n  array: ReadonlyArray<TFirst>,\n  other: ReadonlyArray<TSecond>,\n  comparator: Comparator<TFirst, TSecond>,\n): Array<TFirst>;\n\n/**\n * Returns a list of intersecting values based on a custom\n * comparator function that compares elements of both arrays.\n *\n * @param other - The second array.\n * @param comparator - The custom comparator.\n * @signature\n *    P.intersectionWith(other, comparator)(array)\n * @example\n *    P.intersectionWith(\n *      [3, 5],\n *      (a, b) => a.id === b\n *      )([\n *        { id: 1, name: 'Ryan' },\n *        { id: 3, name: 'Emma' },\n *      ]); // => [{ id: 3, name: 'Emma' }]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function intersectionWith<TFirst, TSecond>(\n  other: ReadonlyArray<TSecond>,\n  /**\n   * Type inference doesn't work properly for the comparator's first parameter\n   * in data last variant.\n   */\n  comparator: Comparator<TFirst, TSecond>,\n): (array: ReadonlyArray<TFirst>) => Array<TFirst>;\n\nexport function intersectionWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<TFirst, TSecond>(\n  other: ReadonlyArray<TSecond>,\n  comparator: Comparator<TFirst, TSecond>,\n): LazyEvaluator<TFirst> {\n  return (value) =>\n    other.some((otherValue) => comparator(value, otherValue))\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n}\n"],"mappings":"kGAgEA,SAAgB,EAAiB,GAAG,EAAuC,CACzE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EACP,EACA,EACuB,CACvB,MAAQ,IACN,EAAM,KAAM,GAAe,EAAW,EAAO,EAAW,CAAC,CACrD,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3C"}

package/dist/intersection.cjs

@@ -1 +1 @@
-require(`./utility-evaluators-DqJcWENu.cjs`),require(`./pipe-DlFjc4Wf.cjs`),require(`./curry-from-lazy-BDH06qZ-.cjs`);const e=require(`./intersection-pxjmHAj1.cjs`);exports.intersection=e.intersection;
+const e=require(`./utility-evaluators-CAbODbuk.cjs`),t=require(`./curry-from-lazy-BCGvmhyS.cjs`);function n(...e){return t.t(r,e)}function r(t){if(t.length===0)return e.n;let n=new Map;for(let e of t)n.set(e,(n.get(e)??0)+1);return t=>{let r=n.get(t);return r===void 0||r===0?e.t:(r===1?n.delete(t):n.set(t,r-1),{hasNext:!0,next:t,done:n.size===0})}}exports.intersection=n;

package/dist/intersection.d.cts

@@ -1,2 +1,37 @@
-import { intersection } from "./intersection-CaBWENw7.cjs";
-export { intersection };
+//#region src/intersection.d.ts
+/**
+ * Returns a list of elements that exist in both array. The output maintains the
+ * same order as the input. The inputs are treated as multi-sets/bags (multiple
+ * copies of items are treated as unique items).
+ *
+ * @param data - The input items.
+ * @param other - The items to compare against.
+ * @signature
+ *    P.intersection(data, other)
+ * @example
+ *    P.intersection([1, 2, 3], [2, 3, 5]); // => [2, 3]
+ *    P.intersection([1, 1, 2, 2], [1]); // => [1]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function intersection<T, S>(data: ReadonlyArray<T>, other: ReadonlyArray<S>): Array<S & T>;
+/**
+ * Returns a list of elements that exist in both array. The output maintains the
+ * same order as the input. The inputs are treated as multi-sets/bags (multiple
+ * copies of items are treated as unique items).
+ *
+ * @param other - The items to compare against.
+ * @signature
+ *    P.intersection(other)(data)
+ * @example
+ *    P.pipe([1, 2, 3], P.intersection([2, 3, 5])); // => [2, 3]
+ *    P.pipe([1, 1, 2, 2], P.intersection([1])); // => [1]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function intersection<S>(other: ReadonlyArray<S>): <T>(data: ReadonlyArray<T>) => Array<S & T>;
+//#endregion
+export { intersection };
+//# sourceMappingURL=intersection.d.cts.map

package/dist/intersection.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.d.cts","names":[],"sources":["../src/intersection.ts"],"sourcesContent":[],"mappings":";;AAqBA;;;;;;;;;AAoBA;;;;;;AAE4C,iBAtB5B,YAsB4B,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EArBpC,aAqBoC,CArBtB,CAqBsB,CAAA,EAAA,KAAA,EApBnC,aAoBmC,CApBrB,CAoBqB,CAAA,CAAA,EAnBzC,KAmByC,CAnBnC,CAmBmC,GAnB/B,CAmB+B,CAAA;;;;;;;;;;;;;;;;iBAF5B,uBACP,cAAc,eACV,cAAc,OAAO,MAAM,IAAI"}

package/dist/intersection.d.ts

@@ -1,2 +1,37 @@
-import { intersection } from "./intersection-DJQJxp9k.js";
-export { intersection };
+//#region src/intersection.d.ts
+/**
+ * Returns a list of elements that exist in both array. The output maintains the
+ * same order as the input. The inputs are treated as multi-sets/bags (multiple
+ * copies of items are treated as unique items).
+ *
+ * @param data - The input items.
+ * @param other - The items to compare against.
+ * @signature
+ *    P.intersection(data, other)
+ * @example
+ *    P.intersection([1, 2, 3], [2, 3, 5]); // => [2, 3]
+ *    P.intersection([1, 1, 2, 2], [1]); // => [1]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function intersection<T, S>(data: ReadonlyArray<T>, other: ReadonlyArray<S>): Array<S & T>;
+/**
+ * Returns a list of elements that exist in both array. The output maintains the
+ * same order as the input. The inputs are treated as multi-sets/bags (multiple
+ * copies of items are treated as unique items).
+ *
+ * @param other - The items to compare against.
+ * @signature
+ *    P.intersection(other)(data)
+ * @example
+ *    P.pipe([1, 2, 3], P.intersection([2, 3, 5])); // => [2, 3]
+ *    P.pipe([1, 1, 2, 2], P.intersection([1])); // => [1]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function intersection<S>(other: ReadonlyArray<S>): <T>(data: ReadonlyArray<T>) => Array<S & T>;
+//#endregion
+export { intersection };
+//# sourceMappingURL=intersection.d.ts.map

package/dist/intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.d.ts","names":[],"sources":["../src/intersection.ts"],"sourcesContent":[],"mappings":";;AAqBA;;;;;;;;;AAoBA;;;;;;AAE4C,iBAtB5B,YAsB4B,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,IAAA,EArBpC,aAqBoC,CArBtB,CAqBsB,CAAA,EAAA,KAAA,EApBnC,aAoBmC,CApBrB,CAoBqB,CAAA,CAAA,EAnBzC,KAmByC,CAnBnC,CAmBmC,GAnB/B,CAmB+B,CAAA;;;;;;;;;;;;;;;;iBAF5B,uBACP,cAAc,eACV,cAAc,OAAO,MAAM,IAAI"}

package/dist/intersection.js

@@ -1 +1,2 @@
-import"./utility-evaluators-CnQVdcZv.js";import"./pipe-CtsfTnqv.js";import"./curry-from-lazy-BR-hoRDR.js";import{intersection as e}from"./intersection-Crt0YdjH.js";export{e as intersection};
+import{n as e,t}from"./utility-evaluators-BwYLtB8b.js";import{t as n}from"./curry-from-lazy-CYtJvyas.js";function r(...e){return n(i,e)}function i(n){if(n.length===0)return e;let r=new Map;for(let e of n)r.set(e,(r.get(e)??0)+1);return e=>{let n=r.get(e);return n===void 0||n===0?t:(n===1?r.delete(e):r.set(e,n-1),{hasNext:!0,next:e,done:r.size===0})}}export{r as intersection};
+//# sourceMappingURL=intersection.js.map

package/dist/intersection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersection.js","names":[],"sources":["../src/intersection.ts"],"sourcesContent":["import type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { lazyEmptyEvaluator, SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a list of elements that exist in both array. The output maintains the\n * same order as the input. The inputs are treated as multi-sets/bags (multiple\n * copies of items are treated as unique items).\n *\n * @param data - The input items.\n * @param other - The items to compare against.\n * @signature\n *    P.intersection(data, other)\n * @example\n *    P.intersection([1, 2, 3], [2, 3, 5]); // => [2, 3]\n *    P.intersection([1, 1, 2, 2], [1]); // => [1]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function intersection<T, S>(\n  data: ReadonlyArray<T>,\n  other: ReadonlyArray<S>,\n): Array<S & T>;\n\n/**\n * Returns a list of elements that exist in both array. The output maintains the\n * same order as the input. The inputs are treated as multi-sets/bags (multiple\n * copies of items are treated as unique items).\n *\n * @param other - The items to compare against.\n * @signature\n *    P.intersection(other)(data)\n * @example\n *    P.pipe([1, 2, 3], P.intersection([2, 3, 5])); // => [2, 3]\n *    P.pipe([1, 1, 2, 2], P.intersection([1])); // => [1]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function intersection<S>(\n  other: ReadonlyArray<S>,\n): <T>(data: ReadonlyArray<T>) => Array<S & T>;\n\nexport function intersection(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T, S>(\n  other: ReadonlyArray<S>,\n): LazyEvaluator<T, S & T> {\n  if (other.length === 0) {\n    return lazyEmptyEvaluator;\n  }\n\n  // We need to build a more efficient data structure that would allow us to\n  // keep track of the number of times we've seen a value in the other array.\n  const remaining = new Map<S | T, number>();\n  for (const value of other) {\n    remaining.set(value, (remaining.get(value) ?? 0) + 1);\n  }\n\n  return (value) => {\n    const copies = remaining.get(value);\n\n    if (copies === undefined || copies === 0) {\n      // The item is either not part of the other array or we've \"used\" enough\n      // copies of it so we skip the remaining values.\n      return SKIP_ITEM;\n    }\n\n    // The item is equal to an item in the other array and there are still\n    // copies of it to \"account\" for so we return this one and remove it from\n    // our ongoing tally.\n    if (copies === 1) {\n      remaining.delete(value);\n    } else {\n      remaining.set(value, copies - 1);\n    }\n\n    return {\n      hasNext: true,\n      // We can safely cast here because if value was in the `remaining` map, it\n      // has to be of type S (that's just how we built it).\n      next: value as S & T,\n      // We can stop the iteration if the remaining map is empty.\n      done: remaining.size === 0,\n    };\n  };\n}\n"],"mappings":"yGA6CA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EACP,EACyB,CACzB,GAAI,EAAM,SAAW,EACnB,OAAO,EAKT,IAAM,EAAY,IAAI,IACtB,IAAK,IAAM,KAAS,EAClB,EAAU,IAAI,GAAQ,EAAU,IAAI,EAAM,EAAI,GAAK,EAAE,CAGvD,MAAQ,IAAU,CAChB,IAAM,EAAS,EAAU,IAAI,EAAM,CAiBnC,OAfI,IAAW,IAAA,IAAa,IAAW,EAG9B,GAML,IAAW,EACb,EAAU,OAAO,EAAM,CAEvB,EAAU,IAAI,EAAO,EAAS,EAAE,CAG3B,CACL,QAAS,GAGT,KAAM,EAEN,KAAM,EAAU,OAAS,EAC1B"}

package/dist/invert.cjs

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

package/dist/invert.d.cts

@@ -1,3 +1,33 @@
-import "./to-string-gK5yUyfp.cjs";
-import { invert } from "./invert-W6EUYMws.cjs";
-export { invert };
+import { t as ToString } from "./to-string-Se4KcQka.cjs";
+import { Simplify } from "type-fest";
+
+//#region src/invert.d.ts
+type Inverted<T extends object> = Simplify<{ -readonly [K in keyof T as K extends number | string ? Required<T>[K] extends PropertyKey ? Required<T>[K] : never : never]: ToString<K> }>;
+/**
+ * Returns an object whose keys and values are swapped. If the object contains duplicate values,
+ * subsequent values will overwrite previous values.
+ *
+ * @param object - The object.
+ * @signature
+ *    P.invert(object)
+ * @example
+ *    P.invert({ a: "d", b: "e", c: "f" }) // => { d: "a", e: "b", f: "c" }
+ * @dataFirst
+ * @category Object
+ */
+declare function invert<T extends object>(object: T): Inverted<T>;
+/**
+ * Returns an object whose keys and values are swapped. If the object contains duplicate values,
+ * subsequent values will overwrite previous values.
+ *
+ * @signature
+ *    P.invert()(object)
+ * @example
+ *    P.pipe({ a: "d", b: "e", c: "f" }, P.invert()); // => { d: "a", e: "b", f: "c" }
+ * @dataLast
+ * @category Object
+ */
+declare function invert<T extends object>(): (object: T) => Inverted<T>;
+//#endregion
+export { invert };
+//# sourceMappingURL=invert.d.cts.map

package/dist/invert.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invert.d.cts","names":[],"sources":["../src/invert.ts"],"sourcesContent":[],"mappings":";;;;KAKK,6BAA6B,iCACV,KAAK,4BACvB,SAAS,GAAG,WAAW,cACrB,SAAS,GAAG,qBAEN,SAAS,IARoC,CAAA;;;;;;;;;;;;;AAGjB,iBAoB1B,MApB0B,CAAA,UAAA,MAAA,CAAA,CAAA,MAAA,EAoBO,CApBP,CAAA,EAoBW,QApBX,CAoBoB,CApBpB,CAAA;AAoB1C;;;;;AAaA;;;;;;iBAAgB,qCAAqC,MAAM,SAAS"}

package/dist/invert.d.ts

@@ -1,3 +1,33 @@
-import "./to-string-RweoJgSy.js";
-import { invert } from "./invert-DMSQXxyb.js";
-export { invert };
+import { t as ToString } from "./to-string-C6_OnZ6e.js";
+import { Simplify } from "type-fest";
+
+//#region src/invert.d.ts
+type Inverted<T extends object> = Simplify<{ -readonly [K in keyof T as K extends number | string ? Required<T>[K] extends PropertyKey ? Required<T>[K] : never : never]: ToString<K> }>;
+/**
+ * Returns an object whose keys and values are swapped. If the object contains duplicate values,
+ * subsequent values will overwrite previous values.
+ *
+ * @param object - The object.
+ * @signature
+ *    P.invert(object)
+ * @example
+ *    P.invert({ a: "d", b: "e", c: "f" }) // => { d: "a", e: "b", f: "c" }
+ * @dataFirst
+ * @category Object
+ */
+declare function invert<T extends object>(object: T): Inverted<T>;
+/**
+ * Returns an object whose keys and values are swapped. If the object contains duplicate values,
+ * subsequent values will overwrite previous values.
+ *
+ * @signature
+ *    P.invert()(object)
+ * @example
+ *    P.pipe({ a: "d", b: "e", c: "f" }, P.invert()); // => { d: "a", e: "b", f: "c" }
+ * @dataLast
+ * @category Object
+ */
+declare function invert<T extends object>(): (object: T) => Inverted<T>;
+//#endregion
+export { invert };
+//# sourceMappingURL=invert.d.ts.map

package/dist/invert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invert.d.ts","names":[],"sources":["../src/invert.ts"],"sourcesContent":[],"mappings":";;;;KAKK,6BAA6B,iCACV,KAAK,4BACvB,SAAS,GAAG,WAAW,cACrB,SAAS,GAAG,qBAEN,SAAS,IARoC,CAAA;;;;;;;;;;;;;AAGjB,iBAoB1B,MApB0B,CAAA,UAAA,MAAA,CAAA,CAAA,MAAA,EAoBO,CApBP,CAAA,EAoBW,QApBX,CAoBoB,CApBpB,CAAA;AAoB1C;;;;;AAaA;;;;;;iBAAgB,qCAAqC,MAAM,SAAS"}

package/dist/invert.js

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

package/dist/invert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invert.js","names":["result: Record<PropertyKey, PropertyKey>"],"sources":["../src/invert.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\n\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Inverted<T extends object> = Simplify<{\n  -readonly [K in keyof T as K extends number | string\n    ? Required<T>[K] extends PropertyKey\n      ? Required<T>[K]\n      : never\n    : never]: ToString<K>;\n}>;\n\n/**\n * Returns an object whose keys and values are swapped. If the object contains duplicate values,\n * subsequent values will overwrite previous values.\n *\n * @param object - The object.\n * @signature\n *    P.invert(object)\n * @example\n *    P.invert({ a: \"d\", b: \"e\", c: \"f\" }) // => { d: \"a\", e: \"b\", f: \"c\" }\n * @dataFirst\n * @category Object\n */\nexport function invert<T extends object>(object: T): Inverted<T>;\n\n/**\n * Returns an object whose keys and values are swapped. If the object contains duplicate values,\n * subsequent values will overwrite previous values.\n *\n * @signature\n *    P.invert()(object)\n * @example\n *    P.pipe({ a: \"d\", b: \"e\", c: \"f\" }, P.invert()); // => { d: \"a\", e: \"b\", f: \"c\" }\n * @dataLast\n * @category Object\n */\nexport function invert<T extends object>(): (object: T) => Inverted<T>;\n\nexport function invert(...args: ReadonlyArray<unknown>): unknown {\n  return curry(invertImplementation, args);\n}\n\nfunction invertImplementation(\n  data: Readonly<Record<PropertyKey, PropertyKey>>,\n): Record<PropertyKey, PropertyKey> {\n  const result: Record<PropertyKey, PropertyKey> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    result[value] = key;\n  }\n\n  return result;\n}\n"],"mappings":"wCAwCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACkC,CAClC,IAAMA,EAA2C,EAAE,CAEnD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAC7C,EAAO,GAAS,EAGlB,OAAO"}

package/dist/is-array.cjs

@@ -1 +1 @@
-const e=require(`./is-array-KzYs6pgh.cjs`);exports.isArray=e.isArray;
+function e(e){return Array.isArray(e)}exports.isArray=e;

package/dist/is-array.d.cts

@@ -1,3 +1,21 @@
-import "./narrowed-to-BTrqm7Xt.cjs";
-import { isArray } from "./is-array-DAz7gkMm.cjs";
-export { isArray };
+import { t as NarrowedTo } from "./narrowed-to-Yf5qTOcD.cjs";
+
+//#region src/is-array.d.ts
+
+/**
+ * A function that checks if the passed parameter is an Array and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is an Array, false otherwise.
+ * @signature
+ *    P.isArray(data)
+ * @example
+ *    P.isArray([5]) //=> true
+ *    P.isArray([]) //=> true
+ *    P.isArray('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isArray<T>(data: ArrayLike<unknown> | T): data is NarrowedTo<T, ReadonlyArray<unknown>>;
+//#endregion
+export { isArray };
+//# sourceMappingURL=is-array.d.cts.map

package/dist/is-array.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-array.d.cts","names":[],"sources":["../src/is-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAeA;;;;;;;;;;;iBAAgB,iBACR,qBAAqB,YAClB,WAAW,GAAG"}

package/dist/is-array.d.ts

@@ -1,3 +1,21 @@
-import "./narrowed-to-C6wP224-.js";
-import { isArray } from "./is-array-prXR4sUC.js";
-export { isArray };
+import { t as NarrowedTo } from "./narrowed-to-j75i8Rl2.js";
+
+//#region src/is-array.d.ts
+
+/**
+ * A function that checks if the passed parameter is an Array and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is an Array, false otherwise.
+ * @signature
+ *    P.isArray(data)
+ * @example
+ *    P.isArray([5]) //=> true
+ *    P.isArray([]) //=> true
+ *    P.isArray('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isArray<T>(data: ArrayLike<unknown> | T): data is NarrowedTo<T, ReadonlyArray<unknown>>;
+//#endregion
+export { isArray };
+//# sourceMappingURL=is-array.d.ts.map

package/dist/is-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-array.d.ts","names":[],"sources":["../src/is-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAeA;;;;;;;;;;;iBAAgB,iBACR,qBAAqB,YAClB,WAAW,GAAG"}

package/dist/is-array.js

@@ -1 +1,2 @@
-import{isArray as e}from"./is-array-DWFX2okh.js";export{e as isArray};
+function e(e){return Array.isArray(e)}export{e as isArray};
+//# sourceMappingURL=is-array.js.map

package/dist/is-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-array.js","names":[],"sources":["../src/is-array.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is an Array and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is an Array, false otherwise.\n * @signature\n *    P.isArray(data)\n * @example\n *    P.isArray([5]) //=> true\n *    P.isArray([]) //=> true\n *    P.isArray('somethingElse') //=> false\n * @category Guard\n */\nexport function isArray<T>(\n  data: ArrayLike<unknown> | T,\n): data is NarrowedTo<T, ReadonlyArray<unknown>> {\n  return Array.isArray(data);\n}\n"],"mappings":"AAeA,SAAgB,EACd,EAC+C,CAC/C,OAAO,MAAM,QAAQ,EAAK"}

package/dist/is-big-int.cjs

@@ -1 +1 @@
-const e=require(`./is-big-int-Cgisg7DN.cjs`);exports.isBigInt=e.isBigInt;
+function e(e){return typeof e==`bigint`}exports.isBigInt=e;

package/dist/is-big-int.d.cts

@@ -1,3 +1,22 @@
-import "./narrowed-to-BTrqm7Xt.cjs";
-import { isBigInt } from "./is-big-int-Dow1Lswh.cjs";
-export { isBigInt };
+import { t as NarrowedTo } from "./narrowed-to-Yf5qTOcD.cjs";
+
+//#region src/is-big-int.d.ts
+
+/**
+ * A function that checks if the passed parameter is a bigint and narrows its
+ * type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a number, false otherwise.
+ * @signature
+ *    P.isBigInt(data)
+ * @example
+ *    P.isBigInt(1n); // => true
+ *    P.isBigInt(1); // => false
+ *    P.isBigInt('notANumber'); // => false
+ * @category Guard
+ */
+declare function isBigInt<T>(data: bigint | T): data is NarrowedTo<T, bigint>;
+//#endregion
+export { isBigInt };
+//# sourceMappingURL=is-big-int.d.cts.map

package/dist/is-big-int.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-big-int.d.cts","names":[],"sources":["../src/is-big-int.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;;;;;;;iBAAgB,2BAA2B,YAAY,WAAW"}

package/dist/is-big-int.d.ts

@@ -1,3 +1,22 @@
-import "./narrowed-to-C6wP224-.js";
-import { isBigInt } from "./is-big-int-e123CwI2.js";
-export { isBigInt };
+import { t as NarrowedTo } from "./narrowed-to-j75i8Rl2.js";
+
+//#region src/is-big-int.d.ts
+
+/**
+ * A function that checks if the passed parameter is a bigint and narrows its
+ * type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a number, false otherwise.
+ * @signature
+ *    P.isBigInt(data)
+ * @example
+ *    P.isBigInt(1n); // => true
+ *    P.isBigInt(1); // => false
+ *    P.isBigInt('notANumber'); // => false
+ * @category Guard
+ */
+declare function isBigInt<T>(data: bigint | T): data is NarrowedTo<T, bigint>;
+//#endregion
+export { isBigInt };
+//# sourceMappingURL=is-big-int.d.ts.map

package/dist/is-big-int.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-big-int.d.ts","names":[],"sources":["../src/is-big-int.ts"],"sourcesContent":[],"mappings":";;;;;;AAgBA;;;;;;;;;;;;iBAAgB,2BAA2B,YAAY,WAAW"}

package/dist/is-big-int.js

@@ -1 +1,2 @@
-import{isBigInt as e}from"./is-big-int-CnWK6SmP.js";export{e as isBigInt};
+function e(e){return typeof e==`bigint`}export{e as isBigInt};
+//# sourceMappingURL=is-big-int.js.map

package/dist/is-big-int.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-big-int.js","names":[],"sources":["../src/is-big-int.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a bigint and narrows its\n * type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a number, false otherwise.\n * @signature\n *    P.isBigInt(data)\n * @example\n *    P.isBigInt(1n); // => true\n *    P.isBigInt(1); // => false\n *    P.isBigInt('notANumber'); // => false\n * @category Guard\n */\nexport function isBigInt<T>(data: bigint | T): data is NarrowedTo<T, bigint> {\n  return typeof data === 'bigint';\n}\n"],"mappings":"AAgBA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS"}

package/dist/is-boolean.cjs

@@ -1 +1 @@
-const e=require(`./is-boolean-DADmOIbu.cjs`);exports.isBoolean=e.isBoolean;
+function e(e){return typeof e==`boolean`}exports.isBoolean=e;

package/dist/is-boolean.d.cts

@@ -1,3 +1,21 @@
-import "./narrowed-to-BTrqm7Xt.cjs";
-import { isBoolean } from "./is-boolean-NhoGl1jZ.cjs";
-export { isBoolean };
+import { t as NarrowedTo } from "./narrowed-to-Yf5qTOcD.cjs";
+
+//#region src/is-boolean.d.ts
+
+/**
+ * A function that checks if the passed parameter is a boolean and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a boolean, false otherwise.
+ * @signature
+ *    P.isBoolean(data)
+ * @example
+ *    P.isBoolean(true) //=> true
+ *    P.isBoolean(false) //=> true
+ *    P.isBoolean('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isBoolean<T>(data: boolean | T): data is NarrowedTo<T, boolean>;
+//#endregion
+export { isBoolean };
+//# sourceMappingURL=is-boolean.d.cts.map

package/dist/is-boolean.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-boolean.d.cts","names":[],"sources":["../src/is-boolean.ts"],"sourcesContent":[],"mappings":";;;;;;AAeA;;;;;;;;;;;iBAAgB,6BACE,YACP,WAAW"}

package/dist/is-boolean.d.ts

@@ -1,3 +1,21 @@
-import "./narrowed-to-C6wP224-.js";
-import { isBoolean } from "./is-boolean-DWuHhrIe.js";
-export { isBoolean };
+import { t as NarrowedTo } from "./narrowed-to-j75i8Rl2.js";
+
+//#region src/is-boolean.d.ts
+
+/**
+ * A function that checks if the passed parameter is a boolean and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a boolean, false otherwise.
+ * @signature
+ *    P.isBoolean(data)
+ * @example
+ *    P.isBoolean(true) //=> true
+ *    P.isBoolean(false) //=> true
+ *    P.isBoolean('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isBoolean<T>(data: boolean | T): data is NarrowedTo<T, boolean>;
+//#endregion
+export { isBoolean };
+//# sourceMappingURL=is-boolean.d.ts.map

package/dist/is-boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-boolean.d.ts","names":[],"sources":["../src/is-boolean.ts"],"sourcesContent":[],"mappings":";;;;;;AAeA;;;;;;;;;;;iBAAgB,6BACE,YACP,WAAW"}

package/dist/is-boolean.js

@@ -1 +1,2 @@
-import{isBoolean as e}from"./is-boolean-CZKz4ij3.js";export{e as isBoolean};
+function e(e){return typeof e==`boolean`}export{e as isBoolean};
+//# sourceMappingURL=is-boolean.js.map

package/dist/is-boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-boolean.js","names":[],"sources":["../src/is-boolean.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a boolean and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a boolean, false otherwise.\n * @signature\n *    P.isBoolean(data)\n * @example\n *    P.isBoolean(true) //=> true\n *    P.isBoolean(false) //=> true\n *    P.isBoolean('somethingElse') //=> false\n * @category Guard\n */\nexport function isBoolean<T>(\n  data: boolean | T,\n): data is NarrowedTo<T, boolean> {\n  return typeof data === 'boolean';\n}\n"],"mappings":"AAeA,SAAgB,EACd,EACgC,CAChC,OAAO,OAAO,GAAS"}

package/dist/is-bounded-record-BGclJjRX.d.ts

@@ -0,0 +1,34 @@
+import { IsNumericLiteral, IsStringLiteral, IsSymbolLiteral, KeysOfUnion, Or, Split } from "type-fest";
+
+//#region src/internal/types/is-bounded.d.ts
+
+/**
+ * Checks if a type is a bounded key: a union of bounded strings, numeric
+ * literals, or symbol literals.
+ *
+ * [For an interactive deeper dive and explanation see the following playground](https://www.typescriptlang.org/play/?noUncheckedIndexedAccess=true#code/PTAEBUAsEsGdQE4FMDGB7BATUdQCIAjNAVwDtMlM8AaHAF1EgEN4nQAzaU6OpUWJAzTtQAayQBPWADpQASQZMANrDSIkAR2LRk8HgHJYAKBCg0BAFaoGdNcwBufZUrMi6kJAFtpRuhIAOfABCJOSUoAC8oABKqBiYADwABv7InAAeAPoAJADeeB5KSmh4oAA++ADuGEpUAL5JtHiqnoIwpADmeAB8ANxGJmBQuMjoWDjweGREZBRUtDyMLKBMpDiknNy8-IKuoP5osLDQBEp84lKyCoaDZpbWoOjEtY9opHRMXKCkb3zCoO4vAC0GgfH5AqAAKqkGZhbBRWJjRIpNLQLJ5WB0BBcDoNJotNo4nr9W4AMQwK1IEggAC4IKAkOleOR4AAFJgIOjQZQJcDdUAEakUTZct60AjEGwedaOBACCbfNCKJSVJhSW5Y4hIWQAdQ8a0WuE1fEqfBQq34aoBzAY4AV0E8-iU0BQPCU1P8HK5ylAAApDcZTJptPZlEh3sDQOzOdylLzugBKXwBPhyWByR3O110d3R71xvmRKNe2PxhlM8OYeB2gD8+AkpTpeFIeBJpj14ZWKBQSCOOJW+wQaH8e0BAtCczuVhQtpTAGUUNj-AxzWtw7BiMhrUwGKlh7dGXA6Ho1mPzNPFOQGaQN1uePBwdqjBQUEoOWa3pjQEEAPKQgByAAiACigF0iEsyUP06A3gwsKTlEv4ASBgEANp4KkSAZJkhTFHgAC6-SmKAJEAHo1gM7b6l2PZ9p0A57iO-xjtME7hOe1i0JU1H6D80IoB4KDiJgchhOklAAILdr2sBJLcuDhkwpzhOA86LtAy6PBabzutet4mjaAIpvQoAAFSeNAHSQHQpkCkg4qSisKhoLcMHHBQCDWmaLAGUgd4MJgaC9qQ+gMIeX5fGe9wzrQqgmU8LzKHFBBILcSSQZslBJD4L5vlubkMABSFAaBdLQvBUFGAVoCsZB8JQv+xUoehmHYbhJSEbcJGgORlFDDAegPggWocBSpmmasEjjYOw57EVf4lYBvSgNxLqQKArSrA+hnODN-jwMItzzchoErFueDDqKpDKDQK0wAJCqMkwM66dxO6gEkealo+-zHYt3RyaYm03jsnirFy5pFBIy1xaa+jYIygQztaRpqMgdCbms+gSPoDkMIs6OY-AvH6AAhMmEJpuVbEiZmLpuhIX0+lEaYZk69M5ozJY8tTdV9F1PUUbcervbt7i4MDg3bvjaxg1SWkCLAtC9kjsa6e4hx8O4726MwEKrLcHHI6aG2WdZ3xIOEthLOQZzjnVlLYLVcLqEi8ACJ6CA7u6tCrJgrmrKF6i6W8OB09mrx+a6n7K44azcZ2gLUmD4g7De2rSD4QA).
+ */
+type IsBounded<T> = (T extends unknown ? Or<IsBoundedString<T>, Or<IsNumericLiteral<T>, IsSymbolLiteral<T>>> : never) extends true ? true : false;
+/**
+ * Literal strings can be unbounded when they are a template literal which
+ * contains non-literal components (e.g. `prefix_${string}`), this is because
+ * there are an infinite number of possible values that satisfy it.
+ */
+type IsBoundedString<T> = T extends string ? IsStringLiteral<T> extends true ? Split<T, ''>[number] extends infer U ? [`${number}`] extends [U] ? false : [string] extends [U] ? false : true : false : false : false;
+//#endregion
+//#region src/internal/types/is-bounded-record.d.ts
+/**
+ * Check if a type is guaranteed to be a bounded record: a record with a finite
+ * set of keys.
+ *
+ * See the docs for `IsBounded` to understand more.
+ *
+ * @example
+ *   IsBoundedRecord<{ a: 1, 1: "a" }>; //=> true
+ *   IsBoundedRecord<Record<string | number, unknown>>; //=> false
+ *   IsBoundedRecord<Record<`prefix_${number}`, unknown>>; //=> false
+ */
+type IsBoundedRecord<T> = IsBounded<KeysOfUnion<T>>;
+//#endregion
+export { IsBounded as n, IsBoundedRecord as t };
+//# sourceMappingURL=is-bounded-record-BGclJjRX.d.ts.map

package/dist/is-bounded-record-BGclJjRX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-bounded-record-BGclJjRX.d.ts","names":[],"sources":["../src/internal/types/is-bounded.ts","../src/internal/types/is-bounded-record.ts"],"sourcesContent":[],"mappings":";;;;;;AAcA;;;;AAKmD,KALvC,SAKuC,CAAA,CAAA,CAAA,GAAA,CAD/C,CAC+C,SAAA,OAAA,GAA3C,EAA2C,CAAxC,eAAwC,CAAxB,CAAwB,CAAA,EAApB,EAAoB,CAAjB,gBAAiB,CAAA,CAAA,CAAA,EAAI,eAAJ,CAAoB,CAApB,CAAA,CAAA,CAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA;;;;;;KAgB9C,eAhBK,CAAA,CAAA,CAAA,GAgBgB,CAhBhB,SAAA,MAAA,GAiBN,eAjBM,CAiBU,CAjBV,CAAA,SAAA,IAAA,GAmBJ,KAnBI,CAmBE,CAnBF,EAAA,EAAA,CAAA,CAAA,MAAA,CAAA,SAAA,KAAA,EAAA,GAAA,CAAA,GAAA,MAAA,EAAA,CAAA,SAAA,CAqBqB,CArBrB,CAAA,GAAA,KAAA,GAAA,CAAA,MAAA,CAAA,SAAA,CAuBoB,CAvBpB,CAAA,GAAA,KAAA,GAAA,IAAA,GAAA,KAAA,GAAA,KAAA,GAAA,KAAA;;;;AALV;;;;;;;;;;AAKU,KCLE,eDKF,CAAA,CAAA,CAAA,GCLuB,SDKvB,CCLiC,WDKjC,CCL6C,CDK7C,CAAA,CAAA"}

package/dist/is-bounded-record-D9YK_OC8.d.cts

@@ -0,0 +1,34 @@
+import { IsNumericLiteral, IsStringLiteral, IsSymbolLiteral, KeysOfUnion, Or, Split } from "type-fest";
+
+//#region src/internal/types/is-bounded.d.ts
+
+/**
+ * Checks if a type is a bounded key: a union of bounded strings, numeric
+ * literals, or symbol literals.
+ *
+ * [For an interactive deeper dive and explanation see the following playground](https://www.typescriptlang.org/play/?noUncheckedIndexedAccess=true#code/PTAEBUAsEsGdQE4FMDGB7BATUdQCIAjNAVwDtMlM8AaHAF1EgEN4nQAzaU6OpUWJAzTtQAayQBPWADpQASQZMANrDSIkAR2LRk8HgHJYAKBCg0BAFaoGdNcwBufZUrMi6kJAFtpRuhIAOfABCJOSUoAC8oABKqBiYADwABv7InAAeAPoAJADeeB5KSmh4oAA++ADuGEpUAL5JtHiqnoIwpADmeAB8ANxGJmBQuMjoWDjweGREZBRUtDyMLKBMpDiknNy8-IKuoP5osLDQBEp84lKyCoaDZpbWoOjEtY9opHRMXKCkb3zCoO4vAC0GgfH5AqAAKqkGZhbBRWJjRIpNLQLJ5WB0BBcDoNJotNo4nr9W4AMQwK1IEggAC4IKAkOleOR4AAFJgIOjQZQJcDdUAEakUTZct60AjEGwedaOBACCbfNCKJSVJhSW5Y4hIWQAdQ8a0WuE1fEqfBQq34aoBzAY4AV0E8-iU0BQPCU1P8HK5ylAAApDcZTJptPZlEh3sDQOzOdylLzugBKXwBPhyWByR3O110d3R71xvmRKNe2PxhlM8OYeB2gD8+AkpTpeFIeBJpj14ZWKBQSCOOJW+wQaH8e0BAtCczuVhQtpTAGUUNj-AxzWtw7BiMhrUwGKlh7dGXA6Ho1mPzNPFOQGaQN1uePBwdqjBQUEoOWa3pjQEEAPKQgByAAiACigF0iEsyUP06A3gwsKTlEv4ASBgEANp4KkSAZJkhTFHgAC6-SmKAJEAHo1gM7b6l2PZ9p0A57iO-xjtME7hOe1i0JU1H6D80IoB4KDiJgchhOklAAILdr2sBJLcuDhkwpzhOA86LtAy6PBabzutet4mjaAIpvQoAAFSeNAHSQHQpkCkg4qSisKhoLcMHHBQCDWmaLAGUgd4MJgaC9qQ+gMIeX5fGe9wzrQqgmU8LzKHFBBILcSSQZslBJD4L5vlubkMABSFAaBdLQvBUFGAVoCsZB8JQv+xUoehmHYbhJSEbcJGgORlFDDAegPggWocBSpmmasEjjYOw57EVf4lYBvSgNxLqQKArSrA+hnODN-jwMItzzchoErFueDDqKpDKDQK0wAJCqMkwM66dxO6gEkealo+-zHYt3RyaYm03jsnirFy5pFBIy1xaa+jYIygQztaRpqMgdCbms+gSPoDkMIs6OY-AvH6AAhMmEJpuVbEiZmLpuhIX0+lEaYZk69M5ozJY8tTdV9F1PUUbcervbt7i4MDg3bvjaxg1SWkCLAtC9kjsa6e4hx8O4726MwEKrLcHHI6aG2WdZ3xIOEthLOQZzjnVlLYLVcLqEi8ACJ6CA7u6tCrJgrmrKF6i6W8OB09mrx+a6n7K44azcZ2gLUmD4g7De2rSD4QA).
+ */
+type IsBounded<T> = (T extends unknown ? Or<IsBoundedString<T>, Or<IsNumericLiteral<T>, IsSymbolLiteral<T>>> : never) extends true ? true : false;
+/**
+ * Literal strings can be unbounded when they are a template literal which
+ * contains non-literal components (e.g. `prefix_${string}`), this is because
+ * there are an infinite number of possible values that satisfy it.
+ */
+type IsBoundedString<T> = T extends string ? IsStringLiteral<T> extends true ? Split<T, ''>[number] extends infer U ? [`${number}`] extends [U] ? false : [string] extends [U] ? false : true : false : false : false;
+//#endregion
+//#region src/internal/types/is-bounded-record.d.ts
+/**
+ * Check if a type is guaranteed to be a bounded record: a record with a finite
+ * set of keys.
+ *
+ * See the docs for `IsBounded` to understand more.
+ *
+ * @example
+ *   IsBoundedRecord<{ a: 1, 1: "a" }>; //=> true
+ *   IsBoundedRecord<Record<string | number, unknown>>; //=> false
+ *   IsBoundedRecord<Record<`prefix_${number}`, unknown>>; //=> false
+ */
+type IsBoundedRecord<T> = IsBounded<KeysOfUnion<T>>;
+//#endregion
+export { IsBounded as n, IsBoundedRecord as t };
+//# sourceMappingURL=is-bounded-record-D9YK_OC8.d.cts.map

package/dist/is-bounded-record-D9YK_OC8.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-bounded-record-D9YK_OC8.d.cts","names":[],"sources":["../src/internal/types/is-bounded.ts","../src/internal/types/is-bounded-record.ts"],"sourcesContent":[],"mappings":";;;;;;AAcA;;;;AAKmD,KALvC,SAKuC,CAAA,CAAA,CAAA,GAAA,CAD/C,CAC+C,SAAA,OAAA,GAA3C,EAA2C,CAAxC,eAAwC,CAAxB,CAAwB,CAAA,EAApB,EAAoB,CAAjB,gBAAiB,CAAA,CAAA,CAAA,EAAI,eAAJ,CAAoB,CAApB,CAAA,CAAA,CAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA;;;;;;KAgB9C,eAhBK,CAAA,CAAA,CAAA,GAgBgB,CAhBhB,SAAA,MAAA,GAiBN,eAjBM,CAiBU,CAjBV,CAAA,SAAA,IAAA,GAmBJ,KAnBI,CAmBE,CAnBF,EAAA,EAAA,CAAA,CAAA,MAAA,CAAA,SAAA,KAAA,EAAA,GAAA,CAAA,GAAA,MAAA,EAAA,CAAA,SAAA,CAqBqB,CArBrB,CAAA,GAAA,KAAA,GAAA,CAAA,MAAA,CAAA,SAAA,CAuBoB,CAvBpB,CAAA,GAAA,KAAA,GAAA,IAAA,GAAA,KAAA,GAAA,KAAA,GAAA,KAAA;;;;AALV;;;;;;;;;;AAKU,KCLE,eDKF,CAAA,CAAA,CAAA,GCLuB,SDKvB,CCLiC,WDKjC,CCL6C,CDK7C,CAAA,CAAA"}

package/dist/is-date.cjs

@@ -1 +1 @@
-const e=require(`./is-date-CNebQb0Y.cjs`);exports.isDate=e.isDate;
+function e(e){return e instanceof Date}exports.isDate=e;

package/dist/is-date.d.cts

@@ -1,2 +1,17 @@
-import { isDate } from "./is-date--gIC--NA.cjs";
-export { isDate };
+//#region src/is-date.d.ts
+/**
+ * A function that checks if the passed parameter is a Date and narrows its type accordingly.
+ *
+ * @param data - The variable to check.
+ * @returns True if the passed input is a Date, false otherwise.
+ * @signature
+ *    P.isDate(data)
+ * @example
+ *    P.isDate(new Date()) //=> true
+ *    P.isDate('somethingElse') //=> false
+ * @category Guard
+ */
+declare function isDate(data: unknown): data is Date;
+//#endregion
+export { isDate };
+//# sourceMappingURL=is-date.d.cts.map

package/dist/is-date.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-date.d.cts","names":[],"sources":["../src/is-date.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;;;;;;;;iBAAgB,MAAA,yBAA+B"}