@vinicunca/perkakas 1.13.2 → 1.14.0

package/dist/truncate.js

@@ -0,0 +1,2 @@
+function e(e,n,r){return typeof e==`string`?t(e,n,r):r=>t(r,e,n)}function t(e,t,{omission:n=`...`,separator:r}={}){if(e.length<=t)return e;if(t<=0)return``;if(t<n.length)return n.slice(0,t);let i=t-n.length;if(typeof r==`string`){let t=e.lastIndexOf(r,i);t!==-1&&(i=t)}else if(r!==void 0){let t=r.flags.includes(`g`)?r:new RegExp(r.source,`${r.flags}g`),n;for(let{index:r}of e.matchAll(t)){if(r>i)break;n=r}n!==void 0&&(i=n)}return`${e.slice(0,i)}${n}`}export{e as truncate};
+//# sourceMappingURL=truncate.js.map

package/dist/truncate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncate.js","names":[],"sources":["../src/truncate.ts"],"sourcesContent":["import type {\n  And,\n  IsEqual,\n  IsNever,\n  IsStringLiteral,\n  NonNegativeInteger,\n} from 'type-fest';\nimport type { ClampedIntegerSubtract } from './internal/types/clamped-integer-subtract';\nimport type { StringLength } from './internal/types/string-length';\n\ninterface TruncateOptions {\n  readonly omission?: string;\n  readonly separator?: string | RegExp;\n}\n\nconst DEFAULT_OMISSION = '...';\n\ntype Truncate<\n  S extends string,\n  N extends number,\n  Options extends TruncateOptions,\n>\n  = IsNever<NonNegativeInteger<N>> extends true\n    ? // There's nothing we can say about the output without a literal, valid,\n  // truncation length `N`.\n    string\n    : IsStringLiteral<S> extends true\n      ? TruncateWithOptions<\n        S,\n        N,\n        // TODO: I don't like how I handled the default options object; I want to have everything coupled between the runtime and the type system, but this feels both brittle to changes, and over-verbose.\n        Options extends Pick<Required<TruncateOptions>, 'omission'>\n          ? Options['omission']\n          : typeof DEFAULT_OMISSION,\n        Options extends Pick<Required<TruncateOptions>, 'separator'>\n          ? Options['separator']\n          : undefined\n      >\n      : // There's nothing we can say about the output without a literal input\n    // string `S`, the result would always be, at best, just a `string`.\n      string;\n\ntype TruncateWithOptions<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Separator extends string | RegExp | undefined,\n>\n  // Distribute the result over unions.\n  = N extends unknown\n    ? // We can short-circuit most of our logic when N is a literal 0.\n    IsEqual<N, 0> extends true\n      ? ''\n      : // Distribute the result over unions.\n      Omission extends unknown\n        ? // When Omission isn't literal we don't know how long it is.\n        IsStringLiteral<Omission> extends true\n          ? // This mirrors the runtime logic where if `n - omission.length`\n        // is not positive then what we end up truncating is Omission\n        // itself and not S.\n          IsEqual<\n            ClampedIntegerSubtract<N, StringLength<Omission>>,\n            0\n          > extends true\n            ? TruncateLiterals<Omission, N, ''>\n            : And<\n              // When S isn't literal the output wouldn't be literal\n              // either.\n              IsStringLiteral<S>,\n              // TODO: Handling non-trivial separators would add a ton of complexity to this type! It's possible (but hard!) to support string literals so I'm leaving this as a TODO; regular expressions are impossible because we can't get the type checker to run them.\n              IsEqual<Separator, undefined>\n            > extends true\n              ? TruncateLiterals<S, N, Omission>\n              : string\n          : string\n        : never\n    : never;\n\n/**\n * This is the actual implementation of the truncation logic. It assumes all\n * its params are literals and valid.\n */\ntype TruncateLiterals<\n  S extends string,\n  N extends number,\n  Omission extends string,\n  Iteration extends ReadonlyArray<unknown> = [],\n> = S extends `${infer Character}${infer Rest}`\n  ? // The cutoff point N - omission.length leaves room for the omission.\n  Iteration['length'] extends ClampedIntegerSubtract<\n    N,\n    StringLength<Omission>\n  >\n    ? // The string is only truncated if its total length is longer than N; at\n  // the cutoff point this is simplified to comparing the remaining suffix\n  // length to the omission length.\n    IsLongerThan<S, Omission> extends true\n      ? Omission\n      : S\n    : // Reconstruct string character by character until cutoff.\n      `${Character}${TruncateLiterals<Rest, N, Omission, [...Iteration, unknown]>}`\n  : // Empty input string results in empty output.\n  '';\n\n/**\n * An optimized check that efficiently checks if the string A is longer than B.\n */\ntype IsLongerThan<\n  A extends string,\n  B extends string,\n> = A extends `${string}${infer RestA}`\n  ? B extends `${string}${infer RestB}`\n    ? IsLongerThan<RestA, RestB>\n    : // B is empty and A isn't!\n    true\n  : // A is empty, even if B is empty, A wouldn't be (strictly) longer.\n  false;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param data - The input string.\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(data, n, { omission, separator });\n * @example\n *   truncate(\"Hello, world!\", 8); //=> \"Hello...\"\n *   truncate(\n *     \"cat, dog, mouse\",\n *     12,\n *     { omission: \"__\", separator: \",\"},\n *   ); //=> \"cat, dog__\"\n * @dataFirst\n * @category String\n */\nexport function truncate<\n  S extends string,\n  N extends number,\n  const Options extends TruncateOptions,\n>(data: S, n: N, options?: Options): Truncate<S, N, Options>;\n\n/**\n * Truncates strings to a maximum length, adding an ellipsis when truncated.\n *\n * Shorter strings are returned unchanged. If the omission marker is longer than\n * the maximum length, it will be truncated as well.\n *\n * The `separator` argument provides more control by optimistically searching\n * for a matching cutoff point, which could be used to avoid truncating in the\n * middle of a word or other semantic boundary.\n *\n * If you just need to limit the total length of the string, without adding an\n * `omission` or optimizing the cutoff point via `separator`, prefer\n * `sliceString` instead, which runs more efficiently.\n *\n * The function counts Unicode characters, not visual graphemes, and may split\n * emojis, denormalized diacritics, or combining characters, in the middle. For\n * display purposes, prefer CSS [`text-overflow: ellipsis`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-overflow#ellipsis)\n * which is locale-aware and purpose-built for this task.\n *\n * @param n - The maximum length of the output string. The output will **never**\n * exceed this length.\n * @param options - An optional options object.\n * @param options.omission - The string that is appended to the end of the\n * output *whenever the input string is truncated*. Default: '...'.\n * @param options.separator - A string or regular expression that defines a\n * cutoff point for the truncation. If multiple cutoff points are found, the one\n * closest to `n` will be used, and if no cutoff point is found then the\n * function will fallback to the trivial cutoff point. Regular expressions are\n * also supported. Default: <none> (which is equivalent to `\"\"` or the regular\n * expression `/./`).\n * @signature\n *   truncate(n, { omission, separator })(data);\n * @example\n *   pipe(\"Hello, world!\" as const, truncate(8)); //=> \"Hello...\"\n *   pipe(\n *     \"cat, dog, mouse\" as const,\n *     truncate(12, { omission: \"__\", separator: \",\"}),\n *   ); //=> \"cat, dog__\"\n * @dataLast\n * @category String\n */\nexport function truncate<\n  N extends number,\n  const Options extends TruncateOptions,\n>(\n  n: N,\n  options?: Options,\n): <S extends string>(data: S) => Truncate<S, N, Options>;\n\nexport function truncate(\n  dataOrN: string | number,\n  nOrOptions?: number | TruncateOptions,\n  options?: TruncateOptions,\n): unknown {\n  return typeof dataOrN === 'string'\n    ? truncateImplementation(\n        dataOrN,\n        // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n        // minimum, and there's no (easy) way to couple params so that when we\n        // check one, the others are inferred accordingly.\n        nOrOptions,\n        options,\n      )\n    : (data: string) =>\n        truncateImplementation(\n          data,\n          dataOrN,\n          // @ts-expect-error [ts2345] -- We want to reduce runtime checks to a\n          // minimum, and there's no (easy) way to couple params so that when we\n          // check one, the others are inferred accordingly.\n          nOrOptions,\n        );\n}\n\nfunction truncateImplementation(\n  data: string,\n  n: number,\n  { omission = DEFAULT_OMISSION, separator }: TruncateOptions = {},\n): string {\n  if (data.length <= n) {\n    // No truncation needed.\n    return data;\n  }\n\n  if (n <= 0) {\n    // Avoid weirdness when n isn't positive.\n    return '';\n  }\n\n  if (n < omission.length) {\n    // TODO [>3]: This was an oversight, there's no value in returning just parts of the omission string itself, with no actual content. Instead, we should truncate the input without adding the omission at all in cases where the omission would completely eclipse the content.\n    // Handle cases where the omission itself is too long.\n    return omission.slice(0, n);\n  }\n\n  // Our trivial cutoff is the point where we can add the omission and reach\n  // n exactly, this is what we'll use when no separator is provided.\n  let cutoff = n - omission.length;\n\n  if (typeof separator === 'string') {\n    const lastSeparator = data.lastIndexOf(separator, cutoff);\n    if (lastSeparator !== -1) {\n      // If we find the separator within the part of the string that would be\n      // returned we move the cutoff further so that we also remove it.\n      cutoff = lastSeparator;\n    }\n  } else if (separator !== undefined) {\n    const globalSeparator = separator.flags.includes('g')\n      ? separator\n      : new RegExp(separator.source, `${separator.flags}g`);\n\n    let lastSeparator;\n    for (const { index } of data.matchAll(globalSeparator)) {\n      if (index > cutoff) {\n        // We only care about separators within the part of the string that\n        // would be returned anyway, once we are past that point we don't care\n        // about any further separators.\n        break;\n      }\n      lastSeparator = index;\n    }\n    if (lastSeparator !== undefined) {\n      cutoff = lastSeparator;\n    }\n  }\n\n  // Build the output.\n  return `${data.slice(0, cutoff)}${omission}`;\n}\n"],"mappings":"AAwNA,SAAgB,EACd,EACA,EACA,EACS,CACT,OAAO,OAAO,GAAY,SACtB,EACE,EAIA,EACA,EACD,CACA,GACC,EACE,EACA,EAIA,EACD,CAGT,SAAS,EACP,EACA,EACA,CAAE,WAAW,MAAkB,aAA+B,EAAE,CACxD,CACR,GAAI,EAAK,QAAU,EAEjB,OAAO,EAGT,GAAI,GAAK,EAEP,MAAO,GAGT,GAAI,EAAI,EAAS,OAGf,OAAO,EAAS,MAAM,EAAG,EAAE,CAK7B,IAAI,EAAS,EAAI,EAAS,OAE1B,GAAI,OAAO,GAAc,SAAU,CACjC,IAAM,EAAgB,EAAK,YAAY,EAAW,EAAO,CACrD,IAAkB,KAGpB,EAAS,WAEF,IAAc,IAAA,GAAW,CAClC,IAAM,EAAkB,EAAU,MAAM,SAAS,IAAI,CACjD,EACA,IAAI,OAAO,EAAU,OAAQ,GAAG,EAAU,MAAM,GAAG,CAEnD,EACJ,IAAK,GAAM,CAAE,WAAW,EAAK,SAAS,EAAgB,CAAE,CACtD,GAAI,EAAQ,EAIV,MAEF,EAAgB,EAEd,IAAkB,IAAA,KACpB,EAAS,GAKb,MAAO,GAAG,EAAK,MAAM,EAAG,EAAO,GAAG"}

package/dist/uncapitalize.cjs

@@ -1 +1,2 @@
-const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){return`${e[0]?.toLowerCase()??``}${e.slice(1)}`}exports.uncapitalize=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[0]?.toLowerCase()??``}${e.slice(1)}`}exports.uncapitalize=t;
+//# sourceMappingURL=uncapitalize.cjs.map

package/dist/uncapitalize.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uncapitalize.cjs","names":["curry"],"sources":["../src/uncapitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   uncapitalize(data);\n * @example\n *   uncapitalize(\"HELLO WORLD\"); // \"hELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function uncapitalize<T extends string>(data: T): Uncapitalize<T>;\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @signature\n *   uncapitalize()(data);\n * @example\n *   pipe(\"HELLO WORLD\", uncapitalize()); // \"hELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function uncapitalize(): <T extends string>(data: T) => Uncapitalize<T>;\n\nexport function uncapitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(uncapitalizeImplementation, args);\n}\n\nfunction uncapitalizeImplementation<T extends string>(data: T): Uncapitalize<T> {\n  return `${data[0]?.toLowerCase() ?? ''}${data.slice(1)}` as Uncapitalize<T>;\n}\n"],"mappings":"kGAmDA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAOA,EAAAA,MAAM,EAA4B,EAAK,CAGhD,SAAS,EAA6C,EAA0B,CAC9E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}

package/dist/uncapitalize.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[0]?.toLowerCase()??``}${e.slice(1)}`}export{t as uncapitalize};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t)}function n(e){return`${e[0]?.toLowerCase()??``}${e.slice(1)}`}export{t as uncapitalize};
 //# sourceMappingURL=uncapitalize.js.map

package/dist/uncapitalize.js.map

@@ -1 +1 @@
-{"version":3,"file":"uncapitalize.js","names":[],"sources":["../src/uncapitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   P.uncapitalize(data);\n * @example\n *   P.uncapitalize(\"HELLO WORLD\"); // \"hELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function uncapitalize<T extends string>(data: T): Uncapitalize<T>;\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @signature\n *   P.uncapitalize()(data);\n * @example\n *   P.pipe(\"HELLO WORLD\", P.uncapitalize()); // \"hELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function uncapitalize(): <T extends string>(data: T) => Uncapitalize<T>;\n\nexport function uncapitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(uncapitalizeImplementation, args);\n}\n\nfunction uncapitalizeImplementation<T extends string>(data: T): Uncapitalize<T> {\n  return `${data[0]?.toLowerCase() ?? ''}${data.slice(1)}` as Uncapitalize<T>;\n}\n"],"mappings":"wCAmDA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAM,EAA4B,EAAK,CAGhD,SAAS,EAA6C,EAA0B,CAC9E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}
+{"version":3,"file":"uncapitalize.js","names":[],"sources":["../src/uncapitalize.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @param data - A string.\n * @signature\n *   uncapitalize(data);\n * @example\n *   uncapitalize(\"HELLO WORLD\"); // \"hELLO WORLD\"\n * @dataFirst\n * @category String\n */\nexport function uncapitalize<T extends string>(data: T): Uncapitalize<T>;\n\n/**\n * Makes the first character of a string lowercase while leaving the rest\n * unchanged.\n *\n * It uses the built-in [`String.prototype.toLowerCase`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)\n * for the runtime and the built-in [`Uncapitalize`](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html#Uncapitalizestringtype)\n * utility type for typing and thus shares their _[locale inaccuracies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase#description)_.\n *\n * For display purposes, prefer using the CSS pseudo-element [`::first-letter`](https://developer.mozilla.org/en-US/docs/Web/CSS/::first-letter) to target\n * just the first letter of the word, and [`text-transform: lowercase`](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform#lowercase)\n * to lowercase it. This transformation **is** locale-aware.\n *\n * For other case manipulations see: `toUpperCase`, `toLowerCase`, `capitalize`,\n * `toCamelCase`, `toKebabCase`, `toSnakeCase`, and `toTitleCase`.\n *\n * @signature\n *   uncapitalize()(data);\n * @example\n *   pipe(\"HELLO WORLD\", uncapitalize()); // \"hELLO WORLD\"\n * @dataLast\n * @category String\n */\nexport function uncapitalize(): <T extends string>(data: T) => Uncapitalize<T>;\n\nexport function uncapitalize(...args: ReadonlyArray<unknown>): unknown {\n  return curry(uncapitalizeImplementation, args);\n}\n\nfunction uncapitalizeImplementation<T extends string>(data: T): Uncapitalize<T> {\n  return `${data[0]?.toLowerCase() ?? ''}${data.slice(1)}` as Uncapitalize<T>;\n}\n"],"mappings":"mCAmDA,SAAgB,EAAa,GAAG,EAAuC,CACrE,OAAO,EAAM,EAA4B,EAAK,CAGhD,SAAS,EAA6C,EAA0B,CAC9E,MAAO,GAAG,EAAK,IAAI,aAAa,EAAI,KAAK,EAAK,MAAM,EAAE"}

package/dist/unique-by.cjs

@@ -1 +1,2 @@
-const e=require(`./utility-evaluators-CAbODbuk.cjs`),t=require(`./curry-from-lazy-BCGvmhyS.cjs`);function n(...e){return t.t(r,e)}function r(t){let n=new Set;return(r,i,a)=>{let o=t(r,i,a);return n.has(o)?e.t:(n.add(o),{done:!1,hasNext:!0,next:r})}}exports.uniqueBy=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utility-evaluators-C8koSp9T.cjs`),t=require(`./curry-from-lazy-BvN_VKlH.cjs`);function n(...e){return t.t(r,e)}function r(t){let n=t,r=new Set;return(t,i,a)=>{let o=n(t,i,a);return r.has(o)?e.t:(r.add(o),{done:!1,hasNext:!0,next:t})}}exports.uniqueBy=n;
+//# sourceMappingURL=unique-by.cjs.map

package/dist/unique-by.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-by.cjs","names":["curryFromLazy","SKIP_ITEM"],"sources":["../src/unique-by.ts"],"sourcesContent":["import type { BrandedReturn } from './internal/types/branded-return';\nimport type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(data, keyFunction)\n * @example\n *    uniqueBy(\n *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],\n *     (obj) => obj.n,\n *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  data: T,\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(keyFunction)(data)\n * @example\n *    pipe(\n *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations\n *      uniqueBy(obj => obj.n),\n *      take(3)\n *    ) // => [{n: 1}, {n: 2}, {n: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): (data: T) => Deduped<T>;\n\nexport function uniqueBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(\n  keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => unknown,\n): LazyEvaluator<T> {\n  // @see https://github.com/typescript-eslint/typescript-eslint/issues/9885\n  const brandedKeyFunction = keyFunction as BrandedReturn<typeof keyFunction>;\n\n  const set = new Set<ReturnType<typeof brandedKeyFunction>>();\n  return (value, index, data) => {\n    const key = brandedKeyFunction(value, index, data);\n    if (set.has(key)) {\n      return SKIP_ITEM;\n    }\n\n    set.add(key);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"oKAkDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,SAAS,EACP,EACkB,CAElB,IAAM,EAAqB,EAErB,EAAM,IAAI,IAChB,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAM,EAAmB,EAAO,EAAO,EAAK,CAMlD,OALI,EAAI,IAAI,EAAI,CACPC,EAAAA,GAGT,EAAI,IAAI,EAAI,CACL,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/unique-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./utility-evaluators-Boc-TMbq.js";import{t}from"./curry-from-lazy-PQ0BbG-7.js";function n(...e){return t(r,e)}function r(t){let n=new Set;return(r,i,a)=>{let o=t(r,i,a);return n.has(o)?e:(n.add(o),{done:!1,hasNext:!0,next:r})}}export{n as uniqueBy};
+import{t as e}from"./utility-evaluators-ZAaUtL2Z.js";import{t}from"./curry-from-lazy-CtH1dp14.js";function n(...e){return t(r,e)}function r(t){let n=t,r=new Set;return(t,i,a)=>{let o=n(t,i,a);return r.has(o)?e:(r.add(o),{done:!1,hasNext:!0,next:t})}}export{n as uniqueBy};
 //# sourceMappingURL=unique-by.js.map

package/dist/unique-by.js.map

@@ -1 +1 @@
-{"version":3,"file":"unique-by.js","names":[],"sources":["../src/unique-by.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    P.uniqueBy(data, keyFunction)\n * @example\n *    P.uniqueBy(\n *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],\n *     (obj) => obj.n,\n *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer, K>(\n  data: T,\n  keyFunction: (item: T[number], index: number, data: T) => K,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    P.uniqueBy(keyFunction)(data)\n * @example\n *    P.pipe(\n *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations\n *      P.uniqueBy(obj => obj.n),\n *      P.take(3)\n *    ) // => [{n: 1}, {n: 2}, {n: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer, K>(\n  keyFunction: (item: T[number], index: number, data: T) => K,\n): (data: T) => Deduped<T>;\n\nexport function uniqueBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T, K>(\n  keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): LazyEvaluator<T> {\n  const set = new Set<K>();\n  return (value, index, data) => {\n    const key = keyFunction(value, index, data);\n    if (set.has(key)) {\n      return SKIP_ITEM;\n    }\n\n    set.add(key);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAkDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EACP,EACkB,CAClB,IAAM,EAAM,IAAI,IAChB,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAM,EAAY,EAAO,EAAO,EAAK,CAM3C,OALI,EAAI,IAAI,EAAI,CACP,GAGT,EAAI,IAAI,EAAI,CACL,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"unique-by.js","names":[],"sources":["../src/unique-by.ts"],"sourcesContent":["import type { BrandedReturn } from './internal/types/branded-return';\nimport type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(data, keyFunction)\n * @example\n *    uniqueBy(\n *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],\n *     (obj) => obj.n,\n *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  data: T,\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    uniqueBy(keyFunction)(data)\n * @example\n *    pipe(\n *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations\n *      uniqueBy(obj => obj.n),\n *      take(3)\n *    ) // => [{n: 1}, {n: 2}, {n: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer>(\n  keyFunction: (item: T[number], index: number, data: T) => unknown,\n): (data: T) => Deduped<T>;\n\nexport function uniqueBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(\n  keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => unknown,\n): LazyEvaluator<T> {\n  // @see https://github.com/typescript-eslint/typescript-eslint/issues/9885\n  const brandedKeyFunction = keyFunction as BrandedReturn<typeof keyFunction>;\n\n  const set = new Set<ReturnType<typeof brandedKeyFunction>>();\n  return (value, index, data) => {\n    const key = brandedKeyFunction(value, index, data);\n    if (set.has(key)) {\n      return SKIP_ITEM;\n    }\n\n    set.add(key);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAkDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EACP,EACkB,CAElB,IAAM,EAAqB,EAErB,EAAM,IAAI,IAChB,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAM,EAAmB,EAAO,EAAO,EAAK,CAMlD,OALI,EAAI,IAAI,EAAI,CACP,GAGT,EAAI,IAAI,EAAI,CACL,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/unique-with.cjs

@@ -1 +1,2 @@
-const e=require(`./utility-evaluators-CAbODbuk.cjs`),t=require(`./curry-from-lazy-BCGvmhyS.cjs`);function n(...e){return t.t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e.t}exports.uniqueWith=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utility-evaluators-C8koSp9T.cjs`),t=require(`./curry-from-lazy-BvN_VKlH.cjs`);function n(...e){return t.t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e.t}exports.uniqueWith=n;
+//# sourceMappingURL=unique-with.cjs.map

package/dist/unique-with.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-with.cjs","names":["curryFromLazy","SKIP_ITEM"],"sources":["../src/unique-with.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEquals<T> = (a: T, b: T) => boolean;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param data - The array to filter.\n * @param isEquals - The comparator.\n * @signature\n *    uniqueWith(array, isEquals)\n * @example\n *    uniqueWith(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *      equals,\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  data: T,\n  isEquals: IsEquals<T[number]>,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param isEquals - The comparator.\n * @signature uniqueWith(isEquals)(array)\n * @example\n *    uniqueWith(equals)(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n *    pipe(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations\n *      uniqueWith(equals),\n *      take(3)\n *    ) // => [{a: 1}, {a: 2}, {a: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  isEquals: IsEquals<T[number]>,\n): (data: T) => Deduped<T>;\n\nexport function uniqueWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(isEquals: IsEquals<T>): LazyEvaluator<T> {\n  return (value, index, data) => {\n    const firstEqualIndex = data.findIndex(\n      (otherValue, otherIndex) =>\n        index === otherIndex || isEquals(value, otherValue),\n    );\n\n    // skip items that aren't at the first equal index.\n    return firstEqualIndex === index\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n  };\n}\n"],"mappings":"oKAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAAyC,CACtE,OAAQ,EAAO,EAAO,IACI,EAAK,WAC1B,EAAY,IACX,IAAU,GAAc,EAAS,EAAO,EAAW,CACtD,GAG0B,EACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3CC,EAAAA"}

package/dist/unique-with.js

@@ -1,2 +1,2 @@
-import{t as e}from"./utility-evaluators-Boc-TMbq.js";import{t}from"./curry-from-lazy-PQ0BbG-7.js";function n(...e){return t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e}export{n as uniqueWith};
+import{t as e}from"./utility-evaluators-ZAaUtL2Z.js";import{t}from"./curry-from-lazy-CtH1dp14.js";function n(...e){return t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e}export{n as uniqueWith};
 //# sourceMappingURL=unique-with.js.map

package/dist/unique-with.js.map

@@ -1 +1 @@
-{"version":3,"file":"unique-with.js","names":[],"sources":["../src/unique-with.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEquals<T> = (a: T, b: T) => boolean;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param data - The array to filter.\n * @param isEquals - The comparator.\n * @signature\n *    P.uniqueWith(array, isEquals)\n * @example\n *    P.uniqueWith(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *      P.equals,\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  data: T,\n  isEquals: IsEquals<T[number]>,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param isEquals - The comparator.\n * @signature P.uniqueWith(isEquals)(array)\n * @example\n *    P.uniqueWith(P.equals)(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n *    P.pipe(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations\n *      P.uniqueWith(P.equals),\n *      P.take(3)\n *    ) // => [{a: 1}, {a: 2}, {a: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  isEquals: IsEquals<T[number]>,\n): (data: T) => Deduped<T>;\n\nexport function uniqueWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(isEquals: IsEquals<T>): LazyEvaluator<T> {\n  return (value, index, data) => {\n    const firstEqualIndex = data.findIndex(\n      (otherValue, otherIndex) =>\n        index === otherIndex || isEquals(value, otherValue),\n    );\n\n    // skip items that aren't at the first equal index.\n    return firstEqualIndex === index\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n  };\n}\n"],"mappings":"kGAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAAyC,CACtE,OAAQ,EAAO,EAAO,IACI,EAAK,WAC1B,EAAY,IACX,IAAU,GAAc,EAAS,EAAO,EAAW,CACtD,GAG0B,EACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3C"}
+{"version":3,"file":"unique-with.js","names":[],"sources":["../src/unique-with.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEquals<T> = (a: T, b: T) => boolean;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param data - The array to filter.\n * @param isEquals - The comparator.\n * @signature\n *    uniqueWith(array, isEquals)\n * @example\n *    uniqueWith(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *      equals,\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  data: T,\n  isEquals: IsEquals<T[number]>,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param isEquals - The comparator.\n * @signature uniqueWith(isEquals)(array)\n * @example\n *    uniqueWith(equals)(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n *    pipe(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations\n *      uniqueWith(equals),\n *      take(3)\n *    ) // => [{a: 1}, {a: 2}, {a: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  isEquals: IsEquals<T[number]>,\n): (data: T) => Deduped<T>;\n\nexport function uniqueWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(isEquals: IsEquals<T>): LazyEvaluator<T> {\n  return (value, index, data) => {\n    const firstEqualIndex = data.findIndex(\n      (otherValue, otherIndex) =>\n        index === otherIndex || isEquals(value, otherValue),\n    );\n\n    // skip items that aren't at the first equal index.\n    return firstEqualIndex === index\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n  };\n}\n"],"mappings":"kGAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAAyC,CACtE,OAAQ,EAAO,EAAO,IACI,EAAK,WAC1B,EAAY,IACX,IAAU,GAAc,EAAS,EAAO,EAAW,CACtD,GAG0B,EACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3C"}

package/dist/unique.cjs

@@ -1 +1,2 @@
-const e=require(`./utility-evaluators-CAbODbuk.cjs`),t=require(`./curry-from-lazy-BCGvmhyS.cjs`);function n(...e){return t.t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e.t:(t.add(n),{done:!1,hasNext:!0,next:n})}exports.unique=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utility-evaluators-C8koSp9T.cjs`),t=require(`./curry-from-lazy-BvN_VKlH.cjs`);function n(...e){return t.t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e.t:(t.add(n),{done:!1,hasNext:!0,next:n})}exports.unique=n;
+//# sourceMappingURL=unique.cjs.map

package/dist/unique.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.cjs","names":["curryFromLazy","SKIP_ITEM"],"sources":["../src/unique.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @signature\n *    unique(array)\n * @example\n *    unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function unique<T extends IterableContainer>(data: T): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @signature\n *    unique()(array)\n * @example\n *    pipe(\n *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations\n *      unique(),\n *      take(3)\n *    ) // => [1, 2, 5]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;\n\nexport function unique(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(): LazyEvaluator<T> {\n  const set = new Set<T>();\n  return (value) => {\n    if (set.has(value)) {\n      return SKIP_ITEM;\n    }\n    set.add(value);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"oKAuCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,EAAc,EAAoB,EAAK,CAGhD,SAAS,GAA0C,CACjD,IAAM,EAAM,IAAI,IAChB,MAAQ,IACF,EAAI,IAAI,EAAM,CACTC,EAAAA,GAET,EAAI,IAAI,EAAM,CACP,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/unique.js

@@ -1,2 +1,2 @@
-import{t as e}from"./utility-evaluators-Boc-TMbq.js";import{t}from"./curry-from-lazy-PQ0BbG-7.js";function n(...e){return t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e:(t.add(n),{done:!1,hasNext:!0,next:n})}export{n as unique};
+import{t as e}from"./utility-evaluators-ZAaUtL2Z.js";import{t}from"./curry-from-lazy-CtH1dp14.js";function n(...e){return t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e:(t.add(n),{done:!1,hasNext:!0,next:n})}export{n as unique};
 //# sourceMappingURL=unique.js.map

package/dist/unique.js.map

@@ -1 +1 @@
-{"version":3,"file":"unique.js","names":[],"sources":["../src/unique.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @signature\n *    P.unique(array)\n * @example\n *    P.unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function unique<T extends IterableContainer>(data: T): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @signature\n *    P.unique()(array)\n * @example\n *    P.pipe(\n *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations\n *      P.unique(),\n *      P.take(3)\n *    ) // => [1, 2, 5]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;\n\nexport function unique(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(): LazyEvaluator<T> {\n  const set = new Set<T>();\n  return (value) => {\n    if (set.has(value)) {\n      return SKIP_ITEM;\n    }\n    set.add(value);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAuCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,GAA0C,CACjD,IAAM,EAAM,IAAI,IAChB,MAAQ,IACF,EAAI,IAAI,EAAM,CACT,GAET,EAAI,IAAI,EAAM,CACP,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}
+{"version":3,"file":"unique.js","names":[],"sources":["../src/unique.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @signature\n *    unique(array)\n * @example\n *    unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function unique<T extends IterableContainer>(data: T): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @signature\n *    unique()(array)\n * @example\n *    pipe(\n *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations\n *      unique(),\n *      take(3)\n *    ) // => [1, 2, 5]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;\n\nexport function unique(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(): LazyEvaluator<T> {\n  const set = new Set<T>();\n  return (value) => {\n    if (set.has(value)) {\n      return SKIP_ITEM;\n    }\n    set.add(value);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAuCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,GAA0C,CACjD,IAAM,EAAM,IAAI,IAChB,MAAQ,IACF,EAAI,IAAI,EAAM,CACT,GAET,EAAI,IAAI,EAAM,CACP,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/utility-evaluators-C8koSp9T.cjs

@@ -0,0 +1,2 @@
+const e={done:!0,hasNext:!1},t={done:!1,hasNext:!1},n=()=>e;function r(e){return{hasNext:!0,next:e,done:!1}}Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return n}}),Object.defineProperty(exports,`r`,{enumerable:!0,get:function(){return r}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=utility-evaluators-C8koSp9T.cjs.map

package/dist/utility-evaluators-C8koSp9T.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-evaluators-C8koSp9T.cjs","names":[],"sources":["../src/internal/utility-evaluators.ts"],"sourcesContent":["import type { LazyResult } from './types/lazy-result';\n\nconst EMPTY_PIPE = { done: true, hasNext: false } as const;\n\n/**\n * A singleton value for skipping an item in a lazy evaluator.\n */\nexport const SKIP_ITEM = { done: false, hasNext: false } as const;\n\n/**\n * A helper evaluator when we want to return an empty result. It memoizes both\n * the result and the evaluator itself to reduce memory usage.\n */\nexport const lazyEmptyEvaluator = <T>(): LazyResult<T> => EMPTY_PIPE;\n\n/**\n * A helper evaluator when we want to return a shallow clone of the input. It\n * memoizes both the evaluator itself to reduce memory usage.\n */\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function lazyIdentityEvaluator<T>(value: T) {\n  return ({\n    hasNext: true,\n    next: value,\n    done: false,\n  }) as const;\n}\n"],"mappings":"AAEA,MAAM,EAAa,CAAE,KAAM,GAAM,QAAS,GAAO,CAKpC,EAAY,CAAE,KAAM,GAAO,QAAS,GAAO,CAM3C,MAA6C,EAO1D,SAAgB,EAAyB,EAAU,CACjD,MAAQ,CACN,QAAS,GACT,KAAM,EACN,KAAM,GACP"}

package/dist/utility-evaluators-ZAaUtL2Z.js

@@ -0,0 +1,2 @@
+const e={done:!0,hasNext:!1},t={done:!1,hasNext:!1},n=()=>e;function r(e){return{hasNext:!0,next:e,done:!1}}export{n,r,t};
+//# sourceMappingURL=utility-evaluators-ZAaUtL2Z.js.map

package/dist/utility-evaluators-ZAaUtL2Z.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-evaluators-ZAaUtL2Z.js","names":[],"sources":["../src/internal/utility-evaluators.ts"],"sourcesContent":["import type { LazyResult } from './types/lazy-result';\n\nconst EMPTY_PIPE = { done: true, hasNext: false } as const;\n\n/**\n * A singleton value for skipping an item in a lazy evaluator.\n */\nexport const SKIP_ITEM = { done: false, hasNext: false } as const;\n\n/**\n * A helper evaluator when we want to return an empty result. It memoizes both\n * the result and the evaluator itself to reduce memory usage.\n */\nexport const lazyEmptyEvaluator = <T>(): LazyResult<T> => EMPTY_PIPE;\n\n/**\n * A helper evaluator when we want to return a shallow clone of the input. It\n * memoizes both the evaluator itself to reduce memory usage.\n */\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function lazyIdentityEvaluator<T>(value: T) {\n  return ({\n    hasNext: true,\n    next: value,\n    done: false,\n  }) as const;\n}\n"],"mappings":"AAEA,MAAM,EAAa,CAAE,KAAM,GAAM,QAAS,GAAO,CAKpC,EAAY,CAAE,KAAM,GAAO,QAAS,GAAO,CAM3C,MAA6C,EAO1D,SAAgB,EAAyB,EAAU,CACjD,MAAQ,CACN,QAAS,GACT,KAAM,EACN,KAAM,GACP"}

package/dist/values.cjs

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

package/dist/values.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.cjs","names":["curry"],"sources":["../src/values.ts"],"sourcesContent":["import type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Values<T extends object> = T extends IterableContainer\n  ? Array<T[number]>\n  : Array<EnumerableStringKeyedValueOf<T>>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    values(source)\n * @example\n *    values(['x', 'y', 'z']) // => ['x', 'y', 'z']\n *    values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']\n * @dataFirst\n * @category Object\n */\nexport function values<T extends object>(data: T): Values<T>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @signature\n *    values()(source)\n * @example\n *    pipe(['x', 'y', 'z'], values()) // => ['x', 'y', 'z']\n *    pipe({ a: 'x', b: 'y', c: 'z' }, values()) // => ['x', 'y', 'z']\n *    pipe(\n *      { a: 'x', b: 'y', c: 'z' },\n *      values(),\n *      first(),\n *    ) // => 'x'\n * @dataLast\n * @category Object\n */\nexport function values(): <T extends object>(data: T) => Values<T>;\n\nexport function values(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.values, args);\n}\n"],"mappings":"kGAwCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAOA,EAAAA,MAAM,OAAO,OAAQ,EAAK"}

package/dist/values.js

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

package/dist/values.js.map

@@ -1 +1 @@
-{"version":3,"file":"values.js","names":[],"sources":["../src/values.ts"],"sourcesContent":["import type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Values<T extends object> = T extends IterableContainer\n  ? Array<T[number]>\n  : Array<EnumerableStringKeyedValueOf<T>>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    P.values(source)\n * @example\n *    P.values(['x', 'y', 'z']) // => ['x', 'y', 'z']\n *    P.values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']\n * @dataFirst\n * @category Object\n */\nexport function values<T extends object>(data: T): Values<T>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @signature\n *    P.values()(source)\n * @example\n *    P.pipe(['x', 'y', 'z'], P.values()) // => ['x', 'y', 'z']\n *    P.pipe({ a: 'x', b: 'y', c: 'z' }, P.values()) // => ['x', 'y', 'z']\n *    P.pipe(\n *      { a: 'x', b: 'y', c: 'z' },\n *      P.values(),\n *      P.first(),\n *    ) // => 'x'\n * @dataLast\n * @category Object\n */\nexport function values(): <T extends object>(data: T) => Values<T>;\n\nexport function values(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.values, args);\n}\n"],"mappings":"wCAwCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,OAAO,OAAQ,EAAK"}
+{"version":3,"file":"values.js","names":[],"sources":["../src/values.ts"],"sourcesContent":["import type { EnumerableStringKeyedValueOf } from './internal/types/enumerable-string-keyed-value-of';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\ntype Values<T extends object> = T extends IterableContainer\n  ? Array<T[number]>\n  : Array<EnumerableStringKeyedValueOf<T>>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @param data - Either an array or an object.\n * @signature\n *    values(source)\n * @example\n *    values(['x', 'y', 'z']) // => ['x', 'y', 'z']\n *    values({ a: 'x', b: 'y', c: 'z' }) // => ['x', 'y', 'z']\n * @dataFirst\n * @category Object\n */\nexport function values<T extends object>(data: T): Values<T>;\n\n/**\n * Returns a new array containing the values of the array or object.\n *\n * @signature\n *    values()(source)\n * @example\n *    pipe(['x', 'y', 'z'], values()) // => ['x', 'y', 'z']\n *    pipe({ a: 'x', b: 'y', c: 'z' }, values()) // => ['x', 'y', 'z']\n *    pipe(\n *      { a: 'x', b: 'y', c: 'z' },\n *      values(),\n *      first(),\n *    ) // => 'x'\n * @dataLast\n * @category Object\n */\nexport function values(): <T extends object>(data: T) => Values<T>;\n\nexport function values(...args: ReadonlyArray<unknown>): unknown {\n  return curry(Object.values, args);\n}\n"],"mappings":"mCAwCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,OAAO,OAAQ,EAAK"}

package/dist/when.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(...e){return e.length===2?(n,...r)=>t(n,...e,...r):t(...e)}function t(e,t,n,...r){return t(e,...r)?typeof n==`function`?n(e,...r):n.onTrue(e,...r):typeof n==`function`?e:n.onFalse(e,...r)}exports.when=e;
+//# sourceMappingURL=when.cjs.map

package/dist/when.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"when.cjs","names":[],"sources":["../src/when.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any --\n * function inference is stricter and doesn't work well when the arguments\n * aren't typed as `any` in the generic type declaration.\n */\n\nimport type { GuardType } from './internal/types/guard-type';\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - Function to run when the predicate returns `true`.\n * @signature\n *   when(predicate, onTrue)(data, ...extraArgs)\n *   when(predicate, { onTrue, onFalse })(data, ...extraArgs)\n * @example\n *   pipe(data, when(isNullish, constant(42)));\n *   pipe(data, when((x) => x > 3, { onTrue: add(1), onFalse: multiply(2) }));\n *   map(data, when(isNullish, (x, index) => x + index));\n * @dataLast\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  onTrue: OnTrue,\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => ReturnType<OnFalse> | ReturnType<OnTrue>;\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param data - The data to be passed to all functions, as the first param.\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - The function that would run when the predicate returns\n * `true`.\n * @param extraArgs - Additional arguments. These would be passed as is to the\n * `predicate`, `onTrue`, and `onFalse` functions.\n * @signature\n *   when(data, predicate, onTrue, ...extraArgs)\n *   when(data, predicate, { onTrue, onFalse }, ...extraArgs)\n * @example\n *   when(data, isNullish, constant(42));\n *   when(data, (x) => x > 3, { onTrue: add(1), onFalse: multiply(2) });\n *   when(data, isString, (x, radix) => parseInt(x, radix), 10);\n * @dataFirst\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  onTrue: OnTrue,\n  ...extraArgs: ExtraArgs\n): Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n  ...extraArgs: ExtraArgs\n): ReturnType<OnFalse> | ReturnType<OnTrue>;\n\nexport function when(...args: ReadonlyArray<unknown>): unknown {\n  return args.length === 2\n    ? (data: unknown, ...extraArgs: ReadonlyArray<unknown>) =>\n        // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n        whenImplementation(data, ...args, ...extraArgs)\n    : // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n      whenImplementation(...args);\n}\n\nfunction whenImplementation<T, ExtraArgs extends Array<any>, WhenTrue, WhenFalse>(data: T, predicate: (data: T, ...extraArgs: ExtraArgs) => boolean, onTrueOrBranches:\n    | ((data: T, ...extraArgs: ExtraArgs) => WhenTrue)\n    | {\n      readonly onTrue: (data: T, ...extraArgs: ExtraArgs) => WhenTrue;\n      readonly onFalse: (data: T, ...extraArgs: ExtraArgs) => WhenFalse;\n    }, ...extraArgs: ExtraArgs): T | WhenFalse | WhenTrue {\n  // eslint-disable-next-line no-nested-ternary\n  return predicate(data, ...extraArgs)\n    ? typeof onTrueOrBranches === 'function'\n      ? onTrueOrBranches(data, ...extraArgs)\n      : onTrueOrBranches.onTrue(data, ...extraArgs)\n    : typeof onTrueOrBranches === 'function'\n      ? data\n      : onTrueOrBranches.onFalse(data, ...extraArgs);\n}\n"],"mappings":"mEA6IA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAK,SAAW,GAClB,EAAe,GAAG,IAEjB,EAAmB,EAAM,GAAG,EAAM,GAAG,EAAU,CAEjD,EAAmB,GAAG,EAAK,CAGjC,SAAS,EAAyE,EAAS,EAA0D,EAK9I,GAAG,EAAgD,CAExD,OAAO,EAAU,EAAM,GAAG,EAAU,CAChC,OAAO,GAAqB,WAC1B,EAAiB,EAAM,GAAG,EAAU,CACpC,EAAiB,OAAO,EAAM,GAAG,EAAU,CAC7C,OAAO,GAAqB,WAC1B,EACA,EAAiB,QAAQ,EAAM,GAAG,EAAU"}

package/dist/when.js

@@ -0,0 +1,2 @@
+function e(...e){return e.length===2?(n,...r)=>t(n,...e,...r):t(...e)}function t(e,t,n,...r){return t(e,...r)?typeof n==`function`?n(e,...r):n.onTrue(e,...r):typeof n==`function`?e:n.onFalse(e,...r)}export{e as when};
+//# sourceMappingURL=when.js.map

package/dist/when.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"when.js","names":[],"sources":["../src/when.ts"],"sourcesContent":["/* eslint-disable ts/no-explicit-any --\n * function inference is stricter and doesn't work well when the arguments\n * aren't typed as `any` in the generic type declaration.\n */\n\nimport type { GuardType } from './internal/types/guard-type';\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - Function to run when the predicate returns `true`.\n * @signature\n *   when(predicate, onTrue)(data, ...extraArgs)\n *   when(predicate, { onTrue, onFalse })(data, ...extraArgs)\n * @example\n *   pipe(data, when(isNullish, constant(42)));\n *   pipe(data, when((x) => x > 3, { onTrue: add(1), onFalse: multiply(2) }));\n *   map(data, when(isNullish, (x, index) => x + index));\n * @dataLast\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  onTrue: OnTrue,\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n): (\n  data: T,\n  ...extraArgs: ExtraArgs\n) => ReturnType<OnFalse> | ReturnType<OnTrue>;\n\n/**\n * Conditionally run a function based on a predicate, returning its result (similar to\n * the [`?:` (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator).)\n * If the optional `onFalse` function is not provided, the data will be passed\n * through in those cases.\n *\n * Supports type predicates to refine the types for both branches and the return\n * value.\n *\n * Additional arguments are passed to all functions. In data-first calls, they\n * are taken as variadic arguments; but in data-last calls, they are when the\n * curried function itself is called.\n *\n * For more complex cases check out `conditional`.\n *\n * @param data - The data to be passed to all functions, as the first param.\n * @param predicate - Decides if the `onTrue` mapper should run or not. If it's\n * a type predicate it also narrows types for the mappers and the return value.\n * @param onTrue - The function that would run when the predicate returns\n * `true`.\n * @param extraArgs - Additional arguments. These would be passed as is to the\n * `predicate`, `onTrue`, and `onFalse` functions.\n * @signature\n *   when(data, predicate, onTrue, ...extraArgs)\n *   when(data, predicate, { onTrue, onFalse }, ...extraArgs)\n * @example\n *   when(data, isNullish, constant(42));\n *   when(data, (x) => x > 3, { onTrue: add(1), onFalse: multiply(2) });\n *   when(data, isString, (x, radix) => parseInt(x, radix), 10);\n * @dataFirst\n * @category Function\n */\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  onTrue: OnTrue,\n  ...extraArgs: ExtraArgs\n): Exclude<T, GuardType<Predicate>> | ReturnType<OnTrue>;\nexport function when<\n  T,\n  ExtraArgs extends Array<any>,\n  Predicate extends (data: T, ...extraArgs: ExtraArgs) => boolean,\n  OnTrue extends (\n    data: GuardType<Predicate, T>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n  OnFalse extends (\n    data: Exclude<T, GuardType<Predicate>>,\n    ...extraArgs: ExtraArgs\n  ) => unknown,\n>(\n  data: T,\n  predicate: Predicate,\n  branches: {\n    readonly onTrue: OnTrue;\n    readonly onFalse: OnFalse;\n  },\n  ...extraArgs: ExtraArgs\n): ReturnType<OnFalse> | ReturnType<OnTrue>;\n\nexport function when(...args: ReadonlyArray<unknown>): unknown {\n  return args.length === 2\n    ? (data: unknown, ...extraArgs: ReadonlyArray<unknown>) =>\n        // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n        whenImplementation(data, ...args, ...extraArgs)\n    : // @ts-expect-error [ts2556] -- This is OK, we trust our typing of the overloaded functions\n      whenImplementation(...args);\n}\n\nfunction whenImplementation<T, ExtraArgs extends Array<any>, WhenTrue, WhenFalse>(data: T, predicate: (data: T, ...extraArgs: ExtraArgs) => boolean, onTrueOrBranches:\n    | ((data: T, ...extraArgs: ExtraArgs) => WhenTrue)\n    | {\n      readonly onTrue: (data: T, ...extraArgs: ExtraArgs) => WhenTrue;\n      readonly onFalse: (data: T, ...extraArgs: ExtraArgs) => WhenFalse;\n    }, ...extraArgs: ExtraArgs): T | WhenFalse | WhenTrue {\n  // eslint-disable-next-line no-nested-ternary\n  return predicate(data, ...extraArgs)\n    ? typeof onTrueOrBranches === 'function'\n      ? onTrueOrBranches(data, ...extraArgs)\n      : onTrueOrBranches.onTrue(data, ...extraArgs)\n    : typeof onTrueOrBranches === 'function'\n      ? data\n      : onTrueOrBranches.onFalse(data, ...extraArgs);\n}\n"],"mappings":"AA6IA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAK,SAAW,GAClB,EAAe,GAAG,IAEjB,EAAmB,EAAM,GAAG,EAAM,GAAG,EAAU,CAEjD,EAAmB,GAAG,EAAK,CAGjC,SAAS,EAAyE,EAAS,EAA0D,EAK9I,GAAG,EAAgD,CAExD,OAAO,EAAU,EAAM,GAAG,EAAU,CAChC,OAAO,GAAqB,WAC1B,EAAiB,EAAM,GAAG,EAAU,CACpC,EAAiB,OAAO,EAAM,GAAG,EAAU,CAC7C,OAAO,GAAqB,WAC1B,EACA,EAAiB,QAAQ,EAAM,GAAG,EAAU"}

package/dist/with-precision-CgRuf7Wl.js

@@ -0,0 +1,2 @@
+function e(e){return(n,r)=>{if(r===0)return e(n);if(!Number.isInteger(r))throw TypeError(`precision must be an integer: ${r.toString()}`);if(r>15||r<-15)throw RangeError(`precision must be between -15 and 15`);return Number.isNaN(n)||!Number.isFinite(n)?e(n):t(e(t(n,r)),-r)}}function t(e,t){let[n,r]=e.toString().split(`e`),i=`${n}e${((r===void 0?0:Number.parseInt(r,10))+t).toString()}`;return Number.parseFloat(i)}export{e as t};
+//# sourceMappingURL=with-precision-CgRuf7Wl.js.map

package/dist/with-precision-CgRuf7Wl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-precision-CgRuf7Wl.js","names":[],"sources":["../src/internal/with-precision.ts"],"sourcesContent":["// ECMAScript doesn't support more decimal places than 15 anyways,\n// so supporting higher values doesn't make a lot of sense,\n// Considering Number.MAX_SAFE_INTEGER < 10**16, we can use -15\n// for the negative precision limit, too.\nconst MAX_PRECISION = 15;\n\nconst RADIX = 10;\n\nexport function withPrecision(roundingFn: (value: number) => number) {\n  return (value: number, precision: number): number => {\n    if (precision === 0) {\n      return roundingFn(value);\n    }\n\n    if (!Number.isInteger(precision)) {\n      throw new TypeError(\n        `precision must be an integer: ${precision.toString()}`,\n      );\n    }\n\n    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {\n      throw new RangeError('precision must be between -15 and 15');\n    }\n\n    if (Number.isNaN(value) || !Number.isFinite(value)) {\n      return roundingFn(value);\n    }\n\n    const shiftedValue = shiftDecimalPoint(value, precision);\n    const rounded = roundingFn(shiftedValue);\n    return shiftDecimalPoint(rounded, -precision);\n  };\n}\n\n/**\n * Shift a number's decimal point via scientific notation.\n *\n * This takes advantage of the fact that `Number` methods support scientific\n * (e-notation) string natively and avoids working with double-precision\n * floating-point numbers directly, working around their limitations\n * with representing decimal numbers.\n */\nfunction shiftDecimalPoint(value: number, shift: number): number {\n  const asString = value.toString();\n  const [n, exponent] = asString.split('e');\n\n  const shiftedExponent\n    = (exponent === undefined ? 0 : Number.parseInt(exponent, RADIX)) + shift;\n\n  const shiftedValueAsString = `${n!}e${shiftedExponent.toString()}`;\n\n  return Number.parseFloat(shiftedValueAsString);\n}\n"],"mappings":"AAQA,SAAgB,EAAc,EAAuC,CACnE,OAAQ,EAAe,IAA8B,CACnD,GAAI,IAAc,EAChB,OAAO,EAAW,EAAM,CAG1B,GAAI,CAAC,OAAO,UAAU,EAAU,CAC9B,MAAU,UACR,iCAAiC,EAAU,UAAU,GACtD,CAGH,GAAI,EAAY,IAAiB,EAAY,IAC3C,MAAU,WAAW,uCAAuC,CAS9D,OANI,OAAO,MAAM,EAAM,EAAI,CAAC,OAAO,SAAS,EAAM,CACzC,EAAW,EAAM,CAKnB,EADS,EADK,EAAkB,EAAO,EAAU,CAChB,CACN,CAAC,EAAU,EAYjD,SAAS,EAAkB,EAAe,EAAuB,CAE/D,GAAM,CAAC,EAAG,GADO,EAAM,UAAU,CACF,MAAM,IAAI,CAKnC,EAAuB,GAAG,EAAG,KAF9B,IAAa,IAAA,GAAY,EAAI,OAAO,SAAS,EAAU,GAAM,EAAI,GAEhB,UAAU,GAEhE,OAAO,OAAO,WAAW,EAAqB"}

package/dist/with-precision-DVi9325n.cjs

@@ -0,0 +1,2 @@
+function e(e){return(n,r)=>{if(r===0)return e(n);if(!Number.isInteger(r))throw TypeError(`precision must be an integer: ${r.toString()}`);if(r>15||r<-15)throw RangeError(`precision must be between -15 and 15`);return Number.isNaN(n)||!Number.isFinite(n)?e(n):t(e(t(n,r)),-r)}}function t(e,t){let[n,r]=e.toString().split(`e`),i=`${n}e${((r===void 0?0:Number.parseInt(r,10))+t).toString()}`;return Number.parseFloat(i)}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});
+//# sourceMappingURL=with-precision-DVi9325n.cjs.map

package/dist/with-precision-DVi9325n.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-precision-DVi9325n.cjs","names":[],"sources":["../src/internal/with-precision.ts"],"sourcesContent":["// ECMAScript doesn't support more decimal places than 15 anyways,\n// so supporting higher values doesn't make a lot of sense,\n// Considering Number.MAX_SAFE_INTEGER < 10**16, we can use -15\n// for the negative precision limit, too.\nconst MAX_PRECISION = 15;\n\nconst RADIX = 10;\n\nexport function withPrecision(roundingFn: (value: number) => number) {\n  return (value: number, precision: number): number => {\n    if (precision === 0) {\n      return roundingFn(value);\n    }\n\n    if (!Number.isInteger(precision)) {\n      throw new TypeError(\n        `precision must be an integer: ${precision.toString()}`,\n      );\n    }\n\n    if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {\n      throw new RangeError('precision must be between -15 and 15');\n    }\n\n    if (Number.isNaN(value) || !Number.isFinite(value)) {\n      return roundingFn(value);\n    }\n\n    const shiftedValue = shiftDecimalPoint(value, precision);\n    const rounded = roundingFn(shiftedValue);\n    return shiftDecimalPoint(rounded, -precision);\n  };\n}\n\n/**\n * Shift a number's decimal point via scientific notation.\n *\n * This takes advantage of the fact that `Number` methods support scientific\n * (e-notation) string natively and avoids working with double-precision\n * floating-point numbers directly, working around their limitations\n * with representing decimal numbers.\n */\nfunction shiftDecimalPoint(value: number, shift: number): number {\n  const asString = value.toString();\n  const [n, exponent] = asString.split('e');\n\n  const shiftedExponent\n    = (exponent === undefined ? 0 : Number.parseInt(exponent, RADIX)) + shift;\n\n  const shiftedValueAsString = `${n!}e${shiftedExponent.toString()}`;\n\n  return Number.parseFloat(shiftedValueAsString);\n}\n"],"mappings":"AAQA,SAAgB,EAAc,EAAuC,CACnE,OAAQ,EAAe,IAA8B,CACnD,GAAI,IAAc,EAChB,OAAO,EAAW,EAAM,CAG1B,GAAI,CAAC,OAAO,UAAU,EAAU,CAC9B,MAAU,UACR,iCAAiC,EAAU,UAAU,GACtD,CAGH,GAAI,EAAY,IAAiB,EAAY,IAC3C,MAAU,WAAW,uCAAuC,CAS9D,OANI,OAAO,MAAM,EAAM,EAAI,CAAC,OAAO,SAAS,EAAM,CACzC,EAAW,EAAM,CAKnB,EADS,EADK,EAAkB,EAAO,EAAU,CAChB,CACN,CAAC,EAAU,EAYjD,SAAS,EAAkB,EAAe,EAAuB,CAE/D,GAAM,CAAC,EAAG,GADO,EAAM,UAAU,CACF,MAAM,IAAI,CAKnC,EAAuB,GAAG,EAAG,KAF9B,IAAa,IAAA,GAAY,EAAI,OAAO,SAAS,EAAU,GAAM,EAAI,GAEhB,UAAU,GAEhE,OAAO,OAAO,WAAW,EAAqB"}

package/dist/words-C8Rd_80F.cjs

@@ -0,0 +1,3 @@
+const e=new Set([`-`,`_`,...`	.
+.\v.\f.\r. .….\xA0. . . . . . . . . . . . .\u2028.\u2029. . .　.`.split(`.`)]);function t(t){let n=[],r=``,i=()=>{r.length>0&&(n.push(r),r=``)};for(let n of t){if(e.has(n)){i();continue}if(/[a-z]$/u.test(r)&&/[A-Z]/u.test(n))i();else if(/[A-Z][A-Z]$/u.test(r)&&/[a-z]/u.test(n)){let e=r.slice(-1);r=r.slice(0,-1),i(),r=e}else /\d$/u.test(r)!==/\d/u.test(n)&&i();r+=n}return i(),n}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=words-C8Rd_80F.cjs.map

package/dist/words-C8Rd_80F.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"words-C8Rd_80F.cjs","names":[],"sources":["../src/internal/words.ts"],"sourcesContent":["import type { Words } from 'type-fest';\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L5-L31\nconst WHITESPACE = [\n  '\\u{9}', // '\\t'\n  '\\u{A}', // '\\n'\n  '\\u{B}', // '\\v'\n  '\\u{C}', // '\\f'\n  '\\u{D}', // '\\r'\n  '\\u{20}', // ' '\n  '\\u{85}',\n  '\\u{A0}',\n  '\\u{1680}',\n  '\\u{2000}',\n  '\\u{2001}',\n  '\\u{2002}',\n  '\\u{2003}',\n  '\\u{2004}',\n  '\\u{2005}',\n  '\\u{2006}',\n  '\\u{2007}',\n  '\\u{2008}',\n  '\\u{2009}',\n  '\\u{200A}',\n  '\\u{2028}',\n  '\\u{2029}',\n  '\\u{202F}',\n  '\\u{205F}',\n  '\\u{3000}',\n  '\\u{FEFF}',\n] as const;\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L33\nconst WORD_SEPARATORS = new Set(['-', '_', ...WHITESPACE]);\n\nexport function words<S extends string>(data: S): string extends S ? Array<string> : Words<S> {\n  const results: Array<string> = [];\n  let word = '';\n\n  const flush = (): void => {\n    if (word.length > 0) {\n      results.push(word);\n      word = '';\n    }\n  };\n\n  for (const character of data) {\n    if (WORD_SEPARATORS.has(character)) {\n      // Separator encountered; flush the current word & exclude the separator.\n      flush();\n      continue;\n    }\n\n    // Detect transitions:\n    // 1. Lowercase to uppercase (e.g., \"helloWorld\")\n    if (/[a-z]$/u.test(word) && /[A-Z]/u.test(character)) {\n      flush();\n    } else if (/[A-Z][A-Z]$/u.test(word) && /[a-z]/u.test(character)) {\n      // 2. Uppercase to lowercase following multiple uppercase letters (e.g., \"HELLOWorld\")\n      // When the text transitions from 2 upper case letters to a lower case\n      // letter. (one upper case letter is considered part of the word, e.g.\n      // \"Dog\").\n      const lastCharacter = word.slice(-1);\n      word = word.slice(0, -1);\n      flush();\n      word = lastCharacter;\n    } else if (/\\d$/u.test(word) !== /\\d/u.test(character)) {\n      // 3. Digit to non-digit or non-digit to digit (e.g., \"123abc\" or \"abc123\")\n      flush();\n    }\n\n    // Add the current character to the current word.\n    word += character;\n  }\n\n  // Flush any remaining word.\n  flush();\n\n  // @ts-expect-error [ts2322] -- TypeScript can't infer this type...\n  return results;\n}\n"],"mappings":"AAiCA,MAAM,EAAkB,IAAI,IAAI,CAAC,IAAK,IAAK,GA9BxB;4EA2BlB,CAGwD,CAAC,CAE1D,SAAgB,EAAwB,EAAsD,CAC5F,IAAM,EAAyB,EAAE,CAC7B,EAAO,GAEL,MAAoB,CACpB,EAAK,OAAS,IAChB,EAAQ,KAAK,EAAK,CAClB,EAAO,KAIX,IAAK,IAAM,KAAa,EAAM,CAC5B,GAAI,EAAgB,IAAI,EAAU,CAAE,CAElC,GAAO,CACP,SAKF,GAAI,UAAU,KAAK,EAAK,EAAI,SAAS,KAAK,EAAU,CAClD,GAAO,SACE,eAAe,KAAK,EAAK,EAAI,SAAS,KAAK,EAAU,CAAE,CAKhE,IAAM,EAAgB,EAAK,MAAM,GAAG,CACpC,EAAO,EAAK,MAAM,EAAG,GAAG,CACxB,GAAO,CACP,EAAO,OACE,OAAO,KAAK,EAAK,GAAK,MAAM,KAAK,EAAU,EAEpD,GAAO,CAIT,GAAQ,EAOV,OAHA,GAAO,CAGA"}

package/dist/words-CYZ0Lyko.js

@@ -0,0 +1,3 @@
+const e=new Set([`-`,`_`,...`	.
+.\v.\f.\r. .….\xA0. . . . . . . . . . . . .\u2028.\u2029. . .　.`.split(`.`)]);function t(t){let n=[],r=``,i=()=>{r.length>0&&(n.push(r),r=``)};for(let n of t){if(e.has(n)){i();continue}if(/[a-z]$/u.test(r)&&/[A-Z]/u.test(n))i();else if(/[A-Z][A-Z]$/u.test(r)&&/[a-z]/u.test(n)){let e=r.slice(-1);r=r.slice(0,-1),i(),r=e}else /\d$/u.test(r)!==/\d/u.test(n)&&i();r+=n}return i(),n}export{t};
+//# sourceMappingURL=words-CYZ0Lyko.js.map

package/dist/words-CYZ0Lyko.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"words-CYZ0Lyko.js","names":[],"sources":["../src/internal/words.ts"],"sourcesContent":["import type { Words } from 'type-fest';\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L5-L31\nconst WHITESPACE = [\n  '\\u{9}', // '\\t'\n  '\\u{A}', // '\\n'\n  '\\u{B}', // '\\v'\n  '\\u{C}', // '\\f'\n  '\\u{D}', // '\\r'\n  '\\u{20}', // ' '\n  '\\u{85}',\n  '\\u{A0}',\n  '\\u{1680}',\n  '\\u{2000}',\n  '\\u{2001}',\n  '\\u{2002}',\n  '\\u{2003}',\n  '\\u{2004}',\n  '\\u{2005}',\n  '\\u{2006}',\n  '\\u{2007}',\n  '\\u{2008}',\n  '\\u{2009}',\n  '\\u{200A}',\n  '\\u{2028}',\n  '\\u{2029}',\n  '\\u{202F}',\n  '\\u{205F}',\n  '\\u{3000}',\n  '\\u{FEFF}',\n] as const;\n\n// @see https://github.com/sindresorhus/type-fest/blob/main/source/internal/characters.d.ts#L33\nconst WORD_SEPARATORS = new Set(['-', '_', ...WHITESPACE]);\n\nexport function words<S extends string>(data: S): string extends S ? Array<string> : Words<S> {\n  const results: Array<string> = [];\n  let word = '';\n\n  const flush = (): void => {\n    if (word.length > 0) {\n      results.push(word);\n      word = '';\n    }\n  };\n\n  for (const character of data) {\n    if (WORD_SEPARATORS.has(character)) {\n      // Separator encountered; flush the current word & exclude the separator.\n      flush();\n      continue;\n    }\n\n    // Detect transitions:\n    // 1. Lowercase to uppercase (e.g., \"helloWorld\")\n    if (/[a-z]$/u.test(word) && /[A-Z]/u.test(character)) {\n      flush();\n    } else if (/[A-Z][A-Z]$/u.test(word) && /[a-z]/u.test(character)) {\n      // 2. Uppercase to lowercase following multiple uppercase letters (e.g., \"HELLOWorld\")\n      // When the text transitions from 2 upper case letters to a lower case\n      // letter. (one upper case letter is considered part of the word, e.g.\n      // \"Dog\").\n      const lastCharacter = word.slice(-1);\n      word = word.slice(0, -1);\n      flush();\n      word = lastCharacter;\n    } else if (/\\d$/u.test(word) !== /\\d/u.test(character)) {\n      // 3. Digit to non-digit or non-digit to digit (e.g., \"123abc\" or \"abc123\")\n      flush();\n    }\n\n    // Add the current character to the current word.\n    word += character;\n  }\n\n  // Flush any remaining word.\n  flush();\n\n  // @ts-expect-error [ts2322] -- TypeScript can't infer this type...\n  return results;\n}\n"],"mappings":"AAiCA,MAAM,EAAkB,IAAI,IAAI,CAAC,IAAK,IAAK,GA9BxB;4EA2BlB,CAGwD,CAAC,CAE1D,SAAgB,EAAwB,EAAsD,CAC5F,IAAM,EAAyB,EAAE,CAC7B,EAAO,GAEL,MAAoB,CACpB,EAAK,OAAS,IAChB,EAAQ,KAAK,EAAK,CAClB,EAAO,KAIX,IAAK,IAAM,KAAa,EAAM,CAC5B,GAAI,EAAgB,IAAI,EAAU,CAAE,CAElC,GAAO,CACP,SAKF,GAAI,UAAU,KAAK,EAAK,EAAI,SAAS,KAAK,EAAU,CAClD,GAAO,SACE,eAAe,KAAK,EAAK,EAAI,SAAS,KAAK,EAAU,CAAE,CAKhE,IAAM,EAAgB,EAAK,MAAM,GAAG,CACpC,EAAO,EAAK,MAAM,EAAG,GAAG,CACxB,GAAO,CACP,EAAO,OACE,OAAO,KAAK,EAAK,GAAK,MAAM,KAAK,EAAU,EAEpD,GAAO,CAIT,GAAQ,EAOV,OAHA,GAAO,CAGA"}

package/dist/zip-with.cjs

@@ -1 +1,2 @@
-const e=require(`./lazy-data-last-impl-D4kLybyP.cjs`);function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e.t(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}exports.zipWith=t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./lazy-data-last-impl-B05ZpguF.cjs`);function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e.t(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}exports.zipWith=t;
+//# sourceMappingURL=zip-with.cjs.map

package/dist/zip-with.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-with.cjs","names":["lazyDataLastImpl"],"sources":["../src/zip-with.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\ntype ZippingFunction<\n  T1 extends IterableContainer = IterableContainer,\n  T2 extends IterableContainer = IterableContainer,\n  Value = unknown,\n> = (\n  first: T1[number],\n  second: T2[number],\n  index: number,\n  data: readonly [first: T1, second: T2],\n) => Value;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(fn)(first, second)\n * @example\n *   zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']\n * @category Array\n */\nexport function zipWith<TItem1, TItem2, Value>(\n  fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>,\n): (first: ReadonlyArray<TItem1>, second: ReadonlyArray<TItem2>) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(second, fn)(first)\n * @example\n *   pipe(['1', '2', '3'], zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(first, second, fn)\n * @example\n *   zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;\n\nexport function zipWith(\n  arg0: IterableContainer | ZippingFunction,\n  arg1?: IterableContainer | ZippingFunction,\n  arg2?: ZippingFunction,\n): unknown {\n  if (typeof arg0 === 'function') {\n    // Both datum's last\n    return (data1: IterableContainer, data2: IterableContainer) =>\n      zipWithImplementation(data1, data2, arg0);\n  }\n\n  if (typeof arg1 === 'function') {\n    // dataLast\n    return lazyDataLastImpl(\n      zipWithImplementation,\n      [arg0, arg1],\n      lazyImplementation,\n    );\n  }\n\n  // dataFirst. Notice that we assert that the arguments are defined to reduce\n  // the number of runtime checks that would otherwise be needed to make\n  // TypeScript happy here. Because this is an internal implementation and we\n  // are protected by the function typing itself this is fine!\n  return zipWithImplementation(arg0, arg1!, arg2!);\n}\n\nfunction zipWithImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value> {\n  const datum = [first, second] as const;\n  return first.length < second.length\n    ? first.map((item, index) => fn(item, second[index], index, datum))\n    : second.map((item, index) => fn(first[index], item, index, datum));\n}\n\nfunction lazyImplementation<T1, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<ReadonlyArray<T1>, T2, Value>): LazyEvaluator<T1, Value> {\n  return (value, index, data) => ({\n    next: fn(value, second[index], index, [data, second]),\n    hasNext: true,\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"yHAuEA,SAAgB,EACd,EACA,EACA,EACS,CAoBT,OAnBI,OAAO,GAAS,YAEV,EAA0B,IAChC,EAAsB,EAAO,EAAO,EAAK,CAGzC,OAAO,GAAS,WAEXA,EAAAA,EACL,EACA,CAAC,EAAM,EAAK,CACZ,EACD,CAOI,EAAsB,EAAM,EAAO,EAAM,CAGlD,SAAS,EAIP,EAAW,EAAY,EAAkD,CACzE,IAAM,EAAQ,CAAC,EAAO,EAAO,CAC7B,OAAO,EAAM,OAAS,EAAO,OACzB,EAAM,KAAK,EAAM,IAAU,EAAG,EAAM,EAAO,GAAQ,EAAO,EAAM,CAAC,CACjE,EAAO,KAAK,EAAM,IAAU,EAAG,EAAM,GAAQ,EAAM,EAAO,EAAM,CAAC,CAGvE,SAAS,EAA4D,EAAY,EAA6E,CAC5J,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,EAAG,EAAO,EAAO,GAAQ,EAAO,CAAC,EAAM,EAAO,CAAC,CACrD,QAAS,GACT,KAAM,GAAS,EAAO,OAAS,EAChC"}

package/dist/zip-with.js

@@ -1,2 +1,2 @@
-import{t as e}from"./lazy-data-last-impl-R05wr4K6.js";function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}export{t as zipWith};
+import{t as e}from"./lazy-data-last-impl-Vt_M0l7X.js";function t(t,i,a){return typeof t==`function`?(e,r)=>n(e,r,t):typeof i==`function`?e(n,[t,i],r):n(t,i,a)}function n(e,t,n){let r=[e,t];return e.length<t.length?e.map((e,i)=>n(e,t[i],i,r)):t.map((t,i)=>n(e[i],t,i,r))}function r(e,t){return(n,r,i)=>({next:t(n,e[r],r,[i,e]),hasNext:!0,done:r>=e.length-1})}export{t as zipWith};
 //# sourceMappingURL=zip-with.js.map

package/dist/zip-with.js.map

@@ -1 +1 @@
-{"version":3,"file":"zip-with.js","names":[],"sources":["../src/zip-with.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\ntype ZippingFunction<\n  T1 extends IterableContainer = IterableContainer,\n  T2 extends IterableContainer = IterableContainer,\n  Value = unknown,\n> = (\n  first: T1[number],\n  second: T2[number],\n  index: number,\n  data: readonly [first: T1, second: T2],\n) => Value;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param fn - The function applied to each position of the list.\n * @signature\n *   P.zipWith(fn)(first, second)\n * @example\n *   P.zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']\n * @category Array\n */\nexport function zipWith<TItem1, TItem2, Value>(\n  fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>,\n): <T1 extends IterableContainer<TItem1>, T2 extends IterableContainer<TItem2>>(\n  first: T1,\n  second: T2,\n) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   P.zipWith(second, fn)(first)\n * @example\n *   P.pipe(['1', '2', '3'], P.zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   P.zipWith(first, second, fn)\n * @example\n *   P.zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;\n\nexport function zipWith(\n  arg0: IterableContainer | ZippingFunction,\n  arg1?: IterableContainer | ZippingFunction,\n  arg2?: ZippingFunction,\n): unknown {\n  if (typeof arg0 === 'function') {\n    // Both datum's last\n    return (data1: IterableContainer, data2: IterableContainer) =>\n      zipWithImplementation(data1, data2, arg0);\n  }\n\n  if (typeof arg1 === 'function') {\n    // dataLast\n    return lazyDataLastImpl(\n      zipWithImplementation,\n      [arg0, arg1],\n      lazyImplementation,\n    );\n  }\n\n  // dataFirst. Notice that we assert that the arguments are defined to reduce\n  // the number of runtime checks that would otherwise be needed to make\n  // TypeScript happy here. Because this is an internal implementation and we\n  // are protected by the function typing itself this is fine!\n  return zipWithImplementation(arg0, arg1!, arg2!);\n}\n\nfunction zipWithImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value> {\n  const datum = [first, second] as const;\n  return first.length < second.length\n    ? first.map((item, index) => fn(item, second[index], index, datum))\n    : second.map((item, index) => fn(first[index], item, index, datum));\n}\n\nfunction lazyImplementation<T1, T2 extends IterableContainer, Value>(\n  second: T2,\n  fn: ZippingFunction<ReadonlyArray<T1>, T2, Value>,\n): LazyEvaluator<T1, Value> {\n  return (value, index, data) => ({\n    next: fn(value, second[index], index, [data, second]),\n    hasNext: true,\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"sDA0EA,SAAgB,EACd,EACA,EACA,EACS,CAoBT,OAnBI,OAAO,GAAS,YAEV,EAA0B,IAChC,EAAsB,EAAO,EAAO,EAAK,CAGzC,OAAO,GAAS,WAEX,EACL,EACA,CAAC,EAAM,EAAK,CACZ,EACD,CAOI,EAAsB,EAAM,EAAO,EAAM,CAGlD,SAAS,EAIP,EAAW,EAAY,EAAkD,CACzE,IAAM,EAAQ,CAAC,EAAO,EAAO,CAC7B,OAAO,EAAM,OAAS,EAAO,OACzB,EAAM,KAAK,EAAM,IAAU,EAAG,EAAM,EAAO,GAAQ,EAAO,EAAM,CAAC,CACjE,EAAO,KAAK,EAAM,IAAU,EAAG,EAAM,GAAQ,EAAM,EAAO,EAAM,CAAC,CAGvE,SAAS,EACP,EACA,EAC0B,CAC1B,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,EAAG,EAAO,EAAO,GAAQ,EAAO,CAAC,EAAM,EAAO,CAAC,CACrD,QAAS,GACT,KAAM,GAAS,EAAO,OAAS,EAChC"}
+{"version":3,"file":"zip-with.js","names":[],"sources":["../src/zip-with.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { lazyDataLastImpl } from './internal/lazy-data-last-impl';\n\ntype ZippingFunction<\n  T1 extends IterableContainer = IterableContainer,\n  T2 extends IterableContainer = IterableContainer,\n  Value = unknown,\n> = (\n  first: T1[number],\n  second: T2[number],\n  index: number,\n  data: readonly [first: T1, second: T2],\n) => Value;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(fn)(first, second)\n * @example\n *   zipWith((a: string, b: string) => a + b)(['1', '2', '3'], ['a', 'b', 'c']) // => ['1a', '2b', '3c']\n * @category Array\n */\nexport function zipWith<TItem1, TItem2, Value>(\n  fn: ZippingFunction<ReadonlyArray<TItem1>, ReadonlyArray<TItem2>, Value>,\n): (first: ReadonlyArray<TItem1>, second: ReadonlyArray<TItem2>) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(second, fn)(first)\n * @example\n *   pipe(['1', '2', '3'], zipWith(['a', 'b', 'c'], (a, b) => a + b)) // => ['1a', '2b', '3c']\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(second: T2, fn: ZippingFunction<T1, T2, Value>): (first: T1) => Array<Value>;\n\n/**\n * Creates a new list from two supplied lists by calling the supplied function\n * with the same-positioned element from each list.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @param fn - The function applied to each position of the list.\n * @signature\n *   zipWith(first, second, fn)\n * @example\n *   zipWith(['1', '2', '3'], ['a', 'b', 'c'], (a, b) => a + b) // => ['1a', '2b', '3c']\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zipWith<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value>;\n\nexport function zipWith(\n  arg0: IterableContainer | ZippingFunction,\n  arg1?: IterableContainer | ZippingFunction,\n  arg2?: ZippingFunction,\n): unknown {\n  if (typeof arg0 === 'function') {\n    // Both datum's last\n    return (data1: IterableContainer, data2: IterableContainer) =>\n      zipWithImplementation(data1, data2, arg0);\n  }\n\n  if (typeof arg1 === 'function') {\n    // dataLast\n    return lazyDataLastImpl(\n      zipWithImplementation,\n      [arg0, arg1],\n      lazyImplementation,\n    );\n  }\n\n  // dataFirst. Notice that we assert that the arguments are defined to reduce\n  // the number of runtime checks that would otherwise be needed to make\n  // TypeScript happy here. Because this is an internal implementation and we\n  // are protected by the function typing itself this is fine!\n  return zipWithImplementation(arg0, arg1!, arg2!);\n}\n\nfunction zipWithImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n  Value,\n>(first: T1, second: T2, fn: ZippingFunction<T1, T2, Value>): Array<Value> {\n  const datum = [first, second] as const;\n  return first.length < second.length\n    ? first.map((item, index) => fn(item, second[index], index, datum))\n    : second.map((item, index) => fn(first[index], item, index, datum));\n}\n\nfunction lazyImplementation<T1, T2 extends IterableContainer, Value>(second: T2, fn: ZippingFunction<ReadonlyArray<T1>, T2, Value>): LazyEvaluator<T1, Value> {\n  return (value, index, data) => ({\n    next: fn(value, second[index], index, [data, second]),\n    hasNext: true,\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"sDAuEA,SAAgB,EACd,EACA,EACA,EACS,CAoBT,OAnBI,OAAO,GAAS,YAEV,EAA0B,IAChC,EAAsB,EAAO,EAAO,EAAK,CAGzC,OAAO,GAAS,WAEX,EACL,EACA,CAAC,EAAM,EAAK,CACZ,EACD,CAOI,EAAsB,EAAM,EAAO,EAAM,CAGlD,SAAS,EAIP,EAAW,EAAY,EAAkD,CACzE,IAAM,EAAQ,CAAC,EAAO,EAAO,CAC7B,OAAO,EAAM,OAAS,EAAO,OACzB,EAAM,KAAK,EAAM,IAAU,EAAG,EAAM,EAAO,GAAQ,EAAO,EAAM,CAAC,CACjE,EAAO,KAAK,EAAM,IAAU,EAAG,EAAM,GAAQ,EAAM,EAAO,EAAM,CAAC,CAGvE,SAAS,EAA4D,EAAY,EAA6E,CAC5J,OAAQ,EAAO,EAAO,KAAU,CAC9B,KAAM,EAAG,EAAO,EAAO,GAAQ,EAAO,CAAC,EAAM,EAAO,CAAC,CACrD,QAAS,GACT,KAAM,GAAS,EAAO,OAAS,EAChC"}

package/dist/zip.cjs

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

package/dist/zip.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.cjs","names":["curry"],"sources":["../src/zip.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\ntype Zipped<Left extends IterableContainer, Right extends IterableContainer>\n  // If the array is empty the output is empty, no surprises\n  = Left extends readonly []\n    ? []\n    : Right extends readonly []\n      ? []\n      : // Are the two inputs both tuples with a non-rest first item?\n      Left extends readonly [infer LeftHead, ...infer LeftRest]\n        ? Right extends readonly [infer RightHead, ...infer RightRest]\n          ? // ...Then take that first item from both and recurse\n            [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>]\n          : // Is only one of the inputs a tuple (with a non-rest first item)?\n            // Then take that item, and match it with whatever the type of the other *array's* items are.\n            [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>]\n        : Right extends readonly [infer RightHead, ...infer RightRest]\n          ? [[Left[number], RightHead], ...Zipped<Left, RightRest>]\n          : // Both inputs are not tuples (with a non-rest first item, they might be tuples with non-rest last item(s))\n        // So the output is just the \"trivial\" zip result.\n          Array<[Left[number], Right[number]]>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @signature\n *   zip(first, second)\n * @example\n *   zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zip<F extends IterableContainer, S extends IterableContainer>(\n  first: F,\n  second: S,\n): Zipped<F, S>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param second - The second input list.\n * @signature\n *   zip(second)(first)\n * @example\n *   zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zip<S extends IterableContainer>(\n  second: S,\n): <F extends IterableContainer>(first: F) => Zipped<F, S>;\n\nexport function zip(...args: ReadonlyArray<unknown>): unknown {\n  return curry(zipImplementation, args, lazyImplementation);\n}\n\nfunction zipImplementation<\n  F extends IterableContainer,\n  S extends IterableContainer,\n>(first: F, second: S): Zipped<F, S> {\n  return (first.length < second.length\n    ? first.map((item, index) => [item, second[index]])\n    : second.map((item, index) => [first[index], item])) as Zipped<F, S>;\n}\n\nfunction lazyImplementation<F extends IterableContainer, S extends IterableContainer>(second: S): LazyEvaluator<F[number], [F[number], S[number]]> {\n  return (value, index) => ({\n    hasNext: true,\n    next: [value, second[index]],\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"kGA8DA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAOA,EAAAA,MAAM,EAAmB,EAAM,EAAmB,CAG3D,SAAS,EAGP,EAAU,EAAyB,CACnC,OAAQ,EAAM,OAAS,EAAO,OAC1B,EAAM,KAAK,EAAM,IAAU,CAAC,EAAM,EAAO,GAAO,CAAC,CACjD,EAAO,KAAK,EAAM,IAAU,CAAC,EAAM,GAAQ,EAAK,CAAC,CAGvD,SAAS,EAA6E,EAA6D,CACjJ,OAAQ,EAAO,KAAW,CACxB,QAAS,GACT,KAAM,CAAC,EAAO,EAAO,GAAO,CAC5B,KAAM,GAAS,EAAO,OAAS,EAChC"}

package/dist/zip.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t,r)}function n(e,t){return e.length<t.length?e.map((e,n)=>[e,t[n]]):t.map((t,n)=>[e[n],t])}function r(e){return(t,n)=>({done:n>=e.length-1,hasNext:!0,next:[t,e[n]]})}export{t as zip};
+import{curry as e}from"./curry.js";function t(...t){return e(n,t,r)}function n(e,t){return e.length<t.length?e.map((e,n)=>[e,t[n]]):t.map((t,n)=>[e[n],t])}function r(e){return(t,n)=>({hasNext:!0,next:[t,e[n]],done:n>=e.length-1})}export{t as zip};
 //# sourceMappingURL=zip.js.map

package/dist/zip.js.map

@@ -1 +1 @@
-{"version":3,"file":"zip.js","names":[],"sources":["../src/zip.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curry } from './curry';\n\ntype Zipped<Left extends IterableContainer, Right extends IterableContainer>\n  // If the array is empty the output is empty, no surprises\n  = Left extends readonly []\n    ? []\n    : Right extends readonly []\n      ? []\n      : // Are the two inputs both tuples with a non-rest first item?\n      Left extends readonly [infer LeftHead, ...infer LeftRest]\n        ? Right extends readonly [infer RightHead, ...infer RightRest]\n          ? // ...Then take that first item from both and recurse\n            [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>]\n          : // Is only one of the inputs a tuple (with a non-rest first item)?\n            // Then take that item, and match it with whatever the type of the other *array's* items are.\n            [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>]\n        : Right extends readonly [infer RightHead, ...infer RightRest]\n          ? [[Left[number], RightHead], ...Zipped<Left, RightRest>]\n          : // Both inputs are not tuples (with a non-rest first item, they might be tuples with non-rest last item(s))\n        // So the output is just the \"trivial\" zip result.\n          Array<[Left[number], Right[number]]>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @signature\n *   P.zip(first, second)\n * @example\n *   P.zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zip<F extends IterableContainer, S extends IterableContainer>(\n  first: F,\n  second: S,\n): Zipped<F, S>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param second - The second input list.\n * @signature\n *   P.zip(second)(first)\n * @example\n *   P.zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zip<S extends IterableContainer>(\n  second: S,\n): <F extends IterableContainer>(first: F) => Zipped<F, S>;\n\nexport function zip(...args: ReadonlyArray<unknown>): unknown {\n  return curry(zipImplementation, args, lazyImplementation);\n}\n\nfunction zipImplementation<\n  F extends IterableContainer,\n  S extends IterableContainer,\n>(\n  first: F,\n  second: S,\n): Zipped<F, S> {\n  return (first.length < second.length\n    ? first.map((item, index) => [item, second[index]])\n    : second.map((item, index) => [first[index], item])) as Zipped<F, S>;\n}\n\nfunction lazyImplementation<F extends IterableContainer, S extends IterableContainer>(\n  second: S,\n): LazyEvaluator<F[number], [F[number], S[number]]> {\n  return (value, index) => ({\n    done: index >= second.length - 1,\n    hasNext: true,\n    next: [value, second[index]],\n  });\n}\n"],"mappings":"wCA+DA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAM,EAAmB,CAG3D,SAAS,EAIP,EACA,EACc,CACd,OAAQ,EAAM,OAAS,EAAO,OAC1B,EAAM,KAAK,EAAM,IAAU,CAAC,EAAM,EAAO,GAAO,CAAC,CACjD,EAAO,KAAK,EAAM,IAAU,CAAC,EAAM,GAAQ,EAAK,CAAC,CAGvD,SAAS,EACP,EACkD,CAClD,OAAQ,EAAO,KAAW,CACxB,KAAM,GAAS,EAAO,OAAS,EAC/B,QAAS,GACT,KAAM,CAAC,EAAO,EAAO,GAAO,CAC7B"}
+{"version":3,"file":"zip.js","names":[],"sources":["../src/zip.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curry } from './curry';\n\ntype Zipped<Left extends IterableContainer, Right extends IterableContainer>\n  // If the array is empty the output is empty, no surprises\n  = Left extends readonly []\n    ? []\n    : Right extends readonly []\n      ? []\n      : // Are the two inputs both tuples with a non-rest first item?\n      Left extends readonly [infer LeftHead, ...infer LeftRest]\n        ? Right extends readonly [infer RightHead, ...infer RightRest]\n          ? // ...Then take that first item from both and recurse\n            [[LeftHead, RightHead], ...Zipped<LeftRest, RightRest>]\n          : // Is only one of the inputs a tuple (with a non-rest first item)?\n            // Then take that item, and match it with whatever the type of the other *array's* items are.\n            [[LeftHead, Right[number]], ...Zipped<LeftRest, Right>]\n        : Right extends readonly [infer RightHead, ...infer RightRest]\n          ? [[Left[number], RightHead], ...Zipped<Left, RightRest>]\n          : // Both inputs are not tuples (with a non-rest first item, they might be tuples with non-rest last item(s))\n        // So the output is just the \"trivial\" zip result.\n          Array<[Left[number], Right[number]]>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param first - The first input list.\n * @param second - The second input list.\n * @signature\n *   zip(first, second)\n * @example\n *   zip([1, 2], ['a', 'b']) // => [[1, 'a'], [2, 'b']]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function zip<F extends IterableContainer, S extends IterableContainer>(\n  first: F,\n  second: S,\n): Zipped<F, S>;\n\n/**\n * Creates a new list from two supplied lists by pairing up equally-positioned\n * items. The length of the returned list will match the shortest of the two\n * inputs.\n *\n * @param second - The second input list.\n * @signature\n *   zip(second)(first)\n * @example\n *   zip(['a', 'b'])([1, 2]) // => [[1, 'a'], [2, 'b']]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function zip<S extends IterableContainer>(\n  second: S,\n): <F extends IterableContainer>(first: F) => Zipped<F, S>;\n\nexport function zip(...args: ReadonlyArray<unknown>): unknown {\n  return curry(zipImplementation, args, lazyImplementation);\n}\n\nfunction zipImplementation<\n  F extends IterableContainer,\n  S extends IterableContainer,\n>(first: F, second: S): Zipped<F, S> {\n  return (first.length < second.length\n    ? first.map((item, index) => [item, second[index]])\n    : second.map((item, index) => [first[index], item])) as Zipped<F, S>;\n}\n\nfunction lazyImplementation<F extends IterableContainer, S extends IterableContainer>(second: S): LazyEvaluator<F[number], [F[number], S[number]]> {\n  return (value, index) => ({\n    hasNext: true,\n    next: [value, second[index]],\n    done: index >= second.length - 1,\n  });\n}\n"],"mappings":"mCA8DA,SAAgB,EAAI,GAAG,EAAuC,CAC5D,OAAO,EAAM,EAAmB,EAAM,EAAmB,CAG3D,SAAS,EAGP,EAAU,EAAyB,CACnC,OAAQ,EAAM,OAAS,EAAO,OAC1B,EAAM,KAAK,EAAM,IAAU,CAAC,EAAM,EAAO,GAAO,CAAC,CACjD,EAAO,KAAK,EAAM,IAAU,CAAC,EAAM,GAAQ,EAAK,CAAC,CAGvD,SAAS,EAA6E,EAA6D,CACjJ,OAAQ,EAAO,KAAW,CACxB,QAAS,GACT,KAAM,CAAC,EAAO,EAAO,GAAO,CAC5B,KAAM,GAAS,EAAO,OAAS,EAChC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vinicunca/perkakas",
   "type": "module",
-  "version": "1.13.2",
+  "version": "1.14.0",
   "description": "Utility for JavaScript and Typescript.",
   "author": "praburangki<https://github.com/praburangki>",
   "license": "MIT",
@@ -38,17 +38,18 @@
   },
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.2",
-    "@types/node": "^25.0.3",
-    "@vinicunca/eslint-config": "^4.1.0",
-    "@vitest/coverage-v8": "4.0.16",
+    "@fast-check/vitest": "^0.4.0",
+    "@types/node": "^25.5.2",
+    "@vinicunca/eslint-config": "5.0.0",
+    "@vitest/coverage-v8": "^4.1.2",
     "bumpp": "^10.3.2",
-    "eslint": "^9.39.2",
+    "eslint": "^10.2.0",
+    "fast-check": "^4.7.0",
     "publint": "^0.3.14",
-    "taze": "^19.9.2",
-    "tsdown": "^0.18.2",
-    "type-fest": "^5.3.1",
-    "typescript": "^5.9.3",
-    "vitest": "4.0.16"
+    "tsdown": "^0.21.7",
+    "type-fest": "^5.5.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
   },
   "scripts": {
     "build": "tsdown",
@@ -57,13 +58,10 @@
     "lint": "eslint . --fix",
     "publish:ci": "pnpm publish --access public --no-git-checks",
     "release": "bumpp package.json",
-    "taze": "taze major -wIrl",
-    "test": "tsc --project tsconfig.tests.json && vitest --typecheck.enabled --typecheck.ignoreSourceErrors",
-    "test:runtime": "tsc --project tsconfig.tests.json && vitest",
-    "test:typing": "vitest --typecheck.only --typecheck.ignoreSourceErrors",
-    "typecheck": "tsc --project tsconfig.source.json",
-    "typecheck:dist": "tsc --project tsconfig.dist.json",
-    "build:docs": "pnpm --filter @vinicunca/perkakas-docs build",
-    "fb:deploy": "firebase deploy --only hosting:perkakas"
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage --project runtime",
+    "test:prop": "vitest --project prop",
+    "test:runtime": "vitest --project runtime",
+    "test:types": "vitest --project types"
   }
 }

package/dist/add-prop.d.cts

@@ -1,46 +0,0 @@
-import { t as UpsertProp } from "./upsert-prop-0hwik6JJ.cjs";
-
-//#region src/add-prop.d.ts
-
-/**
- * Add a new property to an object.
- *
- * The function doesn't do any checks on the input object. If the property
- * already exists it will be overwritten, and the type of the new value is not
- * checked against the previous type.
- *
- * Use `set` to override values explicitly with better protections.
- *
- * @param obj the target object
- * @param prop the property name
- * @param value the property value
- * @signature
- *  P.addProp(obj, prop, value)
- * @example
- *  P.addProp({ firstName: 'john' }, 'lastName', 'doe'); // => {firstName: 'john', lastName: 'doe'}
- * @dataFirst
- * @category Object
- */
-declare function addProp<T, K extends PropertyKey, V>(obj: T, prop: K, value: V): UpsertProp<T, K, V>;
-/**
- * Add a new property to an object.
- *
- * The function doesn't do any checks on the input object. If the property
- * already exists it will be overwritten, and the type of the new value is not
- * checked against the previous type.
- *
- * Use `set` to override values explicitly with better protections.
- *
- * @param prop the property name
- * @param value the property value
- * @signature
- *  P.addProp(prop, value)(obj)
- * @example
- *  P.addProp('lastName', 'doe')({ firstName: 'john' }); // => {firstName: 'john', lastName: 'doe'}
- * @dataLast
- * @category Object
- */
-declare function addProp<T, K extends PropertyKey, V>(prop: K, value: V): (obj: T) => UpsertProp<T, K, V>;
-//#endregion
-export { addProp };
-//# sourceMappingURL=add-prop.d.cts.map

package/dist/add-prop.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"add-prop.d.cts","names":[],"sources":["../src/add-prop.ts"],"sourcesContent":[],"mappings":";;;;;;AAsBA;;;;;;;;;;AAwBA;;;;;;;AAGgC,iBA3BhB,OA2BgB,CAAA,CAAA,EAAA,UA3BK,WA2BL,EAAA,CAAA,CAAA,CAAA,GAAA,EA1BzB,CA0ByB,EAAA,IAAA,EAzBxB,CAyBwB,EAAA,KAAA,EAxBvB,CAwBuB,CAAA,EAvB7B,UAuB6B,CAvBlB,CAuBkB,EAvBf,CAuBe,EAvBZ,CAuBY,CAAA;;;;;;;;;;;;;;;;;;;iBAHhB,qBAAqB,sBAC7B,UACC,UACA,MAAM,WAAW,GAAG,GAAG"}