@sohanemon/utils 6.2.7 → 6.2.10

package/dist/index.d.mts

@@ -0,0 +1,665 @@
+import { ClassValue } from "clsx";
+import * as React from "react";
+
+//#region src/functions/cookie.d.ts
+declare const setClientSideCookie: (name: string, value: string, days?: number, path?: string) => void;
+declare const deleteClientSideCookie: (name: string, path?: string) => void;
+declare const hasClientSideCookie: (name: string) => boolean;
+declare const getClientSideCookie: (name: string) => {
+  value: string | undefined;
+};
+//#endregion
+//#region src/functions/deepmerge.d.ts
+type TAllKeys<T> = T extends any ? keyof T : never;
+type TIndexValue<T, K$1 extends PropertyKey, D = never> = T extends any ? K$1 extends keyof T ? T[K$1] : D : never;
+type TPartialKeys<T, K$1 extends keyof T> = Omit<T, K$1> & Partial<Pick<T, K$1>> extends infer O ? { [P in keyof O]: O[P] } : never;
+type TFunction = (...a: any[]) => any;
+type TPrimitives = string | number | boolean | bigint | symbol | Date | TFunction;
+type TMerged<T> = [T] extends [Array<any>] ? { [K in keyof T]: TMerged<T[K]> } : [T] extends [TPrimitives] ? T : [T] extends [object] ? TPartialKeys<{ [K in TAllKeys<T>]: TMerged<TIndexValue<T, K>> }, never> : T;
+/**
+ * Deeply merges multiple objects, with later sources taking precedence.
+ * Handles nested objects, arrays, and special object types with circular reference detection.
+ *
+ * Features:
+ * - Deep merging of nested objects
+ * - Configurable array merging strategies
+ * - Circular reference detection and handling
+ * - Support for symbols and special objects (Date, RegExp, etc.)
+ * - Type-safe with improved generics
+ * - Optional cloning to avoid mutation
+ * - Custom merge functions for specific keys
+ *
+ * @template T - The target object type
+ * @param target - The target object to merge into
+ * @param sources - Source objects to merge from (can have additional properties)
+ * @param options - Configuration options
+ * @param options.arrayMerge - How to merge arrays: 'replace' (default), 'concat', or 'merge'
+ * @param options.clone - Whether to clone the target (default: true)
+ * @param options.customMerge - Custom merge function for specific keys
+ * @param options.maxDepth - Maximum recursion depth (default: 100)
+ * @returns The merged object with proper typing
+ *
+ * @example
+ * // Basic merge
+ * deepmerge({ a: 1 }, { b: 2 }) // { a: 1, b: 2 }
+ *
+ * @example
+ * // Nested merge
+ * deepmerge({ a: { x: 1 } }, { a: { y: 2 } }) // { a: { x: 1, y: 2 } }
+ *
+ * @example
+ * // Array concat
+ * deepmerge({ arr: [1] }, { arr: [2] }, { arrayMerge: 'concat' }) // { arr: [1, 2] }
+ *
+ * @example
+ * // Sources with extra properties
+ * deepmerge({ a: 1 }, { b: 2, c: 3 }) // { a: 1, b: 2, c: 3 }
+ */
+declare function deepmerge<T extends Record<string, any>, S$1 extends Record<string, any>[]>(target: T, ...sources: S$1): TMerged<T | S$1[number]>;
+declare function deepmerge<T extends Record<string, any>, S$1 extends Record<string, any>[]>(target: T, sources: S$1, options?: {
+  arrayMerge?: 'replace' | 'concat' | 'merge' | ((target: any[], source: any[]) => any[]);
+  clone?: boolean;
+  customMerge?: (key: string | symbol, targetValue: any, sourceValue: any) => any;
+  maxDepth?: number;
+}): TMerged<T | S$1[number]>;
+//#endregion
+//#region src/functions/hydrate.d.ts
+type Hydrate<T> = T extends null ? undefined : T extends (infer U)[] ? Hydrate<U>[] : T extends object ? { [K in keyof T]: Hydrate<T[K]> } : T;
+/**
+ * Converts all `null` values to `undefined` in the data structure recursively.
+ *
+ * @param data - Any input data (object, array, primitive)
+ * @returns Same type as input, but with all nulls replaced by undefined
+ *
+ * @example
+ * hydrate({ a: null, b: 'test' }) // { a: undefined, b: 'test' }
+ * hydrate([null, 1, { c: null }]) // [undefined, 1, { c: undefined }]
+ */
+declare function hydrate<T>(data: T): Hydrate<T>;
+//#endregion
+//#region src/functions/object.d.ts
+/**
+ * Type representing a path split into segments
+ * @template S - The original path string type
+ */
+type SplitPath<S$1 extends string> = S$1 extends `${infer First}.${infer Rest}` ? [First, ...SplitPath<Rest>] : [S$1];
+/**
+ * Recursive type to resolve nested object types based on path
+ * @template T - Current object type
+ * @template K - Array of path segments
+ */
+type GetValue<T, K$1 extends Array<string | number>> = K$1 extends [infer First, ...infer Rest] ? First extends keyof T ? GetValue<T[First], Rest extends Array<string | number> ? Rest : []> : First extends `${number}` ? T extends any[] ? GetValue<T[number], Rest extends Array<string | number> ? Rest : []> : undefined : undefined : T;
+/**
+ * Get a nested value from an object using array path segments
+ * @template T - Object type
+ * @template K - Path segments array type
+ * @template D - Default value type
+ * @param obj - Source object
+ * @param path - Array of path segments
+ * @param defaultValue - Fallback value if path not found
+ * @returns Value at path or default value
+ *
+ * @example
+ * getObjectValue({a: [{b: 1}]}, ['a', 0, 'b']) // 1
+ */
+declare function getObjectValue<T, K$1 extends Array<string | number>, D>(obj: T, path: K$1, defaultValue: D): Exclude<GetValue<T, K$1>, undefined> | D;
+/**
+ * Get a nested value from an object using array path segments
+ * @template T - Object type
+ * @template K - Path segments array type
+ * @param obj - Source object
+ * @param path - Array of path segments
+ * @returns Value at path or undefined
+ *
+ * @example
+ * getObjectValue({a: [{b: 1}]}, ['a', 0, 'b']) // 1
+ */
+declare function getObjectValue<T, K$1 extends Array<string | number>>(obj: T, path: K$1): GetValue<T, K$1> | undefined;
+/**
+ * Get a nested value from an object using dot notation path
+ * @template T - Object type
+ * @template S - Path string literal type
+ * @template D - Default value type
+ * @param obj - Source object
+ * @param path - Dot-separated path string
+ * @param defaultValue - Fallback value if path not found
+ * @returns Value at path or default value
+ *
+ * @example
+ * getObjectValue({a: [{b: 1}]}, 'a.0.b', 2) // 1
+ */
+declare function getObjectValue<T, S$1 extends string, D>(obj: T, path: S$1, defaultValue: D): Exclude<GetValue<T, SplitPath<S$1>>, undefined> | D;
+/**
+ * Get a nested value from an object using dot notation path
+ * @template T - Object type
+ * @template S - Path string literal type
+ * @param obj - Source object
+ * @param path - Dot-separated path string
+ * @returns Value at path or undefined
+ *
+ * @example
+ * getObjectValue({a: [{b: 1}]}, 'a.0.b') // 1
+ */
+declare function getObjectValue<T, S$1 extends string>(obj: T, path: S$1): GetValue<T, SplitPath<S$1>> | undefined;
+/**
+ * Extend an object or function with additional properties while
+ * preserving the original type information.
+ *
+ * Works with both plain objects and callable functions since
+ * functions in JavaScript are objects too.
+ *
+ * @template T The base object or function type
+ * @template P The additional properties type
+ *
+ * @param base - The object or function to extend
+ * @param props - An object containing properties to attach
+ *
+ * @returns The same object/function, augmented with the given properties
+ *
+ * @example
+ * // Extend an object
+ * const obj = extendProps({ a: 1 }, { b: "hello" });
+ * // obj has { a: number; b: string }
+ *
+ * // Extend a function
+ * const fn = (x: number) => x * 2;
+ * const enhanced = extendProps(fn, { name: "doubler" });
+ * // enhanced is callable and also has { name: string }
+ */
+declare function extendProps<T extends object, P$1 extends object>(base: T, props: P$1): T & P$1;
+//#endregion
+//#region src/functions/poll.d.ts
+/**
+ * Repeatedly polls an async `cond` function UNTIL it returns a TRUTHY value,
+ * or until the operation times out or is aborted.
+ *
+ * Designed for waiting on async jobs, external state, or delayed availability.
+ *
+ * @template T The type of the successful result.
+ *
+ * @param cond
+ * A function returning a Promise that resolves to:
+ *   - a truthy value `T` → stop polling and return it
+ *   - falsy/null/undefined → continue polling
+ *
+ * @param options
+ * Configuration options:
+ * - `interval` (number) — Time between polls in ms (default: 5000 ms)
+ * - `timeout` (number) — Max total duration before failing (default: 5 min)
+ * - `jitter` (boolean) — Add small random offset (±10%) to intervals to avoid sync bursts (default: true)
+ * - `signal` (AbortSignal) — Optional abort signal to cancel polling
+ *
+ * @returns
+ * Resolves with the truthy value `T` when successful.
+ * Throws `AbortError` if aborted
+ *
+ * @example
+ * ```ts
+ * const job = await poll(async () => {
+ *   const status = await getJobStatus();
+ *   return status === 'done' ? status : null;
+ * }, { interval: 3000, timeout: 60000 });
+ * ```
+ */
+declare function poll<T>(cond: () => Promise<T | null | false | undefined>, {
+  interval,
+  timeout,
+  jitter,
+  signal
+}?: Partial<{
+  interval: number;
+  timeout: number;
+  signal: AbortSignal;
+  jitter: boolean;
+}>): Promise<T>;
+//#endregion
+//#region src/functions/schedule.d.ts
+type Task = () => Promise<void> | void;
+interface ScheduleOpts {
+  retry?: number;
+  delay?: number;
+  timeout?: number;
+}
+/**
+ * Runs a function asynchronously in the background.
+ * Returns immediately, retries on failure if configured.
+ * Logs total time taken.
+ */
+declare function schedule(task: Task, options?: ScheduleOpts): void;
+//#endregion
+//#region src/functions/shield.d.ts
+/**
+ * A helper to run sync or async operations safely without try/catch.
+ *
+ * Returns a tuple `[error, data]`:
+ * - `error`: the thrown error (if any), otherwise `null`
+ * - `data`: the resolved value (if successful), otherwise `null`
+ *
+ * @example
+ * ```ts
+ * const [err, value] = shield(() => riskySync());
+ * if (err) console.error(err);
+ *
+ * const [asyncErr, result] = await shield(fetchData());
+ * if (asyncErr) throw asyncErr;
+ * ```
+ */
+declare function shield<T, E = Error>(operation: Promise<T>): Promise<[E | null, T | null]>;
+declare function shield<T, E = Error>(operation: () => T): [E | null, T | null];
+//#endregion
+//#region src/functions/utils.d.ts
+/**
+ * Utility to merge class names with Tailwind CSS and additional custom merging logic.
+ *
+ * @param {...ClassValue[]} inputs - Class names to merge.
+ * @returns {string} - A string of merged class names.
+ */
+declare function cn(...inputs: ClassValue[]): string;
+/**
+ * @deprecated Use isLinkActive instead.
+ *
+ * Determines if a navigation link is active based on the current path.
+ *
+ * @param  href - The target URL.
+ * @param  path - The current browser path.
+ * @returns - True if the navigation is active, false otherwise.
+ */
+declare function isNavActive(href: string, path: string): boolean;
+/**
+ * Checks if a link is active, considering optional localization prefixes.
+ *
+ * @param {Object} params - Parameters object.
+ * @param {string} params.path - The target path of the link.
+ * @param {string} params.currentPath - The current browser path.
+ * @param {string[]} [params.locales=['en', 'es', 'de', 'zh', 'bn', 'fr', 'it', 'nl']] - Supported locale prefixes.
+ * @returns {boolean} - True if the link is active, false otherwise.
+ */
+declare function isLinkActive({
+  path,
+  currentPath,
+  locales,
+  exact
+}: {
+  path: string;
+  currentPath: string;
+  locales?: string[];
+  exact?: boolean;
+}): boolean;
+/**
+ * Cleans a file path by removing the `/public/` prefix if present.
+ *
+ * @param  src - The source path to clean.
+ * @returns - The cleaned path.
+ */
+declare function cleanSrc(src: string): string;
+/**
+ * Smoothly scrolls to the top or bottom of a specified container.
+ *
+ * @param  containerSelector - The CSS selector or React ref for the container.
+ * @param  to - Specifies whether to scroll to the top or bottom.
+ */
+declare const scrollTo: (containerSelector: string | React.RefObject<HTMLDivElement>, to: "top" | "bottom") => void;
+/**
+ * Copies a given string to the clipboard.
+ *
+ * @param  value - The value to copy to the clipboard.
+ * @param  [onSuccess=() => {}] - Optional callback executed after successful copy.
+ */
+declare const copyToClipboard: (value: string, onSuccess?: () => void) => void;
+/**
+ * Converts camelCase, PascalCase, kebab-case, snake_case into normal case.
+ *
+ * @param  inputString - The string need to be converted into normal case
+ * @returns - Normal Case
+ */
+declare function convertToNormalCase(inputString: string): string;
+/**
+ * Converts a string to a URL-friendly slug by trimming, converting to lowercase,
+ * replacing diacritics, removing invalid characters, and replacing spaces with hyphens.
+ * @param {string} [str] - The input string to convert.
+ * @returns {string} The generated slug.
+ * @example
+ * convertToSlug("Hello World!"); // "hello-world"
+ * convertToSlug("Déjà Vu"); // "deja-vu"
+ */
+declare const convertToSlug: (str: string) => string;
+/**
+ * Checks if the code is running in a server-side environment.
+ *
+ * @returns - True if the code is executed in SSR (Server-Side Rendering) context, false otherwise
+ */
+declare const isSSR: boolean;
+/**
+ * Converts an SVG string to a Base64-encoded string.
+ *
+ * @param str - The SVG string to encode
+ * @returns - Base64-encoded string representation of the SVG
+ */
+declare const svgToBase64: (str: string) => string;
+/**
+ * Pauses execution for the specified time.
+ *
+ * `signal` allows cancelling the sleep via AbortSignal.
+ *
+ * @param time - Time in milliseconds to sleep (default is 1000ms)
+ * @param signal - Optional AbortSignal to cancel the sleep early
+ * @returns - A Promise that resolves after the specified time or when aborted
+ */
+declare const sleep: (time?: number, signal?: AbortSignal) => Promise<void>;
+type DebouncedFunction<F$1 extends (...args: any[]) => any> = {
+  (...args: Parameters<F$1>): ReturnType<F$1> | undefined;
+  readonly isPending: boolean;
+};
+/**
+ * Creates a debounced function that delays invoking the provided function until
+ * after the specified `wait` time has elapsed since the last invocation.
+ *
+ * If the `immediate` option is set to `true`, the function will be invoked immediately
+ * on the leading edge of the wait interval. Subsequent calls during the wait interval
+ * will reset the timer but not invoke the function until the interval elapses again.
+ *
+ * The returned function includes the `isPending` property to check if the debounce
+ * timer is currently active.
+ *
+ * @typeParam F - The type of the function to debounce.
+ *
+ * @param function_ - The function to debounce.
+ * @param wait - The number of milliseconds to delay (default is 100ms).
+ * @param options - An optional object with the following properties:
+ *   - `immediate` (boolean): If `true`, invokes the function on the leading edge
+ *     of the wait interval instead of the trailing edge.
+ *
+ * @returns A debounced version of the provided function, enhanced with the `isPending` property.
+ *
+ * @throws {TypeError} If the first parameter is not a function.
+ * @throws {RangeError} If the `wait` parameter is negative.
+ *
+ * @example
+ * const log = debounce((message: string) => console.log(message), 200);
+ * log('Hello'); // Logs "Hello" after 200ms if no other call is made.
+ * console.log(log.isPending); // true if the timer is active.
+ */
+declare function debounce<F$1 extends (...args: any[]) => any>(function_: F$1, wait?: number, options?: {
+  immediate: boolean;
+}): DebouncedFunction<F$1>;
+type ThrottledFunction<F$1 extends (...args: any[]) => any> = {
+  (...args: Parameters<F$1>): ReturnType<F$1> | undefined;
+  readonly isPending: boolean;
+};
+/**
+ * Creates a throttled function that invokes the provided function at most once
+ * every `wait` milliseconds.
+ *
+ * If the `leading` option is set to `true`, the function will be invoked immediately
+ * on the leading edge of the throttle interval. If the `trailing` option is set to `true`,
+ * the function will also be invoked at the end of the throttle interval if additional
+ * calls were made during the interval.
+ *
+ * The returned function includes the `isPending` property to check if the throttle
+ * timer is currently active.
+ *
+ * @typeParam F - The type of the function to throttle.
+ *
+ * @param function_ - The function to throttle.
+ * @param wait - The number of milliseconds to wait between invocations (default is 100ms).
+ * @param options - An optional object with the following properties:
+ *   - `leading` (boolean): If `true`, invokes the function on the leading edge of the interval.
+ *   - `trailing` (boolean): If `true`, invokes the function on the trailing edge of the interval.
+ *
+ * @returns A throttled version of the provided function, enhanced with the `isPending` property.
+ *
+ * @throws {TypeError} If the first parameter is not a function.
+ * @throws {RangeError} If the `wait` parameter is negative.
+ *
+ * @example
+ * const log = throttle((message: string) => console.log(message), 200);
+ * log('Hello'); // Logs "Hello" immediately if leading is true.
+ * console.log(log.isPending); // true if the timer is active.
+ */
+declare function throttle<F$1 extends (...args: any[]) => any>(function_: F$1, wait?: number, options?: {
+  leading?: boolean;
+  trailing?: boolean;
+}): ThrottledFunction<F$1>;
+/**
+ * Formats a string by replacing each '%s' placeholder with the corresponding argument.
+ * This function mimics the basic behavior of C's printf for %s substitution.
+ *
+ * It supports both calls like `printf(format, ...args)` and `printf(format, argsArray)`.
+ *
+ * @param format - The format string containing '%s' placeholders.
+ * @param args - The values to substitute into the placeholders, either as separate arguments or as a single array.
+ * @returns The formatted string with all '%s' replaced by the provided arguments.
+ *
+ * @example
+ * ```ts
+ * const message = printf("%s love %s", "I", "Bangladesh");
+ * // message === "I love Bangladesh"
+ *
+ * const arr = ["I", "Bangladesh"];
+ * const message2 = printf("%s love %s", arr);
+ * // message2 === "I love Bangladesh"
+ *
+ * // If there are too few arguments:
+ * const incomplete = printf("Bangladesh is %s %s", "beautiful");
+ * // incomplete === "Bangladesh is beautiful"
+ * ```
+ */
+declare function printf(format: string, ...args: unknown[]): string;
+/**
+ * Merges multiple refs into a single ref callback.
+ *
+ * @param refs - An array of refs to merge.
+ *
+ * @returns - A function that updates the merged ref with the provided value.
+ */
+type MergeRefs = <T>(...refs: Array<React.Ref<T> | undefined>) => React.RefCallback<T>;
+declare const mergeRefs: MergeRefs;
+/**
+ * Navigates to the specified client-side hash without ssr.
+ * use `scroll-margin-top` with css to add margins
+ *
+ * @param id - The ID of the element without # to navigate to.
+ *
+ * @example goToClientSideHash('my-element');
+ */
+declare function goToClientSideHash(id: string, opts?: ScrollIntoViewOptions): void;
+/**
+ * Escapes a string for use in a regular expression.
+ *
+ * @param str - The string to escape
+ * @returns - The escaped string
+ *
+ * @example
+ * const escapedString = escapeRegExp('Hello, world!');
+ * // escapedString === 'Hello\\, world!'
+ */
+declare function escapeRegExp(str: string): string;
+/**
+ * Normalizes a string by:
+ * - Applying Unicode normalization (NFC)
+ * - Optionally removing diacritic marks (accents)
+ * - Optionally trimming leading/trailing non-alphanumeric characters
+ * - Optionally converting to lowercase
+ *
+ * @param str - The string to normalize
+ * @param options - Normalization options
+ * @param options.lowercase - Whether to convert the result to lowercase (default: true)
+ * @param options.removeAccents - Whether to remove diacritic marks like accents (default: true)
+ * @param options.removeNonAlphanumeric - Whether to trim non-alphanumeric characters from the edges (default: true)
+ * @returns The normalized string
+ */
+declare function normalizeText(str?: string | null, options?: {
+  lowercase?: boolean;
+  removeAccents?: boolean;
+  removeNonAlphanumeric?: boolean;
+}): string;
+//#endregion
+//#region src/types/utilities.d.ts
+type Keys<T extends object> = keyof T;
+type Values<T extends object> = T[keyof T];
+type DeepPartial<T> = T extends Function ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
+type SelectivePartial<T, K$1 extends keyof T> = Omit<T, K$1> & Partial<Pick<T, K$1>>;
+type DeepRequired<T> = T extends Function ? T : T extends Array<infer U> ? Array<DeepRequired<U>> : T extends object ? { [K in keyof T]-?: DeepRequired<T[K]> } : T;
+type SelectiveRequired<T, K$1 extends keyof T> = Omit<T, K$1> & Required<Pick<T, K$1>>;
+type Never<T> = { [K in keyof T]: never };
+type Nullable<T> = T extends object ? { [P in keyof T]: Nullable<T[P]> } : T | null;
+type Optional<T> = T extends object ? { [P in keyof T]: Optional<T[P]> } : T | undefined;
+type Nullish<T> = T extends object ? { [P in keyof T]: Nullish<T[P]> } : T | null | undefined;
+type Maybe<T> = T extends object ? { [P in keyof T]?: Nullish<T[P]> } : T | null | undefined;
+type DeepReadonly<T> = T extends Function ? T : T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T;
+type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+type KeysOfType<T, U$1> = { [K in keyof T]: T[K] extends U$1 ? K : never }[keyof T];
+type OmitByType<T, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] };
+type RequiredKeys<T, K$1 extends keyof T> = Omit<T, K$1> & Required<Pick<T, K$1>>;
+type Diff<T, U$1> = Omit<T, keyof U$1> & Omit<U$1, keyof T>;
+type Intersection<T extends object, U$1 extends object> = Pick<T, Extract<keyof T, keyof U$1> & Extract<keyof U$1, keyof T>>;
+type Merge<T extends object, U$1 extends object, I = Diff<T, U$1> & Intersection<U$1, T> & Diff<U$1, T>> = Pick<I, keyof I>;
+type Substract<T extends object, U$1 extends object> = Omit<T, keyof U$1>;
+type AllOrNone<T> = T | { [P in keyof T]?: never };
+type OneOf<T> = { [K in keyof T]: Pick<T, K> }[keyof T];
+type TwoOf<T> = { [K in keyof T]: { [L in Exclude<keyof T, K>]: Pick<T, K | L> }[Exclude<keyof T, K>] }[keyof T];
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type NestedKeyOf<ObjectType extends object, IgnoreKeys extends string = never> = { [Key in keyof ObjectType & string]: Key extends IgnoreKeys ? never : ObjectType[Key] extends object ? ObjectType[Key] extends Array<any> ? Key : `${Key}` | `${Key}.${NestedKeyOf<ObjectType[Key], IgnoreKeys>}` : `${Key}` }[keyof ObjectType & string];
+type Without<T, U$1> = { [P in Exclude<keyof T, keyof U$1>]?: never };
+//#endregion
+//#region src/types/gates.d.ts
+type BUFFER<T> = T;
+type IMPLIES<T, U$1> = T extends U$1 ? true : false;
+type XOR_Binary<T, U$1> = T | U$1 extends object ? (Without<T, U$1> & U$1) | (Without<U$1, T> & T) : T | U$1;
+type XNOR_Binary<T, U$1> = (T & U$1) | (Without<T, U$1> & Without<U$1, T>);
+/**
+ * Computes a type-level AND (all must true) for a tuple of types.
+ *
+ * Truth table for 3 arguments:
+ *
+ * A  B  C  = AND
+ * 1  1  1  = 1
+ * 1  1  0  = 0
+ * 1  0  1  = 0
+ * 1  0  0  = 0
+ * 0  1  1  = 0
+ * 0  1  0  = 0
+ * 0  0  1  = 0
+ * 0  0  0  = 0
+ *
+ * @template T - Tuple of boolean-like types (1/0)
+ */
+type AND<T extends any[]> = T extends [infer F, ...infer R] ? R extends any[] ? F & AND<R> : F : unknown;
+/**
+ * Computes a type-level OR (At least one) for a tuple of types.
+ *
+ * Truth table for 3 arguments:
+ *
+ * A  B  C  = OR
+ * 1  1  1  = 1
+ * 1  1  0  = 1
+ * 1  0  1  = 1
+ * 1  0  0  = 1
+ * 0  1  1  = 1
+ * 0  1  0  = 1
+ * 0  0  1  = 1
+ * 0  0  0  = 0
+ *
+ * @template T - Tuple of boolean-like types (1/0)
+ */
+type OR<T extends any[]> = T extends [infer F, ...infer R] ? R extends any[] ? F | OR<R> : F : never;
+/**
+ * Computes a type-level XOR (only one/odd) for a tuple of types.
+ *
+ * Truth table for 3 arguments:
+ *
+ * A  B  C  = XOR
+ * 1  1  1  = 1
+ * 1  1  0  = 0
+ * 1  0  1  = 0
+ * 1  0  0  = 1
+ * 0  1  1  = 0
+ * 0  1  0  = 1
+ * 0  0  1  = 1
+ * 0  0  0  = 0
+ *
+ * @template T - Tuple of boolean-like types (1/0)
+ */
+type XOR<T extends any[]> = T extends [infer F, ...infer R] ? R extends [infer S, ...infer Rest] ? XOR<[XOR_Binary<F, S>, ...Rest]> : F : never;
+/**
+ * Computes a type-level XNOR (All or None true) for a tuple of types.
+ *
+ * Truth table for 3 arguments:
+ *
+ * A  B  C  = XNOR
+ * 1  1  1  = 0
+ * 1  1  0  = 1
+ * 1  0  1  = 1
+ * 1  0  0  = 0
+ * 0  1  1  = 1
+ * 0  1  0  = 0
+ * 0  0  1  = 0
+ * 0  0  0  = 1
+ *
+ * @template T - Tuple of boolean-like types (1/0)
+ */
+type XNOR<T extends any[]> = T extends [infer F, ...infer R] ? R extends [infer S, ...infer Rest] ? XNOR<[XNOR_Binary<F, S>, ...Rest]> : F : never;
+/**
+ * Computes a type-level NOT for a tuple of types.
+ *
+ * Truth table for 3 arguments:
+ *
+ * A  B  C  = NOT
+ * 1  1  1  = 0
+ * 1  1  0  = 0
+ * 1  0  1  = 0
+ * 1  0  0  = 0
+ * 0  1  1  = 0
+ * 0  1  0  = 0
+ * 0  0  1  = 0
+ * 0  0  0  = 1
+ *
+ * @template T - Tuple of boolean-like types (1/0)
+ */
+type NOT<T> = { [P in keyof T]?: never };
+/**
+ * Computes a type-level NAND for a tuple of types.
+ *
+ * Truth table for 3 arguments:
+ *
+ * A  B  C  = NAND
+ * 1  1  1  = 0
+ * 1  1  0  = 1
+ * 1  0  1  = 1
+ * 1  0  0  = 1
+ * 0  1  1  = 1
+ * 0  1  0  = 1
+ * 0  0  1  = 1
+ * 0  0  0  = 1
+ *
+ * @template T - Tuple of boolean-like types (1/0)
+ */
+type NAND<T extends any[]> = NOT<AND<T>>;
+/**
+ * Computes a type-level NOR for a tuple of types.
+ *
+ * Truth table for 3 arguments:
+ *
+ * A  B  C  = NOR
+ * 1  1  1  = 0
+ * 1  1  0  = 0
+ * 1  0  1  = 0
+ * 1  0  0  = 0
+ * 0  1  1  = 0
+ * 0  1  0  = 0
+ * 0  0  1  = 0
+ * 0  0  0  = 1
+ *
+ * @template T - Tuple of boolean-like types (1/0)
+ */
+type NOR<T extends any[]> = NOT<OR<T>>;
+//#endregion
+//#region src/types/guards.d.ts
+type Primitive = string | number | bigint | boolean | symbol | null | undefined;
+type Falsy = false | '' | 0 | null | undefined;
+declare const isFalsy: (val: unknown) => val is Falsy;
+declare const isNullish: (val: unknown) => val is null | undefined;
+declare const isPrimitive: (val: unknown) => val is Primitive;
+declare function isPlainObject(value: unknown): value is Record<string, any>;
+//#endregion
+export { AND, AllOrNone, BUFFER, DeepPartial, DeepReadonly, DeepRequired, Diff, Falsy, IMPLIES, Intersection, Keys, KeysOfType, Maybe, Merge, MergeRefs, Mutable, NAND, NOR, NOT, NestedKeyOf, Never, Nullable, Nullish, OR, OmitByType, OneOf, Optional, Prettify, Primitive, RequiredKeys, ScheduleOpts, SelectivePartial, SelectiveRequired, Substract, Task, TwoOf, Values, Without, XNOR, XNOR_Binary, XOR, XOR_Binary, cleanSrc, cn, convertToNormalCase, convertToSlug, copyToClipboard, debounce, deepmerge, deleteClientSideCookie, escapeRegExp, extendProps, getClientSideCookie, getObjectValue, goToClientSideHash, hasClientSideCookie, hydrate, isFalsy, isLinkActive, isNavActive, isNullish, isPlainObject, isPrimitive, isSSR, mergeRefs, normalizeText, poll, printf, schedule, scrollTo, setClientSideCookie, shield, sleep, svgToBase64, throttle };