@luxass/utils 1.6.1 → 2.1.0

package/dist/index.d.ts

@@ -1,5 +1,24 @@
 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, sanitizeIdentifier$1 as sanitizeIdentifier, toCamelCase$1 as toCamelCase, toKebabCase$1 as toKebabCase, toPascalCase$1 as toPascalCase, toSnakeCase$1 as toSnakeCase } from "./string.d-BSY3kSBV.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";
-export { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish, capitalize, clamp, dedent, dedentRaw, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+
+//#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
+*/
+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 };

package/dist/index.js

@@ -1,5 +1,27 @@
 import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-O1HGJraI.js";
-import { clamp } from "./number-Bfr1z0Nr.js";
-import { capitalize, dedent, dedentRaw, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-bY1lSRQs.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-pQApOGKP.js";
+import { clamp } from "./number-BS9T5WGO.js";
 
-export { capitalize, clamp, dedent, dedentRaw, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+//#region src/common.ts
+var InvariantError = class extends Error {
+	constructor(message, ...positionals) {
+		super(message);
+		this.message = message;
+		this.message = formatStr(message, ...positionals);
+	}
+};
+/**
+* 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
+*/
+function invariant(predicate, message, ...positionals) {
+	if (!predicate) throw new InvariantError(message, ...positionals);
+}
+
+//#endregion
+export { InvariantError, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/number.js

@@ -1,3 +1,3 @@
-import { clamp } from "./number-Bfr1z0Nr.js";
+import { clamp } from "./number-BS9T5WGO.js";
 
 export { clamp };

package/dist/{string-CxNDb3Ui.cjs → string-pQApOGKP.js}

@@ -1,5 +1,3 @@
-"use strict";
-
 //#region src/string.ts
 const FULL_WHITESPACE_RE = /^\s*$/;
 /**
@@ -138,53 +136,51 @@ function sanitizeIdentifier(str) {
 	const cleaned = str.replace(/[^\w$]/g, "");
 	return /^[A-Z_$]/i.test(cleaned) ? cleaned : `_${cleaned}`;
 }
+const POSITION_REGEX = /(%?)(%([sdijo]))/g;
+/** @internal */
+function serializePositional(positional, flag) {
+	if (flag === "s") return positional;
+	if (flag === "d" || flag === "i") return Number(positional);
+	if (flag === "j") return JSON.stringify(positional);
+	if (flag === "o") {
+		if (typeof positional === "string") return positional;
+		const json = JSON.stringify(positional);
+		if (json === "{}" || json === "[]" || /^\[object .+?\]$/.test(json)) return positional;
+		return json;
+	}
+}
+/**
+* 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"
+* ```
+*/
+function formatStr(message, ...positionals) {
+	if (!positionals.length) return message;
+	let positionalIndex = 0;
+	let formattedMessage = message.replace(POSITION_REGEX, (match, isEscaped, _, flag) => {
+		const positional = positionals[positionalIndex];
+		const value = serializePositional(positional, flag);
+		if (!isEscaped) {
+			positionalIndex++;
+			return value;
+		}
+		return match;
+	});
+	if (positionalIndex < positionals.length) formattedMessage += ` ${positionals.slice(positionalIndex).join(" ")}`;
+	formattedMessage = formattedMessage.replace(/%{2}/g, "%");
+	return formattedMessage;
+}
 
 //#endregion
-Object.defineProperty(exports, 'capitalize', {
-  enumerable: true,
-  get: function () {
-    return capitalize;
-  }
-});
-Object.defineProperty(exports, 'dedent', {
-  enumerable: true,
-  get: function () {
-    return dedent;
-  }
-});
-Object.defineProperty(exports, 'dedentRaw', {
-  enumerable: true,
-  get: function () {
-    return dedentRaw;
-  }
-});
-Object.defineProperty(exports, 'sanitizeIdentifier', {
-  enumerable: true,
-  get: function () {
-    return sanitizeIdentifier;
-  }
-});
-Object.defineProperty(exports, 'toCamelCase', {
-  enumerable: true,
-  get: function () {
-    return toCamelCase;
-  }
-});
-Object.defineProperty(exports, 'toKebabCase', {
-  enumerable: true,
-  get: function () {
-    return toKebabCase;
-  }
-});
-Object.defineProperty(exports, 'toPascalCase', {
-  enumerable: true,
-  get: function () {
-    return toPascalCase;
-  }
-});
-Object.defineProperty(exports, 'toSnakeCase', {
-  enumerable: true,
-  get: function () {
-    return toSnakeCase;
-  }
-});
+export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/{string.d-BSY3kSBV.d.ts → string.d-B2ppMtlR.d.ts}

@@ -114,6 +114,23 @@ declare function dedentRaw(strings: TemplateStringsArray, ...values: unknown[]):
                                                                                          * ```
                                                                                          */
 
-declare function sanitizeIdentifier(str: string): string;
+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, sanitizeIdentifier as sanitizeIdentifier$1, toCamelCase as toCamelCase$1, toKebabCase as toKebabCase$1, toPascalCase as toPascalCase$1, toSnakeCase as toSnakeCase$1 };
+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, sanitizeIdentifier$1 as sanitizeIdentifier, toCamelCase$1 as toCamelCase, toKebabCase$1 as toKebabCase, toPascalCase$1 as toPascalCase, toSnakeCase$1 as toSnakeCase } from "./string.d-BSY3kSBV.js";
-export { capitalize, dedent, dedentRaw, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+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";
+export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string.js

@@ -1,3 +1,3 @@
-import { capitalize, dedent, dedentRaw, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-bY1lSRQs.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-pQApOGKP.js";
 
-export { capitalize, dedent, dedentRaw, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxass/utils",
-  "version": "1.6.1",
+  "version": "2.1.0",
   "description": "A collection of utilities for JavaScript/TypeScript",
   "type": "module",
   "author": {
@@ -22,49 +22,14 @@
   ],
   "sideEffects": false,
   "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    },
-    "./guards": {
-      "import": {
-        "types": "./dist/guards.d.ts",
-        "default": "./dist/guards.js"
-      },
-      "require": {
-        "types": "./dist/guards.d.cts",
-        "default": "./dist/guards.cjs"
-      }
-    },
-    "./number": {
-      "import": {
-        "types": "./dist/number.d.ts",
-        "default": "./dist/number.js"
-      },
-      "require": {
-        "types": "./dist/number.d.cts",
-        "default": "./dist/number.cjs"
-      }
-    },
-    "./types": {
-      "import": {
-        "types": "./dist/types.d.ts",
-        "default": "./dist/types.js"
-      },
-      "require": {
-        "types": "./dist/types.d.cts",
-        "default": "./dist/types.cjs"
-      }
-    },
+    ".": "./dist/index.js",
+    "./string": "./dist/string.js",
+    "./guards": "./dist/guards.js",
+    "./number": "./dist/number.js",
+    "./types": "./dist/types.js",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -82,7 +47,8 @@
     "publint": "^0.3.12",
     "tsdown": "^0.9.9",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.2"
+    "vitest": "^3.1.2",
+    "vitest-package-exports": "^0.1.1"
   },
   "scripts": {
     "build": "tsdown",

package/dist/guards-DE5pQVvl.cjs

@@ -1,93 +0,0 @@
-"use strict";
-
-//#region src/guards.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"]
-* ```
-*/
-function isNotNullish(v) {
-	return v != null;
-}
-/**
-* 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]
-* ```
-*/
-function isNotNull(v) {
-	return v !== 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]
-* ```
-*/
-function isNotUndefined(v) {
-	return v !== void 0;
-}
-/**
-* 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"]
-* ```
-*/
-function isTruthy(v) {
-	return Boolean(v);
-}
-
-//#endregion
-Object.defineProperty(exports, 'isNotNull', {
-  enumerable: true,
-  get: function () {
-    return isNotNull;
-  }
-});
-Object.defineProperty(exports, 'isNotNullish', {
-  enumerable: true,
-  get: function () {
-    return isNotNullish;
-  }
-});
-Object.defineProperty(exports, 'isNotUndefined', {
-  enumerable: true,
-  get: function () {
-    return isNotUndefined;
-  }
-});
-Object.defineProperty(exports, 'isTruthy', {
-  enumerable: true,
-  get: function () {
-    return isTruthy;
-  }
-});

package/dist/guards.cjs

@@ -1,6 +0,0 @@
-const require_guards = require('./guards-DE5pQVvl.cjs');
-
-exports.isNotNull = require_guards.isNotNull
-exports.isNotNullish = require_guards.isNotNullish
-exports.isNotUndefined = require_guards.isNotUndefined
-exports.isTruthy = require_guards.isTruthy

package/dist/guards.d-DXUlpL_S.d.cts

@@ -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, isNotNullish, isNotUndefined, isTruthy };

package/dist/guards.d.cts

@@ -1,2 +0,0 @@
-import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards.d-DXUlpL_S.cjs";
-export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

package/dist/index.cjs

@@ -1,17 +0,0 @@
-const require_guards = require('./guards-DE5pQVvl.cjs');
-const require_number = require('./number-DRbo8lb6.cjs');
-const require_string = require('./string-CxNDb3Ui.cjs');
-
-exports.capitalize = require_string.capitalize
-exports.clamp = require_number.clamp
-exports.dedent = require_string.dedent
-exports.dedentRaw = require_string.dedentRaw
-exports.isNotNull = require_guards.isNotNull
-exports.isNotNullish = require_guards.isNotNullish
-exports.isNotUndefined = require_guards.isNotUndefined
-exports.isTruthy = require_guards.isTruthy
-exports.sanitizeIdentifier = require_string.sanitizeIdentifier
-exports.toCamelCase = require_string.toCamelCase
-exports.toKebabCase = require_string.toKebabCase
-exports.toPascalCase = require_string.toPascalCase
-exports.toSnakeCase = require_string.toSnakeCase

package/dist/index.d.cts

@@ -1,5 +0,0 @@
-import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards.d-DXUlpL_S.cjs";
-import { clamp } from "./number.d-C1FAMQlq.cjs";
-import { capitalize, dedent, dedentRaw, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string.d-Dm-Z_ZP2.cjs";
-import { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish } from "./types.d-fcYBBT6c.cjs";
-export { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish, capitalize, clamp, dedent, dedentRaw, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/number-DRbo8lb6.cjs

@@ -1,33 +0,0 @@
-"use strict";
-
-//#region src/number.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
-* ```
-*/
-function clamp(value, min, max) {
-	return Math.min(Math.max(value, min), max);
-}
-
-//#endregion
-Object.defineProperty(exports, 'clamp', {
-  enumerable: true,
-  get: function () {
-    return clamp;
-  }
-});

package/dist/number.cjs

@@ -1,3 +0,0 @@
-const require_number = require('./number-DRbo8lb6.cjs');
-
-exports.clamp = require_number.clamp

package/dist/number.d-C1FAMQlq.d.cts

@@ -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 };

package/dist/number.d.cts

@@ -1,2 +0,0 @@
-import { clamp } from "./number.d-C1FAMQlq.cjs";
-export { clamp };

package/dist/string-bY1lSRQs.js

@@ -1,141 +0,0 @@
-//#region src/string.ts
-const FULL_WHITESPACE_RE = /^\s*$/;
-/**
-* 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("") // ""
-* ```
-*/
-function capitalize(str) {
-	if (!str) return "";
-	return str[0].toUpperCase() + str.slice(1).toLowerCase();
-}
-/**
-* 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("") // ""
-* ```
-*/
-function toCamelCase(str) {
-	if (!str) return "";
-	str = str.trim().replace(/\s+/g, " ");
-	const words = str.split(/[\s\-_]+/);
-	if (words.length === 1 && words[0]?.length === 1) return words[0].toLowerCase();
-	let result = words[0]?.toLowerCase() || "";
-	for (let i = 1; i < words.length; i++) {
-		const word = words[i];
-		if (!word) continue;
-		const hasCamelCase = word.match(/[a-z][A-Z]/g);
-		result += hasCamelCase ? word.charAt(0).toUpperCase() + word.slice(1) : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-	}
-	return result;
-}
-/**
-* 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("") // ""
-* ```
-*/
-function toKebabCase(str) {
-	if (!str) return "";
-	return str.trim().replace(/_/g, "-").replace(/\s+/g, " ").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/\s+/g, "-").replace(/-+/g, "-").toLowerCase();
-}
-/**
-* 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("") // ""
-* ```
-*/
-function toPascalCase(str) {
-	if (!str) return "";
-	return str.trim().replace(/[_-]+/g, " ").replace(/\s+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").replace(/(\d+)([a-z])/gi, "$1 $2").split(" ").filter((word) => word.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-}
-/**
-* 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("") // ""
-* ```
-*/
-function toSnakeCase(str) {
-	if (!str) return "";
-	return str.trim().replace(/-/g, "_").replace(/\s+/g, " ").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/\s+/g, "_").replace(/_+/g, "_").toLowerCase();
-}
-function dedent(strings, ...values) {
-	return internal_dedent(strings, values, false);
-}
-dedent.raw = dedentRaw;
-function dedentRaw(strings, ...values) {
-	return internal_dedent(strings, values, true);
-}
-/** @internal */
-function internal_dedent(strings, values, raw = false) {
-	const _raw = typeof strings === "string" ? [strings] : raw ? strings.raw : strings;
-	let result = "";
-	for (let i = 0; i < _raw.length; i++) {
-		const next = _raw[i];
-		result += next;
-		if (i < values.length) result += values[i];
-	}
-	const lines = result.split("\n");
-	const whitespaceLines = lines.map((line) => FULL_WHITESPACE_RE.test(line));
-	const commonIndent = lines.reduce((min, line, idx) => {
-		if (whitespaceLines[idx]) return min;
-		const indent = line.match(/^\s*/)?.[0].length;
-		return indent === void 0 ? min : Math.min(min, indent);
-	}, Number.POSITIVE_INFINITY);
-	const firstNonWhitespaceLine = whitespaceLines.findIndex((isWhitespace) => !isWhitespace);
-	const lastNonWhitespaceLine = whitespaceLines.lastIndexOf(false);
-	return lines.slice(firstNonWhitespaceLine >= 0 ? firstNonWhitespaceLine : 0, lastNonWhitespaceLine >= 0 ? lastNonWhitespaceLine + 1 : lines.length).map((line) => line.slice(commonIndent)).join("\n");
-}
-/**
-* 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"
-* ```
-*/
-function sanitizeIdentifier(str) {
-	const cleaned = str.replace(/[^\w$]/g, "");
-	return /^[A-Z_$]/i.test(cleaned) ? cleaned : `_${cleaned}`;
-}
-
-//#endregion
-export { capitalize, dedent, dedentRaw, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string.cjs

@@ -1,10 +0,0 @@
-const require_string = require('./string-CxNDb3Ui.cjs');
-
-exports.capitalize = require_string.capitalize
-exports.dedent = require_string.dedent
-exports.dedentRaw = require_string.dedentRaw
-exports.sanitizeIdentifier = require_string.sanitizeIdentifier
-exports.toCamelCase = require_string.toCamelCase
-exports.toKebabCase = require_string.toKebabCase
-exports.toPascalCase = require_string.toPascalCase
-exports.toSnakeCase = require_string.toSnakeCase

package/dist/string.d-Dm-Z_ZP2.d.cts

@@ -1,119 +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;
-//#endregion
-export { capitalize, dedent, dedentRaw, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/string.d.cts

@@ -1,2 +0,0 @@
-import { capitalize, dedent, dedentRaw, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string.d-Dm-Z_ZP2.cjs";
-export { capitalize, dedent, dedentRaw, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/types.d-fcYBBT6c.d.cts

@@ -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 };

package/dist/types.d.cts

@@ -1,2 +0,0 @@
-import { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish } from "./types.d-fcYBBT6c.cjs";
-export { Arrayable, Awaitable, ElementOf, InferArguments, Nullable, Nullish };