@vinicunca/perkakas 1.12.0 → 1.13.0

package/dist/{n-tuple-Bu1e7UH_.d.cts → n-tuple-BkMobYQ9.d.cts}

@@ -9,4 +9,4 @@
 type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
 //#endregion
 export { NTuple as t };
-//# sourceMappingURL=n-tuple-Bu1e7UH_.d.cts.map
+//# sourceMappingURL=n-tuple-BkMobYQ9.d.cts.map

package/dist/{n-tuple-Bu1e7UH_.d.cts.map → n-tuple-BkMobYQ9.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"n-tuple-Bu1e7UH_.d.cts","names":[],"sources":["../src/internal/types/n-tuple.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;AAIoD,KAJxC,MAIwC,CAAA,CAAA,EAAA,UAAA,MAAA,EAAA,eADnC,KACmC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAhD,MAAgD,CAAA,QAAA,CAAA,SAAvB,CAAuB,GAAnB,MAAmB,GAAV,MAAU,CAAH,CAAG,EAAA,CAAA,EAAA,CAAA,GAAO,MAAP,EAAe,CAAf,CAAA,CAAA"}
+{"version":3,"file":"n-tuple-BkMobYQ9.d.cts","names":[],"sources":["../src/internal/types/n-tuple.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;AAIoD,KAJxC,MAIwC,CAAA,CAAA,EAAA,UAAA,MAAA,EAAA,eADnC,KACmC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAhD,MAAgD,CAAA,QAAA,CAAA,SAAvB,CAAuB,GAAnB,MAAmB,GAAV,MAAU,CAAH,CAAG,EAAA,CAAA,EAAA,CAAA,GAAO,MAAP,EAAe,CAAf,CAAA,CAAA"}

package/dist/{n-tuple-DoE0z7Kl.d.ts → n-tuple-zo5g_mSL.d.ts}

@@ -9,4 +9,4 @@
 type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
 //#endregion
 export { NTuple as t };
-//# sourceMappingURL=n-tuple-DoE0z7Kl.d.ts.map
+//# sourceMappingURL=n-tuple-zo5g_mSL.d.ts.map

package/dist/{n-tuple-DoE0z7Kl.d.ts.map → n-tuple-zo5g_mSL.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"n-tuple-DoE0z7Kl.d.ts","names":[],"sources":["../src/internal/types/n-tuple.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;AAIoD,KAJxC,MAIwC,CAAA,CAAA,EAAA,UAAA,MAAA,EAAA,eADnC,KACmC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAhD,MAAgD,CAAA,QAAA,CAAA,SAAvB,CAAuB,GAAnB,MAAmB,GAAV,MAAU,CAAH,CAAG,EAAA,CAAA,EAAA,CAAA,GAAO,MAAP,EAAe,CAAf,CAAA,CAAA"}
+{"version":3,"file":"n-tuple-zo5g_mSL.d.ts","names":[],"sources":["../src/internal/types/n-tuple.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;AAIoD,KAJxC,MAIwC,CAAA,CAAA,EAAA,UAAA,MAAA,EAAA,eADnC,KACmC,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAhD,MAAgD,CAAA,QAAA,CAAA,SAAvB,CAAuB,GAAnB,MAAmB,GAAV,MAAU,CAAH,CAAG,EAAA,CAAA,EAAA,CAAA,GAAO,MAAP,EAAe,CAAf,CAAA,CAAA"}

package/dist/{narrowed-to-j75i8Rl2.d.ts → narrowed-to-B7tkuY2k.d.ts}

@@ -12,4 +12,4 @@ import { IsAny } from "type-fest";
 type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
 //#endregion
 export { NarrowedTo as t };
-//# sourceMappingURL=narrowed-to-j75i8Rl2.d.ts.map
+//# sourceMappingURL=narrowed-to-B7tkuY2k.d.ts.map

package/dist/{narrowed-to-j75i8Rl2.d.ts.map → narrowed-to-B7tkuY2k.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"narrowed-to-j75i8Rl2.d.ts","names":[],"sources":["../src/internal/types/narrowed-to.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAGY,KAHA,UAGA,CAAA,CAAA,EAAA,IAAA,CAAA,GAFR,OAEQ,CAFA,CAEA,EAFG,IAEH,CAAA,SAAA,KAAA,GADN,IACM,GAAN,KAAM,CAAA,CAAA,CAAA,SAAA,IAAA,GACJ,IADI,GAEJ,OAFI,CAEI,CAFJ,EAEO,IAFP,CAAA"}
+{"version":3,"file":"narrowed-to-B7tkuY2k.d.ts","names":[],"sources":["../src/internal/types/narrowed-to.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAGY,KAHA,UAGA,CAAA,CAAA,EAAA,IAAA,CAAA,GAFR,OAEQ,CAFA,CAEA,EAFG,IAEH,CAAA,SAAA,KAAA,GADN,IACM,GAAN,KAAM,CAAA,CAAA,CAAA,SAAA,IAAA,GACJ,IADI,GAEJ,OAFI,CAEI,CAFJ,EAEO,IAFP,CAAA"}

package/dist/{narrowed-to-Yf5qTOcD.d.cts → narrowed-to-D_6H-aZW.d.cts}

@@ -12,4 +12,4 @@ import { IsAny } from "type-fest";
 type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
 //#endregion
 export { NarrowedTo as t };
-//# sourceMappingURL=narrowed-to-Yf5qTOcD.d.cts.map
+//# sourceMappingURL=narrowed-to-D_6H-aZW.d.cts.map

package/dist/{narrowed-to-Yf5qTOcD.d.cts.map → narrowed-to-D_6H-aZW.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"narrowed-to-Yf5qTOcD.d.cts","names":[],"sources":["../src/internal/types/narrowed-to.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAGY,KAHA,UAGA,CAAA,CAAA,EAAA,IAAA,CAAA,GAFR,OAEQ,CAFA,CAEA,EAFG,IAEH,CAAA,SAAA,KAAA,GADN,IACM,GAAN,KAAM,CAAA,CAAA,CAAA,SAAA,IAAA,GACJ,IADI,GAEJ,OAFI,CAEI,CAFJ,EAEO,IAFP,CAAA"}
+{"version":3,"file":"narrowed-to-D_6H-aZW.d.cts","names":[],"sources":["../src/internal/types/narrowed-to.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAGY,KAHA,UAGA,CAAA,CAAA,EAAA,IAAA,CAAA,GAFR,OAEQ,CAFA,CAEA,EAFG,IAEH,CAAA,SAAA,KAAA,GADN,IACM,GAAN,KAAM,CAAA,CAAA,CAAA,SAAA,IAAA,GACJ,IADI,GAEJ,OAFI,CAEI,CAFJ,EAEO,IAFP,CAAA"}

package/dist/{non-empty-array-DXkY7ynY.d.ts → non-empty-array-DHAKSw6t.d.ts}

@@ -2,4 +2,4 @@
 type NonEmptyArray<T> = [T, ...Array<T>];
 //#endregion
 export { NonEmptyArray as t };
-//# sourceMappingURL=non-empty-array-DXkY7ynY.d.ts.map
+//# sourceMappingURL=non-empty-array-DHAKSw6t.d.ts.map

package/dist/non-empty-array-DHAKSw6t.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-empty-array-DHAKSw6t.d.ts","names":[],"sources":["../src/internal/types/non-empty-array.ts"],"sourcesContent":[],"mappings":";KAAY,oBAAoB,MAAM,MAAM"}

package/dist/{non-empty-array-CFG7wGD-.d.cts → non-empty-array-NDjbHRjk.d.cts}

@@ -2,4 +2,4 @@
 type NonEmptyArray<T> = [T, ...Array<T>];
 //#endregion
 export { NonEmptyArray as t };
-//# sourceMappingURL=non-empty-array-CFG7wGD-.d.cts.map
+//# sourceMappingURL=non-empty-array-NDjbHRjk.d.cts.map

package/dist/non-empty-array-NDjbHRjk.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-empty-array-NDjbHRjk.d.cts","names":[],"sources":["../src/internal/types/non-empty-array.ts"],"sourcesContent":[],"mappings":";KAAY,oBAAoB,MAAM,MAAM"}

package/dist/{nth-by-Bs6FNGL-.js → nth-by-JP3-Htbo.js}

@@ -1,2 +1,2 @@
-import{n as e}from"./curry-order-rules-C6bwcUwC.js";import{t}from"./swap-in-place-COm7qHj4.js";function n(e,t,n){return t<0||t>=e.length?void 0:r([...e],0,e.length-1,t,n)}function r(e,t,n,a,o){if(t===n)return e[t];let s=i(e,t,n,o);return a===s?e[a]:r(e,a<s?t:s+1,a<s?s-1:n,a,o)}function i(e,n,r,i){let a=e[r],o=n;for(let s=n;s<r;s++)i(e[s],a)<0&&(t(e,o,s),o+=1);return t(e,o,r),o}function a(...t){return e(o,t)}function o(e,t,r){return n(e,r>=0?r:e.length+r,t)}export{a as t};
-//# sourceMappingURL=nth-by-Bs6FNGL-.js.map
+import{n as e}from"./curry-order-rules-DwrF-_P1.js";import{t}from"./swap-in-place-C_jXKHuD.js";function n(e,t,n){return t<0||t>=e.length?void 0:r([...e],0,e.length-1,t,n)}function r(e,t,n,a,o){if(t===n)return e[t];let s=i(e,t,n,o);return a===s?e[a]:r(e,a<s?t:s+1,a<s?s-1:n,a,o)}function i(e,n,r,i){let a=e[r],o=n;for(let s=n;s<r;s++)i(e[s],a)<0&&(t(e,o,s),o+=1);return t(e,o,r),o}function a(...t){return e(o,t)}function o(e,t,r){return n(e,r>=0?r:e.length+r,t)}export{a as t};
+//# sourceMappingURL=nth-by-JP3-Htbo.js.map

package/dist/{nth-by-Bs6FNGL-.js.map → nth-by-JP3-Htbo.js.map}

@@ -1 +1 @@
-{"version":3,"file":"nth-by-Bs6FNGL-.js","names":[],"sources":["../src/internal/quick-select.ts","../src/nth-by.ts"],"sourcesContent":["/**\n * A simple implementation of the *QuickSelect* algorithm.\n *\n * @see https://en.wikipedia.org/wiki/Quickselect\n */\n\nimport type { CompareFunction } from './types/compare-function';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Perform QuickSelect on the given data. Notice that the data would be cloned\n * shallowly so that it could be mutated in-place, and then discarded once the\n * algorithm is done. This means that running this function multiple times on\n * the same array might be slower then sorting the array before.\n *\n * @param data - The data to perform the selection on.\n * @param index - The index of the item we are looking for.\n * @param compareFn - The compare function to use for sorting.\n * @returns The item at the given index, or `undefined` if the index is out-of-\n * bounds.\n */\nexport function quickSelect<T>(\n  data: ReadonlyArray<T>,\n  index: number,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  return index < 0 || index >= data.length\n  // Quickselect doesn't work with out-of-bound indices\n    ? undefined\n    : quickSelectImplementation(\n      // We need to clone the array because quickSelect mutates it in-place.\n        [...data],\n        0 /* left */,\n        data.length - 1 /* right */,\n        index,\n        compareFn,\n      );\n}\n\n/**\n * The actual implementation, called recursively.\n */\nfunction quickSelectImplementation<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  index: number,\n  compareFn: CompareFunction<T>,\n): T {\n  if (left === right) {\n    return data[left]!;\n  }\n\n  const pivotIndex = partition(data, left, right, compareFn);\n\n  return index === pivotIndex\n    // Once a pivot is chosen it's location is final, so if it matches the\n    // index we found out item!\n    ? data[index]!\n    : quickSelectImplementation(\n        data,\n        // We continue by recursing into the partition where index would be\n        index < pivotIndex ? left : pivotIndex + 1,\n        index < pivotIndex ? pivotIndex - 1 : right,\n        index,\n        compareFn,\n      );\n}\n\nfunction partition<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  compareFn: CompareFunction<T>,\n): number {\n  const pivot = data[right]!;\n\n  let i = left;\n  for (let j = left; j < right; j++) {\n    if (compareFn(data[j]!, pivot) < 0) {\n      // Move items smaller then the pivot to the start of the array.\n      swapInPlace(data, i, j);\n      i += 1;\n    }\n  }\n\n  swapInPlace(data, i, right);\n\n  // The location of the pivot by the end of the partition function.\n  return i;\n}\n","import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\nimport { quickSelect } from './internal/quick-select';\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules).at(index)` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param data - The input array.\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   P.nthBy(data, index, ...rules);\n * @example\n *   P.nthBy([2,1,4,5,3,], 2, identity()); // => 3\n * @dataFirst\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  data: T,\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): T[number] | undefined;\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules)[index]` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   P.nthBy(index, ...rules)(data);\n * @example\n *   P.pipe([2,1,4,5,3,], P.nthBy(2, identity())); // => 3\n * @dataLast\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => T[number] | undefined;\n\nexport function nthBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(nthByImplementation, args);\n}\n\nfunction nthByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  index: number,\n): T | undefined {\n  return quickSelect(\n    data,\n    // Allow negative indices gracefully\n    index >= 0 ? index : data.length + index,\n    compareFn,\n  );\n}\n"],"mappings":"+FAqBA,SAAgB,EACd,EACA,EACA,EACe,CACf,OAAO,EAAQ,GAAK,GAAS,EAAK,OAE9B,IAAA,GACA,EAEE,CAAC,GAAG,EAAK,CACT,EACA,EAAK,OAAS,EACd,EACA,EACD,CAMP,SAAS,EACP,EACA,EACA,EACA,EACA,EACG,CACH,GAAI,IAAS,EACX,OAAO,EAAK,GAGd,IAAM,EAAa,EAAU,EAAM,EAAM,EAAO,EAAU,CAE1D,OAAO,IAAU,EAGb,EAAK,GACL,EACE,EAEA,EAAQ,EAAa,EAAO,EAAa,EACzC,EAAQ,EAAa,EAAa,EAAI,EACtC,EACA,EACD,CAGP,SAAS,EACP,EACA,EACA,EACA,EACQ,CACR,IAAM,EAAQ,EAAK,GAEf,EAAI,EACR,IAAK,IAAI,EAAI,EAAM,EAAI,EAAO,IACxB,EAAU,EAAK,GAAK,EAAM,CAAG,IAE/B,EAAY,EAAM,EAAG,EAAE,CACvB,GAAK,GAOT,OAHA,EAAY,EAAM,EAAG,EAAM,CAGpB,ECrCT,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAA4B,EAAqB,EAAK,CAG/D,SAAS,EACP,EACA,EACA,EACe,CACf,OAAO,EACL,EAEA,GAAS,EAAI,EAAQ,EAAK,OAAS,EACnC,EACD"}
+{"version":3,"file":"nth-by-JP3-Htbo.js","names":[],"sources":["../src/internal/quick-select.ts","../src/nth-by.ts"],"sourcesContent":["/**\n * A simple implementation of the *QuickSelect* algorithm.\n *\n * @see https://en.wikipedia.org/wiki/Quickselect\n */\n\nimport type { CompareFunction } from './types/compare-function';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Perform QuickSelect on the given data. Notice that the data would be cloned\n * shallowly so that it could be mutated in-place, and then discarded once the\n * algorithm is done. This means that running this function multiple times on\n * the same array might be slower then sorting the array before.\n *\n * @param data - The data to perform the selection on.\n * @param index - The index of the item we are looking for.\n * @param compareFn - The compare function to use for sorting.\n * @returns The item at the given index, or `undefined` if the index is out-of-\n * bounds.\n */\nexport function quickSelect<T>(\n  data: ReadonlyArray<T>,\n  index: number,\n  compareFn: CompareFunction<T>,\n): T | undefined {\n  return index < 0 || index >= data.length\n  // Quickselect doesn't work with out-of-bound indices\n    ? undefined\n    : quickSelectImplementation(\n      // We need to clone the array because quickSelect mutates it in-place.\n        [...data],\n        0 /* left */,\n        data.length - 1 /* right */,\n        index,\n        compareFn,\n      );\n}\n\n/**\n * The actual implementation, called recursively.\n */\nfunction quickSelectImplementation<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  index: number,\n  compareFn: CompareFunction<T>,\n): T {\n  if (left === right) {\n    return data[left]!;\n  }\n\n  const pivotIndex = partition(data, left, right, compareFn);\n\n  return index === pivotIndex\n    // Once a pivot is chosen it's location is final, so if it matches the\n    // index we found out item!\n    ? data[index]!\n    : quickSelectImplementation(\n        data,\n        // We continue by recursing into the partition where index would be\n        index < pivotIndex ? left : pivotIndex + 1,\n        index < pivotIndex ? pivotIndex - 1 : right,\n        index,\n        compareFn,\n      );\n}\n\nfunction partition<T>(\n  data: Array<T>,\n  left: number,\n  right: number,\n  compareFn: CompareFunction<T>,\n): number {\n  const pivot = data[right]!;\n\n  let i = left;\n  for (let j = left; j < right; j++) {\n    if (compareFn(data[j]!, pivot) < 0) {\n      // Move items smaller then the pivot to the start of the array.\n      swapInPlace(data, i, j);\n      i += 1;\n    }\n  }\n\n  swapInPlace(data, i, right);\n\n  // The location of the pivot by the end of the partition function.\n  return i;\n}\n","import type { OrderRule } from './internal/curry-order-rules';\nimport type { CompareFunction } from './internal/types/compare-function';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { NonEmptyArray } from './internal/types/non-empty-array';\nimport {\n  curryOrderRulesWithArgument,\n\n} from './internal/curry-order-rules';\nimport { quickSelect } from './internal/quick-select';\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules).at(index)` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param data - The input array.\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   P.nthBy(data, index, ...rules);\n * @example\n *   P.nthBy([2,1,4,5,3,], 2, identity()); // => 3\n * @dataFirst\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  data: T,\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): T[number] | undefined;\n\n/**\n * Retrieves the element that would be at the given index if the array were sorted according to specified rules. This function uses the *QuickSelect* algorithm running at an average complexity of *O(n)*. Semantically it is equivalent to `sortBy(data, ...rules)[index]` which would run at *O(nlogn)*.\n *\n * See also `firstBy` which provides an even more efficient algorithm and a stricter return type, but only for `index === 0`. See `takeFirstBy` to get all the elements up to and including `index`.\n *\n * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.\n * @param rules - A variadic array of order rules defining the sorting criteria. Each order rule is a projection function that extracts a comparable value from the data. Sorting is based on these extracted values using the native `<` and `>` operators. Earlier rules take precedence over later ones. Use the syntax `[projection, \"desc\"]` for descending order.\n * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.\n * @signature\n *   P.nthBy(index, ...rules)(data);\n * @example\n *   P.pipe([2,1,4,5,3,], P.nthBy(2, identity())); // => 3\n * @dataLast\n * @category Array\n */\nexport function nthBy<T extends IterableContainer>(\n  index: number,\n  ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>\n): (data: T) => T[number] | undefined;\n\nexport function nthBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryOrderRulesWithArgument(nthByImplementation, args);\n}\n\nfunction nthByImplementation<T>(\n  data: ReadonlyArray<T>,\n  compareFn: CompareFunction<T>,\n  index: number,\n): T | undefined {\n  return quickSelect(\n    data,\n    // Allow negative indices gracefully\n    index >= 0 ? index : data.length + index,\n    compareFn,\n  );\n}\n"],"mappings":"+FAqBA,SAAgB,EACd,EACA,EACA,EACe,CACf,OAAO,EAAQ,GAAK,GAAS,EAAK,OAE9B,IAAA,GACA,EAEE,CAAC,GAAG,EAAK,CACT,EACA,EAAK,OAAS,EACd,EACA,EACD,CAMP,SAAS,EACP,EACA,EACA,EACA,EACA,EACG,CACH,GAAI,IAAS,EACX,OAAO,EAAK,GAGd,IAAM,EAAa,EAAU,EAAM,EAAM,EAAO,EAAU,CAE1D,OAAO,IAAU,EAGb,EAAK,GACL,EACE,EAEA,EAAQ,EAAa,EAAO,EAAa,EACzC,EAAQ,EAAa,EAAa,EAAI,EACtC,EACA,EACD,CAGP,SAAS,EACP,EACA,EACA,EACA,EACQ,CACR,IAAM,EAAQ,EAAK,GAEf,EAAI,EACR,IAAK,IAAI,EAAI,EAAM,EAAI,EAAO,IACxB,EAAU,EAAK,GAAK,EAAM,CAAG,IAE/B,EAAY,EAAM,EAAG,EAAE,CACvB,GAAK,GAOT,OAHA,EAAY,EAAM,EAAG,EAAM,CAGpB,ECrCT,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAA4B,EAAqB,EAAK,CAG/D,SAAS,EACP,EACA,EACA,EACe,CACf,OAAO,EACL,EAEA,GAAS,EAAI,EAAQ,EAAK,OAAS,EACnC,EACD"}

package/dist/nth-by.d.cts

@@ -1,6 +1,6 @@
-import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
-import { t as NonEmptyArray } from "./non-empty-array-CFG7wGD-.cjs";
-import { t as OrderRule } from "./curry-order-rules-cezUWcSx.cjs";
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+import { t as NonEmptyArray } from "./non-empty-array-NDjbHRjk.cjs";
+import { t as OrderRule } from "./curry-order-rules-BoF09Dq2.cjs";
 
 //#region src/nth-by.d.ts
 

package/dist/nth-by.d.ts

@@ -1,6 +1,6 @@
-import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
-import { t as NonEmptyArray } from "./non-empty-array-DXkY7ynY.js";
-import { t as OrderRule } from "./curry-order-rules-BCcwbNxd.js";
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+import { t as NonEmptyArray } from "./non-empty-array-DHAKSw6t.js";
+import { t as OrderRule } from "./curry-order-rules-CoO4bk5I.js";
 
 //#region src/nth-by.d.ts
 

package/dist/nth-by.js

@@ -1 +1 @@
-import{t as e}from"./nth-by-Bs6FNGL-.js";export{e as nthBy};
+import{t as e}from"./nth-by-JP3-Htbo.js";export{e as nthBy};

package/dist/obj-of.js

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

package/dist/omit-DI8DRDHj.d.ts

@@ -0,0 +1,71 @@
+import { t as TupleParts } from "./tuple-parts-BYI4o8Vk.js";
+import { n as IsBounded, t as IsBoundedRecord } from "./is-bounded-record-Bx4n8QB0.js";
+import { t as PartitionByUnion } from "./partition-by-union-DnfiiEMU.js";
+import { EmptyObject, IsNever, KeysOfUnion } from "type-fest";
+
+//#region src/internal/types/simplified-writable.d.ts
+
+/**
+ * Type-fest's `Writable` acts funny for complex types involving intersections
+ * that redefine the same key, because of how it reconstructs the output type
+ * keys eagerly. Instead, this type is based on the `Simplify` utility type
+ * which avoids this problem.
+ *
+ * @see Writable
+ * @see Simplify
+ */
+type SimplifiedWritable<T> = { -readonly [KeyType in keyof T]: T[KeyType] } & {};
+//#endregion
+//#region src/omit.d.ts
+type OmitFromArray<T, Keys extends ReadonlyArray<PropertyKey>> = T extends unknown ? Keys extends unknown ? SimplifiedWritable<IsNever<Extract<Keys[number], keyof T>> extends true ? T : IsBoundedRecord<T> extends true ? OmitBounded<T, Keys> : OmitUnbounded<T, Keys>> : never : never;
+type OmitBounded<T, Keys extends ReadonlyArray<PropertyKey>> = FixEmpty<Omit<T, Keys[number]>> & Partial<Pick<T, Exclude<PartitionByUnion<TupleParts<Keys>['required']>['union'] | TupleParts<Keys>['optional'][number] | TupleParts<Keys>['item'] | PartitionByUnion<TupleParts<Keys>['suffix']>['union'], PartitionByUnion<TupleParts<Keys>['required']>['singular'] | PartitionByUnion<TupleParts<Keys>['suffix']>['singular']>>>;
+/**
+ * The built-in `Omit` type doesn't handle unbounded records correctly! When
+ * omitting an unbounded key the result should be untouched as we can't tell
+ * what got removed, and can't represent an object that had "something" removed
+ * from it, but instead it returns `{}`(?!) The same thing applies when a key
+ * is only optionally omitted for the same reasons. This is why we don't use
+ * `Omit` at all for the unbounded case.
+ *
+ * @see https://www.typescriptlang.org/play/?#code/C4TwDgpgBAqgdgIwPYFc4BMLqgXigeQFsBLYAHgCUIBjJAJ3TIGdg7i4BzAGigCIALCABshSXgD4eLNp3EBuAFAB6JVDUA9APxA
+ */
+type OmitUnbounded<T, Keys extends ReadonlyArray<PropertyKey>> = T & Record<Bounded<PartitionByUnion<TupleParts<Keys>['required']>['singular'] | PartitionByUnion<TupleParts<Keys>['suffix']>['singular']>, never>;
+/**
+ * When `Omit` omits **all** keys from a bounded record it results in `{}` which
+ * doesn't match what we'd expect to be returned in terms of a useful type as
+ * the output of `Omit`.
+ */
+type FixEmpty<T> = IsNever<keyof T> extends true ? EmptyObject : T;
+/**
+ * Filter a union of types, leaving only those that are bounded. e.g.,
+ * `Bounded<"a" | number>` results in `"a"`.
+ */
+type Bounded<T> = T extends unknown ? IsBounded<T> extends true ? T : never : never;
+/**
+ * Returns a partial copy of an object omitting the keys specified.
+ *
+ * @param keys - The property names.
+ * @signature
+ *    P.omit(keys)(obj);
+ * @example
+ *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.omit(['a', 'd'])) // => { b: 2, c: 3 }
+ * @dataLast
+ * @category Object
+ */
+declare function omit<T, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(keys: Keys): (data: T) => OmitFromArray<T, Keys>;
+/**
+ * Returns a partial copy of an object omitting the keys specified.
+ *
+ * @param data - The object.
+ * @param keys - The property names.
+ * @signature
+ *    P.omit(obj, keys);
+ * @example
+ *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }
+ * @dataFirst
+ * @category Object
+ */
+declare function omit<T, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(data: T, keys: Keys): OmitFromArray<T, Keys>;
+//#endregion
+export { omit as t };
+//# sourceMappingURL=omit-DI8DRDHj.d.ts.map

package/dist/omit-DI8DRDHj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit-DI8DRDHj.d.ts","names":[],"sources":["../src/internal/types/simplified-writable.ts","../src/omit.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/omit-DQiCiWAg.d.cts

@@ -0,0 +1,71 @@
+import { t as TupleParts } from "./tuple-parts-CzQQupgi.cjs";
+import { n as IsBounded, t as IsBoundedRecord } from "./is-bounded-record-DV6ZQk9H.cjs";
+import { t as PartitionByUnion } from "./partition-by-union-BztEpKVh.cjs";
+import { EmptyObject, IsNever, KeysOfUnion } from "type-fest";
+
+//#region src/internal/types/simplified-writable.d.ts
+
+/**
+ * Type-fest's `Writable` acts funny for complex types involving intersections
+ * that redefine the same key, because of how it reconstructs the output type
+ * keys eagerly. Instead, this type is based on the `Simplify` utility type
+ * which avoids this problem.
+ *
+ * @see Writable
+ * @see Simplify
+ */
+type SimplifiedWritable<T> = { -readonly [KeyType in keyof T]: T[KeyType] } & {};
+//#endregion
+//#region src/omit.d.ts
+type OmitFromArray<T, Keys extends ReadonlyArray<PropertyKey>> = T extends unknown ? Keys extends unknown ? SimplifiedWritable<IsNever<Extract<Keys[number], keyof T>> extends true ? T : IsBoundedRecord<T> extends true ? OmitBounded<T, Keys> : OmitUnbounded<T, Keys>> : never : never;
+type OmitBounded<T, Keys extends ReadonlyArray<PropertyKey>> = FixEmpty<Omit<T, Keys[number]>> & Partial<Pick<T, Exclude<PartitionByUnion<TupleParts<Keys>['required']>['union'] | TupleParts<Keys>['optional'][number] | TupleParts<Keys>['item'] | PartitionByUnion<TupleParts<Keys>['suffix']>['union'], PartitionByUnion<TupleParts<Keys>['required']>['singular'] | PartitionByUnion<TupleParts<Keys>['suffix']>['singular']>>>;
+/**
+ * The built-in `Omit` type doesn't handle unbounded records correctly! When
+ * omitting an unbounded key the result should be untouched as we can't tell
+ * what got removed, and can't represent an object that had "something" removed
+ * from it, but instead it returns `{}`(?!) The same thing applies when a key
+ * is only optionally omitted for the same reasons. This is why we don't use
+ * `Omit` at all for the unbounded case.
+ *
+ * @see https://www.typescriptlang.org/play/?#code/C4TwDgpgBAqgdgIwPYFc4BMLqgXigeQFsBLYAHgCUIBjJAJ3TIGdg7i4BzAGigCIALCABshSXgD4eLNp3EBuAFAB6JVDUA9APxA
+ */
+type OmitUnbounded<T, Keys extends ReadonlyArray<PropertyKey>> = T & Record<Bounded<PartitionByUnion<TupleParts<Keys>['required']>['singular'] | PartitionByUnion<TupleParts<Keys>['suffix']>['singular']>, never>;
+/**
+ * When `Omit` omits **all** keys from a bounded record it results in `{}` which
+ * doesn't match what we'd expect to be returned in terms of a useful type as
+ * the output of `Omit`.
+ */
+type FixEmpty<T> = IsNever<keyof T> extends true ? EmptyObject : T;
+/**
+ * Filter a union of types, leaving only those that are bounded. e.g.,
+ * `Bounded<"a" | number>` results in `"a"`.
+ */
+type Bounded<T> = T extends unknown ? IsBounded<T> extends true ? T : never : never;
+/**
+ * Returns a partial copy of an object omitting the keys specified.
+ *
+ * @param keys - The property names.
+ * @signature
+ *    P.omit(keys)(obj);
+ * @example
+ *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.omit(['a', 'd'])) // => { b: 2, c: 3 }
+ * @dataLast
+ * @category Object
+ */
+declare function omit<T, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(keys: Keys): (data: T) => OmitFromArray<T, Keys>;
+/**
+ * Returns a partial copy of an object omitting the keys specified.
+ *
+ * @param data - The object.
+ * @param keys - The property names.
+ * @signature
+ *    P.omit(obj, keys);
+ * @example
+ *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }
+ * @dataFirst
+ * @category Object
+ */
+declare function omit<T, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(data: T, keys: Keys): OmitFromArray<T, Keys>;
+//#endregion
+export { omit as t };
+//# sourceMappingURL=omit-DQiCiWAg.d.cts.map

package/dist/omit-DQiCiWAg.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit-DQiCiWAg.d.cts","names":[],"sources":["../src/internal/types/simplified-writable.ts","../src/omit.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/omit-by.d.cts

@@ -1,6 +1,6 @@
-import { t as IsBoundedRecord } from "./is-bounded-record-D9YK_OC8.cjs";
-import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-FUg082M_.cjs";
-import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-CEclDoqe.cjs";
+import { t as IsBoundedRecord } from "./is-bounded-record-DV6ZQk9H.cjs";
+import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-DhcNc5iz.cjs";
+import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-icm2q60J.cjs";
 import { IsNever, Or, Simplify } from "type-fest";
 
 //#region src/omit-by.d.ts

package/dist/omit-by.d.ts

@@ -1,6 +1,6 @@
-import { t as IsBoundedRecord } from "./is-bounded-record-BGclJjRX.js";
-import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-DMAkBhMk.js";
-import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-B2F2aTB7.js";
+import { t as IsBoundedRecord } from "./is-bounded-record-Bx4n8QB0.js";
+import { t as EnumerableStringKeyOf } from "./enumerable-string-key-of-CZQf3ld_.js";
+import { t as EnumerableStringKeyedValueOf } from "./enumerable-string-keyed-value-of-CRlVAvdp.js";
 import { IsNever, Or, Simplify } from "type-fest";
 
 //#region src/omit-by.d.ts

package/dist/omit-by.js

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

package/dist/omit.d.cts

@@ -1,29 +1,2 @@
-//#region src/omit.d.ts
-/**
- * Returns a partial copy of an object omitting the keys specified.
- *
- * @param propNames - The property names.
- * @signature
- *    P.omit(names)(obj);
- * @example
- *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.omit(['a', 'd'])) // => { b: 2, c: 3 }
- * @dataLast
- * @category Object
- */
-declare function omit<T extends object, K extends keyof T>(propNames: ReadonlyArray<K>): (data: T) => Omit<T, K>;
-/**
- * Returns a partial copy of an object omitting the keys specified.
- *
- * @param data - The object.
- * @param propNames - The property names.
- * @signature
- *    P.omit(obj, names);
- * @example
- *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }
- * @dataFirst
- * @category Object
- */
-declare function omit<T extends object, K extends keyof T>(data: T, propNames: ReadonlyArray<K>): Omit<T, K>;
-//#endregion
-export { omit };
-//# sourceMappingURL=omit.d.cts.map
+import { t as omit } from "./omit-DQiCiWAg.cjs";
+export { omit };

package/dist/omit.d.ts

@@ -1,29 +1,2 @@
-//#region src/omit.d.ts
-/**
- * Returns a partial copy of an object omitting the keys specified.
- *
- * @param propNames - The property names.
- * @signature
- *    P.omit(names)(obj);
- * @example
- *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.omit(['a', 'd'])) // => { b: 2, c: 3 }
- * @dataLast
- * @category Object
- */
-declare function omit<T extends object, K extends keyof T>(propNames: ReadonlyArray<K>): (data: T) => Omit<T, K>;
-/**
- * Returns a partial copy of an object omitting the keys specified.
- *
- * @param data - The object.
- * @param propNames - The property names.
- * @signature
- *    P.omit(obj, names);
- * @example
- *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }
- * @dataFirst
- * @category Object
- */
-declare function omit<T extends object, K extends keyof T>(data: T, propNames: ReadonlyArray<K>): Omit<T, K>;
-//#endregion
-export { omit };
-//# sourceMappingURL=omit.d.ts.map
+import { t as omit } from "./omit-DI8DRDHj.js";
+export { omit };

package/dist/omit.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";import{t}from"./has-at-least-DyIhWZJH.js";function n(...t){return e(r,t)}function r(e,n){if(!t(n,1))return{...e};if(!t(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}export{n as omit};
+import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./has-at-least-Coy9sM-B.js";function n(...t){return e(r,t)}function r(e,n){if(!t(n,1))return{...e};if(!t(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}export{n as omit};
 //# sourceMappingURL=omit.js.map

package/dist/omit.js.map

@@ -1 +1 @@
-{"version":3,"file":"omit.js","names":[],"sources":["../src/omit.ts"],"sourcesContent":["import { curry } from './curry';\nimport { hasAtLeast } from './has-at-least';\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param propNames - The property names.\n * @signature\n *    P.omit(names)(obj);\n * @example\n *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.omit(['a', 'd'])) // => { b: 2, c: 3 }\n * @dataLast\n * @category Object\n */\nexport function omit<T extends object, K extends keyof T>(\n  propNames: ReadonlyArray<K>,\n): (data: T) => Omit<T, K>;\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param data - The object.\n * @param propNames - The property names.\n * @signature\n *    P.omit(obj, names);\n * @example\n *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }\n * @dataFirst\n * @category Object\n */\nexport function omit<T extends object, K extends keyof T>(\n  data: T,\n  propNames: ReadonlyArray<K>,\n): Omit<T, K>;\n\nexport function omit(...args: ReadonlyArray<unknown>): unknown {\n  return curry(omitImplementation, args);\n}\n\nfunction omitImplementation<T extends object, K extends keyof T>(\n  data: T,\n  propNames: ReadonlyArray<K>,\n): Omit<T, K> {\n  if (!hasAtLeast(propNames, 1)) {\n    // No props to omit at all!\n    return { ...data };\n  }\n\n  if (!hasAtLeast(propNames, 2)) {\n    // Only one prop to omit.\n    const { [propNames[0]]: _omitted, ...remaining } = data;\n    return remaining;\n  }\n\n  // Multiple props to omit...\n\n  const out = { ...data };\n  for (const prop of propNames) {\n    // eslint-disable-next-line ts/no-dynamic-delete -- This is the best way to do it!\n    delete out[prop];\n  }\n  return out;\n}\n"],"mappings":"kFAmCA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EACP,EACA,EACY,CACZ,GAAI,CAAC,EAAW,EAAW,EAAE,CAE3B,MAAO,CAAE,GAAG,EAAM,CAGpB,GAAI,CAAC,EAAW,EAAW,EAAE,CAAE,CAE7B,GAAM,EAAG,EAAU,IAAK,EAAU,GAAG,GAAc,EACnD,OAAO,EAKT,IAAM,EAAM,CAAE,GAAG,EAAM,CACvB,IAAK,IAAM,KAAQ,EAEjB,OAAO,EAAI,GAEb,OAAO"}
+{"version":3,"file":"omit.js","names":[],"sources":["../src/omit.ts"],"sourcesContent":["import type { EmptyObject, IsNever, KeysOfUnion } from 'type-fest';\nimport type { IsBounded } from './internal/types/is-bounded';\nimport type { IsBoundedRecord } from './internal/types/is-bounded-record';\nimport type { PartitionByUnion } from './internal/types/partition-by-union';\nimport type { SimplifiedWritable } from './internal/types/simplified-writable';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\nimport { hasAtLeast } from './has-at-least';\n\ntype OmitFromArray<T, Keys extends ReadonlyArray<PropertyKey>>\n  // Distribute unions for both object types and key arrays.\n  = T extends unknown\n    ? Keys extends unknown\n      // The output is always writable because we always create a new object!\n      ? SimplifiedWritable<\n        IsNever<Extract<Keys[number], keyof T>> extends true\n          // When none of the keys belong to T we can short-circuit and\n          // simply return T as-is because `omit` would do nothing.\n          ? T\n          : IsBoundedRecord<T> extends true\n            ? OmitBounded<T, Keys>\n            : OmitUnbounded<T, Keys>\n      >\n      : never\n    : never;\n\ntype OmitBounded<T, Keys extends ReadonlyArray<PropertyKey>>\n  // We build our output by first considering any key present in the keys array\n  // as being omitted. This object would contain all keys that are unaffected at\n  // all by this omit operation.\n  = FixEmpty<Omit<T, Keys[number]>>\n    // But we might be missing keys that are optional in the keys tuple (and\n    // thus might not be removed). Because these keys are optional, their props\n    // in the output also need to be optional.\n    & Partial<\n      Pick<\n        T,\n        Exclude<\n          // Find all keys that can either be omitted or not, these are all keys\n          // in unions in the required parts of the keys tuple (the prefix and\n          // the suffix), as well as all keys in the optional parts and the rest\n          // item.\n          | PartitionByUnion<TupleParts<Keys>['required']>['union']\n          | TupleParts<Keys>['optional'][number]\n          | TupleParts<Keys>['item']\n          | PartitionByUnion<TupleParts<Keys>['suffix']>['union'],\n          // We then need to remove from these any items which *also* are\n          // ensured to always exist in the keys tuple, these are the elements\n          // of the required parts of the tuple which are singular (not unions).\n          | PartitionByUnion<TupleParts<Keys>['required']>['singular']\n          | PartitionByUnion<TupleParts<Keys>['suffix']>['singular']\n        >\n      >\n    >;\n\n/**\n * The built-in `Omit` type doesn't handle unbounded records correctly! When\n * omitting an unbounded key the result should be untouched as we can't tell\n * what got removed, and can't represent an object that had \"something\" removed\n * from it, but instead it returns `{}`(?!) The same thing applies when a key\n * is only optionally omitted for the same reasons. This is why we don't use\n * `Omit` at all for the unbounded case.\n *\n * @see https://www.typescriptlang.org/play/?#code/C4TwDgpgBAqgdgIwPYFc4BMLqgXigeQFsBLYAHgCUIBjJAJ3TIGdg7i4BzAGigCIALCABshSXgD4eLNp3EBuAFAB6JVDUA9APxA\n */\ntype OmitUnbounded<T, Keys extends ReadonlyArray<PropertyKey>> = T\n  // Any key we know for sure is being omitted needs to become \"impossible\" to\n  // access; for an unbounded record this means merging it with a bounded record\n  // with `never` value for these keys.\n  & Record<\n    Bounded<\n      | PartitionByUnion<TupleParts<Keys>['required']>['singular']\n      | PartitionByUnion<TupleParts<Keys>['suffix']>['singular']\n    >,\n    never\n  >;\n\n/**\n * When `Omit` omits **all** keys from a bounded record it results in `{}` which\n * doesn't match what we'd expect to be returned in terms of a useful type as\n * the output of `Omit`.\n */\ntype FixEmpty<T> = IsNever<keyof T> extends true ? EmptyObject : T;\n\n/**\n * Filter a union of types, leaving only those that are bounded. e.g.,\n * `Bounded<\"a\" | number>` results in `\"a\"`.\n */\ntype Bounded<T> = T extends unknown\n  ? IsBounded<T> extends true\n    ? T\n    : never\n  : never;\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param keys - The property names.\n * @signature\n *    P.omit(keys)(obj);\n * @example\n *    P.pipe({ a: 1, b: 2, c: 3, d: 4 }, P.omit(['a', 'd'])) // => { b: 2, c: 3 }\n * @dataLast\n * @category Object\n */\nexport function omit<T, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(\n  keys: Keys,\n): (data: T) => OmitFromArray<T, Keys>;\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param data - The object.\n * @param keys - The property names.\n * @signature\n *    P.omit(obj, keys);\n * @example\n *    P.omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }\n * @dataFirst\n * @category Object\n */\nexport function omit<T, const Keys extends ReadonlyArray<KeysOfUnion<T>>>(\n  data: T,\n  keys: Keys,\n): OmitFromArray<T, Keys>;\n\nexport function omit(...args: ReadonlyArray<unknown>): unknown {\n  return curry(omitImplementation, args);\n}\n\nfunction omitImplementation<\n  T extends object,\n  Keys extends ReadonlyArray<keyof T>,\n>(data: T, keys: Keys): OmitFromArray<T, Keys> {\n  if (!hasAtLeast(keys, 1)) {\n    // No props to omit at all!\n    // @ts-expect-error [ts2322] - TypeScript can't connect the fact that the\n    // keys array is empty and infer the expected output, and then infer that we\n    // return it correctly here.\n    return { ...data };\n  }\n\n  if (!hasAtLeast(keys, 2)) {\n    // Only one prop to omit so we can let the runtime engine deal with\n    // removing it efficiently.\n    const { [keys[0]]: _omitted, ...remaining } = data;\n\n    // @ts-expect-error [ts2322] - TypeScript can't compute the expected output\n    // correctly and then infer that we return it correctly here.\n    return remaining;\n  }\n\n  // Multiple props to omit so we have to use a loop to omit all of them.\n  const out = { ...data };\n  for (const key of keys) {\n    // eslint-disable-next-line ts/no-dynamic-delete -- This is intentional! It is the most effective way to allow the runtime engine to optimize the object without creating excessive copies for every omitted key.\n    delete out[key];\n  }\n  // @ts-expect-error [ts2322] - The type is too complex and TypeScript can't\n  // \"follow\" the iterative algorithm to ensure the output makes sense.\n  return out;\n}\n"],"mappings":"kFA8HA,SAAgB,EAAK,GAAG,EAAuC,CAC7D,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EAGP,EAAS,EAAoC,CAC7C,GAAI,CAAC,EAAW,EAAM,EAAE,CAKtB,MAAO,CAAE,GAAG,EAAM,CAGpB,GAAI,CAAC,EAAW,EAAM,EAAE,CAAE,CAGxB,GAAM,EAAG,EAAK,IAAK,EAAU,GAAG,GAAc,EAI9C,OAAO,EAIT,IAAM,EAAM,CAAE,GAAG,EAAM,CACvB,IAAK,IAAM,KAAO,EAEhB,OAAO,EAAI,GAIb,OAAO"}

package/dist/only.d.cts

@@ -1,4 +1,4 @@
-import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
 
 //#region src/only.d.ts
 type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown, unknown] | readonly [] | readonly [unknown, ...Array<unknown>, unknown] | readonly [unknown, unknown, ...Array<unknown>] ? undefined : T extends readonly [unknown] ? T[number] : T[number] | undefined;

package/dist/only.d.ts

@@ -1,4 +1,4 @@
-import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
 
 //#region src/only.d.ts
 type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown, unknown] | readonly [] | readonly [unknown, ...Array<unknown>, unknown] | readonly [unknown, unknown, ...Array<unknown>] ? undefined : T extends readonly [unknown] ? T[number] : T[number] | undefined;

package/dist/only.js

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

package/dist/optional-options-with-defaults-BFaBSKkF.d.ts

@@ -0,0 +1,12 @@
+import { Merge } from "type-fest";
+
+//#region src/internal/types/optional-options-with-defaults.d.ts
+
+/**
+ * A simplified version of type-fest's `ApplyDefaultOptions` which isn't
+ * exported. It allows us to provide a default fallback for an optional option.
+ */
+type OptionalOptionsWithDefaults<T, Provided extends T, Defaults extends T> = Merge<Defaults, { [Key in keyof Provided as Extract<Provided[Key], undefined> extends never ? Key : never]: Provided[Key] }> & Required<T>;
+//#endregion
+export { OptionalOptionsWithDefaults as t };
+//# sourceMappingURL=optional-options-with-defaults-BFaBSKkF.d.ts.map

package/dist/optional-options-with-defaults-BFaBSKkF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional-options-with-defaults-BFaBSKkF.d.ts","names":[],"sources":["../src/internal/types/optional-options-with-defaults.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;;AAGmB,KAHP,2BAGO,CAAA,CAAA,EAAA,iBADA,CACA,EAAA,iBAAA,CAAA,CAAA,GACf,KADe,CAEjB,QAFiB,EAAA,UAEjB,MAKgB,QALhB,IAK4B,OAL5B,CAKoC,QALpC,CAK6C,GAL7C,CAAA,EAAA,SAAA,CAAA,SAAA,KAAA,GAMM,GANN,GAAA,KAAA,GAOc,QAPd,CAOuB,GAPvB,CAAA,EAKgB,CAAA,GAQhB,QARgB,CAQP,CARO,CAAA"}

package/dist/optional-options-with-defaults-BZVW8GfC.d.cts

@@ -0,0 +1,12 @@
+import { Merge } from "type-fest";
+
+//#region src/internal/types/optional-options-with-defaults.d.ts
+
+/**
+ * A simplified version of type-fest's `ApplyDefaultOptions` which isn't
+ * exported. It allows us to provide a default fallback for an optional option.
+ */
+type OptionalOptionsWithDefaults<T, Provided extends T, Defaults extends T> = Merge<Defaults, { [Key in keyof Provided as Extract<Provided[Key], undefined> extends never ? Key : never]: Provided[Key] }> & Required<T>;
+//#endregion
+export { OptionalOptionsWithDefaults as t };
+//# sourceMappingURL=optional-options-with-defaults-BZVW8GfC.d.cts.map

package/dist/optional-options-with-defaults-BZVW8GfC.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional-options-with-defaults-BZVW8GfC.d.cts","names":[],"sources":["../src/internal/types/optional-options-with-defaults.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;;AAGmB,KAHP,2BAGO,CAAA,CAAA,EAAA,iBADA,CACA,EAAA,iBAAA,CAAA,CAAA,GACf,KADe,CAEjB,QAFiB,EAAA,UAEjB,MAKgB,QALhB,IAK4B,OAL5B,CAKoC,QALpC,CAK6C,GAL7C,CAAA,EAAA,SAAA,CAAA,SAAA,KAAA,GAMM,GANN,GAAA,KAAA,GAOc,QAPd,CAOuB,GAPvB,CAAA,EAKgB,CAAA,GAQhB,QARgB,CAQP,CARO,CAAA"}

package/dist/{partial-array-CoV_xxyQ.d.cts → partial-array-CQF5oggb.d.cts}

@@ -9,4 +9,4 @@
 type PartialArray<T> = T extends ReadonlyArray<unknown> | [] ? Partial<T> : never;
 //#endregion
 export { PartialArray as t };
-//# sourceMappingURL=partial-array-CoV_xxyQ.d.cts.map
+//# sourceMappingURL=partial-array-CQF5oggb.d.cts.map

package/dist/partial-array-CQF5oggb.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial-array-CQF5oggb.d.cts","names":[],"sources":["../src/internal/types/partial-array.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;KAAY,kBAAkB,UAAU,8BACpC,QAAQ"}

package/dist/{partial-array-CeoXpbZU.d.ts → partial-array-DU-2Vkyx.d.ts}

@@ -9,4 +9,4 @@
 type PartialArray<T> = T extends ReadonlyArray<unknown> | [] ? Partial<T> : never;
 //#endregion
 export { PartialArray as t };
-//# sourceMappingURL=partial-array-CeoXpbZU.d.ts.map
+//# sourceMappingURL=partial-array-DU-2Vkyx.d.ts.map

package/dist/partial-array-DU-2Vkyx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial-array-DU-2Vkyx.d.ts","names":[],"sources":["../src/internal/types/partial-array.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;KAAY,kBAAkB,UAAU,8BACpC,QAAQ"}

package/dist/partition-by-union-BztEpKVh.d.cts

@@ -0,0 +1,20 @@
+import { IsUnion } from "type-fest";
+
+//#region src/internal/types/partition-by-union.d.ts
+
+/**
+ * We split the fixed tuple item types into **singular** types (e.g., `"a"`),
+ * and unions of several types (e.g., `"a" | "b"`). This split allows building
+ * complex types based on if a specific value would always be present, or if
+ * it is *effectively* optional.
+ *
+ * We assume that T is a fixed tuple (no optional or rest elements), and that
+ * all elements in it are bounded (as defined by `IsBounded`).
+ */
+type PartitionByUnion<T, Singular = never, Union = never> = T extends readonly [infer Head, ...infer Rest] ? IsUnion<Head> extends true ? PartitionByUnion<Rest, Singular, Union | Head> : PartitionByUnion<Rest, Singular | Head, Union> : {
+  singular: Singular;
+  union: Union;
+};
+//#endregion
+export { PartitionByUnion as t };
+//# sourceMappingURL=partition-by-union-BztEpKVh.d.cts.map

package/dist/partition-by-union-BztEpKVh.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-by-union-BztEpKVh.d.cts","names":[],"sources":["../src/internal/types/partition-by-union.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;AAM+C,KANnC,gBAMmC,CAAA,CAAA,EAAA,WAAA,KAAA,EAAA,QAAA,KAAA,CAAA,GAF3C,CAE2C,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAD3C,OAC2C,CADnC,IACmC,CAAA,SAAA,IAAA,GAAzC,gBAAyC,CAAxB,IAAwB,EAAlB,QAAkB,EAAR,KAAQ,GAAA,IAAA,CAAA,GACzC,gBADyC,CACxB,IADwB,EAClB,QADkB,GACP,IADO,EACD,KADC,CAAA,GAAA;EAAzC,QAAA,EAEU,QAFV;EACiB,KAAA,EACU,KADV;CAAM"}

package/dist/partition-by-union-DnfiiEMU.d.ts

@@ -0,0 +1,20 @@
+import { IsUnion } from "type-fest";
+
+//#region src/internal/types/partition-by-union.d.ts
+
+/**
+ * We split the fixed tuple item types into **singular** types (e.g., `"a"`),
+ * and unions of several types (e.g., `"a" | "b"`). This split allows building
+ * complex types based on if a specific value would always be present, or if
+ * it is *effectively* optional.
+ *
+ * We assume that T is a fixed tuple (no optional or rest elements), and that
+ * all elements in it are bounded (as defined by `IsBounded`).
+ */
+type PartitionByUnion<T, Singular = never, Union = never> = T extends readonly [infer Head, ...infer Rest] ? IsUnion<Head> extends true ? PartitionByUnion<Rest, Singular, Union | Head> : PartitionByUnion<Rest, Singular | Head, Union> : {
+  singular: Singular;
+  union: Union;
+};
+//#endregion
+export { PartitionByUnion as t };
+//# sourceMappingURL=partition-by-union-DnfiiEMU.d.ts.map

package/dist/partition-by-union-DnfiiEMU.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-by-union-DnfiiEMU.d.ts","names":[],"sources":["../src/internal/types/partition-by-union.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;AAM+C,KANnC,gBAMmC,CAAA,CAAA,EAAA,WAAA,KAAA,EAAA,QAAA,KAAA,CAAA,GAF3C,CAE2C,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAD3C,OAC2C,CADnC,IACmC,CAAA,SAAA,IAAA,GAAzC,gBAAyC,CAAxB,IAAwB,EAAlB,QAAkB,EAAR,KAAQ,GAAA,IAAA,CAAA,GACzC,gBADyC,CACxB,IADwB,EAClB,QADkB,GACP,IADO,EACD,KADC,CAAA,GAAA;EAAzC,QAAA,EAEU,QAFV;EACiB,KAAA,EACU,KADV;CAAM"}

package/dist/partition.js

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

package/dist/path-or.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t,n){let r=e;for(let e of t){if(r==null)break;r=r[e]}return r??n}export{t as pathOr};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t,n){let r=e;for(let e of t){if(r==null)break;r=r[e]}return r??n}export{t as pathOr};
 //# sourceMappingURL=path-or.js.map

package/dist/{perkakas-type-error-DmmsEmEF.d.ts → perkakas-type-error-B9ULNhW0.d.ts}

@@ -16,4 +16,4 @@ type PerkakasTypeError<FunctionName extends string, Message extends number | str
 } ? Metadata : never>;
 //#endregion
 export { PerkakasTypeError as t };
-//# sourceMappingURL=perkakas-type-error-DmmsEmEF.d.ts.map
+//# sourceMappingURL=perkakas-type-error-B9ULNhW0.d.ts.map

package/dist/{perkakas-type-error-DmmsEmEF.d.ts.map → perkakas-type-error-B9ULNhW0.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"perkakas-type-error-DmmsEmEF.d.ts","names":[],"sources":["../src/internal/types/perkakas-type-error.ts"],"sourcesContent":[],"mappings":";;;cAIM;UAEI,wBAAA;EAFJ,IAAA,CAAA,EAAA,OAAA;EAEI,QAAA,CAAA,EAAA,OAAA;AAQV;;;;AASuB,KATX,iBASW,CAAA,qBAAA,MAAA,EAAA,gBAAA,MAAA,GAAA,MAAA,EAAA,gBAHL,wBAGK,GAAA,CAAA,CAAA,CAAA,GAFnB,MAEmB,CADrB,OACqB,SAAA;EAAkB,IAAA,EAAA,KAAA,EAAA;CACvC,GAAA,CAAA,GAAA,OAF+C,mBAE/C,EAAA,qBADqB,YACrB,MADuC,OACvC,GAAA,EAAA,OAAA,SAAA;EAHE,QAAA,EAAA,KAAA,SAAA;CAAM,GAAA,QAAA,GAAA,KAAA,CAAA"}
+{"version":3,"file":"perkakas-type-error-B9ULNhW0.d.ts","names":[],"sources":["../src/internal/types/perkakas-type-error.ts"],"sourcesContent":[],"mappings":";;;cAIM;UAEI,wBAAA;EAFJ,IAAA,CAAA,EAAA,OAAA;EAEI,QAAA,CAAA,EAAA,OAAA;AAQV;;;;AASuB,KATX,iBASW,CAAA,qBAAA,MAAA,EAAA,gBAAA,MAAA,GAAA,MAAA,EAAA,gBAHL,wBAGK,GAAA,CAAA,CAAA,CAAA,GAFnB,MAEmB,CADrB,OACqB,SAAA;EAAkB,IAAA,EAAA,KAAA,EAAA;CACvC,GAAA,CAAA,GAAA,OAF+C,mBAE/C,EAAA,qBADqB,YACrB,MADuC,OACvC,GAAA,EAAA,OAAA,SAAA;EAHE,QAAA,EAAA,KAAA,SAAA;CAAM,GAAA,QAAA,GAAA,KAAA,CAAA"}

package/dist/{perkakas-type-error-BERl_sWR.d.cts → perkakas-type-error-ClCCHBW1.d.cts}

@@ -16,4 +16,4 @@ type PerkakasTypeError<FunctionName extends string, Message extends number | str
 } ? Metadata : never>;
 //#endregion
 export { PerkakasTypeError as t };
-//# sourceMappingURL=perkakas-type-error-BERl_sWR.d.cts.map
+//# sourceMappingURL=perkakas-type-error-ClCCHBW1.d.cts.map