@h3ravel/support 0.10.3 → 0.11.0

package/dist/index.js

@@ -1,7 +1,28 @@
+import { __export } from "./chunk-PECeCxCb.js";
+import { createHash, createHmac, randomBytes, randomUUID } from "crypto";
 import process from "process";
 import util from "util";
 
 //#region src/Helpers/Arr.ts
+var Arr_exports = /* @__PURE__ */ __export({
+	alternate: () => alternate,
+	chunk: () => chunk,
+	collapse: () => collapse,
+	combine: () => combine,
+	find: () => find,
+	first: () => first,
+	flatten: () => flatten,
+	forget: () => forget,
+	isEmpty: () => isEmpty,
+	isNotEmpty: () => isNotEmpty,
+	last: () => last,
+	pop: () => pop,
+	prepend: () => prepend,
+	range: () => range,
+	reverse: () => reverse,
+	shift: () => shift,
+	take: () => take
+});
 /**
 * Splits an array into chunks of a specified size.
 *
@@ -17,6 +38,67 @@ const chunk = (arr, size = 2) => {
 	return chunks;
 };
 /**
+* Collapse an array of arrays into a single array.
+*/
+const collapse = (arr) => {
+	const result = [];
+	for (const item of arr) if (Array.isArray(item)) result.push(...item);
+	else result.push(item);
+	return result;
+};
+/**
+* Alternates between two arrays, creating a zipped result.
+*/
+const alternate = (a, b) => {
+	const result = [];
+	const max = Math.max(a.length, b.length);
+	for (let i = 0; i < max; i++) {
+		if (i < a.length) result.push(a[i]);
+		if (i < b.length) result.push(b[i]);
+	}
+	return result;
+};
+/**
+* Combine arrays and sum their values element by element.
+*/
+const combine = (...arr) => {
+	const maxLength = Math.max(...arr.map((a) => a.length));
+	const result = new Array(maxLength).fill(0);
+	for (let i = 0; i < maxLength; i++) for (const array of arr) result[i] += array[i] || 0;
+	return result;
+};
+/** Find the value associated with a given key. */
+const find = (key, arr) => arr.find((item) => item === key) || null;
+/** Returns a new array without the given indices. */
+const forget = (arr, keys) => arr.filter((_, i) => !keys.includes(i));
+/** Remove the first element and return tuple [el, rest]. */
+const first = (arr) => {
+	if (!arr.length) throw new Error("Cannot shift from empty array");
+	return [arr[0], arr.slice(1)];
+};
+/** Remove the last element and return tuple [el, rest]. */
+const last = (arr) => {
+	if (!arr.length) throw new Error("Cannot pop from empty array");
+	return [arr[arr.length - 1], arr.slice(0, -1)];
+};
+/** Check if array is empty. */
+const isEmpty = (arr) => {
+	if (arr.length === 0) return true;
+	else return false;
+};
+/** Check if array is empty. */
+const isNotEmpty = (arr) => arr.length > 0;
+/** Pop the element off the end of array. */
+const pop = (arr) => arr.slice(0, -1);
+/** Add elements to the beginning of array. */
+const prepend = (arr, ...elements) => [...elements, ...arr];
+/** Take first n elements of array. */
+const take = (amount, arr) => arr.slice(0, Math.max(0, amount));
+/** Create a new array in reverse order. */
+const reverse = (arr) => [...arr].reverse();
+/** Alias for first element removal. */
+const shift = first;
+/**
 * Generates an array of sequential numbers.
 *
 * @param size - Number of elements in the range
@@ -27,40 +109,197 @@ const range = (size, startAt = 0) => {
 	if (size <= 0 || !Number.isFinite(size)) return [];
 	return Array.from({ length: size }, (_, i) => startAt + i);
 };
+/** Flatten multi-dimensional arrays into single level. */
+const flatten = (arr) => {
+	const result = [];
+	const recurse = (input) => {
+		for (const item of input) Array.isArray(item) ? recurse(item) : result.push(item);
+	};
+	recurse(arr);
+	return result;
+};
 
 //#endregion
-//#region src/Helpers/DumpDie.ts
-const inspect = (thing) => {
-	return util.inspect(thing, {
-		showHidden: true,
-		depth: null,
-		colors: true
-	});
+//#region src/Helpers/Crypto.ts
+var Crypto_exports = /* @__PURE__ */ __export({
+	base64Decode: () => base64Decode,
+	base64Encode: () => base64Encode,
+	caesarCipher: () => caesarCipher,
+	checksum: () => checksum,
+	hash: () => hash,
+	hmac: () => hmac,
+	random: () => random,
+	randomColor: () => randomColor,
+	randomPassword: () => randomPassword,
+	randomSecure: () => randomSecure,
+	secureToken: () => secureToken,
+	uuid: () => uuid,
+	verifyChecksum: () => verifyChecksum,
+	xor: () => xor
+});
+/**
+* Generate a random UUID string.
+* 
+* @returns A random UUID string
+*/
+const uuid = () => {
+	return randomUUID();
 };
 /**
-* Dump something and kill the process for quick debugging. Based on Laravel's dd()
+* Generate a random string of specified length.
 * 
-* @param args 
+* @param length - Length of the random string (default: 16)
+* @param charset - Character set to use (default: alphanumeric)
+* @returns A random string
 */
-const dd = (...args) => {
-	args.forEach((thing) => {
-		console.log(inspect(thing));
-	});
-	process.exit(1);
+const random = (length = 16, charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") => {
+	let result = "";
+	for (let i = 0; i < length; i++) result += charset.charAt(Math.floor(Math.random() * charset.length));
+	return result;
 };
 /**
-* Dump something but keep the process for quick debugging. Based on Laravel's dump()
+* Secure random string generator that uses crypto.randomBytes.
 * 
-* @param args 
+* @param length - Length of the random string (default: 32)
+* @returns A cryptographically secure random string
 */
-const dump = (...args) => {
-	args.forEach((thing) => {
-		console.log(inspect(thing));
+const randomSecure = (length = 32) => {
+	return randomBytes(Math.ceil(length / 2)).toString("hex").slice(0, length);
+};
+/**
+* Hash a string using the specified algorithm.
+* 
+* @param data - Data to hash
+* @param algorithm - Hash algorithm (default: 'sha256')
+* @returns Hexadecimal hash string
+*/
+const hash = (data, algorithm = "sha256") => {
+	return createHash(algorithm).update(data).digest("hex");
+};
+/**
+* Hash a string with salt using HMAC.
+* 
+* @param data - Data to hash
+* @param key - Secret key for HMAC
+* @param algorithm - Hash algorithm (default: 'sha256')
+* @returns Hexadecimal hash string
+*/
+const hmac = (data, key, algorithm = "sha256") => {
+	return createHmac(algorithm, key).update(data).digest("hex");
+};
+/**
+* Encode data to base64.
+* 
+* @param data - Data to encode
+* @returns Base64 encoded string
+*/
+const base64Encode = (data) => {
+	return Buffer.from(data, "utf8").toString("base64");
+};
+/**
+* Decode base64 data.
+* 
+* @param data - Base64 string to decode
+* @returns Decoded string
+*/
+const base64Decode = (data) => {
+	return Buffer.from(data, "base64").toString("utf8");
+};
+/**
+* Simple XOR encryption/decryption.
+* 
+* @param data - Data to encrypt/decrypt
+* @param key - Encryption key
+* @returns Encrypted/decrypted string
+*/
+const xor = (data, key) => {
+	let result = "";
+	const keyLength = key.length;
+	for (let i = 0; i < data.length; i++) {
+		const dataCharCode = data.charCodeAt(i);
+		const keyCharCode = key.charCodeAt(i % keyLength);
+		result += String.fromCharCode(dataCharCode ^ keyCharCode);
+	}
+	return result;
+};
+/**
+* Generate a random hex color code.
+* 
+* @returns A hex color code string (e.g., '#a3b2f3')
+*/
+const randomColor = () => {
+	return `#${random(6, "0123456789abcdef").toLowerCase()}`;
+};
+const randomPassword = (length = 16, options = {}) => {
+	const opts = {
+		useUppercase: true,
+		useLowercase: true,
+		useNumbers: true,
+		useSymbols: true,
+		...options
+	};
+	let charset = "";
+	if (opts.useUppercase) charset += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	if (opts.useLowercase) charset += "abcdefghijklmnopqrstuvwxyz";
+	if (opts.useNumbers) charset += "0123456789";
+	if (opts.useSymbols) charset += "!@#$%^&*()_+-=[]{}|;:,.<>?";
+	if (charset.length === 0) throw new Error("At least one character type must be enabled");
+	return random(length, charset);
+};
+/**
+* Generate a cryptographically secure token for APIs, sessions, etc.
+* 
+* @param strength - Token strength (bytes) (default: 32)
+* @returns A secure token string
+*/
+const secureToken = (strength = 32) => {
+	return randomBytes(strength).toString("hex");
+};
+/**
+* Create a checksum for data integrity verification.
+* 
+* @param data - Data to create checksum for
+* @param algorithm - Hash algorithm (default: 'sha256')
+* @returns SHA256 checksum
+*/
+const checksum = (data, algorithm = "sha256") => {
+	return hash(data, algorithm);
+};
+/**
+* Verify data integrity using checksum.
+* 
+* @param data - Data to verify
+* @param expectedChecksum - Expected checksum
+* @param algorithm - Hash algorithm (default: 'sha256')
+* @returns True if checksums match
+*/
+const verifyChecksum = (data, expectedChecksum, algorithm = "sha256") => {
+	return checksum(data, algorithm) === expectedChecksum;
+};
+/**
+* Simple Caesar cipher implementation.
+* 
+* @param text - Text to encrypt/decrypt
+* @param shift - Number of positions to shift (default: 13)
+* @returns Encrypted/decrypted text
+*/
+const caesarCipher = (text, shift$1 = 13) => {
+	return text.replace(/[a-zA-Z]/g, (char) => {
+		const baseCharCode = char === char.toUpperCase() ? "A" : "a";
+		const shiftedCharCode = (char.charCodeAt(0) - baseCharCode.charCodeAt(0) + shift$1) % 26;
+		const newCharCode = (shiftedCharCode < 0 ? 26 + shiftedCharCode : shiftedCharCode) + baseCharCode.charCodeAt(0);
+		return String.fromCharCode(newCharCode);
 	});
 };
 
 //#endregion
 //#region src/Helpers/Number.ts
+var Number_exports = /* @__PURE__ */ __export({
+	abbreviate: () => abbreviate,
+	humanize: () => humanize,
+	toBytes: () => toBytes,
+	toHumanTime: () => toHumanTime
+});
 /**
 * Abbreviates large numbers using SI symbols (K, M, B...) 
 * and formats the output according to the given locale.
@@ -160,10 +399,10 @@ const humanize = (num, slugify$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);
+		const end$1 = +((numString[1] || "") + numString[2] + numString[3]);
+		if (end$1 === 0) return ones[numString[0]] + " thousand";
+		if (end$1 < 100) return ones[numString[0]] + " thousand and " + humanize(end$1, slugify$1);
+		return ones[numString[0]] + " thousand " + humanize(end$1, slugify$1);
 	}
 	return num;
 };
@@ -226,12 +465,21 @@ const toHumanTime = (seconds = 0, worded = false) => {
 	}
 	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}`;
+	const ss$1 = secs < 10 ? `0${secs}` : secs;
+	return `${hh}${mm}${ss$1}`;
 };
 
 //#endregion
 //#region src/Helpers/Obj.ts
+var Obj_exports = /* @__PURE__ */ __export({
+	dot: () => dot,
+	extractProperties: () => extractProperties,
+	getValue: () => getValue,
+	modObj: () => modObj,
+	safeDot: () => safeDot,
+	setNested: () => setNested,
+	slugifyKeys: () => slugifyKeys
+});
 /**
 * Flattens a nested object into a single-level object
 * with dot-separated keys.
@@ -376,6 +624,33 @@ const slugifyKeys = (obj, only = [], separator = "_") => {
 
 //#endregion
 //#region src/Helpers/Str.ts
+var Str_exports = /* @__PURE__ */ __export({
+	after: () => after,
+	afterLast: () => afterLast,
+	before: () => before,
+	beforeLast: () => beforeLast,
+	capitalize: () => capitalize,
+	chop: () => chop,
+	esc: () => esc,
+	firstLines: () => firstLines,
+	isInteger: () => isInteger,
+	isNumber: () => isNumber,
+	lastLines: () => lastLines,
+	padString: () => padString,
+	pluralize: () => pluralize,
+	replacePunctuation: () => replacePunctuation,
+	rot: () => rot,
+	singularize: () => singularize,
+	slugify: () => slugify,
+	split: () => split,
+	ss: () => ss,
+	sub: () => sub,
+	subString: () => subString,
+	substitute: () => substitute,
+	substr: () => substr,
+	translate: () => translate,
+	truncate: () => truncate
+});
 /**
 * Get the portion of the string after the first occurrence of the given value.
 * 
@@ -424,22 +699,13 @@ const beforeLast = (value, search) => {
 	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
-*/
+/** Capitalizes the first character of a string. */
 function capitalize(str) {
 	if (!str) return "";
 	return str[0].toUpperCase() + str.slice(1);
 }
 /**
 * 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;
@@ -459,16 +725,11 @@ const pluralize = (word, count) => {
 		"i",
 		"o",
 		"u"
-	].includes(word[word.length - 2]?.toLowerCase() ?? "")) return word.slice(0, -1) + "ies";
+	].includes(word.at(-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
-*/
+/** Converts a plural English word into its singular form. */
 const singularize = (word) => {
 	const irregulars = {
 		feet: "foot",
@@ -485,42 +746,17 @@ const singularize = (word) => {
 	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
-*/
+/** Converts a string into a slug format. */
 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();
+	return str.replace(/([a-z])([A-Z])/g, `$1${joiner}$2`).replace(/[\s\W]+/g, joiner).replace(new RegExp(`${joiner}{2,}`, "g"), joiner).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
-*/
+/** Truncates a string to a specified length and appends an ellipsis if needed. */
 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.
-*/
+/** Substitute placeholders { key } using object with dot notation. */
 const substitute = (str, data = {}, def) => {
 	if (!str || !data) return void 0;
 	const regex = /{\s*([a-zA-Z0-9_.]+)\s*}/g;
@@ -530,21 +766,588 @@ const substitute = (str, data = {}, def) => {
 		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
-*/
+/** Truncate string removing HTML tags and append suffix if needed. */
 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);
 };
+/** Get substring from offset/length similar to PHP substr. */
+const substr = (string, offset, length) => {
+	if (offset < 0) offset += string.length;
+	if (length === void 0) return string.substring(offset);
+	return string.substring(offset, offset + length);
+};
+/** Get substring by start/stop indexes. */
+const sub = (string, start$1, stop) => string.substring(start$1, stop);
+/** Escape string for JSON encoding (returns string without quotes). */
+const esc = (string) => JSON.stringify(string).slice(1, -1);
+/** Padding to a fixed size, right by default. */
+const padString = (string, size, padString$1 = " ", padRight = true) => {
+	if (string.length >= size) return string;
+	const pad = padString$1.repeat(size - string.length);
+	return padRight ? string + pad : pad + string;
+};
+/** Split by delimiter with edge-case rule. */
+const split = (string, delimiter) => {
+	if (string.startsWith(delimiter) || string.endsWith(delimiter)) return [""];
+	return string.split(delimiter);
+};
+/** Returns all the characters except the last. */
+const chop = (string) => string.slice(0, -1);
+/** Number checks. */
+const isNumber = (string) => !isNaN(Number(string)) && string.trim() !== "";
+const isInteger = (string) => Number.isInteger(Number(string)) && string.trim() !== "";
+/** ROT-N cipher. */
+const rot = (string, n = 13) => {
+	return string.replace(/[a-zA-Z]/g, (char) => {
+		const code = char.charCodeAt(0);
+		const start$1 = char >= "a" ? "a".charCodeAt(0) : "A".charCodeAt(0);
+		const end$1 = char >= "a" ? "z".charCodeAt(0) : "Z".charCodeAt(0);
+		let next = code + n;
+		while (next < start$1) next += 26;
+		while (next > end$1) next -= 26;
+		return String.fromCharCode(next);
+	});
+};
+/** Replace trailing punctuation with new format. */
+const replacePunctuation = (string, newFormat) => string.replace(/[.,;:!?]*$/, "") + newFormat;
+/** Array/object driven text replacement. */
+const translate = (string, replacements) => {
+	let result = string;
+	if (Array.isArray(replacements)) for (const [from, to] of replacements) result = result.replace(new RegExp(from, "g"), to);
+	else for (const [from, to] of Object.entries(replacements)) result = result.replace(new RegExp(from, "g"), to);
+	return result;
+};
+/** Strip slashes recursively. */
+const ss = (string) => string.replace(/\\(.)/g, "$1");
+/** First and last N lines. */
+const firstLines = (string, amount = 1) => string.split("\n").slice(0, amount).join("\n");
+const lastLines = (string, amount = 1) => string.split("\n").slice(-amount).join("\n");
+
+//#endregion
+//#region src/Helpers/Time.ts
+var Time_exports = /* @__PURE__ */ __export({
+	add: () => add,
+	dayOfYear: () => dayOfYear,
+	diff: () => diff,
+	end: () => end,
+	firstDayOfMonth: () => firstDayOfMonth,
+	format: () => format,
+	fromNow: () => fromNow,
+	fromTimestamp: () => fromTimestamp,
+	isBetween: () => isBetween,
+	isLeapYear: () => isLeapYear,
+	lastDayOfMonth: () => lastDayOfMonth,
+	now: () => now,
+	randomTime: () => randomTime,
+	start: () => start,
+	subtract: () => subtract,
+	unix: () => unix
+});
+/**
+* Get current timestamp in milliseconds.
+*
+* @returns Current timestamp as number
+*/
+const now = () => {
+	return Date.now();
+};
+/**
+* Get current Unix timestamp.
+*
+* @returns Current Unix timestamp
+*/
+const unix = () => {
+	return Math.floor(Date.now() / 1e3);
+};
+/**
+* Format a date string according to a specified format (UTC-based for determinism).
+*
+* @param date - Date string or Date object
+* @param format - Format to output (default: 'Y-m-d H:i:s')
+* @returns Formatted date string
+*/
+const format = (date, format$1 = "Y-m-d H:i:s") => {
+	const d = new Date(date);
+	if (isNaN(d.getTime())) throw new Error("Invalid date provided");
+	const year = d.getUTCFullYear();
+	const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+	const day = String(d.getUTCDate()).padStart(2, "0");
+	const hours = String(d.getUTCHours()).padStart(2, "0");
+	const minutes = String(d.getUTCMinutes()).padStart(2, "0");
+	const seconds = String(d.getUTCSeconds()).padStart(2, "0");
+	const monthNames = [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	];
+	const monthNamesShort = [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	];
+	const dayNames = [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	];
+	switch (format$1) {
+		case "Y-m-d": return `${year}-${month}-${day}`;
+		case "Y-m-d H:i:s": return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+		case "d-m-Y": return `${day}-${month}-${year}`;
+		case "d/m/Y": return `${day}/${month}/${year}`;
+		case "M j, Y": return `${monthNamesShort[d.getUTCMonth()]} ${d.getUTCDate()}, ${year}`;
+		case "F j, Y": return `${monthNames[d.getUTCMonth()]} ${d.getUTCDate()}, ${year}`;
+		case "D j M": return `${dayNames[d.getUTCDay()]} ${d.getUTCDate()} ${monthNamesShort[d.getUTCMonth()]}`;
+		case "timestamp": return d.toISOString();
+		case "unix": return Math.floor(d.getTime() / 1e3).toString();
+		default: return d.toISOString();
+	}
+};
+/**
+* Create a date for a given timestamp.
+*
+* @param timestamp - Unix timestamp
+* @returns Date object
+*/
+const fromTimestamp = (timestamp) => {
+	return /* @__PURE__ */ new Date(timestamp * 1e3);
+};
+/**
+* Return the difference for given date in seconds.
+*
+* @param date - Date to compare
+* @param referenceDate - Reference date (optional, defaults to now)
+* @returns Number of seconds difference
+*/
+const diff = (date, referenceDate) => {
+	const d1 = new Date(date);
+	const d2 = referenceDate ? new Date(referenceDate) : /* @__PURE__ */ new Date();
+	if (isNaN(d1.getTime()) || isNaN(d2.getTime())) throw new Error("Invalid date provided");
+	return Math.floor((d2.getTime() - d1.getTime()) / 1e3);
+};
+/**
+* Subtract time from the given date.
+*/
+const subtract = (date, amount = 1, unit = "days") => {
+	const d = new Date(date);
+	if (isNaN(d.getTime())) throw new Error("Invalid date provided");
+	const multiplier = {
+		milliseconds: 1,
+		seconds: 1e3,
+		minutes: 60 * 1e3,
+		hours: 3600 * 1e3,
+		days: 1440 * 60 * 1e3
+	}[unit] || 1e3;
+	return new Date(d.getTime() - amount * multiplier);
+};
+/**
+* Add time to the given date.
+*/
+const add = (date, amount = 1, unit = "days") => {
+	const d = new Date(date);
+	if (isNaN(d.getTime())) throw new Error("Invalid date provided");
+	const multiplier = {
+		milliseconds: 1,
+		seconds: 1e3,
+		minutes: 60 * 1e3,
+		hours: 3600 * 1e3,
+		days: 1440 * 60 * 1e3
+	}[unit] || 1e3;
+	return new Date(d.getTime() + amount * multiplier);
+};
+/**
+* Start time of a specific unit.
+*/
+const start = (date, unit = "days") => {
+	const d = new Date(date);
+	if (isNaN(d.getTime())) throw new Error("Invalid date provided");
+	const newDt = new Date(d);
+	switch (unit) {
+		case "days":
+			newDt.setHours(0, 0, 0, 0);
+			break;
+		case "hours":
+			newDt.setMinutes(0, 0, 0);
+			break;
+		case "minutes":
+			newDt.setSeconds(0, 0);
+			break;
+		case "seconds":
+			newDt.setMilliseconds(0);
+			break;
+		case "milliseconds": break;
+	}
+	return newDt;
+};
+/**
+* End time of a specific unit.
+*/
+const end = (date, unit = "days") => {
+	const d = new Date(date);
+	if (isNaN(d.getTime())) throw new Error("Invalid date provided");
+	const newDt = new Date(d);
+	switch (unit) {
+		case "days":
+			newDt.setHours(23, 59, 59, 999);
+			break;
+		case "hours":
+			newDt.setMinutes(59, 59, 999);
+			break;
+		case "minutes":
+			newDt.setSeconds(59, 999);
+			break;
+		case "seconds":
+			newDt.setMilliseconds(999);
+			break;
+		case "milliseconds": break;
+	}
+	return newDt;
+};
+/**
+* Get the difference in days from today.
+*/
+const fromNow = (date) => {
+	return diff(date) / (1440 * 60);
+};
+/**
+* Get a random time between the specified hour and minute.
+*/
+const randomTime = (startHour = 9, startMinute = 0, endHour = 17, endMinute = 0) => {
+	const today = /* @__PURE__ */ new Date();
+	const startMinutes = startHour * 60 + startMinute;
+	const endMinutes = endHour * 60 + endMinute;
+	const randomMinutes = Math.floor(Math.random() * (endMinutes - startMinutes)) + startMinutes;
+	const hour = Math.floor(randomMinutes / 60);
+	const minute = randomMinutes % 60;
+	const date = new Date(today);
+	date.setHours(hour, minute, 0, 0);
+	return date;
+};
+/**
+* Check if the current time is between the specified durations.
+*/
+const isBetween = (startTime, endTime) => {
+	const now$1 = /* @__PURE__ */ new Date();
+	const currentHours = now$1.getHours();
+	const currentMinutes = now$1.getMinutes();
+	const currentTotalMinutes = currentHours * 60 + currentMinutes;
+	const parseTime = (timeStr) => {
+		const [hours, minutes] = timeStr.split(":").map(Number);
+		return hours * 60 + minutes;
+	};
+	const startTotalMinutes = parseTime(startTime);
+	const endTotalMinutes = parseTime(endTime);
+	if (startTotalMinutes <= endTotalMinutes) return currentTotalMinutes >= startTotalMinutes && currentTotalMinutes <= endTotalMinutes;
+	else return currentTotalMinutes >= startTotalMinutes || currentTotalMinutes <= endTotalMinutes;
+};
+/** Day of year, first/last day of month, leap year checks. */
+const dayOfYear = (date = /* @__PURE__ */ new Date()) => {
+	const d = new Date(date);
+	const start$1 = new Date(Date.UTC(d.getUTCFullYear(), 0, 0));
+	const diff$1 = d.getTime() - start$1.getTime();
+	return Math.floor(diff$1 / (1e3 * 60 * 60 * 24));
+};
+const firstDayOfMonth = (date = /* @__PURE__ */ new Date()) => {
+	const d = new Date(date);
+	return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1));
+};
+const lastDayOfMonth = (date = /* @__PURE__ */ new Date()) => {
+	const d = new Date(date);
+	return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 0));
+};
+const isLeapYear = (year = (/* @__PURE__ */ new Date()).getUTCFullYear()) => {
+	return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+};
+
+//#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));
+	});
+};
+
+//#endregion
+//#region src/GlobalBootstrap.ts
+/**
+* Bootstrap the global helpers into the global scope.
+* This enables optional global access to all helper functions.
+* 
+* Example usage:
+* ```typescript
+* import { bootstrap } from '@h3ravel/support'
+* 
+* // Make helpers globally available
+* bootstrap()
+* 
+* // Now you can use:
+* Arr.chunk([1, 2, 3, 4], 2)
+* // or directly:
+* chunk([1, 2, 3, 4], 2)
+* Str.capitalize('hello world')
+* // or directly:
+* capitalize('hello world')
+* ```
+* 
+* @param target - The target object to attach helpers to (default: globalThis)
+*/
+function bootstrap(target = globalThis) {
+	const globalHelpers = {
+		Arr: Arr_exports,
+		Crypto: Crypto_exports,
+		Number: Number_exports,
+		Obj: Obj_exports,
+		Str: Str_exports,
+		Time: Time_exports,
+		chunk,
+		collapse,
+		alternate,
+		combine,
+		find,
+		forget,
+		first,
+		last,
+		isEmpty,
+		isNotEmpty,
+		pop,
+		prepend,
+		take,
+		reverse,
+		shift,
+		range,
+		flatten,
+		after,
+		afterLast,
+		before,
+		beforeLast,
+		capitalize,
+		pluralize,
+		singularize,
+		slugify,
+		subString,
+		substitute,
+		truncate,
+		substr,
+		sub,
+		esc,
+		padString,
+		split,
+		chop,
+		isNumber,
+		isInteger,
+		rot,
+		replacePunctuation,
+		translate,
+		ss,
+		firstLines,
+		lastLines,
+		dot,
+		extractProperties,
+		getValue,
+		modObj,
+		safeDot,
+		setNested,
+		slugifyKeys,
+		uuid,
+		random,
+		randomSecure,
+		hash,
+		hmac,
+		base64Encode,
+		base64Decode,
+		xor,
+		randomColor,
+		randomPassword,
+		secureToken,
+		checksum,
+		verifyChecksum,
+		caesarCipher,
+		now,
+		unix,
+		format,
+		fromTimestamp,
+		diff,
+		subtract,
+		add,
+		start,
+		end,
+		fromNow,
+		randomTime,
+		isBetween,
+		dayOfYear,
+		firstDayOfMonth,
+		lastDayOfMonth,
+		isLeapYear,
+		abbreviate,
+		humanize,
+		toBytes,
+		toHumanTime,
+		dump,
+		dd
+	};
+	Object.assign(target, globalHelpers);
+}
+/**
+* Clean up global helpers by removing them from the global scope.
+* This function removes all global helper attachments.
+* 
+* @param target - The target object to clean up (default: globalThis)
+*/
+function cleanBootstrap(target = globalThis) {
+	[
+		"Arr",
+		"chunk",
+		"collapse",
+		"alternate",
+		"combine",
+		"each",
+		"keys",
+		"find",
+		"forget",
+		"first",
+		"last",
+		"isEmpty",
+		"isNotEmpty",
+		"pop",
+		"prepend",
+		"take",
+		"reverse",
+		"shift",
+		"range",
+		"where",
+		"skip",
+		"flatten",
+		"Str",
+		"after",
+		"afterLast",
+		"before",
+		"beforeLast",
+		"capitalize",
+		"pluralize",
+		"singularize",
+		"slugify",
+		"subString",
+		"substitute",
+		"truncate",
+		"startsWith",
+		"endsWith",
+		"substr",
+		"sub",
+		"esc",
+		"padString",
+		"trim",
+		"ltrim",
+		"rtrim",
+		"trimChars",
+		"split",
+		"chop",
+		"isNumber",
+		"isInteger",
+		"rot",
+		"replacePunctuation",
+		"translate",
+		"ss",
+		"firstLines",
+		"lastLines",
+		"Obj",
+		"dot",
+		"extractProperties",
+		"getValue",
+		"modObj",
+		"safeDot",
+		"setNested",
+		"slugifyKeys",
+		"Crypto",
+		"uuid",
+		"random",
+		"randomSecure",
+		"hash",
+		"hmac",
+		"base64Encode",
+		"base64Decode",
+		"xor",
+		"randomColor",
+		"randomPassword",
+		"secureToken",
+		"checksum",
+		"verifyChecksum",
+		"caesarCipher",
+		"Time",
+		"now",
+		"unix",
+		"format",
+		"fromTimestamp",
+		"diff",
+		"subtract",
+		"add",
+		"start",
+		"end",
+		"fromNow",
+		"randomTime",
+		"isBetween",
+		"dayOfYear",
+		"firstDayOfMonth",
+		"lastDayOfMonth",
+		"isLeapYear",
+		"Number",
+		"abbreviate",
+		"humanize",
+		"toBytes",
+		"toHumanTime",
+		"dump",
+		"dd"
+	].forEach((helper) => {
+		if (helper in target) delete target[helper];
+	});
+}
 
 //#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 };
+export { abbreviate, add, after, afterLast, alternate, base64Decode, base64Encode, before, beforeLast, bootstrap, caesarCipher, capitalize, checksum, chop, chunk, cleanBootstrap, collapse, combine, dayOfYear, dd, diff, dot, dump, end, esc, extractProperties, find, first, firstDayOfMonth, firstLines, flatten, forget, format, fromNow, fromTimestamp, getValue, hash, hmac, humanize, isBetween, isEmpty, isInteger, isLeapYear, isNotEmpty, isNumber, last, lastDayOfMonth, lastLines, modObj, now, padString, pluralize, pop, prepend, random, randomColor, randomPassword, randomSecure, randomTime, range, replacePunctuation, reverse, rot, safeDot, secureToken, setNested, shift, singularize, slugify, slugifyKeys, split, ss, start, sub, subString, substitute, substr, subtract, take, toBytes, toHumanTime, translate, truncate, unix, uuid, verifyChecksum, xor };
 //# sourceMappingURL=index.js.map