@h3ravel/support 0.15.6 → 0.16.0

package/dist/index.cjs

@@ -5,21 +5,30 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (all) => {
+var __export = (all, symbols) => {
 	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
 	return target;
 };
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
 	}
 	return to;
 };
@@ -29,7 +38,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let crypto = require("crypto");
+const require_RuntimeException = require('./RuntimeException-CmsL83ow.cjs');
+let __h3ravel_collect_js = require("@h3ravel/collect.js");
+let crypto$1 = require("crypto");
 let process = require("process");
 process = __toESM(process);
 let util = require("util");
@@ -52,27 +63,48 @@ 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);
+let node_net = require("node:net");
+let __h3ravel_shared = require("@h3ravel/shared");
+let node_fs_promises = require("node:fs/promises");
+let __h3ravel_contracts = require("@h3ravel/contracts");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
 
-//#region src/Exceptions/InvalidArgumentException.ts
+//#region src/Collection.ts
+var Collection = class extends __h3ravel_collect_js.Collection {
+	/**
+	* 
+	* @param collection 
+	*/
+	constructor(collection) {
+		super(collection);
+	}
+};
 /**
-* Custom error for invalid type coercion
+* 
+* @param collection 
+* @returns 
 */
-var InvalidArgumentException = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "InvalidArgumentException";
-	}
+const collect = (collection) => {
+	return new Collection(collection);
 };
 
 //#endregion
-//#region src/Exceptions/RuntimeException.ts
+//#region src/Exceptions/BadMethodCallException.ts
+/**
+* Exception thrown if an error with a method call occurs.
+*/
+var BadMethodCallException = class extends Error {};
+
+//#endregion
+//#region src/Exceptions/InvalidArgumentException.ts
 /**
 * Custom error for invalid type coercion
 */
-var RuntimeException = class extends Error {
+var InvalidArgumentException = class extends Error {
 	constructor(message) {
 		super(message);
-		this.name = "RuntimeException";
+		this.name = "InvalidArgumentException";
 	}
 };
 
@@ -100,7 +132,7 @@ var Crypto_exports = /* @__PURE__ */ __export({
 * @returns A random UUID string
 */
 const uuid = () => {
-	return (0, crypto.randomUUID)();
+	return (0, crypto$1.randomUUID)();
 };
 /**
 * Generate a random string of specified length.
@@ -121,7 +153,7 @@ const random = (length = 16, charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN
 * @returns A cryptographically secure random string
 */
 const randomSecure = (length = 32) => {
-	return (0, crypto.randomBytes)(Math.ceil(length / 2)).toString("hex").slice(0, length);
+	return (0, crypto$1.randomBytes)(Math.ceil(length / 2)).toString("hex").slice(0, length);
 };
 /**
 * Hash a string using the specified algorithm.
@@ -131,7 +163,7 @@ const randomSecure = (length = 32) => {
 * @returns Hexadecimal hash string
 */
 const hash = (data, algorithm = "sha256") => {
-	return (0, crypto.createHash)(algorithm).update(data).digest("hex");
+	return (0, crypto$1.createHash)(algorithm).update(data).digest("hex");
 };
 /**
 * Hash a string with salt using HMAC.
@@ -142,7 +174,7 @@ const hash = (data, algorithm = "sha256") => {
 * @returns Hexadecimal hash string
 */
 const hmac = (data, key, algorithm = "sha256") => {
-	return (0, crypto.createHmac)(algorithm, key).update(data).digest("hex");
+	return (0, crypto$1.createHmac)(algorithm, key).update(data).digest("hex");
 };
 /**
 * Encode data to base64.
@@ -210,7 +242,7 @@ const randomPassword = (length = 16, options = {}) => {
 * @returns A secure token string
 */
 const secureToken = (strength = 32) => {
-	return (0, crypto.randomBytes)(strength).toString("hex");
+	return (0, crypto$1.randomBytes)(strength).toString("hex");
 };
 /**
 * Create a checksum for data integrity verification.
@@ -465,7 +497,7 @@ const toHumanTime = (seconds = 0, worded = false) => {
 * with dot-separated keys.
 *
 * Example:
-* doter({
+* dot({
 *   user: { name: "John", address: { city: "NY" } },
 *   active: true
 * })
@@ -608,6 +640,9 @@ const slugifyKeys = (obj, only = [], separator = "_") => {
 * - Arrays: included if truthy
 * - Objects: keys included if value is truthy
 * - Strings: included as-is
+* 
+* @param input 
+* @returns 
 */
 function toCssClasses(input) {
 	if (!input) return "";
@@ -626,6 +661,9 @@ function toCssClasses(input) {
 *
 * Convert object input into CSS style string.
 * - Only includes truthy values (ignores null/undefined/false)
+* 
+* @param styles 
+* @returns 
 */
 function toCssStyles(styles) {
 	const parts = [];
@@ -642,6 +680,9 @@ function toCssStyles(styles) {
 *
 * Example:
 * undot({ 'a.b': 1, 'c.0': 2 }) -> { a: { b: 1 }, c: [2] }
+* 
+* @param obj 
+* @returns 
 */
 function undot(obj) {
 	const result = {};
@@ -666,6 +707,11 @@ function undot(obj) {
 * data_get
 *
 * Get a value from an object using dot notation.
+* 
+* @param obj 
+* @param path 
+* @param defaultValue 
+* @returns 
 */
 function data_get(obj, path, defaultValue) {
 	if (!obj) return defaultValue;
@@ -681,6 +727,10 @@ function data_get(obj, path, defaultValue) {
 * data_set
 *
 * Set a value in an object using dot notation. Mutates the object.
+* 
+* @param obj 
+* @param path 
+* @param value 
 */
 function data_set(obj, path, value) {
 	const parts = Array.isArray(path) ? path : path.split(".");
@@ -698,6 +748,10 @@ function data_set(obj, path, value) {
 * data_fill
 *
 * Like data_set, but only sets the value if the key does NOT exist.
+* 
+* @param obj 
+* @param path 
+* @param value 
 */
 function data_fill(obj, path, value) {
 	if (data_get(obj, path) === void 0) data_set(obj, path, value);
@@ -706,6 +760,9 @@ function data_fill(obj, path, value) {
 * data_forget
 *
 * Remove a key from an object using dot notation.
+* 
+* @param obj 
+* @param path 
 */
 function data_forget(obj, path) {
 	const parts = Array.isArray(path) ? path : path.split(".");
@@ -723,14 +780,18 @@ function data_forget(obj, path) {
 * Checks if a value is a plain object (not array, function, etc.)
 * 
 * @param value 
+* @param allowArray
 * @returns 
 */
-function isPlainObject(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+function isPlainObject(value, allowArray) {
+	return value !== null && typeof value === "object" && (Array.isArray(value) === false || allowArray === true) && Object.prototype.toString.call(value) === "[object Object]";
 }
 var Obj = class Obj {
 	/**
 	* Check if the value is a non-null object (associative/accessible).
+	* 
+	* @param value 
+	* @returns 
 	*/
 	static accessible(value) {
 		return value !== null && typeof value === "object";
@@ -739,6 +800,11 @@ var Obj = class Obj {
 	* Add a key-value pair to an object only if the key does not already exist.
 	*
 	* Returns a new object (does not mutate original).
+	* 
+	* @param obj 
+	* @param key 
+	* @param value 
+	* @returns 
 	*/
 	static add(obj, key, value) {
 		if (!(key in obj)) return {
@@ -770,12 +836,43 @@ var Obj = class Obj {
 	}
 	/**
 	* Split object into [keys, values]
+	* 
+	* @param obj 
+	* @returns 
 	*/
 	static divide(obj) {
 		return [Object.keys(obj), Object.values(obj)];
 	}
 	/**
+	* Flattens a nested object into a single-level object
+	* with dot-separated keys.
+	*
+	* Example:
+	* dot({
+	*   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
+	*/
+	static dot(obj) {
+		return dot(obj);
+	}
+	/**
 	* Check if a key exists in the object.
+	* 
+	* @param obj 
+	* @param key 
+	* @returns 
 	*/
 	static exists(obj, key) {
 		return Object.prototype.hasOwnProperty.call(obj, key);
@@ -785,6 +882,11 @@ var Obj = class Obj {
 	*
 	* Example:
 	* Obj.get({a:{b:1}}, 'a.b') -> 1
+	* 
+	* @param obj 
+	* @param path 
+	* @param defaultValue 
+	* @returns 
 	*/
 	static get(obj, path, defaultValue) {
 		if (!Obj.accessible(obj)) return defaultValue;
@@ -798,6 +900,10 @@ var Obj = class Obj {
 	}
 	/**
 	* Check if the object has a given key or keys (dot notation supported).
+	* 
+	* @param obj 
+	* @param keys 
+	* @returns 
 	*/
 	static has(obj, keys) {
 		if (!Obj.accessible(obj)) return false;
@@ -813,13 +919,30 @@ var Obj = class Obj {
 	}
 	/**
 	* Check if an object is associative (has at least one non-numeric key).
+	* 
+	* @param obj 
+	* @returns 
 	*/
 	static isAssoc(obj) {
 		if (!Obj.accessible(obj)) return false;
 		return Object.keys(obj).some((k) => isNaN(Number(k)));
 	}
 	/**
+	* Checks if a value is a plain object (not array, function, etc.)
+	* 
+	* @param value 
+	* @param allowArray 
+	* @returns 
+	*/
+	static isPlainObject(value, allowArray) {
+		return isPlainObject(value, allowArray);
+	}
+	/**
 	* Add a prefix to all keys of the object.
+	* 
+	* @param obj 
+	* @param prefix 
+	* @returns 
 	*/
 	static prependKeysWith(obj, prefix) {
 		if (!Obj.accessible(obj)) return {};
@@ -831,6 +954,9 @@ var Obj = class Obj {
 	* Convert an object into a URL query string.
 	*
 	* Nested objects/arrays are flattened using bracket notation.
+	* 
+	* @param obj 
+	* @returns 
 	*/
 	static query(obj) {
 		const encode = encodeURIComponent;
@@ -843,6 +969,20 @@ var Obj = class Obj {
 		Object.entries(obj).forEach(([k, v]) => build(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] }
+	* 
+	* @param obj 
+	* @returns 
+	*/
+	undot(obj) {
+		return undot(obj);
+	}
 };
 
 //#endregion
@@ -1379,6 +1519,7 @@ var Arr = class Arr {
 	*/
 	static whereNotNull(array, key) {
 		if (!Array.isArray(array)) return [];
+		if (!key) return array.filter((item) => item !== null && item !== void 0);
 		return array.filter((item) => item[key] !== null && item[key] !== void 0);
 	}
 	/**
@@ -1517,6 +1658,15 @@ var Arr = class Arr {
 		if (size <= 0 || !Number.isFinite(size)) return [];
 		return Array.from({ length: size }, (_, i) => startAt + i);
 	}
+	/**
+	* Filters an array and returns only unique values
+	* 
+	* @param items 
+	* @returns 
+	*/
+	static unique(items) {
+		return items.filter((value, index, self) => self.indexOf(value) === index);
+	}
 };
 
 //#endregion
@@ -1536,9 +1686,9 @@ function format(date, fmt) {
 const TimeClass = class {};
 var DateTime = class DateTime extends TimeClass {
 	instance;
-	constructor(config) {
+	constructor(config, format$1, locale, strict) {
 		super(config);
-		this.instance = (0, dayjs.default)(config);
+		this.instance = (0, dayjs.default)(config, format$1, locale, strict);
 		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);
@@ -1906,18 +2056,6 @@ var Str = class Str {
 		return result;
 	}
 	/**
-	* Determine if a given string doesn't contain a given substring.
-	*
-	* @param { string } haystack
-	* @param { string | string[] } needles
-	* @param { boolean } ignoreCase
-	*
-	* @return { boolean }
-	*/
-	static doesntContain(haystack, needles, ignoreCase = false) {
-		return !this.contains(haystack, needles, ignoreCase);
-	}
-	/**
 	* Convert the case of a string.
 	*
 	* @param { string } string
@@ -1955,6 +2093,46 @@ var Str = class Str {
 		return string;
 	}
 	/**
+	* Detect content type
+	* 
+	* @param content 
+	* @returns 
+	*/
+	static detectContentType(content) {
+		if (typeof content !== "string") return "json";
+		const trimmed = content.trim();
+		/**
+		* JSON check 
+		*/
+		if (/^[[{]/.test(trimmed)) try {
+			JSON.parse(trimmed);
+			return "json";
+		} catch {}
+		/**
+		* XML check 
+		*/
+		if (/^<\?xml/i.test(trimmed) || /^<[A-Za-z]+[^>]*>/.test(trimmed)) {
+			if (!/^<!DOCTYPE html>/i.test(trimmed) && !/<html[\s>]/i.test(trimmed)) return "xml";
+		}
+		/**
+		* HTML check 
+		*/
+		if (/<(html|head|body|div|span|p|!DOCTYPE)/i.test(trimmed)) return "html";
+		return "text";
+	}
+	/**
+	* Determine if a given string doesn't contain a given substring.
+	*
+	* @param { string } haystack
+	* @param { string | string[] } needles
+	* @param { boolean } ignoreCase
+	*
+	* @return { boolean }
+	*/
+	static doesntContain(haystack, needles, ignoreCase = false) {
+		return !this.contains(haystack, needles, ignoreCase);
+	}
+	/**
 	* Replace consecutive instances of a given character with a single character in the given string.
 	*
 	* @param { string } string
@@ -2099,7 +2277,7 @@ var Str = class Str {
 		for (let pattern$1 of patterns) {
 			if (pattern$1 === value) return true;
 			if (ignoreCase && pattern$1.toLowerCase() === value.toLowerCase()) return true;
-			pattern$1 = pattern$1.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&").replace(/\\\*/g, ".*");
+			pattern$1 = pattern$1.replace(/[\\^$*+?.()|[\]{}]/g, "\\$&").replace(/\\\*/g, ".*");
 			if (new RegExp("^" + pattern$1 + "$", ignoreCase ? "iu" : "u").test(value)) return true;
 		}
 		return false;
@@ -2227,6 +2405,19 @@ var Str = class Str {
 		return value.toLowerCase();
 	}
 	/**
+	* Parse a Class[@]method style callback into class and method.
+	*
+	* @param callback
+	* @param defaultValue
+	*/
+	static parseCallback(callback, defaultValue) {
+		if (this.contains(callback, "anonymous")) {
+			if (this.substrCount(callback, "@") > 1) return [this.beforeLast(callback, "@"), this.afterLast(callback, "@")];
+			return [callback, defaultValue];
+		}
+		return this.contains(callback, "@") ? callback.split("@", 2) : [callback, defaultValue];
+	}
+	/**
 	* Get substring by start/stop indexes.
 	* 
 	* @param string 
@@ -3676,10 +3867,9 @@ var Str = class Str {
 	static trim(value, characters = null) {
 		if (characters === null) return value.trim();
 		if (characters === "") return value;
-		if (characters === " ") return value.replaceAll(" ", "");
-		characters = characters.split("").join("|");
-		const regex = new RegExp(`${characters}+`, "g");
-		return value.replace(regex, "") ?? value;
+		for (const char of characters) while (value.startsWith(char)) value = value.substring(char.length);
+		for (const char of characters) while (value.endsWith(char)) value = value.substring(0, value.length - char.length);
+		return value;
 	}
 	/**
 	* Remove all whitespace from the beginning of a string.
@@ -3692,8 +3882,7 @@ var Str = class Str {
 	static ltrim(value, characters = null) {
 		if (characters === null) return value.trimStart();
 		if (characters === "") return value;
-		if (characters === " ") return this.replaceStart(" ", "", value);
-		characters.split("").forEach((character) => value = this.replaceStart(character, "", value));
+		for (const char of characters) while (value.startsWith(char)) value = value.substring(char.length);
 		return value;
 	}
 	/**
@@ -3707,8 +3896,7 @@ var Str = class Str {
 	static rtrim(value, characters = null) {
 		if (characters === null) return value.trimEnd();
 		if (characters === "") return value;
-		if (characters === " ") return this.replaceEnd(" ", "", value);
-		characters.split("").forEach((character) => value = this.replaceEnd(character, "", value));
+		for (const char of characters) while (value.endsWith(char)) value = value.substring(0, value.length - char.length);
 		return value;
 	}
 	/**
@@ -4059,6 +4247,23 @@ var Str = class Str {
 		return result;
 	}
 	/**
+	* Validate an IP address
+	* 
+	* @param host 
+	* @param type 
+	* 
+	* @return { boolean }
+	*/
+	static validateIp(host, type) {
+		const code = {
+			ipv4: 4,
+			ipv6: 6
+		};
+		const result = (0, node_net.isIP)(host);
+		if (type) return result === code[type];
+		return result > 0;
+	}
+	/**
 	* Generate a time-ordered UUID (version 4).
 	*
 	* @return { string }
@@ -4431,6 +4636,16 @@ var Stringable = class Stringable {
 		return Str.containsAll(this.#value, needles, ignoreCase);
 	}
 	/**
+	* Convert the case of a string.
+	*
+	* @param { Mode | number } mode
+	*
+	* @return { Stringable }
+	*/
+	convertCase(mode = Mode.MB_CASE_FOLD) {
+		return new Stringable(Str.convertCase(this.#value, mode));
+	}
+	/**
 	* Determine if a given string doesn't contain a given substring.
 	*
 	* @param  { string | string[] } needles
@@ -4442,14 +4657,13 @@ var Stringable = class Stringable {
 		return !this.contains(needles, ignoreCase);
 	}
 	/**
-	* Convert the case of a string.
-	*
-	* @param { Mode | number } mode
-	*
-	* @return { Stringable }
+	* Detect content type
+	* 
+	* @param content 
+	* @returns 
 	*/
-	convertCase(mode = Mode.MB_CASE_FOLD) {
-		return new Stringable(Str.convertCase(this.#value, mode));
+	static detectContentType(content) {
+		return Str.detectContentType(content);
 	}
 	/**
 	* Replace consecutive instances of a given character with a single character in the given string.
@@ -5262,6 +5476,16 @@ var Stringable = class Stringable {
 		return this;
 	}
 	/**
+	* Validate an IP address
+	* 
+	* @param host 
+	* @param type 
+	* @returns 
+	*/
+	validateIp(type = "ipv4") {
+		return Str.validateIp(this.#value, type);
+	}
+	/**
 	* Execute the given callback if the string contains a given substring.
 	*
 	* @param { string | string[] } needles
@@ -6076,6 +6300,7 @@ function loadHelpers(target = globalThis) {
 		last: Arr.last,
 		prepend: Arr.prepend,
 		flatten: Arr.flatten,
+		unique: Arr.unique,
 		dot,
 		undot,
 		extractProperties,
@@ -6090,6 +6315,7 @@ function loadHelpers(target = globalThis) {
 		data_set,
 		data_fill,
 		data_forget,
+		isPlainObject,
 		uuid,
 		random,
 		randomSecure,
@@ -6214,8 +6440,605 @@ function cleanHelpers(target = globalThis) {
 	});
 }
 
+//#endregion
+//#region src/HigherOrderTapProxy.ts
+var HigherOrderTapProxy = class {
+	/**
+	* The target being tapped.
+	*/
+	target;
+	/**
+	* Create a new tap proxy instance.
+	*/
+	constructor(target) {
+		this.target = target;
+	}
+	/**
+	* Dynamically pass method calls to the target.
+	*
+	* @param  method
+	* @param  parameters
+	*/
+	__call(method, parameters) {
+		this.target[method](...parameters);
+		return this.target;
+	}
+};
+
+//#endregion
+//#region src/Helpers.ts
+/**
+* Call the given Closure with the given value then return the value.
+*
+* @param  value
+* @param  callback
+*/
+const tap = (value, callback) => {
+	if (!callback) return new HigherOrderTapProxy(value);
+	callback(value);
+	return value;
+};
+/**
+* Optional Proxy factory
+* 
+* @param value 
+* @returns 
+*/
+const createOptionalProxy = (value) => {
+	return new Proxy({}, { get(_, prop) {
+		if (prop === "value") return () => value ?? void 0;
+		if (value == null) return createOptionalProxy(void 0);
+		const result = value[prop];
+		if (typeof result === "function") return (...args) => {
+			try {
+				return createOptionalProxy(result.apply(value, args));
+			} catch {
+				return createOptionalProxy(void 0);
+			}
+		};
+		return createOptionalProxy(result);
+	} });
+};
+/**
+* Provide access to optional objects.
+*
+* @param  value
+* @param  callback
+*/
+const optional = (value, callback) => {
+	if (callback) return value != null ? callback(value) : void 0;
+	return createOptionalProxy(value);
+};
+/**
+* Checks if the givevn value is a class
+* 
+* @param C  
+*/
+const isClass = (C) => {
+	return typeof C === "function" && C.prototype !== void 0 && Object.toString.call(C).substring(0, 5) === "class";
+};
+/**
+* Checks if the givevn value is an abstract class
+* 
+* @param C  
+*/
+const isAbstract = (C) => {
+	return isClass(C) && C.name.startsWith("I");
+};
+/**
+* Checks if the givevn value is callable
+* 
+* @param C  
+*/
+const isCallable = (C) => {
+	return typeof C === "function" && !isClass(C);
+};
+
+//#endregion
+//#region src/Macroable.ts
+const Macroable = () => (0, __h3ravel_shared.trait)((Base) => {
+	return class Macroable$1 extends Base {
+		static macros = {};
+		constructor(...args) {
+			super(...args);
+			return new Proxy(this, { get(target, prop, receiver) {
+				if (typeof prop === "string") {
+					const ctor = target.constructor;
+					if (ctor.hasMacro(prop)) return (...args$1) => ctor.macros[prop].apply(receiver, args$1);
+				}
+				return Reflect.get(target, prop, receiver);
+			} });
+		}
+		static macro(name, macro) {
+			this.macros[name] = macro;
+		}
+		static hasMacro(name) {
+			return Object.prototype.hasOwnProperty.call(this.macros, name);
+		}
+		static flushMacros() {
+			this.macros = {};
+		}
+		static mixin(mixin, replace = true) {
+			const proto = Object.getPrototypeOf(mixin);
+			for (const key of Object.getOwnPropertyNames(proto)) {
+				if (key === "constructor") continue;
+				const desc = Object.getOwnPropertyDescriptor(proto, key);
+				if (!desc || typeof desc.value !== "function") continue;
+				if (replace || !this.hasMacro(key)) this.macro(key, desc.value.bind(mixin));
+			}
+		}
+		static createProxy() {
+			return new Proxy(this, { get(target, prop, receiver) {
+				if (typeof prop === "string" && target.hasMacro(prop)) return (...args) => target.macros[prop](...args);
+				return Reflect.get(target, prop, receiver);
+			} });
+		}
+		/**
+		* Dynamically handle calls to the class.
+		*
+		* @param  method
+		* @param  parameters
+		*
+		* @throws {BadMethodCallException}
+		*/
+		static macroCallStatic(method, parameters = []) {
+			if (!Macroable$1.hasMacro(method)) throw new BadMethodCallException(`Method ${Macroable$1.constructor.name}.${method} does not exist.`);
+			let macro = Macroable$1.macros[method];
+			if (typeof macro === "function") macro = macro.bind(this);
+			if (typeof macro === "function") macro = macro.bind(this);
+			return macro(...parameters);
+		}
+		/**
+		* Dynamically handle calls to the class.
+		*
+		* @param  method
+		* @param  parameters
+		*
+		* @throws {BadMethodCallException}
+		*/
+		macroCall(method, parameters = []) {
+			if (!Macroable$1.hasMacro(method)) throw new BadMethodCallException(`Method ${Macroable$1.constructor.name}.${method} does not exist.`);
+			let macro = Macroable$1.macros[method];
+			if (typeof macro === "function") macro = macro.bind(this);
+			return macro(...parameters);
+		}
+	};
+});
+const MacroableClass = Macroable().factory(class {});
+
+//#endregion
+//#region src/Providers/ServiceProvider.ts
+var ServiceProvider = class extends __h3ravel_contracts.IServiceProvider {
+	/**
+	* The current app instance
+	*/
+	app;
+	/**
+	* Unique Identifier for the service providers
+	*/
+	static uid;
+	/**
+	* Sort order
+	*/
+	static order;
+	/**
+	* Sort priority
+	*/
+	static priority = 0;
+	/**
+	* Indicate that this service provider only runs in console
+	*/
+	static console = false;
+	/**
+	* Indicate that this service provider only runs in console
+	*/
+	console = false;
+	/**
+	* Indicate that this service provider only runs in console
+	*/
+	runsInConsole = false;
+	/**
+	* List of registered console commands
+	*/
+	registeredCommands = [];
+	/**
+	* All of the registered booted callbacks.
+	*/
+	bootedCallbacks = [];
+	constructor(app) {
+		super();
+		this.app = app;
+	}
+	/**
+	* Register a booted callback to be run after the "boot" method is called.
+	*
+	* @param callback
+	*/
+	booted(callback) {
+		this.bootedCallbacks.push(callback);
+	}
+	/**
+	* Call the registered booted callbacks.
+	*/
+	async callBootedCallbacks() {
+		let index = 0;
+		while (index < this.bootedCallbacks.length) {
+			await this.app.call(this.bootedCallbacks[index]);
+			index++;
+		}
+	}
+	/**
+	* Register the listed service providers.
+	* 
+	* @param commands An array of console commands to register.
+	* 
+	* @deprecated since version 1.16.0. Will be removed in future versions, use `registerCommands` instead
+	*/
+	commands(commands) {
+		this.registerCommands(commands);
+	}
+	/**
+	* Register the listed service providers.
+	* 
+	* @param commands An array of console commands to register.
+	*/
+	registerCommands(commands) {
+		this.registeredCommands = commands;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/h3@2.0.1-rc.5/node_modules/h3/dist/h3.mjs
+const kEventNS = "h3.internal.event.";
+const kEventRes = /* @__PURE__ */ Symbol.for(`${kEventNS}res`);
+const kEventResHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.headers`);
+const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
+function sanitizeStatusMessage(statusMessage = "") {
+	return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
+}
+function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
+	if (!statusCode) return defaultStatusCode;
+	if (typeof statusCode === "string") statusCode = +statusCode;
+	if (statusCode < 100 || statusCode > 599) return defaultStatusCode;
+	return statusCode;
+}
+var HTTPError = class HTTPError$1 extends Error {
+	get name() {
+		return "HTTPError";
+	}
+	status;
+	statusText;
+	headers;
+	cause;
+	data;
+	body;
+	unhandled;
+	static isError(input) {
+		return input instanceof Error && input?.name === "HTTPError";
+	}
+	static status(status, statusText, details) {
+		return new HTTPError$1({
+			...details,
+			statusText,
+			status
+		});
+	}
+	constructor(arg1, arg2) {
+		let messageInput;
+		let details;
+		if (typeof arg1 === "string") {
+			messageInput = arg1;
+			details = arg2;
+		} else details = arg1;
+		const status = sanitizeStatusCode(details?.status || (details?.cause)?.status || details?.status || details?.statusCode, 500);
+		const statusText = sanitizeStatusMessage(details?.statusText || (details?.cause)?.statusText || details?.statusText || details?.statusMessage);
+		const message = messageInput || details?.message || (details?.cause)?.message || details?.statusText || details?.statusMessage || [
+			"HTTPError",
+			status,
+			statusText
+		].filter(Boolean).join(" ");
+		super(message, { cause: details });
+		this.cause = details;
+		Error.captureStackTrace?.(this, this.constructor);
+		this.status = status;
+		this.statusText = statusText || void 0;
+		const rawHeaders = details?.headers || (details?.cause)?.headers;
+		this.headers = rawHeaders ? new Headers(rawHeaders) : void 0;
+		this.unhandled = details?.unhandled ?? (details?.cause)?.unhandled ?? void 0;
+		this.data = details?.data;
+		this.body = details?.body;
+	}
+	get statusCode() {
+		return this.status;
+	}
+	get statusMessage() {
+		return this.statusText;
+	}
+	toJSON() {
+		const unhandled = this.unhandled;
+		return {
+			status: this.status,
+			statusText: this.statusText,
+			unhandled,
+			message: unhandled ? "HTTPError" : this.message,
+			data: unhandled ? void 0 : this.data,
+			...unhandled ? void 0 : this.body
+		};
+	}
+};
+var HTTPResponse = class {
+	#headers;
+	#init;
+	body;
+	constructor(body, init) {
+		this.body = body;
+		this.#init = init;
+	}
+	get status() {
+		return this.#init?.status || 200;
+	}
+	get statusText() {
+		return this.#init?.statusText || "OK";
+	}
+	get headers() {
+		return this.#headers ||= new Headers(this.#init?.headers);
+	}
+};
+function withLeadingSlash(path) {
+	if (!path || path === "/") return "/";
+	return path[0] === "/" ? path : `/${path}`;
+}
+function withoutTrailingSlash(path) {
+	if (!path || path === "/") return "/";
+	return path[path.length - 1] === "/" ? path.slice(0, -1) : path;
+}
+const COMMON_MIME_TYPES = {
+	".html": "text/html",
+	".htm": "text/html",
+	".css": "text/css",
+	".js": "text/javascript",
+	".json": "application/json",
+	".txt": "text/plain",
+	".xml": "application/xml",
+	".gif": "image/gif",
+	".ico": "image/vnd.microsoft.icon",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".png": "image/png",
+	".svg": "image/svg+xml",
+	".webp": "image/webp",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".zip": "application/zip",
+	".pdf": "application/pdf"
+};
+function getExtension(path) {
+	const filename = path.split("/").pop();
+	if (!filename) return;
+	const separatorIndex = filename.lastIndexOf(".");
+	if (separatorIndex !== -1) return filename.slice(separatorIndex);
+}
+function getType(ext) {
+	return ext ? COMMON_MIME_TYPES[ext] : void 0;
+}
+async function serveStatic(event, options) {
+	if (options.headers) {
+		const entries = Array.isArray(options.headers) ? options.headers : typeof options.headers.entries === "function" ? options.headers.entries() : Object.entries(options.headers);
+		for (const [key, value] of entries) event.res.headers.set(key, value);
+	}
+	if (event.req.method !== "GET" && event.req.method !== "HEAD") {
+		if (options.fallthrough) return;
+		event.res.headers.set("allow", "GET, HEAD");
+		throw new HTTPError({ status: 405 });
+	}
+	const originalId = decodeURI(withLeadingSlash(withoutTrailingSlash(event.url.pathname)));
+	const acceptEncodings = parseAcceptEncoding(event.req.headers.get("accept-encoding") || "", options.encodings);
+	if (acceptEncodings.length > 1) event.res.headers.set("vary", "accept-encoding");
+	let id = originalId;
+	let meta;
+	const _ids = idSearchPaths(originalId, acceptEncodings, options.indexNames || ["/index.html"]);
+	for (const _id of _ids) {
+		const _meta = await options.getMeta(_id);
+		if (_meta) {
+			meta = _meta;
+			id = _id;
+			break;
+		}
+	}
+	if (!meta) {
+		if (options.fallthrough) return;
+		throw new HTTPError({ statusCode: 404 });
+	}
+	if (meta.mtime) {
+		const mtimeDate = new Date(meta.mtime);
+		const ifModifiedSinceH = event.req.headers.get("if-modified-since");
+		if (ifModifiedSinceH && new Date(ifModifiedSinceH) >= mtimeDate) return new HTTPResponse(null, {
+			status: 304,
+			statusText: "Not Modified"
+		});
+		if (!event.res.headers.get("last-modified")) event.res.headers.set("last-modified", mtimeDate.toUTCString());
+	}
+	if (meta.etag && !event.res.headers.has("etag")) event.res.headers.set("etag", meta.etag);
+	if (meta.etag && event.req.headers.get("if-none-match") === meta.etag) return new HTTPResponse(null, {
+		status: 304,
+		statusText: "Not Modified"
+	});
+	if (!event.res.headers.get("content-type")) if (meta.type) event.res.headers.set("content-type", meta.type);
+	else {
+		const ext = getExtension(id);
+		const type = ext ? options.getType?.(ext) ?? getType(ext) : void 0;
+		if (type) event.res.headers.set("content-type", type);
+	}
+	if (meta.encoding && !event.res.headers.get("content-encoding")) event.res.headers.set("content-encoding", meta.encoding);
+	if (meta.size !== void 0 && meta.size > 0 && !event.req.headers.get("content-length")) event.res.headers.set("content-length", meta.size + "");
+	if (event.req.method === "HEAD") return new HTTPResponse(null, { status: 200 });
+	return new HTTPResponse(await options.getContents(id) || null, { status: 200 });
+}
+function parseAcceptEncoding(header, encodingMap) {
+	if (!encodingMap || !header) return [];
+	return String(header || "").split(",").map((e) => encodingMap[e.trim()]).filter(Boolean);
+}
+function idSearchPaths(id, encodings, indexNames) {
+	const ids = [];
+	for (const suffix of ["", ...indexNames]) for (const encoding of [...encodings, ""]) ids.push(`${id}${suffix}${encoding}`);
+	return ids;
+}
+
+//#endregion
+//#region src/Providers/AssetsServiceProvider.ts
+/**
+* Handles public assets loading
+* 
+* Auto-Registered
+*/
+var AssetsServiceProvider = class extends ServiceProvider {
+	static priority = 996;
+	register() {
+		const app = this.app.make("router");
+		const publicPath = this.app.getPath("public");
+		/**
+		* Use a middleware to check if this request for for a file
+		*/
+		app.h3middleware((event) => {
+			const { pathname } = new URL(event.req.url);
+			/**
+			* Only serve if it looks like a static asset (has an extension)
+			* but skip dotfiles or sensitive files
+			*/
+			if (!/\.[a-zA-Z0-9]+$/.test(pathname)) return;
+			if (pathname.startsWith("/.") || pathname.includes("..")) return;
+			/**
+			* Serve the asset
+			*/
+			return serveStatic(event, {
+				indexNames: ["/index.html"],
+				getContents: (id) => {
+					return (0, node_fs_promises.readFile)((0, node_path.join)(Str.before(publicPath, id), id));
+				},
+				getMeta: async (id) => {
+					const stats = await (0, node_fs_promises.stat)((0, node_path.join)(Str.before(publicPath, id), id)).catch(() => {});
+					if (stats?.isFile()) return {
+						size: stats.size,
+						mtime: stats.mtimeMs
+					};
+				}
+			});
+		});
+		this.app.singleton("asset", () => {
+			return (key, def) => {
+				if (def) try {
+					(0, node_fs.statSync)((0, node_path.join)(Str.before(publicPath, key), key));
+				} catch {
+					key = def;
+				}
+				return key;
+			};
+		});
+	}
+};
+
+//#endregion
+//#region src/Providers/RouteServiceProvider.ts
+/**
+* Handles routing registration
+* 
+* Load route files (web.ts, api.ts).
+* Map controllers to routes.
+* Register route-related middleware.
+*/
+var RouteServiceProvider = class RouteServiceProvider extends ServiceProvider {
+	static priority = 997;
+	/**
+	* The callback that should be used to load the application's routes.
+	*/
+	loadRoutesUsing;
+	/**
+	* The global callback that should be used to load the application's routes.
+	*/
+	static alwaysLoadRoutesUsing;
+	async register() {
+		const { RouteListCommand, Router, SubstituteBindings } = await import("@h3ravel/router");
+		this.app.bindMiddleware("SubstituteBindings", SubstituteBindings);
+		this.booted(() => {
+			const router$1 = this.app.make(__h3ravel_contracts.IRouter);
+			if (typeof router$1.getRoutes === "function") {
+				router$1.getRoutes().refreshActionLookups();
+				router$1.getRoutes().refreshNameLookups();
+			}
+		});
+		const router = () => {
+			try {
+				return new Router(this.app.make("http.app"), this.app);
+			} catch (error) {
+				if (String(error.message).includes("http.app")) __h3ravel_shared.Logger.log([
+					["The", "white"],
+					["@h3ravel/http", ["italic", "gray"]],
+					["package is required to use the routing system.", "white"]
+				], " ");
+				else __h3ravel_shared.Logger.log(error, "white");
+			}
+			return {};
+		};
+		this.app.singleton("router", router);
+		this.app.alias(Router, "router");
+		this.app.alias(__h3ravel_contracts.IRouter, "router");
+		this.registerCommands([RouteListCommand]);
+	}
+	/**
+	* Load routes from src/routes
+	*/
+	async boot() {
+		await this.loadRoutes();
+	}
+	/**
+	* Register the callback that will be used to load the application's routes.
+	*
+	* @param  routesCallback
+	*/
+	routes(routesCallback) {
+		this.loadRoutesUsing = routesCallback;
+		return this;
+	}
+	/**
+	* Register the callback that will be used to load the application's routes.
+	*
+	* @param  routesCallback
+	*/
+	static loadRoutesUsing(routesCallback) {
+		this.alwaysLoadRoutesUsing = routesCallback;
+	}
+	/**
+	* Load the application routes.
+	*/
+	async loadRoutes() {
+		if (RouteServiceProvider.alwaysLoadRoutesUsing != null) this.app.call(RouteServiceProvider.alwaysLoadRoutesUsing);
+		if (this.loadRoutesUsing != null) this.app.call(this.loadRoutesUsing);
+		else if (typeof this["map"] === "function") this.app.call(this["map"]);
+	}
+};
+
+//#endregion
+//#region src/Tappable.ts
+const Tappable = (Base) => {
+	return class extends Base {
+		/**
+		* Call the given Closure with this instance then return the instance.
+		*
+		* @param  callback
+		*/
+		tap(callback) {
+			return tap(this, callback);
+		}
+	};
+};
+
 //#endregion
 exports.Arr = Arr;
+exports.AssetsServiceProvider = AssetsServiceProvider;
+exports.BadMethodCallException = BadMethodCallException;
+exports.Collection = Collection;
 Object.defineProperty(exports, 'Crypto', {
   enumerable: true,
   get: function () {
@@ -6223,8 +7046,11 @@ Object.defineProperty(exports, 'Crypto', {
   }
 });
 exports.DateTime = DateTime;
+exports.HigherOrderTapProxy = HigherOrderTapProxy;
 exports.HtmlString = HtmlString;
 exports.InvalidArgumentException = InvalidArgumentException;
+exports.Macroable = Macroable;
+exports.MacroableClass = MacroableClass;
 exports.Mode = Mode;
 Object.defineProperty(exports, 'Number', {
   enumerable: true,
@@ -6233,15 +7059,21 @@ Object.defineProperty(exports, 'Number', {
   }
 });
 exports.Obj = Obj;
-exports.RuntimeException = RuntimeException;
+exports.RouteServiceProvider = RouteServiceProvider;
+exports.RuntimeException = require_RuntimeException.RuntimeException;
+exports.ServiceProvider = ServiceProvider;
 exports.Str = Str;
 exports.Stringable = Stringable;
+exports.Tappable = Tappable;
+exports.__toESM = __toESM;
 exports.abbreviate = abbreviate;
 exports.base64Decode = base64Decode;
 exports.base64Encode = base64Encode;
 exports.caesarCipher = caesarCipher;
 exports.checksum = checksum;
 exports.cleanHelpers = cleanHelpers;
+exports.collect = collect;
+exports.createOptionalProxy = createOptionalProxy;
 exports.data_fill = data_fill;
 exports.data_forget = data_forget;
 exports.data_get = data_get;
@@ -6255,9 +7087,13 @@ exports.getValue = getValue;
 exports.hash = hash;
 exports.hmac = hmac;
 exports.humanize = humanize;
+exports.isAbstract = isAbstract;
+exports.isCallable = isCallable;
+exports.isClass = isClass;
 exports.isPlainObject = isPlainObject;
 exports.loadHelpers = loadHelpers;
 exports.modObj = modObj;
+exports.optional = optional;
 exports.random = random;
 exports.randomColor = randomColor;
 exports.randomPassword = randomPassword;
@@ -6267,6 +7103,7 @@ exports.secureToken = secureToken;
 exports.setNested = setNested;
 exports.slugifyKeys = slugifyKeys;
 exports.str = str;
+exports.tap = tap;
 exports.toBytes = toBytes;
 exports.toCssClasses = toCssClasses;
 exports.toCssStyles = toCssStyles;