@ztimson/utils 0.1.1 → 0.1.3

package/dist/array.d.ts

@@ -0,0 +1,66 @@
+export declare function addUnique<T>(array: T[], el: T): T[];
+export declare function arrayDiff(a: any[], b: any[]): any[];
+/**
+ * Provides a shorthand for sorting arrays of complex objects by a string property
+ *
+ * @example
+ * ```ts
+ * let arr = [{a: 'Apple', b: 123}, {a: 'Carrot', b: 789}, {a: 'banana', b: 456}];
+ * arr.sort(caseInsensitiveSort('a'));
+ * ```
+ *
+ * @param {string} prop - Name of property to use, supports dot notation
+ * @returns {(a, b) => (number)} - Function to handle sort (Meant to be passed to Array.prototype.sort or used in sortFn)
+ */
+export declare function caseInsensitiveSort(prop: string): (a: any, b: any) => number;
+/**
+ * Recursively flatten nested arrays
+ *
+ * @example
+ * ```ts
+ * const arr = [
+ *     {label: null, url: '/'},
+ *     {label: 'Model Admin', url: '/model-admin'},
+ *     [
+ *       {label: 'Elements', url: '/model-admin/elements'},
+ *       {label: 'Example', url: null}
+ *     ]
+ * ];
+ *
+ * console.log(flattenArr(arr));
+ * // Output:
+ * [
+ *     {label: null, url: '/'},
+ *     {label: 'Model Admin', url: '/model-admin'},
+ *     {label: 'Elements', url: '/model-admin/elements'},
+ *     {label: 'Example', url: null}
+ * ]
+ * ```
+ *
+ * @param {any[]} arr - n-dimensional array
+ * @param {any[]} result - Internal use only -- Keeps track of recursion
+ * @returns {any[]} - Flattened array
+ */
+export declare function flattenArr(arr: any[], result?: any[]): any[];
+/**
+ * Provides a shorthand for sorting arrays of complex objects
+ *
+ * @example
+ * ```ts
+ * let arr = [{a: {b: 2}}, {a: {b: 3}}, {a: {b: 1}}];
+ * arr.sort(sortByProp('a.b'));
+ * ```
+ *
+ * @param {string} prop - Name of property to use, supports dot notation
+ * @param {boolean} reverse - Reverse the order of the sort
+ * @returns {(a, b) => (number)} - Function to handle sort (Meant to be passed to Array.prototype.sort)
+ */
+export declare function sortByProp(prop: string, reverse?: boolean): (a: any, b: any) => number;
+export declare function findByProp(prop: string, value: any): (v: any) => boolean;
+export declare function makeUnique(arr: any[]): any[];
+/**
+ * Make sure value is an array, if it isn't wrap it in one.
+ * @param {T[] | T} value Value that should be an array
+ * @returns {T[]} Value in an array
+ */
+export declare function makeArray<T>(value: T | T[]): T[];

package/dist/emitter.d.ts

@@ -0,0 +1,18 @@
+export type Listener = (...args: any[]) => any;
+export type TypedEvents = {
+    [k in string | symbol]: Listener;
+} & {
+    '*': (event: string, ...args: any[]) => any;
+};
+export declare class TypedEmitter<T extends TypedEvents = TypedEvents> {
+    private static listeners;
+    private listeners;
+    static emit(event: any, ...args: any[]): void;
+    static off(event: any, listener: Listener): void;
+    static on(event: any, listener: Listener): () => void;
+    static once(event: any, listener?: Listener): Promise<any>;
+    emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>): void;
+    off<K extends keyof T = string>(event: K, listener: T[K]): void;
+    on<K extends keyof T = string>(event: K, listener: T[K]): () => void;
+    once<K extends keyof T = string>(event: K, listener?: T[K]): Promise<any>;
+}

package/dist/errors.d.ts

@@ -0,0 +1,35 @@
+export declare class CustomError extends Error {
+    static code: number;
+    private _code?;
+    get code(): number;
+    set code(c: number);
+    constructor(message?: string, code?: number);
+    static from(err: Error): CustomError;
+    static instanceof(err: Error): boolean;
+    toString(): string;
+}
+export declare class BadRequestError extends CustomError {
+    static code: number;
+    constructor(message?: string);
+    static instanceof(err: Error): boolean;
+}
+export declare class UnauthorizedError extends CustomError {
+    static code: number;
+    constructor(message?: string);
+    static instanceof(err: Error): boolean;
+}
+export declare class ForbiddenError extends CustomError {
+    static code: number;
+    constructor(message?: string);
+    static instanceof(err: Error): boolean;
+}
+export declare class NotFoundError extends CustomError {
+    static code: number;
+    constructor(message?: string);
+    static instanceof(err: Error): boolean;
+}
+export declare class InternalServerError extends CustomError {
+    static code: number;
+    constructor(message?: string);
+    static instanceof(err: Error): boolean;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './array';
+export * from './emitter';
+export * from './errors';
+export * from './logger';
+export * from './misc';
+export * from './objects';
+export * from './string';
+export * from './time';
+export * from './xhr';

package/dist/logger.d.ts

@@ -0,0 +1,65 @@
+import { TypedEmitter, TypedEvents } from './emitter';
+export declare const CliEffects: {
+    CLEAR: string;
+    BRIGHT: string;
+    DIM: string;
+    UNDERSCORE: string;
+    BLINK: string;
+    REVERSE: string;
+    HIDDEN: string;
+};
+export declare const CliForeground: {
+    BLACK: string;
+    RED: string;
+    GREEN: string;
+    YELLOW: string;
+    BLUE: string;
+    MAGENTA: string;
+    CYAN: string;
+    LIGHT_GREY: string;
+    GREY: string;
+    LIGHT_RED: string;
+    LIGHT_GREEN: string;
+    LIGHT_YELLOW: string;
+    LIGHT_BLUE: string;
+    LIGHT_MAGENTA: string;
+    LIGHT_CYAN: string;
+    WHITE: string;
+};
+export declare const CliBackground: {
+    BLACK: string;
+    RED: string;
+    GREEN: string;
+    YELLOW: string;
+    BLUE: string;
+    MAGENTA: string;
+    CYAN: string;
+    WHITE: string;
+    GREY: string;
+};
+export declare enum LOG_LEVEL {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    LOG = 3,
+    DEBUG = 4
+}
+export type LoggerEvents = TypedEvents & {
+    'ERROR': (...args: any[]) => any;
+    'WARN': (...args: any[]) => any;
+    'INFO': (...args: any[]) => any;
+    'LOG': (...args: any[]) => any;
+    'DEBUG': (...args: any[]) => any;
+};
+export declare class Logger extends TypedEmitter<LoggerEvents> {
+    readonly namespace?: string | undefined;
+    static LOG_LEVEL: LOG_LEVEL;
+    constructor(namespace?: string | undefined);
+    private pad;
+    private format;
+    debug(...args: string[]): void;
+    log(...args: string[]): void;
+    info(...args: string[]): void;
+    warn(...args: string[]): void;
+    error(...args: string[]): void;
+}

package/dist/misc.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Convert data into a form encoded format.
+ *
+ * @param {any} data - data to convert
+ * @returns {string} - Ecodeded form data
+ */
+export declare function formEncode(data: any): string;
+/**
+ * Get profile image from Gravatar
+ *
+ * @param {string} email Account email address
+ * @param {string} def Default image, can be a link or '404', see: https://docs.gravatar.com/general/images/
+ * @returns {string} Gravatar URL
+ */
+export declare function gravatar(email: string, def?: string): string;
+/** Parts of a URL */
+export type ParsedUrl = {
+    protocol?: string;
+    subdomain?: string;
+    domain: string;
+    host: string;
+    port?: number;
+    path?: string;
+    query?: {
+        [name: string]: string;
+    };
+    fragment?: string;
+};
+/**
+ *
+ * @param {string} url
+ * @returns {RegExpExecArray}
+ */
+export declare function urlParser(url: string): ParsedUrl;

package/dist/objects.d.ts

@@ -0,0 +1,82 @@
+/**
+ *  Removes any null values from an object in-place
+ *
+ * @example
+ * ```ts
+ * let test = {a: 0, b: false, c: null, d: 'abc'}
+ * console.log(clean(test)); // Output: {a: 0, b: false, d: 'abc'}
+ * ```
+ *
+ * @param {T} obj Object reference that will be cleaned
+ * @param undefinedOnly Ignore null values
+ * @returns {Partial<T>} Cleaned object
+ */
+export declare function clean<T>(obj: T, undefinedOnly?: boolean): Partial<T>;
+/**
+ * Create a deep copy of an object (vs. a shallow copy of references)
+ *
+ * Should be replaced by `structuredClone` once released.
+ *
+ * @param {T} value Object to copy
+ * @returns {T} Type
+ */
+export declare function deepCopy<T>(value: T): T;
+/**
+ * Get/set a property of an object using dot notation
+ *
+ * @example
+ * ```ts
+ * // Get a value
+ * const name = dotNotation<string>(person, 'firstName');
+ * const familyCarMake = dotNotation(family, 'cars[0].make');
+ * // Set a value
+ * dotNotation(family, 'cars[0].make', 'toyota');
+ * ```
+ *
+ * @type T Return type
+ * @param {Object} obj source object to search
+ * @param {string} prop property name (Dot notation & indexing allowed)
+ * @param {any} set  Set object property to value, omit to fetch value instead
+ * @return {T} property value
+ */
+export declare function dotNotation<T>(obj: any, prop: string, set: T): T;
+export declare function dotNotation<T>(obj: any, prop: string): T | undefined;
+/**
+ * Recursively flatten a nested object, while maintaining key structure.
+ *
+ * @example
+ * ```ts
+ * const car = {honda: {model: "Civic"}};
+ * console.log(flattenObj(car)); //Output {honda.model: "Civic"}
+ * ```
+ *
+ * @param obj - Object to flatten
+ * @param parent - Recursively check if key is a parent key or not
+ * @param result - Result
+ * @returns {object} - Flattened object
+ */
+export declare function flattenObj(obj: any, parent?: any, result?: any): any;
+/**
+ * Check that an object has the following values
+ *
+ * @example
+ * ```ts
+ * const test = {a: 2, b: 2};
+ * includes(test, {a: 1}); // true
+ * includes(test, {b: 1, c: 3}); // false
+ * ```
+ *
+ * @param target Object to search
+ * @param values Criteria to check against
+ * @param allowMissing Only check the keys that are available on the target
+ * @returns {boolean} Does target include all the values
+ */
+export declare function includes(target: any, values: any, allowMissing?: boolean): boolean;
+/**
+ * Deep check if two objects are equal
+ *
+ * @param {any} a - first item to compare
+ * @param {any} b - second item to compare
+ * @returns {boolean} True if they match
+ */
+export declare function isEqual(a: any, b: any): boolean;

package/dist/string.d.ts

@@ -0,0 +1,72 @@
+export declare function countChars(text: string, pattern: RegExp): number;
+export declare function createHex(length: number): string;
+export declare function formatPhoneNumber(number: string): string;
+/**
+ * Insert a string into another string at a given position
+ *
+ * @example
+ * ```
+ * console.log(insertAt('Hello world!', ' glorious', 5);
+ * // Output: Hello glorious world!
+ * ```
+ *
+ * @param {string} target - Parent string you want to modify
+ * @param {string} str - Value that will be injected to parent
+ * @param {number} index - Position to inject string at
+ * @returns {string} - New string
+ */
+export declare function insertAt(target: string, str: string, index: number): String;
+export declare function pad(text: any, length: number, char: string, start?: boolean): any;
+/**
+ * Generate a string of random characters.
+ *
+ * @example
+ * ```ts
+ * const random = randomString();
+ * const randomByte = randomString(8, "01")
+ * ```
+ *
+ * @param {number} length - length of generated string
+ * @param {string} pool - character pool to generate string from
+ * @return {string} generated string
+ */
+export declare function randomString(length: number, pool?: string): string;
+/**
+ * Generate a random string with fine control over letters, numbers & symbols
+ *
+ * @example
+ * ```ts
+ * const randomLetter = randomString(1, true);
+ * const randomChar = randomString(1, true, true, true);
+ * ```
+ *
+ * @param {number} length - length of generated string
+ * @param {boolean} letters - Add letters to pool
+ * @param {boolean} numbers - Add numbers to pool
+ * @param {boolean} symbols - Add symbols to pool
+ * @return {string} generated string
+ */
+export declare function randomStringBuilder(length: number, letters?: boolean, numbers?: boolean, symbols?: boolean): string;
+/**
+ * Find all substrings that match a given pattern.
+ *
+ * Roughly based on `String.prototype.matchAll`.
+ *
+ * @param {string} value - String to search.
+ * @param {RegExp | string} regex - Regular expression to match.
+ * @return {RegExpExecArray[]} Found matches.
+ */
+export declare function matchAll(value: string, regex: RegExp | string): RegExpExecArray[];
+/**
+ * Create MD5 hash using native javascript
+ * @param d String to hash
+ * @returns {string} Hashed string
+ */
+export declare function md5(d: string): string;
+/**
+ * Check if email is valid
+ *
+ * @param {string} email - Target
+ * @returns {boolean} - Follows format
+ */
+export declare function validateEmail(email: string): boolean;

package/dist/time.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Calculate the number of milliseconds until date/time
+ *
+ * @param {Date | number} date - Target
+ * @returns {number} - Number of milliseconds until target
+ */
+export declare function timeUntil(date: Date | number): number;
+/**
+ * Use in conjunction with `await` to pause an async script
+ *
+ * @example
+ * ```ts
+ * async () => {
+ *      ...
+ *      await sleep(1000) // Pause for 1 second
+ *	    ...
+ * }
+ * ```
+ *
+ * @param {number} ms - Time to pause for in milliseconds
+ * @returns {Promise<unknown>} - Resolves promise when it's time to resume
+ */
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function formatDate(date: Date | number | string): string;

package/dist/xhr.d.ts

@@ -0,0 +1,31 @@
+import { TypedEmitter, type TypedEvents } from './emitter';
+export type Interceptor = (request: Response, next: () => void) => void;
+export type RequestOptions = {
+    url?: string;
+    method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    body?: any;
+    headers?: {
+        [key: string | symbol]: string | null | undefined;
+    };
+    [key: string]: any;
+};
+export type XhrEvents = TypedEvents & {
+    'REQUEST': (request: Promise<any>, options: RequestOptions) => any;
+    'RESPONSE': (response: Response, options: RequestOptions) => any;
+    'REJECTED': (response: Error, options: RequestOptions) => any;
+};
+export type XhrOptions = {
+    interceptors?: Interceptor[];
+    url?: string;
+};
+export declare class XHR extends TypedEmitter<XhrEvents> {
+    readonly opts: XhrOptions;
+    private static headers;
+    private static interceptors;
+    private headers;
+    private interceptors;
+    constructor(opts?: XhrOptions);
+    static addInterceptor(fn: Interceptor): () => void;
+    addInterceptor(fn: Interceptor): () => void;
+    request<T>(opts?: RequestOptions): Promise<T>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ztimson/utils",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"description": "Utility library",
 	"author": "Zak Timson",
 	"license": "MIT",
@@ -9,8 +9,7 @@
 		"type": "git",
 		"url": "https://git.zakscode.com/ztimson/js-utilities"
 	},
-	"main": "./dist/utils.cjs",
-	"module": "./dist/utils.mjs",
+	"main": "./dist/utils.mjs",
 	"types": "./dist/utils.d.ts",
 	"scripts": {
 		"build": "npx tsc && npx vite build",

package/dist/utils.d.ts

@@ -1,456 +0,0 @@
-declare module "objects" {
-    /**
-     *  Removes any null values from an object in-place
-     *
-     * @example
-     * ```ts
-     * let test = {a: 0, b: false, c: null, d: 'abc'}
-     * console.log(clean(test)); // Output: {a: 0, b: false, d: 'abc'}
-     * ```
-     *
-     * @param {T} obj Object reference that will be cleaned
-     * @param undefinedOnly Ignore null values
-     * @returns {Partial<T>} Cleaned object
-     */
-    export function clean<T>(obj: T, undefinedOnly?: boolean): Partial<T>;
-    /**
-     * Create a deep copy of an object (vs. a shallow copy of references)
-     *
-     * Should be replaced by `structuredClone` once released.
-     *
-     * @param {T} value Object to copy
-     * @returns {T} Type
-     */
-    export function deepCopy<T>(value: T): T;
-    /**
-     * Get/set a property of an object using dot notation
-     *
-     * @example
-     * ```ts
-     * // Get a value
-     * const name = dotNotation<string>(person, 'firstName');
-     * const familyCarMake = dotNotation(family, 'cars[0].make');
-     * // Set a value
-     * dotNotation(family, 'cars[0].make', 'toyota');
-     * ```
-     *
-     * @type T Return type
-     * @param {Object} obj source object to search
-     * @param {string} prop property name (Dot notation & indexing allowed)
-     * @param {any} set  Set object property to value, omit to fetch value instead
-     * @return {T} property value
-     */
-    export function dotNotation<T>(obj: any, prop: string, set: T): T;
-    export function dotNotation<T>(obj: any, prop: string): T | undefined;
-    /**
-     * Recursively flatten a nested object, while maintaining key structure.
-     *
-     * @example
-     * ```ts
-     * const car = {honda: {model: "Civic"}};
-     * console.log(flattenObj(car)); //Output {honda.model: "Civic"}
-     * ```
-     *
-     * @param obj - Object to flatten
-     * @param parent - Recursively check if key is a parent key or not
-     * @param result - Result
-     * @returns {object} - Flattened object
-     */
-    export function flattenObj(obj: any, parent?: any, result?: any): any;
-    /**
-     * Check that an object has the following values
-     *
-     * @example
-     * ```ts
-     * const test = {a: 2, b: 2};
-     * includes(test, {a: 1}); // true
-     * includes(test, {b: 1, c: 3}); // false
-     * ```
-     *
-     * @param target Object to search
-     * @param values Criteria to check against
-     * @param allowMissing Only check the keys that are available on the target
-     * @returns {boolean} Does target include all the values
-     */
-    export function includes(target: any, values: any, allowMissing?: boolean): boolean;
-    /**
-     * Deep check if two objects are equal
-     *
-     * @param {any} a - first item to compare
-     * @param {any} b - second item to compare
-     * @returns {boolean} True if they match
-     */
-    export function isEqual(a: any, b: any): boolean;
-}
-declare module "array" {
-    export function addUnique<T>(array: T[], el: T): T[];
-    export function arrayDiff(a: any[], b: any[]): any[];
-    /**
-     * Provides a shorthand for sorting arrays of complex objects by a string property
-     *
-     * @example
-     * ```ts
-     * let arr = [{a: 'Apple', b: 123}, {a: 'Carrot', b: 789}, {a: 'banana', b: 456}];
-     * arr.sort(caseInsensitiveSort('a'));
-     * ```
-     *
-     * @param {string} prop - Name of property to use, supports dot notation
-     * @returns {(a, b) => (number)} - Function to handle sort (Meant to be passed to Array.prototype.sort or used in sortFn)
-     */
-    export function caseInsensitiveSort(prop: string): (a: any, b: any) => number;
-    /**
-     * Recursively flatten nested arrays
-     *
-     * @example
-     * ```ts
-     * const arr = [
-     *     {label: null, url: '/'},
-     *     {label: 'Model Admin', url: '/model-admin'},
-     *     [
-     *       {label: 'Elements', url: '/model-admin/elements'},
-     *       {label: 'Example', url: null}
-     *     ]
-     * ];
-     *
-     * console.log(flattenArr(arr));
-     * // Output:
-     * [
-     *     {label: null, url: '/'},
-     *     {label: 'Model Admin', url: '/model-admin'},
-     *     {label: 'Elements', url: '/model-admin/elements'},
-     *     {label: 'Example', url: null}
-     * ]
-     * ```
-     *
-     * @param {any[]} arr - n-dimensional array
-     * @param {any[]} result - Internal use only -- Keeps track of recursion
-     * @returns {any[]} - Flattened array
-     */
-    export function flattenArr(arr: any[], result?: any[]): any[];
-    /**
-     * Provides a shorthand for sorting arrays of complex objects
-     *
-     * @example
-     * ```ts
-     * let arr = [{a: {b: 2}}, {a: {b: 3}}, {a: {b: 1}}];
-     * arr.sort(sortByProp('a.b'));
-     * ```
-     *
-     * @param {string} prop - Name of property to use, supports dot notation
-     * @param {boolean} reverse - Reverse the order of the sort
-     * @returns {(a, b) => (number)} - Function to handle sort (Meant to be passed to Array.prototype.sort)
-     */
-    export function sortByProp(prop: string, reverse?: boolean): (a: any, b: any) => number;
-    export function findByProp(prop: string, value: any): (v: any) => boolean;
-    export function makeUnique(arr: any[]): any[];
-    /**
-     * Make sure value is an array, if it isn't wrap it in one.
-     * @param {T[] | T} value Value that should be an array
-     * @returns {T[]} Value in an array
-     */
-    export function makeArray<T>(value: T | T[]): T[];
-}
-declare module "emitter" {
-    export type Listener = (...args: any[]) => any;
-    export type TypedEvents = {
-        [k in string | symbol]: Listener;
-    } & {
-        '*': (event: string, ...args: any[]) => any;
-    };
-    export class TypedEmitter<T extends TypedEvents = TypedEvents> {
-        private static listeners;
-        private listeners;
-        static emit(event: any, ...args: any[]): void;
-        static off(event: any, listener: Listener): void;
-        static on(event: any, listener: Listener): () => void;
-        static once(event: any, listener?: Listener): Promise<any>;
-        emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>): void;
-        off<K extends keyof T = string>(event: K, listener: T[K]): void;
-        on<K extends keyof T = string>(event: K, listener: T[K]): () => void;
-        once<K extends keyof T = string>(event: K, listener?: T[K]): Promise<any>;
-    }
-}
-declare module "xhr" {
-    import { TypedEmitter, type TypedEvents } from "emitter";
-    export type Interceptor = (request: Response, next: () => void) => void;
-    export type RequestOptions = {
-        url?: string;
-        method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
-        body?: any;
-        headers?: {
-            [key: string | symbol]: string | null | undefined;
-        };
-        [key: string]: any;
-    };
-    export type XhrEvents = TypedEvents & {
-        'REQUEST': (request: Promise<any>, options: RequestOptions) => any;
-        'RESPONSE': (response: Response, options: RequestOptions) => any;
-        'REJECTED': (response: Error, options: RequestOptions) => any;
-    };
-    export type XhrOptions = {
-        interceptors?: Interceptor[];
-        url?: string;
-    };
-    export class XHR extends TypedEmitter<XhrEvents> {
-        readonly opts: XhrOptions;
-        private static headers;
-        private static interceptors;
-        private headers;
-        private interceptors;
-        constructor(opts?: XhrOptions);
-        static addInterceptor(fn: Interceptor): () => void;
-        addInterceptor(fn: Interceptor): () => void;
-        request<T>(opts?: RequestOptions): Promise<T>;
-    }
-}
-declare module "errors" {
-    export class CustomError extends Error {
-        static code: number;
-        private _code?;
-        get code(): number;
-        set code(c: number);
-        constructor(message?: string, code?: number);
-        static from(err: Error): CustomError;
-        static instanceof(err: Error): boolean;
-        toString(): string;
-    }
-    export class BadRequestError extends CustomError {
-        static code: number;
-        constructor(message?: string);
-        static instanceof(err: Error): boolean;
-    }
-    export class UnauthorizedError extends CustomError {
-        static code: number;
-        constructor(message?: string);
-        static instanceof(err: Error): boolean;
-    }
-    export class ForbiddenError extends CustomError {
-        static code: number;
-        constructor(message?: string);
-        static instanceof(err: Error): boolean;
-    }
-    export class NotFoundError extends CustomError {
-        static code: number;
-        constructor(message?: string);
-        static instanceof(err: Error): boolean;
-    }
-    export class InternalServerError extends CustomError {
-        static code: number;
-        constructor(message?: string);
-        static instanceof(err: Error): boolean;
-    }
-}
-declare module "logger" {
-    import { TypedEmitter, TypedEvents } from "emitter";
-    export const CliEffects: {
-        CLEAR: string;
-        BRIGHT: string;
-        DIM: string;
-        UNDERSCORE: string;
-        BLINK: string;
-        REVERSE: string;
-        HIDDEN: string;
-    };
-    export const CliForeground: {
-        BLACK: string;
-        RED: string;
-        GREEN: string;
-        YELLOW: string;
-        BLUE: string;
-        MAGENTA: string;
-        CYAN: string;
-        LIGHT_GREY: string;
-        GREY: string;
-        LIGHT_RED: string;
-        LIGHT_GREEN: string;
-        LIGHT_YELLOW: string;
-        LIGHT_BLUE: string;
-        LIGHT_MAGENTA: string;
-        LIGHT_CYAN: string;
-        WHITE: string;
-    };
-    export const CliBackground: {
-        BLACK: string;
-        RED: string;
-        GREEN: string;
-        YELLOW: string;
-        BLUE: string;
-        MAGENTA: string;
-        CYAN: string;
-        WHITE: string;
-        GREY: string;
-    };
-    export enum LOG_LEVEL {
-        ERROR = 0,
-        WARN = 1,
-        INFO = 2,
-        LOG = 3,
-        DEBUG = 4
-    }
-    export type LoggerEvents = TypedEvents & {
-        'ERROR': (...args: any[]) => any;
-        'WARN': (...args: any[]) => any;
-        'INFO': (...args: any[]) => any;
-        'LOG': (...args: any[]) => any;
-        'DEBUG': (...args: any[]) => any;
-    };
-    export class Logger extends TypedEmitter<LoggerEvents> {
-        readonly namespace?: string | undefined;
-        static LOG_LEVEL: LOG_LEVEL;
-        constructor(namespace?: string | undefined);
-        private pad;
-        private format;
-        debug(...args: string[]): void;
-        log(...args: string[]): void;
-        info(...args: string[]): void;
-        warn(...args: string[]): void;
-        error(...args: string[]): void;
-    }
-}
-declare module "string" {
-    export function countChars(text: string, pattern: RegExp): number;
-    export function createHex(length: number): string;
-    export function formatPhoneNumber(number: string): string;
-    /**
-     * Insert a string into another string at a given position
-     *
-     * @example
-     * ```
-     * console.log(insertAt('Hello world!', ' glorious', 5);
-     * // Output: Hello glorious world!
-     * ```
-     *
-     * @param {string} target - Parent string you want to modify
-     * @param {string} str - Value that will be injected to parent
-     * @param {number} index - Position to inject string at
-     * @returns {string} - New string
-     */
-    export function insertAt(target: string, str: string, index: number): String;
-    export function pad(text: any, length: number, char: string, start?: boolean): any;
-    /**
-     * Generate a string of random characters.
-     *
-     * @example
-     * ```ts
-     * const random = randomString();
-     * const randomByte = randomString(8, "01")
-     * ```
-     *
-     * @param {number} length - length of generated string
-     * @param {string} pool - character pool to generate string from
-     * @return {string} generated string
-     */
-    export function randomString(length: number, pool?: string): string;
-    /**
-     * Generate a random string with fine control over letters, numbers & symbols
-     *
-     * @example
-     * ```ts
-     * const randomLetter = randomString(1, true);
-     * const randomChar = randomString(1, true, true, true);
-     * ```
-     *
-     * @param {number} length - length of generated string
-     * @param {boolean} letters - Add letters to pool
-     * @param {boolean} numbers - Add numbers to pool
-     * @param {boolean} symbols - Add symbols to pool
-     * @return {string} generated string
-     */
-    export function randomStringBuilder(length: number, letters?: boolean, numbers?: boolean, symbols?: boolean): string;
-    /**
-     * Find all substrings that match a given pattern.
-     *
-     * Roughly based on `String.prototype.matchAll`.
-     *
-     * @param {string} value - String to search.
-     * @param {RegExp | string} regex - Regular expression to match.
-     * @return {RegExpExecArray[]} Found matches.
-     */
-    export function matchAll(value: string, regex: RegExp | string): RegExpExecArray[];
-    /**
-     * Create MD5 hash using native javascript
-     * @param d String to hash
-     * @returns {string} Hashed string
-     */
-    export function md5(d: string): string;
-    /**
-     * Check if email is valid
-     *
-     * @param {string} email - Target
-     * @returns {boolean} - Follows format
-     */
-    export function validateEmail(email: string): boolean;
-}
-declare module "misc" {
-    /**
-     * Convert data into a form encoded format.
-     *
-     * @param {any} data - data to convert
-     * @returns {string} - Ecodeded form data
-     */
-    export function formEncode(data: any): string;
-    /**
-     * Get profile image from Gravatar
-     *
-     * @param {string} email Account email address
-     * @param {string} def Default image, can be a link or '404', see: https://docs.gravatar.com/general/images/
-     * @returns {string} Gravatar URL
-     */
-    export function gravatar(email: string, def?: string): string;
-    /** Parts of a URL */
-    export type ParsedUrl = {
-        protocol?: string;
-        subdomain?: string;
-        domain: string;
-        host: string;
-        port?: number;
-        path?: string;
-        query?: {
-            [name: string]: string;
-        };
-        fragment?: string;
-    };
-    /**
-     *
-     * @param {string} url
-     * @returns {RegExpExecArray}
-     */
-    export function urlParser(url: string): ParsedUrl;
-}
-declare module "time" {
-    /**
-     * Calculate the number of milliseconds until date/time
-     *
-     * @param {Date | number} date - Target
-     * @returns {number} - Number of milliseconds until target
-     */
-    export function timeUntil(date: Date | number): number;
-    /**
-     * Use in conjunction with `await` to pause an async script
-     *
-     * @example
-     * ```ts
-     * async () => {
-     *      ...
-     *      await sleep(1000) // Pause for 1 second
-     *	    ...
-     * }
-     * ```
-     *
-     * @param {number} ms - Time to pause for in milliseconds
-     * @returns {Promise<unknown>} - Resolves promise when it's time to resume
-     */
-    export function sleep(ms: number): Promise<unknown>;
-    export function formatDate(date: Date | number | string): string;
-}
-declare module "index" {
-    export * from "array";
-    export * from "emitter";
-    export * from "errors";
-    export * from "logger";
-    export * from "misc";
-    export * from "objects";
-    export * from "string";
-    export * from "time";
-    export * from "xhr";
-}