@luxass/utils 2.2.2 → 2.4.0

package/dist/{guards-C19fJmlu.d.ts → guards-x9QZDUSt.d.ts}

@@ -55,6 +55,5 @@ declare function isNotUndefined<T>(v: T): v is Exclude<T, undefined>;
  * ```
  */
 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 };
+export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

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-C19fJmlu.js";
+import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-x9QZDUSt.js";
 export { isNotNull, isNotNullish, isNotUndefined, isTruthy };

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-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 { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-QETho94V.js";
+import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-x9QZDUSt.js";
+import { clamp } from "./number-DzUC7V5F.js";
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-BT3S70pM.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-BjsgnDeW.js";
+import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-DCrM3M9i.js";
+import pRetry from "p-retry";
 
 //#region src/common.d.ts
 declare class InvariantError extends Error {
@@ -18,6 +20,5 @@ declare class InvariantError extends Error {
  * @throws {InvariantError} Throws when the predicate is falsy
  */
 declare function invariant(predicate: unknown, message: string, ...positionals: unknown[]): asserts predicate;
-
 //#endregion
-export { ElementOf, InferArguments, InvariantError, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+export { ElementOf, InferArguments, InvariantError, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature, capitalize, clamp, dedent, dedentRaw, formatStr, getChangedKeys, getOwnProperty, hasOwnProperty, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, omit, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/index.js

@@ -1,7 +1,34 @@
 import { isNotNull, isNotNullish, isNotUndefined, isTruthy } from "./guards-O1HGJraI.js";
 import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-pQApOGKP.js";
 import { clamp } from "./number-BS9T5WGO.js";
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-CyGLe77G.js";
 
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
 //#region src/common.ts
 var InvariantError = class extends Error {
 	constructor(message, ...positionals) {
@@ -24,4 +51,270 @@ function invariant(predicate, message, ...positionals) {
 }
 
 //#endregion
-export { InvariantError, capitalize, clamp, dedent, dedentRaw, formatStr, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };
+//#region node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
+	function RetryOperation$1(timeouts, options) {
+		if (typeof options === "boolean") options = { forever: options };
+		this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+		this._timeouts = timeouts;
+		this._options = options || {};
+		this._maxRetryTime = options && options.maxRetryTime || Infinity;
+		this._fn = null;
+		this._errors = [];
+		this._attempts = 1;
+		this._operationTimeout = null;
+		this._operationTimeoutCb = null;
+		this._timeout = null;
+		this._operationStart = null;
+		this._timer = null;
+		if (this._options.forever) this._cachedTimeouts = this._timeouts.slice(0);
+	}
+	module.exports = RetryOperation$1;
+	RetryOperation$1.prototype.reset = function() {
+		this._attempts = 1;
+		this._timeouts = this._originalTimeouts.slice(0);
+	};
+	RetryOperation$1.prototype.stop = function() {
+		if (this._timeout) clearTimeout(this._timeout);
+		if (this._timer) clearTimeout(this._timer);
+		this._timeouts = [];
+		this._cachedTimeouts = null;
+	};
+	RetryOperation$1.prototype.retry = function(err) {
+		if (this._timeout) clearTimeout(this._timeout);
+		if (!err) return false;
+		var currentTime = (/* @__PURE__ */ new Date()).getTime();
+		if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+			this._errors.push(err);
+			this._errors.unshift(/* @__PURE__ */ new Error("RetryOperation timeout occurred"));
+			return false;
+		}
+		this._errors.push(err);
+		var timeout = this._timeouts.shift();
+		if (timeout === void 0) if (this._cachedTimeouts) {
+			this._errors.splice(0, this._errors.length - 1);
+			timeout = this._cachedTimeouts.slice(-1);
+		} else return false;
+		var self = this;
+		this._timer = setTimeout(function() {
+			self._attempts++;
+			if (self._operationTimeoutCb) {
+				self._timeout = setTimeout(function() {
+					self._operationTimeoutCb(self._attempts);
+				}, self._operationTimeout);
+				if (self._options.unref) self._timeout.unref();
+			}
+			self._fn(self._attempts);
+		}, timeout);
+		if (this._options.unref) this._timer.unref();
+		return true;
+	};
+	RetryOperation$1.prototype.attempt = function(fn, timeoutOps) {
+		this._fn = fn;
+		if (timeoutOps) {
+			if (timeoutOps.timeout) this._operationTimeout = timeoutOps.timeout;
+			if (timeoutOps.cb) this._operationTimeoutCb = timeoutOps.cb;
+		}
+		var self = this;
+		if (this._operationTimeoutCb) this._timeout = setTimeout(function() {
+			self._operationTimeoutCb();
+		}, self._operationTimeout);
+		this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+		this._fn(this._attempts);
+	};
+	RetryOperation$1.prototype.try = function(fn) {
+		console.log("Using RetryOperation.try() is deprecated");
+		this.attempt(fn);
+	};
+	RetryOperation$1.prototype.start = function(fn) {
+		console.log("Using RetryOperation.start() is deprecated");
+		this.attempt(fn);
+	};
+	RetryOperation$1.prototype.start = RetryOperation$1.prototype.try;
+	RetryOperation$1.prototype.errors = function() {
+		return this._errors;
+	};
+	RetryOperation$1.prototype.attempts = function() {
+		return this._attempts;
+	};
+	RetryOperation$1.prototype.mainError = function() {
+		if (this._errors.length === 0) return null;
+		var counts = {};
+		var mainError = null;
+		var mainErrorCount = 0;
+		for (var i = 0; i < this._errors.length; i++) {
+			var error = this._errors[i];
+			var message = error.message;
+			var count = (counts[message] || 0) + 1;
+			counts[message] = count;
+			if (count >= mainErrorCount) {
+				mainError = error;
+				mainErrorCount = count;
+			}
+		}
+		return mainError;
+	};
+} });
+
+//#endregion
+//#region node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
+var require_retry$1 = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
+	var RetryOperation = require_retry_operation();
+	exports.operation = function(options) {
+		var timeouts = exports.timeouts(options);
+		return new RetryOperation(timeouts, {
+			forever: options && (options.forever || options.retries === Infinity),
+			unref: options && options.unref,
+			maxRetryTime: options && options.maxRetryTime
+		});
+	};
+	exports.timeouts = function(options) {
+		if (options instanceof Array) return [].concat(options);
+		var opts = {
+			retries: 10,
+			factor: 2,
+			minTimeout: 1 * 1e3,
+			maxTimeout: Infinity,
+			randomize: false
+		};
+		for (var key in options) opts[key] = options[key];
+		if (opts.minTimeout > opts.maxTimeout) throw new Error("minTimeout is greater than maxTimeout");
+		var timeouts = [];
+		for (var i = 0; i < opts.retries; i++) timeouts.push(this.createTimeout(i, opts));
+		if (options && options.forever && !timeouts.length) timeouts.push(this.createTimeout(i, opts));
+		timeouts.sort(function(a, b) {
+			return a - b;
+		});
+		return timeouts;
+	};
+	exports.createTimeout = function(attempt, opts) {
+		var random = opts.randomize ? Math.random() + 1 : 1;
+		var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+		timeout = Math.min(timeout, opts.maxTimeout);
+		return timeout;
+	};
+	exports.wrap = function(obj, options, methods) {
+		if (options instanceof Array) {
+			methods = options;
+			options = null;
+		}
+		if (!methods) {
+			methods = [];
+			for (var key in obj) if (typeof obj[key] === "function") methods.push(key);
+		}
+		for (var i = 0; i < methods.length; i++) {
+			var method = methods[i];
+			var original = obj[method];
+			obj[method] = function retryWrapper(original$1) {
+				var op = exports.operation(options);
+				var args = Array.prototype.slice.call(arguments, 1);
+				var callback = args.pop();
+				args.push(function(err) {
+					if (op.retry(err)) return;
+					if (err) arguments[0] = op.mainError();
+					callback.apply(this, arguments);
+				});
+				op.attempt(function() {
+					original$1.apply(obj, args);
+				});
+			}.bind(obj, original);
+			obj[method].options = options;
+		}
+	};
+} });
+
+//#endregion
+//#region node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
+var require_retry = __commonJS({ "node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module) {
+	module.exports = require_retry$1();
+} });
+
+//#endregion
+//#region node_modules/.pnpm/is-network-error@1.1.0/node_modules/is-network-error/index.js
+const objectToString = Object.prototype.toString;
+const isError = (value) => objectToString.call(value) === "[object Error]";
+const errorMessages = new Set([
+	"network error",
+	"Failed to fetch",
+	"NetworkError when attempting to fetch resource.",
+	"The Internet connection appears to be offline.",
+	"Load failed",
+	"Network request failed",
+	"fetch failed",
+	"terminated"
+]);
+function isNetworkError(error) {
+	const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
+	if (!isValid) return false;
+	if (error.message === "Load failed") return error.stack === void 0;
+	return errorMessages.has(error.message);
+}
+
+//#endregion
+//#region node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
+var import_retry = __toESM(require_retry(), 1);
+var AbortError = class extends Error {
+	constructor(message) {
+		super();
+		if (message instanceof Error) {
+			this.originalError = message;
+			({message} = message);
+		} else {
+			this.originalError = new Error(message);
+			this.originalError.stack = this.stack;
+		}
+		this.name = "AbortError";
+		this.message = message;
+	}
+};
+const decorateErrorWithCounts = (error, attemptNumber, options) => {
+	const retriesLeft = options.retries - (attemptNumber - 1);
+	error.attemptNumber = attemptNumber;
+	error.retriesLeft = retriesLeft;
+	return error;
+};
+async function pRetry(input, options) {
+	return new Promise((resolve, reject) => {
+		options = { ...options };
+		options.onFailedAttempt ??= () => {};
+		options.shouldRetry ??= () => true;
+		options.retries ??= 10;
+		const operation = import_retry.operation(options);
+		const abortHandler = () => {
+			operation.stop();
+			reject(options.signal?.reason);
+		};
+		if (options.signal && !options.signal.aborted) options.signal.addEventListener("abort", abortHandler, { once: true });
+		const cleanUp = () => {
+			options.signal?.removeEventListener("abort", abortHandler);
+			operation.stop();
+		};
+		operation.attempt(async (attemptNumber) => {
+			try {
+				const result = await input(attemptNumber);
+				cleanUp();
+				resolve(result);
+			} catch (error) {
+				try {
+					if (!(error instanceof Error)) throw new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+					if (error instanceof AbortError) throw error.originalError;
+					if (error instanceof TypeError && !isNetworkError(error)) throw error;
+					decorateErrorWithCounts(error, attemptNumber, options);
+					if (!await options.shouldRetry(error)) {
+						operation.stop();
+						reject(error);
+					}
+					await options.onFailedAttempt(error);
+					if (!operation.retry(error)) throw operation.mainError();
+				} catch (finalError) {
+					decorateErrorWithCounts(finalError, attemptNumber, options);
+					cleanUp();
+					reject(finalError);
+				}
+			}
+		});
+	});
+}
+
+//#endregion
+export { InvariantError, capitalize, clamp, dedent, dedentRaw, formatStr, getChangedKeys, getOwnProperty, hasOwnProperty, invariant, isNotNull, isNotNullish, isNotUndefined, isTruthy, omit, pRetry as promiseRetry, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/{number-C2E_sOOy.d.ts → number-DzUC7V5F.d.ts}

@@ -19,6 +19,5 @@
  * ```
  */
 declare function clamp(value: number, min: number, max: number): number;
-
 //#endregion
-export { clamp as clamp$1 };
+export { clamp };

package/dist/number.d.ts

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

package/dist/object-BT3S70pM.d.ts

@@ -0,0 +1,84 @@
+//#region src/object.d.ts
+/**
+ * Checks if an object has a specific property as its own property (not inherited).
+ *
+ * @param {object} obj - The object to check
+ * @param {string} key - The property key to check for
+ * @returns {boolean} `true` if the object has the property as its own property, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * import { hasOwnProperty } from '@luxass/utils/object';
+ *
+ * const obj = { name: 'John' };
+ * hasOwnProperty(obj, 'name'); // true
+ * hasOwnProperty(obj, 'toString'); // false (inherited)
+ * ```
+ */
+declare function hasOwnProperty(obj: object, key: string): boolean;
+/**
+ * Safely gets an own property value from an object, returning undefined if the property doesn't exist.
+ *
+ * This function provides type-safe property access with multiple overloads:
+ * - For objects with known key-value types, returns the value type or undefined
+ * - For generic objects, returns the property value type or undefined
+ * - Fallback returns unknown type
+ *
+ * @param {object} obj - The object to get the property from
+ * @param {string} key - The property key to retrieve
+ * @returns {unknown} The property value if it exists as an own property, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * import { getOwnProperty } from '@luxass/utils/object';
+ *
+ * const obj = { name: 'John', age: 30 };
+ * getOwnProperty(obj, 'name'); // 'John'
+ * getOwnProperty(obj, 'missing'); // undefined
+ * ```
+ */
+declare function getOwnProperty<K extends string, V>(obj: Partial<Record<K, V>>, key: K): V | undefined;
+declare function getOwnProperty<O extends object>(obj: O, key: string): O[keyof O] | undefined;
+declare function getOwnProperty(obj: object, key: string): unknown;
+/**
+ * Compares two objects and returns an array of keys where the values differ.
+ *
+ * Uses Object.is() for comparison, which handles special cases like NaN and -0/+0 correctly.
+ * Only checks keys that exist in the first object.
+ *
+ * @template T - The type of objects being compared
+ * @param {T} obj1 - The first object to compare
+ * @param {T} obj2 - The second object to compare
+ * @returns {(keyof T)[]} An array of keys where the values differ between the two objects
+ *
+ * @example
+ * ```typescript
+ * import { getChangedKeys } from '@luxass/utils/object';
+ *
+ * const obj1 = { name: 'John', age: 30, city: 'NYC' };
+ * const obj2 = { name: 'John', age: 31, city: 'NYC' };
+ * getChangedKeys(obj1, obj2); // ['age']
+ * ```
+ */
+declare function getChangedKeys<T extends object>(obj1: T, obj2: T): (keyof T)[];
+/**
+ * Creates a new object with specified keys omitted from the original object.
+ *
+ * This function creates a shallow copy of the input object and removes the specified keys.
+ * The original object is not modified.
+ *
+ * @param {Record<string, unknown>} obj - The source object to omit keys from
+ * @param {ReadonlyArray<string>} keys - An array of key names to omit from the object
+ * @returns {Record<string, unknown>} A new object with the specified keys removed
+ *
+ * @example
+ * ```typescript
+ * import { omit } from '@luxass/utils/object';
+ *
+ * const obj = { name: 'John', age: 30, city: 'NYC', country: 'USA' };
+ * omit(obj, ['age', 'country']); // { name: 'John', city: 'NYC' }
+ * ```
+ */
+declare function omit(obj: Record<string, unknown>, keys: ReadonlyArray<string>): Record<string, unknown>;
+//#endregion
+export { getChangedKeys, getOwnProperty, hasOwnProperty, omit };

package/dist/object-CyGLe77G.js

@@ -0,0 +1,75 @@
+//#region src/object.ts
+/**
+* Checks if an object has a specific property as its own property (not inherited).
+*
+* @param {object} obj - The object to check
+* @param {string} key - The property key to check for
+* @returns {boolean} `true` if the object has the property as its own property, `false` otherwise
+*
+* @example
+* ```typescript
+* import { hasOwnProperty } from '@luxass/utils/object';
+*
+* const obj = { name: 'John' };
+* hasOwnProperty(obj, 'name'); // true
+* hasOwnProperty(obj, 'toString'); // false (inherited)
+* ```
+*/
+function hasOwnProperty(obj, key) {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function getOwnProperty(obj, key) {
+	if (!hasOwnProperty(obj, key)) return void 0;
+	return obj[key];
+}
+/**
+* Compares two objects and returns an array of keys where the values differ.
+*
+* Uses Object.is() for comparison, which handles special cases like NaN and -0/+0 correctly.
+* Only checks keys that exist in the first object.
+*
+* @template T - The type of objects being compared
+* @param {T} obj1 - The first object to compare
+* @param {T} obj2 - The second object to compare
+* @returns {(keyof T)[]} An array of keys where the values differ between the two objects
+*
+* @example
+* ```typescript
+* import { getChangedKeys } from '@luxass/utils/object';
+*
+* const obj1 = { name: 'John', age: 30, city: 'NYC' };
+* const obj2 = { name: 'John', age: 31, city: 'NYC' };
+* getChangedKeys(obj1, obj2); // ['age']
+* ```
+*/
+function getChangedKeys(obj1, obj2) {
+	const result = [];
+	for (const key in obj1) if (!Object.is(obj1[key], obj2[key])) result.push(key);
+	return result;
+}
+/**
+* Creates a new object with specified keys omitted from the original object.
+*
+* This function creates a shallow copy of the input object and removes the specified keys.
+* The original object is not modified.
+*
+* @param {Record<string, unknown>} obj - The source object to omit keys from
+* @param {ReadonlyArray<string>} keys - An array of key names to omit from the object
+* @returns {Record<string, unknown>} A new object with the specified keys removed
+*
+* @example
+* ```typescript
+* import { omit } from '@luxass/utils/object';
+*
+* const obj = { name: 'John', age: 30, city: 'NYC', country: 'USA' };
+* omit(obj, ['age', 'country']); // { name: 'John', city: 'NYC' }
+* ```
+*/
+function omit(obj, keys) {
+	const result = { ...obj };
+	for (const key of keys) delete result[key];
+	return result;
+}
+
+//#endregion
+export { getChangedKeys, getOwnProperty, hasOwnProperty, omit };

package/dist/object.d.ts

@@ -0,0 +1,2 @@
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-BT3S70pM.js";
+export { getChangedKeys, getOwnProperty, hasOwnProperty, omit };

package/dist/object.js

@@ -0,0 +1,3 @@
+import { getChangedKeys, getOwnProperty, hasOwnProperty, omit } from "./object-CyGLe77G.js";
+
+export { getChangedKeys, getOwnProperty, hasOwnProperty, omit };

package/dist/{string-CBWIJiC0.d.ts → string-BjsgnDeW.d.ts}

@@ -129,4 +129,4 @@ declare function sanitizeIdentifier(str: string): string;
  */
 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 };
+export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

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-CBWIJiC0.js";
+import { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase } from "./string-BjsgnDeW.js";
 export { capitalize, dedent, dedentRaw, formatStr, sanitizeIdentifier, toCamelCase, toKebabCase, toPascalCase, toSnakeCase };

package/dist/{types-QETho94V.d.ts → types-DCrM3M9i.d.ts}

@@ -82,6 +82,5 @@ type Prettify<T> = { [K in keyof T]: T[K] } & {};
  * ```
  */
 type RemoveIndexSignature<T> = { [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K] };
-
 //#endregion
 export { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature };

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-QETho94V.js";
+import { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature } from "./types-DCrM3M9i.js";
 export { ElementOf, InferArguments, MaybeArray, MaybePromise, Nullable, Nullish, Prettify, RemoveIndexSignature };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxass/utils",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "description": "A collection of utilities for JavaScript/TypeScript",
   "type": "module",
   "author": {
@@ -23,9 +23,10 @@
   "sideEffects": false,
   "exports": {
     ".": "./dist/index.js",
-    "./string": "./dist/string.js",
     "./guards": "./dist/guards.js",
     "./number": "./dist/number.js",
+    "./object": "./dist/object.js",
+    "./string": "./dist/string.js",
     "./types": "./dist/types.js",
     "./package.json": "./package.json"
   },
@@ -38,6 +39,9 @@
   "engines": {
     "node": ">=20"
   },
+  "dependencies": {
+    "p-retry": "^6.2.1"
+  },
   "devDependencies": {
     "@luxass/eslint-config": "^4.18.1",
     "@types/node": "^22.15.2",
@@ -45,7 +49,7 @@
     "eslint": "^9.27.0",
     "eslint-plugin-format": "^1.0.1",
     "publint": "^0.3.12",
-    "tsdown": "^0.11.12",
+    "tsdown": "^0.12.9",
     "typescript": "^5.8.3",
     "vitest": "^3.1.4",
     "vitest-package-exports": "^0.1.1"