@vinicunca/perkakas 0.5.3 → 1.0.0

package/dist/merge-deep.d.cts

@@ -0,0 +1,34 @@
+import { MergeDeep } from 'type-fest';
+
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param destination - The object to merge into. In general, this object would have it's values overridden.
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns The merged object.
+ * @signature
+ *    P.mergeDeep(destination, source)
+ * @example
+ *    P.mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function mergeDeep<Destination extends Record<string, unknown>, Source extends Record<string, unknown>>(destination: Destination, source: Source): MergeDeep<Destination, Source>;
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns The merged object.
+ * @signature
+ *    P.mergeDeep(source)(destination)
+ * @example
+ *    P.pipe(
+ *      { foo: 'bar', x: 1 },
+ *      P.mergeDeep({ foo: 'baz', y: 2 }),
+ *    );  // => { foo: 'baz', x: 1, y: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function mergeDeep<Destination extends Record<string, unknown>, Source extends Record<string, unknown>>(source: Source): (target: Destination) => MergeDeep<Destination, Source>;
+
+export { mergeDeep };

package/dist/merge-deep.d.ts

@@ -0,0 +1,34 @@
+import { MergeDeep } from 'type-fest';
+
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param destination - The object to merge into. In general, this object would have it's values overridden.
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns The merged object.
+ * @signature
+ *    P.mergeDeep(destination, source)
+ * @example
+ *    P.mergeDeep({ foo: 'bar', x: 1 }, { foo: 'baz', y: 2 }) // => { foo: 'baz', x: 1, y: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function mergeDeep<Destination extends Record<string, unknown>, Source extends Record<string, unknown>>(destination: Destination, source: Source): MergeDeep<Destination, Source>;
+/**
+ * Merges the `source` object into the `destination` object. The merge is similar to performing `{ ...destination, ... source }` (where disjoint values from each object would be copied as-is, and for any overlapping props the value from `source` would be used); But for *each prop* (`p`), if **both** `destination` and `source` have a **plain-object** as a value, the value would be taken as the result of recursively deepMerging them (`result.p === deepMerge(destination.p, source.p)`).
+ *
+ * @param source - The object to merge from. In general, shared keys would be taken from this object.
+ * @returns The merged object.
+ * @signature
+ *    P.mergeDeep(source)(destination)
+ * @example
+ *    P.pipe(
+ *      { foo: 'bar', x: 1 },
+ *      P.mergeDeep({ foo: 'baz', y: 2 }),
+ *    );  // => { foo: 'baz', x: 1, y: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function mergeDeep<Destination extends Record<string, unknown>, Source extends Record<string, unknown>>(source: Source): (target: Destination) => MergeDeep<Destination, Source>;
+
+export { mergeDeep };

package/dist/merge-deep.js

@@ -0,0 +1 @@
+import{a}from"./chunk-QIYBHLRA.js";import"./chunk-HLL46USD.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as mergeDeep};

package/dist/merge.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkCXZHGDSDcjs = require('./chunk-CXZHGDSD.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.merge = _chunkCXZHGDSDcjs.a;

package/dist/merge.d.cts

@@ -0,0 +1,54 @@
+import { Merge } from 'type-fest';
+
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param data - The destination object, serving as the basis for the merge.
+ * Properties from this object are included in the new object, but will be
+ * overwritten by properties from the source object with matching keys.
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    P.merge(data, source)
+ * @example
+ *    P.merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function merge<T, Source>(data: T, source: Source): Merge<T, Source>;
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    P.merge(source)(data)
+ * @example
+ *    P.pipe(
+ *      { x: 1, y: 2 },
+ *      P.merge({ y: 10, z: 2 }),
+ *    ); // => { x: 1, y: 10, z: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;
+
+export { merge };

package/dist/merge.d.ts

@@ -0,0 +1,54 @@
+import { Merge } from 'type-fest';
+
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param data - The destination object, serving as the basis for the merge.
+ * Properties from this object are included in the new object, but will be
+ * overwritten by properties from the source object with matching keys.
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    P.merge(data, source)
+ * @example
+ *    P.merge({ x: 1, y: 2 }, { y: 10, z: 2 }) // => { x: 1, y: 10, z: 2 }
+ * @dataFirst
+ * @category Object
+ */
+declare function merge<T, Source>(data: T, source: Source): Merge<T, Source>;
+/**
+ * Merges two objects into one by combining their properties, effectively
+ * creating a new object that incorporates elements from both. The merge
+ * operation prioritizes the second object's properties, allowing them to
+ * overwrite those from the first object with the same names.
+ *
+ * Equivalent to `{ ...data, ...source }`.
+ *
+ * @param source - The source object, whose properties will be included in the
+ * new object. If properties in this object share keys with properties in the
+ * destination object, the values from the source object will be used in the
+ * new object.
+ * @returns An object fully containing `source`, and any properties from `data`
+ * that don't share a name with any property in `source`.
+ * @signature
+ *    P.merge(source)(data)
+ * @example
+ *    P.pipe(
+ *      { x: 1, y: 2 },
+ *      P.merge({ y: 10, z: 2 }),
+ *    ); // => { x: 1, y: 10, z: 2 }
+ * @dataLast
+ * @category Object
+ */
+declare function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;
+
+export { merge };

package/dist/merge.js

@@ -0,0 +1 @@
+import{a}from"./chunk-5HAUJEIR.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as merge};

package/dist/multiply.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkKLQZU5J4cjs = require('./chunk-KLQZU5J4.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.multiply = _chunkKLQZU5J4cjs.a;

package/dist/multiply.d.cts

@@ -0,0 +1,31 @@
+/**
+ * Multiplies two numbers.
+ *
+ * @param value - The number.
+ * @param multiplicand - The number to multiply the value by.
+ * @signature
+ *    P.multiply(value, multiplicand);
+ * @example
+ *    P.multiply(3, 4) // => 12
+ *    P.reduce([1, 2, 3, 4], P.multiply, 1) // => 24
+ * @dataFirst
+ * @category Number
+ */
+declare function multiply(value: bigint, multiplicand: bigint): bigint;
+declare function multiply(value: number, multiplicand: number): number;
+/**
+ * Multiplies two numbers.
+ *
+ * @param multiplicand - The number to multiply the value by.
+ * @signature
+ *    P.multiply(multiplicand)(value);
+ * @example
+ *    P.multiply(4)(3) // => 12
+ *    P.map([1, 2, 3, 4], P.multiply(2)) // => [2, 4, 6, 8]
+ * @dataLast
+ * @category Number
+ */
+declare function multiply(multiplicand: bigint): (value: bigint) => bigint;
+declare function multiply(multiplicand: number): (value: number) => number;
+
+export { multiply };

package/dist/multiply.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Multiplies two numbers.
+ *
+ * @param value - The number.
+ * @param multiplicand - The number to multiply the value by.
+ * @signature
+ *    P.multiply(value, multiplicand);
+ * @example
+ *    P.multiply(3, 4) // => 12
+ *    P.reduce([1, 2, 3, 4], P.multiply, 1) // => 24
+ * @dataFirst
+ * @category Number
+ */
+declare function multiply(value: bigint, multiplicand: bigint): bigint;
+declare function multiply(value: number, multiplicand: number): number;
+/**
+ * Multiplies two numbers.
+ *
+ * @param multiplicand - The number to multiply the value by.
+ * @signature
+ *    P.multiply(multiplicand)(value);
+ * @example
+ *    P.multiply(4)(3) // => 12
+ *    P.map([1, 2, 3, 4], P.multiply(2)) // => [2, 4, 6, 8]
+ * @dataLast
+ * @category Number
+ */
+declare function multiply(multiplicand: bigint): (value: bigint) => bigint;
+declare function multiply(multiplicand: number): (value: number) => number;
+
+export { multiply };

package/dist/multiply.js

@@ -0,0 +1 @@
+import{a}from"./chunk-MBYBX5B3.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as multiply};

package/dist/nth-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk5UP2X3VYcjs = require('./chunk-5UP2X3VY.cjs');require('./chunk-5KO77UXQ.cjs');require('./chunk-FWQYL4Y4.cjs');exports.nthBy = _chunk5UP2X3VYcjs.a;

package/dist/nth-by.d.cts

@@ -0,0 +1,39 @@
+import { I as IterableContainer, N as NonEmptyArray } from './types-DCY4LHuA.cjs';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.cjs';
+import 'type-fest';
+
+/**
+ * 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;
+
+export { nthBy };

package/dist/nth-by.d.ts

@@ -0,0 +1,39 @@
+import { I as IterableContainer, N as NonEmptyArray } from './types-DCY4LHuA.js';
+import { O as OrderRule } from './curry-order-rules-BOMf1JS7.js';
+import 'type-fest';
+
+/**
+ * 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;
+
+export { nthBy };

package/dist/nth-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-3DPIEAUX.js";import"./chunk-UYH64IBH.js";import"./chunk-JXXXUJM5.js";export{a as nthBy};

package/dist/obj-of.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkVGZCX6HKcjs = require('./chunk-VGZCX6HK.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.objOf = _chunkVGZCX6HKcjs.a;

package/dist/obj-of.d.cts

@@ -0,0 +1,29 @@
+/**
+ * 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;
+};
+
+export { objOf };

package/dist/obj-of.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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;
+};
+
+export { objOf };

package/dist/obj-of.js

@@ -0,0 +1 @@
+import{a}from"./chunk-UNG2JJTE.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as objOf};

package/dist/omit-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk6LV46ASNcjs = require('./chunk-6LV46ASN.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.omitBy = _chunk6LV46ASNcjs.a;

package/dist/omit-by.d.cts

@@ -0,0 +1,56 @@
+import { Simplify, IfNever } from 'type-fest';
+import { E as EnumerableStringKeyedValueOf, a as EnumerableStringKeyOf, e as IfSimpleRecord, R as ReconstructedRecord } from './types-DCY4LHuA.cjs';
+
+type PickSymbolKeys<T extends object> = {
+    -readonly [P in keyof T as P extends symbol ? P : never]: T[P];
+};
+type PartialEnumerableKeys<T extends object> = Simplify<IfSimpleRecord<T, ReconstructedRecord<T>, PickSymbolKeys<T> & {
+    -readonly [P in keyof T as P extends symbol ? never : P]?: Required<T>[P];
+}>>;
+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 extends keyof T, S> = P extends symbol ? false : T[P] extends Exclude<T[P], S> ? S extends T[P] ? false : true : false;
+type IsPartialProp<T, P extends keyof T, S> = P extends symbol ? false : IsExactProp<T, P, S> extends true ? false : IfNever<Exclude<Required<T>[P], S>, 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>;
+
+export { omitBy };

package/dist/omit-by.d.ts

@@ -0,0 +1,56 @@
+import { Simplify, IfNever } from 'type-fest';
+import { E as EnumerableStringKeyedValueOf, a as EnumerableStringKeyOf, e as IfSimpleRecord, R as ReconstructedRecord } from './types-DCY4LHuA.js';
+
+type PickSymbolKeys<T extends object> = {
+    -readonly [P in keyof T as P extends symbol ? P : never]: T[P];
+};
+type PartialEnumerableKeys<T extends object> = Simplify<IfSimpleRecord<T, ReconstructedRecord<T>, PickSymbolKeys<T> & {
+    -readonly [P in keyof T as P extends symbol ? never : P]?: Required<T>[P];
+}>>;
+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 extends keyof T, S> = P extends symbol ? false : T[P] extends Exclude<T[P], S> ? S extends T[P] ? false : true : false;
+type IsPartialProp<T, P extends keyof T, S> = P extends symbol ? false : IsExactProp<T, P, S> extends true ? false : IfNever<Exclude<Required<T>[P], S>, 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>;
+
+export { omitBy };

package/dist/omit-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-5OVP2TQW.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as omitBy};

package/dist/omit.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkINAPFYB2cjs = require('./chunk-INAPFYB2.cjs');require('./chunk-G66EZBJS.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.omit = _chunkINAPFYB2cjs.a;

package/dist/omit.d.cts

@@ -0,0 +1,27 @@
+/**
+ * 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>;
+
+export { omit };

package/dist/omit.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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>;
+
+export { omit };

package/dist/omit.js

@@ -0,0 +1 @@
+import{a}from"./chunk-KTMLSQQ7.js";import"./chunk-73BYESBE.js";import"./chunk-JFXZ246Y.js";import"./chunk-KQGY2DBY.js";export{a as omit};

package/dist/once.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkJRDQRETRcjs = require('./chunk-JRDQRETR.cjs');exports.once = _chunkJRDQRETRcjs.a;

package/dist/once.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation.
+ *
+ * @param fn - The function to wrap.
+ * @signature P.once(fn)
+ * @example
+ * const initialize = P.once(createApplication);
+ * initialize();
+ * initialize();
+ * // => `createApplication` is invoked once
+ * @category Function
+ */
+declare function once<T>(fn: () => T): () => T;
+
+export { once };

package/dist/once.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation.
+ *
+ * @param fn - The function to wrap.
+ * @signature P.once(fn)
+ * @example
+ * const initialize = P.once(createApplication);
+ * initialize();
+ * initialize();
+ * // => `createApplication` is invoked once
+ * @category Function
+ */
+declare function once<T>(fn: () => T): () => T;
+
+export { once };

package/dist/once.js

@@ -0,0 +1 @@
+import{a}from"./chunk-C6IMN7SF.js";export{a as once};

package/dist/only.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkR52BC2FHcjs = require('./chunk-R52BC2FH.cjs');require('./chunk-Y74ER22O.cjs');require('./chunk-7T4AVFYJ.cjs');exports.only = _chunkR52BC2FHcjs.a;