@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/is-number.cjs

@@ -1 +1,2 @@
-function e(e){return typeof e==`number`&&!Number.isNaN(e)}exports.isNumber=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return typeof e==`number`&&!Number.isNaN(e)}exports.isNumber=e;
+//# sourceMappingURL=is-number.cjs.map

package/dist/is-number.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-number.cjs","names":[],"sources":["../src/is-number.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a number 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 *    isNumber(data)\n * @example\n *    isNumber(1); // => true\n *    isNumber(1n); // => false\n *    isNumber('notANumber'); // => false\n * @category Guard\n */\nexport function isNumber<T>(data: T | number): data is NarrowedTo<T, number> {\n  return typeof data === 'number' && !Number.isNaN(data);\n}\n"],"mappings":"mEAgBA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,UAAY,CAAC,OAAO,MAAM,EAAK"}

package/dist/is-number.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-number.js","names":[],"sources":["../src/is-number.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a number 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.isNumber(data)\n * @example\n *    P.isNumber(1); // => true\n *    P.isNumber(1n); // => false\n *    P.isNumber('notANumber'); // => false\n * @category Guard\n */\nexport function isNumber<T>(data: number | T): data is NarrowedTo<T, number> {\n  return typeof data === 'number' && !Number.isNaN(data);\n}\n"],"mappings":"AAgBA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,UAAY,CAAC,OAAO,MAAM,EAAK"}
+{"version":3,"file":"is-number.js","names":[],"sources":["../src/is-number.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a number 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 *    isNumber(data)\n * @example\n *    isNumber(1); // => true\n *    isNumber(1n); // => false\n *    isNumber('notANumber'); // => false\n * @category Guard\n */\nexport function isNumber<T>(data: T | number): data is NarrowedTo<T, number> {\n  return typeof data === 'number' && !Number.isNaN(data);\n}\n"],"mappings":"AAgBA,SAAgB,EAAY,EAAiD,CAC3E,OAAO,OAAO,GAAS,UAAY,CAAC,OAAO,MAAM,EAAK"}

package/dist/is-object-type.cjs

@@ -1 +1,2 @@
-function e(e){return typeof e==`object`&&!!e}exports.isObjectType=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return typeof e==`object`&&!!e}exports.isObjectType=e;
+//# sourceMappingURL=is-object-type.cjs.map

package/dist/is-object-type.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-object-type.cjs","names":[],"sources":["../src/is-object-type.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if the given parameter is of type `\"object\"` via `typeof`, excluding `null`.\n *\n * It's important to note that in JavaScript, many entities are considered objects, like Arrays, Classes, RegExps, Maps, Sets, Dates, URLs, Promise, Errors, and more. Although technically an object too, `null` is not considered an object by this function, so that its easier to narrow nullables.\n *\n * For a more specific check that is limited to plain objects (simple struct/shape/record-like objects), consider using `isPlainObject` instead. For a simpler check that only removes `null` from the type prefer `isNonNull` or `isDefined`.\n *\n * @param data - The variable to be checked for being an object type.\n * @returns The input type, narrowed to only objects.\n * @signature\n *    isObjectType(data)\n * @example\n *    // true\n *    isObjectType({}) //=> true\n *    isObjectType([]) //=> true\n *    isObjectType(Promise.resolve(\"something\")) //=> true\n *    isObjectType(new Date()) //=> true\n *    isObjectType(new Error(\"error\")) //=> true\n *\n *    // false\n *    isObjectType('somethingElse') //=> false\n *    isObjectType(null) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isObjectType<T>(\n  data: T | object,\n): data is NarrowedTo<T, object> {\n  return typeof data === 'object' && data !== null;\n}\n"],"mappings":"mEA2BA,SAAgB,EACd,EAC+B,CAC/B,OAAO,OAAO,GAAS,YAAY"}

package/dist/is-object-type.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-object-type.js","names":[],"sources":["../src/is-object-type.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if the given parameter is of type `\"object\"` via `typeof`, excluding `null`.\n *\n * It's important to note that in JavaScript, many entities are considered objects, like Arrays, Classes, RegExps, Maps, Sets, Dates, URLs, Promise, Errors, and more.\\\n * Although technically an object too, `null` is not considered an object by this function, so that its easier to narrow nullables.\n *\n * For a more specific check that is limited to plain objects (simple struct/shape/record-like objects), consider using `isPlainObject` instead.\n * For a simpler check that only removes `null` from the type prefer `isNonNull` or `isDefined`.\n *\n * @param data - The variable to be checked for being an object type.\n * @returns The input type, narrowed to only objects.\n * @signature\n *    P.isObjectType(data)\n * @example\n *    // true\n *    P.isObjectType({}) //=> true\n *    P.isObjectType([]) //=> true\n *    P.isObjectType(Promise.resolve(\"something\")) //=> true\n *    P.isObjectType(new Date()) //=> true\n *    P.isObjectType(new Error(\"error\")) //=> true\n *\n *    // false\n *    P.isObjectType('somethingElse') //=> false\n *    P.isObjectType(null) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isObjectType<T>(\n  data: object | T,\n): data is NarrowedTo<T, object> {\n  return typeof data === 'object' && data !== null;\n}\n"],"mappings":"AA6BA,SAAgB,EACd,EAC+B,CAC/B,OAAO,OAAO,GAAS,YAAY"}
+{"version":3,"file":"is-object-type.js","names":[],"sources":["../src/is-object-type.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if the given parameter is of type `\"object\"` via `typeof`, excluding `null`.\n *\n * It's important to note that in JavaScript, many entities are considered objects, like Arrays, Classes, RegExps, Maps, Sets, Dates, URLs, Promise, Errors, and more. Although technically an object too, `null` is not considered an object by this function, so that its easier to narrow nullables.\n *\n * For a more specific check that is limited to plain objects (simple struct/shape/record-like objects), consider using `isPlainObject` instead. For a simpler check that only removes `null` from the type prefer `isNonNull` or `isDefined`.\n *\n * @param data - The variable to be checked for being an object type.\n * @returns The input type, narrowed to only objects.\n * @signature\n *    isObjectType(data)\n * @example\n *    // true\n *    isObjectType({}) //=> true\n *    isObjectType([]) //=> true\n *    isObjectType(Promise.resolve(\"something\")) //=> true\n *    isObjectType(new Date()) //=> true\n *    isObjectType(new Error(\"error\")) //=> true\n *\n *    // false\n *    isObjectType('somethingElse') //=> false\n *    isObjectType(null) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isObjectType<T>(\n  data: T | object,\n): data is NarrowedTo<T, object> {\n  return typeof data === 'object' && data !== null;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EAC+B,CAC/B,OAAO,OAAO,GAAS,YAAY"}

package/dist/is-plain-object.cjs

@@ -1 +1,2 @@
-function e(e){if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t===null||t===Object.prototype}exports.isPlainObject=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t===null||t===Object.prototype}exports.isPlainObject=e;
+//# sourceMappingURL=is-plain-object.cjs.map

package/dist/is-plain-object.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object.cjs","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if `data` is a \"plain\" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.\n *\n * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `\"object\"` by JavaScript's `typeof`.\n *\n * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.\n *\n * @param data - The variable to check.\n * @returns The input type, narrowed to only plain objects.\n * @signature\n *    isPlainObject(data)\n * @example\n *    // true\n *    isPlainObject({}) //=> true\n *    isPlainObject({ a: 123 }) //=> true\n *\n *    // false\n *    isPlainObject([]) //=> false\n *    isPlainObject(Promise.resolve(\"something\")) //=> false\n *    isPlainObject(new Date()) //=> false\n *    isPlainObject(new Error(\"error\")) //=> false\n *    isPlainObject('somethingElse') //=> false\n *    isPlainObject(null) //=> false\n * @category Guard\n */\nexport function isPlainObject<T>(\n  data: Readonly<Record<PropertyKey, unknown>> | T,\n): data is NarrowedTo<T, Record<PropertyKey, unknown>> {\n  if (typeof data !== 'object' || data == null) {\n    return false;\n  }\n\n  const proto = Object.getPrototypeOf(data);\n  return proto === null || proto === Object.prototype;\n}\n"],"mappings":"mEA2BA,SAAgB,EACd,EACqD,CACrD,GAAI,OAAO,GAAS,WAAY,EAC9B,MAAO,GAGT,IAAM,EAAQ,OAAO,eAAe,EAAK,CACzC,OAAO,IAAU,MAAQ,IAAU,OAAO"}

package/dist/is-plain-object.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-plain-object.js","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if `data` is a \"plain\" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.\n *\n * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `\"object\"` by JavaScript's `typeof`.\n *\n * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.\n *\n * @param data - The variable to check.\n * @returns The input type, narrowed to only plain objects.\n * @signature\n *    P.isPlainObject(data)\n * @example\n *    // true\n *    P.isPlainObject({}) //=> true\n *    P.isPlainObject({ a: 123 }) //=> true\n *\n *    // false\n *    P.isPlainObject([]) //=> false\n *    P.isPlainObject(Promise.resolve(\"something\")) //=> false\n *    P.isPlainObject(new Date()) //=> false\n *    P.isPlainObject(new Error(\"error\")) //=> false\n *    P.isPlainObject('somethingElse') //=> false\n *    P.isPlainObject(null) //=> false\n * @category Guard\n */\nexport function isPlainObject<T>(\n  data: Readonly<Record<PropertyKey, unknown>> | T,\n): data is NarrowedTo<T, Record<PropertyKey, unknown>> {\n  if (typeof data !== 'object' || data === null) {\n    return false;\n  }\n\n  const proto = Object.getPrototypeOf(data);\n  return proto === null || proto === Object.prototype;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EACqD,CACrD,GAAI,OAAO,GAAS,WAAY,EAC9B,MAAO,GAGT,IAAM,EAAQ,OAAO,eAAe,EAAK,CACzC,OAAO,IAAU,MAAQ,IAAU,OAAO"}
+{"version":3,"file":"is-plain-object.js","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * Checks if `data` is a \"plain\" object. A plain object is defined as an object with string keys and values of any type, including primitives, other objects, functions, classes, etc (aka struct/shape/record/simple). Technically, a plain object is one whose prototype is either `Object.prototype` or `null`, ensuring it does not inherit properties or methods from other object types.\n *\n * This function is narrower in scope than `isObjectType`, which accepts any entity considered an `\"object\"` by JavaScript's `typeof`.\n *\n * Note that Maps, Arrays, and Sets are not considered plain objects and would return `false`.\n *\n * @param data - The variable to check.\n * @returns The input type, narrowed to only plain objects.\n * @signature\n *    isPlainObject(data)\n * @example\n *    // true\n *    isPlainObject({}) //=> true\n *    isPlainObject({ a: 123 }) //=> true\n *\n *    // false\n *    isPlainObject([]) //=> false\n *    isPlainObject(Promise.resolve(\"something\")) //=> false\n *    isPlainObject(new Date()) //=> false\n *    isPlainObject(new Error(\"error\")) //=> false\n *    isPlainObject('somethingElse') //=> false\n *    isPlainObject(null) //=> false\n * @category Guard\n */\nexport function isPlainObject<T>(\n  data: Readonly<Record<PropertyKey, unknown>> | T,\n): data is NarrowedTo<T, Record<PropertyKey, unknown>> {\n  if (typeof data !== 'object' || data == null) {\n    return false;\n  }\n\n  const proto = Object.getPrototypeOf(data);\n  return proto === null || proto === Object.prototype;\n}\n"],"mappings":"AA2BA,SAAgB,EACd,EACqD,CACrD,GAAI,OAAO,GAAS,WAAY,EAC9B,MAAO,GAGT,IAAM,EAAQ,OAAO,eAAe,EAAK,CACzC,OAAO,IAAU,MAAQ,IAAU,OAAO"}

package/dist/is-promise.cjs

@@ -1 +1,2 @@
-function e(e){return e instanceof Promise}exports.isPromise=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return e instanceof Promise}exports.isPromise=e;
+//# sourceMappingURL=is-promise.cjs.map

package/dist/is-promise.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-promise.cjs","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a Promise and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Promise, false otherwise.\n * @signature\n *    isPromise(data)\n * @example\n *    isPromise(Promise.resolve(5)) //=> true\n *    isPromise(Promise.reject(5)) //=> true\n *    isPromise('somethingElse') //=> false\n * @category Guard\n */\nexport function isPromise<T>(\n  data: Readonly<PromiseLike<unknown>> | T,\n): data is NarrowedTo<T, PromiseLike<unknown>> {\n  return data instanceof Promise;\n}\n"],"mappings":"mEAeA,SAAgB,EACd,EAC6C,CAC7C,OAAO,aAAgB"}

package/dist/is-promise.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-promise.js","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is a Promise and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Promise, false otherwise.\n * @signature\n *    P.isPromise(data)\n * @example\n *    P.isPromise(Promise.resolve(5)) //=> true\n *    P.isPromise(Promise.reject(5)) //=> true\n *    P.isPromise('somethingElse') //=> false\n * @category Guard\n */\nexport function isPromise<T, S>(data: Promise<T> | S): data is Promise<T> {\n  return data instanceof Promise;\n}\n"],"mappings":"AAaA,SAAgB,EAAgB,EAA0C,CACxE,OAAO,aAAgB"}
+{"version":3,"file":"is-promise.js","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["import type { NarrowedTo } from './internal/types/narrowed-to';\n\n/**\n * A function that checks if the passed parameter is a Promise and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is a Promise, false otherwise.\n * @signature\n *    isPromise(data)\n * @example\n *    isPromise(Promise.resolve(5)) //=> true\n *    isPromise(Promise.reject(5)) //=> true\n *    isPromise('somethingElse') //=> false\n * @category Guard\n */\nexport function isPromise<T>(\n  data: Readonly<PromiseLike<unknown>> | T,\n): data is NarrowedTo<T, PromiseLike<unknown>> {\n  return data instanceof Promise;\n}\n"],"mappings":"AAeA,SAAgB,EACd,EAC6C,CAC7C,OAAO,aAAgB"}

package/dist/is-shallow-equal.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map)return r(e,t);if(e instanceof Set&&t instanceof Set)return i(e,t);let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n){if(!Object.prototype.hasOwnProperty.call(t,r))return!1;let{[r]:n}=e,{[r]:i}=t;if(n!==i||!Object.is(n,i))return!1}return!0}function r(e,t){if(e.size!==t.size)return!1;for(let[n,r]of e){let e=t.get(n);if(r!==e||!Object.is(r,e))return!1}return!0}function i(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}exports.isShallowEqual=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map)return r(e,t);if(e instanceof Set&&t instanceof Set)return i(e,t);let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n){if(!Object.hasOwn(t,r))return!1;let{[r]:n}=e,{[r]:i}=t;if(n!==i||!Object.is(n,i))return!1}return!0}function r(e,t){if(e.size!==t.size)return!1;for(let[n,r]of e){let e=t.get(n);if(r!==e||!Object.is(r,e))return!1}return!0}function i(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}exports.isShallowEqual=t;
+//# sourceMappingURL=is-shallow-equal.cjs.map

package/dist/is-shallow-equal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-shallow-equal.cjs","names":["curry"],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they\n * are semantically different (e.g. resolved promises); but `isDeepEqual` does\n * compare the latter 2 semantically by-value.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(data, other)\n * @example\n *    isShallowEqual(1, 1) //=> true\n *    isShallowEqual(1, '1') //=> false\n *    isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true\n *    isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isShallowEqual<T>(data: T, other: T): boolean;\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,\n * even when they are semantically different (e.g. resolved promises). Use\n * `isDeepEqual` instead.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(other)(data)\n * @example\n *    pipe(1, isShallowEqual(1)) //=> true\n *    pipe(1, isShallowEqual('1')) //=> false\n *    pipe([1, 2, 3], isShallowEqual([1, 2, 3])) //=> true\n *    pipe([[1], [2], [3]], isShallowEqual([[1], [2], [3]])) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isShallowEqual<T>(other: T): (data: T) => boolean;\n\nexport function isShallowEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isShallowEqualImplementation, args);\n}\n\nfunction isShallowEqualImplementation<T>(a: T, b: T): boolean {\n  if (a === b || Object.is(a, b)) {\n    return true;\n  }\n\n  if (\n    typeof a !== 'object'\n    || a === null\n    || typeof b !== 'object'\n    || b === null\n  ) {\n    return false;\n  }\n\n  if (a instanceof Map && b instanceof Map) {\n    return isMapShallowEqual(a, b);\n  }\n\n  if (a instanceof Set && b instanceof Set) {\n    return isSetShallowEqual(a, b);\n  }\n\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) {\n    return false;\n  }\n\n  for (const key of keys) {\n    if (!Object.hasOwn(b, key)) {\n      return false;\n    }\n\n    const { [key as keyof T]: valueA } = a;\n    const { [key as keyof T]: valueB } = b;\n\n    if (valueA !== valueB || !Object.is(valueA, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isMapShallowEqual(\n  a: ReadonlyMap<unknown, unknown>,\n  b: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    const valueB = b.get(key);\n    if (value !== valueB || !Object.is(value, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isSetShallowEqual(\n  a: ReadonlySet<unknown>,\n  b: ReadonlySet<unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const value of a) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"kGAoFA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAOA,EAAAA,MAAM,EAA8B,EAAK,CAGlD,SAAS,EAAgC,EAAM,EAAe,CAC5D,GAAI,IAAM,GAAK,OAAO,GAAG,EAAG,EAAE,CAC5B,MAAO,GAGT,GACE,OAAO,GAAM,WACV,GACA,OAAO,GAAM,WACb,EAEH,MAAO,GAGT,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,IAAM,EAAO,OAAO,KAAK,EAAE,CAC3B,GAAI,EAAK,SAAW,OAAO,KAAK,EAAE,CAAC,OACjC,MAAO,GAGT,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,CAAC,OAAO,OAAO,EAAG,EAAI,CACxB,MAAO,GAGT,GAAM,EAAG,GAAiB,GAAW,EAC/B,EAAG,GAAiB,GAAW,EAErC,GAAI,IAAW,GAAU,CAAC,OAAO,GAAG,EAAQ,EAAO,CACjD,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAG,CAC5B,IAAM,EAAS,EAAE,IAAI,EAAI,CACzB,GAAI,IAAU,GAAU,CAAC,OAAO,GAAG,EAAO,EAAO,CAC/C,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GAAI,CAAC,EAAE,IAAI,EAAM,CACf,MAAO,GAIX,MAAO"}

package/dist/is-shallow-equal.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map)return r(e,t);if(e instanceof Set&&t instanceof Set)return i(e,t);let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n){if(!Object.prototype.hasOwnProperty.call(t,r))return!1;let{[r]:n}=e,{[r]:i}=t;if(n!==i||!Object.is(n,i))return!1}return!0}function r(e,t){if(e.size!==t.size)return!1;for(let[n,r]of e){let e=t.get(n);if(r!==e||!Object.is(r,e))return!1}return!0}function i(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}export{t as isShallowEqual};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map)return r(e,t);if(e instanceof Set&&t instanceof Set)return i(e,t);let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n){if(!Object.hasOwn(t,r))return!1;let{[r]:n}=e,{[r]:i}=t;if(n!==i||!Object.is(n,i))return!1}return!0}function r(e,t){if(e.size!==t.size)return!1;for(let[n,r]of e){let e=t.get(n);if(r!==e||!Object.is(r,e))return!1}return!0}function i(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}export{t as isShallowEqual};
 //# sourceMappingURL=is-shallow-equal.js.map

package/dist/is-shallow-equal.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-shallow-equal.js","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they\n * are semantically different (e.g. resolved promises); but `isDeepEqual` does\n * compare the latter 2 semantically by-value.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    P.isShallowEqual(data, other)\n * @example\n *    P.isShallowEqual(1, 1) //=> true\n *    P.isShallowEqual(1, '1') //=> false\n *    P.isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true\n *    P.isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isShallowEqual<T, S extends T = T>(data: T, other: S): boolean;\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,\n * even when they are semantically different (e.g. resolved promises). Use\n * `isDeepEqual` instead.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param other - The second value to compare.\n * @signature\n *    P.isShallowEqual(other)(data)\n * @example\n *    P.pipe(1, P.isShallowEqual(1)) //=> true\n *    P.pipe(1, P.isShallowEqual('1')) //=> false\n *    P.pipe([1, 2, 3], P.isShallowEqual([1, 2, 3])) //=> true\n *    P.pipe([[1], [2], [3]], P.isShallowEqual([[1], [2], [3]])) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isShallowEqual<S>(\n  other: S,\n): <T extends S = S>(data: T) => boolean;\n\nexport function isShallowEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isShallowEqualImplementation, args);\n}\n\nfunction isShallowEqualImplementation<T>(a: T, b: T): boolean {\n  if (a === b || Object.is(a, b)) {\n    return true;\n  }\n\n  if (\n    typeof a !== 'object'\n    || a === null\n    || typeof b !== 'object'\n    || b === null\n  ) {\n    return false;\n  }\n\n  if (a instanceof Map && b instanceof Map) {\n    return isMapShallowEqual(a, b);\n  }\n\n  if (a instanceof Set && b instanceof Set) {\n    return isSetShallowEqual(a, b);\n  }\n\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) {\n    return false;\n  }\n\n  for (const key of keys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key)) {\n      return false;\n    }\n\n    const { [key as keyof T]: valueA } = a;\n    const { [key as keyof T]: valueB } = b;\n\n    if (valueA !== valueB || !Object.is(valueA, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isMapShallowEqual(\n  a: ReadonlyMap<unknown, unknown>,\n  b: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    const valueB = b.get(key);\n    if (value !== valueB || !Object.is(value, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isSetShallowEqual(\n  a: ReadonlySet<unknown>,\n  b: ReadonlySet<unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const value of a) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"wCA8EA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAO,EAAM,EAA8B,EAAK,CAGlD,SAAS,EAAgC,EAAM,EAAe,CAC5D,GAAI,IAAM,GAAK,OAAO,GAAG,EAAG,EAAE,CAC5B,MAAO,GAGT,GACE,OAAO,GAAM,WACV,GACA,OAAO,GAAM,WACb,EAEH,MAAO,GAGT,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,IAAM,EAAO,OAAO,KAAK,EAAE,CAC3B,GAAI,EAAK,SAAW,OAAO,KAAK,EAAE,CAAC,OACjC,MAAO,GAGT,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,CAAC,OAAO,UAAU,eAAe,KAAK,EAAG,EAAI,CAC/C,MAAO,GAGT,GAAM,EAAG,GAAiB,GAAW,EAC/B,EAAG,GAAiB,GAAW,EAErC,GAAI,IAAW,GAAU,CAAC,OAAO,GAAG,EAAQ,EAAO,CACjD,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAG,CAC5B,IAAM,EAAS,EAAE,IAAI,EAAI,CACzB,GAAI,IAAU,GAAU,CAAC,OAAO,GAAG,EAAO,EAAO,CAC/C,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GAAI,CAAC,EAAE,IAAI,EAAM,CACf,MAAO,GAIX,MAAO"}
+{"version":3,"file":"is-shallow-equal.js","names":[],"sources":["../src/is-shallow-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: Promise, Date, and RegExp, are shallowly equal, even when they\n * are semantically different (e.g. resolved promises); but `isDeepEqual` does\n * compare the latter 2 semantically by-value.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(data, other)\n * @example\n *    isShallowEqual(1, 1) //=> true\n *    isShallowEqual(1, '1') //=> false\n *    isShallowEqual([1, 2, 3], [1, 2, 3]) //=> true\n *    isShallowEqual([[1], [2], [3]], [[1], [2], [3]]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isShallowEqual<T>(data: T, other: T): boolean;\n\n/**\n * Performs a *shallow structural* comparison between two values to determine if\n * they are equivalent. For primitive values this is equivalent to `===`, for\n * arrays a **strict equality** check would be performed on every item, in\n * order, and for objects props will be matched and checked for **strict\n * equality**; Unlike `isDeepEqual` where the function also *recurses* into each\n * item and value.\n *\n * !IMPORTANT: symbol properties of objects are not supported right now and\n * might result in unexpected behavior. Please open an issue in the Perkakas\n * github project if you need support for these types.\n *\n * !IMPORTANT: All built-in objects (Promise, Date, RegExp) are shallowly equal,\n * even when they are semantically different (e.g. resolved promises). Use\n * `isDeepEqual` instead.\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isStrictEqual` if you don't need a deep comparison and just want to check\n * for simple (`===`, `Object.is`) equality.\n * - `isDeepEqual` for a recursively deep check of arrays and objects.\n *\n * @param other - The second value to compare.\n * @signature\n *    isShallowEqual(other)(data)\n * @example\n *    pipe(1, isShallowEqual(1)) //=> true\n *    pipe(1, isShallowEqual('1')) //=> false\n *    pipe([1, 2, 3], isShallowEqual([1, 2, 3])) //=> true\n *    pipe([[1], [2], [3]], isShallowEqual([[1], [2], [3]])) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isShallowEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isShallowEqual<T>(other: T): (data: T) => boolean;\n\nexport function isShallowEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isShallowEqualImplementation, args);\n}\n\nfunction isShallowEqualImplementation<T>(a: T, b: T): boolean {\n  if (a === b || Object.is(a, b)) {\n    return true;\n  }\n\n  if (\n    typeof a !== 'object'\n    || a === null\n    || typeof b !== 'object'\n    || b === null\n  ) {\n    return false;\n  }\n\n  if (a instanceof Map && b instanceof Map) {\n    return isMapShallowEqual(a, b);\n  }\n\n  if (a instanceof Set && b instanceof Set) {\n    return isSetShallowEqual(a, b);\n  }\n\n  const keys = Object.keys(a);\n  if (keys.length !== Object.keys(b).length) {\n    return false;\n  }\n\n  for (const key of keys) {\n    if (!Object.hasOwn(b, key)) {\n      return false;\n    }\n\n    const { [key as keyof T]: valueA } = a;\n    const { [key as keyof T]: valueB } = b;\n\n    if (valueA !== valueB || !Object.is(valueA, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isMapShallowEqual(\n  a: ReadonlyMap<unknown, unknown>,\n  b: ReadonlyMap<unknown, unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const [key, value] of a) {\n    const valueB = b.get(key);\n    if (value !== valueB || !Object.is(value, valueB)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isSetShallowEqual(\n  a: ReadonlySet<unknown>,\n  b: ReadonlySet<unknown>,\n): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  for (const value of a) {\n    if (!b.has(value)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"mCAoFA,SAAgB,EAAe,GAAG,EAAuC,CACvE,OAAO,EAAM,EAA8B,EAAK,CAGlD,SAAS,EAAgC,EAAM,EAAe,CAC5D,GAAI,IAAM,GAAK,OAAO,GAAG,EAAG,EAAE,CAC5B,MAAO,GAGT,GACE,OAAO,GAAM,WACV,GACA,OAAO,GAAM,WACb,EAEH,MAAO,GAGT,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,GAAI,aAAa,KAAO,aAAa,IACnC,OAAO,EAAkB,EAAG,EAAE,CAGhC,IAAM,EAAO,OAAO,KAAK,EAAE,CAC3B,GAAI,EAAK,SAAW,OAAO,KAAK,EAAE,CAAC,OACjC,MAAO,GAGT,IAAK,IAAM,KAAO,EAAM,CACtB,GAAI,CAAC,OAAO,OAAO,EAAG,EAAI,CACxB,MAAO,GAGT,GAAM,EAAG,GAAiB,GAAW,EAC/B,EAAG,GAAiB,GAAW,EAErC,GAAI,IAAW,GAAU,CAAC,OAAO,GAAG,EAAQ,EAAO,CACjD,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,GAAM,CAAC,EAAK,KAAU,EAAG,CAC5B,IAAM,EAAS,EAAE,IAAI,EAAI,CACzB,GAAI,IAAU,GAAU,CAAC,OAAO,GAAG,EAAO,EAAO,CAC/C,MAAO,GAIX,MAAO,GAGT,SAAS,EACP,EACA,EACS,CACT,GAAI,EAAE,OAAS,EAAE,KACf,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GAAI,CAAC,EAAE,IAAI,EAAM,CACf,MAAO,GAIX,MAAO"}

package/dist/is-strict-equal.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return e===t||Object.is(e,t)}exports.isStrictEqual=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e===t||Object.is(e,t)}exports.isStrictEqual=t;
+//# sourceMappingURL=is-strict-equal.cjs.map

package/dist/is-strict-equal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-strict-equal.cjs","names":["curry"],"sources":["../src/is-strict-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(data, other)\n * @example\n *    isStrictEqual(1, 1) //=> true\n *    isStrictEqual(1, '1') //=> false\n *    isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isStrictEqual<T>(data: T, other: T): boolean;\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(other)(data)\n * @example\n *    pipe(1, isStrictEqual(1)); //=> true\n *    pipe(1, isStrictEqual('1')); //=> false\n *    pipe([1, 2, 3], isStrictEqual([1, 2, 3])); //=> false\n * @dataLast\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isStrictEqual<T>(other: T): (data: T) => boolean;\n\nexport function isStrictEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isStrictlyEqualImplementation, args);\n}\n\nfunction isStrictlyEqualImplementation<T>(data: unknown, other: T): data is T {\n  return data === other || Object.is(data, other);\n}\n"],"mappings":"kGAwEA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAOA,EAAAA,MAAM,EAA+B,EAAK,CAGnD,SAAS,EAAiC,EAAe,EAAqB,CAC5E,OAAO,IAAS,GAAS,OAAO,GAAG,EAAM,EAAM"}

package/dist/is-strict-equal.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return e===t||Object.is(e,t)}export{t as isStrictEqual};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){return e===t||Object.is(e,t)}export{t as isStrictEqual};
 //# sourceMappingURL=is-strict-equal.js.map

package/dist/is-strict-equal.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-strict-equal.js","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    P.isStrictEqual(data, other)\n * @example\n *    P.isStrictEqual(1, 1) //=> true\n *    P.isStrictEqual(1, '1') //=> false\n *    P.isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isStrictEqual<T, S extends T = T>(data: T, other: S): boolean;\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    P.isStrictEqual(other)(data)\n * @example\n *    P.pipe(1, P.isStrictEqual(1)); //=> true\n *    P.pipe(1, P.isStrictEqual('1')); //=> false\n *    P.pipe([1, 2, 3], P.isStrictEqual([1, 2, 3])); //=> false\n * @dataLast\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isStrictEqual<S>(\n  other: S,\n): <T extends S = S>(data: T) => boolean;\n\nexport function isStrictEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isStrictlyEqualImplementation, args);\n}\n\nfunction isStrictlyEqualImplementation<T, S>(data: S | T, other: S): data is S {\n  return data === other || Object.is(data, other);\n}\n"],"mappings":"wCA0EA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA+B,EAAK,CAGnD,SAAS,EAAoC,EAAa,EAAqB,CAC7E,OAAO,IAAS,GAAS,OAAO,GAAG,EAAM,EAAM"}
+{"version":3,"file":"is-strict-equal.js","names":[],"sources":["../src/is-strict-equal.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param data - The first value to compare.\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(data, other)\n * @example\n *    isStrictEqual(1, 1) //=> true\n *    isStrictEqual(1, '1') //=> false\n *    isStrictEqual([1, 2, 3], [1, 2, 3]) //=> false\n * @dataFirst\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  data: T,\n  other: T extends Exclude<T, S> ? S : never,\n): data is S;\nexport function isStrictEqual<T>(data: T, other: T): boolean;\n\n/**\n * Determines whether two values are *functionally identical* in all contexts.\n * For primitive values (string, number), this is done by-value, and for objects\n * it is done by-reference (i.e., they point to the same object in memory).\n *\n * Under the hood we use **both** the [`===` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)\n * and [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is). This means that `isStrictEqual(NaN, NaN) === true`\n * (whereas `NaN !== NaN`), and `isStrictEqual(-0, 0) === true` (whereas\n * `Object.is(-0, 0) === false`).\n *\n * The result would be narrowed to the second value so that the function can be\n * used as a type guard.\n *\n * See:\n * - `isDeepEqual` for a semantic comparison that allows comparing arrays and\n * objects \"by-value\", and recurses for every item.\n * - `isShallowEqual` if you need to compare arrays and objects \"by-value\" but\n * don't want to recurse into their values.\n *\n * @param other - The second value to compare.\n * @signature\n *    isStrictEqual(other)(data)\n * @example\n *    pipe(1, isStrictEqual(1)); //=> true\n *    pipe(1, isStrictEqual('1')); //=> false\n *    pipe([1, 2, 3], isStrictEqual([1, 2, 3])); //=> false\n * @dataLast\n * @category Guard\n */\nexport function isStrictEqual<T, S extends T>(\n  other: T extends Exclude<T, S> ? S : never,\n): (data: T) => data is S;\nexport function isStrictEqual<T>(other: T): (data: T) => boolean;\n\nexport function isStrictEqual(...args: ReadonlyArray<unknown>): unknown {\n  return curry(isStrictlyEqualImplementation, args);\n}\n\nfunction isStrictlyEqualImplementation<T>(data: unknown, other: T): data is T {\n  return data === other || Object.is(data, other);\n}\n"],"mappings":"mCAwEA,SAAgB,EAAc,GAAG,EAAuC,CACtE,OAAO,EAAM,EAA+B,EAAK,CAGnD,SAAS,EAAiC,EAAe,EAAqB,CAC5E,OAAO,IAAS,GAAS,OAAO,GAAG,EAAM,EAAM"}

package/dist/is-string.cjs

@@ -1 +1,2 @@
-function e(e){return typeof e==`string`}exports.isString=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return typeof e==`string`}exports.isString=e;
+//# sourceMappingURL=is-string.cjs.map

package/dist/is-string.cjs.map

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

package/dist/is-string.js.map

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

package/dist/is-symbol.cjs

@@ -1 +1,2 @@
-function e(e){return typeof e==`symbol`}exports.isSymbol=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return typeof e==`symbol`}exports.isSymbol=e;
+//# sourceMappingURL=is-symbol.cjs.map

package/dist/is-symbol.cjs.map

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

package/dist/is-symbol.js.map

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

package/dist/is-truthy.cjs

@@ -1 +1,2 @@
-function e(e){return!!e}exports.isTruthy=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return!!e}exports.isTruthy=e;
+//# sourceMappingURL=is-truthy.cjs.map

package/dist/is-truthy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-truthy.cjs","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is truthy and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is truthy, false otherwise.\n * @signature\n *    isTruthy(data)\n * @example\n *    isTruthy('somethingElse') //=> true\n *    isTruthy(null) //=> false\n *    isTruthy(undefined) //=> false\n *    isTruthy(false) //=> false\n *    isTruthy(0) //=> false\n *    isTruthy('') //=> false\n * @category Guard\n */\n\nexport function isTruthy<T>(\n  data: T,\n): data is Exclude<T, '' | 0 | false | null | undefined> {\n  return Boolean(data);\n}\n"],"mappings":"mEAiBA,SAAgB,EACd,EACuD,CACvD,MAAO,EAAQ"}

package/dist/is-truthy.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-truthy.js","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is truthy and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is truthy, false otherwise.\n * @signature\n *    P.isTruthy(data)\n * @example\n *    P.isTruthy('somethingElse') //=> true\n *    P.isTruthy(null) //=> false\n *    P.isTruthy(undefined) //=> false\n *    P.isTruthy(false) //=> false\n *    P.isTruthy(0) //=> false\n *    P.isTruthy('') //=> false\n * @category Guard\n */\n\nexport function isTruthy<T>(\n  data: T,\n): data is Exclude<T, '' | 0 | false | null | undefined> {\n  return Boolean(data);\n}\n"],"mappings":"AAiBA,SAAgB,EACd,EACuD,CACvD,MAAO,EAAQ"}
+{"version":3,"file":"is-truthy.js","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":["/**\n * A function that checks if the passed parameter is truthy and narrows its type accordingly.\n *\n * @param data - The variable to check.\n * @returns True if the passed input is truthy, false otherwise.\n * @signature\n *    isTruthy(data)\n * @example\n *    isTruthy('somethingElse') //=> true\n *    isTruthy(null) //=> false\n *    isTruthy(undefined) //=> false\n *    isTruthy(false) //=> false\n *    isTruthy(0) //=> false\n *    isTruthy('') //=> false\n * @category Guard\n */\n\nexport function isTruthy<T>(\n  data: T,\n): data is Exclude<T, '' | 0 | false | null | undefined> {\n  return Boolean(data);\n}\n"],"mappings":"AAiBA,SAAgB,EACd,EACuD,CACvD,MAAO,EAAQ"}

package/dist/join.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return e.join(t)}exports.join=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e.join(t)}exports.join=t;
+//# sourceMappingURL=join.cjs.map

package/dist/join.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.cjs","names":["curry"],"sources":["../src/join.ts"],"sourcesContent":["import type { Join } from 'type-fest';\nimport { curry } from './curry';\n\n// Copied from type-fest, from the Join type.\ntype JoinableItem = bigint | boolean | number | string | null | undefined;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param data - The array to join.\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(data, glue)\n * @example\n *    join([1,2,3], \",\") // => \"1,2,3\" (typed `string`)\n *    join(['a','b','c'], \"\") // => \"abc\" (typed `string`)\n *    join(['hello', 'world'] as const, \" \") // => \"hello world\" (typed `hello world`)\n * @dataFirst\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(data: T, glue: Glue): Join<T, Glue>;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(glue)(data)\n * @example\n *    pipe([1,2,3], join(\",\")) // => \"1,2,3\" (typed `string`)\n *    pipe(['a','b','c'], join(\"\")) // => \"abc\" (typed `string`)\n *    pipe(['hello', 'world'] as const, join(\" \")) // => \"hello world\" (typed `hello world`)\n * @dataLast\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(glue: Glue): (data: T) => Join<T, Glue>;\n\nexport function join(...args: ReadonlyArray<unknown>): unknown {\n  return curry(joinImplementation, args);\n}\n\nfunction joinImplementation(data: ReadonlyArray<unknown>, glue: string): string {\n  return data.join(glue);\n}\n"],"mappings":"kGAqDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,SAAS,EAAmB,EAA8B,EAAsB,CAC9E,OAAO,EAAK,KAAK,EAAK"}

package/dist/join.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){return e.join(t)}export{t as join};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){return e.join(t)}export{t as join};
 //# sourceMappingURL=join.js.map

package/dist/join.js.map

@@ -1 +1 @@
-{"version":3,"file":"join.js","names":[],"sources":["../src/join.ts"],"sourcesContent":["import type { Join } from 'type-fest';\n\nimport { curry } from './curry';\n\n// Copied from type-fest, from the Join type.\ntype JoinableItem = bigint | boolean | null | number | string | undefined;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param data - The array to join.\n * @param glue - The string to put in between every two elements.\n * @signature\n *    P.join(data, glue)\n * @example\n *    P.join([1,2,3], \",\") // => \"1,2,3\" (typed `string`)\n *    P.join(['a','b','c'], \"\") // => \"abc\" (typed `string`)\n *    P.join(['hello', 'world'] as const, \" \") // => \"hello world\" (typed `hello world`)\n * @dataFirst\n * @category Array\n */\nexport function join<\n  T extends [] | ReadonlyArray<JoinableItem>,\n  Glue extends string,\n>(data: T, glue: Glue): Join<T, Glue>;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param glue - The string to put in between every two elements.\n * @signature\n *    P.join(glue)(data)\n * @example\n *    P.pipe([1,2,3], P.join(\",\")) // => \"1,2,3\" (typed `string`)\n *    P.pipe(['a','b','c'], P.join(\"\")) // => \"abc\" (typed `string`)\n *    P.pipe(['hello', 'world'] as const, P.join(\" \")) // => \"hello world\" (typed `hello world`)\n * @dataLast\n * @category Array\n */\nexport function join<\n  T extends [] | ReadonlyArray<JoinableItem>,\n  Glue extends string,\n>(glue: Glue): (data: T) => Join<T, Glue>;\n\nexport function join(...args: ReadonlyArray<unknown>): unknown {\n  return curry(joinImplementation, args);\n}\n\nfunction joinImplementation(\n  data: ReadonlyArray<unknown>,\n  glue: string,\n): string {\n  return data.join(glue);\n};\n"],"mappings":"wCAsDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACA,EACQ,CACR,OAAO,EAAK,KAAK,EAAK"}
+{"version":3,"file":"join.js","names":[],"sources":["../src/join.ts"],"sourcesContent":["import type { Join } from 'type-fest';\nimport { curry } from './curry';\n\n// Copied from type-fest, from the Join type.\ntype JoinableItem = bigint | boolean | number | string | null | undefined;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param data - The array to join.\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(data, glue)\n * @example\n *    join([1,2,3], \",\") // => \"1,2,3\" (typed `string`)\n *    join(['a','b','c'], \"\") // => \"abc\" (typed `string`)\n *    join(['hello', 'world'] as const, \" \") // => \"hello world\" (typed `hello world`)\n * @dataFirst\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(data: T, glue: Glue): Join<T, Glue>;\n\n/**\n * Joins the elements of the array by: casting them to a string and\n * concatenating them one to the other, with the provided glue string in between\n * every two elements.\n *\n * When called on a tuple and with stricter item types (union of literal values,\n * the result is strictly typed to the tuples shape and it's item types).\n *\n * @param glue - The string to put in between every two elements.\n * @signature\n *    join(glue)(data)\n * @example\n *    pipe([1,2,3], join(\",\")) // => \"1,2,3\" (typed `string`)\n *    pipe(['a','b','c'], join(\"\")) // => \"abc\" (typed `string`)\n *    pipe(['hello', 'world'] as const, join(\" \")) // => \"hello world\" (typed `hello world`)\n * @dataLast\n * @category Array\n */\nexport function join<\n  T extends ReadonlyArray<JoinableItem> | [],\n  Glue extends string,\n>(glue: Glue): (data: T) => Join<T, Glue>;\n\nexport function join(...args: ReadonlyArray<unknown>): unknown {\n  return curry(joinImplementation, args);\n}\n\nfunction joinImplementation(data: ReadonlyArray<unknown>, glue: string): string {\n  return data.join(glue);\n}\n"],"mappings":"mCAqDA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EAAmB,EAA8B,EAAsB,CAC9E,OAAO,EAAK,KAAK,EAAK"}

package/dist/key-codes.cjs

@@ -1 +1,2 @@
-const e={ALT:`Alt`,ARROW_DOWN:`ArrowDown`,ARROW_LEFT:`ArrowLeft`,ARROW_RIGHT:`ArrowRight`,ARROW_UP:`ArrowUp`,AT:`@`,BACKSPACE:`Backspace`,CTRL:`Control`,DELETE:`Delete`,END:`End`,ENTER:`Enter`,ESC:`Escape`,HOME:`Home`,KEY_F:`KEY_F`,META:`Meta`,PAGE_DOWN:`PageDown`,PAGE_UP:`PageUp`,SHIFT:`Shift`,SPACE:`Space`,TAB:`Tab`};exports.KEY_CODES=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e={ALT:`Alt`,ARROW_DOWN:`ArrowDown`,ARROW_LEFT:`ArrowLeft`,ARROW_RIGHT:`ArrowRight`,ARROW_UP:`ArrowUp`,AT:`@`,BACKSPACE:`Backspace`,CTRL:`Control`,DELETE:`Delete`,END:`End`,ENTER:`Enter`,ESC:`Escape`,HOME:`Home`,KEY_F:`KEY_F`,META:`Meta`,PAGE_DOWN:`PageDown`,PAGE_UP:`PageUp`,SHIFT:`Shift`,SPACE:`Space`,TAB:`Tab`};exports.KEY_CODES=e;
+//# sourceMappingURL=key-codes.cjs.map

package/dist/key-codes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-codes.cjs","names":[],"sources":["../src/key-codes.ts"],"sourcesContent":["/**\n * Using event.code is not predictable since each machine may have different output\n */\n\nexport const KEY_CODES = {\n  ALT: 'Alt',\n  ARROW_DOWN: 'ArrowDown',\n  ARROW_LEFT: 'ArrowLeft',\n  ARROW_RIGHT: 'ArrowRight',\n  ARROW_UP: 'ArrowUp',\n  AT: '@',\n  BACKSPACE: 'Backspace',\n  CTRL: 'Control',\n  DELETE: 'Delete',\n  END: 'End',\n  ENTER: 'Enter',\n  ESC: 'Escape',\n  HOME: 'Home',\n  KEY_F: 'KEY_F',\n  META: 'Meta',\n  PAGE_DOWN: 'PageDown',\n  PAGE_UP: 'PageUp',\n  SHIFT: 'Shift',\n  SPACE: 'Space',\n  TAB: 'Tab',\n} as const;\n"],"mappings":"mEAIA,MAAa,EAAY,CACvB,IAAK,MACL,WAAY,YACZ,WAAY,YACZ,YAAa,aACb,SAAU,UACV,GAAI,IACJ,UAAW,YACX,KAAM,UACN,OAAQ,SACR,IAAK,MACL,MAAO,QACP,IAAK,SACL,KAAM,OACN,MAAO,QACP,KAAM,OACN,UAAW,WACX,QAAS,SACT,MAAO,QACP,MAAO,QACP,IAAK,MACN"}

package/dist/keys.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(Object.keys,t)}exports.keys=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(Object.keys,t)}exports.keys=t;
+//# sourceMappingURL=keys.cjs.map

package/dist/keys.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.cjs","names":["curry"],"sources":["../src/keys.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;\n\n// The keys output can mirror the input when it is an array/tuple. We do this by\n// \"mapping\" each item \"key\" (which is actually an index) as its own value. This\n// would maintain the shape, even including labels.\ntype ArrayKeys<T extends IterableContainer> = {\n  -readonly [Index in keyof T]: Index extends number | string\n    ? // Notice that we coalesce the values as strings, this is because in JS,\n  // Object.keys always returns strings, even for arrays.\n    ToString<IsIndexAfterSpread<T, Index> extends true ? number : Index>\n    : // Index is typed as a symbol, this can't happen, but we need to guard\n  // against it for typescript.\n    never;\n};\n\ntype IsIndexAfterSpread<\n  T extends IterableContainer,\n  Index extends number | string,\n>\n  = IndicesAfterSpread<T> extends never\n    ? false\n    : Index extends `${IndicesAfterSpread<T>}`\n      ? true\n      : false;\n\n// Find the index of the tuple where a spread item is located, and return all\n// indices in the tuple which are located after it. The tuple could be prefixed\n// by any number of literal items. If the input is a simple array it would\n// return 0 (as expected), and if the tuple doesn't contain a spread element it\n// would return never.\ntype IndicesAfterSpread<\n  T extends ReadonlyArray<unknown> | [],\n  // We use this type to count how many items we consumed, it's just a pseudo-\n  // element that is used for its length.\n  Iterations extends ReadonlyArray<unknown> = [],\n> = T[number] extends never\n  ? never\n  : T extends readonly [unknown, ...infer Tail]\n    ? IndicesAfterSpread<Tail, [unknown, ...Iterations]>\n    : T extends readonly [...infer Head, unknown]\n      ?\n      | IndicesAfterSpread<Head, [unknown, ...Iterations]>\n      | Iterations['length']\n      : Iterations['length'];\n\ntype ObjectKeys<T>\n  = T extends Record<PropertyKey, never> ? [] : Array<EnumerableStringKeyOf<T>>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    keys(source)\n * @example\n *    keys(['x', 'y', 'z']); // => ['0', '1', '2']\n *    keys({ a: 'x', b: 'y', 5: 'z' }); // => ['a', 'b', '5']\n * @dataFirst\n * @category Object\n */\nexport function keys<T extends object>(data: T): Keys<T>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @signature\n *    keys()(source)\n * @example\n *    pipe(['x', 'y', 'z'], keys()); // => ['0', '1', '2']\n *    pipe({ a: 'x', b: 'y', 5: 'z' } as const, keys()) // => ['a', 'b', '5']\n * @dataLast\n * @category Object\n */\nexport function keys(): <T extends object>(data: T) => Keys<T>;\n\nexport function keys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.keys, args);\n}\n"],"mappings":"kGAgFA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,OAAO,KAAM,EAAK"}

package/dist/keys.js

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

package/dist/keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"keys.js","names":[],"sources":["../src/keys.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\n\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;\n\n// The keys output can mirror the input when it is an array/tuple. We do this by\n// \"mapping\" each item \"key\" (which is actually an index) as its own value. This\n// would maintain the shape, even including labels.\ntype ArrayKeys<T extends IterableContainer> = {\n  -readonly [Index in keyof T]: Index extends number | string\n    // Notice that we coalesce the values as strings, this is because in JS,\n    // Object.keys always returns strings, even for arrays.\n    ? ToString<IsIndexAfterSpread<T, Index> extends true ? number : Index>\n    // Index is typed as a symbol, this can't happen, but we need to guard\n    // against it for typescript.\n    : never;\n};\n\ntype IsIndexAfterSpread<\n  T extends IterableContainer,\n  Index extends number | string,\n>\n  = IndicesAfterSpread<T> extends never\n    ? false\n    : Index extends `${IndicesAfterSpread<T>}`\n      ? true\n      : false;\n\n// Find the index of the tuple where a spread item is located, and return all\n// indices in the tuple which are located after it. The tuple could be prefixed\n// by any number of literal items. If the input is a simple array it would\n// return 0 (as expected), and if the tuple doesn't contain a spread element it\n// would return never.\ntype IndicesAfterSpread<\n  T extends ReadonlyArray<unknown> | [],\n  // We use this type to count how many items we consumed, it's just a pseudo-\n  // element that is used for its length.\n  Iterations extends ReadonlyArray<unknown> = [],\n> = T[number] extends never\n  ? never\n  : T extends readonly [unknown, ...infer Tail]\n    ? IndicesAfterSpread<Tail, [unknown, ...Iterations]>\n    : T extends readonly [...infer Head, unknown]\n      ? | IndicesAfterSpread<Head, [unknown, ...Iterations]>\n      | Iterations['length']\n      : Iterations['length'];\n\ntype ObjectKeys<T>\n  = T extends Record<PropertyKey, never> ? [] : Array<EnumerableStringKeyOf<T>>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    P.keys(source)\n * @example\n *    P.keys(['x', 'y', 'z']); // => ['0', '1', '2']\n *    P.keys({ a: 'x', b: 'y', 5: 'z' }); // => ['a', 'b', '5']\n * @dataFirst\n * @category Object\n */\nexport function keys<T extends object>(data: T): Keys<T>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @signature\n *    P.keys()(source)\n * @example\n *    P.Pipe(['x', 'y', 'z'], keys()); // => ['0', '1', '2']\n *    P.pipe({ a: 'x', b: 'y', 5: 'z' } as const, P.keys()) // => ['a', 'b', '5']\n * @dataLast\n * @category Object\n */\nexport function keys(): <T extends object>(data: T) => Keys<T>;\n\nexport function keys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.keys, args);\n}\n"],"mappings":"wCAgFA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,OAAO,KAAM,EAAK"}
+{"version":3,"file":"keys.js","names":[],"sources":["../src/keys.ts"],"sourcesContent":["import type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { ToString } from './internal/types/to-string';\nimport { curry } from './curry';\n\ntype Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;\n\n// The keys output can mirror the input when it is an array/tuple. We do this by\n// \"mapping\" each item \"key\" (which is actually an index) as its own value. This\n// would maintain the shape, even including labels.\ntype ArrayKeys<T extends IterableContainer> = {\n  -readonly [Index in keyof T]: Index extends number | string\n    ? // Notice that we coalesce the values as strings, this is because in JS,\n  // Object.keys always returns strings, even for arrays.\n    ToString<IsIndexAfterSpread<T, Index> extends true ? number : Index>\n    : // Index is typed as a symbol, this can't happen, but we need to guard\n  // against it for typescript.\n    never;\n};\n\ntype IsIndexAfterSpread<\n  T extends IterableContainer,\n  Index extends number | string,\n>\n  = IndicesAfterSpread<T> extends never\n    ? false\n    : Index extends `${IndicesAfterSpread<T>}`\n      ? true\n      : false;\n\n// Find the index of the tuple where a spread item is located, and return all\n// indices in the tuple which are located after it. The tuple could be prefixed\n// by any number of literal items. If the input is a simple array it would\n// return 0 (as expected), and if the tuple doesn't contain a spread element it\n// would return never.\ntype IndicesAfterSpread<\n  T extends ReadonlyArray<unknown> | [],\n  // We use this type to count how many items we consumed, it's just a pseudo-\n  // element that is used for its length.\n  Iterations extends ReadonlyArray<unknown> = [],\n> = T[number] extends never\n  ? never\n  : T extends readonly [unknown, ...infer Tail]\n    ? IndicesAfterSpread<Tail, [unknown, ...Iterations]>\n    : T extends readonly [...infer Head, unknown]\n      ?\n      | IndicesAfterSpread<Head, [unknown, ...Iterations]>\n      | Iterations['length']\n      : Iterations['length'];\n\ntype ObjectKeys<T>\n  = T extends Record<PropertyKey, never> ? [] : Array<EnumerableStringKeyOf<T>>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    keys(source)\n * @example\n *    keys(['x', 'y', 'z']); // => ['0', '1', '2']\n *    keys({ a: 'x', b: 'y', 5: 'z' }); // => ['a', 'b', '5']\n * @dataFirst\n * @category Object\n */\nexport function keys<T extends object>(data: T): Keys<T>;\n\n/**\n * Returns a new array containing the keys of the array or object.\n *\n * @signature\n *    keys()(source)\n * @example\n *    pipe(['x', 'y', 'z'], keys()); // => ['0', '1', '2']\n *    pipe({ a: 'x', b: 'y', 5: 'z' } as const, keys()) // => ['a', 'b', '5']\n * @dataLast\n * @category Object\n */\nexport function keys(): <T extends object>(data: T) => Keys<T>;\n\nexport function keys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.keys, args);\n}\n"],"mappings":"mCAgFA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,OAAO,KAAM,EAAK"}

package/dist/last.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){return e.at(-1)}exports.last=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){return e.at(-1)}exports.last=t;
+//# sourceMappingURL=last.cjs.map

package/dist/last.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"last.cjs","names":["curry"],"sources":["../src/last.ts"],"sourcesContent":["import type { LastArrayElement } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Last<T extends IterableContainer> = LastArrayElement<\n  T,\n  // Type-fest's LastArrayElement assumes a looser typescript configuration\n  // where `noUncheckedIndexedAccess` is disabled. To support the stricter\n  // configuration we assume we need to assign the \"LastArrayElement\" param to\n  // `undefined`, but only if the array isn't empty.\n  T extends readonly [] ? never : undefined\n>;\n\n/**\n * Gets the last element of `array`.\n *\n * @param data - The array.\n * @signature\n *    last(array)\n * @example\n *    last([1, 2, 3]) // => 3\n *    last([]) // => undefined\n * @dataFirst\n * @category Array\n */\nexport function last<T extends IterableContainer>(data: T): Last<T>;\n\n/**\n * Gets the last element of `array`.\n *\n * @signature\n *    last()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      last(),\n *      x => x + 1\n *    ); // => 17\n * @dataLast\n * @category Array\n */\nexport function last(): <T extends IterableContainer>(data: T) => Last<T>;\n\nexport function last(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lastImplementation, args);\n}\n\nfunction lastImplementation<T>(array: ReadonlyArray<T>): T | undefined {\n  return array.at(-1);\n}\n"],"mappings":"kGA4CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,SAAS,EAAsB,EAAwC,CACrE,OAAO,EAAM,GAAG,GAAG"}

package/dist/last.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){return e.at(-1)}export{t as last};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){return e.at(-1)}export{t as last};
 //# sourceMappingURL=last.js.map

package/dist/last.js.map

@@ -1 +1 @@
-{"version":3,"file":"last.js","names":[],"sources":["../src/last.ts"],"sourcesContent":["import type { LastArrayElement } from 'type-fest';\n\nimport type { IterableContainer } from './internal/types/iterable-container';\n\nimport { curry } from './curry';\n\ntype Last<T extends IterableContainer> = LastArrayElement<\n  T,\n  // Type-fest's LastArrayElement assumes a looser typescript configuration\n  // where `noUncheckedIndexedAccess` is disabled. To support the stricter\n  // configuration we assume we need to assign the \"LastArrayElement\" param to\n  // `undefined`, but only if the array isn't empty.\n  T extends readonly [] ? never : undefined\n>;\n\n/**\n * Gets the last element of `array`.\n *\n * @param data - The array.\n * @signature\n *    P.last(array)\n * @example\n *    P.last([1, 2, 3]) // => 3\n *    P.last([]) // => undefined\n * @dataFirst\n * @category Array\n */\nexport function last<T extends IterableContainer>(data: T): Last<T>;\n\n/**\n * Gets the last element of `array`.\n *\n * @signature\n *    P.last()(array)\n * @example\n *    P.pipe(\n *      [1, 2, 4, 8, 16],\n *      P.filter(x => x > 3),\n *      P.last(),\n *      x => x + 1\n *    ); // => 17\n * @dataLast\n * @category Array\n */\nexport function last(): <T extends IterableContainer>(data: T) => Last<T>;\n\nexport function last(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lastImplementation, args);\n}\n\nfunction lastImplementation<T>(array: ReadonlyArray<T>): T | undefined {\n  return array.at(-1);\n};\n"],"mappings":"wCA8CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EAAsB,EAAwC,CACrE,OAAO,EAAM,GAAG,GAAG"}
+{"version":3,"file":"last.js","names":[],"sources":["../src/last.ts"],"sourcesContent":["import type { LastArrayElement } from 'type-fest';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Last<T extends IterableContainer> = LastArrayElement<\n  T,\n  // Type-fest's LastArrayElement assumes a looser typescript configuration\n  // where `noUncheckedIndexedAccess` is disabled. To support the stricter\n  // configuration we assume we need to assign the \"LastArrayElement\" param to\n  // `undefined`, but only if the array isn't empty.\n  T extends readonly [] ? never : undefined\n>;\n\n/**\n * Gets the last element of `array`.\n *\n * @param data - The array.\n * @signature\n *    last(array)\n * @example\n *    last([1, 2, 3]) // => 3\n *    last([]) // => undefined\n * @dataFirst\n * @category Array\n */\nexport function last<T extends IterableContainer>(data: T): Last<T>;\n\n/**\n * Gets the last element of `array`.\n *\n * @signature\n *    last()(array)\n * @example\n *    pipe(\n *      [1, 2, 4, 8, 16],\n *      filter(x => x > 3),\n *      last(),\n *      x => x + 1\n *    ); // => 17\n * @dataLast\n * @category Array\n */\nexport function last(): <T extends IterableContainer>(data: T) => Last<T>;\n\nexport function last(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lastImplementation, args);\n}\n\nfunction lastImplementation<T>(array: ReadonlyArray<T>): T | undefined {\n  return array.at(-1);\n}\n"],"mappings":"mCA4CA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EAAsB,EAAwC,CACrE,OAAO,EAAM,GAAG,GAAG"}

package/dist/lazy-data-last-impl-B05ZpguF.cjs

@@ -0,0 +1,2 @@
+function e(e,t,n){let r=n=>e(n,...t);return n===void 0?r:Object.assign(r,{lazy:n,lazyArgs:t})}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});
+//# sourceMappingURL=lazy-data-last-impl-B05ZpguF.cjs.map

package/dist/lazy-data-last-impl-B05ZpguF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-data-last-impl-B05ZpguF.cjs","names":[],"sources":["../src/internal/lazy-data-last-impl.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport type { StrictFunction } from './types/strict-function';\n\n/**\n * Use this helper function to build the data last implementation together with\n * a lazy implementation. Use this when you need to build your own currying\n * logic when you want to decide between dataFirst and dataLast on something\n * that isn't the number of arguments provided. This is useful for implementing\n * functions with optional or variadic arguments.\n */\nexport function lazyDataLastImpl(\n  fn: StrictFunction,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n  // TODO: We can probably provide better typing to the return type...\n): unknown {\n  // @ts-expect-error [ts2345] -- This error is accurate because we don't know\n  // anything about `fn` so can't ensure that we are passing the correct\n  // arguments to it, we just have to trust that the caller knows what they are\n  // doing.\n  const dataLast = (data: unknown): unknown => fn(data, ...args);\n\n  return lazy === undefined\n    ? dataLast\n    : Object.assign(dataLast, { lazy, lazyArgs: args });\n}\n"],"mappings":"AAYA,SAAgB,EACd,EACA,EACA,EAES,CAKT,IAAM,EAAY,GAA2B,EAAG,EAAM,GAAG,EAAK,CAE9D,OAAO,IAAS,IAAA,GACZ,EACA,OAAO,OAAO,EAAU,CAAE,OAAM,SAAU,EAAM,CAAC"}

package/dist/lazy-data-last-impl-Vt_M0l7X.js

@@ -0,0 +1,2 @@
+function e(e,t,n){let r=n=>e(n,...t);return n===void 0?r:Object.assign(r,{lazy:n,lazyArgs:t})}export{e as t};
+//# sourceMappingURL=lazy-data-last-impl-Vt_M0l7X.js.map

package/dist/lazy-data-last-impl-Vt_M0l7X.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-data-last-impl-Vt_M0l7X.js","names":[],"sources":["../src/internal/lazy-data-last-impl.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any */\n\nimport type { LazyEvaluator } from './types/lazy-evaluator';\nimport type { StrictFunction } from './types/strict-function';\n\n/**\n * Use this helper function to build the data last implementation together with\n * a lazy implementation. Use this when you need to build your own currying\n * logic when you want to decide between dataFirst and dataLast on something\n * that isn't the number of arguments provided. This is useful for implementing\n * functions with optional or variadic arguments.\n */\nexport function lazyDataLastImpl(\n  fn: StrictFunction,\n  args: ReadonlyArray<unknown>,\n  lazy?: (...args: any) => LazyEvaluator,\n  // TODO: We can probably provide better typing to the return type...\n): unknown {\n  // @ts-expect-error [ts2345] -- This error is accurate because we don't know\n  // anything about `fn` so can't ensure that we are passing the correct\n  // arguments to it, we just have to trust that the caller knows what they are\n  // doing.\n  const dataLast = (data: unknown): unknown => fn(data, ...args);\n\n  return lazy === undefined\n    ? dataLast\n    : Object.assign(dataLast, { lazy, lazyArgs: args });\n}\n"],"mappings":"AAYA,SAAgB,EACd,EACA,EACA,EAES,CAKT,IAAM,EAAY,GAA2B,EAAG,EAAM,GAAG,EAAK,CAE9D,OAAO,IAAS,IAAA,GACZ,EACA,OAAO,OAAO,EAAU,CAAE,OAAM,SAAU,EAAM,CAAC"}

package/dist/length.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){return`length`in e?e.length:[...e].length}exports.length=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e){return`length`in e?e.length:[...e].length}exports.length=t;
+//# sourceMappingURL=length.cjs.map

package/dist/length.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"length.cjs","names":["curry"],"sources":["../src/length.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Enumerable<T> = ArrayLike<T> | Iterable<T>;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @param items - The input data.\n * @signature\n *    length(array)\n * @example\n *    length([1, 2, 3]) // => 3\n * @dataFirst\n * @category Array\n */\nexport function length<T>(items: Enumerable<T>): number;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @signature\n *    length()(array)\n * @example\n *    pipe([1, 2, 3], length()) // => 3\n * @dataLast\n * @category Array\n */\nexport function length<T>(): (items: Enumerable<T>) => number;\n\nexport function length(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lengthImplementation, args);\n}\n\nfunction lengthImplementation<T>(items: Enumerable<T>): number {\n  return 'length' in items ? items.length : [...items].length;\n}\n"],"mappings":"kGA6BA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EAAwB,EAA8B,CAC7D,MAAO,WAAY,EAAQ,EAAM,OAAS,CAAC,GAAG,EAAM,CAAC"}

package/dist/length.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){return`length`in e?e.length:[...e].length}export{t as length};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){return`length`in e?e.length:[...e].length}export{t as length};
 //# sourceMappingURL=length.js.map

package/dist/length.js.map

@@ -1 +1 @@
-{"version":3,"file":"length.js","names":[],"sources":["../src/length.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Enumerable<T> = ArrayLike<T> | Iterable<T>;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @param items - The input data.\n * @signature\n *    P.length(array)\n * @example\n *    P.length([1, 2, 3]) // => 3\n * @dataFirst\n * @category Array\n */\nexport function length<T>(items: Enumerable<T>): number;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @signature\n *    P.length()(array)\n * @example\n *    P.pipe([1, 2, 3], P.length()) // => 3\n * @dataLast\n * @category Array\n */\nexport function length<T>(): (items: Enumerable<T>) => number;\n\nexport function length(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lengthImplementation, args);\n}\n\nfunction lengthImplementation<T>(items: Enumerable<T>): number {\n  return 'length' in items ? items.length : [...items].length;\n}\n"],"mappings":"wCA6BA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAAwB,EAA8B,CAC7D,MAAO,WAAY,EAAQ,EAAM,OAAS,CAAC,GAAG,EAAM,CAAC"}
+{"version":3,"file":"length.js","names":[],"sources":["../src/length.ts"],"sourcesContent":["import { curry } from './curry';\n\ntype Enumerable<T> = ArrayLike<T> | Iterable<T>;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @param items - The input data.\n * @signature\n *    length(array)\n * @example\n *    length([1, 2, 3]) // => 3\n * @dataFirst\n * @category Array\n */\nexport function length<T>(items: Enumerable<T>): number;\n\n/**\n * Counts values of the collection or iterable.\n *\n * @signature\n *    length()(array)\n * @example\n *    pipe([1, 2, 3], length()) // => 3\n * @dataLast\n * @category Array\n */\nexport function length<T>(): (items: Enumerable<T>) => number;\n\nexport function length(...args: ReadonlyArray<unknown>): unknown {\n  return curry(lengthImplementation, args);\n}\n\nfunction lengthImplementation<T>(items: Enumerable<T>): number {\n  return 'length' in items ? items.length : [...items].length;\n}\n"],"mappings":"mCA6BA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAAwB,EAA8B,CAC7D,MAAO,WAAY,EAAQ,EAAM,OAAS,CAAC,GAAG,EAAM,CAAC"}

package/dist/map-keys.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e)){let a=t(r,i,e);n[a]=i}return n}exports.mapKeys=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e)){let a=t(r,i,e);n[a]=i}return n}exports.mapKeys=t;
+//# sourceMappingURL=map-keys.cjs.map

package/dist/map-keys.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-keys.cjs","names":["curry"],"sources":["../src/map-keys.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\n\nimport type { And, IsUnion, Or } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IsBounded } from './internal/types/is-bounded';\nimport { curry } from './curry';\n\ntype MappedKeys<T, Key extends PropertyKey> = MaybePartial<\n  T,\n  Key,\n  // We re-key `T` using `Key`, but because we can't infer at the type level\n  // how the mapper would map each specific input key we assign all props the\n  // same value, made of all possible values of `T`.\n  Record<Key, EnumerableStringKeyedValueOf<T>>\n>;\n\n/**\n * This type is very similar to `BoundedPartial` simplified to the case where\n * we reconstruct the Record using a known `Key` type.\n *\n * @see BoundedPartial\n */\ntype MaybePartial<T, Key extends PropertyKey, Output>\n  = And<IsBounded<Key>, Or<IsUnion<Key>, CouldBeEmpty<T>>> extends true\n    ? // When keys are bounded we need to consider what assurances we can make\n  // about the presence of keys in the output; mainly if there is more than\n  // one possible result from the mapper (so we can't know what it would\n  // return for a specific input, at the type level), or if object itself\n  // might be empty and thus also the output object.\n    Partial<Output>\n    : // If keys are not bounded TypeScript treats the Record as implicitly\n  // Partial so we don't need to do that here.\n    Output;\n\n/**\n * Types that are extendable by `{}` are also satisfied by an empty object and\n * thus _could be empty_.\n */\ntype CouldBeEmpty<T> = {} extends T ? true : false;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param data - The object to map.\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(object, fn)\n * @example\n *    mapKeys({a: 1, b: 2}, (key, value) => key + value) // => { a1: 1, b2: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): MappedKeys<T, Key>;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(fn)(object)\n * @example\n *    pipe({a: 1, b: 2}, mapKeys((key, value) => key + value)) // => { a1: 1, b2: 2 }\n * @dataLast\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): (data: T) => MappedKeys<T, Key>;\n\nexport function mapKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapKeysImplementation, args);\n}\n\nfunction mapKeysImplementation<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (key: string, value: unknown, data: T) => Key,\n): Partial<Record<Key, unknown>> {\n  const out: Partial<Record<Key, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedKey = keyMapper(key, value, data);\n    out[mappedKey] = value;\n  }\n\n  return out;\n}\n"],"mappings":"kGAoFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EAC+B,CAC/B,IAAM,EAAqC,EAAE,CAE7C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAAE,CAC/C,IAAM,EAAY,EAAU,EAAK,EAAO,EAAK,CAC7C,EAAI,GAAa,EAGnB,OAAO"}

package/dist/map-keys.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e)){let a=t(r,i,e);n[a]=i}return n}export{t as mapKeys};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e)){let a=t(r,i,e);n[a]=i}return n}export{t as mapKeys};
 //# sourceMappingURL=map-keys.js.map

package/dist/map-keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"map-keys.js","names":["out: Partial<Record<S, unknown>>"],"sources":["../src/map-keys.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\n\nimport type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\n\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param data - The object to map.\n * @param keyMapper - The mapping function.\n * @signature\n *    P.mapKeys(object, fn)\n * @example\n *    P.mapKeys({a: 1, b: 2}, (key, value) => key + value) // => { a1: 1, b2: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mapKeys<T extends {}, S extends PropertyKey>(\n  data: T,\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => S,\n): BoundedPartial<Record<S, EnumerableStringKeyedValueOf<T>>>;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param keyMapper - The mapping function.\n * @signature\n *    P.mapKeys(fn)(object)\n * @example\n *    P.pipe({a: 1, b: 2}, P.mapKeys((key, value) => key + value)) // => { a1: 1, b2: 2 }\n * @dataLast\n * @category Object\n */\nexport function mapKeys<T extends {}, S extends PropertyKey>(\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => S,\n): (data: T) => BoundedPartial<Record<S, EnumerableStringKeyedValueOf<T>>>;\n\nexport function mapKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapKeysImplementation, args);\n}\n\nfunction mapKeysImplementation<T extends {}, S extends PropertyKey>(\n  data: T,\n  keyMapper: (key: string, value: unknown, data: T) => S,\n): Partial<Record<S, unknown>> {\n  const out: Partial<Record<S, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedKey = keyMapper(key, value, data);\n    out[mappedKey] = value;\n  }\n\n  return out;\n}\n"],"mappings":"wCAmDA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EAC6B,CAC7B,IAAMA,EAAmC,EAAE,CAE3C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAAE,CAC/C,IAAM,EAAY,EAAU,EAAK,EAAO,EAAK,CAC7C,EAAI,GAAa,EAGnB,OAAO"}
+{"version":3,"file":"map-keys.js","names":[],"sources":["../src/map-keys.ts"],"sourcesContent":["/* eslint-disable ts/no-empty-object-type --\n * We want to match the typing of the built-in Object.entries as much as\n * possible!\n */\n\nimport type { And, IsUnion, Or } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IsBounded } from './internal/types/is-bounded';\nimport { curry } from './curry';\n\ntype MappedKeys<T, Key extends PropertyKey> = MaybePartial<\n  T,\n  Key,\n  // We re-key `T` using `Key`, but because we can't infer at the type level\n  // how the mapper would map each specific input key we assign all props the\n  // same value, made of all possible values of `T`.\n  Record<Key, EnumerableStringKeyedValueOf<T>>\n>;\n\n/**\n * This type is very similar to `BoundedPartial` simplified to the case where\n * we reconstruct the Record using a known `Key` type.\n *\n * @see BoundedPartial\n */\ntype MaybePartial<T, Key extends PropertyKey, Output>\n  = And<IsBounded<Key>, Or<IsUnion<Key>, CouldBeEmpty<T>>> extends true\n    ? // When keys are bounded we need to consider what assurances we can make\n  // about the presence of keys in the output; mainly if there is more than\n  // one possible result from the mapper (so we can't know what it would\n  // return for a specific input, at the type level), or if object itself\n  // might be empty and thus also the output object.\n    Partial<Output>\n    : // If keys are not bounded TypeScript treats the Record as implicitly\n  // Partial so we don't need to do that here.\n    Output;\n\n/**\n * Types that are extendable by `{}` are also satisfied by an empty object and\n * thus _could be empty_.\n */\ntype CouldBeEmpty<T> = {} extends T ? true : false;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param data - The object to map.\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(object, fn)\n * @example\n *    mapKeys({a: 1, b: 2}, (key, value) => key + value) // => { a1: 1, b2: 2 }\n * @dataFirst\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): MappedKeys<T, Key>;\n\n/**\n * Maps keys of `object` and keeps the same values.\n *\n * @param keyMapper - The mapping function.\n * @signature\n *    mapKeys(fn)(object)\n * @example\n *    pipe({a: 1, b: 2}, mapKeys((key, value) => key + value)) // => { a1: 1, b2: 2 }\n * @dataLast\n * @category Object\n */\nexport function mapKeys<T extends {}, Key extends PropertyKey>(\n  keyMapper: (\n    key: EnumerableStringKeyOf<T>,\n    value: EnumerableStringKeyedValueOf<T>,\n    data: T,\n  ) => Key,\n): (data: T) => MappedKeys<T, Key>;\n\nexport function mapKeys(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapKeysImplementation, args);\n}\n\nfunction mapKeysImplementation<T extends {}, Key extends PropertyKey>(\n  data: T,\n  keyMapper: (key: string, value: unknown, data: T) => Key,\n): Partial<Record<Key, unknown>> {\n  const out: Partial<Record<Key, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedKey = keyMapper(key, value, data);\n    out[mappedKey] = value;\n  }\n\n  return out;\n}\n"],"mappings":"mCAoFA,SAAgB,EAAQ,GAAG,EAAuC,CAChE,OAAO,EAAM,EAAuB,EAAK,CAG3C,SAAS,EACP,EACA,EAC+B,CAC/B,IAAM,EAAqC,EAAE,CAE7C,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAAE,CAC/C,IAAM,EAAY,EAAU,EAAK,EAAO,EAAK,CAC7C,EAAI,GAAa,EAGnB,OAAO"}

package/dist/map-to-obj.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries()){let[a,o]=t(i,r,e);n[a]=o}return n}exports.mapToObj=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries()){let[a,o]=t(i,r,e);n[a]=o}return n}exports.mapToObj=t;
+//# sourceMappingURL=map-to-obj.cjs.map

package/dist/map-to-obj.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-to-obj.cjs","names":["curry"],"sources":["../src/map-to-obj.ts"],"sourcesContent":["import { curry } from './curry';\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\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\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param array - The array to map.\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(array, fn)\n * @example\n *    mapToObj([1, 2, 3], x => [String(x), x * 2]) // => {1: 2, 2: 4, 3: 6}\n * @dataFirst\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  array: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): Record<K, V>;\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\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\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(fn)(array)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      mapToObj(x => [String(x), x * 2])\n *    ) // => {1: 2, 2: 4, 3: 6}\n * @dataLast\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): (array: ReadonlyArray<T>) => Record<K, V>;\n\nexport function mapToObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapToObjImplementation, args);\n}\n\nfunction mapToObjImplementation(\n  array: ReadonlyArray<unknown>,\n  fn: (\n    value: unknown,\n    index: number,\n    data: ReadonlyArray<unknown>,\n  ) => [PropertyKey, unknown],\n): Record<PropertyKey, unknown> {\n  const out: Record<PropertyKey, unknown> = {};\n\n  for (const [index, element] of array.entries()) {\n    const [key, value] = fn(element, index, array);\n    out[key] = value;\n  }\n\n  return out;\n}\n"],"mappings":"kGA2EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,MAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EAK8B,CAC9B,IAAM,EAAoC,EAAE,CAE5C,IAAK,GAAM,CAAC,EAAO,KAAY,EAAM,SAAS,CAAE,CAC9C,GAAM,CAAC,EAAK,GAAS,EAAG,EAAS,EAAO,EAAM,CAC9C,EAAI,GAAO,EAGb,OAAO"}

package/dist/map-to-obj.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries()){let[a,o]=t(i,r,e);n[a]=o}return n}export{t as mapToObj};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries()){let[a,o]=t(i,r,e);n[a]=o}return n}export{t as mapToObj};
 //# sourceMappingURL=map-to-obj.js.map

package/dist/map-to-obj.js.map

@@ -1 +1 @@
-{"version":3,"file":"map-to-obj.js","names":["out: Record<PropertyKey, unknown>"],"sources":["../src/map-to-obj.ts"],"sourcesContent":["import { curry } from './curry';\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\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\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param array - The array to map.\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    P.mapToObj(array, fn)\n * @example\n *    P.mapToObj([1, 2, 3], x => [String(x), x * 2]) // => {1: 2, 2: 4, 3: 6}\n * @dataFirst\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  array: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): Record<K, V>;\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\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\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    P.mapToObj(fn)(array)\n * @example\n *    P.pipe(\n *      [1, 2, 3],\n *      P.mapToObj(x => [String(x), x * 2])\n *    ) // => {1: 2, 2: 4, 3: 6}\n * @dataLast\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): (array: ReadonlyArray<T>) => Record<K, V>;\n\nexport function mapToObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapToObjImplementation, args);\n}\n\nfunction mapToObjImplementation(\n  array: ReadonlyArray<unknown>,\n  fn: (\n    value: unknown,\n    index: number,\n    data: ReadonlyArray<unknown>,\n  ) => [PropertyKey, unknown],\n): Record<PropertyKey, unknown> {\n  const out: Record<PropertyKey, unknown> = {};\n\n  for (const [index, element] of array.entries()) {\n    const [key, value] = fn(element, index, array);\n    out[key] = value;\n  }\n\n  return out;\n}\n"],"mappings":"wCA2EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EAK8B,CAC9B,IAAMA,EAAoC,EAAE,CAE5C,IAAK,GAAM,CAAC,EAAO,KAAY,EAAM,SAAS,CAAE,CAC9C,GAAM,CAAC,EAAK,GAAS,EAAG,EAAS,EAAO,EAAM,CAC9C,EAAI,GAAO,EAGb,OAAO"}
+{"version":3,"file":"map-to-obj.js","names":[],"sources":["../src/map-to-obj.ts"],"sourcesContent":["import { curry } from './curry';\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\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\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param array - The array to map.\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(array, fn)\n * @example\n *    mapToObj([1, 2, 3], x => [String(x), x * 2]) // => {1: 2, 2: 4, 3: 6}\n * @dataFirst\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  array: ReadonlyArray<T>,\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): Record<K, V>;\n\n// TODO [>2]: Once we allow fromEntries to run lazily on iterables we need to remove this utility as it's completely replaceable by `fromEntries(map(...))`.\n/**\n * Map each element of an array into an object using a defined mapper that\n * converts each item into an object entry (a tuple of `[<key>, <value>]`).\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\n * values.\n * - `indexBy` - Builds an object from an array of *values* and a mapper for\n * keys.\n * - `pullObject` - Builds an object from an array of items with a mapper for\n * values and another mapper for keys.\n * - `fromEntries` - Builds an object from an array of key-value pairs.\n *\n * **Warning**: We strongly advise against using this function unless it is\n * used with a huge input array and your app has stringent memory/gc\n * constraints. We recommend that in most cases you should use `pullObject`,\n * or the composition `fromEntries(map(array, fn))`. This function will be\n * deprecated and **removed** in future versions of the library!\n *\n * @param fn - The mapping function, which should return a tuple of [key, value], similar to Object.fromEntries.\n * @returns The new mapped object.\n * @signature\n *    mapToObj(fn)(array)\n * @example\n *    pipe(\n *      [1, 2, 3],\n *      mapToObj(x => [String(x), x * 2])\n *    ) // => {1: 2, 2: 4, 3: 6}\n * @dataLast\n * @category Array\n */\nexport function mapToObj<T, K extends PropertyKey, V>(\n  fn: (value: T, index: number, data: ReadonlyArray<T>) => [K, V],\n): (array: ReadonlyArray<T>) => Record<K, V>;\n\nexport function mapToObj(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapToObjImplementation, args);\n}\n\nfunction mapToObjImplementation(\n  array: ReadonlyArray<unknown>,\n  fn: (\n    value: unknown,\n    index: number,\n    data: ReadonlyArray<unknown>,\n  ) => [PropertyKey, unknown],\n): Record<PropertyKey, unknown> {\n  const out: Record<PropertyKey, unknown> = {};\n\n  for (const [index, element] of array.entries()) {\n    const [key, value] = fn(element, index, array);\n    out[key] = value;\n  }\n\n  return out;\n}\n"],"mappings":"mCA2EA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAM,EAAwB,EAAK,CAG5C,SAAS,EACP,EACA,EAK8B,CAC9B,IAAM,EAAoC,EAAE,CAE5C,IAAK,GAAM,CAAC,EAAO,KAAY,EAAM,SAAS,CAAE,CAC9C,GAAM,CAAC,EAAK,GAAS,EAAG,EAAS,EAAO,EAAM,CAC9C,EAAI,GAAO,EAGb,OAAO"}

package/dist/map-values.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e))n[r]=t(i,r,e);return n}exports.mapValues=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./curry.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e))n[r]=t(i,r,e);return n}exports.mapValues=t;
+//# sourceMappingURL=map-values.cjs.map

package/dist/map-values.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-values.cjs","names":["curry"],"sources":["../src/map-values.ts"],"sourcesContent":["import type { Simplify } from 'type-fest';\nimport type { EnumerableStringKeyOf } from './internal/types/enumerable-string-key-of';\nimport type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport { curry } from './curry';\n\ntype MappedValues<T extends object, Value> = Simplify<{\n  -readonly [P in keyof T as P extends number | string ? P : never]: Value;\n}>;\n\n/**\n * Maps values of `object` and keeps the same keys. Symbol keys are not passed\n * to the mapper and will be removed from the output object.\n *\n * To also copy the symbol keys to the output use merge:\n * `merge(data, mapValues(data, mapper))`).\n *\n * @param data - The object to map.\n * @param valueMapper - The mapping function.\n * @signature\n *    mapValues(data, mapper)\n * @example\n *    mapValues({a: 1, b: 2}, (value, key) => value + key) // => {a: '1a', b: '2b'}\n * @dataFirst\n * @category Object\n */\nexport function mapValues<T extends object, Value>(\n  data: T,\n  valueMapper: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => Value,\n): MappedValues<T, Value>;\n\n/**\n * Maps values of `object` and keeps the same keys. Symbol keys are not passed\n * to the mapper and will be removed from the output object.\n *\n * To also copy the symbol keys to the output use merge:\n * `merge(data, mapValues(data, mapper))`).\n *\n * @param valueMapper - The mapping function.\n * @signature\n *    mapValues(mapper)(data)\n * @example\n *    pipe({a: 1, b: 2}, mapValues((value, key) => value + key)) // => {a: '1a', b: '2b'}\n * @dataLast\n * @category Object\n */\nexport function mapValues<T extends object, Value>(\n  valueMapper: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => Value,\n): (data: T) => MappedValues<T, Value>;\n\nexport function mapValues(...args: ReadonlyArray<unknown>): unknown {\n  return curry(mapValuesImplementation, args);\n}\n\nfunction mapValuesImplementation<T extends object, Value>(\n  data: T,\n  valueMapper: (value: unknown, key: string, data: T) => Value,\n): Record<string, Value> {\n  const out: Record<string, Value> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    const mappedValue = valueMapper(value, key, data);\n    out[key] = mappedValue;\n  }\n\n  return out;\n}\n"],"mappings":"kGAyDA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAOA,EAAAA,MAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACuB,CACvB,IAAM,EAA6B,EAAE,CAErC,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CAE7C,EAAI,GADgB,EAAY,EAAO,EAAK,EAAK,CAInD,OAAO"}

package/dist/map-values.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e))n[r]=t(i,r,e);return n}export{t as mapValues};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e))n[r]=t(i,r,e);return n}export{t as mapValues};
 //# sourceMappingURL=map-values.js.map