@sohanemon/utils 6.4.7 → 7.0.0

package/dist/index.d.ts

@@ -1,613 +1,295 @@
-import { A as deepmerge, C as Task, D as getObjectValue, E as extendProps, M as getClientSideCookie, N as hasClientSideCookie, O as hydrate, P as setClientSideCookie, S as ScheduleOpts, T as poll, _ as scrollTo, a as convertToNormalCase, b as throttle, c as debounce, d as isLinkActive, f as isNavActive, g as printf, h as normalizeText, i as cn, j as deleteClientSideCookie, k as DeepMergeOptions, l as escapeRegExp, m as mergeRefs, n as MergeRefs, o as convertToSlug, p as isSSR, r as cleanSrc, s as copyToClipboard, t as workerize, u as goToClientSideHash, v as sleep, w as schedule, x as shield, y as svgToBase64 } from "./index-CG2oc6F7.js";
+import { ClassValue } from "clsx";
+import * as React from "react";
+export * from "@ts-utilities/core";
 
-//#region src/types/utilities.d.ts
+//#region src/functions/cookie.d.ts
 
 /**
- * Extracts the keys of an object type as a union type.
+ * Sets a client-side cookie with optional expiration and path.
  *
- * @template T - The object type to extract keys from
- * @returns A union of all keys in the object type
+ * @param name - The name of the cookie
+ * @param value - The value to store in the cookie
+ * @param days - Optional number of days until the cookie expires
+ * @param path - Optional path for the cookie (defaults to '/')
  *
  * @example
- * ```ts
- * type User = { name: string; age: number };
- * type UserKeys = Keys<User>; // 'name' | 'age'
- * ```
- */
-type Keys<T extends object> = keyof T;
-/**
- * Extracts the values of an object type as a union type.
- *
- * @template T - The object type to extract values from
- * @returns A union of all values in the object type
+ * // Set a cookie that expires in 7 days
+ * setClientSideCookie('userId', '12345', 7);
  *
  * @example
- * ```ts
- * type User = { name: string; age: number };
- * type UserValues = Values<User>; // string | number
- * ```
+ * // Set a session cookie (no expiration)
+ * setClientSideCookie('sessionId', 'abc123');
  */
-type Values<T extends object> = T[keyof T];
+declare const setClientSideCookie: (name: string, value: string, days?: number, path?: string) => void;
 /**
- * Makes all properties of an object type optional recursively.
- *
- * This type traverses through nested objects and arrays, making all properties optional.
- * Functions and primitives are left unchanged.
+ * Deletes a client-side cookie by setting its expiration to a past date.
  *
- * @template T - The type to make deeply partial
- * @returns A type with all properties optional recursively
+ * @param name - The name of the cookie to delete
+ * @param path - Optional path for the cookie (defaults to '/')
  *
  * @example
- * ```ts
- * type Config = {
- *   server: { host: string; port: number };
- *   features: string[];
- * };
- *
- * type PartialConfig = DeepPartial<Config>;
- * // {
- * //   server?: { host?: string; port?: number };
- * //   features?: string[];
- * // }
- * ```
+ * // Delete a cookie
+ * deleteClientSideCookie('userId');
  */
-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;
+declare const deleteClientSideCookie: (name: string, path?: string) => void;
 /**
- * Makes only specified properties of an object type optional.
+ * Checks if a client-side cookie exists.
  *
- * @template T - The base object type
- * @template K - The keys to make optional
- * @returns An object type with specified properties optional
+ * @param name - The name of the cookie to check
+ * @returns True if the cookie exists, false otherwise
  *
  * @example
- * ```ts
- * type User = { name: string; age: number; email: string };
- * type PartialUser = SelectivePartial<User, 'age' | 'email'>;
- * // { name: string; age?: number; email?: string }
- * ```
+ * // Check if a cookie exists
+ * if (hasClientSideCookie('userId')) {
+ *   console.log('User is logged in');
+ * }
  */
-type SelectivePartial<T, K$1 extends keyof T> = Omit<T, K$1> & Partial<Pick<T, K$1>>;
+declare const hasClientSideCookie: (name: string) => boolean;
 /**
- * Makes all properties of an object type required recursively.
+ * Retrieves the value of a client-side cookie.
  *
- * This type traverses through nested objects and arrays, making all properties required.
- * Functions and primitives are left unchanged.
- *
- * @template T - The type to make deeply required
- * @returns A type with all properties required recursively
+ * @param name - The name of the cookie to retrieve
+ * @returns An object containing the cookie value, or undefined if not found
  *
  * @example
- * ```ts
- * type PartialConfig = {
- *   server?: { host?: string; port?: number };
- * };
- *
- * type RequiredConfig = DeepRequired<PartialConfig>;
- * // {
- * //   server: { host: string; port: number };
- * // }
- * ```
+ * // Get a cookie value
+ * const { value } = getClientSideCookie('userId');
+ * if (value) {
+ *   console.log('User ID:', value);
+ * }
  */
-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;
+declare const getClientSideCookie: (name: string) => {
+  value: string | undefined;
+};
+//#endregion
+//#region src/functions/utils.d.ts
 /**
- * Makes only specified properties of an object type required.
+ * Utility to merge class names with Tailwind CSS and additional custom merging logic.
  *
- * @template T - The base object type
- * @template K - The keys to make required
- * @returns An object type with specified properties required
+ * @param {...ClassValue[]} inputs - Class names to merge.
+ * @returns {string} - A string of merged class names.
  *
  * @example
  * ```ts
- * type PartialUser = { name?: string; age?: number; email?: string };
- * type RequiredUser = SelectiveRequired<PartialUser, 'name'>;
- * // { name: string; age?: number; email?: string }
+ * cn('px-2 py-1', 'bg-red-500') // 'px-2 py-1 bg-red-500'
+ * cn('px-2', 'px-4') // 'px-4' (Tailwind resolves conflicts)
  * ```
  */
-type SelectiveRequired<T, K$1 extends keyof T> = Omit<T, K$1> & Required<Pick<T, K$1>>;
+declare function cn(...inputs: ClassValue[]): string;
 /**
- * Creates a type where all properties are never (useful for excluding types).
+ * @deprecated Use isLinkActive instead.
  *
- * This can be used to create mutually exclusive types or to exclude certain properties.
+ * Determines if a navigation link is active based on the current path.
  *
- * @template T - The object type to transform
- * @returns An object type with all properties set to never
+ * @param href - The target URL.
+ * @param path - The current browser path.
+ * @returns - True if the navigation is active, false otherwise.
  *
  * @example
  * ```ts
- * type User = { name: string; age: number };
- * type ExcludedUser = Never<User>; // { name: never; age: never }
+ * isNavActive('/about', '/about/team') // true
+ * isNavActive('/contact', '/about') // false
  * ```
  */
-type Never<T> = { [K in keyof T]: never };
+declare function isNavActive(href: string, path: string): boolean;
 /**
- * Makes all properties of an object type nullable recursively.
- *
- * @template T - The type to make nullable
- * @returns A type where all properties can be null
+ * Checks if a link is active, considering optional localization prefixes.
  *
- * @example
- * ```ts
- * type User = { name: string; profile: { age: number } };
- * type NullableUser = Nullable<User>;
- * // { name: string | null; profile: { age: number | null } | null }
- * ```
- */
-type Nullable<T> = T extends object ? { [P in keyof T]: Nullable<T[P]> } : T | null;
-/**
- * Makes all properties of an object type optional (undefined) recursively.
+ * Compares paths while ignoring locale prefixes (e.g., /en/, /fr/) for consistent
+ * navigation highlighting across different language versions of the same page.
  *
- * @template T - The type to make optional
- * @returns A type where all properties can be undefined
+ * @param params - Parameters object.
+ * @param params.path - The target path of the link.
+ * @param params.currentPath - The current browser path.
+ * @param params.locales - Supported locale prefixes to ignore during comparison.
+ * @param params.exact - Whether to require exact path match (default: true). If false, checks if current path starts with target path.
+ * @returns True if the link is active, false otherwise.
  *
  * @example
  * ```ts
- * type User = { name: string; profile: { age: number } };
- * type OptionalUser = Optional<User>;
- * // { name: string | undefined; profile: { age: number | undefined } | undefined }
- * ```
- */
-type Optional<T> = T extends object ? { [P in keyof T]: Optional<T[P]> } : T | undefined;
-/**
- * Makes all properties of an object type nullish (null or undefined) recursively.
+ * // Exact match
+ * isLinkActive({ path: '/about', currentPath: '/about' }) // true
+ * isLinkActive({ path: '/about', currentPath: '/about/team' }) // false
  *
- * @template T - The type to make nullish
- * @returns A type where all properties can be null or undefined
+ * // With locales
+ * isLinkActive({ path: '/about', currentPath: '/en/about' }) // true
+ * isLinkActive({ path: '/about', currentPath: '/fr/about' }) // true
  *
- * @example
- * ```ts
- * type User = { name: string; profile: { age: number } };
- * type NullishUser = Nullish<User>;
- * // { name: string | null | undefined; profile: { age: number | null | undefined } | null | undefined }
+ * // Partial match
+ * isLinkActive({ path: '/blog', currentPath: '/blog/post-1', exact: false }) // true
  * ```
  */
-type Nullish<T> = T extends object ? { [P in keyof T]: Nullish<T[P]> } : T | null | undefined;
+declare function isLinkActive({
+  path,
+  currentPath,
+  locales,
+  exact
+}: {
+  path: string;
+  currentPath: string;
+  locales?: string[];
+  exact?: boolean;
+}): boolean;
 /**
- * Makes all properties of an object type optional and nullish recursively.
+ * Cleans a file path by removing the `/public/` prefix if present.
  *
- * This combines optional properties with nullish values.
+ * Useful when working with static assets that may have been processed
+ * or when normalizing paths between development and production environments.
  *
- * @template T - The type to make maybe
- * @returns A type where all properties are optional and can be null or undefined
+ * @param src - The source path to clean.
+ * @returns The cleaned path with `/public/` prefix removed and whitespace trimmed.
  *
  * @example
  * ```ts
- * type User = { name: string; profile: { age: number } };
- * type MaybeUser = Maybe<User>;
- * // { name?: string | null | undefined; profile?: { age?: number | null | undefined } | null | undefined }
+ * cleanSrc('/public/images/logo.png') // '/images/logo.png'
+ * cleanSrc('images/logo.png') // 'images/logo.png'
+ * cleanSrc('  /public/docs/readme.md  ') // '/docs/readme.md'
  * ```
  */
-type Maybe<T> = T extends object ? { [P in keyof T]?: Nullish<T[P]> } : T | null | undefined;
+declare function cleanSrc(src: string): string;
 /**
- * Makes all properties of an object type readonly recursively.
+ * Smoothly scrolls to the top or bottom of a specified container.
  *
- * This type traverses through nested objects and arrays, making all properties readonly.
- * Functions and primitives are left unchanged.
+ * Provides smooth scrolling animation to either end of a scrollable element.
+ * Accepts either a CSS selector string or a React ref to the container element.
  *
- * @template T - The type to make deeply readonly
- * @returns A type with all properties readonly recursively
+ * @param containerSelector - The CSS selector string or React ref for the scrollable container.
+ * @param to - Direction to scroll: 'top' for top of container, 'bottom' for bottom.
  *
  * @example
  * ```ts
- * type Config = {
- *   server: { host: string; port: number };
- *   features: string[];
- * };
+ * // Scroll to top using selector
+ * scrollTo('.main-content', 'top');
  *
- * type ReadonlyConfig = DeepReadonly<Config>;
- * // {
- * //   readonly server: { readonly host: string; readonly port: number };
- * //   readonly features: readonly string[];
- * // }
+ * // Scroll to bottom using ref
+ * scrollTo(containerRef, 'bottom');
  * ```
  */
-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;
+declare const scrollTo: (containerSelector: string | React.RefObject<HTMLDivElement>, to: "top" | "bottom") => void;
 /**
- * Removes readonly modifier from all properties of an object type recursively.
+ * Copies a given string to the clipboard using the modern Clipboard API.
  *
- * @template T - The readonly type to make mutable
- * @returns A type with all readonly modifiers removed
+ * Safely attempts to copy text to the user's clipboard. Falls back gracefully
+ * if the Clipboard API is not available or if the operation fails.
  *
- * @example
- * ```ts
- * type ReadonlyUser = { readonly name: string; readonly profile: { readonly age: number } };
- * type MutableUser = Mutable<ReadonlyUser>;
- * // { name: string; profile: { age: number } }
- * ```
- */
-type Mutable<T> = { -readonly [P in keyof T]: T[P] };
-/**
- * Extracts keys of an object type that have values of a specific type.
- *
- * @template T - The object type to search
- * @template U - The value type to match
- * @returns A union of keys whose values match the specified type
+ * @param value - The text value to copy to the clipboard.
+ * @param onSuccess - Optional callback executed after successful copy operation.
  *
  * @example
  * ```ts
- * type User = { name: string; age: number; active: boolean };
- * type StringKeys = KeysOfType<User, string>; // 'name'
- * type NumberKeys = KeysOfType<User, number>; // 'age'
+ * copyToClipboard('Hello World!', () => {
+ *   console.log('Text copied successfully');
+ * });
  * ```
  */
-type KeysOfType<T, U$1> = { [K in keyof T]: T[K] extends U$1 ? K : never }[keyof T];
+declare const copyToClipboard: (value: string, onSuccess?: () => void) => void;
 /**
- * Omits properties from an object type that have values of a specific type.
+ * Checks if the code is running in a server-side environment.
  *
- * @template T - The object type to filter
- * @template U - The value type to exclude
- * @returns An object type without properties of the specified value type
+ * @returns - True if the code is executed in SSR (Server-Side Rendering) context, false otherwise
  *
  * @example
  * ```ts
- * type Mixed = { name: string; age: number; active: boolean };
- * type WithoutStrings = OmitByType<Mixed, string>; // { age: number; active: boolean }
+ * if (isSSR) {
+ *   // Server-side only code
+ *   console.log('Running on server');
+ * } else {
+ *   // Client-side only code
+ *   window.addEventListener('load', () => {});
+ * }
  * ```
  */
-type OmitByType<T, U$1> = { [K in keyof T as T[K] extends U$1 ? never : K]: T[K] };
+declare const isSSR: boolean;
 /**
- * Makes specified properties required while keeping others as-is.
+ * Converts an SVG string to a Base64-encoded string.
  *
- * @template T - The base object type
- * @template K - The keys to make required
- * @returns An object type with specified properties required
+ * @param str - The SVG string to encode
+ * @returns - Base64-encoded string representation of the SVG
  *
  * @example
  * ```ts
- * type PartialUser = { name?: string; age?: number; email?: string };
- * type RequiredNameUser = RequiredKeys<PartialUser, 'name'>;
- * // { name: string; age?: number; email?: string }
+ * const svg = '<svg><circle cx="50" cy="50" r="40"/></svg>';
+ * const base64 = svgToBase64(svg);
+ * // Use in data URL: `data:image/svg+xml;base64,${base64}`
  * ```
  */
-type RequiredKeys<T, K$1 extends keyof T> = Omit<T, K$1> & Required<Pick<T, K$1>>;
+declare const svgToBase64: (str: string) => string;
 /**
- * Computes the symmetric difference between two object types.
- *
- * Properties that exist in either T or U but not in both.
+ * Merges multiple refs into a single ref callback.
  *
- * @template T - First object type
- * @template U - Second object type
- * @returns Properties unique to T or U
+ * @param refs - An array of refs to merge.
+ * @returns - A function that updates the merged ref with the provided value.
  *
  * @example
- * ```ts
- * type A = { x: number; y: string };
- * type B = { y: string; z: boolean };
- * type DiffAB = Diff<A, B>; // { x: number; z: boolean }
- * ```
- */
-type Diff<T, U$1> = Omit<T, keyof U$1> & Omit<U$1, keyof T>;
-/**
- * Computes the intersection of two object types (properties present in both).
+ * ```tsx
+ * const MyComponent = () => {
+ *   const ref1 = useRef<HTMLDivElement>(null);
+ *   const ref2 = useRef<HTMLDivElement>(null);
  *
- * @template T - First object type
- * @template U - Second object type
- * @returns Properties that exist in both T and U
+ *   const mergedRef = mergeRefs(ref1, ref2);
  *
- * @example
- * ```ts
- * type A = { x: number; y: string };
- * type B = { y: string; z: boolean };
- * type IntersectionAB = Intersection<A, B>; // { y: string }
+ *   return <div ref={mergedRef}>Content</div>;
+ * };
  * ```
  */
-type Intersection<T extends object, U$1 extends object> = Pick<T, Extract<keyof T, keyof U$1> & Extract<keyof U$1, keyof T>>;
+type MergeRefs = <T>(...refs: Array<React.Ref<T> | undefined>) => React.RefCallback<T>;
+declare const mergeRefs: MergeRefs;
 /**
- * Merges two object types, combining their properties.
+ * Navigates to the specified client-side hash without triggering SSR.
  *
- * @template T - First object type
- * @template U - Second object type
- * @returns A merged object type with properties from both
+ * Smoothly scrolls to an element by ID and updates the URL hash.
+ * Use `scroll-margin-top` CSS property to add margins for fixed headers.
  *
- * @example
- * ```ts
- * type A = { x: number; y: string };
- * type B = { y: boolean; z: string };
- * type Merged = Merge<A, B>; // { x: number; y: boolean; z: string }
- * ```
- */
-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>;
-/**
- * Subtracts properties of one object type from another.
- *
- * @template T - The object type to subtract from
- * @template U - The object type whose properties to subtract
- * @returns T without properties that exist in U
+ * @param id - The ID of the element (without #) to navigate to.
+ * @param opts - Additional options for scrollIntoView.
  *
  * @example
  * ```ts
- * type A = { x: number; y: string; z: boolean };
- * type B = { y: string };
- * type Subtracted = Substract<A, B>; // { x: number; z: boolean }
- * ```
- */
-type Substract<T extends object, U$1 extends object> = Omit<T, keyof U$1>;
-/**
- * Represents either all properties present or none of them.
+ * // Navigate to an element
+ * goToClientSideHash('section-about');
  *
- * Useful for creating mutually exclusive configurations.
- *
- * @template T - The object type
- * @returns Either the full object or an empty object with optional properties
- *
- * @example
- * ```ts
- * type Config = { host: string; port: number };
- * type AllOrNoneConfig = AllOrNone<Config>;
- * // { host: string; port: number } | {}
+ * // With custom scroll behavior
+ * goToClientSideHash('contact', { behavior: 'auto', block: 'center' });
  * ```
  */
-type AllOrNone<T> = T | { [P in keyof T]?: never };
+declare function goToClientSideHash(id: string, opts?: ScrollIntoViewOptions): void;
+//#endregion
+//#region src/functions/worker.d.ts
 /**
- * Represents exactly one property from an object type being present.
+ * Converts a regular function into a workerized version that runs in a Web Worker.
  *
- * Useful for creating discriminated unions or mutually exclusive options.
+ * This provides the ultimate DX for Web Workers - just write a normal function
+ * and "workerize" it to run in the background without blocking the UI.
  *
- * @template T - The object type
- * @returns A union where only one property is present at a time
+ * @param fn - The function to workerize
+ * @returns A function that calls the original function in a worker and returns a Promise
  *
  * @example
  * ```ts
- * type Action = { type: 'create'; payload: string } | { type: 'update'; id: number };
- * type OneAction = OneOf<Action>;
- * // { type: 'create'; payload: string } | { type: 'update'; id: number }
- * ```
- */
-type OneOf<T> = { [K in keyof T]: Pick<T, K> }[keyof T];
-/**
- * Represents exactly two properties from an object type being present.
- *
- * @template T - The object type
- * @returns A union where exactly two properties are present at a time
- *
- * @example
- * ```ts
- * type Config = { a: number; b: string; c: boolean };
- * type TwoConfig = TwoOf<Config>;
- * // { a: number; b: string } | { a: number; c: boolean } | { b: string; c: boolean }
- * ```
- */
-type TwoOf<T> = { [K in keyof T]: { [L in Exclude<keyof T, K>]: Pick<T, K | L> }[Exclude<keyof T, K>] }[keyof T];
-/**
- * Prettifies a complex type by expanding it for better readability in tooltips.
- *
- * This type doesn't change the runtime type but helps with IntelliSense display.
+ * // Define a normal function
+ * function fibonacci(n: number): number {
+ *   if (n <= 1) return n;
+ *   return fibonacci(n - 1) + fibonacci(n - 2);
+ * }
  *
- * @template T - The type to prettify
- * @returns The same type but expanded for better readability
+ * // Workerize it
+ * const workerizedFib = workerize(fibonacci);
  *
- * @example
- * ```ts
- * type Complex = { a: string } & { b: number };
- * type PrettyComplex = Prettify<Complex>; // Shows as { a: string; b: number }
+ * // Use like a normal async function!
+ * const result = await workerizedFib(35);
+ * console.log(result); // Works just like the original function
  * ```
- */
-type Prettify<T> = T extends infer U ? U extends object ? { [K in keyof U]: U[K] } & {} : U : never;
-/**
- * Extracts all nested keys of an object type as dot-separated strings.
- *
- * @template ObjectType - The object type to extract nested keys from
- * @template IgnoreKeys - Keys to ignore during extraction
- * @returns A union of dot-separated string paths
  *
  * @example
  * ```ts
- * type User = {
- *   name: string;
- *   profile: { age: number; address: { city: string } };
- *   tags: string[];
- * };
- *
- * type UserPaths = NestedKeyOf<User>;
- * // 'name' | 'profile' | 'profile.age' | 'profile.address' | 'profile.address.city' | 'tags'
- * ```
- */
-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];
-/**
- * Creates a type that excludes properties present in another type.
- *
- * This is useful for creating mutually exclusive types.
- *
- * @template T - The base type
- * @template U - The type whose properties to exclude
- * @returns A type with properties from T that are not in U
+ * // Works with any function signature
+ * const sumArray = workerize((arr: number[]) =>
+ *   arr.reduce((a, b) => a + b, 0)
+ * );
  *
- * @example
- * ```ts
- * type A = { x: number; y: string };
- * type B = { y: string };
- * type WithoutB = Without<A, B>; // { x?: never }
+ * const result = await sumArray([1, 2, 3, 4, 5]); // 15
  * ```
  */
-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
-/**
- * Represents primitive JavaScript types including null and undefined.
- */
-type Primitive = string | number | bigint | boolean | symbol | null | undefined;
-/**
- * Represents all falsy values in JavaScript.
- */
-type Falsy = false | '' | 0 | null | undefined;
-/**
- * Type guard that checks if a value is falsy.
- *
- * @param val - The value to check
- * @returns True if the value is falsy, false otherwise
- *
- * @example
- * if (isFalsy(value)) {
- *   console.log('Value is falsy');
- * }
- */
-declare const isFalsy: (val: unknown) => val is Falsy;
-/**
- * Type guard that checks if a value is null or undefined.
- *
- * @param val - The value to check
- * @returns True if the value is null or undefined, false otherwise
- *
- * @example
- * if (isNullish(value)) {
- *   console.log('Value is null or undefined');
- * }
- */
-declare const isNullish: (val: unknown) => val is null | undefined;
-/**
- * Type guard that checks if a value is a primitive type.
- *
- * @param val - The value to check
- * @returns True if the value is a primitive, false otherwise
- *
- * @example
- * if (isPrimitive(value)) {
- *   console.log('Value is a primitive type');
- * }
- */
-declare const isPrimitive: (val: unknown) => val is Primitive;
-/**
- * Type guard that checks if a value is a plain object (not an array, function, etc.).
- *
- * @param value - The value to check
- * @returns True if the value is a plain object, false otherwise
- *
- * @example
- * if (isPlainObject(value)) {
- *   console.log('Value is a plain object');
- * }
- */
-declare function isPlainObject(value: unknown): value is Record<string, any>;
+declare function workerize<T extends (...args: any[]) => any>(fn: T): (...args: Parameters<T>) => Promise<ReturnType<T>>;
 //#endregion
-export { AND, AllOrNone, BUFFER, DeepMergeOptions, 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, workerize };
+export { MergeRefs, cleanSrc, cn, copyToClipboard, deleteClientSideCookie, getClientSideCookie, goToClientSideHash, hasClientSideCookie, isLinkActive, isNavActive, isSSR, mergeRefs, scrollTo, setClientSideCookie, svgToBase64, workerize };