@h3ravel/support 0.15.5 → 0.16.0

package/dist/index.js

@@ -1,4 +1,6 @@
-import { t as __export } from "./chunk-Bop6jNiL.js";
+import { t as __export } from "./chunk-NmTyJVUt.js";
+import { t as RuntimeException } from "./RuntimeException-CrNX0B-p.js";
+import { Collection as Collection$1 } from "@h3ravel/collect.js";
 import { createHash, createHmac, randomBytes, randomUUID } from "crypto";
 import process from "process";
 import util from "util";
@@ -11,27 +13,48 @@ import isLeapYear from "dayjs/plugin/isLeapYear.js";
 import relativeTime from "dayjs/plugin/relativeTime.js";
 import timezone from "dayjs/plugin/timezone.js";
 import utc from "dayjs/plugin/utc.js";
+import { isIP } from "node:net";
+import { Logger, trait } from "@h3ravel/shared";
+import { readFile, stat } from "node:fs/promises";
+import { IRouter, IServiceProvider } from "@h3ravel/contracts";
+import { join } from "node:path";
+import { statSync } from "node:fs";
 
-//#region src/Exceptions/InvalidArgumentException.ts
+//#region src/Collection.ts
+var Collection = class extends Collection$1 {
+	/**
+	* 
+	* @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";
 	}
 };
 
@@ -424,7 +447,7 @@ const toHumanTime = (seconds = 0, worded = false) => {
 * with dot-separated keys.
 *
 * Example:
-* doter({
+* dot({
 *   user: { name: "John", address: { city: "NY" } },
 *   active: true
 * })
@@ -567,6 +590,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 "";
@@ -585,6 +611,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 = [];
@@ -601,6 +630,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 = {};
@@ -625,6 +657,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;
@@ -640,6 +677,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(".");
@@ -657,6 +698,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);
@@ -665,6 +710,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(".");
@@ -682,14 +730,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";
@@ -698,6 +750,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 {
@@ -729,12 +786,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);
@@ -744,6 +832,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;
@@ -757,6 +850,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;
@@ -772,13 +869,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 {};
@@ -790,6 +904,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;
@@ -802,6 +919,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
@@ -1338,6 +1469,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);
 	}
 	/**
@@ -1476,6 +1608,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
@@ -1495,9 +1636,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 = dayjs(config);
+		this.instance = dayjs(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);
@@ -1865,18 +2006,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
@@ -1914,6 +2043,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
@@ -2058,7 +2227,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;
@@ -2186,6 +2355,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 
@@ -3635,10 +3817,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.
@@ -3651,8 +3832,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;
 	}
 	/**
@@ -3666,8 +3846,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;
 	}
 	/**
@@ -4018,6 +4197,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 = isIP(host);
+		if (type) return result === code[type];
+		return result > 0;
+	}
+	/**
 	* Generate a time-ordered UUID (version 4).
 	*
 	* @return { string }
@@ -4390,6 +4586,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
@@ -4401,14 +4607,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.
@@ -5221,6 +5426,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
@@ -6035,6 +6250,7 @@ function loadHelpers(target = globalThis) {
 		last: Arr.last,
 		prepend: Arr.prepend,
 		flatten: Arr.flatten,
+		unique: Arr.unique,
 		dot,
 		undot,
 		extractProperties,
@@ -6049,6 +6265,7 @@ function loadHelpers(target = globalThis) {
 		data_set,
 		data_fill,
 		data_forget,
+		isPlainObject,
 		uuid,
 		random,
 		randomSecure,
@@ -6174,4 +6391,598 @@ function cleanHelpers(target = globalThis) {
 }
 
 //#endregion
-export { Arr, Crypto_exports as Crypto, DateTime, HtmlString, InvalidArgumentException, Mode, Number_exports as Number, Obj, RuntimeException, Str, Stringable, abbreviate, base64Decode, base64Encode, caesarCipher, checksum, cleanHelpers, data_fill, data_forget, data_get, data_set, dd, dot, dump, extractProperties, format, getValue, hash, hmac, humanize, isPlainObject, loadHelpers, modObj, random, randomColor, randomPassword, randomSecure, safeDot, secureToken, setNested, slugifyKeys, str, toBytes, toCssClasses, toCssStyles, toHumanTime, undot, uuid, verifyChecksum, xor };
+//#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 = () => 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 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 readFile(join(Str.before(publicPath, id), id));
+				},
+				getMeta: async (id) => {
+					const stats = await stat(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 {
+					statSync(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(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")) Logger.log([
+					["The", "white"],
+					["@h3ravel/http", ["italic", "gray"]],
+					["package is required to use the routing system.", "white"]
+				], " ");
+				else Logger.log(error, "white");
+			}
+			return {};
+		};
+		this.app.singleton("router", router);
+		this.app.alias(Router, "router");
+		this.app.alias(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
+export { Arr, AssetsServiceProvider, BadMethodCallException, Collection, Crypto_exports as Crypto, DateTime, HigherOrderTapProxy, HtmlString, InvalidArgumentException, Macroable, MacroableClass, Mode, Number_exports as Number, Obj, RouteServiceProvider, RuntimeException, ServiceProvider, Str, Stringable, Tappable, abbreviate, base64Decode, base64Encode, caesarCipher, checksum, cleanHelpers, collect, createOptionalProxy, data_fill, data_forget, data_get, data_set, dd, dot, dump, extractProperties, format, getValue, hash, hmac, humanize, isAbstract, isCallable, isClass, isPlainObject, loadHelpers, modObj, optional, random, randomColor, randomPassword, randomSecure, safeDot, secureToken, setNested, slugifyKeys, str, tap, toBytes, toCssClasses, toCssStyles, toHumanTime, undot, uuid, verifyChecksum, xor };