@h3ravel/support 0.9.0 → 0.10.0

package/dist/index.js

@@ -1,396 +1,550 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/Helpers/Arr.ts
-var chunk = /* @__PURE__ */ __name((arr, size = 2) => {
-  if (size <= 0) throw new Error("Chunk size must be greater than 0");
-  const chunks = [];
-  for (let i = 0; i < arr.length; i += size) {
-    chunks.push(arr.slice(i, i + size));
-  }
-  return chunks;
-}, "chunk");
-var range = /* @__PURE__ */ __name((size, startAt = 0) => {
-  if (size <= 0 || !Number.isFinite(size)) return [];
-  return Array.from({
-    length: size
-  }, (_, i) => startAt + i);
-}, "range");
-
-// src/Helpers/DumpDie.ts
 import process from "process";
 import util from "util";
-var inspect = /* @__PURE__ */ __name((thing) => {
-  return util.inspect(thing, {
-    showHidden: true,
-    depth: null,
-    colors: true
-  });
-}, "inspect");
-var dd = /* @__PURE__ */ __name((...args) => {
-  args.forEach((thing) => {
-    console.log(inspect(thing));
-  });
-  process.exit(1);
-}, "dd");
-var dump = /* @__PURE__ */ __name((...args) => {
-  args.forEach((thing) => {
-    console.log(inspect(thing));
-  });
-}, "dump");
 
-// src/Helpers/Number.ts
-var abbreviate = /* @__PURE__ */ __name((value, locale = "en-US") => {
-  if (!value) return "0";
-  if (value < 1e3) {
-    return new Intl.NumberFormat(locale).format(value);
-  }
-  const si = [
-    {
-      v: 1e18,
-      s: "E"
-    },
-    {
-      v: 1e15,
-      s: "P"
-    },
-    {
-      v: 1e12,
-      s: "T"
-    },
-    {
-      v: 1e9,
-      s: "B"
-    },
-    {
-      v: 1e6,
-      s: "M"
-    },
-    {
-      v: 1e3,
-      s: "K"
-    }
-  ];
-  const match = si.find((scale) => value >= scale.v);
-  if (!match) return new Intl.NumberFormat(locale).format(value);
-  const formatted = value / match.v;
-  return new Intl.NumberFormat(locale, {
-    minimumFractionDigits: 0,
-    maximumFractionDigits: 2
-  }).format(formatted) + match.s;
-}, "abbreviate");
-var humanize = /* @__PURE__ */ __name((num, slugify2) => {
-  if (!num) {
-    return "";
-  }
-  if (slugify2 === "-" || slugify2 === "_") {
-    const h = humanize(num);
-    return typeof h === "string" ? h.replace(" ", slugify2).toLowerCase() : h;
-  }
-  const ones = [
-    "",
-    "one",
-    "two",
-    "three",
-    "four",
-    "five",
-    "six",
-    "seven",
-    "eight",
-    "nine",
-    "ten",
-    "eleven",
-    "twelve",
-    "thirteen",
-    "fourteen",
-    "fifteen",
-    "sixteen",
-    "seventeen",
-    "eighteen",
-    "nineteen"
-  ];
-  const tens = [
-    "",
-    "",
-    "twenty",
-    "thirty",
-    "forty",
-    "fifty",
-    "sixty",
-    "seventy",
-    "eighty",
-    "ninety"
-  ];
-  const numString = num.toString();
-  if (num < 0) throw new Error("Negative numbers are not supported.");
-  if (num === 0) return "zero";
-  if (num < 20) {
-    return ones[num] ?? "";
-  }
-  if (numString.length === 2) {
-    return tens[numString[0]] + " " + ones[numString[1]];
-  }
-  if (numString.length == 3) {
-    if (numString[1] === "0" && numString[2] === "0") return ones[numString[0]] + " hundred";
-    else return ones[numString[0]] + " hundred and " + humanize(+((numString[1] || "") + numString[2]), slugify2);
-  }
-  if (numString.length === 4) {
-    const end = +((numString[1] || "") + numString[2] + numString[3]);
-    if (end === 0) return ones[numString[0]] + " thousand";
-    if (end < 100) return ones[numString[0]] + " thousand and " + humanize(end, slugify2);
-    return ones[numString[0]] + " thousand " + humanize(end, slugify2);
-  }
-  return num;
-}, "humanize");
-var toBytes = /* @__PURE__ */ __name((bytes, decimals = 2, bits = false) => {
-  if (!bytes || isNaN(bytes)) {
-    return bits ? "0 B" : "0 Bytes";
-  }
-  const base = bits ? 1e3 : 1024;
-  const dm = decimals < 0 ? 0 : decimals;
-  const sizes = bits ? [
-    "B",
-    "KB",
-    "MB",
-    "GB",
-    "TB",
-    "PB",
-    "EB",
-    "ZB",
-    "YB"
-  ] : [
-    "Bytes",
-    "KiB",
-    "MiB",
-    "GiB",
-    "TiB",
-    "PiB",
-    "EiB",
-    "ZiB",
-    "YiB"
-  ];
-  const index = Math.floor(Math.log(bytes) / Math.log(base));
-  const value = parseFloat((bytes / Math.pow(base, index)).toFixed(dm));
-  return `${value} ${sizes[index]}`;
-}, "toBytes");
-var toHumanTime = /* @__PURE__ */ __name((seconds = 0, worded = false) => {
-  if (isNaN(seconds) || seconds < 0) seconds = 0;
-  const hours = Math.floor(seconds / 3600);
-  const minutes = Math.floor(seconds % 3600 / 60);
-  const secs = Math.floor(seconds % 60);
-  if (worded) {
-    const parts = [];
-    if (hours) parts.push(`${hours}hr`);
-    if (minutes) parts.push(`${minutes}min`);
-    if (secs || !hours && !minutes) parts.push(`${secs}sec`);
-    return parts.join(" ");
-  }
-  const hh = hours > 0 ? `${hours}:` : "";
-  const mm = (hours > 0 && minutes < 10 ? `0${minutes}` : minutes) + ":";
-  const ss = secs < 10 ? `0${secs}` : secs;
-  return `${hh}${mm}${ss}`;
-}, "toHumanTime");
+//#region src/Helpers/Arr.ts
+/**
+* Splits an array into chunks of a specified size.
+*
+* @template T - Type of elements in the array
+* @param arr - The input array
+* @param size - Size of each chunk (default: 2)
+* @returns An array of chunks (arrays)
+*/
+const chunk = (arr, size = 2) => {
+	if (size <= 0) throw new Error("Chunk size must be greater than 0");
+	const chunks = [];
+	for (let i = 0; i < arr.length; i += size) chunks.push(arr.slice(i, i + size));
+	return chunks;
+};
+/**
+* Generates an array of sequential numbers.
+*
+* @param size - Number of elements in the range
+* @param startAt - Starting number (default: 0)
+* @returns An array of numbers from startAt to startAt + size - 1
+*/
+const range = (size, startAt = 0) => {
+	if (size <= 0 || !Number.isFinite(size)) return [];
+	return Array.from({ length: size }, (_, i) => startAt + i);
+};
+
+//#endregion
+//#region src/Helpers/DumpDie.ts
+const inspect = (thing) => {
+	return util.inspect(thing, {
+		showHidden: true,
+		depth: null,
+		colors: true
+	});
+};
+/**
+* Dump something and kill the process for quick debugging. Based on Laravel's dd()
+* 
+* @param args 
+*/
+const dd = (...args) => {
+	args.forEach((thing) => {
+		console.log(inspect(thing));
+	});
+	process.exit(1);
+};
+/**
+* Dump something but keep the process for quick debugging. Based on Laravel's dump()
+* 
+* @param args 
+*/
+const dump = (...args) => {
+	args.forEach((thing) => {
+		console.log(inspect(thing));
+	});
+};
 
-// src/Helpers/Obj.ts
-var dot = /* @__PURE__ */ __name((obj) => {
-  const result = {};
-  const recurse = /* @__PURE__ */ __name((o, prefix = "") => {
-    for (const [key, value] of Object.entries(o)) {
-      const newKey = prefix ? `${prefix}.${key}` : key;
-      if (value && typeof value === "object" && !Array.isArray(value)) {
-        recurse(value, newKey);
-      } else {
-        result[newKey] = value;
-      }
-    }
-  }, "recurse");
-  recurse(obj);
-  return result;
-}, "dot");
-var extractProperties = /* @__PURE__ */ __name((obj, keys = []) => {
-  return Object.fromEntries(keys.map((key) => [
-    key,
-    obj[key]
-  ]));
-}, "extractProperties");
-var getValue = /* @__PURE__ */ __name((key, item) => {
-  if (Array.isArray(key)) {
-    const [parent, child] = key;
-    if (child !== void 0) {
-      return String(item?.[parent]?.[child] ?? item?.[parent] ?? `${String(parent)}.${String(child)}`);
-    }
-    return String(item?.[parent] ?? parent);
-  }
-  return String(item?.[key] ?? key);
-}, "getValue");
-var modObj = /* @__PURE__ */ __name((obj, callback) => {
-  return Object.fromEntries(Object.entries(obj).map(([key, value]) => callback([
-    key,
-    value
-  ])));
-}, "modObj");
+//#endregion
+//#region src/Helpers/Number.ts
+/**
+* Abbreviates large numbers using SI symbols (K, M, B...) 
+* and formats the output according to the given locale.
+*
+* @param value - The number to abbreviate
+* @param locale - Optional locale string (default: "en-US")
+* @returns A localized, abbreviated number string
+*/
+const abbreviate = (value, locale = "en-US") => {
+	if (!value) return "0";
+	if (value < 1e3) return new Intl.NumberFormat(locale).format(value);
+	const match = [
+		{
+			v: 0xde0b6b3a7640000,
+			s: "E"
+		},
+		{
+			v: 0x38d7ea4c68000,
+			s: "P"
+		},
+		{
+			v: 0xe8d4a51000,
+			s: "T"
+		},
+		{
+			v: 1e9,
+			s: "B"
+		},
+		{
+			v: 1e6,
+			s: "M"
+		},
+		{
+			v: 1e3,
+			s: "K"
+		}
+	].find((scale) => value >= scale.v);
+	if (!match) return new Intl.NumberFormat(locale).format(value);
+	const formatted = value / match.v;
+	return new Intl.NumberFormat(locale, {
+		minimumFractionDigits: 0,
+		maximumFractionDigits: 2
+	}).format(formatted) + match.s;
+};
+/**
+* Concverts a number into human readable string
+*
+* @param num The number to convert
+* @param slugify convert the ouput into a slug using this as a separator
+* @returns
+*/
+const humanize = (num, slugify$1) => {
+	if (!num) return "";
+	if (slugify$1 === "-" || slugify$1 === "_") {
+		const h = humanize(num);
+		return typeof h === "string" ? h.replace(" ", slugify$1).toLowerCase() : h;
+	}
+	const ones = [
+		"",
+		"one",
+		"two",
+		"three",
+		"four",
+		"five",
+		"six",
+		"seven",
+		"eight",
+		"nine",
+		"ten",
+		"eleven",
+		"twelve",
+		"thirteen",
+		"fourteen",
+		"fifteen",
+		"sixteen",
+		"seventeen",
+		"eighteen",
+		"nineteen"
+	];
+	const tens = [
+		"",
+		"",
+		"twenty",
+		"thirty",
+		"forty",
+		"fifty",
+		"sixty",
+		"seventy",
+		"eighty",
+		"ninety"
+	];
+	const numString = num.toString();
+	if (num < 0) throw new Error("Negative numbers are not supported.");
+	if (num === 0) return "zero";
+	if (num < 20) return ones[num] ?? "";
+	if (numString.length === 2) return tens[numString[0]] + " " + ones[numString[1]];
+	if (numString.length == 3) if (numString[1] === "0" && numString[2] === "0") return ones[numString[0]] + " hundred";
+	else return ones[numString[0]] + " hundred and " + humanize(+((numString[1] || "") + numString[2]), slugify$1);
+	if (numString.length === 4) {
+		const end = +((numString[1] || "") + numString[2] + numString[3]);
+		if (end === 0) return ones[numString[0]] + " thousand";
+		if (end < 100) return ones[numString[0]] + " thousand and " + humanize(end, slugify$1);
+		return ones[numString[0]] + " thousand " + humanize(end, slugify$1);
+	}
+	return num;
+};
+/**
+* Converts a number of bytes into a human-readable string.
+*
+* @param bytes - The size in bytes to convert
+* @param decimals - Number of decimal places to display (default: 2)
+* @param bits - If true, uses 1000-based (SI) units (B, KB, MB...); 
+*               otherwise uses 1024-based binary units (Bytes, KiB...)
+* @returns A formatted string with the appropriate unit
+*/
+const toBytes = (bytes, decimals = 2, bits = false) => {
+	if (!bytes || isNaN(bytes)) return bits ? "0 B" : "0 Bytes";
+	const base = bits ? 1e3 : 1024;
+	const dm = decimals < 0 ? 0 : decimals;
+	const sizes = bits ? [
+		"B",
+		"KB",
+		"MB",
+		"GB",
+		"TB",
+		"PB",
+		"EB",
+		"ZB",
+		"YB"
+	] : [
+		"Bytes",
+		"KiB",
+		"MiB",
+		"GiB",
+		"TiB",
+		"PiB",
+		"EiB",
+		"ZiB",
+		"YiB"
+	];
+	const index = Math.floor(Math.log(bytes) / Math.log(base));
+	return `${parseFloat((bytes / Math.pow(base, index)).toFixed(dm))} ${sizes[index]}`;
+};
+/**
+* Formats a duration (in seconds) into a human-readable string.
+*
+* @param seconds - Duration in seconds
+* @param worded - If true, outputs worded format (e.g., "1hr 2min 3sec"),
+*                 otherwise HH:MM:SS (e.g., "01:02:03")
+* @returns A formatted time string
+*/
+const toHumanTime = (seconds = 0, worded = false) => {
+	if (isNaN(seconds) || seconds < 0) seconds = 0;
+	const hours = Math.floor(seconds / 3600);
+	const minutes = Math.floor(seconds % 3600 / 60);
+	const secs = Math.floor(seconds % 60);
+	if (worded) {
+		const parts = [];
+		if (hours) parts.push(`${hours}hr`);
+		if (minutes) parts.push(`${minutes}min`);
+		if (secs || !hours && !minutes) parts.push(`${secs}sec`);
+		return parts.join(" ");
+	}
+	const hh = hours > 0 ? `${hours}:` : "";
+	const mm = (hours > 0 && minutes < 10 ? `0${minutes}` : minutes) + ":";
+	const ss = secs < 10 ? `0${secs}` : secs;
+	return `${hh}${mm}${ss}`;
+};
+
+//#endregion
+//#region src/Helpers/Obj.ts
+/**
+* Flattens a nested object into a single-level object
+* with dot-separated keys.
+*
+* Example:
+* doter({
+*   user: { name: "John", address: { city: "NY" } },
+*   active: true
+* })
+* 
+* Output:
+* {
+*   "user.name": "John",
+*   "user.address.city": "NY",
+*   "active": true
+* }
+*
+* @template T - The type of the input object
+* @param obj - The nested object to flatten
+* @returns A flattened object with dotted keys and inferred types
+*/
+const dot = (obj) => {
+	const result = {};
+	/**
+	* Internal recursive function to traverse and flatten the object.
+	* 
+	* @param o - Current object to flatten
+	* @param prefix - Key path accumulated so far
+	*/
+	const recurse = (o, prefix = "") => {
+		for (const [key, value] of Object.entries(o)) {
+			const newKey = prefix ? `${prefix}.${key}` : key;
+			/**
+			* Recurse if the value is a plain object
+			*/
+			if (value && typeof value === "object" && !Array.isArray(value)) recurse(value, newKey);
+			else
+ /**
+			* Otherwise, assign directly
+			*/
+			result[newKey] = value;
+		}
+	};
+	recurse(obj);
+	return result;
+};
+/**
+* Extracts a subset of properties from an object.
+*
+* @template T - Type of the source object
+* @template K - Keys of T to extract
+* @param obj - The source object
+* @param keys - Array of keys to extract
+* @returns A new object with only the specified keys
+*/
+const extractProperties = (obj, keys = []) => {
+	return Object.fromEntries(keys.map((key) => [key, obj[key]]));
+};
+/**
+* Safely retrieves a value from an object by key or nested keys.
+*
+* @template T - Type of the source object
+* @param key - Single key or tuple [parentKey, childKey]
+* @param item - The source object
+* @returns The found value as a string or the key itself if not found
+*/
+const getValue = (key, item) => {
+	if (Array.isArray(key)) {
+		const [parent, child] = key;
+		if (child !== void 0) return String(item?.[parent]?.[child] ?? item?.[parent] ?? `${String(parent)}.${String(child)}`);
+		return String(item?.[parent] ?? parent);
+	}
+	return String(item?.[key] ?? key);
+};
+/**
+* Maps over an object's entries and returns a new object 
+* with transformed keys and/or values.
+*
+* @template T - Type of the input object
+* @template R - Type of the new values
+* @param obj - The object to transform
+* @param callback - Function that receives [key, value] and returns [newKey, newValue]
+* @returns A new object with transformed entries
+*/
+const modObj = (obj, callback) => {
+	return Object.fromEntries(Object.entries(obj).map(([key, value]) => callback([key, value])));
+};
 function safeDot(data, key) {
-  if (!key) return data;
-  return key.split(".").reduce((acc, k) => acc?.[k], data);
+	if (!key) return data;
+	return key.split(".").reduce((acc, k) => acc?.[k], data);
 }
-__name(safeDot, "safeDot");
-var setNested = /* @__PURE__ */ __name((obj, key, value) => {
-  if (!key.includes(".")) {
-    obj[key] = value;
-    return;
-  }
-  const parts = key.split(".");
-  let current = obj;
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (i === parts.length - 1) {
-      current[part] = value;
-    } else {
-      if (typeof current[part] !== "object" || current[part] === null) {
-        current[part] = {};
-      }
-      current = current[part];
-    }
-  }
-}, "setNested");
-var slugifyKeys = /* @__PURE__ */ __name((obj, only = [], separator = "_") => {
-  const slugify2 = /* @__PURE__ */ __name((key) => key.replace(/([a-z])([A-Z])/g, `$1${separator}$2`).replace(/[\s\W]+/g, separator).replace(new RegExp(`${separator}{2,}`, "g"), separator).replace(new RegExp(`^${separator}|${separator}$`, "g"), "").toLowerCase(), "slugify");
-  let entries = Object.entries(obj);
-  if (only.length) {
-    entries = entries.filter(([key]) => only.includes(key));
-  }
-  return Object.fromEntries(entries.map(([key, value]) => [
-    slugify2(key),
-    value
-  ]));
-}, "slugifyKeys");
+/**
+* Sets a nested property on an object using dot notation.
+* 
+* @example
+* const obj = {}
+* setNested(obj, 'app.user.name', 'Legacy')
+* console.log(obj)
+* // Output: { app: { user: { name: 'Legacy' } } }
+* 
+* @param obj - The target object to modify.
+* @param key - The dot-separated key (e.g., 'app.user.name').
+* @param value - The value to set at the specified path.
+*/
+const setNested = (obj, key, value) => {
+	if (!key.includes(".")) {
+		obj[key] = value;
+		return;
+	}
+	const parts = key.split(".");
+	let current = obj;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		/**
+		* If we're at the last key, assign the value
+		*/
+		if (i === parts.length - 1) current[part] = value;
+		else {
+			/**
+			* If the key doesn't exist or isn't an object, create it
+			*/
+			if (typeof current[part] !== "object" || current[part] === null) current[part] = {};
+			current = current[part];
+		}
+	}
+};
+/**
+* Converts object keys to a slugified format (e.g., snake_case).
+*
+* @template T - Type of the input object
+* @param obj - The object whose keys will be slugified
+* @param only - Optional array of keys to slugify (others remain unchanged)
+* @param separator - Separator for slugified keys (default: "_")
+* @returns A new object with slugified keys
+*/
+const slugifyKeys = (obj, only = [], separator = "_") => {
+	const slugify$1 = (key) => key.replace(/([a-z])([A-Z])/g, `$1${separator}$2`).replace(/[\s\W]+/g, separator).replace(new RegExp(`${separator}{2,}`, "g"), separator).replace(new RegExp(`^${separator}|${separator}$`, "g"), "").toLowerCase();
+	let entries = Object.entries(obj);
+	if (only.length) entries = entries.filter(([key]) => only.includes(key));
+	return Object.fromEntries(entries.map(([key, value]) => [slugify$1(key), value]));
+};
 
-// src/Helpers/Str.ts
-var after = /* @__PURE__ */ __name((value, search) => {
-  if (!search) return value;
-  const index = value.indexOf(search);
-  return index !== -1 ? value.slice(index + search.length) : value;
-}, "after");
-var afterLast = /* @__PURE__ */ __name((value, search) => {
-  if (!search) return value;
-  const lastIndex = value.lastIndexOf(search);
-  return lastIndex !== -1 ? value.slice(lastIndex + search.length) : value;
-}, "afterLast");
-var before = /* @__PURE__ */ __name((value, search) => {
-  if (!search) return value;
-  const index = value.indexOf(search);
-  return index !== -1 ? value.slice(0, index) : value;
-}, "before");
-var beforeLast = /* @__PURE__ */ __name((value, search) => {
-  if (!search) return value;
-  const lastIndex = value.lastIndexOf(search);
-  return lastIndex !== -1 ? value.slice(0, lastIndex) : value;
-}, "beforeLast");
+//#endregion
+//#region src/Helpers/Str.ts
+/**
+* Get the portion of the string after the first occurrence of the given value.
+* 
+* @param value 
+* @param search 
+* @returns 
+*/
+const after = (value, search) => {
+	if (!search) return value;
+	const index = value.indexOf(search);
+	return index !== -1 ? value.slice(index + search.length) : value;
+};
+/**
+* Get the portion of the string after the last occurrence of the given value.
+* 
+* @param value 
+* @param search 
+* @returns 
+*/
+const afterLast = (value, search) => {
+	if (!search) return value;
+	const lastIndex = value.lastIndexOf(search);
+	return lastIndex !== -1 ? value.slice(lastIndex + search.length) : value;
+};
+/**
+* Get the portion of the string before the first occurrence of the given value.
+* 
+* @param value 
+* @param search 
+* @returns 
+*/
+const before = (value, search) => {
+	if (!search) return value;
+	const index = value.indexOf(search);
+	return index !== -1 ? value.slice(0, index) : value;
+};
+/**
+* Get the portion of the string before the last occurrence of the given value.
+* 
+* @param value 
+* @param search 
+* @returns 
+*/
+const beforeLast = (value, search) => {
+	if (!search) return value;
+	const lastIndex = value.lastIndexOf(search);
+	return lastIndex !== -1 ? value.slice(0, lastIndex) : value;
+};
+/**
+* Capitalizes the first character of a string.
+*
+* @param str - The input string
+* @returns The string with the first character capitalized
+*/
 function capitalize(str) {
-  if (!str) return "";
-  return str[0].toUpperCase() + str.slice(1);
+	if (!str) return "";
+	return str[0].toUpperCase() + str.slice(1);
 }
-__name(capitalize, "capitalize");
-var pluralize = /* @__PURE__ */ __name((word, count) => {
-  if (count === 1) return word;
-  const irregularPlurals = {
-    foot: "feet",
-    child: "children",
-    mouse: "mice",
-    goose: "geese",
-    person: "people",
-    man: "men",
-    woman: "women"
-  };
-  if (word in irregularPlurals) {
-    return irregularPlurals[word];
-  }
-  if (word.endsWith("y") && ![
-    "a",
-    "e",
-    "i",
-    "o",
-    "u"
-  ].includes(word[word.length - 2]?.toLowerCase() ?? "")) {
-    return word.slice(0, -1) + "ies";
-  }
-  if (/(s|ss|sh|ch|x|z)$/i.test(word)) {
-    return word + "es";
-  }
-  return word + "s";
-}, "pluralize");
-var singularize = /* @__PURE__ */ __name((word) => {
-  const irregulars = {
-    feet: "foot",
-    children: "child",
-    mice: "mouse",
-    geese: "goose",
-    people: "person",
-    men: "man",
-    women: "woman"
-  };
-  if (word in irregulars) return irregulars[word];
-  if (/ies$/i.test(word) && word.length > 3) {
-    return word.replace(/ies$/i, "y");
-  }
-  if (/(ches|shes|sses|xes|zes)$/i.test(word)) {
-    return word.replace(/es$/i, "");
-  }
-  if (/s$/i.test(word) && word.length > 1) {
-    return word.replace(/s$/i, "");
-  }
-  return word;
-}, "singularize");
-var slugify = /* @__PURE__ */ __name((str, joiner = "_") => {
-  return str.replace(/([a-z])([A-Z])/g, `$1${joiner}$2`).replace(/[\s\W]+/g, joiner).replace(new RegExp(`${joiner}{2,}`, "g"), joiner).replace(new RegExp(`^${joiner}|${joiner}$`, "g"), "").toLowerCase();
-}, "slugify");
-var subString = /* @__PURE__ */ __name((str, len, ellipsis = "...") => {
-  if (!str) return "";
-  if (len <= ellipsis.length) return ellipsis;
-  return str.length > len ? str.substring(0, len - ellipsis.length).trimEnd() + ellipsis : str;
-}, "subString");
-var substitute = /* @__PURE__ */ __name((str, data = {}, def) => {
-  if (!str || !data) return void 0;
-  const regex = /{\s*([a-zA-Z0-9_.]+)\s*}/g;
-  const flattened = dot(data);
-  const out = str.replace(regex, (_, key) => {
-    const value = flattened[key];
-    return value !== void 0 ? String(value) : def ?? "";
-  });
-  return out;
-}, "substitute");
-var truncate = /* @__PURE__ */ __name((str, len = 20, suffix = "...") => {
-  if (!str) return "";
-  const clean = str.replace(/<[^>]+>/g, "");
-  const truncated = clean.length > len ? clean.substring(0, len - suffix.length) + suffix : clean;
-  return truncated.replace(/\n/g, " ").replace(new RegExp(`\\s+${suffix.replace(/\./g, "\\.")}$`), suffix);
-}, "truncate");
-export {
-  abbreviate,
-  after,
-  afterLast,
-  before,
-  beforeLast,
-  capitalize,
-  chunk,
-  dd,
-  dot,
-  dump,
-  extractProperties,
-  getValue,
-  humanize,
-  modObj,
-  pluralize,
-  range,
-  safeDot,
-  setNested,
-  singularize,
-  slugify,
-  slugifyKeys,
-  subString,
-  substitute,
-  toBytes,
-  toHumanTime,
-  truncate
+/**
+* Returns the pluralized form of a word based on the given number.
+*
+* @param word - The word to pluralize
+* @param count - The number determining pluralization
+* @returns Singular if count === 1, otherwise plural form
+*/
+const pluralize = (word, count) => {
+	if (count === 1) return word;
+	const irregularPlurals = {
+		foot: "feet",
+		child: "children",
+		mouse: "mice",
+		goose: "geese",
+		person: "people",
+		man: "men",
+		woman: "women"
+	};
+	if (word in irregularPlurals) return irregularPlurals[word];
+	if (word.endsWith("y") && ![
+		"a",
+		"e",
+		"i",
+		"o",
+		"u"
+	].includes(word[word.length - 2]?.toLowerCase() ?? "")) return word.slice(0, -1) + "ies";
+	if (/(s|ss|sh|ch|x|z)$/i.test(word)) return word + "es";
+	return word + "s";
+};
+/**
+* Converts a plural English word into its singular form.
+*
+* @param word - The word to singularize
+* @returns The singular form of the word
+*/
+const singularize = (word) => {
+	const irregulars = {
+		feet: "foot",
+		children: "child",
+		mice: "mouse",
+		geese: "goose",
+		people: "person",
+		men: "man",
+		women: "woman"
+	};
+	if (word in irregulars) return irregulars[word];
+	if (/ies$/i.test(word) && word.length > 3) return word.replace(/ies$/i, "y");
+	if (/(ches|shes|sses|xes|zes)$/i.test(word)) return word.replace(/es$/i, "");
+	if (/s$/i.test(word) && word.length > 1) return word.replace(/s$/i, "");
+	return word;
+};
+/**
+* Converts a string into a slug format.
+* Handles camelCase, spaces, and non-alphanumeric characters.
+*
+* @param str - The input string to slugify
+* @param joiner - The character used to join words (default: "_")
+* @returns A slugified string
+*/
+const slugify = (str, joiner = "_") => {
+	return str.replace(/([a-z])([A-Z])/g, `$1${joiner}$2`).replace(/[\s\W]+/g, joiner).replace(new RegExp(`${joiner}{2,}`, "g"), joiner).replace(new RegExp(`^${joiner}|${joiner}$`, "g"), "").toLowerCase();
+};
+/**
+* Truncates a string to a specified length and appends an ellipsis if needed.
+*
+* @param str - The input string
+* @param len - Maximum length of the result (including ellipsis)
+* @param ellipsis - String to append if truncated (default: "...")
+* @returns The truncated string
+*/
+const subString = (str, len, ellipsis = "...") => {
+	if (!str) return "";
+	if (len <= ellipsis.length) return ellipsis;
+	return str.length > len ? str.substring(0, len - ellipsis.length).trimEnd() + ellipsis : str;
 };
+/**
+* Replaces placeholders in a string with corresponding values from a data object.
+* 
+* Example:
+* substitute("Hello { user.name }!", { user: { name: "John" } })
+* // "Hello John!"
+*
+* @param str - The string containing placeholders wrapped in { } braces.
+* @param data - Object containing values to substitute. Supports nested keys via dot notation.
+* @param def - Default value to use if a key is missing. (Optional)
+* @returns The substituted string or undefined if the input string or data is invalid.
+*/
+const substitute = (str, data = {}, def) => {
+	if (!str || !data) return void 0;
+	const regex = /{\s*([a-zA-Z0-9_.]+)\s*}/g;
+	const flattened = dot(data);
+	return str.replace(regex, (_, key) => {
+		const value = flattened[key];
+		return value !== void 0 ? String(value) : def ?? "";
+	});
+};
+/**
+* Truncates a string to a specified length, removing HTML tags and 
+* appending a suffix if the string exceeds the length.
+*
+* @param str - The string to truncate
+* @param len - Maximum length (default: 20)
+* @param suffix - Suffix to append if truncated (default: "...")
+* @returns The truncated string
+*/
+const truncate = (str, len = 20, suffix = "...") => {
+	if (!str) return "";
+	const clean = str.replace(/<[^>]+>/g, "");
+	return (clean.length > len ? clean.substring(0, len - suffix.length) + suffix : clean).replace(/\n/g, " ").replace(/* @__PURE__ */ new RegExp(`\\s+${suffix.replace(/\./g, "\\.")}$`), suffix);
+};
+
+//#endregion
+export { abbreviate, after, afterLast, before, beforeLast, capitalize, chunk, dd, dot, dump, extractProperties, getValue, humanize, modObj, pluralize, range, safeDot, setNested, singularize, slugify, slugifyKeys, subString, substitute, toBytes, toHumanTime, truncate };
 //# sourceMappingURL=index.js.map