@adonisjs/core 7.0.1 → 7.1.1

package/build/{decorate-DmrZA614.js → decorate-B9Uz0anB.js}

@@ -1,7 +1,9 @@
+//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
 	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
 	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
+//#endregion
 export { __decorate as t };

package/build/{define_config-0oHaj43l.js → define_config--5euEdi8.js}

@@ -1,9 +1,51 @@
-import { t as debug_default } from "./debug-CGQmxzGt.js";
-import { t as configProvider } from "./config_provider-FIAUgvae.js";
-import { InvalidArgumentsException } from "./src/exceptions.js";
+import { t as debug_default } from "./debug-DWofTfIX.js";
+import { t as configProvider } from "./config_provider-Do9af1ze.js";
+import { n as InvalidArgumentsException } from "./exceptions-B2MzIlHY.js";
+//#region modules/encryption/define_config.ts
+/**
+* Defines the encryption configuration for the application.
+*
+* This function creates a configuration provider that lazily resolves
+* encryption drivers. It validates that the default encryptor (if specified)
+* exists in the list and resolves any ConfigProvider instances to their
+* concrete values.
+*
+* @template KnownEncryptors - Record of encryptor names to their configurations
+*
+* @param config - The encryption configuration object
+* @param config.default - Optional default encryptor name
+* @param config.list - Map of encryptor names to their configurations or providers
+*
+* @example
+* ```ts
+* const encryptionConfig = defineConfig({
+*   default: 'app',
+*   list: {
+*     app: drivers.aes256gcm({
+*       id: 'app',
+*       keys: [env.get('APP_KEY')]
+*     }),
+*     backup: drivers.chacha20({
+*       id: 'backup',
+*       keys: [env.get('BACKUP_KEY')]
+*     })
+*   }
+* })
+* ```
+*/
 function defineConfig(config) {
+	/**
+	* Encryption list should always be provided
+	*/
 	if (!config.list) throw new InvalidArgumentsException("Missing \"list\" property in encryption config");
+	/**
+	* The default encryption should be mentioned in the list
+	*/
 	if (config.default && !config.list[config.default]) throw new InvalidArgumentsException(`Missing "list.${String(config.default)}" in encryption config. It is referenced by the "default" property`);
+	/**
+	* Config provider to lazily import drivers as they are used inside
+	* the user application
+	*/
 	return configProvider.create(async (app) => {
 		debug_default("resolving encryption config");
 		const encryptorsList = Object.keys(config.list);
@@ -19,6 +61,14 @@ function defineConfig(config) {
 		};
 	});
 }
+/**
+* Collection of encryption driver factory functions.
+*
+* Each driver factory creates a ConfigProvider that lazily imports
+* and configures the corresponding encryption driver. This allows
+* for efficient code splitting and on-demand loading of encryption
+* algorithms.
+*/
 const drivers = {
 	chacha20: (config) => {
 		return configProvider.create(async () => {
@@ -83,4 +133,5 @@ const drivers = {
 		});
 	}
 };
+//#endregion
 export { drivers as n, defineConfig as t };

package/build/dumper-3R77st8F.js

@@ -0,0 +1,353 @@
+import { t as __exportAll } from "./chunk-Do49iUES.js";
+import { inspect } from "node:util";
+import { Exception } from "@poppinss/utils/exception";
+import useColors from "@poppinss/colors";
+import { dump } from "@poppinss/dumper/console";
+import { createScript, createStyleSheet, dump as dump$1 } from "@poppinss/dumper/html";
+import { parse } from "error-stack-parser-es";
+//#region modules/dumper/errors.ts
+var errors_exports = /* @__PURE__ */ __exportAll({ E_DUMP_DIE_EXCEPTION: () => E_DUMP_DIE_EXCEPTION });
+/**
+* DumpDie exception raised by the "dd" (dump and die) function.
+* This special exception terminates execution while dumping the provided
+* value as HTML (during HTTP requests) or ANSI (in console/CLI).
+*
+* @example
+* ```ts
+* // This will dump the user object and terminate
+* dumper.dd(user)
+*
+* // In HTTP context: sends HTML dump to browser
+* // In CLI context: prints ANSI dump to console
+* ```
+*/
+var DumpDieException = class extends Exception {
+	static status = 500;
+	static code = "E_DUMP_DIE_EXCEPTION";
+	#dumper;
+	#traceSourceIndex = 1;
+	value;
+	constructor(value, dumper) {
+		super("Dump and Die exception");
+		this.#dumper = dumper;
+		this.value = value;
+	}
+	/**
+	* Returns the source file and line number location for the error
+	*/
+	#getErrorSource() {
+		if (this.fileName && this.lineNumber) return {
+			location: this.fileName,
+			line: this.lineNumber
+		};
+		const source = parse(this)[this.#traceSourceIndex];
+		if (!source.fileName || !source.lineNumber) return;
+		return {
+			location: source.fileName,
+			line: source.lineNumber
+		};
+	}
+	/**
+	* Set the stack trace index for determining the source location.
+	* This is useful when building nested helpers on top of dump/die functionality.
+	*
+	* @param index - Stack trace index (0 = current function, 1 = caller, etc.)
+	*/
+	setTraceSourceIndex(index) {
+		this.#traceSourceIndex = index;
+		return this;
+	}
+	/**
+	* Preventing itself from getting reported by the
+	* AdonisJS exception reporter
+	*/
+	report() {}
+	/**
+	* HTTP exception handler that renders the dump as HTML output.
+	* This method is called automatically by AdonisJS when a DumpDieException
+	* is thrown during an HTTP request.
+	*
+	* @param error - The DumpDieException instance
+	* @param ctx - HTTP context for the current request
+	*/
+	async handle(error, ctx) {
+		const source = this.#getErrorSource();
+		/**
+		* Comes from the shield package
+		*/
+		const cspNonce = "nonce" in ctx.response ? ctx.response.nonce : void 0;
+		ctx.response.status(500).send(`<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width">${this.#dumper.getHeadElements(cspNonce)}</head><body>${this.#dumper.dumpToHtml(error.value, {
+			cspNonce,
+			source,
+			title: "DUMP DIE"
+		})}</body></html>`);
+	}
+	/**
+	* Ace command exception handler that renders the dump as ANSI output.
+	* This method is called automatically by the Ace kernel when a DumpDieException
+	* is thrown during command execution.
+	*
+	* @param error - The DumpDieException instance
+	* @param kernel - Ace kernel instance
+	*/
+	async render(error, kernel) {
+		const source = this.#getErrorSource();
+		kernel.ui.logger.log(this.#dumper.dumpToAnsi(error.value, {
+			source,
+			title: "DUMP DIE"
+		}));
+	}
+	/**
+	* Custom output for the Node.js util inspect
+	*/
+	[inspect.custom]() {
+		const source = this.#getErrorSource();
+		return this.#dumper.dumpToAnsi(this.value, {
+			source,
+			title: "DUMP DIE"
+		});
+	}
+};
+const E_DUMP_DIE_EXCEPTION = DumpDieException;
+//#endregion
+//#region modules/dumper/dumper.ts
+const colors = useColors.ansi();
+const DUMP_TITLE_STYLES = `
+.adonisjs-dump-header {
+  font-family: JetBrains Mono, monaspace argon, Menlo, Monaco, Consolas, monospace;
+  background: #ff1639;
+  border-radius: 4px;
+  color: #fff;
+  border-bottom-left-radius: 0;
+  border-bottom-right-radius: 0;
+  padding: 0.4rem 1.2rem;
+  font-size: 1em;
+  display: flex;
+  justify-content: space-between;
+}
+.adonisjs-dump-header .adonisjs-dump-header-title {
+  font-weight: bold;
+  text-transform: uppercase;
+}
+.adonisjs-dump-header .adonisjs-dump-header-source {
+  font-weight: bold;
+  color: inherit;
+  text-decoration: underline;
+}
+.dumper-dump pre {
+  border-radius: 4px;
+  border-top-left-radius: 0;
+  border-top-right-radius: 0;
+}`;
+const IDE = process.env.ADONIS_IDE ?? process.env.EDITOR ?? "";
+/**
+* Dumper exposes the API to dump or die/dump values in your
+* AdonisJS application. An singleton instance of the Dumper
+* is shared as a service and may use it follows.
+*
+* ```ts
+* const dumper = container.make('dumper')
+*
+* dumper.configureHtmlOutput({
+*   // parser + html formatter config
+* })
+*
+* dumper.configureAnsiOutput({
+*   // parser + console formatter config
+* })
+*
+* const html = dumper.dumpToHtml(value)
+* const ansi = dumper.dumpToAnsi(value)
+*
+* // Returns style and script tags that must be
+* // injeted to the head of the HTML document
+*
+* const head = dumper.getHeadElements()
+* ```
+*/
+var Dumper = class {
+	#app;
+	/**
+	* Configuration for the HTML formatter
+	*/
+	#htmlConfig = {};
+	/**
+	* Configuration for the Console formatter
+	*/
+	#consoleConfig = { collapse: ["DateTime", "Date"] };
+	/**
+	* A collections of known editors to create URLs to open
+	* them
+	*/
+	#editors = {
+		textmate: "txmt://open?url=file://%f&line=%l",
+		macvim: "mvim://open?url=file://%f&line=%l",
+		emacs: "emacs://open?url=file://%f&line=%l",
+		sublime: "subl://open?url=file://%f&line=%l",
+		phpstorm: "phpstorm://open?file=%f&line=%l",
+		atom: "atom://core/open/file?filename=%f&line=%l",
+		vscode: "vscode://file/%f:%l"
+	};
+	/**
+	* Creates a new Dumper instance
+	*
+	* @param app - The AdonisJS application instance
+	*/
+	constructor(app) {
+		this.#app = app;
+	}
+	/**
+	* Returns the link to open the file using dd inside one
+	* of the known code editors. Constructs a URL that can be used
+	* to open the file at a specific line in supported editors.
+	*
+	* @param source - Optional source file information
+	* @param source.location - The file path to open
+	* @param source.line - The line number to jump to
+	*/
+	#getEditorLink(source) {
+		const editorURL = this.#editors[IDE] || IDE;
+		if (!editorURL || !source) return;
+		return {
+			href: editorURL.replace("%f", source.location).replace("%l", String(source.line)),
+			text: `${this.#app.relativePath(source.location)}:${source.line}`
+		};
+	}
+	/**
+	* Configure the HTML formatter output options
+	*
+	* @param config - Configuration options for HTML dump formatting
+	*
+	* @example
+	* ```ts
+	* dumper.configureHtmlOutput({
+	*   showHidden: true,
+	*   depth: 5,
+	*   colors: false
+	* })
+	* ```
+	*/
+	configureHtmlOutput(config) {
+		this.#htmlConfig = config;
+		return this;
+	}
+	/**
+	* Configure the ANSI formatter output options for console display
+	*
+	* @param config - Configuration options for ANSI console formatting
+	*
+	* @example
+	* ```ts
+	* dumper.configureAnsiOutput({
+	*   showHidden: true,
+	*   depth: 3,
+	*   collapse: ['Date', 'DateTime']
+	* })
+	* ```
+	*/
+	configureAnsiOutput(config) {
+		this.#consoleConfig = config;
+		return this;
+	}
+	/**
+	* Returns the style and script elements that need to be injected into
+	* the HTML document head for proper dump visualization
+	*
+	* @param cspNonce - Optional Content Security Policy nonce for inline scripts
+	*
+	* @example
+	* ```ts
+	* const headElements = dumper.getHeadElements('abc123')
+	* // Insert into your HTML head section
+	* ```
+	*/
+	getHeadElements(cspNonce) {
+		return `<style id="dumper-styles">` + createStyleSheet() + DUMP_TITLE_STYLES + `</style><script id="dumper-script"${cspNonce ? ` nonce="${cspNonce}"` : ""}>` + createScript() + "<\/script>";
+	}
+	/**
+	* Dump a value to formatted HTML output
+	*
+	* @param value - The value to dump and inspect
+	* @param options - Options for HTML output formatting
+	* @param options.cspNonce - Optional Content Security Policy nonce
+	* @param options.title - Optional title to display in the dump header
+	* @param options.source - Optional source file information for editor links
+	*
+	* @example
+	* ```ts
+	* const htmlOutput = dumper.dumpToHtml(user, {
+	*   title: 'User Object',
+	*   source: { location: '/app/controllers/user.ts', line: 42 }
+	* })
+	* ```
+	*/
+	dumpToHtml(value, options = {}) {
+		const link = this.#getEditorLink(options.source) ?? null;
+		return `<div class="adonisjs-dump-header"><span class="adonisjs-dump-header-title">${options.title || "DUMP"}</span>` + (link ? `<a href="${link.href}" class="adonisjs-dump-header-source">${link.text}</a>` : "") + "</div>" + dump$1(value, {
+			cspNonce: options.cspNonce,
+			...this.#htmlConfig
+		});
+	}
+	/**
+	* Dump a value to formatted ANSI output for console display
+	*
+	* @param value - The value to dump and inspect
+	* @param options - Options for ANSI output formatting
+	* @param options.title - Optional title to display in the dump header
+	* @param options.source - Optional source file information for editor links
+	*
+	* @example
+	* ```ts
+	* const ansiOutput = dumper.dumpToAnsi(user, {
+	*   title: 'User Debug',
+	*   source: { location: '/app/controllers/user.ts', line: 42 }
+	* })
+	* console.log(ansiOutput)
+	* ```
+	*/
+	dumpToAnsi(value, options = {}) {
+		const columns = process.stdout.columns;
+		/**
+		* Link to the source file
+		*/
+		const link = `${this.#getEditorLink(options.source)?.text ?? ""} `;
+		/**
+		* Dump title
+		*/
+		const title = ` ${options.title || "DUMP"}`;
+		/**
+		* Whitespace between the title and the link to align them
+		* on each side of x axis
+		*/
+		const whiteSpaceLength = columns ? columns - link.length - title.length - 4 : 2;
+		const whiteSpace = new Array(whiteSpaceLength <= 0 ? 2 : whiteSpaceLength).join(" ");
+		return `${colors.bgRed().bold(`${title}${whiteSpace}${link}`)}\n${dump(value, this.#consoleConfig)}`;
+	}
+	/**
+	* Dump values and die. This method dumps the provided value and then
+	* terminates the application. The output format is automatically chosen
+	* based on the execution context.
+	*
+	* - During an HTTP request, HTML output will be sent to the browser
+	* - Otherwise the value will be logged to the console in ANSI format
+	*
+	* @param value - The value to dump before terminating
+	* @param traceSourceIndex - Stack trace index for source location (default: 1)
+	*
+	* @example
+	* ```ts
+	* // This will dump the user object and terminate the application
+	* dumper.dd(user)
+	*
+	* // This will never execute
+	* console.log('This line will not run')
+	* ```
+	*/
+	dd(value, traceSourceIndex = 1) {
+		const error = new E_DUMP_DIE_EXCEPTION(value, this);
+		error.setTraceSourceIndex(traceSourceIndex);
+		throw error;
+	}
+};
+//#endregion
+export { errors_exports as n, Dumper as t };

package/build/edge-BG5ZYp6Z.js

@@ -0,0 +1,57 @@
+import { Template } from "edge.js";
+//#region modules/dumper/plugins/edge.ts
+/**
+* Returns an edge plugin that integrates with a given
+* dumper instance
+*/
+function pluginEdgeDumper(dumper) {
+	Template.macro("dumper", dumper);
+	return (edge) => {
+		edge.registerTag({
+			tagName: "dump",
+			block: false,
+			seekable: true,
+			noNewLine: true,
+			compile(parser, buffer, token) {
+				const parsed = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+				buffer.writeExpression(`template.stacks.pushOnceTo('dumper', 'dumper_globals', template.dumper.getHeadElements(state.cspNonce))`, token.filename, token.loc.start.line);
+				buffer.outputExpression(`template.dumper.dumpToHtml(${parser.utils.stringify(parsed)}, { cspNonce: state.cspNonce, source: { location: $filename, line: $lineNumber } })`, token.filename, token.loc.start.line, true);
+			}
+		});
+		edge.registerTag({
+			tagName: "dd",
+			block: false,
+			seekable: true,
+			noNewLine: true,
+			compile(parser, buffer, token) {
+				const parsed = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+				/**
+				* Dump/Die statement to catch error and convert it into
+				* an Edge error
+				*/
+				const ddStatement = [
+					"try {",
+					`  template.dumper.dd(${parser.utils.stringify(parsed)})`,
+					"} catch (error) {",
+					`  if (error.code === 'E_DUMP_DIE_EXCEPTION') {`,
+					"    const edgeError = template.createError(error.message, $filename, $lineNumber)",
+					"    error.fileName = $filename",
+					"    error.lineNumber = $lineNumber",
+					"    edgeError.handle = function (_, ctx) {",
+					"      return error.handle(error, ctx)",
+					"    }",
+					"    edgeError.report = function () {",
+					"      return error.report(error)",
+					"    }",
+					"    throw edgeError",
+					"  }",
+					"  throw error",
+					"}"
+				].join("\n");
+				buffer.writeStatement(ddStatement, token.filename, token.loc.start.line);
+			}
+		});
+	};
+}
+//#endregion
+export { pluginEdgeDumper as t };

package/build/{errors-CrCO-k44.js → errors-BScZTzBu.js}

@@ -1,8 +1,16 @@
-import { createError } from "./src/exceptions.js";
+import { i as createError } from "./exceptions-B2MzIlHY.js";
 import { errors } from "@boringnode/encryption";
+//#region modules/encryption/errors.ts
+/**
+* Raised when attempting to compute blind indexes using the legacy driver.
+*/
 const E_BLIND_INDEX_NOT_SUPPORTED = createError("Blind indexes are not supported by the \"%s\" encryption driver", "E_BLIND_INDEX_NOT_SUPPORTED");
+/**
+* Encryption errors exposed by this package.
+*/
 const errors$1 = {
 	...errors,
 	E_BLIND_INDEX_NOT_SUPPORTED
 };
+//#endregion
 export { errors$1 as n, E_BLIND_INDEX_NOT_SUPPORTED as t };

package/build/events-DlKX1ZdL.js

@@ -0,0 +1,7 @@
+import { n as __reExport, t as __exportAll } from "./chunk-Do49iUES.js";
+//#region modules/events.ts
+var events_exports = /* @__PURE__ */ __exportAll({});
+import * as import__adonisjs_events from "@adonisjs/events";
+__reExport(events_exports, import__adonisjs_events);
+//#endregion
+export { events_exports as t };

package/build/exceptions-B2MzIlHY.js

@@ -0,0 +1,2 @@
+import { Exception as Exception$1, InvalidArgumentsException as InvalidArgumentsException$1, RuntimeException as RuntimeException$1, createError } from "@poppinss/utils/exception";
+export { createError as i, InvalidArgumentsException$1 as n, RuntimeException$1 as r, Exception$1 as t };

package/build/factories/app.js

@@ -1,2 +1,3 @@
+import "../chunk-Do49iUES.js";
 export * from "@adonisjs/application/factories";
 export {};

package/build/factories/bodyparser.js

@@ -1,2 +1,3 @@
+import "../chunk-Do49iUES.js";
 export * from "@adonisjs/bodyparser/factories";
 export {};

package/build/factories/core/ace.js

@@ -1,23 +1,17 @@
-import "../../chunk-iKc69rpz.js";
-import "../../debug-CGQmxzGt.js";
-import { t as Ignitor } from "../../main-Cxz0TyIw.js";
-import "../../config_provider-FIAUgvae.js";
-import "../../main-MBAMnmJb.js";
-import "../../main-DN2qEEg5.js";
-import "../../define_config-0oHaj43l.js";
-import "../../main-DkNgvceD.js";
-import { IgnitorFactory } from "./ignitor.js";
-import { t as createAceKernel } from "../../create_kernel-B7ILNhuP.js";
-var AceFactory = class {
-	async make(ignitorOrAppRoot, options) {
-		if (ignitorOrAppRoot instanceof Ignitor) {
-			const app = ignitorOrAppRoot.createApp("console");
-			await app.init();
-			return createAceKernel(app);
-		}
-		const app = new IgnitorFactory().withCoreConfig().withCoreProviders().create(ignitorOrAppRoot, options).createApp("console");
-		await app.init();
-		return createAceKernel(app);
-	}
-};
+import "../../chunk-Do49iUES.js";
+import "../../debug-DWofTfIX.js";
+import "../../main-D1MSq4Uu.js";
+import "../../app-CAuSGb2P.js";
+import "../../app-BCcG_oDd.js";
+import "../../config_provider-Do9af1ze.js";
+import "../../main-CRnMnrH7.js";
+import "../../logger-DIdZPHCe.js";
+import "../../exceptions-B2MzIlHY.js";
+import "../../main-Ck0GqLx4.js";
+import "../../define_config--5euEdi8.js";
+import "../../main-B50zECAi.js";
+import "../../main-zxNP7iRl.js";
+import "../../ignitor-Kym3gR-I.js";
+import "../../create_kernel-D38-0Zbt.js";
+import { t as AceFactory } from "../../ace-DBm6EcQ-.js";
 export { AceFactory };

package/build/factories/core/ignitor.js

@@ -1,74 +1,14 @@
-import "../../chunk-iKc69rpz.js";
-import "../../debug-CGQmxzGt.js";
-import { t as Ignitor } from "../../main-Cxz0TyIw.js";
-import "../../config_provider-FIAUgvae.js";
-import { t as logger_exports } from "../../modules/logger.js";
-import { t as main_exports } from "../../main-DN2qEEg5.js";
-import { n as drivers, t as defineConfig } from "../../define_config-0oHaj43l.js";
-import { n as defineConfig$1, r as drivers$1 } from "../../main-DkNgvceD.js";
-import { t as main_exports$1 } from "../../modules/bodyparser/main.js";
-var IgnitorFactory = class {
-	#preloadActions = [];
-	#parameters = {};
-	#loadCoreProviders = false;
-	preload(action) {
-		this.#preloadActions.push(action);
-		return this;
-	}
-	#mergeCoreProviders(providers) {
-		return [
-			() => import("@adonisjs/core/providers/app_provider"),
-			() => import("@adonisjs/core/providers/hash_provider"),
-			() => import("@adonisjs/core/providers/repl_provider")
-		].concat(providers || []);
-	}
-	merge(params) {
-		if (params.config) this.#parameters.config = Object.assign(this.#parameters.config || {}, params.config);
-		if (params.rcFileContents) this.#parameters.rcFileContents = Object.assign(this.#parameters.rcFileContents || {}, params.rcFileContents);
-		return this;
-	}
-	withCoreProviders() {
-		this.#loadCoreProviders = true;
-		return this;
-	}
-	withCoreConfig() {
-		this.merge({ config: {
-			app: {
-				appUrl: "http://localhost:3333",
-				http: (0, main_exports.defineConfig)({})
-			},
-			validator: {},
-			encryption: defineConfig({
-				default: "gcm",
-				list: { gcm: drivers.aes256gcm({
-					id: "gcm",
-					keys: ["averylongrandomsecretkey"]
-				}) }
-			}),
-			bodyparser: (0, main_exports$1.defineConfig)({}),
-			hash: defineConfig$1({
-				default: "scrypt",
-				list: { scrypt: drivers$1.scrypt({}) }
-			}),
-			logger: (0, logger_exports.defineConfig)({
-				default: "app",
-				loggers: { app: {} }
-			})
-		} });
-		return this;
-	}
-	create(appRoot, options) {
-		return new Ignitor(appRoot, options).tap((app) => {
-			app.booted(async () => {
-				for (let action of this.#preloadActions) await action(app);
-			});
-			if (this.#loadCoreProviders) {
-				this.#parameters.rcFileContents = this.#parameters.rcFileContents || {};
-				this.#parameters.rcFileContents.providers = this.#mergeCoreProviders(this.#parameters.rcFileContents.providers);
-			}
-			this.#parameters.rcFileContents && app.rcContents(this.#parameters.rcFileContents);
-			this.#parameters.config && app.useConfig(this.#parameters.config);
-		});
-	}
-};
+import "../../chunk-Do49iUES.js";
+import "../../debug-DWofTfIX.js";
+import "../../main-D1MSq4Uu.js";
+import "../../app-CAuSGb2P.js";
+import "../../app-BCcG_oDd.js";
+import "../../config_provider-Do9af1ze.js";
+import "../../logger-DIdZPHCe.js";
+import "../../exceptions-B2MzIlHY.js";
+import "../../main-Ck0GqLx4.js";
+import "../../define_config--5euEdi8.js";
+import "../../main-B50zECAi.js";
+import "../../main-zxNP7iRl.js";
+import { t as IgnitorFactory } from "../../ignitor-Kym3gR-I.js";
 export { IgnitorFactory };