import { b as ID, n as ArrayPredicate, t as ArrayElementResolvable, x as nil } from "./array-C6YBhEyW.js";
import { Resolvable } from "jtilz";

//#region src/fp/array.d.ts
/**
 * Appends elements onto the end of the array.
 */
declare function arrayPush<T>(...values: T[]): (a: T[] | nil) => T[];
/**
 * Pops an element off the end of the array.
 */
declare function arrayPop<T>(howMany?: number): (a: T[] | nil) => T[];
/**
 * Insert one or more elements into an array at the given position.
 */
declare function arrayInsert<T>(index: number, ...values: T[]): (a: T[] | nil) => T[];
/**
 * Insert numbers into a sorted array, using binary search to find their position.
 *
 * @param values Values to insert. These needn't be sorted; each one will be searched for individually.
 */
declare function arrayInsertSorted(...values: number[]): (a: number[] | nil) => number[];
/**
 * Prepends elements onto the end of the array.
 */
declare function arrayUnshift<T>(...values: T[]): (a: T[] | nil) => T[];
/**
 * Deletes elements from an array by index.
 */
declare function arrayDeleteIndex<T>(...indices: number[]): (a: T[] | nil) => T[];
/**
 * Deletes up to one element from an array, searching by value.
 * @deprecated
 */
declare function arrayDeleteOneValue<T>(value: T, strict: boolean): (a: T[] | nil) => T[];
/**
 * Deletes up to one element from an array, searching by value.
 */
declare function arrayDeleteValue<T>(value: T, strict: boolean, limit?: number): (a: T[] | nil) => T[];
/**
 * Filters the array to elements that pass the predicate.
 * If limit is provided, returned array will be at most that length.
 */
declare function arraySelect<T>(predicate: (v: T, i: number) => boolean, limit?: number): (a: T[] | nil) => T[];
/**
 * Removes elements for which the predicate returns true.
 * If limit is provided, at most that many elements will be deleted. i.e. new length will be >= array.length - limit.
 */
declare function arrayReject<T>(predicate: (v: T, i: number) => boolean, limit?: number): (a: T[] | nil) => T[];
/**
 * Replaces `count` elements starting at the given `index` with `replaceWith` elements.
 */
declare function arraySplice<T>(index: number, count?: number, ...replaceWith: T[]): (a: T[] | nil) => T[];
declare function arrayFindAndReplace<T>(predicate: ArrayPredicate<T>, replaceWith: ArrayElementResolvable<T>): (a: T[] | nil) => T[];
//#endregion
//#region src/fp/map.d.ts
/**
 * Set a key in a Map.
 */
declare function mapSet<K, V>(key: K, value: Resolvable<V, [V | undefined]>): (map: Map<K, V> | nil) => Map<K, V>;
/**
 * Update an existing value in a map.
 * Returns the map as-is if the key does not exist.
 */
declare function mapUpdate<K, V>(key: K, value: Resolvable<V, [V, K]>): (map: Map<K, V>) => Map<K, V>;
/**
 * Merge multiple entries into a map.
 */
declare function mergeMap<K, V>(values: Resolvable<Iterable<readonly [K, Resolvable<V, [V | undefined, K]>]>, [Map<K, V>]>): (map: Map<K, V>) => Map<K, V>;
/**
 * Delete one or more keys from a map.
 */
declare function mapDelete<K, V>(...keys: K[]): (map: Map<K, V> | nil) => Map<K, V>;
//#endregion
//#region src/fp/number.d.ts
/**
 * Adds a value to a number. Defaults to 0 if undefined.
 */
declare function add(value: number): (prev: number | nil) => number;
/**
 * Subtracts a value from a number. Defaults to 0 if undefined.
 */
declare function sub(value: number): (prev: number | nil) => number;
/**
 * Multiplies a number by a value. Defaults to 0 if undefined.
 */
declare function mult(value: number): (prev: number | nil) => number;
/**
 * Divides a number by a value. Defaults to 0 if undefined.
 */
declare function div(value: number): (prev: number | nil) => number;
//#endregion
//#region src/fp/object.d.ts
type KeysOfUnion<T> = T extends T ? keyof T : never;
type PatchValue<T, K extends PropertyKey> = T extends T ? (K extends keyof T ? T[K] : never) : never;
type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends bigint ? bigint : T extends symbol ? symbol : T;
type ResolvedPatchValue<T> = T extends ((...args: any[]) => infer R) ? R : T;
type MergeTarget<T> = { [K in KeysOfUnion<T>]: Widen<ResolvedPatchValue<PatchValue<T, K>>> };
type InvalidPatchKeys<TObj, TPatch> = { [K in KeysOfUnion<TPatch>]: K extends keyof TObj ? PatchValue<TPatch, K> extends TObj[K] ? never : K : K }[KeysOfUnion<TPatch>];
type PatchTarget<TObj, TPatch> = [InvalidPatchKeys<TObj, TPatch>] extends [never] ? TObj : never;
type MergeObject<T> = { [K in keyof T]?: T[K] | ((value: T[K], key: K) => T[K] | Widen<T[K]>) };
type ValueMergeObject<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => any) ? never : T[K] };
type ValueMergeObjects<T extends ReadonlyArray<object>> = { [K in keyof T]: T[K] extends object ? ValueMergeObject<T[K]> : T[K] };
type IsAny<T> = 0 extends 1 & T ? true : false;
/**
 * Merge one or more objects into a target object, similar to
 * [`Object.assign`]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign}, but each value can be a function that takes the previous value for that key and returns a new one.
 *
 * The target object *should* be the full object (with all keys defined), and the objects to be merged may be partial.
 * If the target and objects to be merged do not sum up to the full object, then the return type will be invalid.
 */
declare function shallowMerge<T extends {}>(...objects: Array<NoInfer<MergeObject<T>>>): (obj: T) => T;
declare function shallowMerge<const T extends ReadonlyArray<object>>(...objects: IsAny<T> extends true ? never : ValueMergeObjects<T>): <TObj extends object>(obj: PatchTarget<TObj, T[number]>) => TObj;
/**
 * Exactly the same as {@link shallowMerge} but the types are relaxed to accept `undefined` and `null`. You may want
 * to use this version when the target object is potentially undefined but you know that the to-be merged objects will
 * result in a full object. This version is harder for TypeScript to infer the proper type, so you may need to
 * explicitly pass `<T>`.
 */
declare const relaxedMerge: {
  <const T extends ReadonlyArray<object | nil>>(...objects: T): <TObj extends MergeTarget<NonNullable<T[number]>>>(obj: TObj | nil) => TObj & {};
  <T>(...objects: Array<MergeObject<T> | nil>): (obj: T | nil) => T & {};
};
/**
 * Create an immutable updater that replaces one object property with a resolved value.
 *
 * @example
 * ```ts
 * type Size = {
 *   width: number
 *   height: number
 * }
 *
 * const growWidth = objSet<Size>('width', (width) => width + 64)
 * const next = growWidth({ width: 512, height: 768 })
 * // { width: 576, height: 768 }
 * ```
 *
 * @param key - The property key to replace.
 * @param value - The next value, or a function that receives the previous value and returns the next value.
 * @returns A function that copies the input object and replaces the selected property.
 */
declare function objSet<T extends {}>(key: keyof T, value: Resolvable<T[typeof key], [T[typeof key]]>): (obj: T) => T;
//#endregion
//#region src/fp/set.d.ts
/**
 * Add or remove a value from a set.
 */
declare function setCheck<T>(value: T, add: boolean): ID<Set<T>>;
/**
 * Adds one or more values to a set.
 */
declare function setAdd<T>(...values: T[]): ID<Set<T>>;
/**
 * Removes one or more values from a set.
 */
declare function setRemove<T>(...values: T[]): ID<Set<T>>;
//#endregion
export { add, arrayDeleteIndex, arrayDeleteOneValue, arrayDeleteValue, arrayFindAndReplace, arrayInsert, arrayInsertSorted, arrayPop, arrayPush, arrayReject, arraySelect, arraySplice, arrayUnshift, div, mapDelete, mapSet, mapUpdate, mergeMap, mult, objSet, relaxedMerge, setAdd, setCheck, setRemove, shallowMerge, sub };