@hairy/utils 1.47.0 → 1.50.0

package/dist/index.d.mts

@@ -0,0 +1,823 @@
+import _Bignumber from "bignumber.js";
+import { chunk, clone, cloneDeep, cloneDeepWith, cloneWith, concat, debounce, find, get, groupBy, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith, isError, isFunction, isInteger, isMap, isMatch, isMatchWith, isNaN, isNative, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp as isRegexp, isSet, isString, isSymbol, isUndefined, isWeakMap, isWeakSet, join, keyBy, keys, max, maxBy, merge, mergeWith, min, minBy, omit, omitBy, once, pick, pickBy, range, set, truncate, uniq, uniqBy, uniqWith, values } from "lodash-es";
+
+//#region src/browser/file.d.ts
+interface OpenFilePickerOptions {
+  /**
+   * select multiple files
+   */
+  multiple?: boolean;
+  /**
+   * Choose the default format for the file
+   */
+  accept?: string;
+}
+/**
+ * Select multiple files
+ */
+declare function openFilePicker(option?: OpenFilePickerOptions): Promise<File[]>;
+/** @deprecated use openFilePicker */
+declare const showOpenFilePicker: typeof openFilePicker;
+interface OpenImagePickerOptions {
+  /**
+   * select multiple images
+   */
+  multiple?: boolean;
+}
+/**
+ * Select multiple images
+ */
+declare function openImagePicker(options?: OpenImagePickerOptions): Promise<File[]>;
+/** @deprecated use openImagePicker */
+declare const selectImages: typeof openImagePicker;
+declare const showOpenImagePicker: typeof openImagePicker;
+/**
+ * Generate Blob | string file and download it
+ * @param data Blob data, or string
+ * @param name file name
+ */
+declare function downloadBlobFile(data: Blob | string, name: string): void;
+/**
+ * Download network files
+ * @param url Download link
+ * @param name file name
+ */
+declare function downloadUrlFile(url: string, name?: string): void;
+/** @deprecated use downloadUrlFile */
+declare const downloadNetworkFile: typeof downloadUrlFile;
+type ReaderType = 'readAsArrayBuffer' | 'readAsBinaryString' | 'readAsDataURL' | 'readAsText';
+/**
+ * Read File file
+ * @param formType Transform type
+ * @param file file object
+ */
+declare function readFileReader<T extends ReaderType>(formType: T, file: File): Promise<T extends "readAsArrayBuffer" ? ArrayBuffer : string>;
+//#endregion
+//#region src/typings/atom.d.ts
+type Numeric = string | number | bigint;
+type Numberish = Numeric | {
+  toString: (...args: any[]) => string;
+} | undefined | null;
+interface DynamicObject {
+  [key: string]: any;
+}
+interface NumericObject {
+  [key: string]: Numeric;
+}
+interface StringObject {
+  [key: string]: string;
+}
+interface NumberObject {
+  [key: string]: string;
+}
+interface SymbolObject {
+  [key: string]: symbol;
+}
+type Key = string | number | symbol;
+type BooleanLike = any;
+type Noop = (...args: any[]) => any;
+//#endregion
+//#region src/typings/util.d.ts
+/**
+ *  Any type that can be used where a big number is needed.
+ */
+type Awaitable<T> = T | PromiseLike<T>;
+type Arrayable<T> = T | T[];
+type Promisify<T> = Promise<Awaited<T>>;
+type ElementOf<T> = T extends (infer E)[] ? E : never;
+type Nullable<T> = T | null | undefined;
+type Fn<T = void> = () => T;
+type AnyFn = (...args: any[]) => any;
+type PromiseFn = (...args: any[]) => Promise<any>;
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+type IsAny<T> = IfAny<T, true, false>;
+type ConstructorType<T = void> = new (...args: any[]) => T;
+type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
+type PromiseType<P extends PromiseLike<any>> = P extends PromiseLike<infer T> ? T : never;
+type BrowserNativeObject = Date | FileList | File;
+type Option<L extends Key = 'label', V extends Key = 'value', C extends Key = 'children'> = { [P in L]?: string } & { [P in V]?: Numeric } & { [P in C]?: Option<L, V, C>[] };
+type OmitBy<T, V> = { [K in keyof T as T[K] extends V ? never : K]: T[K] };
+type PickBy<T, U> = { [K in keyof T as T[K] extends U ? K : never]: T[K] };
+type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+type Assign<T, U> = Omit<T, keyof U> & U;
+type NonUndefined<T> = T extends undefined ? never : T;
+//#endregion
+//#region src/typings/deep.d.ts
+type DeepReadonly<T> = { readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P] };
+type DeepRequired<T> = { [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P] };
+type DeepPartial<T> = { [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P] };
+type DeepReplace<T, K = unknown, V = unknown> = { [P in keyof T]: K extends P ? V : DeepReplace<T[P], K, V> };
+type DeepKeyof<T> = T extends object ? keyof T | DeepKeyof<T[keyof T]> : never;
+type MergeInsertions<T> = T extends object ? { [K in keyof T]: MergeInsertions<T[K]> } : T;
+type DeepMerge<F, S> = MergeInsertions<{ [K in keyof F | keyof S]: K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never }>;
+type DeepMap<T, V, ST = BrowserNativeObject> = IsAny<T> extends true ? any : T extends ST ? V : T extends object ? { [K in keyof T]: DeepMap<NonUndefined<T[K]>, V, ST> } : V;
+//#endregion
+//#region src/browser/util.d.ts
+declare function redirectTo(url: string, target?: string): void;
+declare function dialsPhone(phoneNumber: string): void;
+declare function on<T extends Window | Document | HTMLElement | EventTarget>(obj: T | null, ...args: Parameters<T['addEventListener']> | [string, Fn | null, ...any]): void;
+declare function off<T extends Window | Document | HTMLElement | EventTarget>(obj: T | null, ...args: Parameters<T['removeEventListener']> | [string, Fn | null, ...any]): void;
+//#endregion
+//#region src/is/index.d.ts
+declare const isBrowser: () => boolean;
+declare const isWeex: () => boolean;
+declare const isIE: () => boolean | "";
+declare const isIE9: () => boolean | "";
+declare const isIE11: () => boolean;
+declare const isEdge: () => boolean | "";
+declare const isAndroid: () => boolean;
+declare const isIOS: () => boolean;
+declare const isChrome: () => boolean | "";
+declare const isPhantomJS: () => boolean | "";
+declare const isFF: () => false | RegExpMatchArray | null;
+declare const isMobile: () => boolean;
+declare const isFormData: (value: any) => value is FormData;
+declare const isWindow: (value: any) => value is Window;
+declare const isTruthy: <T>(value: T) => value is NonNullable<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/change-case@5.4.4/node_modules/change-case/dist/index.d.ts
+/**
+ * Supported locale values. Use `false` to ignore locale.
+ * Defaults to `undefined`, which uses the host environment.
+ */
+type Locale = string[] | string | false | undefined;
+/**
+ * Options used for converting strings to pascal/camel case.
+ */
+interface PascalCaseOptions extends Options {
+  mergeAmbiguousCharacters?: boolean;
+}
+/**
+ * Options used for converting strings to any case.
+ */
+interface Options {
+  locale?: Locale;
+  split?: (value: string) => string[];
+  /** @deprecated Pass `split: splitSeparateNumbers` instead. */
+  separateNumbers?: boolean;
+  delimiter?: string;
+  prefixCharacters?: string;
+  suffixCharacters?: string;
+}
+/**
+ * Convert a string to space separated lower case (`foo bar`).
+ */
+declare function noCase(input: string, options?: Options): string;
+/**
+ * Convert a string to camel case (`fooBar`).
+ */
+declare function camelCase(input: string, options?: PascalCaseOptions): string;
+/**
+ * Convert a string to pascal case (`FooBar`).
+ */
+declare function pascalCase(input: string, options?: PascalCaseOptions): string;
+/**
+ * Convert a string to pascal snake case (`Foo_Bar`).
+ */
+declare function pascalSnakeCase(input: string, options?: Options): string;
+/**
+ * Convert a string to capital case (`Foo Bar`).
+ */
+declare function capitalCase(input: string, options?: Options): string;
+/**
+ * Convert a string to constant case (`FOO_BAR`).
+ */
+declare function constantCase(input: string, options?: Options): string;
+/**
+ * Convert a string to dot case (`foo.bar`).
+ */
+declare function dotCase(input: string, options?: Options): string;
+/**
+ * Convert a string to kebab case (`foo-bar`).
+ */
+declare function kebabCase(input: string, options?: Options): string;
+/**
+ * Convert a string to path case (`foo/bar`).
+ */
+declare function pathCase(input: string, options?: Options): string;
+/**
+ * Convert a string to path case (`Foo bar`).
+ */
+declare function sentenceCase(input: string, options?: Options): string;
+/**
+ * Convert a string to snake case (`foo_bar`).
+ */
+declare function snakeCase(input: string, options?: Options): string;
+/**
+ * Convert a string to header case (`Foo-Bar`).
+ */
+declare function trainCase(input: string, options?: Options): string;
+//#endregion
+//#region src/number/index.d.ts
+declare const DEFAULT_BIGNUM_CONFIG: _Bignumber.Config;
+declare namespace Bignumber {
+  type RoundingMode = _Bignumber.RoundingMode;
+  type Format = _Bignumber.Format;
+  type Config = _Bignumber.Config;
+  type Instance = _Bignumber.Instance;
+  type Value = _Bignumber.Value;
+}
+declare const Bignumber: typeof _Bignumber;
+/**
+ * export bignumber.js
+ *
+ * do not use Bignumber directly, use bignumber function instead
+ */
+declare const BIG_INTS: Record<Delimiter, {
+  v: number;
+  d: number;
+  n: string;
+}>;
+type Delimiter = 'k' | 'm' | 'b' | 't';
+interface DecimalOptions {
+  d?: number;
+  r?: Bignumber.RoundingMode;
+}
+interface FormatGroupOptions {
+  size?: number;
+  symbol?: string;
+}
+interface FormatNumericOptions {
+  delimiters?: Delimiter[] | false;
+  rounding?: Bignumber.RoundingMode;
+  decimals?: number;
+  decimalsZero?: boolean;
+  default?: string;
+  format?: Bignumber.Format;
+}
+declare function bignumber(n?: Numberish, base?: number): _Bignumber;
+declare namespace bignumber {
+  var clone: (config: Bignumber.Config) => typeof _Bignumber;
+}
+declare function gte(a: Numberish, b: Numberish): boolean;
+declare function gt(a: Numberish, b: Numberish): boolean;
+declare function lte(a: Numberish, b: Numberish): boolean;
+declare function lt(a: Numberish, b: Numberish): boolean;
+declare function plus(array: Numberish[], options?: DecimalOptions): string;
+declare function divide(array: Numberish[], options?: DecimalOptions): string;
+declare function multiply(array: Numberish[], options?: DecimalOptions): string;
+declare function average(array: Numberish[], options?: DecimalOptions): string;
+/**
+ * calculate percentage
+ * @param total
+ * @param count
+ */
+declare function percentage(total: Numberish, count: Numberish, options?: DecimalOptions): string;
+/**
+ * leading zeros
+ * @param value
+ * @param n
+ * @param type
+ */
+declare function zerofill(value: Numberish, n?: number, type?: 'positive' | 'reverse'): Numberish;
+declare function zeroRemove(value: Numberish, convert?: boolean): string;
+/**
+ * format as a positive integer
+ * @param value
+ */
+declare function integer(value: Numberish): string;
+/**
+ * retain n decimal places
+ * @param value
+ * @param n
+ */
+declare function decimal(value: Numberish, n?: number): string;
+declare function parseNumeric(num: Numberish, delimiters?: Delimiter[]): {
+  v: number;
+  d: number;
+  n: string;
+};
+/**
+ * format number thousand separator and unit
+ * @param value
+ * @param options
+ */
+declare function formatNumeric(value?: Numberish, options?: FormatNumericOptions): string;
+//#endregion
+//#region src/string/index.d.ts
+/**
+ * Intercept front and back characters, hide middle characters
+ * @param value
+ * @param mode
+ * @param symbol
+ */
+declare function cover(value: string, mode: [number, number, number], symbol?: string): string;
+/**
+ * Shortens an identifier string by showing only the beginning and end portions,
+ * with ellipsis in the middle. Suitable for various types of identifiers like
+ * IPFS CID, transaction hashes, EVM addresses, user IDs, etc.
+ *
+ * @param value - The identifier string to shorten
+ * @param startWith - Number of characters to show at the start (default: 6)
+ * @param endWith - Number of characters to show at the end (default: 6)
+ * @returns Shortened identifier string with ellipsis, or empty string if id is null/undefined
+ */
+declare function shortenId(value: string | null | undefined, startWith?: number, endWith?: number): string;
+/**
+ * Replace backslash to slash
+ *
+ * @category String
+ */
+declare function slash(str: string): string;
+/**
+ * Ensure prefix of a string
+ *
+ * @category String
+ */
+declare function ensurePrefix(prefix: string, str: string): string;
+/**
+ * Ensure suffix of a string
+ *
+ * @category String
+ */
+declare function ensureSuffix(suffix: string, str: string): string;
+/**
+ * Dead simple template engine, just like Python's `.format()`
+ * Support passing variables as either in index based or object/name based approach
+ * While using object/name based approach, you can pass a fallback value as the third argument
+ *
+ * @category String
+ * @example
+ * ```
+ * const result = template(
+ *   'Hello {0}! My name is {1}.',
+ *   'Inès',
+ *   'Anthony'
+ * ) // Hello Inès! My name is Anthony.
+ * ```
+ *
+ * ```
+ * const result = namedTemplate(
+ *   '{greet}! My name is {name}.',
+ *   { greet: 'Hello', name: 'Anthony' }
+ * ) // Hello! My name is Anthony.
+ * ```
+ *
+ * const result = namedTemplate(
+ *   '{greet}! My name is {name}.',
+ *   { greet: 'Hello' }, // name isn't passed hence fallback will be used for name
+ *   'placeholder'
+ * ) // Hello! My name is placeholder.
+ * ```
+ */
+declare function template(str: string, object: Record<string | number, any>, fallback?: string | ((key: string) => string)): string;
+declare function template(str: string, ...args: (string | number | bigint | undefined | null)[]): string;
+/**
+ * Remove common leading whitespace from a template string.
+ * Will also remove empty lines at the beginning and end.
+ * @category string
+ * @example
+ * ```ts
+ * const str = unindent`
+ *   if (a) {
+ *     b()
+ *   }
+ * `
+ * ```
+ */
+declare function unindent(str: TemplateStringsArray | string): string;
+//#endregion
+//#region src/util/compose-promise.d.ts
+type UF$1<VT, RT> = (value: VT) => RT | PromiseLike<RT>;
+type Composed<VT, RT> = (value?: VT) => Promise<RT>;
+/**
+ * Compose promise-returning & async fns into a reusable pipeline.
+ *
+ * @param ...fns - Iterated over sequentially when returned `function` is called.
+ * @returns The `fns` are applied from right to left.
+ *
+ * @example
+ * ```
+ * const addUnicorn = async string => `${string} Unicorn`;
+ * const addRainbow = async string => `${string} Rainbow`;
+ *
+ * const pipeline = pCompose(addRainbow, addUnicorn);
+ *
+ * console.log(await pipeline('❤️'));
+ * //=> '❤️ Unicorn Rainbow'
+ * ```
+ */
+declare function pCompose<VT, RT>(f1: UF$1<VT, RT>): Composed<VT, RT>;
+declare function pCompose<VT, R1, RT>(f1: UF$1<R1, RT>, f2: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, RT>(f1: UF$1<R2, RT>, f2: UF$1<R1, R2>, f3: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, RT>(f1: UF$1<R3, RT>, f2: UF$1<R2, R3>, f3: UF$1<R1, R2>, f4: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, RT>(f1: UF$1<R4, RT>, f2: UF$1<R3, R4>, f3: UF$1<R2, R3>, f4: UF$1<R1, R2>, f5: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, R5, RT>(f1: UF$1<R5, RT>, f2: UF$1<R4, R5>, f3: UF$1<R3, R4>, f4: UF$1<R2, R3>, f5: UF$1<R1, R2>, f6: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, R5, R6, RT>(f1: UF$1<R6, RT>, f2: UF$1<R5, R6>, f3: UF$1<R4, R5>, f4: UF$1<R3, R4>, f5: UF$1<R2, R3>, f6: UF$1<R1, R2>, f7: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, R5, R6, R7, RT>(f1: UF$1<R7, RT>, f2: UF$1<R6, R7>, f3: UF$1<R5, R6>, f4: UF$1<R4, R5>, f5: UF$1<R3, R4>, f6: UF$1<R2, R3>, f7: UF$1<R1, R2>, f8: UF$1<VT, R1>): Composed<VT, RT>;
+declare function pCompose<VT, R1, R2, R3, R4, R5, R6, R7, R8, RT>(f1: UF$1<R8, RT>, f2: UF$1<R7, R8>, f3: UF$1<R6, R7>, f4: UF$1<R5, R6>, f5: UF$1<R4, R5>, f6: UF$1<R3, R4>, f7: UF$1<R2, R3>, f8: UF$1<R1, R2>, f9: UF$1<VT, R1>): Composed<VT, RT>;
+//#endregion
+//#region src/util/compose.d.ts
+type Fn$1<V, R> = (x: V) => R;
+type Q<T, V> = (...args: T) => V;
+/**
+ * Performs function composition in RTL (Right To Left) direction.
+ *
+ * Our `compose` and `compose.promise` implementation supports N arguments. But you can use only 10 in
+ * TypeScript, because it doesn't support **Variadic Kinds** and we explicitly
+ * have to define the type of all the possible usages as method overloads.
+ *
+ * @example
+ * const normalizeWhiteSpaces = text => name.replace(/\s+/g, ' ').trim();
+ *
+ * const getInitials = compose(
+ *   initials => initials.join('').toLocaleUpperCase(),
+ *   name => name.split(' ').map(name => name.charAt(0)),
+ *   normalizeWhiteSpaces
+ * );
+ *
+ * getInitials('Vitor Luiz Cavalcanti');
+ * //=> "VLC"
+ *
+ * @param fn - An arity 1 function, except the last one which can have arity N.
+ * @param fns - Functions of arity 1. Each one's result is next's argument.
+ *
+ * @example
+ *
+ * const addUnicorn = async string => `${string} Unicorn`;
+ * const addRainbow = async string => `${string} Rainbow`;
+ *
+ * const pipeline = compose.promise(addRainbow, addUnicorn);
+ *
+ * console.log(await pipeline('❤️'));
+ * //=> '❤️ Unicorn Rainbow'
+ * @param ...fns - Iterated over sequentially when returned `function` is called.
+ * @returns The `fns` functions are applied from right to left.
+ */
+declare function compose<T, V0, V1>(fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V1>;
+declare function compose<T, V0, V1, V2>(fn2: Fn$1<V1, V2>, fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V2>;
+declare function compose<T, V0, V1, V2, V3>(fn3: Fn$1<V2, V3>, fn2: Fn$1<V1, V2>, fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V3>;
+declare function compose<T, V0, V1, V2, V3, V4>(fn4: Fn$1<V3, V4>, fn3: Fn$1<V2, V3>, fn2: Fn$1<V1, V2>, fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V4>;
+declare function compose<T, V0, V1, V2, V3, V4, V5>(fn5: Fn$1<V4, V5>, fn4: Fn$1<V3, V4>, fn3: Fn$1<V2, V3>, fn2: Fn$1<V1, V2>, fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V5>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6>(fn6: Fn$1<V5, V6>, fn5: Fn$1<V4, V5>, fn4: Fn$1<V3, V4>, fn3: Fn$1<V2, V3>, fn2: Fn$1<V1, V2>, fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V6>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6, V7>(fn7: Fn$1<V6, V7>, fn6: Fn$1<V5, V6>, fn5: Fn$1<V4, V5>, fn4: Fn$1<V3, V4>, fn3: Fn$1<V2, V3>, fn2: Fn$1<V1, V2>, fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V7>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6, V7, V8>(fn8: Fn$1<V7, V8>, fn7: Fn$1<V6, V7>, fn6: Fn$1<V5, V6>, fn5: Fn$1<V4, V5>, fn4: Fn$1<V3, V4>, fn3: Fn$1<V2, V3>, fn2: Fn$1<V1, V2>, fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V8>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9>(fn9: Fn$1<V8, V9>, fn8: Fn$1<V7, V8>, fn7: Fn$1<V6, V7>, fn6: Fn$1<V5, V6>, fn5: Fn$1<V4, V5>, fn4: Fn$1<V3, V4>, fn3: Fn$1<V2, V3>, fn2: Fn$1<V1, V2>, fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V9>;
+declare function compose<T, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10>(fn10: Fn$1<V9, V10>, fn9: Fn$1<V8, V9>, fn8: Fn$1<V7, V8>, fn7: Fn$1<V6, V7>, fn6: Fn$1<V5, V6>, fn5: Fn$1<V4, V5>, fn4: Fn$1<V3, V4>, fn3: Fn$1<V2, V3>, fn2: Fn$1<V1, V2>, fn1: Fn$1<V0, V1>, fn0: Q<T, V0>): Q<T, V10>;
+declare namespace compose {
+  var promise: typeof pCompose;
+}
+//#endregion
+//#region src/util/deferred.d.ts
+/**
+ * A deferred promise.
+ * @param T - The type of the value.
+ * @returns The deferred promise.
+ * @example
+ * ```ts
+ * const deferred = new Deferred()
+ * deferred.resolve('value')
+ * ```
+ */
+declare class Deferred<T> extends Promise<T> {
+  resolve: (value?: T) => Deferred<T>;
+  reject: (reason?: any) => Deferred<T>;
+  constructor(executor?: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void);
+}
+//#endregion
+//#region src/util/delay.d.ts
+/**
+ * Delay for a given number of milliseconds.
+ * @param ms - The number of milliseconds to delay.
+ * @returns A promise that resolves after the given number of milliseconds.
+ * @example
+ * ```ts
+ * delay(1000).then(() => { console.log('1 second') })
+ * ```
+ */
+declare function delay(ms: number): Promise<void>;
+//#endregion
+//#region src/util/ghost.d.ts
+type Ghost<T extends object> = T & {
+  enabled: boolean;
+  resolve: (value: T) => void;
+};
+declare function ghost<T extends object>(strictMessage?: string): Ghost<T>;
+//#endregion
+//#region src/util/json.d.ts
+declare function tryParseJson<T = any>(text: string | undefined | null): T | undefined;
+//#endregion
+//#region src/util/loop.d.ts
+/**
+ * A function that performs a loop operation with delay control.
+ * @template T - The return type of the loop function (defaults to void)
+ * @param next - A function that schedules the next iteration after a delay (in milliseconds)
+ * @returns A promise that resolves with the result of type T
+ */
+type Looper<T = void> = (next: (ms: number) => Promise<T>) => Promise<T>;
+declare function loop_return<T = void>(fn: Looper<T>): Promise<T>;
+/**
+ * Creates a cancellable loop that executes repeatedly with delays.
+ * Returns a cancel function that can be called to stop the loop.
+ * The loop will not execute further iterations after cancellation.
+ *
+ * @param fn - The loop function that receives a `next` callback to schedule the next iteration
+ * @returns A cancel function that stops the loop when called
+ *
+ * @example loop
+ * ```ts
+ * const cancel = loop(async (next) => {
+ *   console.log('tick')
+ *   await next(1000) // Wait 1 second before next iteration
+ * })
+ *
+ * // Stop the loop after 5 seconds
+ * setTimeout(cancel, 5000)
+ *```
+ *  @example loop.return
+ * ```ts
+ * const result = await loop.return(async (next) => {
+ *   if (condition) {
+ *     return 'done'
+ *   }
+ *   await next(1000)
+ * })
+ * console.log(result)
+ * ```
+ */
+declare function loop(fn: Looper<void>): Fn;
+declare namespace loop {
+  var _a: typeof loop_return;
+  export { _a as return };
+}
+//#endregion
+//#region src/util/noop.d.ts
+declare const noop: (...args: any) => any;
+//#endregion
+//#region src/util/pipe-promise.d.ts
+type UF<VT, RT> = (value: VT) => RT | PromiseLike<RT>;
+type Pipeline<VT, RT> = (value?: VT) => Promise<RT>;
+/**
+ * Compose promise-returning & async fns into a reusable pipeline.
+ *
+ * @param ...input - Iterated over sequentially when returned `function` is called.
+ * @returns The `input` fns are applied from left to right.
+ *
+ * @example
+ * ```
+ * const addUnicorn = async string => `${string} Unicorn`;
+ * const addRainbow = async string => `${string} Rainbow`;
+ *
+ * const pipeline = pipe.promise(addUnicorn, addRainbow);
+ *
+ * console.log(await pipeline('❤️'));
+ * //=> '❤️ Unicorn Rainbow'
+ * ```
+ */
+declare function pPipe<VT, RT>(f1: UF<VT, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, RT>(f1: UF<VT, R1>, f2: UF<R1, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, R5, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, R5>, f6: UF<R5, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, R5, R6, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, R5>, f6: UF<R5, R6>, f7: UF<R6, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, R5, R6, R7, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, R5>, f6: UF<R5, R6>, f7: UF<R6, R7>, f8: UF<R7, RT>): Pipeline<VT, RT>;
+declare function pPipe<VT, R1, R2, R3, R4, R5, R6, R7, R8, RT>(f1: UF<VT, R1>, f2: UF<R1, R2>, f3: UF<R2, R3>, f4: UF<R3, R4>, f5: UF<R4, R5>, f6: UF<R5, R6>, f7: UF<R6, R7>, f8: UF<R7, R8>, f9: UF<R8, RT>): Pipeline<VT, RT>;
+//#endregion
+//#region src/util/pipe.d.ts
+/**
+ * Performs function composition in LTR (Left To Right) direction.
+ *
+ * Our `pipe` and  `pipe.promise` implementation supports N arguments. But you can use only 10 in
+ * TypeScript, because it doesn't support **Variadic Kinds** and we explicitly
+ * have to define the type of all the possible usages as method overloads.
+ *
+ * @example pipe
+ *
+ * const normalizeWhiteSpaces = text => name.replace(/\s+/g, ' ').trim();
+ *
+ * const getInitials = pipe(
+ *   normalizeWhiteSpaces,
+ *   name => name.split(' ').map(name => name.charAt(0)),
+ *   initials => initials.join('').toLocaleUpperCase()
+ * );
+ *
+ * getInitials('Vitor Luiz Cavalcanti');
+ * //=> "VLC"
+ *
+ * @param fn - An arity N function. Its result is the argument of next one.
+ * @param fns - Functions of arity 1. Each one's result is next's argument.
+ *
+ * @example pipe.promise
+ *
+ * const addUnicorn = async string => `${string} Unicorn`;
+ * const addRainbow = async string => `${string} Rainbow`;
+ *
+ * const pipeline = pipe.promise(addUnicorn, addRainbow);
+ *
+ * console.log(await pipeline('❤️'));
+ * //=> '❤️ Unicorn Rainbow'
+ * @param ...input - Iterated over sequentially when returned `function` is called.
+ * @returns The `input` functions are applied from left to right.
+ */
+declare function pipe<Args extends unknown[], T0>(...fns: [(...xs: Args) => T0]): (...xs: Args) => T0;
+declare function pipe<Args extends unknown[], T0, T1>(...fns: [(...xs: Args) => T0, (x: T0) => T1]): (...xs: Args) => T1;
+declare function pipe<Args extends unknown[], T0, T1, T2>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2]): (...xs: Args) => T2;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3]): (...xs: Args) => T3;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4]): (...xs: Args) => T4;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5]): (...xs: Args) => T5;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5, T6>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5, (x: T5) => T6]): (...xs: Args) => T6;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5, T6, T7>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5, (x: T5) => T6, (x: T6) => T7]): (...xs: Args) => T7;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5, T6, T7, T8>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5, (x: T5) => T6, (x: T6) => T7, (x: T7) => T8]): (...xs: Args) => T8;
+declare function pipe<Args extends unknown[], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(...fns: [(...xs: Args) => T0, (x: T0) => T1, (x: T1) => T2, (x: T2) => T3, (x: T3) => T4, (x: T4) => T5, (x: T5) => T6, (x: T6) => T7, (x: T7) => T8, (x: T8) => T9]): (...xs: Args) => T9;
+declare namespace pipe {
+  var promise: typeof pPipe;
+}
+//#endregion
+//#region src/util/proxy.d.ts
+type Proxyed<T extends object, E extends object = {}> = T & {
+  proxy: {
+    update: (object?: T) => void;
+    source: T | undefined;
+  };
+} & E;
+/**
+ * Creates a proxy object that updates the original object when the proxy is updated.
+ * @param initObject - The initial object to proxy.
+ * @returns The proxy object.
+ *
+ * @example
+ * ```ts
+ * const obj = proxy({ name: 'John' })
+ * console.log(obj.name) // John
+ *
+ * obj.proxy.update({ name: 'Jane' })
+ * console.log(obj.name) // Jane
+ *
+ * const obj2 = proxy()
+ *
+ * obj2.any // Error: Proxy not updated. Call object.proxy.update() to update the proxy.
+ *
+ * obj2.proxy.source // undefined
+ * obj2.update({ name: 'John' })
+ *
+ * // get the original object
+ * obj2.proxy.source // { name: 'John' }
+ * ```
+ */
+declare function proxy<T extends object, E extends object = {}>(initObject?: T, initExtend?: E, options?: {
+  strictMessage?: string;
+}): Proxyed<T, E>;
+//#endregion
+//#region src/util/random.d.ts
+/**
+ * Get a random item from an array.
+ * @param array - The array to get a random item from.
+ * @returns The random item.
+ * @example
+ * ```ts
+ * randomItem(['a', 'b', 'c']) // 'a' | 'b' | 'c'
+ * ```
+ */
+declare function randomItem<T>(array: T[]): T;
+/**
+ * Get a random number between a minimum and maximum value.
+ * @param min - The minimum value.
+ * @param max - The maximum value.
+ * @returns The random number.
+ * @example
+ * ```ts
+ * randomNumber(0, 100) // 0-100
+ * ```
+ */
+declare function randomNumber(min: number, max: number): number;
+/**
+ * Get a random string of a given size.
+ * @param size - The size of the string.
+ * @param chars - The characters to use in the string.
+ * @returns The random string.
+ * @example
+ * ```ts
+ * randomString() // 10 characters long
+ * randomString(20) // 20 characters long
+ * randomString(20, 'abcdefghijklmnopqrstuvwxyz') // 20 characters long
+ * ```
+ */
+declare function randomString(size?: number, chars?: string): string;
+//#endregion
+//#region src/util/serialized.d.ts
+/**
+ * formData to object
+ * @param formData
+ */
+declare function formdataToObject(formData: FormData): Record<string, string>;
+/**
+ * Object to formData
+ * @param object
+ */
+declare function objectToFormdata(object: Record<string, string | File>): FormData;
+/**
+ * Check if a value is not NaN.
+ * @param value - The value to check.
+ * @returns The value if it is not NaN, otherwise undefined.
+ */
+declare function nonnanable<T>(value: T): T | undefined;
+/**
+ * Convert a value to a number.
+ * @param value - The value to convert to a number.
+ * @returns The number value.
+ */
+declare function numberify(value: any): number;
+/**
+ * Convert a value to a string.
+ * @param value - The value to convert to a string.
+ * @returns The string value.
+ */
+declare function stringify(value: any): string;
+/**
+ * Convert a value to a numberish value.
+ * @param value - The value to convert to a numberish value.
+ * @returns The numberish value.
+ */
+declare function numberish(value: Numberish): string;
+//#endregion
+//#region src/util/to.d.ts
+/**
+ * Convert a promise to a tuple of [error, data].
+ * @param promise - The promise to convert.
+ * @param error - The error to return if the promise fails.
+ * @returns The tuple of [error, data].
+ * @example
+ * ```ts
+ * to(Promise.resolve('data')) // Promise<[null, 'data']>
+ * to(Promise.reject(new Error('error'))) // Promise<[Error, undefined]>
+ * ```
+ */
+declare function to<T, U = Error>(promise: Promise<T> | (() => Promise<T>), error?: object): Promise<[U, undefined] | [null, T]>;
+//#endregion
+//#region src/util/to-array.d.ts
+/**
+ * Convert a value to an array.
+ * @param value - The value to convert.
+ * @param required - Whether the array is required.
+ * @returns The array.
+ * @example
+ * ```ts
+ * toArray(arrorOrItemOrUndefined) // item[] | undefined
+ * toArray(arrayOrItemOrUndefined, true) // item[]
+ * ```
+ */
+declare function toArray<T, R extends boolean>(value?: T | T[], required?: R): R extends true ? T[] : T[] | undefined;
+//#endregion
+//#region src/util/unit.d.ts
+type Dimension = Numeric | [Numeric, Numeric] | {
+  width: Numeric;
+  height: Numeric;
+};
+declare function unit(value: Numeric, unit?: string): string;
+declare function size(dimension: Dimension, unit?: string): {
+  width: string;
+  height: string;
+};
+//#endregion
+//#region src/util/util.d.ts
+/** @deprecated Use range instead */
+declare const arange: {
+  (start: number, end?: number, step?: number): number[];
+  (end: number, index: string | number, guard: object): number[];
+};
+/**
+ * Select a value based on a condition.
+ * @param args - The arguments to select from.
+ * @returns The selected value.
+ * @example
+ * ```ts
+ * select(
+ *  [condition1, value],
+ *  [condition2, value2],
+ * // default value
+ * [true, value3],
+ *  ...
+ * ) // value
+ * ```
+ */
+declare function select<T>(...args: [cond: boolean, value: T][]): T;
+/**
+ * @deprecated Use select instead
+ */
+declare const riposte: typeof select;
+/**
+ * Unwrap a value or a function that returns a value.
+ * @param value - The value or function to unwrap.
+ * @returns The unwrapped value.
+ * @example
+ * ```ts
+ * unwrap({ name: 'John' }) // { name: 'John' }
+ * unwrap(() => { return { name: 'John' } }) // { name: 'John' }
+ * ```
+ */
+declare function unwrap<T extends object>(value: T | (() => T)): T;
+/**
+ * Call a callback if a value is not null or undefined.
+ * @param value - The value to check.
+ * @param callback - The callback to call.
+ * @returns The result of the callback.
+ * @example
+ * ```ts
+ * whenever(value, (value) => { return 'value' }) // value
+ * ```
+ */
+declare function whenever<T, C extends (value: Exclude<T, null | undefined>) => any>(value: T, callback: C): ReturnType<C> | undefined;
+declare function call<T extends Fn<any>>(fn: T, ...args: Parameters<T>): ReturnType<T>;
+//#endregion
+export { AnyFn, ArgumentsType, Arrayable, Assign, Awaitable, BIG_INTS, Bignumber, BooleanLike, BrowserNativeObject, ConstructorType, DEFAULT_BIGNUM_CONFIG, DecimalOptions, DeepKeyof, DeepMap, DeepMerge, DeepPartial, DeepReadonly, DeepReplace, DeepRequired, Deferred, Delimiter, Dimension, DynamicObject, ElementOf, Fn, FormatGroupOptions, FormatNumericOptions, Ghost, IfAny, IsAny, Key, Looper, MergeInsertions, NonUndefined, Noop, Nullable, NumberObject, Numberish, Numeric, NumericObject, OmitBy, OpenFilePickerOptions, OpenImagePickerOptions, Option, Overwrite, PickBy, PromiseFn, PromiseType, Promisify, Proxyed, ReaderType, StringObject, SymbolObject, arange, average, bignumber, call, camelCase, capitalCase, chunk, clone, cloneDeep, cloneDeepWith, cloneWith, compose, concat, constantCase, cover, debounce, decimal, delay, dialsPhone, divide, dotCase, downloadBlobFile, downloadNetworkFile, downloadUrlFile, ensurePrefix, ensureSuffix, find, formatNumeric, formdataToObject, get, ghost, groupBy, gt, gte, integer, isAndroid, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean, isBrowser, isBuffer, isChrome, isDate, isEdge, isElement, isEmpty, isEqual, isEqualWith, isError, isFF, isFormData, isFunction, isIE, isIE11, isIE9, isIOS, isInteger, isMap, isMatch, isMatchWith, isMobile, isNaN, isNative, isNull, isNumber, isObject, isObjectLike, isPhantomJS, isPlainObject, isRegexp, isSet, isString, isSymbol, isTruthy, isUndefined, isWeakMap, isWeakSet, isWeex, isWindow, join, kebabCase, keyBy, keys, loop, lt, lte, max, maxBy, merge, mergeWith, min, minBy, multiply, noCase, nonnanable, noop, numberify, numberish, objectToFormdata, off, omit, omitBy, on, once, openFilePicker, openImagePicker, parseNumeric, pascalCase, pascalSnakeCase, pathCase, percentage, pick, pickBy, pipe, plus, proxy, randomItem, randomNumber, randomString, range, readFileReader, redirectTo, riposte, select, selectImages, sentenceCase, set, shortenId, showOpenFilePicker, showOpenImagePicker, size, slash, snakeCase, stringify, template, to, toArray, trainCase, truncate, tryParseJson, unindent, uniq, uniqBy, uniqWith, unit, unwrap, values, whenever, zeroRemove, zerofill };