@oviirup/utils 1.0.5 → 1.0.7

package/dist/{array.d.ts → array/index.d.ts}

@@ -1,3 +1,6 @@
+declare namespace index_d_exports {
+  export { at, chunk, first, last, move, range, toArray, toFiltered, unique };
+}
 /**
  * Converts a given value to represent itself in an array
  * @param value The value to convert to an array
@@ -55,5 +58,12 @@ declare function toFiltered<T>(array: T[], predicate: Predicate<T>): T[];
  * @category Array
  */
 declare function move<T>(array: T[], from: number, to: number): T[];
-
-export { at, first, last, move, range, toArray, toFiltered, unique };
+/**
+ * Chunk an array into smaller arrays of a given size
+ * @param array The array to chunk
+ * @param size The size of the chunks
+ * @category Array
+ */
+declare function chunk<T>(array: T[], size: number): T[][];
+//#endregion
+export { at, chunk, first, last, move, range, index_d_exports as t, toArray, toFiltered, unique };

package/dist/array/index.js

@@ -0,0 +1,99 @@
+import { t as __exportAll } from "../chunk-BYypO7fO.js";
+import { isEmptyArray } from "../assertions/index.js";
+
+//#region src/array/index.ts
+var array_exports = /* @__PURE__ */ __exportAll({
+	at: () => at,
+	chunk: () => chunk,
+	first: () => first,
+	last: () => last,
+	move: () => move,
+	range: () => range,
+	toArray: () => toArray,
+	toFiltered: () => toFiltered,
+	unique: () => unique
+});
+/**
+* Converts a given value to represent itself in an array
+* @param value The value to convert to an array
+* @category Array
+*/
+function toArray(array) {
+	array = array ?? [];
+	return Array.isArray(array) ? array : [array];
+}
+function unique(value, equals) {
+	if (typeof equals !== "function") return Array.from(new Set(value));
+	return value.reduce((acc, item) => {
+		if (acc.findIndex((e) => equals(e, item)) === -1) acc.push(item);
+		return acc;
+	}, []);
+}
+function at(array, index) {
+	const len = array.length;
+	if (!len) return void 0;
+	if (index < 0) index += len;
+	return array[index];
+}
+function last(array) {
+	return at(array, -1);
+}
+function first(array) {
+	return at(array, 0);
+}
+function range(...args) {
+	let start = 0;
+	let stop;
+	let step = 1;
+	if (args.length === 1) [stop] = args;
+	else [start, stop, step = 1] = args;
+	const array = [];
+	let current = start;
+	while (current < stop) {
+		array.push(current);
+		current += step;
+	}
+	return array;
+}
+/**
+* Filter an array in place (faster than Array.filter)
+* @param array The array to filter
+* @param predicate The predicate function to use to filter the array
+* @category Array
+*/
+function toFiltered(array, predicate) {
+	for (let i = array.length - 1; i >= 0; i--) if (!predicate(array[i], i, array)) array.splice(i, 1);
+	return array;
+}
+/**
+* Move an item in an array to a new position
+* @param array The array to move the item in
+* @param from The index of the item to move
+* @param to The index to move the item to
+* @category Array
+*/
+function move(array, from, to) {
+	if (isEmptyArray(array)) return array;
+	if (from === to) return array;
+	const item = array[from];
+	array.splice(from, 1);
+	array.splice(to, 0, item);
+	return array;
+}
+/**
+* Chunk an array into smaller arrays of a given size
+* @param array The array to chunk
+* @param size The size of the chunks
+* @category Array
+*/
+function chunk(array, size) {
+	return array.reduce((acc, item, index) => {
+		const chunkIndex = Math.floor(index / size);
+		if (!acc[chunkIndex]) acc[chunkIndex] = [];
+		acc[chunkIndex].push(item);
+		return acc;
+	}, []);
+}
+
+//#endregion
+export { at, chunk, first, last, move, range, array_exports as t, toArray, toFiltered, unique };

package/dist/{assertions.d.ts → assertions/index.d.ts}

@@ -1,5 +1,6 @@
-import { Dictionary, AnyFunction, Predicate, NegatePredicate } from './types.js';
+import { AnyFunction, Dictionary, NegatePredicate, Predicate } from "../types.js";
 
+//#region src/assertions/index.d.ts
 /** Check if given value is a string */
 declare function isString(val: unknown): val is string;
 /** Check if the given value is a number */
@@ -24,8 +25,9 @@ declare function isFunction(val: any): val is AnyFunction<any>;
 declare function isRegex(val: unknown): val is RegExp;
 /** Check if the given value is truthy */
 declare function isTruthy(val: unknown): boolean;
+/** Check if the code is running in a browser environment */
 declare function isBrowser(): boolean;
 /** Negate an assertion function, returning a new function with the opposite boolean result */
 declare function not<T extends Predicate>(fn: T): NegatePredicate<T>;
-
-export { isArray, isBrowser, isEmpty, isEmptyArray, isEmptyObject, isFloat, isFunction, isInteger, isNumber, isObject, isRegex, isString, isTruthy, not };
+//#endregion
+export { isArray, isBrowser, isEmpty, isEmptyArray, isEmptyObject, isFloat, isFunction, isInteger, isNumber, isObject, isRegex, isString, isTruthy, not };

package/dist/assertions/index.js

@@ -0,0 +1,64 @@
+//#region src/assertions/index.ts
+/** Check if given value is a string */
+function isString(val) {
+	return typeof val === "string";
+}
+/** Check if the given value is a number */
+function isNumber(val) {
+	return typeof val === "number" && !Number.isNaN(val);
+}
+/** Check if the given value is an integer */
+function isInteger(val) {
+	return isNumber(val) && Number.isInteger(val);
+}
+/** Check if the given value is a float */
+function isFloat(val) {
+	return isNumber(val) && !Number.isInteger(val);
+}
+/** Check if given value is an array */
+function isArray(val) {
+	return Array.isArray(val);
+}
+/** Check if given array is empty */
+function isEmptyArray(val) {
+	return isArray(val) && val.length === 0;
+}
+/** Check if given value is an object */
+function isObject(val) {
+	return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+/** Check if given object is empty */
+function isEmptyObject(val) {
+	return Object.keys(val).length === 0;
+}
+/** Check if the given value is empty, null, undefined, or a string with no content */
+function isEmpty(val) {
+	if (val === null || val === void 0) return true;
+	if (typeof val === "string" && val.trim() === "") return true;
+	if (isArray(val)) return isEmptyArray(val);
+	if (isObject(val)) return isEmptyObject(val);
+	return false;
+}
+/** Check if the given object is a function */
+function isFunction(val) {
+	return typeof val === "function";
+}
+/** Check if the given value is a regex */
+function isRegex(val) {
+	return val instanceof RegExp;
+}
+/** Check if the given value is truthy */
+function isTruthy(val) {
+	return !!val;
+}
+/** Check if the code is running in a browser environment */
+function isBrowser() {
+	return typeof window !== "undefined";
+}
+/** Negate an assertion function, returning a new function with the opposite boolean result */
+function not(fn) {
+	return ((val) => !fn(val));
+}
+
+//#endregion
+export { isArray, isBrowser, isEmpty, isEmptyArray, isEmptyObject, isFloat, isFunction, isInteger, isNumber, isObject, isRegex, isString, isTruthy, not };

package/dist/chunk-BYypO7fO.js

@@ -0,0 +1,18 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/dist/{clsx.d.ts → clsx/index.d.ts}

@@ -1,10 +1,10 @@
-import { ClassNameValue } from './types.js';
-export { ClassNameValue } from './types.js';
+import { ClassNameValue } from "../types.js";
 
+//#region src/clsx/index.d.ts
 /**
  * Utility function to construct class names conditionally
  * @category ClassNames
  */
 declare function clsx(...inputs: ClassNameValue[]): string;
-
-export { clsx };
+//#endregion
+export { type ClassNameValue, clsx };

package/dist/clsx/index.js

@@ -0,0 +1,40 @@
+import { isArray, isNumber, isObject, isString } from "../assertions/index.js";
+
+//#region src/clsx/index.ts
+function toClassValue(value) {
+	let names = "";
+	let temp;
+	if (isString(value) || isNumber(value)) {
+		if (value) names += value.toString().trim();
+	} else if (isArray(value)) for (const item of value) {
+		temp = toClassValue(item);
+		if (!temp) continue;
+		if (names) names += " ";
+		names += temp;
+	}
+	else if (isObject(value)) for (const key in value) {
+		if (!value[key]) continue;
+		if (names) names += " ";
+		names += key;
+	}
+	return names;
+}
+/**
+* Utility function to construct class names conditionally
+* @category ClassNames
+*/
+function clsx(...inputs) {
+	let result = "";
+	let temp;
+	for (const arg of inputs) {
+		if (!arg) continue;
+		temp = toClassValue(arg);
+		if (!temp) continue;
+		if (result) result += " ";
+		result += temp;
+	}
+	return result;
+}
+
+//#endregion
+export { clsx };

package/dist/index.d.ts

@@ -1,13 +1,10 @@
-import * as array_d_ts from './array.js';
-export { array_d_ts as array };
-export * from './assertions.js';
-export * from './clsx.js';
-export * from './nanoid.js';
-import * as number_d_ts from './number.js';
-export { number_d_ts as number };
-import * as object_d_ts from './object.js';
-export { object_d_ts as object };
-import * as promise_d_ts from './promise.js';
-export { promise_d_ts as promise };
-import * as string_d_ts from './string.js';
-export { string_d_ts as string };
+import { t as index_d_exports } from "./array/index.js";
+import { ClassNameValue } from "./types.js";
+import { isArray, isBrowser, isEmpty, isEmptyArray, isEmptyObject, isFloat, isFunction, isInteger, isNumber, isObject, isRegex, isString, isTruthy, not } from "./assertions/index.js";
+import { clsx } from "./clsx/index.js";
+import { charset, nanoid } from "./nanoid/index.js";
+import { t as index_d_exports$1 } from "./number/index.js";
+import { t as object_d_exports } from "./object.js";
+import { t as index_d_exports$2 } from "./promise/index.js";
+import { t as index_d_exports$3 } from "./string/index.js";
+export { ClassNameValue, index_d_exports as array, charset, clsx, isArray, isBrowser, isEmpty, isEmptyArray, isEmptyObject, isFloat, isFunction, isInteger, isNumber, isObject, isRegex, isString, isTruthy, nanoid, not, index_d_exports$1 as number, object_d_exports as object, index_d_exports$2 as promise, index_d_exports$3 as string };

package/dist/index.js

@@ -1 +1,10 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./array.js"),r=require("./assertions.js"),t=require("./clsx.js"),o=require("./nanoid.js"),n=require("./number.js"),s=require("./object.js"),u=require("./promise.js"),c=require("./string.js");function a(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach(function(t){if("default"!==t){var o=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,o.get?o:{enumerable:!0,get:function(){return e[t]}})}}),r.default=e,r}var i=a(e),p=a(n),f=a(s),j=a(u),b=a(c);exports.array=i,exports.number=p,exports.object=f,exports.promise=j,exports.string=b,Object.keys(r).forEach(function(e){"default"===e||Object.prototype.hasOwnProperty.call(exports,e)||Object.defineProperty(exports,e,{enumerable:!0,get:function(){return r[e]}})}),Object.keys(t).forEach(function(e){"default"===e||Object.prototype.hasOwnProperty.call(exports,e)||Object.defineProperty(exports,e,{enumerable:!0,get:function(){return t[e]}})}),Object.keys(o).forEach(function(e){"default"===e||Object.prototype.hasOwnProperty.call(exports,e)||Object.defineProperty(exports,e,{enumerable:!0,get:function(){return o[e]}})});
+import { isArray, isBrowser, isEmpty, isEmptyArray, isEmptyObject, isFloat, isFunction, isInteger, isNumber, isObject, isRegex, isString, isTruthy, not } from "./assertions/index.js";
+import { t as array_exports } from "./array/index.js";
+import { clsx } from "./clsx/index.js";
+import { charset, nanoid } from "./nanoid/index.js";
+import { t as number_exports } from "./number/index.js";
+import { t as object_exports } from "./object.js";
+import { t as promise_exports } from "./promise/index.js";
+import { t as string_exports } from "./string/index.js";
+
+export { array_exports as array, charset, clsx, isArray, isBrowser, isEmpty, isEmptyArray, isEmptyObject, isFloat, isFunction, isInteger, isNumber, isObject, isRegex, isString, isTruthy, nanoid, not, number_exports as number, object_exports as object, promise_exports as promise, string_exports as string };

package/dist/{nanoid.d.ts → nanoid/index.d.ts}

@@ -1,3 +1,4 @@
+//#region src/nanoid/index.d.ts
 declare const charset = "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789";
 /**
  * Generate a secure nanoid string using Node.js crypto module.
@@ -7,5 +8,5 @@ declare const charset = "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ-0
  * @source https://github.com/ai/nanoid
  */
 declare function nanoid(length?: number, alphabets?: string): string;
-
-export { charset, nanoid };
+//#endregion
+export { charset, nanoid };

package/dist/nanoid/index.js

@@ -0,0 +1,29 @@
+import { randomBytes } from "crypto";
+
+//#region src/nanoid/index.ts
+const charset = `abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789`;
+/**
+* Generate a secure nanoid string using Node.js crypto module.
+* @param length - Length of the ID (default: 21)
+* @param alphabets - Alphabet to use for the ID
+* @returns A cryptographically secure unique ID string
+* @source https://github.com/ai/nanoid
+*/
+function nanoid(length = 21, alphabets = charset) {
+	const size = alphabets.length;
+	if (size === 0 || size > 255) throw new Error("Alphabet must contain less than 255 characters");
+	const mask = (2 << Math.floor(Math.log2(size - 1))) - 1;
+	const step = Math.ceil(1.6 * mask * length / size);
+	let id = "";
+	while (id.length < length) {
+		const bytes = randomBytes(step);
+		for (let i = 0; i < step && id.length < length; i++) {
+			const index = bytes[i] & mask;
+			if (index < size) id += alphabets[index];
+		}
+	}
+	return id;
+}
+
+//#endregion
+export { charset, nanoid };

package/dist/{number.d.ts → number/index.d.ts}

@@ -1,6 +1,9 @@
-import { AbbreviateOptions } from './types.js';
-export { AbbreviateOptions, AbbreviationSymbols } from './types.js';
+import { AbbreviateOptions, AbbreviationSymbols } from "../types.js";
 
+//#region src/number/index.d.ts
+declare namespace index_d_exports {
+  export { AbbreviateOptions, AbbreviationSymbols, abbreviate, clamp, inRange };
+}
 /**
  * Checks if a number is within a range
  * @param val The number to check
@@ -25,5 +28,5 @@ declare function clamp(val: number, min: number, max: number): number;
  */
 declare function abbreviate(value: number, precision?: number): string;
 declare function abbreviate(value: number, options?: AbbreviateOptions): string;
-
-export { abbreviate, clamp, inRange };
+//#endregion
+export { type AbbreviateOptions, type AbbreviationSymbols, abbreviate, clamp, inRange, index_d_exports as t };

package/dist/number/index.js

@@ -0,0 +1,60 @@
+import { t as __exportAll } from "../chunk-BYypO7fO.js";
+import { isNumber, isObject } from "../assertions/index.js";
+
+//#region src/number/index.ts
+var number_exports = /* @__PURE__ */ __exportAll({
+	abbreviate: () => abbreviate,
+	clamp: () => clamp,
+	inRange: () => inRange
+});
+/**
+* Checks if a number is within a range
+* @param val The number to check
+* @param min Minimum value
+* @param max Maximum value
+* @category Number
+*/
+function inRange(val, min, max) {
+	return val >= min && val <= max;
+}
+/**
+* Clamps a number between a minimum and maximum value
+* @param val The number to clamp
+* @param min Minimum value
+* @param max Maximum value
+* @category Number
+*/
+function clamp(val, min, max) {
+	return Math.min(Math.max(val, min), max);
+}
+const baseAbbreviationSymbols = [
+	"",
+	"K",
+	"M",
+	"B",
+	"T"
+];
+function abbreviate(value, arg) {
+	if (!isNumber(value)) return "0";
+	let precision = 1;
+	let symbols = baseAbbreviationSymbols;
+	if (typeof arg === "number") precision = arg;
+	else if (typeof arg === "object") {
+		precision = arg.precision ?? 1;
+		symbols = arg.symbols ?? baseAbbreviationSymbols;
+	}
+	const thresholds = isObject(symbols) ? Object.entries(symbols) : symbols.map((symbol, i) => [symbol, 10 ** (i * 3)]);
+	thresholds.sort((a, b) => b[1] - a[1]);
+	const sign = value < 0 ? "-" : "";
+	const abs = Math.abs(value);
+	for (const [symbol, threshold] of thresholds) {
+		const frac = (abs / threshold).toFixed(precision);
+		if (Number(frac) < 1) continue;
+		return `${sign}${frac}${symbol}`;
+	}
+	if (Math.floor(abs) === abs) return value.toString();
+	return `${sign}${abs.toFixed(precision)}`;
+}
+
+//#endregion
+export { abbreviate, clamp, inRange, number_exports as t };

package/dist/object.d.ts

@@ -1,5 +1,9 @@
-import { Dictionary } from './types.js';
+import { Dictionary } from "./types.js";
 
+//#region src/object.d.ts
+declare namespace object_d_exports {
+  export { keyInObject, omit, pick };
+}
 /**
  * Checks if a given object has a specified key
  * @category Object
@@ -15,5 +19,5 @@ declare function pick<T extends object, K extends keyof T = keyof T>(input: T, k
  * @category Object
  */
 declare function omit<T extends object, K extends keyof T = keyof T>(input: T, keys: K | K[]): Omit<T, K>;
-
-export { keyInObject, omit, pick };
+//#endregion
+export { keyInObject, omit, pick, object_d_exports as t };

package/dist/object.js

@@ -1 +1,38 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./array.js"),r=require("./assertions.js");exports.keyInObject=function(e,t){return r.isObject(e)&&t in e},exports.omit=function(r,t){let o={...r};for(let n of e.toArray(t))n in r&&delete o[n];return o},exports.pick=function(r,t){let o={};for(let n of e.toArray(t))n in r&&(o[n]=r[n]);return o};
+import { t as __exportAll } from "./chunk-BYypO7fO.js";
+import { isObject } from "./assertions/index.js";
+import { toArray } from "./array/index.js";
+
+//#region src/object.ts
+var object_exports = /* @__PURE__ */ __exportAll({
+	keyInObject: () => keyInObject,
+	omit: () => omit,
+	pick: () => pick
+});
+/**
+* Checks if a given object has a specified key
+* @category Object
+*/
+function keyInObject(val, key) {
+	return isObject(val) && key in val;
+}
+/**
+* Picks a set of keys from an object
+* @category Object
+*/
+function pick(input, keys) {
+	const picked = {};
+	for (const key of toArray(keys)) if (key in input) picked[key] = input[key];
+	return picked;
+}
+/**
+* Omits a set of keys from an object
+* @category Object
+*/
+function omit(input, keys) {
+	const partial = { ...input };
+	for (const key of toArray(keys)) if (key in input) delete partial[key];
+	return partial;
+}
+
+//#endregion
+export { keyInObject, omit, pick, object_exports as t };

package/dist/promise/index.d.ts

@@ -0,0 +1,31 @@
+import { MaybePromise } from "../types.js";
+
+//#region src/promise/index.d.ts
+declare namespace index_d_exports {
+  export { retry, sleep, tryCatch };
+}
+/**
+ * Delays execution for a specified number of milliseconds
+ * @param delay The delay in milliseconds (must be a positive finite number)
+ * @returns A promise that resolves after the specified delay
+ * @category promise
+ */
+declare function sleep(delay: number): Promise<void>;
+/**
+ * Retries a function until it succeeds or the maximum number of retries is reached
+ * @param func The function to retry
+ * @param retries The number of retries
+ * @param delay The delay between retries (optional)
+ * @returns The result of the function
+ * @category promise
+ */
+declare function retry<T>(func: () => Promise<T>, retries: number, delay?: number): Promise<T>;
+/**
+ * Wraps a promise or function and returns a result object with discriminated union
+ * @param input A promise or function that returns a promise/value
+ * @returns A tuple [value, error] where value is the result or null, and error is undefined or the error
+ * @category promise
+ */
+declare function tryCatch<T, E = Error>(input: Promise<T> | (() => MaybePromise<T>)): Promise<readonly [Awaited<T>, undefined] | readonly [null, E]>;
+//#endregion
+export { retry, sleep, index_d_exports as t, tryCatch };

package/dist/promise/index.js

@@ -0,0 +1,56 @@
+import { t as __exportAll } from "../chunk-BYypO7fO.js";
+import { isNumber } from "../assertions/index.js";
+
+//#region src/promise/index.ts
+var promise_exports = /* @__PURE__ */ __exportAll({
+	retry: () => retry,
+	sleep: () => sleep,
+	tryCatch: () => tryCatch
+});
+/**
+* Delays execution for a specified number of milliseconds
+* @param delay The delay in milliseconds (must be a positive finite number)
+* @returns A promise that resolves after the specified delay
+* @category promise
+*/
+function sleep(delay) {
+	if (!isNumber(delay)) throw new TypeError("sleep: delay must be a number");
+	else if (!Number.isFinite(delay) || delay < 0) throw new RangeError("sleep: delay must be a positive finite number");
+	if (delay === 0) return Promise.resolve();
+	return new Promise((resolve) => setTimeout(resolve, delay));
+}
+/**
+* Retries a function until it succeeds or the maximum number of retries is reached
+* @param func The function to retry
+* @param retries The number of retries
+* @param delay The delay between retries (optional)
+* @returns The result of the function
+* @category promise
+*/
+async function retry(func, retries, delay = 0) {
+	try {
+		return await func();
+	} catch (error) {
+		if (retries > 0) {
+			await sleep(delay);
+			return retry(func, retries - 1, delay);
+		}
+		throw error;
+	}
+}
+/**
+* Wraps a promise or function and returns a result object with discriminated union
+* @param input A promise or function that returns a promise/value
+* @returns A tuple [value, error] where value is the result or null, and error is undefined or the error
+* @category promise
+*/
+async function tryCatch(input) {
+	try {
+		return [typeof input === "function" ? await input() : await input, void 0];
+	} catch (error) {
+		return [null, error];
+	}
+}
+
+//#endregion
+export { retry, sleep, promise_exports as t, tryCatch };

package/dist/string/casing.d.ts

@@ -0,0 +1,45 @@
+//#region src/string/casing.d.ts
+/**
+ * Converts a string to `camelCase`
+ * @param str The string to convert
+ * @category String
+ * @returns The CamelCase string
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Converts a string to `PascalCase`
+ * @param str The string to convert
+ * @category String
+ * @returns The PascalCase string
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Converts a string to `snake_case`
+ * @param str The string to convert
+ * @category String
+ * @returns The SnakeCase string
+ */
+declare function toSnakeCase(str: string): string;
+/**
+ * Converts a string to `kebab-case`
+ * @param str The string to convert
+ * @category String
+ * @returns The KebabCase string
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Converts a string to `Sentence case`
+ * @param str The string to convert
+ * @category String
+ * @returns The SentenceCase string
+ */
+declare function toSentenceCase(str: string): string;
+/**
+ * Converts a string to `Title Case`
+ * @param str The string to convert
+ * @category String
+ * @returns The TitleCase string
+ */
+declare function toTitleCase(str: string): string;
+//#endregion
+export { toCamelCase, toKebabCase, toPascalCase, toSentenceCase, toSnakeCase, toTitleCase };

package/dist/string/casing.js

@@ -0,0 +1,92 @@
+import { isEmpty } from "../assertions/index.js";
+
+//#region src/string/casing.ts
+const reWords = /\p{Lu}?\p{Ll}+(?:[''](?:d|ll|m|re|s|t|ve))?(?=[\p{Z}\p{P}\p{S}_-]|\p{Lu}|$)|(?:\p{Lu}|[^\p{Z}\p{N}\p{Emoji_Presentation}\p{L}_-])+(?:[''](?:D|LL|M|RE|S|T|VE))?(?=[\p{Z}\p{P}\p{S}_-]|\p{Lu}(?:\p{Ll}|[^\p{Z}\p{N}\p{Emoji_Presentation}\p{L}_-])|$)|(?:\p{Lu}?[\p{Ll}\p{L}]+(?:[''](?:d|ll|m|re|s|t|ve))?|\p{Lu}+(?:[''](?:D|LL|M|RE|S|T|VE))?|\d*(?:1st|2nd|3rd|(?![123])\dth)(?=\b|\p{Lu})|\d+|\p{Emoji}+)/gu;
+/**
+* Splits a string into an array of words using Unicode-aware matching.
+* @param str The input string to split into words.
+* @returns An array of words found in the input string.
+*/
+function words(str) {
+	return str.match(reWords) || [];
+}
+/**
+* Joins the words in a string with the specified delimiter and converts the result to lowercase.
+* @param str The input string to split into words and join.
+* @param d The delimiter to use when joining the words.
+* @returns The joined string in lowercase.
+*/
+function join(str, d) {
+	return words(str).join(d).toLowerCase();
+}
+/**
+* Capitalizes the first letter of a string
+* @param str The string to convert
+* @category String
+* @returns The string with the first letter capitalized
+*/
+function toUcFirst(str) {
+	if (isEmpty(str)) return "";
+	return str[0].toUpperCase() + str.slice(1);
+}
+/**
+* Converts a string to `camelCase`
+* @param str The string to convert
+* @category String
+* @returns The CamelCase string
+*/
+function toCamelCase(str) {
+	return words(str).reduce((acc, next, i) => {
+		if (!next) return acc;
+		if (i === 0) return next.toLowerCase();
+		return acc + next[0].toUpperCase() + next.slice(1).toLowerCase();
+	}, "");
+}
+/**
+* Converts a string to `PascalCase`
+* @param str The string to convert
+* @category String
+* @returns The PascalCase string
+*/
+function toPascalCase(str) {
+	return toUcFirst(toCamelCase(str));
+}
+/**
+* Converts a string to `snake_case`
+* @param str The string to convert
+* @category String
+* @returns The SnakeCase string
+*/
+function toSnakeCase(str) {
+	return join(str, "_");
+}
+/**
+* Converts a string to `kebab-case`
+* @param str The string to convert
+* @category String
+* @returns The KebabCase string
+*/
+function toKebabCase(str) {
+	return join(str, "-");
+}
+/**
+* Converts a string to `Sentence case`
+* @param str The string to convert
+* @category String
+* @returns The SentenceCase string
+*/
+function toSentenceCase(str) {
+	return toUcFirst(join(str, " "));
+}
+/**
+* Converts a string to `Title Case`
+* @param str The string to convert
+* @category String
+* @returns The TitleCase string
+*/
+function toTitleCase(str) {
+	return words(str).map(toUcFirst).join(" ");
+}
+
+//#endregion
+export { toCamelCase, toKebabCase, toPascalCase, toSentenceCase, toSnakeCase, toTitleCase };

package/dist/{string.d.ts → string/index.d.ts}

@@ -1,3 +1,6 @@
+declare namespace index_d_exports {
+  export { slash, truncate };
+}
 /**
  * Replace backslash to slash
  * @category String
@@ -6,15 +9,9 @@ declare function slash(str: string): string;
 /**
  * Truncates a string to the specified length, adding "..." if it was longer.
  * @param text The string to truncate
- * @param length Maximum allowed length before truncation
+ * @param length Maximum allowed length before truncation (default: 80)
  * @category String
  */
 declare function truncate(input: string, length?: number): string;
-/**
- * Capitalizes the first letter of a string
- * @param input The string to capitalize
- * @category String
- */
-declare function capitalize(input: string): string;
-
-export { capitalize, slash, truncate };
+//#endregion
+export { slash, index_d_exports as t, truncate };

package/dist/string/index.js

@@ -0,0 +1,30 @@
+import { t as __exportAll } from "../chunk-BYypO7fO.js";
+
+//#region src/string/index.ts
+var string_exports = /* @__PURE__ */ __exportAll({
+	slash: () => slash,
+	truncate: () => truncate
+});
+/**
+* Replace backslash to slash
+* @category String
+*/
+function slash(str) {
+	return str.replace(/\\/g, "/");
+}
+/**
+* Truncates a string to the specified length, adding "..." if it was longer.
+* @param text The string to truncate
+* @param length Maximum allowed length before truncation (default: 80)
+* @category String
+*/
+function truncate(input, length = 80) {
+	if (!input) return input;
+	const text = input.trim();
+	const maxLength = Math.max(3, length);
+	if (text.length <= maxLength) return text;
+	return `${text.slice(0, maxLength - 3)}...`;
+}
+
+//#endregion
+export { slash, string_exports as t, truncate };

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+//#region src/types.d.ts
 type Dictionary<T = any> = Record<string, T>;
 type AnyFunction<T = any> = (...args: any[]) => T;
 type ClassValue = string | number | bigint | null | boolean | undefined;
@@ -6,10 +7,11 @@ type ClassRecord = Record<string, any>;
 type ClassNameValue = ClassValue | ClassArray | ClassRecord;
 type AbbreviationSymbols = Dictionary<number> | string[];
 type AbbreviateOptions = {
-    symbols?: AbbreviationSymbols;
-    precision?: number;
+  symbols?: AbbreviationSymbols;
+  precision?: number;
 };
 type Predicate = ((val: unknown) => boolean) | ((val: unknown) => val is unknown);
-type NegatePredicate<T> = T extends (val: unknown) => val is infer U ? <V>(val: V) => val is Exclude<V, U> : T extends (val: unknown) => boolean ? (val: unknown) => boolean : never;
-
-export type { AbbreviateOptions, AbbreviationSymbols, AnyFunction, ClassNameValue, Dictionary, NegatePredicate, Predicate };
+type NegatePredicate<T> = T extends ((val: unknown) => val is infer U) ? <V>(val: V) => val is Exclude<V, U> : T extends ((val: unknown) => boolean) ? (val: unknown) => boolean : never;
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+export { AbbreviateOptions, AbbreviationSymbols, AnyFunction, ClassNameValue, Dictionary, MaybePromise, NegatePredicate, Predicate };

package/dist/types.js

@@ -0,0 +1 @@
+export {  };

package/dist/types.ts

@@ -0,0 +1,27 @@
+export type Dictionary<T = any> = Record<string, T>;
+
+export type AnyFunction<T = any> = (...args: any[]) => T;
+
+type ClassValue = string | number | bigint | null | boolean | undefined;
+type ClassArray = ClassValue[];
+type ClassRecord = Record<string, any>;
+
+export type ClassNameValue = ClassValue | ClassArray | ClassRecord;
+
+export type AbbreviationSymbols = Dictionary<number> | string[];
+export type AbbreviateOptions = {
+  symbols?: AbbreviationSymbols;
+  precision?: number;
+};
+
+export type Predicate =
+  | ((val: unknown) => boolean)
+  | ((val: unknown) => val is unknown);
+
+export type NegatePredicate<T> = T extends (val: unknown) => val is infer U
+  ? <V>(val: V) => val is Exclude<V, U>
+  : T extends (val: unknown) => boolean
+    ? (val: unknown) => boolean
+    : never;
+
+export type MaybePromise<T> = T | Promise<T>;

package/license

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Avirup Ghosh
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Avirup Ghosh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,73 +1,43 @@
 {
   "name": "@oviirup/utils",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Collection of common JavaScript / TypeScript utilities bt @oviirup",
   "license": "MIT",
   "repository": "https://github.com/oviirup/utils",
   "author": "Avirup Ghosh (github.com/oviirup)",
+  "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    },
-    "./array": {
-      "types": "./dist/array.d.ts",
-      "import": "./dist/array.mjs",
-      "require": "./dist/array.js"
-    },
-    "./assertions": {
-      "types": "./dist/assertions.d.ts",
-      "import": "./dist/assertions.mjs",
-      "require": "./dist/assertions.js"
-    },
-    "./clsx": {
-      "types": "./dist/clsx.d.ts",
-      "import": "./dist/clsx.mjs",
-      "require": "./dist/clsx.js"
-    },
-    "./nanoid": {
-      "types": "./dist/nanoid.d.ts",
-      "import": "./dist/nanoid.mjs",
-      "require": "./dist/nanoid.js"
-    },
-    "./number": {
-      "types": "./dist/number.d.ts",
-      "import": "./dist/number.mjs",
-      "require": "./dist/number.js"
-    },
-    "./object": {
-      "types": "./dist/object.d.ts",
-      "import": "./dist/object.mjs",
-      "require": "./dist/object.js"
-    },
-    "./promise": {
-      "types": "./dist/promise.d.ts",
-      "import": "./dist/promise.mjs",
-      "require": "./dist/promise.js"
-    },
-    "./string": {
-      "types": "./dist/string.d.ts",
-      "import": "./dist/string.mjs",
-      "require": "./dist/string.js"
-    },
-    "./types": {
-      "types": "./dist/types.d.ts"
-    }
+    ".": "./dist/index.js",
+    "./array": "./dist/array/index.js",
+    "./assertions": "./dist/assertions/index.js",
+    "./clsx": "./dist/clsx/index.js",
+    "./nanoid": "./dist/nanoid/index.js",
+    "./number": "./dist/number/index.js",
+    "./object": "./dist/object.js",
+    "./promise": "./dist/promise/index.js",
+    "./string": "./dist/string/index.js",
+    "./string/casing": "./dist/string/casing.js",
+    "./types": "./dist/types.js",
+    "./package.json": "./package.json"
   },
   "scripts": {
-    "prepare": "lefthook install",
-    "build": "bunchee --minify --no-sourcemap",
+    "build": "tsdown",
     "format": "biome format --write",
     "lint": "biome check",
+    "prepare": "lefthook install",
     "test": "bun test",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2",
-    "@types/bun": "^1",
-    "bunchee": "^6",
-    "lefthook": "^2",
-    "typescript": "^5"
+    "@biomejs/biome": "^2.3.14",
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
+    "@types/bun": "^1.3.9",
+    "lefthook": "^2.1.0",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/dist/array.js

@@ -1 +0,0 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./assertions.js");function r(e,r){let t=e.length;if(t)return r<0&&(r+=t),e[r]}exports.at=r,exports.first=function(e){return r(e,0)},exports.last=function(e){return r(e,-1)},exports.move=function(r,t,n){if(e.isEmptyArray(r)||t===n)return r;let o=r[t];return r.splice(t,1),r.splice(n,0,o),r},exports.range=function(...e){let r,t=0,n=1;1===e.length?[r]=e:[t,r,n=1]=e;let o=[],u=t;for(;u<r;)o.push(u),u+=n;return o},exports.toArray=function(e){return Array.isArray(e=e??[])?e:[e]},exports.toFiltered=function(e,r){for(let t=e.length-1;t>=0;t--)r(e[t],t,e)||e.splice(t,1);return e},exports.unique=function(e,r){return"function"!=typeof r?Array.from(new Set(e)):e.reduce((e,t)=>(-1===e.findIndex(e=>r(e,t))&&e.push(t),e),[])};

package/dist/array.mjs

@@ -1 +0,0 @@
-import{isEmptyArray as r}from"./assertions.mjs";function t(r){return Array.isArray(r=r??[])?r:[r]}function n(r,t){return"function"!=typeof t?Array.from(new Set(r)):r.reduce((r,n)=>(-1===r.findIndex(r=>t(r,n))&&r.push(n),r),[])}function e(r,t){let n=r.length;if(n)return t<0&&(t+=n),r[t]}function u(r){return e(r,-1)}function i(r){return e(r,0)}function o(...r){let t,n=0,e=1;1===r.length?[t]=r:[n,t,e=1]=r;let u=[],i=n;for(;i<t;)u.push(i),i+=e;return u}function f(r,t){for(let n=r.length-1;n>=0;n--)t(r[n],n,r)||r.splice(n,1);return r}function c(t,n,e){if(r(t)||n===e)return t;let u=t[n];return t.splice(n,1),t.splice(e,0,u),t}export{e as at,i as first,u as last,c as move,o as range,t as toArray,f as toFiltered,n as unique};

package/dist/assertions.js

@@ -1 +0,0 @@
-function t(t){return"number"==typeof t&&!Number.isNaN(t)}function r(t){return Array.isArray(t)}function e(t){return r(t)&&0===t.length}function n(t){return null!==t&&"object"==typeof t&&!Array.isArray(t)}function o(t){return 0===Object.keys(t).length}Object.defineProperty(exports,"__esModule",{value:!0}),exports.isArray=r,exports.isBrowser=function(){return"u">typeof window},exports.isEmpty=function(t){return null==t||"string"==typeof t&&""===t.trim()||(r(t)?e(t):!!n(t)&&o(t))},exports.isEmptyArray=e,exports.isEmptyObject=o,exports.isFloat=function(r){return t(r)&&!Number.isInteger(r)},exports.isFunction=function(t){return"function"==typeof t},exports.isInteger=function(r){return t(r)&&Number.isInteger(r)},exports.isNumber=t,exports.isObject=n,exports.isRegex=function(t){return t instanceof RegExp},exports.isString=function(t){return"string"==typeof t},exports.isTruthy=function(t){return!!t},exports.not=function(t){return r=>!t(r)};

package/dist/assertions.mjs

@@ -1 +0,0 @@
-function n(n){return"string"==typeof n}function t(n){return"number"==typeof n&&!Number.isNaN(n)}function r(n){return t(n)&&Number.isInteger(n)}function e(n){return t(n)&&!Number.isInteger(n)}function i(n){return Array.isArray(n)}function u(n){return i(n)&&0===n.length}function o(n){return null!==n&&"object"==typeof n&&!Array.isArray(n)}function s(n){return 0===Object.keys(n).length}function f(n){return null==n||"string"==typeof n&&""===n.trim()||(i(n)?u(n):!!o(n)&&s(n))}function c(n){return"function"==typeof n}function y(n){return n instanceof RegExp}function p(n){return!!n}function g(){return"u">typeof window}function a(n){return t=>!n(t)}export{i as isArray,g as isBrowser,f as isEmpty,u as isEmptyArray,s as isEmptyObject,e as isFloat,c as isFunction,r as isInteger,t as isNumber,o as isObject,y as isRegex,n as isString,p as isTruthy,a as not};

package/dist/clsx.js

@@ -1 +0,0 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./assertions.js");exports.clsx=function(...r){let t,i="";for(let s of r)s&&(t=function r(t){let i,s="";if(e.isString(t)||e.isNumber(t))t&&(s+=t.toString().trim());else if(e.isArray(t))for(let e of t)(i=r(e))&&(s&&(s+=" "),s+=i);else if(e.isObject(t))for(let e in t)t[e]&&(s&&(s+=" "),s+=e);return s}(s))&&(i&&(i+=" "),i+=t);return i};

package/dist/clsx.mjs

@@ -1 +0,0 @@
-import{isString as t,isNumber as e,isArray as r,isObject as o}from"./assertions.mjs";function f(...i){let n,l="";for(let f of i)f&&(n=function f(i){let n,l="";if(t(i)||e(i))i&&(l+=i.toString().trim());else if(r(i))for(let t of i)(n=f(t))&&(l&&(l+=" "),l+=n);else if(o(i))for(let t in i)i[t]&&(l&&(l+=" "),l+=t);return l}(f))&&(l&&(l+=" "),l+=n);return l}export{f as clsx};

package/dist/index.mjs

@@ -1 +0,0 @@
-import*as r from"./array.mjs";export*from"./assertions.mjs";export*from"./clsx.mjs";export*from"./nanoid.mjs";import*as s from"./number.mjs";import*as m from"./object.mjs";import*as o from"./promise.mjs";import*as a from"./string.mjs";export{r as array,s as number,m as object,o as promise,a as string};

package/dist/nanoid.js

@@ -1 +0,0 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var e=require("node:crypto");let t="abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789";exports.charset=t,exports.nanoid=function(r=21,o=t){let l=o.length;if(0===l||l>255)throw Error("Alphabet must contain less than 255 characters");let n=(2<<Math.floor(Math.log2(l-1)))-1,a=Math.ceil(1.6*n*r/l),h="";for(;h.length<r;){let t=e.randomBytes(a);for(let e=0;e<a&&h.length<r;e++){let r=t[e]&n;r<l&&(h+=o[r])}}return h};

package/dist/nanoid.mjs

@@ -1 +0,0 @@
-import{randomBytes as t}from"node:crypto";let e="abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789";function r(o=21,l=e){let n=l.length;if(0===n||n>255)throw Error("Alphabet must contain less than 255 characters");let h=(2<<Math.floor(Math.log2(n-1)))-1,a=Math.ceil(1.6*h*o/n),c="";for(;c.length<o;){let e=t(a);for(let t=0;t<a&&c.length<o;t++){let r=e[t]&h;r<n&&(c+=l[r])}}return c}export{e as charset,r as nanoid};

package/dist/number.js

@@ -1 +0,0 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./assertions.js");let t=["","K","M","B","T"];exports.abbreviate=function(r,o){if(!e.isNumber(r))return"0";let n=1,i=t;"number"==typeof o?n=o:"object"==typeof o&&(n=o.precision??1,i=o.symbols??t);let s=e.isObject(i)?Object.entries(i):i.map((e,t)=>[e,10**(3*t)]);s.sort((e,t)=>t[1]-e[1]);let a=r<0?"-":"",u=Math.abs(r);for(let[e,t]of s){let r=(u/t).toFixed(n);if(!(1>Number(r)))return`${a}${r}${e}`}return Math.floor(u)===u?r.toString():`${a}${u.toFixed(n)}`},exports.clamp=function(e,t,r){return Math.min(Math.max(e,t),r)},exports.inRange=function(e,t,r){return e>=t&&e<=r};

package/dist/number.mjs

@@ -1 +0,0 @@
-import{isNumber as t,isObject as e}from"./assertions.mjs";function r(t,e,r){return t>=e&&t<=r}function o(t,e,r){return Math.min(Math.max(t,e),r)}let n=["","K","M","B","T"];function i(r,o){if(!t(r))return"0";let i=1,a=n;"number"==typeof o?i=o:"object"==typeof o&&(i=o.precision??1,a=o.symbols??n);let f=e(a)?Object.entries(a):a.map((t,e)=>[t,10**(3*e)]);f.sort((t,e)=>e[1]-t[1]);let m=r<0?"-":"",s=Math.abs(r);for(let[t,e]of f){let r=(s/e).toFixed(i);if(!(1>Number(r)))return`${m}${r}${t}`}return Math.floor(s)===s?r.toString():`${m}${s.toFixed(i)}`}export{i as abbreviate,o as clamp,r as inRange};

package/dist/object.mjs

@@ -1 +0,0 @@
-import{toArray as t}from"./array.mjs";import{isObject as r}from"./assertions.mjs";function e(t,e){return r(t)&&e in t}function n(r,e){let n={};for(let o of t(e))o in r&&(n[o]=r[o]);return n}function o(r,e){let n={...r};for(let o of t(e))o in r&&delete n[o];return n}export{e as keyInObject,o as omit,n as pick};

package/dist/promise.d.ts

@@ -1,11 +0,0 @@
-declare function sleep(delay: number): Promise<void>;
-/**
- * Retries a function until it succeeds or the maximum number of retries is reached
- * @param func The function to retry
- * @param retries The number of retries
- * @param delay The delay between retries (optional)
- * @returns The result of the function
- */
-declare function retry<T>(func: () => Promise<T>, retries: number, delay?: number): Promise<T>;
-
-export { retry, sleep };

package/dist/promise.js

@@ -1 +0,0 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var e=require("./assertions.js");function r(r){if(e.isNumber(r)){if(!Number.isFinite(r)||r<0)throw RangeError("sleep: delay must be a positive finite number")}else throw TypeError("sleep: delay must be a number");return 0===r?Promise.resolve():new Promise(e=>setTimeout(e,r))}async function t(e,s,i=0){try{return await e()}catch(o){if(s>0)return await r(i),t(e,s-1,i);throw o}}exports.retry=t,exports.sleep=r;

package/dist/promise.mjs

@@ -1 +0,0 @@
-import{isNumber as e}from"./assertions.mjs";function r(r){if(e(r)){if(!Number.isFinite(r)||r<0)throw RangeError("sleep: delay must be a positive finite number")}else throw TypeError("sleep: delay must be a number");return 0===r?Promise.resolve():new Promise(e=>setTimeout(e,r))}async function t(e,i,o=0){try{return await e()}catch(s){if(i>0)return await r(o),t(e,i-1,o);throw s}}export{t as retry,r as sleep};

package/dist/string.js

@@ -1 +0,0 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.capitalize=function(e){return e.charAt(0).toUpperCase()+e.slice(1)},exports.slash=function(e){return e.replace(/\\/g,"/")},exports.truncate=function(e,t=80){if(!e)return e;let r=e.trim(),n=Math.max(3,t);return r.length<=n?r:`${r.slice(0,n-3)}...`};

package/dist/string.mjs

@@ -1 +0,0 @@
-function t(t){return t.replace(/\\/g,"/")}function e(t,r=80){if(!t)return t;let n=t.trim(),a=Math.max(3,r);return n.length<=a?n:`${n.slice(0,a-3)}...`}function r(t){return t.charAt(0).toUpperCase()+t.slice(1)}export{r as capitalize,t as slash,e as truncate};