@luxass/utils 2.1.0 → 2.2.1

package/dist/guards-C19fJmlu.d.ts

@@ -0,0 +1,60 @@
+//#region src/guards.d.ts
+/**
+ * Checks if a value is not null or undefined.
+ *
+ * @template T - The type of the input value.
+ * @param {T | null | undefined} v - The value to check for not being null or undefined.
+ * @returns {v is NonNullable<T>} - True if the value is not null or undefined, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isNotNullish)
+ * // [true, false, 0, 1, "", "hello"]
+ * ```
+ */
+declare function isNotNullish<T>(v: T | null | undefined): v is NonNullable<T>;
+/**
+ * Checks if a value is not null.
+ *
+ * @template T - The type of the input value.
+ * @param {T | null} v - The value to check for not being null.
+ * @returns {v is Exclude<T, null>} True if the value is not null, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isNotNull)
+ * // [true, false, 0, 1, "", "hello", undefined]
+ * ```
+ */
+declare function isNotNull<T>(v: T | null): v is Exclude<T, null>;
+/**
+ * Checks if a value is defined.
+ *
+ * @template T - The type of the input value.
+ * @param {T} v - The value to check for being defined.
+ * @returns {v is Exclude<T, undefined>} True if the value is defined, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isDefined)
+ * // [true, false, 0, 1, "", "hello", null]
+ * ```
+ */
+declare function isNotUndefined<T>(v: T): v is Exclude<T, undefined>;
+/**
+ * Checks if a value is truthy, excluding null and undefined.
+ *
+ * @template T - The type of the input value.
+ * @param {T} v - The value to check for truthiness.
+ * @returns {v is NonNullable<T>} True if the value is truthy, false otherwise.
+ *
+ * @example
+ * ```ts
+ * [true, false, 0, 1, "", "hello", null, undefined].filter(isTruthy)
+ * // [true, 1, "hello"]
+ * ```
+ */
+declare function isTruthy<T>(v: T): v is NonNullable<T>;
+
+//#endregion
+export { isNotNull as isNotNull$1, isNotNullish as isNotNullish$1, isNotUndefined as isNotUndefined$1, isTruthy as isTruthy$1 };

package/dist/guards.d.ts

@@ -1,2 +1,2 @@
-import { isNotNull$1 as isNotNull, isNotNullish$1 as isNotNullish, isNotUndefined$1 as isNotUndefined, isTruthy$1 as isTruthy } from "./guards.d-n1BzCANy.js";
+import { isNotNull$1 as isNotNull, isNotNullish$1 as isNotNullish, isNotUndefined$1 as isNotUndefined, isTruthy$1 as isTruthy } from "./guards-C19fJmlu.js";
 export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

package/dist/index.d.ts

@@ -1,24 +1,23 @@
-import { isNotNull$1 as isNotNull, isNotNullish$1 as isNotNullish, isNotUndefined$1 as isNotUndefined, isTruthy$1 as isTruthy } from "./guards.d-n1BzCANy.js";
-import { clamp$1 as clamp } from "./number.d-C2Xuq3Is.js";
-import { capitalize$1 as capitalize, dedent$1 as dedent, dedentRaw$1 as dedentRaw, formatStr$1 as formatStr, sanitizeIdentifier$1 as sanitizeIdentifier, toCamelCase$1 as toCamelCase, toKebabCase$1 as toKebabCase, toPascalCase$1 as toPascalCase, toSnakeCase$1 as toSnakeCase } from "./string.d-B2ppMtlR.js";
-import { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish } from "./types.d-BcKIY6l3.js";
+import { isNotNull$1 as isNotNull, isNotNullish$1 as isNotNullish, isNotUndefined$1 as isNotUndefined, isTruthy$1 as isTruthy } from "./guards-C19fJmlu.js";
+import { clamp$1 as clamp } from "./number-C2E_sOOy.js";
+import { capitalize$1 as capitalize, dedent$1 as dedent, dedentRaw$1 as dedentRaw, formatStr$1 as formatStr, sanitizeIdentifier$1 as sanitizeIdentifier, toCamelCase$1 as toCamelCase, toKebabCase$1 as toKebabCase, toPascalCase$1 as toPascalCase, toSnakeCase$1 as toSnakeCase } from "./string-CBWIJiC0.js";
+import { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-B3iMkmi_.js";
 
 //#region src/common.d.ts
 declare class InvariantError extends Error {
   readonly message: string;
   constructor(message: string, ...positionals: any[]);
 }
-
 /**
-* Asserts that a condition is truthy. If the condition is falsy, throws an InvariantError.
-* This function is useful for ensuring invariants and preconditions in code.
-*
-* @param {unknown} predicate - The condition to check
-* @param {string} message - Error message to display if the condition fails
-* @param {unknown[]} positionals - Values to substitute into the error message using formatStr
-* @throws {InvariantError} Throws when the predicate is falsy
-*/
+ * Asserts that a condition is truthy. If the condition is falsy, throws an InvariantError.
+ * This function is useful for ensuring invariants and preconditions in code.
+ *
+ * @param {unknown} predicate - The condition to check
+ * @param {string} message - Error message to display if the condition fails
+ * @param {unknown[]} positionals - Values to substitute into the error message using formatStr
+ * @throws {InvariantError} Throws when the predicate is falsy
+ */
 declare function invariant(predicate: unknown, message: string, ...positionals: unknown[]): asserts predicate;
 
 //#endregion
-export { Arrayable, Awaitable, ElementOf, InferArguments, InvariantError, Nullable, Nullish, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+export { Arrayable, Awaitable, ElementOf, InferArguments, InvariantError, Nullable, Nullish, Prettify, RemoveIndexSignature, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/number-C2E_sOOy.d.ts

@@ -0,0 +1,24 @@
+//#region src/number.d.ts
+/**
+ * Clamp a value between a min and max value.
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @returns {number} the clamped value
+ *
+ * @example
+ * ```ts
+ * clamp(5, 0, 10)
+ * // 5
+ *
+ * clamp(5, 10, 20)
+ * // 10
+ *
+ * clamp(5, 0, 4)
+ * // 4
+ * ```
+ */
+declare function clamp(value: number, min: number, max: number): number;
+
+//#endregion
+export { clamp as clamp$1 };

package/dist/number.d.ts

@@ -1,2 +1,2 @@
-import { clamp$1 as clamp } from "./number.d-C2Xuq3Is.js";
+import { clamp$1 as clamp } from "./number-C2E_sOOy.js";
 export { clamp };

package/dist/string-CBWIJiC0.d.ts

@@ -0,0 +1,132 @@
+//#region src/string.d.ts
+/**
+ * Capitalizes the first character of a string and converts the rest to lowercase
+ * @param {string} str - The string to capitalize
+ * @returns {string} The capitalized string
+ * @example
+ * ```ts
+ * capitalize("hello") // "Hello"
+ * capitalize("hELLO") // "Hello"
+ * capitalize("") // ""
+ * ```
+ */
+declare function capitalize(str: string): string;
+/**
+ * Converts a string to camelCase format
+ * @param {string} str - The string to convert to camelCase
+ * @returns {string} The string in camelCase format
+ * @example
+ * ```ts
+ * toCamelCase("hello world") // "helloWorld"
+ * toCamelCase("hello-world") // "helloWorld"
+ * toCamelCase("hello_world") // "helloWorld"
+ * toCamelCase("HelloWorld") // "helloWorld"
+ * toCamelCase("") // ""
+ * ```
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Converts a string to kebab-case format
+ * @param {string} str - The string to convert to kebab-case
+ * @returns {string} The string in kebab-case format
+ * @example
+ * ```ts
+ * toKebabCase("hello world") // "hello-world"
+ * toKebabCase("helloWorld") // "hello-world"
+ * toKebabCase("hello_world") // "hello-world"
+ * toKebabCase("HelloWorld") // "hello-world"
+ * toKebabCase("") // ""
+ * ```
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Converts a string to PascalCase format
+ * @param {string} str - The string to convert to PascalCase
+ * @returns {string} The string in PascalCase format
+ * @example
+ * ```ts
+ * toPascalCase("hello world") // "HelloWorld"
+ * toPascalCase("hello-world") // "HelloWorld"
+ * toPascalCase("hello_world") // "HelloWorld"
+ * toPascalCase("helloWorld") // "HelloWorld"
+ * toPascalCase("") // ""
+ * ```
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Converts a string to snake_case format
+ * @param {string} str - The string to convert to snake_case
+ * @returns {string} The string in snake_case format
+ * @example
+ * ```ts
+ * toSnakeCase("hello world") // "hello_world"
+ * toSnakeCase("helloWorld") // "hello_world"
+ * toSnakeCase("hello-world") // "hello_world"
+ * toSnakeCase("HelloWorld") // "hello_world"
+ * toSnakeCase("") // ""
+ * ```
+ */
+declare function toSnakeCase(str: string): string;
+/**
+ * Removes leading and trailing whitespace from each line of a string
+ * @param {TemplateStringsArray | string} literals - The string to dedent
+ * @returns {string} The dedented string
+ * @example ```ts
+ * dedent`
+ *   This is a test.
+ *   This is another line.
+ * `
+ * // "This is a test.\nThis is another line."
+ * ```
+ */
+declare function dedent(literals: string): string;
+declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
+declare namespace dedent {
+  var raw: typeof dedentRaw;
+}
+/**
+ * Removes leading and trailing whitespace from each line of a string
+ * @param {TemplateStringsArray | string} literals - The string to dedent
+ * @returns {string} The dedented string
+ * @example ```ts
+ * dedent`
+ *   This is a test.
+ *   This is another line.
+ * `
+ * // "This is a test.\nThis is another line."
+ * ```
+ */
+declare function dedentRaw(literals: string): string;
+declare function dedentRaw(strings: TemplateStringsArray, ...values: unknown[]): string;
+/**
+ * Ensures a string is a valid JavaScript identifier by prefixing with an underscore if necessary
+ * @param {string} str - The string to sanitize
+ * @returns {string} A valid JavaScript identifier
+ * @example
+ * ```ts
+ * sanitizeIdentifier("validName") // "validName"
+ * sanitizeIdentifier("123invalid") // "_123invalid"
+ * sanitizeIdentifier("$valid") // "$valid"
+ * sanitizeIdentifier("_valid") // "_valid"
+ * ```
+ */
+declare function sanitizeIdentifier(str: string): string;
+/**
+ * Formats a string by replacing placeholders with positional values
+ * @param {string} message - The string containing placeholders to be replaced
+ * @param {...any} positionals - The values to insert into the placeholders
+ * @returns {string} The formatted string
+ *
+ * @example
+ * ```ts
+ * formatStr("Hello %s", "world") // "Hello world"
+ * formatStr("Count: %d", 5) // "Count: 5"
+ * formatStr("Data: %j", { name: "test" }) // "Data: {"name":"test"}"
+ * formatStr("Object: %o", { id: 1 }) // "Object: {"id":1}"
+ * formatStr("Escaped %%s", "value") // "Escaped %s"
+ * formatStr("Extra args", 1, 2) // "Extra args 1 2"
+ * ```
+ */
+declare function formatStr(message: string, ...positionals: unknown[]): string;
+//#endregion
+export { capitalize as capitalize$1, dedent as dedent$1, dedentRaw as dedentRaw$1, formatStr as formatStr$1, sanitizeIdentifier as sanitizeIdentifier$1, toCamelCase as toCamelCase$1, toKebabCase as toKebabCase$1, toPascalCase as toPascalCase$1, toSnakeCase as toSnakeCase$1 };

package/dist/string.d.ts

@@ -1,2 +1,2 @@
-import { capitalize$1 as capitalize, dedent$1 as dedent, dedentRaw$1 as dedentRaw, formatStr$1 as formatStr, sanitizeIdentifier$1 as sanitizeIdentifier, toCamelCase$1 as toCamelCase, toKebabCase$1 as toKebabCase, toPascalCase$1 as toPascalCase, toSnakeCase$1 as toSnakeCase } from "./string.d-B2ppMtlR.js";
+import { capitalize$1 as capitalize, dedent$1 as dedent, dedentRaw$1 as dedentRaw, formatStr$1 as formatStr, sanitizeIdentifier$1 as sanitizeIdentifier, toCamelCase$1 as toCamelCase, toKebabCase$1 as toKebabCase, toPascalCase$1 as toPascalCase, toSnakeCase$1 as toSnakeCase } from "./string-CBWIJiC0.js";
 export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/types-B3iMkmi_.d.ts

@@ -0,0 +1,95 @@
+//#region src/types.d.ts
+/**
+ * Whatever type, or Promise of that type
+ * @param T - Type
+ * @returns T or Promise<T>
+ *
+ * @example
+ * ```ts
+ * type A = Awaitable<string>
+ * // string | Promise<string>
+ * ```
+ */
+type Awaitable<T> = T | PromiseLike<T>;
+/**
+ * Whatever type, or null
+ * @param T - Type
+ * @returns T or null
+ *
+ * @example
+ * ```ts
+ * type A = Nullable<string>
+ * // string | null
+ * ```
+ */
+type Nullable<T> = T | null;
+/**
+ * Whatever type, null or undefined
+ * @param T - Type
+ * @returns T, undefined or null
+ *
+ * @example
+ * ```ts
+ * type A = Nullish<string>
+ * // string | null | undefined
+ * ```
+ */
+type Nullish<T> = T | null | undefined;
+/**
+ * Array, or not yet
+ */
+type Arrayable<T> = T | Array<T>;
+/**
+ * Infers the element type of an array
+ * @param T - Array type
+ * @returns The inferred element type
+ *
+ * @example
+ * ```ts
+ * type A = ElementOf<string[]>
+ * // string
+ * ```
+ */
+type ElementOf<T> = T extends (infer E)[] ? E : never;
+/**
+ * Infers the arguments type of a function
+ * @param T - Function type
+ * @returns The inferred arguments type
+ *
+ * @example
+ * ```ts
+ * type A = InferArguments<(a: string, b: number) => void>
+ * // [string, number]
+ * ```
+ */
+type InferArguments<T> = T extends ((...args: infer A) => any) ? A : never;
+/**
+ * Makes complex nested types more readable in editor tooltips by flattening
+ * the type to a simple object type with all properties
+ * @param T - The type to prettify
+ * @returns A simplified representation of the same type
+ *
+ * @example
+ * ```ts
+ * type Messy = { a: string } & { b: number } & { c: boolean }
+ * type Clean = Prettify<Messy>
+ * // { a: string; b: number; c: boolean }
+ * ```
+ */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/**
+ * Removes index signatures from a type while preserving specific properties
+ * @param T - The type to remove index signatures from
+ * @returns A new type without index signatures
+ *
+ * @example
+ * ```ts
+ * type WithIndex = { id: number; [key: string]: any }
+ * type Clean = RemoveIndexSignature<WithIndex>
+ * // { id: number }
+ * ```
+ */
+type RemoveIndexSignature<T> = { [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K] };
+
+//#endregion
+export { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish, Prettify, RemoveIndexSignature };

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish } from "./types.d-BcKIY6l3.js";
-export { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish };
+import { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-B3iMkmi_.js";
+export { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish, Prettify, RemoveIndexSignature };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxass/utils",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "A collection of utilities for JavaScript/TypeScript",
   "type": "module",
   "author": {
@@ -41,13 +41,13 @@
   "devDependencies": {
     "@luxass/eslint-config": "^4.18.1",
     "@types/node": "^22.15.2",
-    "@vitest/coverage-v8": "3.1.2",
-    "eslint": "^9.25.1",
+    "@vitest/coverage-v8": "3.1.4",
+    "eslint": "^9.27.0",
     "eslint-plugin-format": "^1.0.1",
     "publint": "^0.3.12",
-    "tsdown": "^0.9.9",
+    "tsdown": "^0.11.12",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.2",
+    "vitest": "^3.1.4",
     "vitest-package-exports": "^0.1.1"
   },
   "scripts": {

package/dist/guards.d-n1BzCANy.d.ts

@@ -1,62 +0,0 @@
-//#region src/guards.d.ts
-/**
-* Checks if a value is not null or undefined.
-*
-* @template T - The type of the input value.
-* @param {T | null | undefined} v - The value to check for not being null or undefined.
-* @returns {v is NonNullable<T>} - True if the value is not null or undefined, false otherwise.
-*
-* @example
-* ```ts
-* [true, false, 0, 1, "", "hello", null, undefined].filter(isNotNullish)
-* // [true, false, 0, 1, "", "hello"]
-* ```
-*/declare function isNotNullish<T>(v: T | null | undefined): v is NonNullable<T>;
-
-/**
-* Checks if a value is not null.
-*
-* @template T - The type of the input value.
-* @param {T | null} v - The value to check for not being null.
-* @returns {v is Exclude<T, null>} True if the value is not null, false otherwise.
-*
-* @example
-* ```ts
-* [true, false, 0, 1, "", "hello", null, undefined].filter(isNotNull)
-* // [true, false, 0, 1, "", "hello", undefined]
-* ```
-*/
-declare function isNotNull<T>(v: T | null): v is Exclude<T, null>;
-
-/**
-* Checks if a value is defined.
-*
-* @template T - The type of the input value.
-* @param {T} v - The value to check for being defined.
-* @returns {v is Exclude<T, undefined>} True if the value is defined, false otherwise.
-*
-* @example
-* ```ts
-* [true, false, 0, 1, "", "hello", null, undefined].filter(isDefined)
-* // [true, false, 0, 1, "", "hello", null]
-* ```
-*/
-declare function isNotUndefined<T>(v: T): v is Exclude<T, undefined>;
-
-/**
-* Checks if a value is truthy, excluding null and undefined.
-*
-* @template T - The type of the input value.
-* @param {T} v - The value to check for truthiness.
-* @returns {v is NonNullable<T>} True if the value is truthy, false otherwise.
-*
-* @example
-* ```ts
-* [true, false, 0, 1, "", "hello", null, undefined].filter(isTruthy)
-* // [true, 1, "hello"]
-* ```
-*/
-declare function isTruthy<T>(v: T): v is NonNullable<T>;
-
-//#endregion
-export { isNotNull as isNotNull$1, isNotNullish as isNotNullish$1, isNotUndefined as isNotUndefined$1, isTruthy as isTruthy$1 };

package/dist/number.d-C2Xuq3Is.d.ts

@@ -1,23 +0,0 @@
-//#region src/number.d.ts
-/**
-* Clamp a value between a min and max value.
-* @param {number} value
-* @param {number} min
-* @param {number} max
-* @returns {number} the clamped value
-*
-* @example
-* ```ts
-* clamp(5, 0, 10)
-* // 5
-*
-* clamp(5, 10, 20)
-* // 10
-*
-* clamp(5, 0, 4)
-* // 4
-* ```
-*/declare function clamp(value: number, min: number, max: number): number;
-
-//#endregion
-export { clamp as clamp$1 };

package/dist/string.d-B2ppMtlR.d.ts

@@ -1,136 +0,0 @@
-//#region src/string.d.ts
-/**
-* Capitalizes the first character of a string and converts the rest to lowercase
-* @param {string} str - The string to capitalize
-* @returns {string} The capitalized string
-* @example
-* ```ts
-* capitalize("hello") // "Hello"
-* capitalize("hELLO") // "Hello"
-* capitalize("") // ""
-* ```
-*/declare function capitalize(str: string): string;
-
-/**
-* Converts a string to camelCase format
-* @param {string} str - The string to convert to camelCase
-* @returns {string} The string in camelCase format
-* @example
-* ```ts
-* toCamelCase("hello world") // "helloWorld"
-* toCamelCase("hello-world") // "helloWorld"
-* toCamelCase("hello_world") // "helloWorld"
-* toCamelCase("HelloWorld") // "helloWorld"
-* toCamelCase("") // ""
-* ```
-*/
-declare function toCamelCase(str: string): string;
-
-/**
-* Converts a string to kebab-case format
-* @param {string} str - The string to convert to kebab-case
-* @returns {string} The string in kebab-case format
-* @example
-* ```ts
-* toKebabCase("hello world") // "hello-world"
-* toKebabCase("helloWorld") // "hello-world"
-* toKebabCase("hello_world") // "hello-world"
-* toKebabCase("HelloWorld") // "hello-world"
-* toKebabCase("") // ""
-* ```
-*/
-declare function toKebabCase(str: string): string;
-
-/**
-* Converts a string to PascalCase format
-* @param {string} str - The string to convert to PascalCase
-* @returns {string} The string in PascalCase format
-* @example
-* ```ts
-* toPascalCase("hello world") // "HelloWorld"
-* toPascalCase("hello-world") // "HelloWorld"
-* toPascalCase("hello_world") // "HelloWorld"
-* toPascalCase("helloWorld") // "HelloWorld"
-* toPascalCase("") // ""
-* ```
-*/
-declare function toPascalCase(str: string): string;
-
-/**
-* Converts a string to snake_case format
-* @param {string} str - The string to convert to snake_case
-* @returns {string} The string in snake_case format
-* @example
-* ```ts
-* toSnakeCase("hello world") // "hello_world"
-* toSnakeCase("helloWorld") // "hello_world"
-* toSnakeCase("hello-world") // "hello_world"
-* toSnakeCase("HelloWorld") // "hello_world"
-* toSnakeCase("") // ""
-* ```
-*/
-declare function toSnakeCase(str: string): string;
-
-/**
-* Removes leading and trailing whitespace from each line of a string
-* @param {TemplateStringsArray | string} literals - The string to dedent
-* @returns {string} The dedented string
-* @example ```ts
-* dedent`
-*   This is a test.
-*   This is another line.
-* `
-* // "This is a test.\nThis is another line."
-* ```
-*/
-declare function dedent(literals: string): string;
-declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
-declare namespace dedent {
-  var raw: typeof dedentRaw;
-} /**
-  * Removes leading and trailing whitespace from each line of a string
-  * @param {TemplateStringsArray | string} literals - The string to dedent
-  * @returns {string} The dedented string
-  * @example ```ts
-  * dedent`
-  *   This is a test.
-  *   This is another line.
-  * `
-  * // "This is a test.\nThis is another line."
-  * ```
-  */
-
-declare function dedentRaw(literals: string): string;
-declare function dedentRaw(strings: TemplateStringsArray, ...values: unknown[]): string; /**
-                                                                                         * Ensures a string is a valid JavaScript identifier by prefixing with an underscore if necessary
-                                                                                         * @param {string} str - The string to sanitize
-                                                                                         * @returns {string} A valid JavaScript identifier
-                                                                                         * @example
-                                                                                         * ```ts
-                                                                                         * sanitizeIdentifier("validName") // "validName"
-                                                                                         * sanitizeIdentifier("123invalid") // "_123invalid"
-                                                                                         * sanitizeIdentifier("$valid") // "$valid"
-                                                                                         * sanitizeIdentifier("_valid") // "_valid"
-                                                                                         * ```
-                                                                                         */
-
-declare function sanitizeIdentifier(str: string): string; /**
-                                                          * Formats a string by replacing placeholders with positional values
-                                                          * @param {string} message - The string containing placeholders to be replaced
-                                                          * @param {...any} positionals - The values to insert into the placeholders
-                                                          * @returns {string} The formatted string
-                                                          *
-                                                          * @example
-                                                          * ```ts
-                                                          * formatStr("Hello %s", "world") // "Hello world"
-                                                          * formatStr("Count: %d", 5) // "Count: 5"
-                                                          * formatStr("Data: %j", { name: "test" }) // "Data: {"name":"test"}"
-                                                          * formatStr("Object: %o", { id: 1 }) // "Object: {"id":1}"
-                                                          * formatStr("Escaped %%s", "value") // "Escaped %s"
-                                                          * formatStr("Extra args", 1, 2) // "Extra args 1 2"
-                                                          * ```
-                                                          */
-
-declare function formatStr(message: string, ...positionals: unknown[]): string;
-//#endregion
-export { capitalize as capitalize$1, dedent as dedent$1, dedentRaw as dedentRaw$1, formatStr as formatStr$1, sanitizeIdentifier as sanitizeIdentifier$1, toCamelCase as toCamelCase$1, toKebabCase as toKebabCase$1, toPascalCase as toPascalCase$1, toSnakeCase as toSnakeCase$1 };

package/dist/types.d-BcKIY6l3.d.ts

@@ -1,72 +0,0 @@
-//#region src/types.d.ts
-/**
-* Whatever type, or Promise of that type
-* @param T - Type
-* @returns T or Promise<T>
-*
-* @example
-* ```ts
-* type A = Awaitable<string>
-* // string | Promise<string>
-* ```
-*/type Awaitable<T> = T | PromiseLike<T>;
-
-/**
-* Whatever type, or null
-* @param T - Type
-* @returns T or null
-*
-* @example
-* ```ts
-* type A = Nullable<string>
-* // string | null
-* ```
-*/
-type Nullable<T> = T | null;
-
-/**
-* Whatever type, null or undefined
-* @param T - Type
-* @returns T, undefined or null
-*
-* @example
-* ```ts
-* type A = Nullish<string>
-* // string | null | undefined
-* ```
-*/
-type Nullish<T> = T | null | undefined;
-
-/**
-* Array, or not yet
-*/
-type Arrayable<T> = T | Array<T>;
-
-/**
-* Infers the element type of an array
-* @param T - Array type
-* @returns The inferred element type
-*
-* @example
-* ```ts
-* type A = ElementOf<string[]>
-* // string
-* ```
-*/
-type ElementOf<T> = T extends (infer E)[] ? E : never;
-
-/**
-* Infers the arguments type of a function
-* @param T - Function type
-* @returns The inferred arguments type
-*
-* @example
-* ```ts
-* type A = InferArguments<(a: string, b: number) => void>
-* // [string, number]
-* ```
-*/
-type InferArguments<T> = T extends ((...args: infer A) => any) ? A : never;
-
-//#endregion
-export { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish };