commandkit 1.0.0-dev.20250529020123 → 1.0.0-dev.20250530015910

package/dist/CommandKit-DDrQtQns.js

@@ -0,0 +1,3281 @@
+const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_colors = require('./colors-Cd4Oz-r-.js');
+const require_error_codes = require('./error-codes-C_UO39jz.js');
+const require_element = require('./element-hdSqnIpC.js');
+const require_EventInterceptor = require('./EventInterceptor-DtRINyTP.js');
+const require_constants = require('./constants-DOPSzXI0.js');
+const require_CompilerPlugin = require('./CompilerPlugin-XzuGixkC.js');
+const require_RuntimePlugin = require('./RuntimePlugin-CKsd83M3.js');
+const require_EventWorkerContext = require('./EventWorkerContext-XZGSHn5F.js');
+const require_resolve_file_url = require('./resolve-file-url-pO9_rLft.js');
+const require_MessageCommandParser = require('./MessageCommandParser-B13Pkwo9.js');
+const require_signals = require('./signals-Bp0bzjE6.js');
+const require_types_package = require('./types-package-DRhFn59I.js');
+const require_CommandsRouter = require('./CommandsRouter-BHaPno8o.js');
+const require_EventsRouter = require('./EventsRouter-CqnrlbjN.js');
+const require_common = require('./common-DirpDCa6.js');
+const require_CommandKitEventsChannel = require('./CommandKitEventsChannel-B6LKgxmv.js');
+const require_store = require('./store-Ci6ib2C9.js');
+const node_events = require_chunk.__toESM(require("node:events"));
+const discord_js = require_chunk.__toESM(require("discord.js"));
+const node_async_hooks = require_chunk.__toESM(require("node:async_hooks"));
+const node_fs = require_chunk.__toESM(require("node:fs"));
+const node_path = require_chunk.__toESM(require("node:path"));
+const node_crypto = require_chunk.__toESM(require("node:crypto"));
+const __rollup_plugin_json = require_chunk.__toESM(require("@rollup/plugin-json"));
+
+//#region src/context/async-context.ts
+const kCommandWorker = Symbol("commandkitCommandWorker");
+const context = new node_async_hooks.AsyncLocalStorage();
+function isCommandWorkerContext(worker) {
+	return worker && Reflect.get(worker, kCommandWorker) === true;
+}
+function exitContext(fn) {
+	return context.exit(fn);
+}
+function provideContext(value, receiver) {
+	Reflect.set(value, kCommandWorker, true);
+	return context.run(value, receiver);
+}
+/**
+* Returns a context-aware version of the given function.
+* @param env - The commandkit environment data.
+* @param fn - The target function.
+* @param finalizer - An optional finalizer function to run after the target function. This function will be context-aware.
+* @internal
+*/
+function makeContextAwareFunction(env, fn, finalizer) {
+	const _fn = (...args) => {
+		return provideContext(env, async () => {
+			try {
+				const result = await fn(...args);
+				return result;
+			} catch (e) {
+				if (!require_error_codes.isCommandKitError(e)) env.setExecutionError(e);
+			} finally {
+				if (typeof finalizer === "function") setImmediate(async () => {
+					try {
+						await finalizer(...args);
+					} catch {}
+				});
+			}
+		});
+	};
+	return _fn;
+}
+function getCommandKit(strict = false) {
+	var _context$getStore;
+	const kit = ((_context$getStore = context.getStore()) === null || _context$getStore === void 0 ? void 0 : _context$getStore.commandkit) ?? CommandKit.instance;
+	if (!kit && strict) throw new Error("CommandKit instance not found.");
+	return kit;
+}
+/**
+* Get the current commandkit context.
+* @internal
+*/
+function getContext() {
+	const ctx = context.getStore();
+	return ctx;
+}
+/**
+* Use current commandkit context. Throws an error if no context is found.
+*/
+function useEnvironment() {
+	const ctx = context.getStore();
+	if (!ctx) throw new Error("No commandkit environment found. Please make sure you are inside commandkit handler.");
+	return ctx;
+}
+
+//#endregion
+//#region src/components/v1/button/ButtonKit.ts
+var ButtonKit = class extends discord_js.ButtonBuilder {
+	#onClickHandler = null;
+	#contextData = {
+		autoReset: true,
+		time: 5 * 60 * 1e3,
+		once: false
+	};
+	#unsub = null;
+	#getEventInterceptor() {
+		const ctx = getContext();
+		if (!ctx) return getCommandKit(true).eventInterceptor;
+		return exitContext(() => ctx.commandkit.eventInterceptor);
+	}
+	/**
+	* Sets up an inline interaction collector for this button. This collector by default allows as many interactions as possible if it is actively used.
+	* If unused, this expires after 24 hours or custom time if specified.
+	* @param handler The handler to run when the button is clicked
+	* @param data The context data to use for the interaction collector
+	* @returns This button
+	* @example
+	* ```ts
+	* const button = new ButtonKit()
+	*   .setLabel('Click me')
+	*   .setStyle(ButtonStyle.Primary)
+	*   .setCustomId('click_me')
+	*   .filter((interaction) => interaction.user.id === '1234567890')
+	*   .onClick(async (interaction) => {
+	*     await interaction.reply('You clicked me!');
+	*   });
+	*
+	* const row = new ActionRowBuilder().addComponents(button);
+	*
+	* const message = await channel.send({ content: 'Click the button', components: [row] });
+	*
+	* // Remove onClick handler and destroy the interaction collector
+	* button.onClick(null);
+	* ```
+	*/
+	onClick(handler, data) {
+		if (this.data.style === discord_js.ButtonStyle.Link) throw new TypeError("Cannot setup \"onClick\" handler on link buttons.");
+		if (!handler) throw new TypeError("Cannot setup \"onClick\" without a handler function parameter.");
+		if (this.#onClickHandler) this.#destroyCollector();
+		this.#onClickHandler = handler;
+		if (data) {
+			var _this$contextData, _this$contextData2, _this$contextData3, _this$contextData4;
+			this.#contextData = {
+				autoReset: data.autoReset ?? ((_this$contextData = this.#contextData) === null || _this$contextData === void 0 ? void 0 : _this$contextData.autoReset) ?? true,
+				time: data.time ?? ((_this$contextData2 = this.#contextData) === null || _this$contextData2 === void 0 ? void 0 : _this$contextData2.time) ?? 5 * 60 * 1e3,
+				filter: data.filter ?? ((_this$contextData3 = this.#contextData) === null || _this$contextData3 === void 0 ? void 0 : _this$contextData3.filter),
+				onEnd: data.onEnd ?? ((_this$contextData4 = this.#contextData) === null || _this$contextData4 === void 0 ? void 0 : _this$contextData4.onEnd)
+			};
+		}
+		this.#setupInteractionCollector();
+		return this;
+	}
+	onEnd(handler) {
+		if (this.data.style === discord_js.ButtonStyle.Link) throw new TypeError("Cannot setup \"onEnd\" handler on link buttons.");
+		if (!handler) throw new TypeError("Cannot setup \"onEnd\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onEnd = handler;
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onError(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onError\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onError = handler;
+		return this;
+	}
+	/**
+	* Sets a filter for the interaction collector.
+	* @param predicate The filter to use for the interaction collector
+	*/
+	filter(predicate) {
+		this.#contextData ??= {
+			autoReset: true,
+			time: 5 * 60 * 1e3
+		};
+		this.#contextData.filter = predicate;
+		return this;
+	}
+	get customId() {
+		return this.data.custom_id ?? this.data.customId;
+	}
+	#setupInteractionCollector() {
+		if (this.data.style === discord_js.ButtonStyle.Link || !this.#contextData || !this.#onClickHandler) return;
+		const myCustomId = this.customId ?? null;
+		if (myCustomId === null) throw new TypeError("Cannot setup \"onClick\" handler on a button without a custom id.");
+		const interceptor = this.#getEventInterceptor();
+		this.#unsub = interceptor.subscribe(discord_js.Events.InteractionCreate, async (interaction) => {
+			var _this$contextData5, _this$unsub;
+			if (!interaction.isButton()) return;
+			const myCustomId$1 = this.customId ?? null;
+			const interactionCustomId = interaction.customId;
+			if (myCustomId$1 && interactionCustomId !== myCustomId$1) return;
+			const filter = (_this$contextData5 = this.#contextData) === null || _this$contextData5 === void 0 ? void 0 : _this$contextData5.filter;
+			if (filter && !await filter(interaction)) return;
+			const handler = this.#onClickHandler;
+			if (!handler) return (_this$unsub = this.#unsub) === null || _this$unsub === void 0 ? void 0 : _this$unsub.call(this);
+			return handler(interaction, this);
+		}, this.#contextData);
+	}
+	dispose() {
+		this.#destroyCollector();
+		return this;
+	}
+	#destroyCollector() {
+		var _this$unsub2;
+		(_this$unsub2 = this.#unsub) === null || _this$unsub2 === void 0 || _this$unsub2.call(this);
+		this.#unsub = null;
+		this.#contextData = null;
+		this.#onClickHandler = null;
+	}
+};
+
+//#endregion
+//#region src/components/v1/button/Button.ts
+/**
+* The button component.
+* @param props The button properties.
+* @returns The commandkit element.
+* @example <Button style={ButtonStyle.Primary} customId="click_me">Click Me</Button>
+*/
+function Button(props) {
+	const button = new ButtonKit();
+	props.style ??= discord_js.ButtonStyle.Primary;
+	if (props.onClick) props.customId ??= `buttonkit::${crypto.randomUUID()}`;
+	if (props.customId) button.setCustomId(props.customId);
+	if (props.onClick) button.onClick(props.onClick, props.options);
+	if (props.disabled) button.setDisabled(props.disabled);
+	if (props.emoji) button.setEmoji(props.emoji);
+	if (props.skuId) button.setSKUId(props.skuId);
+	if (props.url) button.setURL(props.url);
+	if (props.style) button.setStyle(props.style);
+	const label = props.label || props.children;
+	if (label) button.setLabel(Array.isArray(label) ? label.join(" ") : typeof label === "string" ? label : String(label));
+	if (props.onEnd) button.onEnd(props.onEnd);
+	if (props.onError) button.onError(props.onError);
+	return button;
+}
+
+//#endregion
+//#region src/components/v1/modal/ModalKit.ts
+var ModalKit = class extends discord_js.ModalBuilder {
+	#onSubmitHandler = null;
+	#contextData = {
+		autoReset: false,
+		time: 5 * 60 * 1e3,
+		once: true
+	};
+	#unsub = null;
+	#getEventInterceptor() {
+		const ctx = getContext();
+		if (!ctx) return getCommandKit(true).eventInterceptor;
+		return exitContext(() => ctx.commandkit.eventInterceptor);
+	}
+	/**
+	* Sets the handler to run when the modal is submitted.
+	* @param handler - The handler to run when the modal is submitted.
+	* @param data - The context data for the interaction collector.
+	* @returns This instance of the modal builder.
+	* @example
+	* ```ts
+	* const modal = new ModalKit()
+	*  .setTitle('My Modal')
+	*  .setCustomId('my-modal')
+	*  .filter((interaction) => interaction.user.id === '1234567890')
+	*  .onSubmit(async (interaction) => {
+	*     await interaction.reply('You submitted the modal!');
+	*   })
+	*   .addComponents(actionRow1, actionRow2);
+	* ```
+	*/
+	onSubmit(handler, data) {
+		if (!handler) throw new TypeError("Cannot setup \"onClick\" without a handler function parameter.");
+		if (this.#onSubmitHandler) this.#destroyCollector();
+		this.#onSubmitHandler = handler;
+		if (data) {
+			var _this$contextData, _this$contextData2, _this$contextData3, _this$contextData4;
+			this.#contextData = {
+				autoReset: data.autoReset ?? ((_this$contextData = this.#contextData) === null || _this$contextData === void 0 ? void 0 : _this$contextData.autoReset) ?? true,
+				time: data.time ?? ((_this$contextData2 = this.#contextData) === null || _this$contextData2 === void 0 ? void 0 : _this$contextData2.time) ?? 5 * 60 * 1e3,
+				filter: data.filter ?? ((_this$contextData3 = this.#contextData) === null || _this$contextData3 === void 0 ? void 0 : _this$contextData3.filter),
+				onEnd: data.onEnd ?? ((_this$contextData4 = this.#contextData) === null || _this$contextData4 === void 0 ? void 0 : _this$contextData4.onEnd)
+			};
+		}
+		this.#setupCollector();
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onEnd(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onEnd\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onEnd = handler;
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onError(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onError\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onError = handler;
+		return this;
+	}
+	/**
+	* Sets a filter for the interaction collector.
+	* @param predicate - The filter to use for the interaction collector.
+	* @returns This instance of the modal builder.
+	*/
+	filter(predicate) {
+		this.#contextData ??= {
+			autoReset: true,
+			time: 5 * 60 * 1e3
+		};
+		this.#contextData.filter = predicate;
+		return this;
+	}
+	get customId() {
+		return this.data.custom_id ?? this.data.customId;
+	}
+	#setupCollector() {
+		if (!this.#contextData) return;
+		if (!this.customId) throw new TypeError("Cannot setup an modal collector without a custom ID.");
+		const interceptor = this.#getEventInterceptor();
+		if (!interceptor) return;
+		this.#unsub = interceptor.subscribe(discord_js.Events.InteractionCreate, async (interaction) => {
+			var _this$contextData5, _this$unsub;
+			if (!interaction.isModalSubmit()) return;
+			const myCustomId = this.customId ?? null;
+			const interactionCustomId = interaction.customId;
+			if (myCustomId && interactionCustomId !== myCustomId) return;
+			const filter = (_this$contextData5 = this.#contextData) === null || _this$contextData5 === void 0 ? void 0 : _this$contextData5.filter;
+			if (filter && !await filter(interaction)) return;
+			const handler = this.#onSubmitHandler;
+			if (!handler) return (_this$unsub = this.#unsub) === null || _this$unsub === void 0 ? void 0 : _this$unsub.call(this);
+			return handler(interaction, this);
+		}, this.#contextData);
+	}
+	dispose() {
+		this.#destroyCollector();
+		return this;
+	}
+	#destroyCollector() {
+		var _this$unsub2;
+		(_this$unsub2 = this.#unsub) === null || _this$unsub2 === void 0 || _this$unsub2.call(this);
+		this.#unsub = null;
+		this.#onSubmitHandler = null;
+		this.#contextData = null;
+	}
+};
+
+//#endregion
+//#region src/components/v1/modal/Modal.ts
+/**
+* The modal component.
+* @param props The modal properties.
+* @returns The commandkit element.
+* @example <Modal title="My Modal" onSubmit={onSubmit}>...</Modal>
+*/
+function Modal(props) {
+	const modal = new ModalKit();
+	if (props.title) modal.setTitle(props.title);
+	if (props.onSubmit) props.customId ??= `modalkit::${crypto.randomUUID()}`;
+	if (props.customId) modal.setCustomId(props.customId);
+	if (props.onSubmit) modal.onSubmit(props.onSubmit, props.options);
+	if (props.children) {
+		const childs = (Array.isArray(props.children) ? props.children : [props.children]).map((c) => {
+			if (c instanceof discord_js.ActionRowBuilder) return c;
+			if (c instanceof discord_js.TextInputBuilder) return new discord_js.ActionRowBuilder().addComponents(c);
+		}).filter((c) => c != null);
+		modal.addComponents(childs);
+	}
+	if (props.onEnd) modal.onEnd(props.onEnd);
+	if (props.onError) modal.onError(props.onError);
+	return modal;
+}
+/**
+* The text input component.
+* @param props The text input properties.
+* @returns The commandkit element.
+* @example <TextInput customId="input" label="Input" style={TextInputStyle.Short} />
+*/
+function TextInput(props) {
+	const input = new discord_js.TextInputBuilder().setStyle(props.style);
+	if (props.customId) input.setCustomId(props.customId);
+	if (props.label) input.setLabel(props.label);
+	if (props.placeholder) input.setPlaceholder(props.placeholder);
+	if (props.maxLength) input.setMaxLength(props.maxLength);
+	if (props.minLength) input.setMinLength(props.minLength);
+	if (props.value) input.setValue(props.value);
+	if (props.required) input.setRequired(props.required);
+	return input;
+}
+/**
+* The short text input component.
+* @param props The text input properties.
+* @returns The commandkit element.
+* @example <ShortInput customId="input" label="Input" />
+*/
+function ShortInput(props) {
+	return TextInput({
+		...props,
+		style: discord_js.TextInputStyle.Short
+	});
+}
+/**
+* The paragraph text input component.
+* @param props The text input properties.
+* @returns The commandkit element.
+* @example <ParagraphInput customId="input" label="Input" />
+*/
+function ParagraphInput(props) {
+	return TextInput({
+		...props,
+		style: discord_js.TextInputStyle.Paragraph
+	});
+}
+
+//#endregion
+//#region src/components/v1/select-menu/StringSelectMenuKit.ts
+var StringSelectMenuKit = class extends discord_js.StringSelectMenuBuilder {
+	#onSelectHandler = null;
+	#contextData = {
+		autoReset: false,
+		time: 5 * 60 * 1e3,
+		once: true
+	};
+	#unsub = null;
+	#getEventInterceptor() {
+		const ctx = getContext();
+		if (!ctx) return getCommandKit(true).eventInterceptor;
+		return exitContext(() => ctx.commandkit.eventInterceptor);
+	}
+	/**
+	* Sets the handler to run when the modal is submitted.
+	* @param handler - The handler to run when the modal is submitted.
+	* @param data - The context data for the interaction collector.
+	* @returns This instance of the modal builder.
+	* @example
+	* ```ts
+	* const modal = new StringSelectMenuKit()
+	*  .setTitle('My Modal')
+	*  .setCustomId('my-modal')
+	*  .filter((interaction) => interaction.user.id === '1234567890')
+	*  .onSelect(async (interaction) => {
+	*     await interaction.reply('You submitted the modal!');
+	*   })
+	*   .addComponents(actionRow1, actionRow2);
+	* ```
+	*/
+	onSelect(handler, data) {
+		if (!handler) throw new TypeError("Cannot setup \"onClick\" without a handler function parameter.");
+		if (this.#onSelectHandler) this.#destroyCollector();
+		this.#onSelectHandler = handler;
+		if (data) {
+			var _this$contextData, _this$contextData2, _this$contextData3, _this$contextData4;
+			this.#contextData = {
+				autoReset: data.autoReset ?? ((_this$contextData = this.#contextData) === null || _this$contextData === void 0 ? void 0 : _this$contextData.autoReset) ?? true,
+				time: data.time ?? ((_this$contextData2 = this.#contextData) === null || _this$contextData2 === void 0 ? void 0 : _this$contextData2.time) ?? 5 * 60 * 1e3,
+				filter: data.filter ?? ((_this$contextData3 = this.#contextData) === null || _this$contextData3 === void 0 ? void 0 : _this$contextData3.filter),
+				onEnd: data.onEnd ?? ((_this$contextData4 = this.#contextData) === null || _this$contextData4 === void 0 ? void 0 : _this$contextData4.onEnd)
+			};
+		}
+		this.#setupCollector();
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onEnd(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onEnd\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onEnd = handler;
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onError(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onError\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onError = handler;
+		return this;
+	}
+	/**
+	* Sets a filter for the interaction collector.
+	* @param predicate - The filter to use for the interaction collector.
+	* @returns This instance of the modal builder.
+	*/
+	filter(predicate) {
+		this.#contextData ??= {
+			autoReset: true,
+			time: 5 * 60 * 1e3
+		};
+		this.#contextData.filter = predicate;
+		return this;
+	}
+	get customId() {
+		return this.data.custom_id ?? this.data.customId;
+	}
+	#setupCollector() {
+		if (!this.#contextData) return;
+		if (!this.customId) throw new TypeError("Cannot setup an modal collector without a custom ID.");
+		const interceptor = this.#getEventInterceptor();
+		if (!interceptor) return;
+		this.#unsub = interceptor.subscribe(discord_js.Events.InteractionCreate, async (interaction) => {
+			var _this$contextData5, _this$unsub;
+			if (!interaction.isStringSelectMenu()) return;
+			const myCustomId = this.customId ?? null;
+			const interactionCustomId = interaction.customId;
+			if (myCustomId && interactionCustomId !== myCustomId) return;
+			const filter = (_this$contextData5 = this.#contextData) === null || _this$contextData5 === void 0 ? void 0 : _this$contextData5.filter;
+			if (filter && !await filter(interaction)) return;
+			const handler = this.#onSelectHandler;
+			if (!handler) return (_this$unsub = this.#unsub) === null || _this$unsub === void 0 ? void 0 : _this$unsub.call(this);
+			return handler(interaction, this);
+		}, this.#contextData);
+	}
+	dispose() {
+		this.#destroyCollector();
+		return this;
+	}
+	#destroyCollector() {
+		var _this$unsub2;
+		(_this$unsub2 = this.#unsub) === null || _this$unsub2 === void 0 || _this$unsub2.call(this);
+		this.#unsub = null;
+		this.#onSelectHandler = null;
+		this.#contextData = null;
+	}
+};
+
+//#endregion
+//#region src/components/v1/select-menu/ChannelSelectMenuKit.ts
+var ChannelSelectMenuKit = class extends discord_js.ChannelSelectMenuBuilder {
+	#onSelectHandler = null;
+	#contextData = {
+		autoReset: false,
+		time: 5 * 60 * 1e3,
+		once: true
+	};
+	#unsub = null;
+	#getEventInterceptor() {
+		const ctx = getContext();
+		if (!ctx) return getCommandKit(true).eventInterceptor;
+		return exitContext(() => ctx.commandkit.eventInterceptor);
+	}
+	/**
+	* Sets the handler to run when the modal is submitted.
+	* @param handler - The handler to run when the modal is submitted.
+	* @param data - The context data for the interaction collector.
+	* @returns This instance of the modal builder.
+	* @example
+	* ```ts
+	* const modal = new ChannelSelectMenuKit()
+	*  .setTitle('My Modal')
+	*  .setCustomId('my-modal')
+	*  .filter((interaction) => interaction.Channel.id === '1234567890')
+	*  .onSelect(async (interaction) => {
+	*     await interaction.reply('You submitted the modal!');
+	*   })
+	*   .addComponents(actionRow1, actionRow2);
+	* ```
+	*/
+	onSelect(handler, data) {
+		if (!handler) throw new TypeError("Cannot setup \"onClick\" without a handler function parameter.");
+		if (this.#onSelectHandler) this.#destroyCollector();
+		this.#onSelectHandler = handler;
+		if (data) {
+			var _this$contextData, _this$contextData2, _this$contextData3, _this$contextData4;
+			this.#contextData = {
+				autoReset: data.autoReset ?? ((_this$contextData = this.#contextData) === null || _this$contextData === void 0 ? void 0 : _this$contextData.autoReset) ?? true,
+				time: data.time ?? ((_this$contextData2 = this.#contextData) === null || _this$contextData2 === void 0 ? void 0 : _this$contextData2.time) ?? 5 * 60 * 1e3,
+				filter: data.filter ?? ((_this$contextData3 = this.#contextData) === null || _this$contextData3 === void 0 ? void 0 : _this$contextData3.filter),
+				onEnd: data.onEnd ?? ((_this$contextData4 = this.#contextData) === null || _this$contextData4 === void 0 ? void 0 : _this$contextData4.onEnd)
+			};
+		}
+		this.#setupCollector();
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onEnd(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onEnd\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onEnd = handler;
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onError(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onError\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onError = handler;
+		return this;
+	}
+	/**
+	* Sets a filter for the interaction collector.
+	* @param predicate - The filter to use for the interaction collector.
+	* @returns This instance of the modal builder.
+	*/
+	filter(predicate) {
+		this.#contextData ??= {
+			autoReset: true,
+			time: 5 * 60 * 1e3
+		};
+		this.#contextData.filter = predicate;
+		return this;
+	}
+	get customId() {
+		return this.data.custom_id ?? this.data.customId;
+	}
+	#setupCollector() {
+		if (!this.#contextData) return;
+		if (!this.customId) throw new TypeError("Cannot setup an modal collector without a custom ID.");
+		const interceptor = this.#getEventInterceptor();
+		if (!interceptor) return;
+		this.#unsub = interceptor.subscribe(discord_js.Events.InteractionCreate, async (interaction) => {
+			var _this$contextData5, _this$unsub;
+			if (!interaction.isChannelSelectMenu()) return;
+			const myCustomId = this.customId ?? null;
+			const interactionCustomId = interaction.customId;
+			if (myCustomId && interactionCustomId !== myCustomId) return;
+			const filter = (_this$contextData5 = this.#contextData) === null || _this$contextData5 === void 0 ? void 0 : _this$contextData5.filter;
+			if (filter && !await filter(interaction)) return;
+			const handler = this.#onSelectHandler;
+			if (!handler) return (_this$unsub = this.#unsub) === null || _this$unsub === void 0 ? void 0 : _this$unsub.call(this);
+			return handler(interaction, this);
+		}, this.#contextData);
+	}
+	dispose() {
+		this.#destroyCollector();
+		return this;
+	}
+	#destroyCollector() {
+		var _this$unsub2;
+		(_this$unsub2 = this.#unsub) === null || _this$unsub2 === void 0 || _this$unsub2.call(this);
+		this.#unsub = null;
+		this.#onSelectHandler = null;
+		this.#contextData = null;
+	}
+};
+
+//#endregion
+//#region src/components/v1/select-menu/MentionableSelectMenuKit.ts
+var MentionableSelectMenuKit = class extends discord_js.MentionableSelectMenuBuilder {
+	#onSelectHandler = null;
+	#contextData = {
+		autoReset: false,
+		time: 5 * 60 * 1e3,
+		once: true
+	};
+	#unsub = null;
+	#getEventInterceptor() {
+		const ctx = getContext();
+		if (!ctx) return getCommandKit(true).eventInterceptor;
+		return exitContext(() => ctx.commandkit.eventInterceptor);
+	}
+	/**
+	* Sets the handler to run when the modal is submitted.
+	* @param handler - The handler to run when the modal is submitted.
+	* @param data - The context data for the interaction collector.
+	* @returns This instance of the modal builder.
+	* @example
+	* ```ts
+	* const modal = new MentionableSelectMenuKit()
+	*  .setTitle('My Modal')
+	*  .setCustomId('my-modal')
+	*  .filter((interaction) => interaction.Mentionable.id === '1234567890')
+	*  .onSelect(async (interaction) => {
+	*     await interaction.reply('You submitted the modal!');
+	*   })
+	*   .addComponents(actionRow1, actionRow2);
+	* ```
+	*/
+	onSelect(handler, data) {
+		if (!handler) throw new TypeError("Cannot setup \"onClick\" without a handler function parameter.");
+		if (this.#onSelectHandler) this.#destroyCollector();
+		this.#onSelectHandler = handler;
+		if (data) {
+			var _this$contextData, _this$contextData2, _this$contextData3, _this$contextData4;
+			this.#contextData = {
+				autoReset: data.autoReset ?? ((_this$contextData = this.#contextData) === null || _this$contextData === void 0 ? void 0 : _this$contextData.autoReset) ?? true,
+				time: data.time ?? ((_this$contextData2 = this.#contextData) === null || _this$contextData2 === void 0 ? void 0 : _this$contextData2.time) ?? 5 * 60 * 1e3,
+				filter: data.filter ?? ((_this$contextData3 = this.#contextData) === null || _this$contextData3 === void 0 ? void 0 : _this$contextData3.filter),
+				onEnd: data.onEnd ?? ((_this$contextData4 = this.#contextData) === null || _this$contextData4 === void 0 ? void 0 : _this$contextData4.onEnd)
+			};
+		}
+		this.#setupCollector();
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onEnd(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onEnd\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onEnd = handler;
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onError(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onError\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onError = handler;
+		return this;
+	}
+	/**
+	* Sets a filter for the interaction collector.
+	* @param predicate - The filter to use for the interaction collector.
+	* @returns This instance of the modal builder.
+	*/
+	filter(predicate) {
+		this.#contextData ??= {
+			autoReset: true,
+			time: 5 * 60 * 1e3
+		};
+		this.#contextData.filter = predicate;
+		return this;
+	}
+	get customId() {
+		return this.data.custom_id ?? this.data.customId;
+	}
+	#setupCollector() {
+		if (!this.#contextData) return;
+		if (!this.customId) throw new TypeError("Cannot setup an modal collector without a custom ID.");
+		const interceptor = this.#getEventInterceptor();
+		if (!interceptor) return;
+		this.#unsub = interceptor.subscribe(discord_js.Events.InteractionCreate, async (interaction) => {
+			var _this$contextData5, _this$unsub;
+			if (!interaction.isMentionableSelectMenu()) return;
+			const myCustomId = this.customId ?? null;
+			const interactionCustomId = interaction.customId;
+			if (myCustomId && interactionCustomId !== myCustomId) return;
+			const filter = (_this$contextData5 = this.#contextData) === null || _this$contextData5 === void 0 ? void 0 : _this$contextData5.filter;
+			if (filter && !await filter(interaction)) return;
+			const handler = this.#onSelectHandler;
+			if (!handler) return (_this$unsub = this.#unsub) === null || _this$unsub === void 0 ? void 0 : _this$unsub.call(this);
+			return handler(interaction, this);
+		}, this.#contextData);
+	}
+	dispose() {
+		this.#destroyCollector();
+		return this;
+	}
+	#destroyCollector() {
+		var _this$unsub2;
+		(_this$unsub2 = this.#unsub) === null || _this$unsub2 === void 0 || _this$unsub2.call(this);
+		this.#unsub = null;
+		this.#onSelectHandler = null;
+		this.#contextData = null;
+	}
+};
+
+//#endregion
+//#region src/components/v1/select-menu/UserSelectMenuKit.ts
+var UserSelectMenuKit = class extends discord_js.UserSelectMenuBuilder {
+	#onSelectHandler = null;
+	#contextData = {
+		autoReset: false,
+		time: 5 * 60 * 1e3,
+		once: true
+	};
+	#unsub = null;
+	#getEventInterceptor() {
+		const ctx = getContext();
+		if (!ctx) return getCommandKit(true).eventInterceptor;
+		return exitContext(() => ctx.commandkit.eventInterceptor);
+	}
+	/**
+	* Sets the handler to run when the modal is submitted.
+	* @param handler - The handler to run when the modal is submitted.
+	* @param data - The context data for the interaction collector.
+	* @returns This instance of the modal builder.
+	* @example
+	* ```ts
+	* const modal = new UserSelectMenuKit()
+	*  .setTitle('My Modal')
+	*  .setCustomId('my-modal')
+	*  .filter((interaction) => interaction.user.id === '1234567890')
+	*  .onSelect(async (interaction) => {
+	*     await interaction.reply('You submitted the modal!');
+	*   })
+	*   .addComponents(actionRow1, actionRow2);
+	* ```
+	*/
+	onSelect(handler, data) {
+		if (!handler) throw new TypeError("Cannot setup \"onClick\" without a handler function parameter.");
+		if (this.#onSelectHandler) this.#destroyCollector();
+		this.#onSelectHandler = handler;
+		if (data) {
+			var _this$contextData, _this$contextData2, _this$contextData3, _this$contextData4;
+			this.#contextData = {
+				autoReset: data.autoReset ?? ((_this$contextData = this.#contextData) === null || _this$contextData === void 0 ? void 0 : _this$contextData.autoReset) ?? true,
+				time: data.time ?? ((_this$contextData2 = this.#contextData) === null || _this$contextData2 === void 0 ? void 0 : _this$contextData2.time) ?? 5 * 60 * 1e3,
+				filter: data.filter ?? ((_this$contextData3 = this.#contextData) === null || _this$contextData3 === void 0 ? void 0 : _this$contextData3.filter),
+				onEnd: data.onEnd ?? ((_this$contextData4 = this.#contextData) === null || _this$contextData4 === void 0 ? void 0 : _this$contextData4.onEnd)
+			};
+		}
+		this.#setupCollector();
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onEnd(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onEnd\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onEnd = handler;
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onError(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onError\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onError = handler;
+		return this;
+	}
+	/**
+	* Sets a filter for the interaction collector.
+	* @param predicate - The filter to use for the interaction collector.
+	* @returns This instance of the modal builder.
+	*/
+	filter(predicate) {
+		this.#contextData ??= {
+			autoReset: true,
+			time: 5 * 60 * 1e3
+		};
+		this.#contextData.filter = predicate;
+		return this;
+	}
+	get customId() {
+		return this.data.custom_id ?? this.data.customId;
+	}
+	#setupCollector() {
+		if (!this.#contextData) return;
+		if (!this.customId) throw new TypeError("Cannot setup an modal collector without a custom ID.");
+		const interceptor = this.#getEventInterceptor();
+		if (!interceptor) return;
+		this.#unsub = interceptor.subscribe(discord_js.Events.InteractionCreate, async (interaction) => {
+			var _this$contextData5, _this$unsub;
+			if (!interaction.isUserSelectMenu()) return;
+			const myCustomId = this.customId ?? null;
+			const interactionCustomId = interaction.customId;
+			if (myCustomId && interactionCustomId !== myCustomId) return;
+			const filter = (_this$contextData5 = this.#contextData) === null || _this$contextData5 === void 0 ? void 0 : _this$contextData5.filter;
+			if (filter && !await filter(interaction)) return;
+			const handler = this.#onSelectHandler;
+			if (!handler) return (_this$unsub = this.#unsub) === null || _this$unsub === void 0 ? void 0 : _this$unsub.call(this);
+			return handler(interaction, this);
+		}, this.#contextData);
+	}
+	dispose() {
+		this.#destroyCollector();
+		return this;
+	}
+	#destroyCollector() {
+		var _this$unsub2;
+		(_this$unsub2 = this.#unsub) === null || _this$unsub2 === void 0 || _this$unsub2.call(this);
+		this.#unsub = null;
+		this.#onSelectHandler = null;
+		this.#contextData = null;
+	}
+};
+
+//#endregion
+//#region src/components/v1/select-menu/RoleSelectMenuKit.ts
+var RoleSelectMenuKit = class extends discord_js.RoleSelectMenuBuilder {
+	#onSelectHandler = null;
+	#contextData = {
+		autoReset: false,
+		time: 5 * 60 * 1e3,
+		once: true
+	};
+	#unsub = null;
+	#getEventInterceptor() {
+		const ctx = getContext();
+		if (!ctx) return getCommandKit(true).eventInterceptor;
+		return exitContext(() => ctx.commandkit.eventInterceptor);
+	}
+	/**
+	* Sets the handler to run when the modal is submitted.
+	* @param handler - The handler to run when the modal is submitted.
+	* @param data - The context data for the interaction collector.
+	* @returns This instance of the modal builder.
+	* @example
+	* ```ts
+	* const modal = new RoleSelectMenuKit()
+	*  .setTitle('My Modal')
+	*  .setCustomId('my-modal')
+	*  .filter((interaction) => interaction.Role.id === '1234567890')
+	*  .onSelect(async (interaction) => {
+	*     await interaction.reply('You submitted the modal!');
+	*   })
+	*   .addComponents(actionRow1, actionRow2);
+	* ```
+	*/
+	onSelect(handler, data) {
+		if (!handler) throw new TypeError("Cannot setup \"onClick\" without a handler function parameter.");
+		if (this.#onSelectHandler) this.#destroyCollector();
+		this.#onSelectHandler = handler;
+		if (data) {
+			var _this$contextData, _this$contextData2, _this$contextData3, _this$contextData4;
+			this.#contextData = {
+				autoReset: data.autoReset ?? ((_this$contextData = this.#contextData) === null || _this$contextData === void 0 ? void 0 : _this$contextData.autoReset) ?? true,
+				time: data.time ?? ((_this$contextData2 = this.#contextData) === null || _this$contextData2 === void 0 ? void 0 : _this$contextData2.time) ?? 5 * 60 * 1e3,
+				filter: data.filter ?? ((_this$contextData3 = this.#contextData) === null || _this$contextData3 === void 0 ? void 0 : _this$contextData3.filter),
+				onEnd: data.onEnd ?? ((_this$contextData4 = this.#contextData) === null || _this$contextData4 === void 0 ? void 0 : _this$contextData4.onEnd)
+			};
+		}
+		this.#setupCollector();
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onEnd(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onEnd\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onEnd = handler;
+		return this;
+	}
+	/**
+	* Sets the handler to run when the interaction collector ends.
+	* @param handler - The handler to run when the interaction collector ends.
+	* @returns This instance of the modal builder.
+	*/
+	onError(handler) {
+		if (!handler) throw new TypeError("Cannot setup \"onError\" without a handler function parameter.");
+		this.#contextData ??= {};
+		this.#contextData.onError = handler;
+		return this;
+	}
+	/**
+	* Sets a filter for the interaction collector.
+	* @param predicate - The filter to use for the interaction collector.
+	* @returns This instance of the modal builder.
+	*/
+	filter(predicate) {
+		this.#contextData ??= {
+			autoReset: true,
+			time: 5 * 60 * 1e3
+		};
+		this.#contextData.filter = predicate;
+		return this;
+	}
+	get customId() {
+		return this.data.custom_id ?? this.data.customId;
+	}
+	#setupCollector() {
+		if (!this.#contextData) return;
+		if (!this.customId) throw new TypeError("Cannot setup an modal collector without a custom ID.");
+		const interceptor = this.#getEventInterceptor();
+		if (!interceptor) return;
+		this.#unsub = interceptor.subscribe(discord_js.Events.InteractionCreate, async (interaction) => {
+			var _this$contextData5, _this$unsub;
+			if (!interaction.isRoleSelectMenu()) return;
+			const myCustomId = this.customId ?? null;
+			const interactionCustomId = interaction.customId;
+			if (myCustomId && interactionCustomId !== myCustomId) return;
+			const filter = (_this$contextData5 = this.#contextData) === null || _this$contextData5 === void 0 ? void 0 : _this$contextData5.filter;
+			if (filter && !await filter(interaction)) return;
+			const handler = this.#onSelectHandler;
+			if (!handler) return (_this$unsub = this.#unsub) === null || _this$unsub === void 0 ? void 0 : _this$unsub.call(this);
+			return handler(interaction, this);
+		}, this.#contextData);
+	}
+	dispose() {
+		this.#destroyCollector();
+		return this;
+	}
+	#destroyCollector() {
+		var _this$unsub2;
+		(_this$unsub2 = this.#unsub) === null || _this$unsub2 === void 0 || _this$unsub2.call(this);
+		this.#unsub = null;
+		this.#onSelectHandler = null;
+		this.#contextData = null;
+	}
+};
+
+//#endregion
+//#region src/components/v1/select-menu/SelectMenu.ts
+function applyPropsToBuilder(builder, props) {
+	builder.setCustomId(props.customId ?? `select-menu::${crypto.randomUUID()}`);
+	if (props.maxValues != null) builder.setMaxValues(props.maxValues);
+	if (props.minValues != null) builder.setMinValues(props.minValues);
+	if (props.placeholder) builder.setPlaceholder(props.placeholder);
+	if (props.disabled) builder.setDisabled(props.disabled);
+	if (props.onEnd) builder.onEnd(props.onEnd);
+	if (props.onError) builder.onError(props.onError);
+	if (props.onSelect) builder.onSelect(props.onSelect, props.options);
+}
+function StringSelectMenu(props) {
+	const builder = new StringSelectMenuKit();
+	applyPropsToBuilder(builder, props);
+	if (props.children) builder.setOptions(Array.isArray(props.children) ? props.children : [props.children]);
+	if (props.children) builder.setOptions(Array.isArray(props.children) ? props.children : [props.children]);
+	return builder;
+}
+function StringSelectMenuOption(props) {
+	return new discord_js.StringSelectMenuOptionBuilder(props);
+}
+function UserSelectMenu(props) {
+	const builder = new UserSelectMenuKit();
+	applyPropsToBuilder(builder, props);
+	if (props.defaultValues) builder.setDefaultUsers(Array.isArray(props.defaultValues) ? props.defaultValues : [props.defaultValues]);
+	return builder;
+}
+function RoleSelectMenu(props) {
+	const builder = new RoleSelectMenuKit();
+	applyPropsToBuilder(builder, props);
+	if (props.defaultValues) builder.setDefaultRoles(Array.isArray(props.defaultValues) ? props.defaultValues : [props.defaultValues]);
+	return builder;
+}
+function MentionableSelectMenu(props) {
+	const builder = new MentionableSelectMenuKit();
+	applyPropsToBuilder(builder, props);
+	if (props.defaultValues) builder.setDefaultValues(Array.isArray(props.defaultValues) ? props.defaultValues : [props.defaultValues]);
+	return builder;
+}
+function ChannelSelectMenu(props) {
+	const builder = new ChannelSelectMenuKit();
+	applyPropsToBuilder(builder, props);
+	if (props.defaultValues) builder.setDefaultChannels(Array.isArray(props.defaultValues) ? props.defaultValues : [props.defaultValues]);
+	if (props.channelTypes) builder.setChannelTypes(Array.isArray(props.channelTypes) ? props.channelTypes : [props.channelTypes]);
+	return builder;
+}
+
+//#endregion
+//#region src/logger/DefaultLogger.ts
+var LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1[LogLevel$1["DEBUG"] = 0] = "DEBUG";
+	LogLevel$1[LogLevel$1["INFO"] = 1] = "INFO";
+	LogLevel$1[LogLevel$1["WARN"] = 2] = "WARN";
+	LogLevel$1[LogLevel$1["ERROR"] = 3] = "ERROR";
+	LogLevel$1[LogLevel$1["DEFAULT"] = 4] = "DEFAULT";
+	return LogLevel$1;
+}(LogLevel || {});
+const execHandlerKind = {
+	autocomplete: "Autocomplete",
+	messageContextMenu: "MessageContextMenu",
+	userContextMenu: "UserContextMenu",
+	chatInput: "ChatInputCommand",
+	message: "Message"
+};
+const TextColorMap = {
+	[LogLevel.DEBUG]: require_colors.colors_default.blue,
+	[LogLevel.INFO]: require_colors.colors_default.green,
+	[LogLevel.WARN]: require_colors.colors_default.yellow,
+	[LogLevel.ERROR]: require_colors.colors_default.red,
+	[LogLevel.DEFAULT]: require_colors.colors_default.white
+};
+const TextBgColorMap = {
+	[LogLevel.DEBUG]: require_colors.colors_default.bgBlue,
+	[LogLevel.INFO]: require_colors.colors_default.bgGreen,
+	[LogLevel.WARN]: require_colors.colors_default.bgYellow,
+	[LogLevel.ERROR]: require_colors.colors_default.bgRed,
+	[LogLevel.DEFAULT]: require_colors.colors_default.bgWhite
+};
+const BoxChars = {
+	vertical: "│",
+	horizontalDown: "┬",
+	horizontalUp: "┴",
+	verticalRight: "├",
+	corner: "└"
+};
+var DefaultLogger = class {
+	logger;
+	constructor(stdout = process.stdout, stderr = process.stderr) {
+		this.stdout = stdout;
+		this.stderr = stderr;
+		this.logger = new console.Console(this.stdout, this.stderr);
+	}
+	_formatTime(date) {
+		const hours = date.getHours().toString().padStart(2, "0");
+		const minutes = date.getMinutes().toString().padStart(2, "0");
+		const seconds = date.getSeconds().toString().padStart(2, "0");
+		const millis = date.getMilliseconds().toString().padStart(3, "0");
+		return `${hours}:${minutes}:${seconds}.${millis}`;
+	}
+	_getContext() {
+		const ctx = getContext();
+		if (!ctx) return "";
+		const kind = ctx.variables.get("execHandlerKind");
+		const commandHandler = ctx.variables.get("commandHandlerType");
+		const command = ctx.variables.get("currentCommandName");
+		if (!kind && !commandHandler) return "";
+		const h = execHandlerKind[kind];
+		if (!h && !commandHandler) return "";
+		const forwardedBy = ctx.variables.get("forwardedBy");
+		const forwardedTo = ctx.variables.get("forwardedTo");
+		const cmdText = command ? require_colors.colors_default.magenta(`/${command}`) + " " : "";
+		const forward = forwardedTo ? `${require_colors.colors_default.yellowBright(`(${forwardedBy || command} → ${forwardedTo})`)} ` : "";
+		return require_colors.colors_default.dim(`${BoxChars.vertical} `) + require_colors.colors_default.cyanBright(`${cmdText}${forward}${h ? require_colors.colors_default.gray(`[${h}]`) : ""}`.trim());
+	}
+	_getLevelLabel(level) {
+		let label;
+		switch (level) {
+			case LogLevel.DEBUG:
+				label = "[DEBUG]";
+				break;
+			case LogLevel.INFO:
+				label = "[INFO]";
+				break;
+			case LogLevel.WARN:
+				label = "[WARN]";
+				break;
+			case LogLevel.ERROR:
+				label = "[ERROR]";
+				break;
+			default: label = "[LOG]";
+		}
+		const coloredLabel = TextBgColorMap[level](require_colors.colors_default.whiteBright(` ${label} `));
+		return `${coloredLabel}   `;
+	}
+	_getPrefix(level) {
+		const timestamp = this._formatTime(new Date());
+		const label = this._getLevelLabel(level);
+		return `${label}${require_colors.colors_default.dim(BoxChars.vertical)} ${require_colors.colors_default.dim(timestamp)}`;
+	}
+	_log(level, ...args) {
+		const prefix = this._getPrefix(level);
+		const context$1 = this._getContext();
+		const colorFn = TextColorMap[level];
+		if (context$1) this.logger.log(`${prefix}\n${context$1} ${require_colors.colors_default.dim(BoxChars.corner)}`, ...args.map((arg) => colorFn(arg)));
+		else this.logger.log(`${prefix} ${require_colors.colors_default.dim(BoxChars.corner)}`, ...args.map((arg) => colorFn(arg)));
+	}
+	debug(...args) {
+		this._log(LogLevel.DEBUG, ...args);
+	}
+	error(...args) {
+		this._log(LogLevel.ERROR, ...args);
+	}
+	log(...args) {
+		this._log(LogLevel.DEFAULT, ...args);
+	}
+	info(...args) {
+		this._log(LogLevel.INFO, ...args);
+	}
+	warn(...args) {
+		this._log(LogLevel.WARN, ...args);
+	}
+};
+
+//#endregion
+//#region src/logger/Logger.ts
+function createLogger(options) {
+	let opt = options;
+	if (!(opt === null || opt === void 0 ? void 0 : opt.provider)) throw new Error("A logger provider must be provided.");
+	const methods = [
+		"log",
+		"error",
+		"warn",
+		"info",
+		"debug"
+	];
+	const impl = { configure(options$1) {
+		opt = options$1;
+	} };
+	for (const method of methods) impl[method] = (...args) => {
+		opt.provider[method](...args);
+	};
+	return impl;
+}
+const Logger = createLogger({ provider: new DefaultLogger() });
+
+//#endregion
+//#region src/plugins/plugin-runtime/CommandKitPluginRuntime.ts
+var CommandKitPluginRuntime = class {
+	plugins = new discord_js.Collection();
+	constructor(commandkit$1) {
+		this.commandkit = commandkit$1;
+	}
+	getPlugins() {
+		return this.plugins;
+	}
+	getPlugin(pluginName) {
+		return this.plugins.get(pluginName) ?? null;
+	}
+	async softRegisterPlugin(plugin) {
+		const pluginName = plugin.name;
+		if (this.plugins.has(pluginName)) return;
+		try {
+			await plugin.activate(this);
+			this.plugins.set(pluginName, plugin);
+		} catch (e) {
+			throw new Error(`Failed to activate plugin "${pluginName}": ${(e === null || e === void 0 ? void 0 : e.stack) || e}`);
+		}
+	}
+	async registerPlugin(plugin) {
+		const pluginName = plugin.name;
+		if (this.plugins.has(pluginName)) throw new Error(`Plugin with name "${pluginName}" already exists.`);
+		try {
+			await plugin.activate(this);
+			this.plugins.set(pluginName, plugin);
+		} catch (e) {
+			throw new Error(`Failed to activate plugin "${pluginName}": ${(e === null || e === void 0 ? void 0 : e.stack) || e}`);
+		}
+	}
+	async unregisterPlugin(plugin) {
+		const pluginName = plugin.name;
+		if (!this.plugins.has(pluginName)) throw new Error(`Plugin with name "${pluginName}" does not exist.`);
+		this.plugins.delete(pluginName);
+		try {
+			await plugin.deactivate(this);
+		} catch (e) {
+			throw new Error(`Failed to deactivate plugin "${pluginName}": ${(e === null || e === void 0 ? void 0 : e.stack) || e}`);
+		}
+	}
+	async unregisterAllPlugins() {
+		for (const plugin of this.plugins.values()) await this.unregisterPlugin(plugin);
+	}
+	capture() {
+		throw require_error_codes.createCommandKitError(require_error_codes.CommandKitErrorCodes.PluginCaptureHandle);
+	}
+	async execute(f) {
+		let result;
+		for (const plugin of this.plugins.values()) try {
+			result = await f(this, plugin);
+		} catch (e) {
+			if (require_error_codes.isErrorType(e, require_error_codes.CommandKitErrorCodes.PluginCaptureHandle)) return true;
+			Logger.error(`Plugin "${plugin.name}" failed`, (e === null || e === void 0 ? void 0 : e.stack) || e);
+		}
+		return result;
+	}
+};
+
+//#endregion
+//#region src/plugins/plugin-runtime/builtin/CommonDirectiveTransformer.ts
+var CommonDirectiveTransformer = class extends require_CompilerPlugin.CompilerPlugin {
+	transformer = null;
+	async activate(ctx) {
+		const { createDirectiveTransformer } = await import("directive-to-hof");
+		this.transformer = createDirectiveTransformer(this.options);
+	}
+	async deactivate(ctx) {
+		this.transformer = null;
+	}
+	async transform(params) {
+		if (!this.options.enabled) return null;
+		if (!this.transformer) return null;
+		if (/\.json$/.test(params.id)) return null;
+		const result = await this.transformer(params.code.toString(), params.id);
+		return {
+			code: result.contents,
+			map: null
+		};
+	}
+};
+
+//#endregion
+//#region src/plugins/plugin-runtime/builtin/MacroPlugin.ts
+var MacroPlugin = class extends require_CompilerPlugin.CompilerPlugin {
+	name = "MacroPlugin";
+	macroTransformer;
+	async activate() {
+		const transform = await import("use-macro");
+		this.macroTransformer = new transform.MacroTransformer();
+	}
+	async deactivate() {
+		this.macroTransformer = null;
+	}
+	async transform(params) {
+		if (!this.options.enabled) return null;
+		if (/\.json$/.test(params.id)) return null;
+		const { contents } = await this.macroTransformer.transform(params.code, params.id);
+		return {
+			code: typeof contents === "string" ? contents : new TextDecoder().decode(contents),
+			map: null
+		};
+	}
+};
+
+//#endregion
+//#region src/config/default.ts
+const defaultConfig = {
+	plugins: [new MacroPlugin({ enabled: true })],
+	rolldownPlugins: [(0, __rollup_plugin_json.default)()],
+	compilerOptions: { macro: { development: false } },
+	static: true,
+	typescript: { ignoreBuildErrors: false },
+	distDir: "dist",
+	env: {},
+	sourceMap: {
+		development: true,
+		production: true
+	},
+	typedCommands: true
+};
+
+//#endregion
+//#region src/config/config.ts
+let defined = defaultConfig;
+/**
+* Get the defined configuration for CommandKit.
+*/
+function getConfig() {
+	return defined;
+}
+/**
+* Define the configuration for CommandKit.
+* @param config The configuration to use.
+*/
+function defineConfig(config = {}) {
+	var _config$compilerOptio;
+	defined = {
+		compilerOptions: { macro: {
+			...defaultConfig.compilerOptions.macro,
+			...(_config$compilerOptio = config.compilerOptions) === null || _config$compilerOptio === void 0 ? void 0 : _config$compilerOptio.macro
+		} },
+		distDir: config.distDir ?? defaultConfig.distDir,
+		env: {
+			...defaultConfig.env,
+			...config.env
+		},
+		rolldownPlugins: [...config.rolldownPlugins ?? [], ...defaultConfig.rolldownPlugins ?? []],
+		plugins: [...config.plugins ?? [], ...defaultConfig.plugins ?? []].flat(Infinity),
+		sourceMap: {
+			...defaultConfig.sourceMap,
+			...config.sourceMap
+		},
+		static: config.static ?? defaultConfig.static,
+		typedCommands: config.typedCommands ?? defaultConfig.typedCommands,
+		typescript: {
+			...defaultConfig.typescript,
+			...config.typescript
+		}
+	};
+	return defined;
+}
+
+//#endregion
+//#region src/utils/utilities.ts
+let appDir = null;
+let currentDir = null;
+function getCurrentDirectory() {
+	if (currentDir) return currentDir;
+	let root = (0, node_path.join)(process.cwd(), require_constants.COMMANDKIT_IS_DEV ? ".commandkit" : getConfig().distDir);
+	if (!(0, node_fs.existsSync)(root)) root = process.cwd();
+	currentDir = root;
+	return root;
+}
+function getSourceDirectories() {
+	const dist = getConfig().distDir;
+	const locations = [
+		"src",
+		".commandkit",
+		dist
+	].map((dir) => (0, node_path.join)(process.cwd(), dir));
+	return locations;
+}
+/**
+* Returns the path to the app directory.
+* @returns The path to the app directory or `null` if not found.
+*/
+function findAppDirectory() {
+	if (appDir) return appDir;
+	let root = (0, node_path.join)(process.cwd(), require_constants.COMMANDKIT_IS_DEV ? ".commandkit" : getConfig().distDir);
+	if (!(0, node_fs.existsSync)(root)) root = process.cwd();
+	const dirs = ["app"].map((dir) => (0, node_path.join)(root, dir));
+	for (const dir of dirs) if ((0, node_fs.existsSync)(dir)) {
+		appDir = dir;
+		return dir;
+	}
+	return null;
+}
+/**
+* Debounces a function.
+* @param fn The function to debounce.
+* @param ms The debounce time in milliseconds.
+* @returns The debounced function.
+*/
+function debounce(fn, ms) {
+	let timer = null;
+	let resolve = null;
+	return (...args) => {
+		if (timer) {
+			clearTimeout(timer);
+			if (resolve) resolve(null);
+		}
+		return new Promise((res) => {
+			resolve = res;
+			timer = setTimeout(() => {
+				const result = fn(...args);
+				res(result);
+				timer = null;
+				resolve = null;
+			}, ms);
+		});
+	};
+}
+/**
+* Creates a function from the given function that runs only in development mode.
+* @param fn The function to run in development mode.
+* @returns The function that runs only in development mode.
+* @example
+* ```ts
+* const devOnlyFn = devOnly(() => {
+*   console.log('This function runs only in development mode');
+* });
+* devOnlyFn(); // This will log the message only in development mode
+* ```
+*/
+function devOnly(fn) {
+	const f = (...args) => {
+		if (require_constants.COMMANDKIT_IS_DEV) return fn(...args);
+	};
+	return f;
+}
+/**
+* Custom error for stopping event propagation.
+*/
+var StopEventPropagationError = class extends Error {
+	constructor() {
+		super("Event propagation stopped");
+		this.name = "StopEventPropagationError";
+	}
+};
+/**
+* Stops event propagation.
+* @throws {StopEventPropagationError}
+*/
+function stopEvents() {
+	if (!require_EventWorkerContext.eventWorkerContext.getStore()) throw new Error("stopEvents() may only be called inside an event handler");
+	throw new StopEventPropagationError();
+}
+
+//#endregion
+//#region src/app/register/CommandRegistrar.ts
+var CommandRegistrar = class {
+	api = new discord_js.REST();
+	/**
+	* Creates an instance of CommandRegistrar.
+	* @param commandkit The commandkit instance.
+	*/
+	constructor(commandkit$1) {
+		this.commandkit = commandkit$1;
+		this.api.setToken(this.commandkit.client.token ?? process.env.DISCORD_TOKEN ?? process.env.TOKEN ?? "");
+	}
+	/**
+	* Gets the commands data.
+	*/
+	getCommandsData() {
+		const handler = this.commandkit.commandHandler;
+		const commands = handler.getCommandsArray();
+		return commands.flatMap((cmd) => {
+			const json$1 = "toJSON" in cmd.data.command ? cmd.data.command.toJSON() : cmd.data.command;
+			const collections = [json$1];
+			if (cmd.data.userContextMenu && json$1.type !== discord_js.ApplicationCommandType.User) collections.push({
+				...json$1,
+				type: discord_js.ApplicationCommandType.User,
+				options: void 0,
+				description_localizations: void 0,
+				description: void 0
+			});
+			if (cmd.data.messageContextMenu && json$1.type !== discord_js.ApplicationCommandType.Message) collections.push({
+				...json$1,
+				type: discord_js.ApplicationCommandType.Message,
+				description_localizations: void 0,
+				description: void 0,
+				options: void 0
+			});
+			return collections;
+		});
+	}
+	/**
+	* Registers loaded commands.
+	*/
+	async register() {
+		const commands = this.getCommandsData();
+		let preRegistrationPrevented = false;
+		const preRegisterEvent = {
+			preventDefault() {
+				preRegistrationPrevented = true;
+			},
+			commands
+		};
+		await this.commandkit.plugins.execute(async (ctx, plugin) => {
+			if (preRegistrationPrevented) return;
+			return plugin.onBeforeRegisterCommands(ctx, preRegisterEvent);
+		});
+		if (preRegistrationPrevented) return;
+		if (!this.commandkit.client.isReady()) throw new Error("Cannot register commands before the client is ready");
+		const guildCommands = commands.filter((command) => {
+			var _command$guilds;
+			return (_command$guilds = command.guilds) === null || _command$guilds === void 0 ? void 0 : _command$guilds.filter(Boolean).length;
+		}).map((c) => {
+			var _c$guilds;
+			return {
+				...c,
+				guilds: Array.from(new Set((_c$guilds = c.guilds) === null || _c$guilds === void 0 ? void 0 : _c$guilds.filter(Boolean)))
+			};
+		});
+		const globalCommands = commands.filter((command) => {
+			var _command$guilds2;
+			return !((_command$guilds2 = command.guilds) === null || _command$guilds2 === void 0 ? void 0 : _command$guilds2.filter(Boolean).length);
+		});
+		await this.updateGlobalCommands(globalCommands);
+		await this.updateGuildCommands(guildCommands);
+	}
+	/**
+	* Updates the global commands.
+	*/
+	async updateGlobalCommands(commands) {
+		if (!commands.length) return;
+		let prevented = false;
+		const preRegisterEvent = {
+			preventDefault() {
+				prevented = true;
+			},
+			commands
+		};
+		await this.commandkit.plugins.execute(async (ctx, plugin) => {
+			if (prevented) return;
+			return plugin.onBeforeRegisterGlobalCommands(ctx, preRegisterEvent);
+		});
+		try {
+			const data = await this.api.put(discord_js.Routes.applicationCommands(this.commandkit.client.user.id), { body: commands.map((c) => ({
+				...c,
+				guilds: void 0
+			})) });
+			Logger.info(`✨ Refreshed ${data.length} global application (/) commands`);
+		} catch (e) {
+			Logger.error("Failed to update global application (/) commands", e);
+		}
+	}
+	/**
+	* Updates the guild commands.
+	*/
+	async updateGuildCommands(commands) {
+		if (!commands.length) return;
+		let prevented = false;
+		const preRegisterEvent = {
+			preventDefault() {
+				prevented = true;
+			},
+			commands
+		};
+		await this.commandkit.plugins.execute(async (ctx, plugin) => {
+			if (prevented) return;
+			return plugin.onBeforePrepareGuildCommandsRegistration(ctx, preRegisterEvent);
+		});
+		if (prevented) return;
+		try {
+			const guildCommandsMap = new Map();
+			commands.forEach((command) => {
+				var _command$guilds3;
+				if (!((_command$guilds3 = command.guilds) === null || _command$guilds3 === void 0 ? void 0 : _command$guilds3.length)) return;
+				command.guilds.forEach((guild) => {
+					if (!guildCommandsMap.has(guild)) guildCommandsMap.set(guild, []);
+					guildCommandsMap.get(guild).push(command);
+				});
+			});
+			if (!guildCommandsMap.size) return;
+			let count = 0;
+			for (const [guild, guildCommands] of guildCommandsMap) {
+				let prevented$1 = false;
+				const preRegisterEvent$1 = {
+					preventDefault() {
+						prevented$1 = true;
+					},
+					commands: guildCommands
+				};
+				await this.commandkit.plugins.execute(async (ctx, plugin) => {
+					if (prevented$1) return;
+					return plugin.onBeforeRegisterGuildCommands(ctx, preRegisterEvent$1);
+				});
+				if (prevented$1) continue;
+				const data = await this.api.put(discord_js.Routes.applicationGuildCommands(this.commandkit.client.user.id, guild), { body: guildCommands.map((b) => ({
+					...b,
+					guilds: void 0
+				})) });
+				count += data.length;
+			}
+			Logger.info(`✨ Refreshed ${count} guild application (/) commands`);
+		} catch (e) {
+			Logger.error("Failed to update guild application (/) commands", e);
+		}
+	}
+};
+
+//#endregion
+//#region src/context/environment.ts
+var CommandKitEnvironment = class {
+	#data = {
+		executionError: null,
+		type: null,
+		variables: new Map(),
+		deferredFunctions: new Map(),
+		marker: "",
+		markStart: 0,
+		markEnd: 0,
+		context: null
+	};
+	/**
+	* Creates the commandkit execution environment.
+	* @param commandkit - The commandkit instance.
+	*/
+	constructor(commandkit$1) {
+		this.commandkit = commandkit$1;
+	}
+	/**
+	* Set the context.
+	* @param context - The context to set.
+	*/
+	setContext(context$1) {
+		this.#data.context = context$1;
+	}
+	/**
+	* Get the context. `null` if not set.
+	* @internal
+	*/
+	get context() {
+		return this.#data.context;
+	}
+	/**
+	* Get the execution error.
+	* @internal
+	*/
+	getExecutionError() {
+		return this.#data.executionError;
+	}
+	/**
+	* Set the execution error.
+	* @param error - The error to set.
+	* @internal
+	*/
+	setExecutionError(error) {
+		if (this.#data.executionError) throw new Error("Execution error already set.");
+		this.#data.executionError = error;
+	}
+	/**
+	* Get the environment type.
+	*/
+	getType() {
+		const type = this.#data.type;
+		if (!type) throw new Error("Environment type not set.");
+		return type;
+	}
+	/**
+	* Set the environment type.
+	* @param type - The environment type to set.
+	* @internal
+	*/
+	setType(type) {
+		this.#data.type = type;
+	}
+	/**
+	* The variables store for this environment.
+	*/
+	get variables() {
+		return this.#data.variables;
+	}
+	/**
+	* Register a deferred function.
+	* @param fn - The deferred function to register.
+	* @returns The deferred function id.
+	* @internal
+	*/
+	registerDeferredFunction(fn) {
+		const id = (0, node_crypto.randomUUID)();
+		this.#data.deferredFunctions.set(id, fn);
+		return id;
+	}
+	/**
+	* Clear a deferred function by id.
+	* @param id - The deferred function id to clear.
+	* @internal
+	*/
+	clearDeferredFunction(id) {
+		this.#data.deferredFunctions.delete(id);
+	}
+	/**
+	* Run all deferred functions sequentially.
+	* @internal
+	*/
+	async runDeferredFunctions() {
+		for (const [id, fn] of this.#data.deferredFunctions) try {
+			await fn(this);
+		} catch (e) {
+			this.commandkit.emit("unhandledDeferredFunctionRejection", e);
+		} finally {
+			this.clearDeferredFunction(id);
+		}
+	}
+	/**
+	* Clear all deferred functions.
+	* @internal
+	*/
+	clearAllDeferredFunctions() {
+		this.#data.deferredFunctions.clear();
+	}
+	/**
+	* Mark the start of a command execution.
+	* @param marker - The marker to set.
+	* @internal
+	*/
+	markStart(marker) {
+		this.#data.marker = marker;
+		this.#data.markStart = performance.now();
+	}
+	/**
+	* Mark the end of a command execution.
+	* @internal
+	*/
+	markEnd() {
+		if (!this.#data.markEnd) this.#data.markEnd = performance.now();
+	}
+	/**
+	* Get the marker.
+	* @internal
+	*/
+	getMarker() {
+		return this.#data.marker;
+	}
+	/**
+	* Get the execution time in milliseconds.
+	* @internal
+	*/
+	getExecutionTime() {
+		return Math.abs(this.#data.markEnd - this.#data.markStart);
+	}
+};
+let CommandKitEnvironmentType = /* @__PURE__ */ function(CommandKitEnvironmentType$1) {
+	CommandKitEnvironmentType$1["CommandHandler"] = "COMMAND_HANDLER";
+	return CommandKitEnvironmentType$1;
+}({});
+/**
+* Runs the given function after the current command has finished executing.
+* @param fn The function to run after the current command.
+* @returns The deferred function id. This can be used to cancel the deferred function.
+*/
+function after(fn) {
+	const env = getContext();
+	if (!env) throw new Error("after must be called inside commandkit handler.");
+	return env.registerDeferredFunction(fn);
+}
+/**
+* Cancels a deferred function registered with `after`.
+* @param id The deferred function id to cancel.
+*/
+function cancelAfter(id) {
+	const env = getContext();
+	if (!env) throw new Error("cancelAfter must be called inside commandkit handler.");
+	env.clearDeferredFunction(id);
+}
+
+//#endregion
+//#region src/app/commands/Context.ts
+const CommandExecutionMode = {
+	ChatInputCommand: "chatInput",
+	MessageContextMenu: "messageContextMenu",
+	UserContextMenu: "userContextMenu",
+	Autocomplete: "autocomplete",
+	Message: "message"
+};
+var Context = class Context {
+	/**
+	* The interaction that triggered the command.
+	*/
+	interaction;
+	/**
+	* The message that triggered the command.
+	*/
+	message;
+	/**
+	* The guild where the command was triggered.
+	*/
+	guild;
+	/**
+	* The guild ID where the command was triggered.
+	*/
+	guildId;
+	/**
+	* The channel where the command was triggered.
+	*/
+	channel;
+	/**
+	* The channel id where the command was triggered.
+	*/
+	channelId;
+	/**
+	* The client instance.
+	*/
+	client;
+	/**
+	* The command that this context belongs to.
+	*/
+	command;
+	#store;
+	_locale = null;
+	/**
+	* Creates a new command context.
+	* @param commandkit The command kit instance.
+	* @param config The context parameters.
+	*/
+	constructor(commandkit$1, config) {
+		this.commandkit = commandkit$1;
+		this.config = config;
+		this.interaction = config.interaction;
+		this.message = config.message;
+		this.client = commandkit$1.client;
+		this.#store = config.store ?? new Map();
+		this.command = config.command;
+		if (config.interaction) {
+			this.guild = config.interaction.guild;
+			this.guildId = config.interaction.guildId;
+			this.channel = config.interaction.channel;
+			this.channelId = config.interaction.channelId;
+		}
+		if (config.message) {
+			this.guild = config.message.guild;
+			this.guildId = config.message.guildId;
+			this.channel = config.message.channel;
+			this.channelId = config.message.channelId;
+		}
+		if (this.config.environment) this.config.environment.setContext(this);
+	}
+	/**
+	* The shared key-value store for this context. This can be used to store data that needs to be shared between middlewares or commands.
+	* This store is shared across all contexts in the same command execution, including the cloned contexts and middleware contexts.
+	*/
+	get store() {
+		return this.#store;
+	}
+	get commandName() {
+		if (this.isInteraction()) return this.interaction.commandName;
+		else return this.config.messageCommandParser.getCommand();
+	}
+	get options() {
+		if (this.isMessage()) {
+			const parser = this.config.messageCommandParser;
+			return parser.options;
+		} else {
+			const interaction = this.interaction;
+			return interaction.options;
+		}
+	}
+	/**
+	* Whether this context was forwarded from another context. This happens when a command forwards its context to another command.
+	*/
+	get forwarded() {
+		return this.config.forwarded ?? false;
+	}
+	/**
+	* Forwards the context to another command. The target handler will be the same as current handler.
+	* @param command The command to forward to.
+	*/
+	async forwardCommand(command) {
+		const target = await this.commandkit.commandHandler.prepareCommandRun(this.isInteraction() ? this.interaction : this.message, command);
+		if (!target) throw new Error(`Command ${command} not found`);
+		const env = this.config.environment ?? getContext();
+		if (!env) throw new Error("No commandkit environment found.");
+		const handlers = {
+			chatInput: target.command.data.chatInput,
+			autocomplete: target.command.data.autocomplete,
+			message: target.command.data.message,
+			messageContextMenu: target.command.data.messageContextMenu,
+			userContextMenu: target.command.data.userContextMenu
+		};
+		const handlerKind = env.variables.get("execHandlerKind");
+		if (!handlerKind) throw new Error("No execution handler kind found.");
+		const handler = handlers[handlerKind];
+		if (!handler) throw new Error(`No handler found for ${handlerKind}`);
+		env.variables.set("forwardedBy", this.commandName);
+		env.variables.set("forwardedTo", command);
+		await handler(this.clone({ forwarded: true }));
+		require_signals.redirect();
+	}
+	/**
+	* The execution mode of the command.
+	*/
+	get executionMode() {
+		return this.config.executionMode;
+	}
+	/**
+	* Whether the command was triggered by an interaction.
+	*/
+	isInteraction() {
+		return this.executionMode === CommandExecutionMode.ChatInputCommand || this.executionMode === CommandExecutionMode.Autocomplete || this.executionMode === CommandExecutionMode.MessageContextMenu || this.executionMode === CommandExecutionMode.UserContextMenu;
+	}
+	/**
+	* Whether the command was triggered by a slash command interaction.
+	*/
+	isChatInputCommand() {
+		return this.executionMode === CommandExecutionMode.ChatInputCommand;
+	}
+	/**
+	* Whether the command was triggered by an autocomplete interaction.
+	*/
+	isAutocomplete() {
+		return this.executionMode === CommandExecutionMode.Autocomplete;
+	}
+	/**
+	* Whether the command was triggered by a message context menu interaction.
+	*/
+	isMessageContextMenu() {
+		return this.executionMode === CommandExecutionMode.MessageContextMenu;
+	}
+	/**
+	* Whether the command was triggered by a user context menu interaction.
+	*/
+	isUserContextMenu() {
+		return this.executionMode === CommandExecutionMode.UserContextMenu;
+	}
+	/**
+	* Whether the command was triggered by a message.
+	*/
+	isMessage() {
+		return this.executionMode === CommandExecutionMode.Message;
+	}
+	/**
+	* Returns the command identifier.
+	*/
+	getCommandIdentifier() {
+		if (this.isInteraction()) return this.interaction.commandName;
+		else return this.message.content.split(" ")[0].slice(1);
+	}
+	/**
+	* Returns the locale of the guild where this command was triggered.
+	*/
+	getGuildLocale() {
+		if (this.isInteraction()) return this.interaction.guildLocale;
+		else {
+			var _this$message$guild;
+			return ((_this$message$guild = this.message.guild) === null || _this$message$guild === void 0 ? void 0 : _this$message$guild.preferredLocale) ?? null;
+		}
+	}
+	/**
+	* Returns the locale of the user who triggered this command.
+	*/
+	getUserLocale() {
+		if (this.isInteraction()) return this.interaction.locale;
+		else return null;
+	}
+	/**
+	* Returns the locale for this command.
+	* @param preferUser Whether to prefer the user's locale over the guild's locale.
+	* @returns The locale for this command. If no locale is found, the default locale is returned.
+	*/
+	getLocale(preferUser = false) {
+		if (this._locale) return this._locale;
+		const locale = preferUser ? this.getUserLocale() : this.getGuildLocale();
+		if (!locale) return this.commandkit.config.defaultLocale;
+		return locale;
+	}
+	/**
+	* Sets the locale for this command.
+	* @param locale The locale to set.
+	*/
+	setLocale(locale) {
+		this._locale = locale;
+	}
+	/**
+	* Creates a clone of this context
+	*/
+	clone(config) {
+		if (!config) return new Context(this.commandkit, this.config);
+		const ctx = new Context(this.commandkit, {
+			...this.config,
+			...config,
+			store: this.#store
+		});
+		return ctx;
+	}
+	isMiddleware() {
+		return this instanceof MiddlewareContext;
+	}
+	args() {
+		if (this.isMessage()) return this.config.messageCommandParser.getArgs();
+		return [];
+	}
+	/**
+	* Stops upcoming middleware or current command execution.
+	* If this is called inside pre-stage middleware, the next run will be the actual command, skipping all other pre-stage middlewares.
+	* If this is called inside a command itself, it will skip all post-stage middlewares.
+	* If this is called inside post-stage middleware, it will skip all other post-stage middlewares.
+	*/
+	exit() {
+		require_signals.exitMiddleware();
+	}
+};
+var MiddlewareContext = class extends Context {
+	#cancel = false;
+	/**
+	* Whether the command execution was cancelled.
+	*/
+	get cancelled() {
+		return this.#cancel;
+	}
+	/**
+	* Cancels the command execution.
+	*/
+	cancel() {
+		this.#cancel = true;
+	}
+	/**
+	* Sets command runner function to wrap the command execution.
+	* @param fn The function to set.
+	* @example ctx.setCommandRunner(async (execute) => {
+	*  // do something before command execution
+	*  await execute();
+	*  // do something after command execution
+	* })
+	*/
+	setCommandRunner(fn) {
+		var _this$config$customAr, _this$config$customAr2;
+		(_this$config$customAr = this.config.customArgs) === null || _this$config$customAr === void 0 || (_this$config$customAr2 = _this$config$customAr.setCommandRunner) === null || _this$config$customAr2 === void 0 || _this$config$customAr2.call(_this$config$customAr, fn);
+	}
+};
+
+//#endregion
+//#region src/app/commands/AppCommandRunner.ts
+var AppCommandRunner = class {
+	constructor(handler) {
+		this.handler = handler;
+	}
+	async runCommand(prepared, source) {
+		const { commandkit: commandkit$1 } = this.handler;
+		const executionMode = this.getExecutionMode(source);
+		let runCommand = null;
+		const env = new CommandKitEnvironment(commandkit$1);
+		env.setType(CommandKitEnvironmentType.CommandHandler);
+		env.variables.set("commandHandlerType", "app");
+		env.variables.set("currentCommandName", prepared.command.command.name);
+		env.variables.set("execHandlerKind", executionMode);
+		const ctx = new MiddlewareContext(commandkit$1, {
+			command: prepared.command,
+			environment: env,
+			executionMode,
+			interaction: !(source instanceof discord_js.Message) ? source : null,
+			message: source instanceof discord_js.Message ? source : null,
+			forwarded: false,
+			customArgs: { setCommandRunner: (fn) => {
+				runCommand = fn;
+			} },
+			messageCommandParser: prepared.messageCommandParser
+		});
+		let middlewaresCanceled = false;
+		if (prepared.middlewares.length) await provideContext(env, async () => {
+			for (const middleware of prepared.middlewares) {
+				if (!middleware.data.beforeExecute) continue;
+				try {
+					await middleware.data.beforeExecute(ctx);
+				} catch (e) {
+					if (require_error_codes.isErrorType(e, require_error_codes.CommandKitErrorCodes.ExitMiddleware)) {
+						middlewaresCanceled = true;
+						return;
+					}
+					if (require_error_codes.isErrorType(e, [require_error_codes.CommandKitErrorCodes.ForwardedCommand, require_error_codes.CommandKitErrorCodes.InvalidCommandPrefix])) continue;
+					throw e;
+				}
+			}
+		});
+		if (!ctx.cancelled) {
+			const targetData = prepared.command.data;
+			const fn = targetData[executionMode];
+			if (!fn) Logger.warn(`Command ${prepared.command.command.name} has no handler for ${executionMode}`);
+			if (fn) try {
+				const _executeCommand = makeContextAwareFunction(env, async () => {
+					env.registerDeferredFunction((env$1) => {
+						env$1.markEnd();
+						const error = env$1.getExecutionError();
+						const marker = env$1.getMarker();
+						const time = `${env$1.getExecutionTime().toFixed(2)}ms`;
+						if (error) {
+							Logger.error(`[${marker} - ${time}] Error executing command: ${error.stack || error}`);
+							return;
+						}
+						Logger.info(`[${marker} - ${time}] Command executed successfully`);
+					});
+					return fn(ctx.clone());
+				}, this.#finalizer.bind(this));
+				const executeCommand = runCommand != null ? runCommand(_executeCommand) : _executeCommand;
+				env.markStart(prepared.command.data.command.name);
+				const res = await commandkit$1.plugins.execute(async (ctx$1, plugin) => {
+					return plugin.executeCommand(ctx$1, env, source, prepared, executeCommand);
+				});
+				if (!res) await executeCommand();
+			} catch (e) {
+				if (require_error_codes.isErrorType(e, require_error_codes.CommandKitErrorCodes.ExitMiddleware)) middlewaresCanceled = true;
+				if (!require_error_codes.isErrorType(e, [require_error_codes.CommandKitErrorCodes.ForwardedCommand, require_error_codes.CommandKitErrorCodes.ExitMiddleware])) Logger.error(e);
+			}
+		}
+		if (!middlewaresCanceled && prepared.middlewares.length) await provideContext(env, async () => {
+			for (const middleware of prepared.middlewares) {
+				if (!middleware.data.afterExecute) continue;
+				try {
+					await middleware.data.afterExecute(ctx);
+				} catch (e) {
+					if (require_error_codes.isErrorType(e, require_error_codes.CommandKitErrorCodes.ExitMiddleware)) return;
+					throw e;
+				}
+			}
+		});
+	}
+	async #finalizer() {
+		const env = useEnvironment();
+		await env.runDeferredFunctions();
+		env.clearAllDeferredFunctions();
+		await this.handler.commandkit.plugins.execute(async (ctx, plugin) => {
+			await plugin.onAfterCommand(ctx, env);
+		});
+	}
+	getExecutionMode(source) {
+		if (source instanceof discord_js.Message) return CommandExecutionMode.Message;
+		if (source.isChatInputCommand()) return CommandExecutionMode.ChatInputCommand;
+		if (source.isAutocomplete()) return CommandExecutionMode.Autocomplete;
+		if (source.isMessageContextMenuCommand()) return CommandExecutionMode.MessageContextMenu;
+		if (source.isUserContextMenuCommand()) return CommandExecutionMode.UserContextMenu;
+		return null;
+	}
+};
+
+//#endregion
+//#region src/app/handlers/AppCommandHandler.ts
+const commandDataSchema = {
+	command: (c) => c instanceof discord_js.SlashCommandBuilder || c instanceof discord_js.ContextMenuCommandBuilder || c && typeof c === "object",
+	chatInput: (c) => typeof c === "function",
+	autocomplete: (c) => typeof c === "function",
+	message: (c) => typeof c === "function",
+	messageContextMenu: (c) => typeof c === "function",
+	userContextMenu: (c) => typeof c === "function"
+};
+const middlewareDataSchema = {
+	beforeExecute: (c) => typeof c === "function",
+	afterExecute: (c) => typeof c === "function"
+};
+var AppCommandHandler = class {
+	loadedCommands = new discord_js.Collection();
+	loadedMiddlewares = new discord_js.Collection();
+	commandNameToId = new Map();
+	subcommandPathToId = new Map();
+	registrar;
+	onInteraction = null;
+	onMessageCreate = null;
+	commandRunner = new AppCommandRunner(this);
+	externalCommandData = new discord_js.Collection();
+	externalMiddlewareData = new discord_js.Collection();
+	constructor(commandkit$1) {
+		this.commandkit = commandkit$1;
+		this.registrar = new CommandRegistrar(this.commandkit);
+	}
+	printBanner() {
+		const uncategorized = crypto.randomUUID();
+		const categorizedCommands = this.getCommandsArray().reduce((acc, cmd) => {
+			const category = cmd.command.category || uncategorized;
+			acc[category] = acc[category] || [];
+			acc[category].push(cmd);
+			return acc;
+		}, {});
+		console.log(require_colors.colors_default.green(`Loaded ${require_colors.colors_default.magenta(this.loadedCommands.size.toString())} commands:`));
+		const categories = Object.keys(categorizedCommands).sort();
+		const categoryTree = {};
+		categories.forEach((category) => {
+			if (category === uncategorized) return;
+			if (category.includes(":")) {
+				const parts = category.split(":");
+				let bestParent = null;
+				for (let i = parts.length - 1; i > 0; i--) {
+					const potentialParent = parts.slice(0, i).join(":");
+					if (categories.includes(potentialParent)) {
+						bestParent = potentialParent;
+						break;
+					}
+				}
+				if (bestParent) {
+					categoryTree[bestParent] = categoryTree[bestParent] || [];
+					categoryTree[bestParent].push(category);
+				}
+			}
+		});
+		const processedCategories = new Set();
+		const printCategory = (category, indent = "", isLast = false, parentPrefix = "") => {
+			if (processedCategories.has(category)) return;
+			processedCategories.add(category);
+			const commands = categorizedCommands[category];
+			const hasChildren = categoryTree[category] && categoryTree[category].length > 0;
+			const thisPrefix = isLast ? "└─" : "├─";
+			const childIndent = parentPrefix + (isLast ? "   " : "│  ");
+			if (category !== uncategorized) {
+				const displayName = category.includes(":") ? category.split(":").pop() : category;
+				console.log(require_colors.colors_default.cyan(`${indent}${thisPrefix} ${require_colors.colors_default.bold(displayName)}`));
+			}
+			commands.forEach((cmd, cmdIndex) => {
+				const cmdIsLast = cmdIndex === commands.length - 1 && !hasChildren;
+				const cmdPrefix = cmdIsLast ? "└─" : "├─";
+				const cmdIndent = category !== uncategorized ? childIndent : indent;
+				const name = cmd.data.command.name;
+				const hasMw = cmd.command.middlewares.length > 0;
+				const middlewareIcon = hasMw ? require_colors.colors_default.magenta(" (λ)") : "";
+				console.log(`${require_colors.colors_default.green(`${cmdIndent}${cmdPrefix}`)} ${require_colors.colors_default.yellow(name)}${middlewareIcon}`);
+			});
+			if (hasChildren) {
+				const children = categoryTree[category].sort();
+				children.forEach((childCategory, idx) => {
+					const childIsLast = idx === children.length - 1;
+					printCategory(childCategory, childIndent, childIsLast, childIndent);
+				});
+			}
+		};
+		const topLevelCategories = categories.filter((category) => {
+			if (category === uncategorized) return true;
+			if (category.includes(":")) {
+				const parts = category.split(":");
+				for (let i = 1; i < parts.length; i++) {
+					const parentPath = parts.slice(0, i).join(":");
+					if (categories.includes(parentPath)) return false;
+				}
+				return true;
+			}
+			return true;
+		}).sort();
+		topLevelCategories.forEach((category, index) => {
+			const isLast = index === topLevelCategories.length - 1;
+			printCategory(category, "", isLast);
+		});
+	}
+	getCommandsArray() {
+		return Array.from(this.loadedCommands.values());
+	}
+	registerCommandHandler() {
+		this.onInteraction ??= async (interaction) => {
+			const success = await this.commandkit.plugins.execute(async (ctx, plugin) => {
+				return plugin.onBeforeInteraction(ctx, interaction);
+			});
+			if (success) return;
+			const isCommandLike = interaction.isCommand() || interaction.isAutocomplete() || interaction.isUserContextMenuCommand() || interaction.isMessageContextMenuCommand();
+			if (!isCommandLike) return;
+			const prepared = await this.prepareCommandRun(interaction);
+			if (!prepared) return;
+			return this.commandRunner.runCommand(prepared, interaction);
+		};
+		this.onMessageCreate ??= async (message) => {
+			const success = await this.commandkit.plugins.execute(async (ctx, plugin) => {
+				return plugin.onBeforeMessageCommand(ctx, message);
+			});
+			if (success) return;
+			if (message.author.bot) return;
+			const prepared = await this.prepareCommandRun(message);
+			if (!prepared) return;
+			return this.commandRunner.runCommand(prepared, message);
+		};
+		this.commandkit.client.on(discord_js.Events.InteractionCreate, this.onInteraction);
+		this.commandkit.client.on(discord_js.Events.MessageCreate, this.onMessageCreate);
+	}
+	async prepareCommandRun(source, cmdName) {
+		var _loadedCommand$guilds2;
+		let parser;
+		if (!cmdName) if (source instanceof discord_js.Message) {
+			if (source.author.bot) return null;
+			const prefix = await this.commandkit.config.getMessageCommandPrefix(source);
+			parser = new require_MessageCommandParser.MessageCommandParser(source, Array.isArray(prefix) ? prefix : [prefix], (command) => {
+				var _loadedCommand$guilds, _json$options;
+				const commandId$1 = this.commandNameToId.get(command);
+				if (!commandId$1) return null;
+				const loadedCommand$1 = this.loadedCommands.get(commandId$1);
+				if (!loadedCommand$1) return null;
+				if (source.guildId && ((_loadedCommand$guilds = loadedCommand$1.guilds) === null || _loadedCommand$guilds === void 0 ? void 0 : _loadedCommand$guilds.length) && !loadedCommand$1.guilds.includes(source.guildId)) return null;
+				const json$1 = "toJSON" in loadedCommand$1.data.command ? loadedCommand$1.data.command.toJSON() : loadedCommand$1.data.command;
+				return ((_json$options = json$1.options) === null || _json$options === void 0 ? void 0 : _json$options.reduce((acc, opt) => {
+					acc[opt.name] = opt.type;
+					return acc;
+				}, {})) ?? {};
+			});
+			try {
+				const fullCommand = parser.getFullCommand();
+				const parts = fullCommand.split(" ");
+				cmdName = parts[0];
+			} catch (e) {
+				if (require_error_codes.isErrorType(e, require_error_codes.CommandKitErrorCodes.InvalidCommandPrefix)) return null;
+				Logger.error(e);
+				return null;
+			}
+		} else {
+			const isAnyCommand = source.isChatInputCommand() || source.isAutocomplete() || source.isContextMenuCommand();
+			if (!isAnyCommand) return null;
+			cmdName = source.commandName;
+		}
+		const commandId = this.commandNameToId.get(cmdName);
+		if (!commandId) return null;
+		const loadedCommand = this.loadedCommands.get(commandId);
+		if (!loadedCommand) return null;
+		if ((source instanceof discord_js.CommandInteraction || source instanceof discord_js.AutocompleteInteraction) && source.guildId && ((_loadedCommand$guilds2 = loadedCommand.guilds) === null || _loadedCommand$guilds2 === void 0 ? void 0 : _loadedCommand$guilds2.length) && !loadedCommand.guilds.includes(source.guildId)) return null;
+		const middlewares = [];
+		for (const middlewareId of loadedCommand.command.middlewares) {
+			const middleware = this.loadedMiddlewares.get(middlewareId);
+			if (middleware) middlewares.push(middleware);
+		}
+		return {
+			command: loadedCommand,
+			middlewares,
+			messageCommandParser: parser
+		};
+	}
+	async reloadCommands() {
+		this.loadedCommands.clear();
+		this.loadedMiddlewares.clear();
+		this.commandNameToId.clear();
+		this.subcommandPathToId.clear();
+		this.externalCommandData.clear();
+		this.externalMiddlewareData.clear();
+		await this.loadCommands();
+	}
+	async addExternalMiddleware(data) {
+		for (const middleware of data) {
+			if (!middleware.id) continue;
+			this.externalMiddlewareData.set(middleware.id, middleware);
+		}
+	}
+	async addExternalCommands(data) {
+		for (const command of data) {
+			if (!command.id) continue;
+			this.externalCommandData.set(command.id, command);
+		}
+	}
+	async registerExternalLoadedMiddleware(data) {
+		for (const middleware of data) this.loadedMiddlewares.set(middleware.middleware.id, middleware);
+	}
+	async registerExternalLoadedCommands(data) {
+		for (const command of data) {
+			this.loadedCommands.set(command.command.id, command);
+			this.commandNameToId.set(command.command.name, command.command.id);
+		}
+	}
+	async loadCommands() {
+		await this.commandkit.plugins.execute((ctx, plugin) => {
+			return plugin.onBeforeCommandsLoad(ctx);
+		});
+		const commandsRouter = this.commandkit.commandsRouter;
+		if (!commandsRouter) throw new Error("Commands router has not yet initialized");
+		const { commands, middlewares } = commandsRouter.getData();
+		const combinedCommands = this.externalCommandData.size ? commands.concat(this.externalCommandData) : commands;
+		const combinedMiddlewares = this.externalMiddlewareData.size ? middlewares.concat(this.externalMiddlewareData) : middlewares;
+		for (const [id, middleware] of combinedMiddlewares) await this.loadMiddleware(id, middleware);
+		for (const [id, command] of combinedCommands) await this.loadCommand(id, command);
+		if (require_constants.COMMANDKIT_IS_DEV) await require_types_package.rewriteCommandDeclaration(`type CommandTypeData = ${Array.from(this.loadedCommands.mapValues((v) => JSON.stringify(v.command.name)).values()).join(" | ")}`);
+		await this.commandkit.plugins.execute((ctx, plugin) => {
+			return plugin.onAfterCommandsLoad(ctx);
+		});
+	}
+	async loadMiddleware(id, middleware) {
+		try {
+			const data = await import(`${require_resolve_file_url.toFileURL(middleware.path)}?t=${Date.now()}`);
+			let handlerCount = 0;
+			for (const [key, validator] of Object.entries(middlewareDataSchema)) {
+				if (data[key] && !await validator(data[key])) throw new Error(`Invalid export for middleware ${id}: ${key} does not match expected value`);
+				if (data[key]) handlerCount++;
+			}
+			if (handlerCount === 0) throw new Error(`Invalid export for middleware ${id}: at least one handler function must be provided`);
+			this.loadedMiddlewares.set(id, {
+				middleware,
+				data
+			});
+		} catch (error) {
+			Logger.error(`Failed to load middleware ${id}`, error);
+		}
+	}
+	async loadCommand(id, command) {
+		try {
+			if (command.path === null) {
+				this.loadedCommands.set(id, {
+					command,
+					data: { command: {
+						name: command.name,
+						description: `${command.name} commands`,
+						type: 1
+					} }
+				});
+				return;
+			}
+			const data = await import(`${require_resolve_file_url.toFileURL(command.path)}?t=${Date.now()}`);
+			if (!data.command) throw new Error(`Invalid export for command ${command.name}: no command definition found`);
+			let handlerCount = 0;
+			for (const [key, validator] of Object.entries(commandDataSchema)) {
+				if (key !== "command" && data[key]) handlerCount++;
+				if (data[key] && !await validator(data[key])) throw new Error(`Invalid export for command ${command.name}: ${key} does not match expected value`);
+			}
+			if (handlerCount === 0) throw new Error(`Invalid export for command ${command.name}: at least one handler function must be provided`);
+			let lastUpdated = data.command;
+			await this.commandkit.plugins.execute(async (ctx, plugin) => {
+				const res = await plugin.prepareCommand(ctx, lastUpdated);
+				if (res) lastUpdated = res;
+			});
+			this.loadedCommands.set(id, {
+				command,
+				guilds: data.guilds,
+				data: {
+					...data,
+					command: "toJSON" in lastUpdated ? lastUpdated.toJSON() : lastUpdated
+				}
+			});
+			this.commandNameToId.set(command.name, id);
+		} catch (error) {
+			Logger.error(`Failed to load command ${command.name} (${id})`, error);
+		}
+	}
+};
+
+//#endregion
+//#region src/app/handlers/AppEventsHandler.ts
+var AppEventsHandler = class {
+	loadedEvents = new discord_js.Collection();
+	constructor(commandkit$1) {
+		this.commandkit = commandkit$1;
+	}
+	getEvents() {
+		if (this.loadedEvents.size === 0) return [];
+		const events = this.loadedEvents.toJSON();
+		return events.map((event) => ({
+			name: event.name,
+			namespace: event.namespace,
+			onceListeners: event.listeners.filter((listener) => listener.once).length,
+			regularListeners: event.listeners.filter((listener) => !listener.once).length,
+			metadata: event.event
+		}));
+	}
+	async reloadEvents() {
+		this.unregisterAll();
+		await this.loadEvents();
+	}
+	async loadEvents() {
+		await this.commandkit.plugins.execute((ctx, plugin) => {
+			return plugin.onBeforeEventsLoad(ctx);
+		});
+		const router = this.commandkit.eventsRouter;
+		const events = await router.scan();
+		for (const event of Object.values(events)) {
+			const listeners = [];
+			for (const listener of event.listeners) {
+				const handler = await import(require_resolve_file_url.toFileURL(listener, true));
+				if (!handler.default || typeof handler.default !== "function") Logger.error(`Event handler for ${event.event}${event.namespace ? ` of namespace ${event.namespace}` : ""} does not have a default export or is not a function`);
+				listeners.push({
+					handler: handler.default,
+					once: !!handler.once
+				});
+			}
+			const len = listeners.length;
+			if (!len) Logger.warn(`Event ${event.event}${event.namespace ? ` of namespace ${event.namespace}` : ""} does not have any listeners`);
+			const key = `${event.namespace ? `${event.namespace}:` : ""}${event.event}`;
+			this.loadedEvents.set(key, {
+				name: event.event,
+				namespace: event.namespace,
+				event,
+				listeners
+			});
+			Logger.info(`✨ Loaded event ${event.event}${event.namespace ? ` of namespace ${event.namespace}` : ""} with ${len} listener${len === 1 ? "" : "s"}`);
+		}
+		this.registerAllClientEvents();
+		await this.commandkit.plugins.execute((ctx, plugin) => {
+			return plugin.onAfterEventsLoad(ctx);
+		});
+	}
+	unregisterAll() {
+		this.unregisterAllClientListeners();
+		this.loadedEvents.clear();
+	}
+	registerAllClientEvents() {
+		const client = this.commandkit.client;
+		for (const [key, data] of this.loadedEvents.entries()) {
+			const { name, listeners, namespace } = data;
+			const onceListeners = listeners.filter((listener) => listener.once);
+			const onListeners = listeners.filter((listener) => !listener.once);
+			const executedOnceListeners = new Set();
+			const mainHandler = async (...args) => {
+				let accepted = false;
+				const event = {
+					name,
+					args,
+					namespace: namespace ?? null,
+					once: false,
+					metadata: data.event,
+					accept() {
+						if (accepted) return;
+						accepted = true;
+					}
+				};
+				await this.commandkit.plugins.execute(async (ctx, plugin) => {
+					var _plugin$willEmitEvent;
+					if (accepted) return;
+					return (_plugin$willEmitEvent = plugin.willEmitEvent) === null || _plugin$willEmitEvent === void 0 ? void 0 : _plugin$willEmitEvent.call(plugin, ctx, event);
+				}).catch(Object);
+				await require_EventWorkerContext.runInEventWorkerContext({
+					event: name,
+					namespace: namespace ?? null,
+					data: data.event,
+					commandkit: this.commandkit,
+					arguments: args
+				}, async () => {
+					for (const listener of onListeners) try {
+						await listener.handler(...args);
+					} catch (e) {
+						if (e instanceof StopEventPropagationError) {
+							Logger.debug(`Event propagation stopped for ${name}${namespace ? ` of namespace ${namespace}` : ""}`);
+							break;
+						}
+						Logger.error(`Error handling event ${name}${namespace ? ` of namespace ${namespace}` : ""}`, e);
+					}
+				});
+			};
+			const onceHandler = async (...args) => {
+				let broken = false;
+				let accepted = false;
+				const event = {
+					name,
+					args,
+					namespace: namespace ?? null,
+					once: true,
+					metadata: data.event,
+					accept() {
+						if (accepted) return;
+						accepted = true;
+					}
+				};
+				await this.commandkit.plugins.execute(async (ctx, plugin) => {
+					var _plugin$willEmitEvent2;
+					if (accepted) return;
+					return (_plugin$willEmitEvent2 = plugin.willEmitEvent) === null || _plugin$willEmitEvent2 === void 0 ? void 0 : _plugin$willEmitEvent2.call(plugin, ctx, event);
+				}).catch(Object);
+				for (const listener of onceListeners) {
+					if (broken) break;
+					await require_EventWorkerContext.runInEventWorkerContext({
+						event: name,
+						namespace: namespace ?? null,
+						data: data.event,
+						commandkit: this.commandkit,
+						arguments: args
+					}, async () => {
+						try {
+							if (executedOnceListeners.has(listener.handler)) return;
+							await listener.handler(...args);
+							executedOnceListeners.add(listener.handler);
+						} catch (e) {
+							if (e instanceof StopEventPropagationError) {
+								Logger.debug(`Event propagation stopped for ${name}${namespace ? ` of namespace ${namespace}` : ""}`);
+								broken = true;
+							}
+							Logger.error(`Error handling event ${name}${namespace ? ` of namespace ${namespace}` : ""}`, e);
+						}
+					});
+				}
+				if (executedOnceListeners.size === onceListeners.length && onListeners.length === 0) {
+					this.loadedEvents.delete(key);
+					Logger.info(`🧹 Cleaned up completed once-only event ${name}${namespace ? ` of namespace ${namespace}` : ""}`);
+				}
+			};
+			this.loadedEvents.set(key, {
+				...data,
+				mainListener: onListeners.length > 0 ? {
+					handler: mainHandler,
+					once: false
+				} : void 0,
+				executedOnceListeners
+			});
+			if (namespace) {
+				if (onListeners.length > 0) this.commandkit.events.on(namespace, name, mainHandler);
+				if (onceListeners.length > 0) this.commandkit.events.once(namespace, name, onceHandler);
+			} else {
+				if (onListeners.length > 0) client.on(name, mainHandler);
+				if (onceListeners.length > 0) client.once(name, onceHandler);
+			}
+			Logger.info(`🔌 Registered event ${name}${namespace ? ` of namespace ${namespace}` : ""} (${onListeners.length} regular, ${onceListeners.length} once-only)`);
+		}
+	}
+	unregisterAllClientListeners() {
+		const client = this.commandkit.client;
+		for (const [key, { name, mainListener, namespace }] of this.loadedEvents.entries()) {
+			if (mainListener) if (namespace) this.commandkit.events.off(namespace, name, mainListener.handler);
+			else client.off(name, mainListener.handler);
+			else if (namespace) this.commandkit.events.removeAllListeners(namespace, name);
+			else client.removeAllListeners(name);
+			this.loadedEvents.delete(key);
+			Logger.info(`🗑️ Unregistered event ${name}${namespace ? ` of namespace ${namespace}` : ""}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/config/loader.ts
+const CONFIG_FILE_NAMES = [
+	"commandkit.config.js",
+	"commandkit.config.mjs",
+	"commandkit.config.cjs",
+	"commandkit.config.ts"
+];
+function getPossibleConfigPaths(root) {
+	return CONFIG_FILE_NAMES.map((name) => (0, node_path.join)(root, name));
+}
+function findConfigFile(cwd) {
+	const locations = getPossibleConfigPaths(cwd);
+	for (const location of locations) if ((0, node_fs.existsSync)(location)) return {
+		path: location,
+		isTypeScript: /\.ts$/.test(location)
+	};
+	return null;
+}
+let loadedConfig = null;
+/**
+* Load the configuration file from the given entrypoint.
+* @param entrypoint The entrypoint to load the configuration file from. Defaults to the current working directory.
+*/
+async function loadConfigFile(entrypoint = process.cwd()) {
+	if (loadedConfig) return loadedConfig;
+	const filePath = findConfigFile(entrypoint);
+	if (!filePath) return getConfig();
+	const config = await require_common.loadConfigFileFromPath(filePath.path);
+	loadedConfig = config;
+	return config;
+}
+
+//#endregion
+//#region src/utils/dev-hooks.ts
+function registerDevHooks(commandkit$1) {
+	if (!require_constants.COMMANDKIT_IS_DEV) return;
+	process.on("message", async (message) => {
+		if (typeof message !== "object" || message === null) return;
+		const { event, path, id } = message;
+		if (!event) return;
+		if (process.env.COMMANDKIT_DEBUG_HMR === "true") Logger.info(`Received HMR event: ${event}${path ? ` for ${path}` : ""}`);
+		let accepted = false, prevented = false, handled = false;
+		const hmrEvent = {
+			accept() {
+				accepted = true;
+			},
+			preventDefault() {
+				prevented = true;
+			},
+			path,
+			event
+		};
+		try {
+			await commandkit$1.plugins.execute(async (ctx, plugin) => {
+				var _plugin$performHMR;
+				if (accepted) return;
+				await ((_plugin$performHMR = plugin.performHMR) === null || _plugin$performHMR === void 0 ? void 0 : _plugin$performHMR.call(plugin, ctx, hmrEvent));
+			});
+			if (prevented) return;
+			switch (event) {
+				case require_constants.HMREventType.ReloadCommands:
+					commandkit$1.commandHandler.reloadCommands();
+					handled = true;
+					break;
+				case require_constants.HMREventType.ReloadEvents:
+					commandkit$1.eventHandler.reloadEvents();
+					handled = true;
+					break;
+				case require_constants.HMREventType.Unknown:
+					handled = false;
+					break;
+				default: break;
+			}
+		} finally {
+			if (id && process.send) process.send({
+				type: "commandkit-hmr-ack",
+				id,
+				handled: handled || accepted
+			});
+		}
+	});
+}
+
+//#endregion
+//#region src/CommandKit.ts
+let commandkit;
+const bootstrapHooks = new Set();
+const onApplicationBootstrapHooks = new Set();
+/**
+* Registers a bootstrap hook that will be called when the CommandKit instance is created.
+* This is useful for plugins that need to run some code after the CommandKit instance is fully initialized.
+* Note that not all commandkit dependiencs are available at this point. It is recommended to use the `onApplicationBootstrap` hook instead,
+* if you need access to the commandkit dependencies.
+* @param fn The bootstrap function to register.
+* @example ```ts
+* import { onBootstrap } from 'commandkit';
+*
+* onBootstrap(async (commandkit) => {
+*   // Do something with the commandkit instance
+* })
+* ```
+*/
+function onBootstrap(fn) {
+	bootstrapHooks.add(fn);
+}
+/**
+* Registers a bootstrap hook that will be called when the CommandKit instance is created.
+* This is useful for plugins that need to run some code after the CommandKit instance is fully initialized.
+* @param fn The bootstrap function to register.
+* @example ```ts
+* import { onApplicationBootstrap } from 'commandkit';
+*
+* onApplicationBootstrap(async (commandkit) => {
+*   // Do something with the commandkit instance
+* })
+* ```
+*/
+function onApplicationBootstrap(fn) {
+	onApplicationBootstrapHooks.add(fn);
+}
+var CommandKit = class CommandKit extends node_events.default {
+	#started = false;
+	options;
+	eventInterceptor;
+	static createElement = require_element.createElement;
+	static Fragment = require_element.Fragment;
+	config = {
+		defaultLocale: discord_js.Locale.EnglishUS,
+		getMessageCommandPrefix: () => "!"
+	};
+	store = new Map();
+	flags = new require_store.FlagStore();
+	commandsRouter;
+	eventsRouter;
+	commandHandler;
+	eventHandler;
+	plugins;
+	events;
+	static instance = void 0;
+	/**
+	* Create a new command and event handler with CommandKit.
+	*
+	* @param options - The default CommandKit configuration.
+	* @see {@link https://commandkit.js.org/docs/guide/commandkit-setup}
+	*/
+	constructor(options) {
+		if (CommandKit.instance) process.emitWarning("CommandKit instance already exists. Having multiple instance in same project is discouraged and it may lead to unexpected behavior.", { code: "MultiInstanceWarning" });
+		if (!options.client) throw new Error(require_colors.colors_default.red("\"client\" is required when instantiating CommandKit."));
+		super();
+		this.options = options;
+		if (!CommandKit.instance) CommandKit.instance = this;
+		this.plugins = new CommandKitPluginRuntime(this);
+		commandkit = CommandKit.instance;
+		this.#bootstrapHooks();
+	}
+	async #bootstrapHooks() {
+		for (const hook of bootstrapHooks) try {
+			await hook(this);
+		} catch (e) {
+			Logger.error("Error while executing bootstrap hook: ", e);
+		} finally {
+			bootstrapHooks.delete(hook);
+		}
+		bootstrapHooks.clear();
+	}
+	async #applicationBootstrapHooks() {
+		for (const hook of onApplicationBootstrapHooks) try {
+			await hook(this);
+		} catch (e) {
+			Logger.error("Error while executing application bootstrap hook: ", e);
+		} finally {
+			onApplicationBootstrapHooks.delete(hook);
+		}
+		onApplicationBootstrapHooks.clear();
+	}
+	/**
+	* Starts the commandkit application.
+	* @param token The application token to connect to the discord gateway. If not provided, it will use the `TOKEN` or `DISCORD_TOKEN` environment variable. If set to `false`, it will not login.
+	*/
+	async start(token) {
+		if (this.#started) return;
+		if (!this.options.client) throw new Error(require_colors.colors_default.red("\"client\" is required when starting CommandKit."));
+		this.eventInterceptor = new require_EventInterceptor.EventInterceptor(this.client);
+		if (require_constants.COMMANDKIT_IS_DEV) try {
+			registerDevHooks(this);
+			await require_types_package.generateTypesPackage();
+		} catch (e) {
+			if (process.env.COMMANDKIT_DEBUG_TYPEGEN) Logger.error(e);
+		}
+		await this.loadPlugins();
+		await this.#init();
+		this.commandHandler.registerCommandHandler();
+		this.incrementClientListenersCount();
+		if (token !== false && !this.options.client.isReady()) {
+			this.client.once(discord_js.Events.ClientReady, async () => {
+				await this.commandHandler.registrar.register();
+			});
+			await this.plugins.execute((ctx, plugin) => {
+				var _plugin$onBeforeClien;
+				return (_plugin$onBeforeClien = plugin.onBeforeClientLogin) === null || _plugin$onBeforeClien === void 0 ? void 0 : _plugin$onBeforeClien.call(plugin, ctx);
+			});
+			const botToken = token ?? this.options.client.token ?? process.env.TOKEN ?? process.env.DISCORD_TOKEN;
+			await this.options.client.login(botToken);
+			await this.plugins.execute((ctx, plugin) => {
+				var _plugin$onAfterClient;
+				return (_plugin$onAfterClient = plugin.onAfterClientLogin) === null || _plugin$onAfterClient === void 0 ? void 0 : _plugin$onAfterClient.call(plugin, ctx);
+			});
+		} else if (this.options.client.isReady()) await this.commandHandler.registrar.register();
+		this.#started = true;
+		await this.#applicationBootstrapHooks();
+	}
+	/**
+	* Loads all the plugins.
+	*/
+	async loadPlugins() {
+		const config = await loadConfigFile();
+		const plugins = config.plugins.flat(2).filter((p) => require_RuntimePlugin.isRuntimePlugin(p));
+		if (!plugins.length) return;
+		for (const plugin of plugins) await this.plugins.softRegisterPlugin(plugin);
+	}
+	/**
+	* Whether or not the commandkit application has started.
+	*/
+	get started() {
+		return this.#started;
+	}
+	/**
+	* Sets the prefix resolver for the command handler.
+	* @param resolver The resolver function.
+	*/
+	setPrefixResolver(resolver) {
+		this.config.getMessageCommandPrefix = resolver;
+		return this;
+	}
+	/**
+	* Sets the default locale for the command handler.
+	* @param locale The default locale.
+	*/
+	setDefaultLocale(locale) {
+		this.config.defaultLocale = locale;
+		return this;
+	}
+	/**
+	* Get the client attached to this CommandKit instance.
+	*/
+	get client() {
+		return this.options.client;
+	}
+	async #init() {
+		const appDir$1 = this.getAppDirectory();
+		if (!appDir$1) return;
+		const commandsPath = this.getPath("commands");
+		const events = this.getPath("events");
+		this.commandHandler = new AppCommandHandler(this);
+		this.eventHandler = new AppEventsHandler(this);
+		this.events = new require_CommandKitEventsChannel.CommandKitEventsChannel(this);
+		this.commandsRouter = new require_CommandsRouter.CommandsRouter({ entrypoint: commandsPath });
+		await this.plugins.execute((ctx, plugin) => {
+			return plugin.onCommandsRouterInit(ctx);
+		});
+		this.eventsRouter = new require_EventsRouter.EventsRouter({ entrypoints: [events] });
+		await this.plugins.execute((ctx, plugin) => {
+			return plugin.onEventsRouterInit(ctx);
+		});
+		await this.#initEvents();
+		await this.#initCommands();
+	}
+	async #initCommands() {
+		if (this.commandsRouter.isValidPath()) {
+			const result = await this.commandsRouter.scan();
+			if (require_constants.COMMANDKIT_IS_DEV) (0, node_fs.writeFileSync)("./.commandkit/commands.json", JSON.stringify(result, null, 2));
+		}
+		await this.commandHandler.loadCommands();
+		this.commandHandler.printBanner();
+	}
+	async #initEvents() {
+		if (this.eventsRouter.isValidPath()) await this.eventsRouter.scan();
+		await this.eventHandler.loadEvents();
+	}
+	/**
+	* Updates application commands with the latest from "commandsPath".
+	*/
+	async reloadCommands() {
+		await this.commandHandler.reloadCommands();
+	}
+	/**
+	* Updates application events with the latest from "eventsPath".
+	*/
+	async reloadEvents() {
+		await this.eventHandler.reloadEvents();
+	}
+	/**
+	* Increment the client listeners count.
+	*/
+	incrementClientListenersCount() {
+		this.options.client.setMaxListeners(this.options.client.getMaxListeners() + 1);
+	}
+	/**
+	* Decrement the client listeners count.
+	*/
+	decrementClientListenersCount() {
+		this.options.client.setMaxListeners(this.options.client.getMaxListeners() - 1);
+	}
+	/**
+	* Path to the app directory. Returns `null` if not found.
+	* The lookup order is:
+	* - `./app`
+	* - `./src/app`
+	*/
+	getAppDirectory() {
+		return findAppDirectory();
+	}
+	getPath(to) {
+		const appDir$1 = this.getAppDirectory();
+		if (!appDir$1) return null;
+		switch (to) {
+			case "commands": return (0, node_path.join)(appDir$1, "commands");
+			case "events": return (0, node_path.join)(appDir$1, "events");
+			default: return to;
+		}
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'AppCommandHandler', {
+  enumerable: true,
+  get: function () {
+    return AppCommandHandler;
+  }
+});
+Object.defineProperty(exports, 'AppCommandRunner', {
+  enumerable: true,
+  get: function () {
+    return AppCommandRunner;
+  }
+});
+Object.defineProperty(exports, 'AppEventsHandler', {
+  enumerable: true,
+  get: function () {
+    return AppEventsHandler;
+  }
+});
+Object.defineProperty(exports, 'Button', {
+  enumerable: true,
+  get: function () {
+    return Button;
+  }
+});
+Object.defineProperty(exports, 'ButtonKit', {
+  enumerable: true,
+  get: function () {
+    return ButtonKit;
+  }
+});
+Object.defineProperty(exports, 'ChannelSelectMenu', {
+  enumerable: true,
+  get: function () {
+    return ChannelSelectMenu;
+  }
+});
+Object.defineProperty(exports, 'ChannelSelectMenuKit', {
+  enumerable: true,
+  get: function () {
+    return ChannelSelectMenuKit;
+  }
+});
+Object.defineProperty(exports, 'CommandExecutionMode', {
+  enumerable: true,
+  get: function () {
+    return CommandExecutionMode;
+  }
+});
+Object.defineProperty(exports, 'CommandKit', {
+  enumerable: true,
+  get: function () {
+    return CommandKit;
+  }
+});
+Object.defineProperty(exports, 'CommandKitEnvironment', {
+  enumerable: true,
+  get: function () {
+    return CommandKitEnvironment;
+  }
+});
+Object.defineProperty(exports, 'CommandKitEnvironmentType', {
+  enumerable: true,
+  get: function () {
+    return CommandKitEnvironmentType;
+  }
+});
+Object.defineProperty(exports, 'CommandKitPluginRuntime', {
+  enumerable: true,
+  get: function () {
+    return CommandKitPluginRuntime;
+  }
+});
+Object.defineProperty(exports, 'CommandRegistrar', {
+  enumerable: true,
+  get: function () {
+    return CommandRegistrar;
+  }
+});
+Object.defineProperty(exports, 'CommonDirectiveTransformer', {
+  enumerable: true,
+  get: function () {
+    return CommonDirectiveTransformer;
+  }
+});
+Object.defineProperty(exports, 'Context', {
+  enumerable: true,
+  get: function () {
+    return Context;
+  }
+});
+Object.defineProperty(exports, 'DefaultLogger', {
+  enumerable: true,
+  get: function () {
+    return DefaultLogger;
+  }
+});
+Object.defineProperty(exports, 'Logger', {
+  enumerable: true,
+  get: function () {
+    return Logger;
+  }
+});
+Object.defineProperty(exports, 'MacroPlugin', {
+  enumerable: true,
+  get: function () {
+    return MacroPlugin;
+  }
+});
+Object.defineProperty(exports, 'MentionableSelectMenu', {
+  enumerable: true,
+  get: function () {
+    return MentionableSelectMenu;
+  }
+});
+Object.defineProperty(exports, 'MentionableSelectMenuKit', {
+  enumerable: true,
+  get: function () {
+    return MentionableSelectMenuKit;
+  }
+});
+Object.defineProperty(exports, 'MiddlewareContext', {
+  enumerable: true,
+  get: function () {
+    return MiddlewareContext;
+  }
+});
+Object.defineProperty(exports, 'Modal', {
+  enumerable: true,
+  get: function () {
+    return Modal;
+  }
+});
+Object.defineProperty(exports, 'ModalKit', {
+  enumerable: true,
+  get: function () {
+    return ModalKit;
+  }
+});
+Object.defineProperty(exports, 'ParagraphInput', {
+  enumerable: true,
+  get: function () {
+    return ParagraphInput;
+  }
+});
+Object.defineProperty(exports, 'RoleSelectMenu', {
+  enumerable: true,
+  get: function () {
+    return RoleSelectMenu;
+  }
+});
+Object.defineProperty(exports, 'RoleSelectMenuKit', {
+  enumerable: true,
+  get: function () {
+    return RoleSelectMenuKit;
+  }
+});
+Object.defineProperty(exports, 'ShortInput', {
+  enumerable: true,
+  get: function () {
+    return ShortInput;
+  }
+});
+Object.defineProperty(exports, 'StopEventPropagationError', {
+  enumerable: true,
+  get: function () {
+    return StopEventPropagationError;
+  }
+});
+Object.defineProperty(exports, 'StringSelectMenu', {
+  enumerable: true,
+  get: function () {
+    return StringSelectMenu;
+  }
+});
+Object.defineProperty(exports, 'StringSelectMenuKit', {
+  enumerable: true,
+  get: function () {
+    return StringSelectMenuKit;
+  }
+});
+Object.defineProperty(exports, 'StringSelectMenuOption', {
+  enumerable: true,
+  get: function () {
+    return StringSelectMenuOption;
+  }
+});
+Object.defineProperty(exports, 'TextInput', {
+  enumerable: true,
+  get: function () {
+    return TextInput;
+  }
+});
+Object.defineProperty(exports, 'UserSelectMenu', {
+  enumerable: true,
+  get: function () {
+    return UserSelectMenu;
+  }
+});
+Object.defineProperty(exports, 'UserSelectMenuKit', {
+  enumerable: true,
+  get: function () {
+    return UserSelectMenuKit;
+  }
+});
+Object.defineProperty(exports, 'after', {
+  enumerable: true,
+  get: function () {
+    return after;
+  }
+});
+Object.defineProperty(exports, 'cancelAfter', {
+  enumerable: true,
+  get: function () {
+    return cancelAfter;
+  }
+});
+Object.defineProperty(exports, 'commandkit', {
+  enumerable: true,
+  get: function () {
+    return commandkit;
+  }
+});
+Object.defineProperty(exports, 'createLogger', {
+  enumerable: true,
+  get: function () {
+    return createLogger;
+  }
+});
+Object.defineProperty(exports, 'debounce', {
+  enumerable: true,
+  get: function () {
+    return debounce;
+  }
+});
+Object.defineProperty(exports, 'defaultConfig', {
+  enumerable: true,
+  get: function () {
+    return defaultConfig;
+  }
+});
+Object.defineProperty(exports, 'defineConfig', {
+  enumerable: true,
+  get: function () {
+    return defineConfig;
+  }
+});
+Object.defineProperty(exports, 'devOnly', {
+  enumerable: true,
+  get: function () {
+    return devOnly;
+  }
+});
+Object.defineProperty(exports, 'exitContext', {
+  enumerable: true,
+  get: function () {
+    return exitContext;
+  }
+});
+Object.defineProperty(exports, 'findAppDirectory', {
+  enumerable: true,
+  get: function () {
+    return findAppDirectory;
+  }
+});
+Object.defineProperty(exports, 'getCommandKit', {
+  enumerable: true,
+  get: function () {
+    return getCommandKit;
+  }
+});
+Object.defineProperty(exports, 'getConfig', {
+  enumerable: true,
+  get: function () {
+    return getConfig;
+  }
+});
+Object.defineProperty(exports, 'getContext', {
+  enumerable: true,
+  get: function () {
+    return getContext;
+  }
+});
+Object.defineProperty(exports, 'getCurrentDirectory', {
+  enumerable: true,
+  get: function () {
+    return getCurrentDirectory;
+  }
+});
+Object.defineProperty(exports, 'getPossibleConfigPaths', {
+  enumerable: true,
+  get: function () {
+    return getPossibleConfigPaths;
+  }
+});
+Object.defineProperty(exports, 'getSourceDirectories', {
+  enumerable: true,
+  get: function () {
+    return getSourceDirectories;
+  }
+});
+Object.defineProperty(exports, 'isCommandWorkerContext', {
+  enumerable: true,
+  get: function () {
+    return isCommandWorkerContext;
+  }
+});
+Object.defineProperty(exports, 'loadConfigFile', {
+  enumerable: true,
+  get: function () {
+    return loadConfigFile;
+  }
+});
+Object.defineProperty(exports, 'makeContextAwareFunction', {
+  enumerable: true,
+  get: function () {
+    return makeContextAwareFunction;
+  }
+});
+Object.defineProperty(exports, 'onApplicationBootstrap', {
+  enumerable: true,
+  get: function () {
+    return onApplicationBootstrap;
+  }
+});
+Object.defineProperty(exports, 'onBootstrap', {
+  enumerable: true,
+  get: function () {
+    return onBootstrap;
+  }
+});
+Object.defineProperty(exports, 'provideContext', {
+  enumerable: true,
+  get: function () {
+    return provideContext;
+  }
+});
+Object.defineProperty(exports, 'registerDevHooks', {
+  enumerable: true,
+  get: function () {
+    return registerDevHooks;
+  }
+});
+Object.defineProperty(exports, 'stopEvents', {
+  enumerable: true,
+  get: function () {
+    return stopEvents;
+  }
+});
+Object.defineProperty(exports, 'useEnvironment', {
+  enumerable: true,
+  get: function () {
+    return useEnvironment;
+  }
+});
+//# sourceMappingURL=CommandKit-DDrQtQns.js.map