@h3ravel/support 0.12.0 → 0.14.0

package/dist/index.cjs

@@ -37,138 +37,44 @@ let util = require("util");
 util = __toESM(util);
 let dayjs = require("dayjs");
 dayjs = __toESM(dayjs);
-let dayjs_plugin_advancedFormat = require("dayjs/plugin/advancedFormat");
-dayjs_plugin_advancedFormat = __toESM(dayjs_plugin_advancedFormat);
-let dayjs_plugin_customParseFormat = require("dayjs/plugin/customParseFormat");
-dayjs_plugin_customParseFormat = __toESM(dayjs_plugin_customParseFormat);
-let dayjs_plugin_dayOfYear = require("dayjs/plugin/dayOfYear");
-dayjs_plugin_dayOfYear = __toESM(dayjs_plugin_dayOfYear);
-let dayjs_plugin_isBetween = require("dayjs/plugin/isBetween");
-dayjs_plugin_isBetween = __toESM(dayjs_plugin_isBetween);
-let dayjs_plugin_isLeapYear = require("dayjs/plugin/isLeapYear");
-dayjs_plugin_isLeapYear = __toESM(dayjs_plugin_isLeapYear);
-let dayjs_plugin_relativeTime = require("dayjs/plugin/relativeTime");
-dayjs_plugin_relativeTime = __toESM(dayjs_plugin_relativeTime);
-let dayjs_plugin_timezone = require("dayjs/plugin/timezone");
-dayjs_plugin_timezone = __toESM(dayjs_plugin_timezone);
-let dayjs_plugin_utc = require("dayjs/plugin/utc");
-dayjs_plugin_utc = __toESM(dayjs_plugin_utc);
+let dayjs_plugin_advancedFormat_js = require("dayjs/plugin/advancedFormat.js");
+dayjs_plugin_advancedFormat_js = __toESM(dayjs_plugin_advancedFormat_js);
+let dayjs_plugin_customParseFormat_js = require("dayjs/plugin/customParseFormat.js");
+dayjs_plugin_customParseFormat_js = __toESM(dayjs_plugin_customParseFormat_js);
+let dayjs_plugin_dayOfYear_js = require("dayjs/plugin/dayOfYear.js");
+dayjs_plugin_dayOfYear_js = __toESM(dayjs_plugin_dayOfYear_js);
+let dayjs_plugin_isBetween_js = require("dayjs/plugin/isBetween.js");
+dayjs_plugin_isBetween_js = __toESM(dayjs_plugin_isBetween_js);
+let dayjs_plugin_isLeapYear_js = require("dayjs/plugin/isLeapYear.js");
+dayjs_plugin_isLeapYear_js = __toESM(dayjs_plugin_isLeapYear_js);
+let dayjs_plugin_relativeTime_js = require("dayjs/plugin/relativeTime.js");
+dayjs_plugin_relativeTime_js = __toESM(dayjs_plugin_relativeTime_js);
+let dayjs_plugin_timezone_js = require("dayjs/plugin/timezone.js");
+dayjs_plugin_timezone_js = __toESM(dayjs_plugin_timezone_js);
+let dayjs_plugin_utc_js = require("dayjs/plugin/utc.js");
+dayjs_plugin_utc_js = __toESM(dayjs_plugin_utc_js);
 
-//#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.
-*
-* @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;
-};
-/**
-* 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;
-};
+//#region src/Exceptions/InvalidArgumentException.ts
 /**
-* Alternates between two arrays, creating a zipped result.
+* Custom error for invalid type coercion
 */
-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]);
+var InvalidArgumentException = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidArgumentException";
 	}
-	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;
+
+//#endregion
+//#region src/Exceptions/RuntimeException.ts
 /**
-* 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
+* Custom error for invalid type coercion
 */
-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) if (Array.isArray(item)) recurse(item);
-		else result.push(item);
-	};
-	recurse(arr);
-	return result;
+var RuntimeException = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RuntimeException";
+	}
 };
 
 //#endregion
@@ -335,10 +241,10 @@ const verifyChecksum = (data, expectedChecksum, algorithm = "sha256") => {
 * @param shift - Number of positions to shift (default: 13)
 * @returns Encrypted/decrypted text
 */
-const caesarCipher = (text, shift$1 = 13) => {
+const caesarCipher = (text, shift = 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 shiftedCharCode = (char.charCodeAt(0) - baseCharCode.charCodeAt(0) + shift) % 26;
 		const newCharCode = (shiftedCharCode < 0 ? 26 + shiftedCharCode : shiftedCharCode) + baseCharCode.charCodeAt(0);
 		return String.fromCharCode(newCharCode);
 	});
@@ -550,22 +456,27 @@ const toHumanTime = (seconds = 0, worded = false) => {
 		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}`;
+	return `${hours > 0 ? `${hours}:` : ""}${(hours > 0 && minutes < 10 ? `0${minutes}` : minutes) + ":"}${secs < 10 ? `0${secs}` : secs}`;
 };
 
 //#endregion
 //#region src/Helpers/Obj.ts
 var Obj_exports = /* @__PURE__ */ __export({
+	Obj: () => Obj,
+	data_fill: () => data_fill,
+	data_forget: () => data_forget,
+	data_get: () => data_get,
+	data_set: () => data_set,
 	dot: () => dot,
 	extractProperties: () => extractProperties,
 	getValue: () => getValue,
 	modObj: () => modObj,
 	safeDot: () => safeDot,
 	setNested: () => setNested,
-	slugifyKeys: () => slugifyKeys
+	slugifyKeys: () => slugifyKeys,
+	toCssClasses: () => toCssClasses,
+	toCssStyles: () => toCssStyles,
+	undot: () => undot
 });
 /**
 * Flattens a nested object into a single-level object
@@ -639,74 +550,1119 @@ const getValue = (key, item) => {
 		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);
-}
-/**
-* 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;
+	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);
+}
+/**
+* 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 = (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(key), value]));
+};
+/**
+* toCssClasses
+*
+* Convert array/object/string input into a CSS class string.
+* - Arrays: included if truthy
+* - Objects: keys included if value is truthy
+* - Strings: included as-is
+*/
+function toCssClasses(input) {
+	if (!input) return "";
+	const classes = [];
+	if (typeof input === "string") return input.trim();
+	if (Array.isArray(input)) input.forEach((item) => {
+		if (item) classes.push(String(item).trim());
+	});
+	else if (typeof input === "object") {
+		for (const [key, value] of Object.entries(input)) if (value) classes.push(key);
+	}
+	return classes.join(" ");
+}
+/**
+* toCssStyles
+*
+* Convert object input into CSS style string.
+* - Only includes truthy values (ignores null/undefined/false)
+*/
+function toCssStyles(styles) {
+	const parts = [];
+	for (const [k, v] of Object.entries(styles)) {
+		if (v === null || v === void 0 || v === false) continue;
+		parts.push(`${k}:${v}`);
+	}
+	return parts.join(";");
+}
+/**
+* undot
+*
+* Convert a dot-notated object back into nested structure.
+*
+* Example:
+* undot({ 'a.b': 1, 'c.0': 2 }) -> { a: { b: 1 }, c: [2] }
+*/
+function undot(obj) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const parts = key.split(".");
+		let node = result;
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			const isLast = i === parts.length - 1;
+			const nextPart = parts[i + 1];
+			const isArrayIndex = !isNaN(Number(nextPart));
+			if (isLast) node[part] = value;
+			else {
+				if (!(part in node)) node[part] = isArrayIndex ? [] : {};
+				node = node[part];
+			}
+		}
+	}
+	return result;
+}
+/**
+* data_get
+*
+* Get a value from an object using dot notation.
+*/
+function data_get(obj, path, defaultValue) {
+	if (!obj) return defaultValue;
+	const parts = Array.isArray(path) ? path : path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (!current || !(part in current)) return defaultValue;
+		current = current[part];
+	}
+	return current;
+}
+/**
+* data_set
+*
+* Set a value in an object using dot notation. Mutates the object.
+*/
+function data_set(obj, path, value) {
+	const parts = Array.isArray(path) ? path : path.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 (!(part in current) || typeof current[part] !== "object" || current[part] === null) current[part] = {};
+			current = current[part];
+		}
+	}
+}
+/**
+* data_fill
+*
+* Like data_set, but only sets the value if the key does NOT exist.
+*/
+function data_fill(obj, path, value) {
+	if (data_get(obj, path) === void 0) data_set(obj, path, value);
+}
+/**
+* data_forget
+*
+* Remove a key from an object using dot notation.
+*/
+function data_forget(obj, path) {
+	const parts = Array.isArray(path) ? path : path.split(".");
+	let current = obj;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (i === parts.length - 1) delete current[part];
+		else {
+			if (!current[part] || typeof current[part] !== "object") break;
+			current = current[part];
+		}
+	}
+}
+var Obj = class Obj {
+	/**
+	* Check if the value is a non-null object (associative/accessible).
+	*/
+	static accessible(value) {
+		return value !== null && typeof value === "object";
+	}
+	/**
+	* Add a key-value pair to an object only if the key does not already exist.
+	*
+	* Returns a new object (does not mutate original).
+	*/
+	static add(obj, key, value) {
+		if (!(key in obj)) return {
+			...obj,
+			[key]: value
+		};
+		return obj;
+	}
+	/**
+	* Split object into [keys, values]
+	*/
+	static divide(obj) {
+		return [Object.keys(obj), Object.values(obj)];
+	}
+	/**
+	* Check if a key exists in the object.
+	*/
+	static exists(obj, key) {
+		return Object.prototype.hasOwnProperty.call(obj, key);
+	}
+	/**
+	* Get a value from an object using dot notation.
+	*
+	* Example:
+	* Obj.get({a:{b:1}}, 'a.b') -> 1
+	*/
+	static get(obj, path, defaultValue) {
+		if (!Obj.accessible(obj)) return defaultValue;
+		const parts = Array.isArray(path) ? path : path.split(".");
+		let current = obj;
+		for (const part of parts) {
+			if (!Obj.accessible(current) || !(part in current)) return defaultValue;
+			current = current[part];
+		}
+		return current;
+	}
+	/**
+	* Check if the object has a given key or keys (dot notation supported).
+	*/
+	static has(obj, keys) {
+		if (!Obj.accessible(obj)) return false;
+		return (Array.isArray(keys) ? keys : [keys]).every((key) => {
+			const parts = key.split(".");
+			let current = obj;
+			for (const part of parts) {
+				if (!Obj.accessible(current) || !(part in current)) return false;
+				current = current[part];
+			}
+			return true;
+		});
+	}
+	/**
+	* Check if an object is associative (has at least one non-numeric key).
+	*/
+	static isAssoc(obj) {
+		if (!Obj.accessible(obj)) return false;
+		return Object.keys(obj).some((k) => isNaN(Number(k)));
+	}
+	/**
+	* Add a prefix to all keys of the object.
+	*/
+	static prependKeysWith(obj, prefix) {
+		if (!Obj.accessible(obj)) return {};
+		const result = {};
+		for (const [k, v] of Object.entries(obj)) result[`${prefix}${k}`] = v;
+		return result;
+	}
+	/**
+	* Convert an object into a URL query string.
+	*
+	* Nested objects/arrays are flattened using bracket notation.
+	*/
+	static query(obj) {
+		const encode = encodeURIComponent;
+		const parts = [];
+		function build(key, value) {
+			if (Array.isArray(value)) value.forEach((v, i) => build(`${key}[${i}]`, v));
+			else if (Obj.accessible(value)) Object.entries(value).forEach(([k, v]) => build(`${key}[${k}]`, v));
+			else parts.push(`${encode(key)}=${encode(value)}`);
+		}
+		Object.entries(obj).forEach(([k, v]) => build(k, v));
+		return parts.join("&");
+	}
+};
+
+//#endregion
+//#region src/Helpers/Arr.ts
+/**
+* Arr — Laravel-like array helpers for JavaScript.
+*
+* - Methods aim for clear, predictable JS behavior.
+* - Inputs are validated where useful; functions try not to mutate arguments.
+*/
+var Arr = class Arr {
+	/**
+	* Helper: is a value an object (but not null).
+	*/
+	static _isObject(value) {
+		return value !== null && typeof value === "object" && !Array.isArray(value);
+	}
+	/**
+	* Helper: deep clone for safety (simple).
+	* Uses JSON methods — good for typical data shapes (no functions, Dates, Maps).
+	*/
+	static _clone(value) {
+		try {
+			return JSON.parse(JSON.stringify(value));
+		} catch {
+			return value;
+		}
+	}
+	/**
+	* Retrieve a value using dot notation
+	* Throws if value is not an array
+	*/
+	static array(obj, path, defaultValue) {
+		const val = data_get(obj, path, defaultValue);
+		if (!Array.isArray(val)) throw new InvalidArgumentException(`Value at "${path}" is not an array.`);
+		return val;
+	}
+	/**
+	* Retrieve a value using dot notation
+	* Throws if value is not a boolean
+	*/
+	static boolean(obj, path, defaultValue) {
+		const val = data_get(obj, path, defaultValue);
+		if (typeof val !== "boolean") throw new InvalidArgumentException(`Value at "${path}" is not a boolean.`);
+		return val;
+	}
+	/**
+	* Flatten an array of arrays by one level.
+	*
+	* Example:
+	* Arr.collapse([[1,2], [3], 4]) -> [1,2,3,4]
+	*/
+	static collapse(array) {
+		if (!Array.isArray(array)) return [];
+		const result = [];
+		for (const item of array) if (Array.isArray(item)) result.push(...item);
+		else result.push(item);
+		return result;
+	}
+	/**
+	* Cartesian product of arrays.
+	*
+	* Example:
+	* Arr.crossJoin([1,2], ['a','b']) -> [[1,'a'], [1,'b'], [2,'a'], [2,'b']]
+	*
+	* Accepts any number of array arguments (or single array-of-arrays).
+	*/
+	static crossJoin(...arrays) {
+		let inputs = arrays;
+		if (arrays.length === 1 && Array.isArray(arrays[0]) && arrays[0].some(Array.isArray)) inputs = arrays[0];
+		inputs = inputs.map((a) => Array.isArray(a) ? a : [a]);
+		let product = [[]];
+		for (const arr of inputs) {
+			const next = [];
+			for (const prefix of product) for (const value of arr) next.push([...prefix, value]);
+			product = next;
+		}
+		return product;
+	}
+	/**
+	* Split an array (or object) into two arrays: [keys, values].
+	*
+	* For arrays, keys are numeric indices. For objects, keys are property names.
+	*
+	* Example:
+	* Arr.divide(['a','b']) -> [[0,1], ['a','b']]
+	* Arr.divide({x:1,y:2}) -> [['x','y'], [1,2]]
+	*/
+	static divide(input) {
+		if (Array.isArray(input)) return [input.map((_, i) => i), input.slice()];
+		if (Arr._isObject(input)) {
+			const keys = Object.keys(input);
+			return [keys, keys.map((k) => input[k])];
+		}
+		return [[], []];
+	}
+	/**
+	* Flatten a nested array/object structure into a single-level object
+	* with dot-notated keys.
+	*
+	* Example:
+	* Arr.dot({ a: { b: 1 }, c: [2,3] }) -> { 'a.b': 1, 'c.0': 2, 'c.1': 3 }
+	*
+	* Works for arrays and plain objects.
+	*/
+	static dot(input, prefix = "") {
+		const result = {};
+		const recurse = (val, path) => {
+			if (Array.isArray(val)) for (let i = 0; i < val.length; i++) recurse(val[i], path ? `${path}.${i}` : String(i));
+			else if (Arr._isObject(val)) for (const [k, v] of Object.entries(val)) recurse(v, path ? `${path}.${k}` : k);
+			else result[path] = val;
+		};
+		if (Array.isArray(input) || Arr._isObject(input)) recurse(input, prefix);
+		return result;
+	}
+	/**
+	* Checks if all elements satisfy the predicate
+	*/
+	static every(array, predicate) {
+		return array.every(predicate);
+	}
+	/**
+	* Remove items by keys/indices from an array or properties from an object.
+	*
+	* For arrays: keys are numeric indices (single number or array of numbers).
+	*
+	* Returns a shallow-copied result (does not mutate input).
+	*
+	* Example:
+	* Arr.except([10,20,30], [1]) -> [10,30]
+	*/
+	static except(input, keys) {
+		const keySet = new Set(Array.isArray(keys) ? keys : [keys]);
+		if (Array.isArray(input)) return input.filter((_, idx) => !keySet.has(idx));
+		if (Arr._isObject(input)) {
+			const out = {};
+			for (const [k, v] of Object.entries(input)) if (!keySet.has(k)) out[k] = v;
+			return out;
+		}
+		return input;
+	}
+	/**
+	* Return the first element of an array that satisfies the predicate,
+	* or the first element if no predicate is provided, otherwise the defaultValue.
+	*
+	* Predicate can be true (boolean), a function or a value to match (strict equality).
+	* 
+	* When predicate is true (boolean), the first element will be removed and a tuple will be returned [el, rest].
+	* 
+	* @param array 
+	* @param predicate 
+	* @param defaultValue 
+	* 
+	* @returns 
+	*/
+	static first(array, predicate, defaultValue) {
+		if (predicate === true) {
+			if (!array.length) throw new Error("Cannot shift from empty array");
+			return [array[0], array.slice(1)];
+		}
+		if (!Array.isArray(array) || array.length === 0) return defaultValue;
+		if (predicate === void 0) return array[0];
+		if (typeof predicate === "function") {
+			for (const item of array) if (predicate(item)) return item;
+			return defaultValue;
+		}
+		for (const item of array) if (typeof predicate !== "boolean" && item === predicate) return item;
+		return defaultValue;
+	}
+	/**
+	* Recursively flatten an array up to `depth` levels (default: Infinity).
+	*
+	* Example:
+	* Arr.flatten([1, [2, [3]]], 1) -> [1,2,[3]]
+	*/
+	static flatten(array, depth = Infinity) {
+		if (!Array.isArray(array)) return [];
+		if (depth < 1) return array.slice();
+		const result = [];
+		for (const item of array) if (Array.isArray(item) && depth > 0) result.push(...Arr.flatten(item, depth - 1));
+		else result.push(item);
+		return result;
+	}
+	/**
+	* Retrieve a value from an array/object using dot notation
+	* Throws if value is not a float
+	*/
+	static float(obj, path, defaultValue) {
+		const val = data_get(obj, path, defaultValue);
+		if (typeof val !== "number" || Number.isNaN(val)) throw new InvalidArgumentException(`Value at "${path}" is not a float.`);
+		return val;
+	}
+	/**
+	* Remove element(s) by index or dot-notated path from an array/object.
+	*
+	* For arrays: accepts numeric index or array of indices. Returns a new array.
+	*
+	* For objects: supports dot notation to remove nested keys.
+	*
+	* Example:
+	* Arr.forget([1,2,3], 1) -> [1,3]
+	* Arr.forget({a:{b:1}}, 'a.b') -> { a: {} }
+	*/
+	static forget(input, keys) {
+		if (Array.isArray(input)) {
+			const removeSet = new Set(Array.isArray(keys) ? keys : [keys]);
+			return input.filter((_, i) => !removeSet.has(i));
+		}
+		if (Arr._isObject(input)) {
+			const out = Arr._clone(input);
+			const keyList = Array.isArray(keys) ? keys : [keys];
+			for (const key of keyList) {
+				const parts = String(key).split(".");
+				let node = out;
+				for (let i = 0; i < parts.length; i++) {
+					const part = parts[i];
+					if (i === parts.length - 1) {
+						if (node && Object.prototype.hasOwnProperty.call(node, part)) delete node[part];
+					} else {
+						if (!Arr._isObject(node[part])) break;
+						node = node[part];
+					}
+				}
+			}
+			return out;
+		}
+		return input;
+	}
+	/**
+	* Converts various input types into a plain array
+	* Supports Arrays, Objects, Iterables, Map, WeakMap, and custom toArray/toJSON/jsonSerialize methods
+	*/
+	static from(value) {
+		if (value == null) return [];
+		if (Array.isArray(value)) return value;
+		if (Symbol.iterator in Object(value)) return [...value];
+		if (value.toArray) return value.toArray();
+		if (value.toJSON) return value.toJSON();
+		if (value.jsonSerialize) return value.jsonSerialize();
+		if (value instanceof Map) return Array.from(value.entries());
+		if (value instanceof WeakMap) return [];
+		if (typeof value === "object") return Object.values(value);
+		return [value];
+	}
+	/**
+	* Checks if an object has all the specified keys
+	*/
+	static hasAll(obj, keys) {
+		return keys.every((k) => k in obj);
+	}
+	/**
+	* For arrays: check if the array contains any of the provided values.
+	*
+	* values can be single value or array of values.
+	*
+	* Example:
+	* Arr.hasAny([1,2,3], [4,2]) -> true
+	*/
+	static hasAny(array, values) {
+		if (!Array.isArray(array)) return false;
+		const vs = Array.isArray(values) ? values : [values];
+		const set = new Set(array);
+		for (const v of vs) if (set.has(v)) return true;
+		return false;
+	}
+	/**
+	* Retrieve a value using dot notation
+	* Throws if value is not an integer
+	*/
+	static integer(obj, path, defaultValue) {
+		const val = data_get(obj, path, defaultValue);
+		if (!Number.isInteger(val)) throw new InvalidArgumentException(`Value at "${path}" is not an integer.`);
+		return val;
+	}
+	/**
+	* Determine if the input is a "list-like" array: an Array with
+	* contiguous numeric indices starting at 0 (no gaps).
+	*
+	* Example:
+	* Arr.isList([1,2,3]) -> true
+	* const a = []; a[2] = 5; Arr.isList(a) -> false
+	*/
+	static isList(value) {
+		if (!Array.isArray(value)) return false;
+		for (let i = 0; i < value.length; i++) if (!(i in value)) return false;
+		return true;
+	}
+	/**
+	* Join array elements into a string using the given separator.
+	*
+	* Example:
+	* Arr.join([1,2,3], '-') -> '1-2-3'
+	*/
+	static join(array, separator = ",") {
+		return Array.isArray(array) ? array.join(separator) : "";
+	}
+	/**
+	* Create an object indexed by a key or callback function.
+	*
+	* Example:
+	* Arr.keyBy([{id:1},{id:2}], 'id') -> { '1': {id:1}, '2': {id:2} }
+	*/
+	static keyBy(array, key) {
+		const result = {};
+		if (!Array.isArray(array)) return result;
+		for (const item of array) {
+			let k;
+			if (typeof key === "function") k = key(item);
+			else k = String(item[key]);
+			result[k] = item;
+		}
+		return result;
+	}
+	/**
+	* Get the last element of an array, optionally matching a predicate,
+	* or the last element if no predicate is provided, otherwise the defaultValue.
+	*
+	* Predicate can be a true (boolean), a function or a value to match (strict equality).
+	* 
+	* When predicate is true (boolean), the last element will be removed and a tuple will be returned [el, rest].
+	* 
+	* @param array 
+	* @param predicate 
+	* @param defaultValue 
+	* 
+	* @returns 
+	*/
+	static last(array, predicate, defaultValue) {
+		if (predicate === true) {
+			if (!array.length) throw new Error("Cannot pop from empty array");
+			return [array[array.length - 1], array.slice(0, -1)];
+		}
+		if (!Array.isArray(array) || array.length === 0) return defaultValue;
+		if (!predicate) return array[array.length - 1];
+		if (typeof predicate === "function") {
+			for (let i = array.length - 1; i >= 0; i--) if (predicate(array[i])) return array[i];
+		} else for (let i = array.length - 1; i >= 0; i--) if (array[i] === predicate) return array[i];
+		return defaultValue;
+	}
+	/**
+	* Transform each element in an array using a callback.
+	*/
+	static map(array, callback) {
+		return Array.isArray(array) ? array.map(callback) : [];
+	}
+	/**
+	* Maps a multi-dimensional array with a spread callback
+	*/
+	static mapSpread(array, callback) {
+		return array.map((item) => callback(...Array.isArray(item) ? item : [item]));
+	}
+	/**
+	* Map each element to a key-value pair.
+	*
+	* Example:
+	* Arr.mapWithKeys([{id:1, name:'A'}], x => [x.id, x.name])
+	* -> { '1': 'A' }
+	*/
+	static mapWithKeys(array, callback) {
+		const result = {};
+		if (!Array.isArray(array)) return result;
+		array.forEach((item, idx) => {
+			const [k, v] = callback(item, idx);
+			result[String(k)] = v;
+		});
+		return result;
+	}
+	/**
+	* Return only elements at the given indices.
+	*
+	* Example:
+	* Arr.only([10,20,30], [0,2]) -> [10,30]
+	*/
+	static only(array, keys) {
+		if (!Array.isArray(array)) return [];
+		const keyArray = Array.isArray(keys) ? keys : [keys];
+		return array.filter((_, idx) => keyArray.includes(idx));
+	}
+	/**
+	* Split an array into two arrays based on a predicate
+	*/
+	static partition(array, predicate) {
+		const truthy = [];
+		const falsy = [];
+		array.forEach((item) => (predicate(item) ? truthy : falsy).push(item));
+		return [truthy, falsy];
+	}
+	/**
+	* Extract a property from each element in an array of objects.
+	*
+	* Example:
+	* Arr.pluck([{name:'A'},{name:'B'}], 'name') -> ['A','B']
+	*/
+	static pluck(array, key) {
+		if (!Array.isArray(array)) return [];
+		return array.map((item) => item[key]);
+	}
+	/**
+	* Add elements to the beginning of an array and return a new array.
+	* 
+	* @param array 
+	* @param value 
+	* @returns 
+	*/
+	static prepend(array, ...value) {
+		return [...value, ...Array.isArray(array) ? array : []];
+	}
+	/**
+	* Remove a value from an array by index and return it.
+	* Returns a tuple: [newArray, removedValue]
+	*/
+	static pull(array, key) {
+		if (!Array.isArray(array) || key < 0 || key >= array.length) return [array, void 0];
+		const copy = array.slice();
+		const [removed] = copy.splice(key, 1);
+		return [copy, removed];
+	}
+	/**
+	* Append values to an array (mutable)
+	*/
+	static push(array, ...values) {
+		array.push(...values);
+		return array;
+	}
+	/**
+	* Pick one or more random elements from an array.
+	*/
+	static random(array, count = 1) {
+		if (!Array.isArray(array) || array.length === 0) return void 0;
+		const shuffled = Arr.shuffle(array);
+		if (count === 1) return shuffled[0];
+		return shuffled.slice(0, count);
+	}
+	/**
+	* Returns array elements that do NOT satisfy the predicate
+	*/
+	static reject(array, predicate) {
+		return array.filter((item) => !predicate(item));
+	}
+	/**
+	* Pick keys from an array of objects or an object
+	*/
+	static select(obj, keys) {
+		const result = {};
+		keys.forEach((k) => {
+			if (k in obj) result[k] = obj[k];
+		});
+		return result;
+	}
+	/**
+	* Returns the only element that passes a callback, throws if none or multiple
+	*/
+	static sole(array, predicate) {
+		const filtered = array.filter(predicate);
+		if (filtered.length === 0) throw new InvalidArgumentException("No element satisfies the condition.");
+		if (filtered.length > 1) throw new InvalidArgumentException("Multiple elements satisfy the condition.");
+		return filtered[0];
+	}
+	/**
+	* Checks if at least one element satisfies the predicate
+	*/
+	static some(array, predicate) {
+		return array.some(predicate);
+	}
+	/**
+	* Randomly shuffle an array and return a new array.
+	*/
+	static shuffle(array) {
+		if (!Array.isArray(array)) return [];
+		const copy = array.slice();
+		for (let i = copy.length - 1; i > 0; i--) {
+			const j = Math.floor(Math.random() * (i + 1));
+			[copy[i], copy[j]] = [copy[j], copy[i]];
+		}
+		return copy;
+	}
+	/**
+	* Sort an array ascending using optional comparator.
+	*/
+	static sort(array, comparator) {
+		if (!Array.isArray(array)) return [];
+		return array.slice().sort(comparator);
+	}
+	/**
+	* Sort an array descending using optional comparator.
+	*/
+	static sortDesc(array, comparator) {
+		return Arr.sort(array, comparator ? (a, b) => comparator(b, a) : void 0);
+	}
+	/**
+	* Recursively sort arrays inside an array.
+	*/
+	static sortRecursive(array) {
+		if (!Array.isArray(array)) return [];
+		return array.map((item) => Array.isArray(item) ? Arr.sortRecursive(item) : item).sort();
+	}
+	/**
+	* Recursively sort arrays inside an array descending.
+	*/
+	static sortRecursiveDesc(array) {
+		if (!Array.isArray(array)) return [];
+		return array.map((item) => Array.isArray(item) ? Arr.sortRecursiveDesc(item) : item).sort().reverse();
+	}
+	/**
+	* Retrieve a value using dot notation
+	* Throws if value is not a string
+	*/
+	static string(obj, path, defaultValue) {
+		const val = data_get(obj, path, defaultValue);
+		if (typeof val !== "string") throw new InvalidArgumentException(`Value at "${path}" is not a string.`);
+		return val;
+	}
+	/**
+	* Return the first N elements of an array.
+	* 
+	* @param array 
+	* @param count 
+	* @returns 
+	*/
+	static take(array, count) {
+		if (!Array.isArray(array)) return [];
+		return array.slice(0, count);
+	}
+	/**
+	* Filter an array based on a predicate function or key-value match.
+	*/
+	static where(array, predicate) {
+		if (!Array.isArray(array)) return [];
+		if (typeof predicate === "function") return array.filter(predicate);
+		return array.filter((item) => Object.entries(predicate).every(([k, v]) => item[k] === v));
+	}
+	/**
+	* Filter an array of objects, keeping elements where the given key is not null/undefined.
+	*/
+	static whereNotNull(array, key) {
+		if (!Array.isArray(array)) return [];
+		return array.filter((item) => item[key] !== null && item[key] !== void 0);
+	}
+	/**
+	* If the given value is not an array and not null, wrap it in one.
+	* 
+	* Non-array values become [value]; null/undefined becomes [].
+	* 
+	* @param value 
+	* @returns 
+	*/
+	static wrap(value) {
+		if (value === null || value === void 0) return [];
+		return Array.isArray(value) ? value : [value];
+	}
+	/**
+	* Return the first element of an array, undefined if empty.
+	*/
+	static head(array) {
+		return Array.isArray(array) && array.length ? array[0] : void 0;
+	}
+	/**
+	* 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)
+	*/
+	static 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;
+	};
+	/**
+	* Alternates between two arrays, creating a zipped result.
+	* 
+	* @param a 
+	* @param b 
+	* @returns 
+	*/
+	static 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.
+	* 
+	* @param arr 
+	* @returns 
+	*/
+	static 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. 
+	* 
+	* @param key 
+	* @param arr 
+	* @returns 
+	*/
+	static find(key, arr) {
+		return arr.find((item) => item === key) || null;
+	}
+	/**
+	* Check if array is empty.
+	* 
+	* @param arr 
+	* @returns 
+	*/
+	static isEmpty(arr) {
+		if (arr.length === 0) return true;
+		else return false;
+	}
+	/**
+	* Check if array is empty. 
+	* 
+	* @param arr 
+	* @returns 
+	*/
+	static isNotEmpty(arr) {
+		return arr.length > 0;
+	}
+	/**
+	* Pop the element off the end of array.
+	* 
+	* @param arr 
+	* @returns 
+	*/
+	static pop(arr) {
+		return arr.slice(0, -1);
+	}
+	/**
+	* Create a new array in reverse order. 
+	* 
+	* @param arr 
+	* @returns 
+	*/
+	static reverse(arr) {
+		return [...arr].reverse();
+	}
+	/**
+	* Return the first element of an array that satisfies the predicate,
+	* or the first element if no predicate is provided, otherwise the defaultValue.
+	*
+	* Predicate can be true (boolean), a function or a value to match (strict equality).
+	* 
+	* When predicate is true (boolean), the first element will be removed and a tuple will be returned [el, rest].
+	* 
+	* @param array 
+	* @param predicate 
+	* @param defaultValue 
+	* 
+	* @alias Arr.first()
+	* @returns 
+	*/
+	static shift(array, predicate, defaultValue) {
+		return Arr.first(array, predicate, defaultValue);
+	}
+	/**
+	* 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
+	*/
+	static range(size, startAt = 0) {
+		if (size <= 0 || !Number.isFinite(size)) return [];
+		return Array.from({ length: size }, (_, i) => startAt + i);
+	}
+};
+
+//#endregion
+//#region src/Helpers/Time.ts
+dayjs.default.extend(dayjs_plugin_utc_js.default);
+dayjs.default.extend(dayjs_plugin_timezone_js.default);
+dayjs.default.extend(dayjs_plugin_dayOfYear_js.default);
+dayjs.default.extend(dayjs_plugin_isBetween_js.default);
+dayjs.default.extend(dayjs_plugin_isLeapYear_js.default);
+dayjs.default.extend(dayjs_plugin_relativeTime_js.default);
+dayjs.default.extend(dayjs_plugin_advancedFormat_js.default);
+dayjs.default.extend(dayjs_plugin_customParseFormat_js.default);
+const phpToDayjsTokens = (format$1) => format$1.replace(/Y/g, "YYYY").replace(/m/g, "MM").replace(/d/g, "DD").replace(/H/g, "HH").replace(/i/g, "mm").replace(/s/g, "ss");
+function format(date, fmt) {
+	return (0, dayjs.default)(date).format(phpToDayjsTokens(fmt));
+}
+const TimeClass = class {};
+var DateTime = class DateTime extends TimeClass {
+	instance;
+	constructor(config) {
+		super(config);
+		this.instance = (0, dayjs.default)(config);
+		return new Proxy(this, { get: (target, prop, receiver) => {
+			if (prop in target) return Reflect.get(target, prop, receiver);
+			const value = Reflect.get(this.instance, prop, receiver);
+			if (typeof value === "function") return (...args) => {
+				const result = value.apply(this.instance, args);
+				return dayjs.default.isDayjs(result) ? new DateTime(result) : result;
+			};
+			return value;
+		} });
+	}
+	/**
+	* Start time of a specific unit.
+	* 
+	* @returns 
+	*/
+	start(unit = "days") {
+		return this.startOf(unit);
+	}
+	/**
+	* End time of a specific unit.
+	* 
+	* @returns 
+	*/
+	end(unit = "days") {
+		return this.endOf(unit);
+	}
+	/**
+	* Get the first day of the month of the given date
+	* 
+	* @returns 
+	*/
+	firstDayOfMonth() {
+		return new DateTime(new Date(Date.UTC(this.year(), this.month(), 1)));
+	}
+	carbonFormat(template) {
+		return template ? this.format(phpToDayjsTokens(template)) : this.format();
+	}
+	/**
+	* Get the last day of the month of the given date
+	* 
+	* @returns 
+	*/
+	lastDayOfMonth() {
+		return new DateTime(new Date(Date.UTC(this.year(), this.month() + 1, 0)));
+	}
+	/**
+	* Get a random time between the specified hour and minute.
+	* 
+	* @param startHour 
+	* @param startMinute 
+	* @param endHour 
+	* @param endMinute 
+	* @returns 
+	*/
+	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 new DateTime(date);
+	}
+	/**
+	* Create a date for a given timestamp.
+	*
+	* @param timestamp - Unix timestamp
+	* 
+	* @return {Date} object
+	*/
+	static fromTimestamp(timestamp) {
+		return /* @__PURE__ */ new Date(timestamp * 1e3);
+	}
+	/**
+	* Get current time instance.
+	*
+	* @returns Current time
+	*/
+	static now() {
+		return new DateTime();
+	}
+	/**
+	* Parse the time
+	* 
+	* @param date 
+	* @returns 
+	*/
+	static parse(date) {
+		return new DateTime(date);
 	}
-	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];
-		}
+	/**
+	* Get the formatted date according to the string of tokens passed in.
+	* 
+	* To escape characters, wrap them in square brackets (e.g. [MM]).
+	*
+	* @param time - current time
+	* @param template - time format
+	*/
+	static format(time, template) {
+		return new DateTime(time).format(template);
+	}
+	/**
+	* Get the difference in days from today.
+	*
+	* @param time 
+	* @param startHour 
+	* @param startMinute 
+	* @param endHour 
+	* @param endMinute 
+	* @returns 
+	*/
+	static randomTime(time, startHour, startMinute, endHour, endMinute) {
+		return new DateTime(time).randomTime(startHour, startMinute, endHour, endMinute);
+	}
+	/**
+	* Get the first day of the month of the given date
+	* 
+	* @param time 
+	* 
+	* @returns 
+	*/
+	static firstDayOfMonth(time) {
+		return new DateTime(time).firstDayOfMonth();
+	}
+	/**
+	* Get the last day of the month of the given date
+	* 
+	* @param time 
+	* 
+	* @returns 
+	*/
+	static lastDayOfMonth(time) {
+		return new DateTime(time).lastDayOfMonth();
 	}
-};
-/**
-* 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 = (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(key), value]));
 };
 
 //#endregion
@@ -5048,164 +6004,6 @@ function matchCase(value, comparison) {
 	return value;
 }
 
-//#endregion
-//#region src/Helpers/Time.ts
-dayjs.default.extend(dayjs_plugin_utc.default);
-dayjs.default.extend(dayjs_plugin_timezone.default);
-dayjs.default.extend(dayjs_plugin_dayOfYear.default);
-dayjs.default.extend(dayjs_plugin_isBetween.default);
-dayjs.default.extend(dayjs_plugin_isLeapYear.default);
-dayjs.default.extend(dayjs_plugin_relativeTime.default);
-dayjs.default.extend(dayjs_plugin_advancedFormat.default);
-dayjs.default.extend(dayjs_plugin_customParseFormat.default);
-const phpToDayjsTokens = (format$1) => format$1.replace(/Y/g, "YYYY").replace(/m/g, "MM").replace(/d/g, "DD").replace(/H/g, "HH").replace(/i/g, "mm").replace(/s/g, "ss");
-function format(date, fmt) {
-	return (0, dayjs.default)(date).format(phpToDayjsTokens(fmt));
-}
-const TimeClass = class {};
-var Time = class Time extends TimeClass {
-	instance;
-	constructor(config) {
-		super(config);
-		this.instance = (0, dayjs.default)(config);
-		return new Proxy(this, { get: (target, prop, receiver) => {
-			if (prop in target) return Reflect.get(target, prop, receiver);
-			const value = Reflect.get(this.instance, prop, receiver);
-			if (typeof value === "function") return (...args) => {
-				const result = value.apply(this.instance, args);
-				return dayjs.default.isDayjs(result) ? new Time(result) : result;
-			};
-			return value;
-		} });
-	}
-	/**
-	* Start time of a specific unit.
-	* 
-	* @returns 
-	*/
-	start(unit = "days") {
-		return this.startOf(unit);
-	}
-	/**
-	* End time of a specific unit.
-	* 
-	* @returns 
-	*/
-	end(unit = "days") {
-		return this.endOf(unit);
-	}
-	/**
-	* Get the first day of the month of the given date
-	* 
-	* @returns 
-	*/
-	firstDayOfMonth() {
-		return new Time(new Date(Date.UTC(this.year(), this.month(), 1)));
-	}
-	carbonFormat(template) {
-		return template ? this.format(phpToDayjsTokens(template)) : this.format();
-	}
-	/**
-	* Get the last day of the month of the given date
-	* 
-	* @returns 
-	*/
-	lastDayOfMonth() {
-		return new Time(new Date(Date.UTC(this.year(), this.month() + 1, 0)));
-	}
-	/**
-	* Get a random time between the specified hour and minute.
-	* 
-	* @param startHour 
-	* @param startMinute 
-	* @param endHour 
-	* @param endMinute 
-	* @returns 
-	*/
-	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 new Time(date);
-	}
-	/**
-	* Create a date for a given timestamp.
-	*
-	* @param timestamp - Unix timestamp
-	* 
-	* @return {Date} object
-	*/
-	static fromTimestamp(timestamp) {
-		return /* @__PURE__ */ new Date(timestamp * 1e3);
-	}
-	/**
-	* Get current time instance.
-	*
-	* @returns Current time
-	*/
-	static now() {
-		return new Time();
-	}
-	/**
-	* Parse the time
-	* 
-	* @param date 
-	* @returns 
-	*/
-	static parse(date) {
-		return new Time(date);
-	}
-	/**
-	* Get the formatted date according to the string of tokens passed in.
-	* 
-	* To escape characters, wrap them in square brackets (e.g. [MM]).
-	*
-	* @param time - current time
-	* @param template - time format
-	*/
-	static format(time, template) {
-		return new Time(time).format(template);
-	}
-	/**
-	* Get the difference in days from today.
-	*
-	* @param time 
-	* @param startHour 
-	* @param startMinute 
-	* @param endHour 
-	* @param endMinute 
-	* @returns 
-	*/
-	static randomTime(time, startHour, startMinute, endHour, endMinute) {
-		return new Time(time).randomTime(startHour, startMinute, endHour, endMinute);
-	}
-	/**
-	* Get the first day of the month of the given date
-	* 
-	* @param time 
-	* 
-	* @returns 
-	*/
-	static firstDayOfMonth(time) {
-		return new Time(time).firstDayOfMonth();
-	}
-	/**
-	* Get the last day of the month of the given date
-	* 
-	* @param time 
-	* 
-	* @returns 
-	*/
-	static lastDayOfMonth(time) {
-		return new Time(time).lastDayOfMonth();
-	}
-};
-
 //#endregion
 //#region src/GlobalBootstrap.ts
 /**
@@ -5232,12 +6030,12 @@ var Time = class Time extends TimeClass {
 */
 function loadHelpers(target = globalThis) {
 	const globalHelpers = {
-		Arr: Arr_exports,
+		Arr,
 		Crypto: Crypto_exports,
 		Number: Number_exports,
-		Obj: Obj_exports,
+		Obj,
 		Str,
-		Time,
+		DateTime,
 		DumpDie: DumpDie_exports,
 		apa: Str.apa,
 		title: Str.title,
@@ -5251,24 +6049,26 @@ function loadHelpers(target = globalThis) {
 		plural: Str.plural,
 		singular: Str.singular,
 		capitalize: Str.capitalize,
-		collapse,
-		alternate,
-		combine,
-		forget,
-		first,
-		last,
-		isEmpty,
-		isNotEmpty,
-		prepend,
-		range,
-		flatten,
+		collapse: Arr.collapse,
+		forget: Arr.forget,
+		first: Arr.first,
+		last: Arr.last,
+		prepend: Arr.prepend,
+		flatten: Arr.flatten,
 		dot,
+		undot,
 		extractProperties,
 		getValue,
 		modObj,
 		safeDot,
 		setNested,
+		toCssClasses,
 		slugifyKeys,
+		toCssStyles,
+		data_get,
+		data_set,
+		data_fill,
+		data_forget,
 		uuid,
 		random,
 		randomSecure,
@@ -5283,13 +6083,13 @@ function loadHelpers(target = globalThis) {
 		checksum,
 		verifyChecksum,
 		caesarCipher,
-		now: Time.now,
-		format: Time.format,
-		fromTimestamp: Time.fromTimestamp,
-		parse: Time.parse,
-		randomTime: Time.randomTime,
-		firstDayOfMonth: Time.firstDayOfMonth,
-		lastDayOfMonth: Time.lastDayOfMonth,
+		now: DateTime.now,
+		format: DateTime.format,
+		fromTimestamp: DateTime.fromTimestamp,
+		parse: DateTime.parse,
+		randomTime: DateTime.randomTime,
+		firstDayOfMonth: DateTime.firstDayOfMonth,
+		lastDayOfMonth: DateTime.lastDayOfMonth,
 		abbreviate,
 		humanize,
 		toBytes,
@@ -5350,6 +6150,13 @@ function cleanHelpers(target = globalThis) {
 		"safeDot",
 		"setNested",
 		"slugifyKeys",
+		"toCssClasses",
+		"undot",
+		"toCssStyles",
+		"data_get",
+		"data_set",
+		"data_fill",
+		"data_forget",
 		"Crypto",
 		"uuid",
 		"random",
@@ -5387,18 +6194,14 @@ function cleanHelpers(target = globalThis) {
 }
 
 //#endregion
-Object.defineProperty(exports, 'Arr', {
-  enumerable: true,
-  get: function () {
-    return Arr_exports;
-  }
-});
+exports.Arr = Arr;
 Object.defineProperty(exports, 'Crypto', {
   enumerable: true,
   get: function () {
     return Crypto_exports;
   }
 });
+exports.DateTime = DateTime;
 Object.defineProperty(exports, 'DumpDie', {
   enumerable: true,
   get: function () {
@@ -5406,6 +6209,7 @@ Object.defineProperty(exports, 'DumpDie', {
   }
 });
 exports.HtmlString = HtmlString;
+exports.InvalidArgumentException = InvalidArgumentException;
 exports.Mode = Mode;
 Object.defineProperty(exports, 'Number', {
   enumerable: true,
@@ -5419,54 +6223,44 @@ Object.defineProperty(exports, 'Obj', {
     return Obj_exports;
   }
 });
+exports.RuntimeException = RuntimeException;
 exports.Str = Str;
 exports.Stringable = Stringable;
-exports.Time = Time;
 exports.abbreviate = abbreviate;
-exports.alternate = alternate;
 exports.base64Decode = base64Decode;
 exports.base64Encode = base64Encode;
 exports.caesarCipher = caesarCipher;
 exports.checksum = checksum;
-exports.chunk = chunk;
 exports.cleanHelpers = cleanHelpers;
-exports.collapse = collapse;
-exports.combine = combine;
+exports.data_fill = data_fill;
+exports.data_forget = data_forget;
+exports.data_get = data_get;
+exports.data_set = data_set;
 exports.dd = dd;
 exports.dot = dot;
 exports.dump = dump;
 exports.extractProperties = extractProperties;
-exports.find = find;
-exports.first = first;
-exports.flatten = flatten;
-exports.forget = forget;
 exports.format = format;
 exports.getValue = getValue;
 exports.hash = hash;
 exports.hmac = hmac;
 exports.humanize = humanize;
-exports.isEmpty = isEmpty;
-exports.isNotEmpty = isNotEmpty;
-exports.last = last;
 exports.loadHelpers = loadHelpers;
 exports.modObj = modObj;
-exports.pop = pop;
-exports.prepend = prepend;
 exports.random = random;
 exports.randomColor = randomColor;
 exports.randomPassword = randomPassword;
 exports.randomSecure = randomSecure;
-exports.range = range;
-exports.reverse = reverse;
 exports.safeDot = safeDot;
 exports.secureToken = secureToken;
 exports.setNested = setNested;
-exports.shift = shift;
 exports.slugifyKeys = slugifyKeys;
 exports.str = str;
-exports.take = take;
 exports.toBytes = toBytes;
+exports.toCssClasses = toCssClasses;
+exports.toCssStyles = toCssStyles;
 exports.toHumanTime = toHumanTime;
+exports.undot = undot;
 exports.uuid = uuid;
 exports.verifyChecksum = verifyChecksum;
 exports.xor = xor;