@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/narrowed-to-B7tkuY2k.d.ts

@@ -0,0 +1,15 @@
+import { IsAny } from "type-fest";
+
+//#region src/internal/types/narrowed-to.d.ts
+
+/**
+ * An extension of Extract for type predicates which falls back to the base
+ * in order to narrow the `unknown` case.
+ *
+ * @example
+ *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
+ */
+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-B7tkuY2k.d.ts.map

package/dist/narrowed-to-B7tkuY2k.d.ts.map

@@ -0,0 +1 @@
+{"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-D_6H-aZW.d.cts

@@ -0,0 +1,15 @@
+import { IsAny } from "type-fest";
+
+//#region src/internal/types/narrowed-to.d.ts
+
+/**
+ * An extension of Extract for type predicates which falls back to the base
+ * in order to narrow the `unknown` case.
+ *
+ * @example
+ *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
+ */
+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-D_6H-aZW.d.cts.map

package/dist/narrowed-to-D_6H-aZW.d.cts.map

@@ -0,0 +1 @@
+{"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-DHAKSw6t.d.ts

@@ -0,0 +1,5 @@
+//#region src/internal/types/non-empty-array.d.ts
+type NonEmptyArray<T> = [T, ...Array<T>];
+//#endregion
+export { NonEmptyArray as t };
+//# 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-NDjbHRjk.d.cts

@@ -0,0 +1,5 @@
+//#region src/internal/types/non-empty-array.d.ts
+type NonEmptyArray<T> = [T, ...Array<T>];
+//#endregion
+export { NonEmptyArray as t };
+//# 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-Bby4vIbZ.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-order-rules-ClqHrs8_.cjs`),t=require(`./swap-in-place-BHkB_mvV.cjs`);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.t(e,o,s),o+=1);return t.t(e,o,r),o}function a(...t){return e.n(o,t)}function o(e,t,r){return n(e,r>=0?r:e.length+r,t)}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return a}});

package/dist/nth-by-JP3-Htbo.js

@@ -0,0 +1,2 @@
+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-JP3-Htbo.js.map

@@ -0,0 +1 @@
+{"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.cjs

@@ -1 +1 @@
-require(`./curry-order-rules-UcuuWkKd.cjs`),require(`./swap-in-place-CJrU2n1_.cjs`);const e=require(`./nth-by-BZiAVAjT.cjs`);exports.nthBy=e.nthBy;
+const e=require(`./nth-by-Bby4vIbZ.cjs`);exports.nthBy=e.t;

package/dist/nth-by.d.cts

@@ -1,5 +1,42 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import "./non-empty-array-D3ZRHApS.cjs";
-import "./curry-order-rules-1zjlAgqa.cjs";
-import { nthBy } from "./nth-by-CK-aOfcg.cjs";
-export { nthBy };
+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
+
+/**
+ * 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)*.
+ *
+ * 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`.
+ *
+ * @param data - The input array.
+ * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
+ * @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.
+ * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
+ * @signature
+ *   P.nthBy(data, index, ...rules);
+ * @example
+ *   P.nthBy([2,1,4,5,3,], 2, identity()); // => 3
+ * @dataFirst
+ * @category Array
+ */
+declare function nthBy<T extends IterableContainer>(data: T, index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): T[number] | undefined;
+/**
+ * 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)*.
+ *
+ * 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`.
+ *
+ * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
+ * @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.
+ * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
+ * @signature
+ *   P.nthBy(index, ...rules)(data);
+ * @example
+ *   P.pipe([2,1,4,5,3,], P.nthBy(2, identity())); // => 3
+ * @dataLast
+ * @category Array
+ */
+declare function nthBy<T extends IterableContainer>(index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => T[number] | undefined;
+//#endregion
+export { nthBy };
+//# sourceMappingURL=nth-by.d.cts.map

package/dist/nth-by.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nth-by.d.cts","names":[],"sources":["../src/nth-by.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA0BA;;;;;;;;;AAqBA;;;;;AAEY,iBAvBI,KAuBJ,CAAA,UAvBoB,iBAuBpB,CAAA,CAAA,IAAA,EAtBJ,CAsBI,EAAA,KAAA,EAAA,MAAA,EAAA,GAAA,KAAA,EApBA,QAoBA,CApBS,aAoBT,CApBuB,SAoBvB,CApBiC,CAoBjC,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAnBT,CAmBS,CAAA,MAAA,CAAA,GAAA,SAAA;;;;;;;;;;;;;;;;iBAFI,gBAAgB,4CAEpB,SAAS,cAAc,UAAU,sBACnC,MAAM"}

package/dist/nth-by.d.ts

@@ -1,5 +1,42 @@
-import "./iterable-container-F9CDF7ym.js";
-import "./non-empty-array-BfTfvDYg.js";
-import "./curry-order-rules-D2zI7gpB.js";
-import { nthBy } from "./nth-by-CebpSYpY.js";
-export { nthBy };
+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
+
+/**
+ * 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)*.
+ *
+ * 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`.
+ *
+ * @param data - The input array.
+ * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
+ * @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.
+ * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
+ * @signature
+ *   P.nthBy(data, index, ...rules);
+ * @example
+ *   P.nthBy([2,1,4,5,3,], 2, identity()); // => 3
+ * @dataFirst
+ * @category Array
+ */
+declare function nthBy<T extends IterableContainer>(data: T, index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): T[number] | undefined;
+/**
+ * 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)*.
+ *
+ * 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`.
+ *
+ * @param index - The zero-based index for selecting the element in the sorted order. Negative indices count backwards from the end.
+ * @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.
+ * @returns The element at the specified index in the sorted order, or `undefined` if the index is out of bounds.
+ * @signature
+ *   P.nthBy(index, ...rules)(data);
+ * @example
+ *   P.pipe([2,1,4,5,3,], P.nthBy(2, identity())); // => 3
+ * @dataLast
+ * @category Array
+ */
+declare function nthBy<T extends IterableContainer>(index: number, ...rules: Readonly<NonEmptyArray<OrderRule<T[number]>>>): (data: T) => T[number] | undefined;
+//#endregion
+export { nthBy };
+//# sourceMappingURL=nth-by.d.ts.map

package/dist/nth-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nth-by.d.ts","names":[],"sources":["../src/nth-by.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA0BA;;;;;;;;;AAqBA;;;;;AAEY,iBAvBI,KAuBJ,CAAA,UAvBoB,iBAuBpB,CAAA,CAAA,IAAA,EAtBJ,CAsBI,EAAA,KAAA,EAAA,MAAA,EAAA,GAAA,KAAA,EApBA,QAoBA,CApBS,aAoBT,CApBuB,SAoBvB,CApBiC,CAoBjC,CAAA,MAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAnBT,CAmBS,CAAA,MAAA,CAAA,GAAA,SAAA;;;;;;;;;;;;;;;;iBAFI,gBAAgB,4CAEpB,SAAS,cAAc,UAAU,sBACnC,MAAM"}

package/dist/nth-by.js

@@ -1 +1 @@
-import"./curry-order-rules-BuA7D1F4.js";import"./swap-in-place-BBqaxzzG.js";import{nthBy as e}from"./nth-by-Ol9Thsua.js";export{e as nthBy};
+import{t as e}from"./nth-by-JP3-Htbo.js";export{e as nthBy};

package/dist/obj-of.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./obj-of-UU0PjTXp.cjs`);exports.objOf=e.objOf;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t){return{[t]:e}}exports.objOf=t;

package/dist/obj-of.d.cts

@@ -1,2 +1,27 @@
-import { objOf } from "./obj-of-CWMITxro.cjs";
-export { objOf };
+//#region src/obj-of.d.ts
+/**
+ * Creates an object containing a single `key:value` pair.
+ *
+ * @param value - The object value.
+ * @param key - The property name.
+ * @signature
+ *    P.objOf(value, key)
+ * @example
+ *    P.objOf(10, 'a') // => { a: 10 }
+ * @category Object
+ */
+declare function objOf<T, K extends string>(value: T, key: K): { [x in K]: T };
+/**
+ * Creates an object containing a single `key:value` pair.
+ *
+ * @param key - The property name.
+ * @signature
+ *    P.objOf(key)(value)
+ * @example
+ *    P.pipe(10, P.objOf('a')) // => { a: 10 }
+ * @category Object
+ */
+declare function objOf<T, K extends string>(key: K): (value: T) => { [x in K]: T };
+//#endregion
+export { objOf };
+//# sourceMappingURL=obj-of.d.cts.map

package/dist/obj-of.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"obj-of.d.cts","names":[],"sources":["../src/obj-of.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;AAYA;;;;AAE6B,iBAdb,KAca,CAAA,CAAA,EAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EAdqB,CAcrB,EAAA,GAAA,EAd6B,CAc7B,CAAA,EAAA,QAdyC,CAcxC,GAd4C,CAc5C;;;;;;;;;;;iBAFd,gCACT,YACI,cAAc,IAAI"}

package/dist/obj-of.d.ts

@@ -1,2 +1,27 @@
-import { objOf } from "./obj-of-D8oOjocO.js";
-export { objOf };
+//#region src/obj-of.d.ts
+/**
+ * Creates an object containing a single `key:value` pair.
+ *
+ * @param value - The object value.
+ * @param key - The property name.
+ * @signature
+ *    P.objOf(value, key)
+ * @example
+ *    P.objOf(10, 'a') // => { a: 10 }
+ * @category Object
+ */
+declare function objOf<T, K extends string>(value: T, key: K): { [x in K]: T };
+/**
+ * Creates an object containing a single `key:value` pair.
+ *
+ * @param key - The property name.
+ * @signature
+ *    P.objOf(key)(value)
+ * @example
+ *    P.pipe(10, P.objOf('a')) // => { a: 10 }
+ * @category Object
+ */
+declare function objOf<T, K extends string>(key: K): (value: T) => { [x in K]: T };
+//#endregion
+export { objOf };
+//# sourceMappingURL=obj-of.d.ts.map

package/dist/obj-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"obj-of.d.ts","names":[],"sources":["../src/obj-of.ts"],"sourcesContent":[],"mappings":";;AAaA;;;;;;AAYA;;;;AAE6B,iBAdb,KAca,CAAA,CAAA,EAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EAdqB,CAcrB,EAAA,GAAA,EAd6B,CAc7B,CAAA,EAAA,QAdyC,CAcxC,GAd4C,CAc5C;;;;;;;;;;;iBAFd,gCACT,YACI,cAAc,IAAI"}

package/dist/obj-of.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{objOf as e}from"./obj-of-BHle5r-f.js";export{e 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/obj-of.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"obj-of.js","names":[],"sources":["../src/obj-of.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param value - The object value.\n * @param key - The property name.\n * @signature\n *    P.objOf(value, key)\n * @example\n *    P.objOf(10, 'a') // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(value: T, key: K): { [x in K]: T };\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param key - The property name.\n * @signature\n *    P.objOf(key)(value)\n * @example\n *    P.pipe(10, P.objOf('a')) // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(\n  key: K,\n): (value: T) => { [x in K]: T };\n\nexport function objOf(...args: ReadonlyArray<unknown>): unknown {\n  return curry(objOfImplementation, args);\n}\n\nfunction objOfImplementation<T, K extends string>(\n  value: T,\n  key: K,\n): { [x in K]: T } {\n  // @ts-expect-error [ts2322] - I'm not sure how to get the type right here...\n  return ({ [key]: value });\n}\n"],"mappings":"wCA6BA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EACiB,CAEjB,MAAQ,EAAG,GAAM,EAAO"}

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":";;;;;;;;;;;;;AASA;;;AACoC,KADxB,kBACwB,CAAA,CAAA,CAAA,GAAA,wBAAO,MAAb,CAAa,GAAT,CAAS,CAAP,OAAO,CAAA;;;AAD3C,KCAK,aDAO,CAAA,CAAA,EAAA,aCAuB,aDAL,CCAmB,WDAnB,CAAA,CAAA,GCE1B,CDF0B,SAAA,OAAA,GCGxB,IDHwB,SAAA,OAAA,GCKtB,kBDLsB,CCMtB,ODNsB,CCMd,ODNc,CCMN,IDNM,CAAA,MAAA,CAAA,EAAA,MCMc,CDNd,CAAA,CAAA,SAAA,IAAA,GCSlB,CDTkB,GCUlB,eDVkB,CCUF,CDVE,CAAA,SAAA,IAAA,GCWhB,WDXgB,CCWJ,CDXI,ECWD,IDXC,CAAA,GCYhB,aDZgB,CCYF,CDZE,ECYC,IDZD,CAAA,CAAA,GAAA,KAAA,GAAA,KAAA;KCiBzB,WDhByB,CAAA,CAAA,EAAA,aCgBG,aDhBH,CCgBiB,WDhBjB,CAAA,CAAA,GCoB1B,QDpB0B,CCoBjB,IDpBiB,CCoBZ,CDpBY,ECoBT,IDpBS,CAAA,MAAA,CAAA,CAAA,CAAA,GCwBxB,ODxBwB,CCyBxB,IDzBwB,CC0BtB,CD1BsB,EC2BtB,OD3BsB,CCgClB,gBDhCkB,CCgCD,UDhCC,CCgCU,IDhCV,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,OAAA,CAAA,GCiClB,UDjCkB,CCiCP,IDjCO,CAAA,CAAA,UAAA,CAAA,CAAA,MAAA,CAAA,GCkClB,UDlCkB,CCkCP,IDlCO,CAAA,CAAA,MAAA,CAAA,GCmClB,gBDnCkB,CCmCD,UDnCC,CCmCU,IDnCV,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,OAAA,CAAA,ECuClB,gBDvCkB,CCuCD,UDvCC,CCuCU,IDvCV,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,GCwClB,gBDxCkB,CCwCD,UDxCC,CCwCU,IDxCV,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,CAAA;;;;;;;ACLiC;;;;KA4D1D,aArDC,CAAA,CAAA,EAAA,aAqD6B,aArD7B,CAqD2C,WArD3C,CAAA,CAAA,GAqD2D,CArD3D,GAyDF,MAzDE,CA0DF,OA1DE,CA2DE,gBA3DF,CA2DmB,UA3DnB,CA2D8B,IA3D9B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,UAAA,CAAA,GA4DE,gBA5DF,CA4DmB,UA5DnB,CA4D8B,IA5D9B,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,UAAA,CAAA,CAAA,EAAA,KAAA,CAAA;;;;;;KAsED,QA/DuB,CAAA,CAAA,CAAA,GA+DT,OA/DS,CAAA,MA+DK,CA/DL,CAAA,SAAA,IAAA,GA+DuB,WA/DvB,GA+DqC,CA/DrC;;;;;KAqEvB,OAnEuB,CAAA,CAAA,CAAA,GAmEV,CAnEU,SAAA,OAAA,GAoExB,SApEwB,CAoEd,CApEc,CAAA,SAAA,IAAA,GAqEtB,CArEsB,GAAA,KAAA,GAAA,KAAA;;;;;AAPF;;;;;;;AAsBlB,iBAqEQ,IArER,CAAA,CAAA,EAAA,mBAqEmC,aArEnC,CAqEiD,WArEjD,CAqE6D,CArE7D,CAAA,CAAA,CAAA,CAAA,IAAA,EAsEA,IAtEA,CAAA,EAAA,CAAA,IAAA,EAuEE,CAvEF,EAAA,GAuEQ,aAvER,CAuEsB,CAvEtB,EAuEyB,IAvEzB,CAAA;;;;;;;;;;;;;AAaI,iBAwEI,IAxEJ,CAAA,CAAA,EAAA,mBAwE+B,aAxE/B,CAwE6C,WAxE7C,CAwEyD,CAxEzD,CAAA,CAAA,CAAA,CAAA,IAAA,EAyEJ,CAzEI,EAAA,IAAA,EA0EJ,IA1EI,CAAA,EA2ET,aA3ES,CA2EK,CA3EL,EA2EQ,IA3ER,CAAA"}

package/dist/omit-by.cjs

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

package/dist/omit-by.d.cts

@@ -1,6 +1,52 @@
-import "./is-bounded-record-kpsb1wQA.cjs";
-import "./to-string-gK5yUyfp.cjs";
-import "./enumerable-string-key-of-D2OpyD6n.cjs";
-import "./enumerable-string-keyed-value-of-aov5dXss.cjs";
-import { omitBy } from "./omit-by-DXSSUFwz.cjs";
-export { omitBy };
+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
+type PickSymbolKeys<T extends object> = { -readonly [P in keyof T as P extends symbol ? P : never]: T[P] };
+type PartialEnumerableKeys<T extends object> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? PickSymbolKeys<T> & { -readonly [P in keyof T as P extends symbol ? never : P]?: Required<T>[P] } : Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>> : never;
+type PartialEnumerableKeysNarrowed<T extends object, S> = Simplify<ExactProps<T, S> & PartialProps<T, S> & PickSymbolKeys<T>>;
+type ExactProps<T, S> = { -readonly [P in keyof T as IsExactProp<T, P, S> extends true ? P : never]: Exclude<T[P], S> };
+type PartialProps<T, S> = { -readonly [P in keyof T as IsPartialProp<T, P, S> extends true ? P : never]?: Exclude<T[P], S> };
+type IsExactProp<T, P$1 extends keyof T, S> = P$1 extends symbol ? false : T[P$1] extends Exclude<T[P$1], S> ? S extends T[P$1] ? false : true : false;
+type IsPartialProp<T, P$1 extends keyof T, S> = P$1 extends symbol ? false : Or<IsExactProp<T, P$1, S>, IsNever<Exclude<Required<T>[P$1], S>>> extends true ? false : true;
+/**
+ * Creates a shallow copy of the data, and then removes any keys that the
+ * predicate rejects. Symbol keys are not passed to the predicate and would be
+ * passed through to the output as-is.
+ *
+ * See `pickBy` for a complementary function which starts with an empty object
+ * and adds the entries that the predicate accepts. Because it is additive,
+ * symbol keys will not be passed through to the output object.
+ *
+ * @param data - The target object.
+ * @param predicate - A function that takes the value, key, and the data itself
+ * and returns `true` if the entry shouldn't be part of the output object, or
+ * `false` to keep it. If the function is a type-guard on the value the output
+ * type would be narrowed accordingly.
+ * @returns A shallow copy of the input object with the rejected entries
+ * removed.
+ * @signature P.omitBy(data, predicate)
+ * @example
+ *    P.omitBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {a: 1, b: 2}
+ * @dataFirst
+ * @category Object
+ */
+declare function omitBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): PartialEnumerableKeysNarrowed<T, S>;
+declare function omitBy<T extends object>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): PartialEnumerableKeys<T>;
+/**
+ * Returns a partial copy of an object omitting the keys matching predicate.
+ *
+ * @param predicate - The predicate.
+ * @signature P.omitBy(fn)(object)
+ * @example
+ *    P.omitBy((val, key) => key.toUpperCase() === key)({a: 1, b: 2, A: 3, B: 4}) // => {a: 1, b: 2}
+ * @dataLast
+ * @category Object
+ */
+declare function omitBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): (data: T) => PartialEnumerableKeysNarrowed<T, S>;
+declare function omitBy<T extends object>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): (data: T) => PartialEnumerableKeys<T>;
+//#endregion
+export { omitBy };
+//# sourceMappingURL=omit-by.d.cts.map

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

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

package/dist/omit-by.d.ts

@@ -1,6 +1,52 @@
-import "./is-bounded-record-DEQ2a3_Y.js";
-import "./to-string-B9YWszXY.js";
-import "./enumerable-string-key-of-nnI9DYHk.js";
-import "./enumerable-string-keyed-value-of-D0kMm_yz.js";
-import { omitBy } from "./omit-by-DTipg3uJ.js";
-export { omitBy };
+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
+type PickSymbolKeys<T extends object> = { -readonly [P in keyof T as P extends symbol ? P : never]: T[P] };
+type PartialEnumerableKeys<T extends object> = T extends unknown ? Simplify<IsBoundedRecord<T> extends true ? PickSymbolKeys<T> & { -readonly [P in keyof T as P extends symbol ? never : P]?: Required<T>[P] } : Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>> : never;
+type PartialEnumerableKeysNarrowed<T extends object, S> = Simplify<ExactProps<T, S> & PartialProps<T, S> & PickSymbolKeys<T>>;
+type ExactProps<T, S> = { -readonly [P in keyof T as IsExactProp<T, P, S> extends true ? P : never]: Exclude<T[P], S> };
+type PartialProps<T, S> = { -readonly [P in keyof T as IsPartialProp<T, P, S> extends true ? P : never]?: Exclude<T[P], S> };
+type IsExactProp<T, P$1 extends keyof T, S> = P$1 extends symbol ? false : T[P$1] extends Exclude<T[P$1], S> ? S extends T[P$1] ? false : true : false;
+type IsPartialProp<T, P$1 extends keyof T, S> = P$1 extends symbol ? false : Or<IsExactProp<T, P$1, S>, IsNever<Exclude<Required<T>[P$1], S>>> extends true ? false : true;
+/**
+ * Creates a shallow copy of the data, and then removes any keys that the
+ * predicate rejects. Symbol keys are not passed to the predicate and would be
+ * passed through to the output as-is.
+ *
+ * See `pickBy` for a complementary function which starts with an empty object
+ * and adds the entries that the predicate accepts. Because it is additive,
+ * symbol keys will not be passed through to the output object.
+ *
+ * @param data - The target object.
+ * @param predicate - A function that takes the value, key, and the data itself
+ * and returns `true` if the entry shouldn't be part of the output object, or
+ * `false` to keep it. If the function is a type-guard on the value the output
+ * type would be narrowed accordingly.
+ * @returns A shallow copy of the input object with the rejected entries
+ * removed.
+ * @signature P.omitBy(data, predicate)
+ * @example
+ *    P.omitBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {a: 1, b: 2}
+ * @dataFirst
+ * @category Object
+ */
+declare function omitBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): PartialEnumerableKeysNarrowed<T, S>;
+declare function omitBy<T extends object>(data: T, predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): PartialEnumerableKeys<T>;
+/**
+ * Returns a partial copy of an object omitting the keys matching predicate.
+ *
+ * @param predicate - The predicate.
+ * @signature P.omitBy(fn)(object)
+ * @example
+ *    P.omitBy((val, key) => key.toUpperCase() === key)({a: 1, b: 2, A: 3, B: 4}) // => {a: 1, b: 2}
+ * @dataLast
+ * @category Object
+ */
+declare function omitBy<T extends object, S extends EnumerableStringKeyedValueOf<T>>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => value is S): (data: T) => PartialEnumerableKeysNarrowed<T, S>;
+declare function omitBy<T extends object>(predicate: (value: EnumerableStringKeyedValueOf<T>, key: EnumerableStringKeyOf<T>, data: T) => boolean): (data: T) => PartialEnumerableKeys<T>;
+//#endregion
+export { omitBy };
+//# sourceMappingURL=omit-by.d.ts.map

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

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

package/dist/omit-by.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{omitBy as e}from"./omit-by-QzqJAuk3.js";export{e 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