@codependix/cli 0.0.3

package/dist/main.module-B07sXqnE.js

@@ -0,0 +1,718 @@
+import { ConsoleLogger as e, Global as t, Injectable as n, Module as r, Scope as i } from "@nestjs/common";
+import { ConfigModule as a } from "@nestjs/config";
+import { DiscoveryModule as o } from "@nestjs/core";
+import { existsSync as s, mkdirSync as c } from "node:fs";
+import l from "node:path";
+import u from "pino";
+import { z as d } from "zod";
+import { BoundaryCheckModule as f, BoundaryCheckService as p, RunContextModule as m, RunContextService as h } from "@codependix/boundaries";
+import { CHECK_NAMES as g, ConfigurationModule as _, ConfigurationService as v } from "@codependix/configuration";
+import { CombinedOutputModule as y, CombinedOutputService as b, FORMAT_MARKDOWN as x, FORMAT_NAMES as S, GraphRunModule as C, GraphRunService as w, PATH_FORMAT_NAMES as T, PathQueryModule as E, PathQueryService as D, ReportingModule as O, ReportingService as k } from "@codependix/output";
+import { Command as A, CommandRunner as j, Option as M } from "nest-commander";
+//#region packages/logger/src/modules/logger/logger.constants.ts
+var N = /^(\p{Extended_Pictographic}️?(?:‍\p{Extended_Pictographic}️?)*)\s+/u, P = /^([A-Za-z]+)/, F = /* @__PURE__ */ new Set([
+	"built",
+	"cut",
+	"found",
+	"got",
+	"kept",
+	"left",
+	"lost",
+	"made",
+	"put",
+	"ran",
+	"read",
+	"rebuilt",
+	"sent",
+	"set",
+	"split",
+	"took",
+	"wrote"
+]), I = /* @__PURE__ */ new Set([
+	"CommandFactory",
+	"ExceptionHandler",
+	"GraphQLModule",
+	"InstanceLoader",
+	"NestApplication",
+	"NestFactory",
+	"RouterExplorer",
+	"RoutesResolver",
+	"TypeOrmModule"
+]);
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+function L(e, t) {
+	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
+function R(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
+}
+//#endregion
+//#region packages/logger/src/modules/logger/logger.service.ts
+var z, B = class extends e {
+	static {
+		z = this;
+	}
+	constructor() {
+		super();
+	}
+	static isProduction = process.env.NODE_ENV === "production";
+	static rootLogger;
+	static writesToStandardError = !1;
+	child = z.root;
+	static createRootLogger() {
+		let e = process.env.LOG_LEVEL ?? "info";
+		return z.isProduction ? z.writesToStandardError ? u({ level: e }, u.destination(2)) : u({ level: e }) : u({
+			level: e,
+			transport: {
+				options: {
+					colorize: !0,
+					destination: z.writesToStandardError ? 2 : 1,
+					ignore: "pid,hostname,emoji",
+					messageFormat: "{emoji} {msg}",
+					singleLine: !0
+				},
+				target: "pino-pretty"
+			}
+		});
+	}
+	static logToStandardError() {
+		if (z.rootLogger !== void 0) {
+			process.emitWarning("LoggerService.logToStandardError() was called after the first log line, so log lines still go to standard output and anything piping that stream will read them as data. Call it as the first statement of the application's bootstrap.");
+			return;
+		}
+		z.writesToStandardError = !0;
+	}
+	assertConventionalMessage(e) {
+		if (z.isProduction || this.shouldSkipConventionalMessageValidation(e.context)) return;
+		let t = this.getConventionalMessageViolation(e.parsed);
+		if (t !== void 0) throw Error(t);
+	}
+	buildBindings(e) {
+		return this.assertConventionalMessage({
+			context: e.context,
+			parsed: e.parsed
+		}), {
+			...e.data,
+			context: e.context,
+			...z.isProduction ? {} : { emoji: e.parsed.emoji }
+		};
+	}
+	getConventionalMessageViolation(e) {
+		let t = e.emoji, n = e.text;
+		if (t === void 0) return `Log message must start with an emoji naming its subject, then a verb: "${n}"`;
+		let r = P.exec(n)?.[1];
+		if (r === void 0 || !this.isConventionalVerb(r)) return `Log message must begin with a verb in present progressive or past tense, got "${r ?? ""}": "${t} ${n}"`;
+	}
+	isConventionalVerb(e) {
+		let t = e.toLowerCase();
+		return t.endsWith("ing") || t.endsWith("ed") || F.has(t);
+	}
+	parseMessage(e) {
+		let t = String(e), n = N.exec(t), r = n?.[1];
+		return r === void 0 ? {
+			emoji: void 0,
+			text: t
+		} : {
+			emoji: r,
+			text: t.slice(n?.[0].length)
+		};
+	}
+	shouldSkipConventionalMessageValidation(e) {
+		return e !== void 0 && I.has(e);
+	}
+	static get root() {
+		return z.rootLogger ??= z.createRootLogger(), z.rootLogger;
+	}
+	buildErrorLogEntry(e, t) {
+		let n = t instanceof Error ? t.stack || t.message : String(t);
+		return {
+			errorMessage: n,
+			logLine: `[${(/* @__PURE__ */ new Date()).toISOString()}] ${e}: ${n}\n`
+		};
+	}
+	createTimestampedOutputLogFilePath(e) {
+		let t = l.join(process.cwd(), "output");
+		return s(t) || c(t, { recursive: !0 }), l.join(t, `${e}-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-")}.log`);
+	}
+	debug(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.debug(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	error(e, t, n) {
+		let r = this.parseMessage(e), i = typeof n == "object" ? n : void 0, a = typeof n == "string" ? n : this.context;
+		this.child.error({
+			...this.buildBindings({
+				context: a,
+				data: i,
+				parsed: r
+			}),
+			stack: t
+		}, r.text);
+	}
+	info(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.info(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	log(e, t, n) {
+		this.info(e, t, n);
+	}
+	setContext(e) {
+		super.setContext(e), this.child = z.root.child({ context: e });
+	}
+	verbose(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.trace(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	warn(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.warn(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+};
+B = z = R([n({ scope: i.TRANSIENT }), L("design:paramtypes", [])], B);
+//#endregion
+//#region packages/logger/src/modules/logger/logger.module.ts
+var V = class {};
+V = R([t(), r({
+	controllers: [],
+	exports: [B],
+	imports: [],
+	providers: [B]
+})], V);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-cli/src/constants.ts
+var H = d.object({}), U, W = U = class extends j {
+	graphRunService;
+	boundaryCheckService;
+	combinedOutputService;
+	configurationService;
+	logger;
+	reportingService;
+	runContextService;
+	constructor(e, t, n, r, i, a, o) {
+		super(), this.graphRunService = e, this.boundaryCheckService = t, this.combinedOutputService = n, this.configurationService = r, this.logger = i, this.reportingService = a, this.runContextService = o, this.logger.setContext(U.name);
+	}
+	runCombinedOutput(e) {
+		e.combinedGraphs !== void 0 && this.combinedOutputService.run({
+			format: e.format,
+			graphs: e.combinedGraphs,
+			jsonOutputPath: e.options.jsonOutput,
+			markdownOutputPath: e.options.markdownOutput,
+			workingDirectory: e.workingDirectory
+		});
+	}
+	async runExports(e) {
+		let t = await this.graphRunService.run(e);
+		return this.reportingService.reportEmptySelection(t.outcome.results.length + t.outcome.failures.length), t;
+	}
+	async runMode(e) {
+		let { format: t, mode: n, options: r } = e, i = await this.runContextService.build({
+			mode: n.writes ? "write" : "check",
+			options: r,
+			workingDirectory: l.resolve(r.directory ?? process.cwd())
+		}), a = this.configurationService.touchesFiles(n) ? await this.runExports(i) : void 0, o = n.checksBoundaries ? await this.boundaryCheckService.run(i) : void 0;
+		if (this.runCombinedOutput({
+			combinedGraphs: a?.combinedGraphs,
+			format: t,
+			options: r,
+			workingDirectory: i.workingDirectory
+		}), !this.reportingService.reportPassOutcomes({
+			boundaryOutcome: o,
+			exportRun: a
+		})) {
+			process.exitCode = 1;
+			return;
+		}
+		this.reportingService.reportSuccess({
+			boundaryOutcome: o,
+			exportOutcome: a?.outcome
+		});
+	}
+	parseCheck(e) {
+		return e;
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseDirectory(e) {
+		return this.configurationService.parsePathOption(e);
+	}
+	parseExclude(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseFileImports() {
+		return !0;
+	}
+	parseFormat(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseInclude(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseJsonOutput(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseMarkdownOutput(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseNestjsModules() {
+		return !0;
+	}
+	parseNoFileImports() {
+		return !1;
+	}
+	parseNoNestjsModules() {
+		return !1;
+	}
+	parseNoNxProjects() {
+		return !1;
+	}
+	parseNxProjects() {
+		return !0;
+	}
+	parseProjects(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseTags(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseWrite(e) {
+		return this.configurationService.parseFlagOption(e);
+	}
+	async run(e, t = {}) {
+		try {
+			let { errors: e, mode: n } = await this.configurationService.selectMode(t), { errors: r, format: i } = this.combinedOutputService.resolveFormat(t.format), a = [...e, ...r];
+			if (a.length > 0) {
+				this.logger.error("🕸️ Rejected the command line", void 0, { reasons: a }), process.exitCode = 1;
+				return;
+			}
+			await this.runMode({
+				format: i,
+				mode: n,
+				options: t
+			});
+		} catch (e) {
+			this.reportingService.reportFailure(e);
+		}
+	}
+};
+R([
+	M({
+		description: `Fail on a comma-separated set drawn from ${g.map((e) => `"${e}"`).join(" and ")}`,
+		flags: "--check [check]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [String]),
+	L("design:returntype", String)
+], W.prototype, "parseCheck", null), R([
+	M({
+		description: "Path to the codependix configuration file",
+		flags: "--config [config]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], W.prototype, "parseConfig", null), R([
+	M({
+		description: "Directory whose Nx workspace this run reads",
+		flags: "-d, --directory [directory]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", String)
+], W.prototype, "parseDirectory", null), R([
+	M({
+		description: "Comma-separated globs overriding the configured exclude. Refused when exclude was never configured",
+		flags: "--exclude [exclude]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Array)
+], W.prototype, "parseExclude", null), R([
+	M({
+		description: "Build, check, and write the fileImports graph type",
+		flags: "--file-imports"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], W.prototype, "parseFileImports", null), R([
+	M({
+		description: `What to print to standard output, one of ${S.join(" and ")} (default: ${x}). A graph type prints only when this run also configured a workspace destination for it, even if its own toggle flag enabled it`,
+		flags: "-f, --format [format]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], W.prototype, "parseFormat", null), R([
+	M({
+		description: "Comma-separated globs overriding the configured include. Refused when include was never configured",
+		flags: "--include [include]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Array)
+], W.prototype, "parseInclude", null), R([
+	M({
+		description: "Write every active graph type's data, combined into one JSON file at this path, keyed by graph type name. A type appears only when this run also configured a workspace destination for it",
+		flags: "--json-output [jsonOutput]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], W.prototype, "parseJsonOutput", null), R([
+	M({
+		description: "Write every active graph type's rendered diagram, combined into one Markdown file at this path. A type appears only when this run also configured a workspace destination for it",
+		flags: "--markdown-output [markdownOutput]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], W.prototype, "parseMarkdownOutput", null), R([
+	M({
+		description: "Build, check, and write the nestjsModules graph type",
+		flags: "--nestjs-modules"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], W.prototype, "parseNestjsModules", null), R([
+	M({
+		description: "Skip the fileImports graph type for this run",
+		flags: "--no-file-imports"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], W.prototype, "parseNoFileImports", null), R([
+	M({
+		description: "Skip the nestjsModules graph type for this run",
+		flags: "--no-nestjs-modules"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], W.prototype, "parseNoNestjsModules", null), R([
+	M({
+		description: "Skip the nxProjects graph type for this run",
+		flags: "--no-nx-projects"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], W.prototype, "parseNoNxProjects", null), R([
+	M({
+		description: "Build, check, and write the nxProjects graph type",
+		flags: "--nx-projects"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], W.prototype, "parseNxProjects", null), R([
+	M({
+		description: "Comma-separated project names or roots to export for, as globs, beyond those include already selects. Also narrows the Workspace Graph and --check boundaries to the named set",
+		flags: "--projects [projects]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], W.prototype, "parseProjects", null), R([
+	M({
+		description: "Comma-separated Nx tags to export for, beyond what include already selects. Also narrows the Workspace Graph and --check boundaries to the tagged projects",
+		flags: "--tags [tags]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], W.prototype, "parseTags", null), R([
+	M({
+		description: "Write every configured export",
+		flags: "--write"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Boolean)
+], W.prototype, "parseWrite", null), W = U = R([
+	A({
+		description: "Map every configured dependency graph and export it",
+		name: "map"
+	}),
+	n(),
+	L("design:paramtypes", [
+		w === void 0 ? Object : w,
+		p === void 0 ? Object : p,
+		b === void 0 ? Object : b,
+		v === void 0 ? Object : v,
+		B === void 0 ? Object : B,
+		k === void 0 ? Object : k,
+		h === void 0 ? Object : h
+	])
+], W);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-cli/src/modules/map/map.module.ts
+var G = class {};
+G = R([r({
+	controllers: [],
+	exports: [W],
+	imports: [
+		f,
+		y,
+		_,
+		C,
+		O,
+		m
+	],
+	providers: [W]
+})], G);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-cli/src/modules/path/path.constants.ts
+var K = "The path command requires both <from> and <to> arguments, as in \"codependix path <from> <to>\".", q, J = q = class extends j {
+	configurationService;
+	logger;
+	pathQueryService;
+	reportingService;
+	runContextService;
+	constructor(e, t, n, r, i) {
+		super(), this.configurationService = e, this.logger = t, this.pathQueryService = n, this.reportingService = r, this.runContextService = i, this.logger.setContext(q.name);
+	}
+	validateInputs(e, t) {
+		let n = e[0], r = e[1];
+		if (!n || !r) return this.logger.error("🕸️ Rejected the command line", void 0, { reasons: [K] }), process.exitCode = 1, null;
+		let { errors: i, format: a } = this.pathQueryService.resolveFormat(t.format);
+		return i.length > 0 ? (this.logger.error("🕸️ Rejected the command line", void 0, { reasons: i }), process.exitCode = 1, null) : {
+			format: a,
+			from: n,
+			to: r
+		};
+	}
+	parseConfig(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseDirectory(e) {
+		return this.configurationService.parsePathOption(e);
+	}
+	parseExclude(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseFileImports() {
+		return !0;
+	}
+	parseFormat(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseInclude(e) {
+		return this.configurationService.parseCommaDelimitedOption(e);
+	}
+	parseNestjsModules() {
+		return !0;
+	}
+	parseNoFileImports() {
+		return !1;
+	}
+	parseNoNestjsModules() {
+		return !1;
+	}
+	parseNoNxProjects() {
+		return !1;
+	}
+	parseNxProjects() {
+		return !0;
+	}
+	parseProjects(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseTags(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	async run(e, t = {}) {
+		try {
+			let n = this.validateInputs(e, t);
+			if (!n) return;
+			let r = await this.runContextService.build({
+				mode: "check",
+				options: t,
+				workingDirectory: l.resolve(t.directory ?? process.cwd())
+			}), i = await this.pathQueryService.query({
+				context: r,
+				from: n.from,
+				to: n.to
+			}), a = this.pathQueryService.render({
+				format: n.format,
+				results: i
+			});
+			process.stdout.write(`${a}\n`);
+		} catch (e) {
+			this.reportingService.reportFailure(e);
+		}
+	}
+};
+R([
+	M({
+		description: "Path to the codependix configuration file",
+		flags: "--config [config]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], J.prototype, "parseConfig", null), R([
+	M({
+		description: "Directory whose Nx workspace this run reads",
+		flags: "-d, --directory [directory]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", String)
+], J.prototype, "parseDirectory", null), R([
+	M({
+		description: "Comma-separated globs overriding the configured exclude. Refused when exclude was never configured",
+		flags: "--exclude [exclude]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Array)
+], J.prototype, "parseExclude", null), R([
+	M({
+		description: "Query the fileImports graph type",
+		flags: "--file-imports"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], J.prototype, "parseFileImports", null), R([
+	M({
+		description: `What to print to standard output, one of ${T.join(", ")} (default: ${x})`,
+		flags: "-f, --format [format]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], J.prototype, "parseFormat", null), R([
+	M({
+		description: "Comma-separated globs overriding the configured include. Refused when include was never configured",
+		flags: "--include [include]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Array)
+], J.prototype, "parseInclude", null), R([
+	M({
+		description: "Query the nestjsModules graph type",
+		flags: "--nestjs-modules"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], J.prototype, "parseNestjsModules", null), R([
+	M({
+		description: "Skip the fileImports graph type for this query",
+		flags: "--no-file-imports"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], J.prototype, "parseNoFileImports", null), R([
+	M({
+		description: "Skip the nestjsModules graph type for this query",
+		flags: "--no-nestjs-modules"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], J.prototype, "parseNoNestjsModules", null), R([
+	M({
+		description: "Skip the nxProjects graph type for this query",
+		flags: "--no-nx-projects"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], J.prototype, "parseNoNxProjects", null), R([
+	M({
+		description: "Query the nxProjects graph type",
+		flags: "--nx-projects"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", []),
+	L("design:returntype", Boolean)
+], J.prototype, "parseNxProjects", null), R([
+	M({
+		description: "Comma-separated project names or roots to search across, as globs, beyond those include already selects",
+		flags: "--projects [projects]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], J.prototype, "parseProjects", null), R([
+	M({
+		description: "Comma-separated Nx tags to search across, beyond what include already selects",
+		flags: "--tags [tags]"
+	}),
+	L("design:type", Function),
+	L("design:paramtypes", [Object]),
+	L("design:returntype", Object)
+], J.prototype, "parseTags", null), J = q = R([
+	A({
+		arguments: "<from> <to>",
+		description: "Find the shortest connecting path between two nodes in codependix graphs",
+		name: "path"
+	}),
+	n(),
+	L("design:paramtypes", [
+		v === void 0 ? Object : v,
+		B === void 0 ? Object : B,
+		D === void 0 ? Object : D,
+		k === void 0 ? Object : k,
+		h === void 0 ? Object : h
+	])
+], J);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-cli/src/modules/path/path.module.ts
+var Y = class {};
+Y = R([r({
+	controllers: [],
+	exports: [J],
+	imports: [
+		_,
+		E,
+		O,
+		m
+	],
+	providers: [J]
+})], Y);
+//#endregion
+//#region packages/ic-suite/codependix/codependix-cli/src/main.module.ts
+var X = class {};
+X = R([r({ imports: [
+	a.forRoot({
+		envFilePath: ".env",
+		isGlobal: !0,
+		validate: (e) => H.parse(e)
+	}),
+	o,
+	V,
+	G,
+	Y
+] })], X);
+//#endregion
+export { B as i, G as n, W as r, X as t };