@codometer/measurement 0.0.0-stage → 0.0.4

package/dist/src/index.js

@@ -0,0 +1,1150 @@
+import { ConsoleLogger as e, Global as t, Injectable as n, Module as r, Scope as i } from "@nestjs/common";
+import a from "node:path";
+import { existsSync as o, mkdirSync as s, readFileSync as c, readdirSync as l, statSync as u } from "node:fs";
+import d from "pino";
+import f from "ignore";
+import { ConfigurationModule as p, DEFAULT_INPUT_NAME as m, REPOSITORY_ROOT_MARKERS as ee } from "@codometer/configuration";
+import { LanguagesModule as te, LanguagesService as h } from "@codometer/languages";
+import { brotliCompressSync as g, constants as _, gzipSync as v } from "node:zlib";
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+function y(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 b(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/ic-suite/codometer/codometer-measurement/src/modules/customization/customization.service.ts
+var x = class {
+	constructor() {}
+	buildCommentResult(e, t) {
+		let n = (t[e.label] ?? []).filter((e) => e.breached);
+		return {
+			color: e.color,
+			count: n.length,
+			group: e.group,
+			instances: n.map((e) => ({
+				file: e.file,
+				line: e.line,
+				measured: e.measured
+			})),
+			label: e.label
+		};
+	}
+	countMatches(e, t) {
+		return e.filter((e) => t.some((t) => a.matchesGlob(e, t))).length;
+	}
+	analyze({ commentCounts: e, files: t, statistics: n, symbolCounts: r }) {
+		return n.map((n) => n.comment === void 0 ? {
+			color: n.color,
+			count: n.symbols === void 0 ? this.countMatches(t, n.patterns) : r[n.label] ?? 0,
+			group: n.group,
+			label: n.label
+		} : this.buildCommentResult(n, e));
+	}
+	buildCommentCounters(e) {
+		let t = [];
+		for (let n of e) {
+			let { comment: e, label: r } = n;
+			e !== void 0 && t.push({
+				budget: {
+					maximumCharacters: e.maximumCharacters,
+					maximumLines: e.maximumLines,
+					maximumWords: e.maximumWords,
+					severity: e.severity
+				},
+				kind: e.kind,
+				label: r,
+				language: e.language
+			});
+		}
+		return t;
+	}
+	buildSymbolCounters(e) {
+		return e.flatMap((e) => e.symbols === void 0 ? [] : [{
+			kinds: e.symbols.kinds,
+			label: e.label,
+			modifiers: e.symbols.modifiers ?? [],
+			patterns: e.patterns
+		}]);
+	}
+};
+x = b([n(), y("design:paramtypes", [])], x);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/customization/customization.module.ts
+var S = class {};
+S = b([r({
+	controllers: [],
+	exports: [x],
+	imports: [],
+	providers: [x]
+})], S);
+//#endregion
+//#region packages/logger/src/modules/logger/logger.constants.ts
+var ne = /^(\p{Extended_Pictographic}️?(?:‍\p{Extended_Pictographic}️?)*)\s+/u, re = /^([A-Za-z]+)/, ie = /* @__PURE__ */ new Set([
+	"built",
+	"cut",
+	"found",
+	"got",
+	"kept",
+	"left",
+	"lost",
+	"made",
+	"put",
+	"ran",
+	"read",
+	"rebuilt",
+	"sent",
+	"set",
+	"split",
+	"took",
+	"wrote"
+]), ae = /* @__PURE__ */ new Set([
+	"CommandFactory",
+	"ExceptionHandler",
+	"GraphQLModule",
+	"InstanceLoader",
+	"NestApplication",
+	"NestFactory",
+	"RouterExplorer",
+	"RoutesResolver",
+	"TypeOrmModule"
+]), C, w = class extends e {
+	static {
+		C = this;
+	}
+	constructor() {
+		super();
+	}
+	static isProduction = process.env.NODE_ENV === "production";
+	static rootLogger;
+	static writesToStandardError = !1;
+	child = C.root;
+	static createRootLogger() {
+		let e = process.env.LOG_LEVEL ?? "info";
+		return C.isProduction ? C.writesToStandardError ? d({ level: e }, d.destination(2)) : d({ level: e }) : d({
+			level: e,
+			transport: {
+				options: {
+					colorize: !0,
+					destination: C.writesToStandardError ? 2 : 1,
+					ignore: "pid,hostname,emoji",
+					messageFormat: "{emoji} {msg}",
+					singleLine: !0
+				},
+				target: "pino-pretty"
+			}
+		});
+	}
+	static logToStandardError() {
+		if (C.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;
+		}
+		C.writesToStandardError = !0;
+	}
+	assertConventionalMessage(e) {
+		if (C.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,
+			...C.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 = re.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") || ie.has(t);
+	}
+	parseMessage(e) {
+		let t = String(e), n = ne.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 && ae.has(e);
+	}
+	static get root() {
+		return C.rootLogger ??= C.createRootLogger(), C.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 = a.join(process.cwd(), "output");
+		return o(t) || s(t, { recursive: !0 }), a.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 = C.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);
+	}
+};
+w = C = b([n({ scope: i.TRANSIENT }), y("design:paramtypes", [])], w);
+//#endregion
+//#region packages/logger/src/modules/logger/logger.module.ts
+var T = class {};
+T = b([t(), r({
+	controllers: [],
+	exports: [w],
+	imports: [],
+	providers: [w]
+})], T);
+var oe = ".gitignore", E = /* @__PURE__ */ new Set([
+	".cts",
+	".mts",
+	".ts",
+	".tsx"
+]), D = /* @__PURE__ */ new Set([
+	".cjs",
+	".js",
+	".jsx",
+	".mjs"
+]), O = /* @__PURE__ */ new Set([
+	".markdown",
+	".md",
+	".mdx"
+]), k = /* @__PURE__ */ new Set([
+	".json",
+	".jsonc",
+	".jsonl"
+]), A = /* @__PURE__ */ new Set([".css"]), se = /* @__PURE__ */ new Set([
+	".hcl",
+	".tf",
+	".tfvars"
+]), ce = /* @__PURE__ */ new Set([
+	".bash",
+	".sh",
+	".zsh"
+]), le = /* @__PURE__ */ new Set([".sql"]), ue = /* @__PURE__ */ new Set([".toml"]), j = /* @__PURE__ */ new Set([".yaml", ".yml"]), M = /* @__PURE__ */ new Set([".ipynb"]), N = /\.(test|spec|unit\.test|integration\.test|end-to-end\.test)\.[cm]?[jt]sx?$/, P = class {
+	constructor() {}
+	toScopedPath(e, t) {
+		if (e.directory === "") return t;
+		let n = `${e.directory}/`;
+		if (t.startsWith(n)) return t.slice(n.length);
+	}
+	createScope(e) {
+		return {
+			directory: e.directory,
+			matcher: f({ ignorecase: !1 }).add(e.patterns)
+		};
+	}
+	isIgnored(e, t) {
+		let n = !1;
+		for (let r of e) {
+			let e = this.toScopedPath(r, t);
+			if (e === void 0 || e === "") continue;
+			let i = r.matcher.test(e);
+			i.ignored ? n = !0 : i.unignored && (n = !1);
+		}
+		return n;
+	}
+	readScope(e) {
+		if (o(e.filePath)) return this.createScope({
+			directory: e.directory,
+			patterns: c(e.filePath, "utf8").split("\n")
+		});
+	}
+};
+P = b([n(), y("design:paramtypes", [])], P);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/discovery/discovery.service.ts
+var F, I = F = class {
+	ignoreRulesService;
+	logger;
+	constructor(e, t) {
+		this.ignoreRulesService = e, this.logger = t, this.logger.setContext(F.name);
+	}
+	applyDirectoryIgnoreFile(e) {
+		let t = this.ignoreRulesService.readScope({
+			directory: e.relativeDirectory,
+			filePath: a.join(e.absoluteDirectory, oe)
+		});
+		return t === void 0 ? e : {
+			...e,
+			ignoreScopes: [...e.ignoreScopes, t]
+		};
+	}
+	filterByExtension(e, t) {
+		return e.filter((e) => t.has(a.extname(e).toLowerCase()));
+	}
+	isExcluded(e, t) {
+		return t.some((t) => a.matchesGlob(e, t));
+	}
+	isExhaustivelyExcluded(e, t) {
+		return t.some((t) => t.endsWith("/**") && a.matchesGlob(e, t.slice(0, -3)));
+	}
+	isIgnoredPath(e, t) {
+		return this.ignoreRulesService.isIgnored(e.ignoreScopes, t) || this.ignoreRulesService.isIgnored(e.excludeFromScopes, t);
+	}
+	listDiscoveredFiles(e) {
+		return this.walkDirectory({
+			absoluteDirectory: e.workingDirectory,
+			exclude: e.exclude,
+			excludeFromScopes: this.readExcludeFromScopes(e),
+			ignoreScopes: [],
+			relativeDirectory: ""
+		}).filter((t) => !this.isExcluded(t, e.exclude)).toSorted();
+	}
+	readDirectoryEntries(e) {
+		try {
+			return l(e.absoluteDirectory, { withFileTypes: !0 });
+		} catch (t) {
+			return this.logger.warn("📂 Skipped unreadable directory", void 0, {
+				path: e.absoluteDirectory,
+				reason: String(t)
+			}), [];
+		}
+	}
+	readExcludeFromScopes(e) {
+		let t = [];
+		for (let n of e.excludeFrom) {
+			let r = this.ignoreRulesService.readScope({
+				directory: "",
+				filePath: a.resolve(e.workingDirectory, n)
+			});
+			if (r === void 0) {
+				this.logger.warn("🙈 Skipped missing ignore file", void 0, { path: n });
+				continue;
+			}
+			t.push(r);
+		}
+		return t;
+	}
+	walkDirectory(e) {
+		let t = this.readDirectoryEntries(e), n = this.applyDirectoryIgnoreFile(e), r = [];
+		for (let i of t) {
+			if (i.isSymbolicLink() || i.name === ".git") continue;
+			let t = a.join(e.absoluteDirectory, i.name), o = e.relativeDirectory === "" ? i.name : `${e.relativeDirectory}/${i.name}`;
+			i.isDirectory() ? r.push(...this.walkSubdirectory({
+				...n,
+				absolutePath: t,
+				relativePath: o
+			})) : i.isFile() && !this.isIgnoredPath(n, o) && r.push(o);
+		}
+		return r;
+	}
+	walkSubdirectory(e) {
+		return this.isExhaustivelyExcluded(e.relativePath, e.exclude) || this.isIgnoredPath(e, `${e.relativePath}/`) ? [] : this.walkDirectory({
+			...e,
+			absoluteDirectory: e.absolutePath,
+			relativeDirectory: e.relativePath
+		});
+	}
+	categorize(e) {
+		let t = /* @__PURE__ */ new Set([...E, ...D]), n = e.filter((e) => t.has(a.extname(e)));
+		return {
+			cssFiles: this.filterByExtension(e, A),
+			files: e,
+			hclFiles: this.filterByExtension(e, se),
+			jsFiles: n.filter((e) => D.has(a.extname(e))),
+			jsonFiles: this.filterByExtension(e, k),
+			markdownFiles: this.filterByExtension(e, O),
+			notebookFiles: this.filterByExtension(e, M),
+			pyFiles: e.filter((e) => a.extname(e) === ".py"),
+			shellFiles: this.filterByExtension(e, ce),
+			sourceFiles: n,
+			sqlFiles: this.filterByExtension(e, le),
+			testFiles: n.filter((e) => N.test(e)),
+			tomlFiles: this.filterByExtension(e, ue),
+			tsFiles: n.filter((e) => E.has(a.extname(e))),
+			yamlFiles: this.filterByExtension(e, j)
+		};
+	}
+	discoverFiles(e) {
+		return this.categorize(this.listDiscoveredFiles(e));
+	}
+};
+I = F = b([n(), y("design:paramtypes", [P === void 0 ? Object : P, w === void 0 ? Object : w])], I);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/discovery/discovery.module.ts
+var L = class {};
+L = b([r({
+	controllers: [],
+	exports: [I],
+	imports: [T],
+	providers: [I, P]
+})], L);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/inputs/inputs.constants.ts
+var R = /[!*+?@[\]{}()]/, z = class extends Error {
+	constructor(e, t, n) {
+		super(`Input "${e}" starts at ${t}, which is outside ${n}. An input may reach out of the measured folder but not out of the repository holding it — write its directory relative to something inside.`), this.name = "InputOutsideRepositoryError";
+	}
+}, B, V = B = class {
+	logger;
+	constructor(e) {
+		this.logger = e, this.logger.setContext(B.name);
+	}
+	canDescend(e, t) {
+		let n = this.isHidden(t);
+		return e.includeBases.some((e) => n ? this.leadsToBase(e, t) : this.leadsToBase(e, t) || this.sitsInsideBase(e, t));
+	}
+	findBoundary(e) {
+		let t = a.resolve(e);
+		for (;;) {
+			let n = t;
+			if (ee.some((e) => o(a.join(n, e)))) return n;
+			let r = a.dirname(t);
+			if (r === t) return a.resolve(e);
+			t = r;
+		}
+	}
+	isHidden(e) {
+		return e.split("/").at(-1)?.startsWith(".") === !0;
+	}
+	isLinkedFile(e) {
+		try {
+			return u(e).isFile();
+		} catch (t) {
+			return this.logger.warn("🔗 Skipped unreadable link", void 0, {
+				path: e,
+				reason: String(t)
+			}), !1;
+		}
+	}
+	isMatched(e, t) {
+		return e.include.some((e) => a.matchesGlob(t, e)) && !e.exclude.some((e) => a.matchesGlob(t, e));
+	}
+	leadsToBase(e, t) {
+		return e === t || e.startsWith(`${t}/`);
+	}
+	readEntries(e) {
+		try {
+			return l(e, { withFileTypes: !0 });
+		} catch (t) {
+			return this.logger.warn("🎯 Skipped unreadable input directory", void 0, {
+				path: e,
+				reason: String(t)
+			}), [];
+		}
+	}
+	readInputPrefix(e, t) {
+		return a.relative(t, e).split(a.sep).join("/");
+	}
+	resolveEntryKind(e, t) {
+		return t.isDirectory() ? "directory" : t.isFile() || t.isSymbolicLink() && this.isLinkedFile(e) ? "file" : "other";
+	}
+	sitsInsideBase(e, t) {
+		return e === "" || t.startsWith(`${e}/`);
+	}
+	sitsInsideBoundary(e, t) {
+		return t === e || t.startsWith(`${e}${a.sep}`);
+	}
+	toIncludeBase(e) {
+		let t = [];
+		for (let n of e.split("/")) {
+			if (R.test(n)) break;
+			t.push(n);
+		}
+		return t.join("/");
+	}
+	walk(e) {
+		let t = [];
+		for (let n of this.readEntries(e.absoluteDirectory)) {
+			let r = a.join(e.absoluteDirectory, n.name), i = e.relativeDirectory === "" ? n.name : `${e.relativeDirectory}/${n.name}`, o = this.resolveEntryKind(r, n);
+			o === "directory" && this.canDescend(e, i) ? t.push(...this.walk({
+				...e,
+				absoluteDirectory: r,
+				relativeDirectory: i
+			})) : o === "file" && this.isMatched(e.input, i) && t.push(i);
+		}
+		return t;
+	}
+	matchFiles(e) {
+		let t = a.resolve(e.workingDirectory, e.input.directory), n = this.findBoundary(e.workingDirectory);
+		if (!this.sitsInsideBoundary(n, t)) throw new z(e.input.name, t, n);
+		let r = this.readInputPrefix(t, e.workingDirectory), i = this.walk({
+			absoluteDirectory: t,
+			includeBases: e.input.include.map((e) => this.toIncludeBase(e)),
+			input: e.input,
+			relativeDirectory: ""
+		}).toSorted();
+		return r === "" ? i : i.map((e) => `${r}/${e}`);
+	}
+};
+V = B = b([n(), y("design:paramtypes", [w === void 0 ? Object : w])], V);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/inputs/inputs.module.ts
+var H = class {};
+H = b([r({
+	controllers: [],
+	exports: [V],
+	imports: [T],
+	providers: [V]
+})], H);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/limits/limits.constants.ts
+var de = "files", fe = "custom", pe = "size", U = class extends Error {
+	constructor(e, t) {
+		super(`Input "${e}" matched no files, and a limit is written against its "${t}" metric. A limit says the files are there, so an empty match is a glob that stopped matching or a build that never ran — not a measurement of zero.`), this.name = "EmptyTargetError";
+	}
+}, W = class extends Error {
+	constructor(e, t) {
+		super(`Cannot bind the limit written against "${e}": ${t}`), this.name = "UnboundMetricError";
+	}
+}, G = class {
+	constructor() {}
+	bind(e) {
+		if (e.index.ambiguous.has(e.metricPath)) throw new W(e.path, `the "${e.target}" target measured more than one metric called "${e.metricPath}". Two configured statistics sharing a label is how that happens — rename one of them.`);
+		let t = e.index.metrics.get(e.metricPath);
+		return t === void 0 ? void 0 : {
+			files: e.index.files,
+			measured: t,
+			metric: e.metricPath,
+			target: e.target
+		};
+	}
+	describeBinding(e) {
+		return `the "${e.target}" target's "${e.metric}" metric`;
+	}
+	describeFailure(e) {
+		return e instanceof Error ? e.message : String(e);
+	}
+	describeTargets(e) {
+		return [...e.keys()].map((e) => `"${e}"`).join(", ");
+	}
+	findCandidates(e) {
+		let t = [];
+		for (let [n, r] of e.indexes) {
+			let i = `${n}.`;
+			if (!e.path.startsWith(i)) continue;
+			let a = this.bind({
+				index: r,
+				metricPath: e.path.slice(i.length),
+				path: e.path,
+				target: n
+			});
+			a !== void 0 && t.push(a);
+		}
+		let n = this.findDefaultCandidate(e);
+		return n !== void 0 && t.push(n), t;
+	}
+	findDefaultCandidate(e) {
+		if (e.defaultInput === void 0) return;
+		let t = e.indexes.get(e.defaultInput);
+		if (t === void 0) throw new W(e.path, `the configured default input "${e.defaultInput}" was never measured. Measured targets: ${this.describeTargets(e.indexes)}.`);
+		return this.bind({
+			index: t,
+			metricPath: e.path,
+			path: e.path,
+			target: e.defaultInput
+		});
+	}
+	resolve(e) {
+		let t = this.findCandidates(e), [n] = t;
+		if (n === void 0) throw new W(e.path, `nothing measured answers to it. Measured targets: ${this.describeTargets(e.indexes)}. Write the target's name in front of the metric path, or configure a default input.`);
+		if (t.length > 1) {
+			let n = t.map((e) => this.describeBinding(e)).join(", or ");
+			throw new W(e.path, `it could be ${n}. Write the target's name in front of the one it means.`);
+		}
+		if (n.files === 0) throw new U(n.target, n.metric);
+		return n;
+	}
+	evaluate(e) {
+		let t = [], n = [];
+		for (let r of e.configuration.limits) try {
+			let t = this.resolve({
+				defaultInput: e.configuration.defaultInput,
+				indexes: e.indexes,
+				path: r.metric
+			});
+			n.push({
+				breached: t.measured > r.value,
+				label: r.label,
+				limit: r.value,
+				measured: t.measured,
+				metric: t.metric,
+				severity: r.severity,
+				target: t.target
+			});
+		} catch (e) {
+			t.push({
+				metric: r.metric,
+				reason: this.describeFailure(e)
+			});
+		}
+		return {
+			failures: t,
+			limits: n
+		};
+	}
+};
+G = b([n(), y("design:paramtypes", [])], G);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/limits/metric-index.service.ts
+var K = class {
+	constructor() {}
+	addMetric(e) {
+		if (e.index.metrics.has(e.metricPath)) {
+			e.index.ambiguous.add(e.metricPath);
+			return;
+		}
+		e.index.metrics.set(e.metricPath, e.value), e.instances !== void 0 && e.index.instances.set(e.metricPath, e.instances);
+	}
+	buildTargetIndex(e) {
+		let t = {
+			ambiguous: /* @__PURE__ */ new Set(),
+			files: e.files,
+			instances: /* @__PURE__ */ new Map(),
+			metrics: /* @__PURE__ */ new Map()
+		};
+		return this.addMetric({
+			index: t,
+			metricPath: de,
+			value: e.files
+		}), e.size !== void 0 && this.addMetric({
+			index: t,
+			metricPath: pe,
+			value: e.size.bytes
+		}), e.language !== void 0 && this.indexLanguage(t, e.language), t;
+	}
+	describeDuplicate(e) {
+		return {
+			reason: `Two measured targets are called "${e}". A limit addresses its metric by target name, so the name has to belong to one of them; the second was dropped.`,
+			target: e
+		};
+	}
+	indexCounters(e, t, n) {
+		for (let [r, i] of Object.entries(t)) {
+			let t = n === "" ? r : `${n}.${r}`;
+			typeof i == "number" ? this.addMetric({
+				index: e,
+				metricPath: t,
+				value: i
+			}) : this.isCounterGroup(i) && this.indexCounters(e, i, t);
+		}
+	}
+	indexLanguage(e, t) {
+		let { custom: n, ...r } = t;
+		this.indexCounters(e, r, "");
+		for (let t of n) this.addMetric({
+			index: e,
+			instances: t.instances,
+			metricPath: `${fe}.${t.label}`,
+			value: t.count
+		});
+	}
+	isCounterGroup(e) {
+		return typeof e == "object" && !!e && !Array.isArray(e);
+	}
+	index(e) {
+		let t = [], n = /* @__PURE__ */ new Map();
+		for (let r of e) {
+			if (n.has(r.name)) {
+				t.push(this.describeDuplicate(r.name));
+				continue;
+			}
+			n.set(r.name, this.buildTargetIndex(r));
+		}
+		return {
+			duplicates: t,
+			indexes: n
+		};
+	}
+};
+K = b([n(), y("design:paramtypes", [])], K);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/limits/limits.module.ts
+var q = class {};
+q = b([r({
+	controllers: [],
+	exports: [G, K],
+	imports: [],
+	providers: [G, K]
+})], q);
+var me = { params: { [_.BROTLI_PARAM_QUALITY]: 11 } }, J = class extends Error {
+	constructor(e, t) {
+		super(`Cannot measure ${e}: ${t}`), this.name = "UnreadableTargetFileError";
+	}
+}, Y, X = Y = class {
+	logger;
+	constructor(e) {
+		this.logger = e, this.logger.setContext(Y.name);
+	}
+	compress(e, t) {
+		return {
+			brotli: () => g(e, me).length,
+			gzip: () => v(e, { level: 9 }).length,
+			none: () => e.length
+		}[t]();
+	}
+	measureFile(e, t) {
+		try {
+			return this.compress(c(e), t);
+		} catch (t) {
+			throw this.logger.error("🗜️ Failed to measure a target file", void 0, {
+				path: e,
+				reason: t instanceof Error ? t.message : String(t)
+			}), new J(e, String(t));
+		}
+	}
+	analyze(e) {
+		let t = 0;
+		for (let n of e.files) t += this.measureFile(a.resolve(e.workingDirectory, n), e.compression);
+		return {
+			bytes: t,
+			compression: e.compression,
+			files: e.files.length
+		};
+	}
+};
+X = Y = b([n(), y("design:paramtypes", [w === void 0 ? Object : w])], X);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/size/size.module.ts
+var Z = class {};
+Z = b([r({
+	controllers: [],
+	exports: [X],
+	imports: [T],
+	providers: [X]
+})], Z);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/measure/measure.constants.ts
+var he = {
+	css: {
+		atRules: 0,
+		comments: 0,
+		customProperties: 0,
+		declarations: 0,
+		files: 0,
+		lines: 0,
+		mediaQueries: 0,
+		rules: 0,
+		selectors: 0
+	},
+	custom: [],
+	folders: 0,
+	hcl: {
+		attributes: 0,
+		blocks: 0,
+		comments: 0,
+		files: 0,
+		interpolations: 0,
+		lines: 0,
+		outputs: 0,
+		resources: 0,
+		variables: 0
+	},
+	javascript: {
+		asyncFunctions: 0,
+		classes: 0,
+		commentLines: 0,
+		comments: 0,
+		constants: 0,
+		exported: 0,
+		externalPackages: 0,
+		files: 0,
+		functions: 0,
+		imports: 0,
+		methods: 0,
+		syncFunctions: 0,
+		testFiles: 0,
+		todos: 0
+	},
+	json: {
+		arrays: 0,
+		booleans: 0,
+		files: 0,
+		items: 0,
+		lines: 0,
+		maxDepth: 0,
+		nulls: 0,
+		numbers: 0,
+		objects: 0,
+		properties: 0,
+		strings: 0,
+		totalNodes: 0
+	},
+	jupyter: {
+		cells: 0,
+		classes: 0,
+		codeBlocks: 0,
+		codeCells: 0,
+		codeLines: 0,
+		decorators: 0,
+		executedCells: 0,
+		files: 0,
+		functions: 0,
+		headings: 0,
+		images: 0,
+		imports: 0,
+		links: 0,
+		markdownCells: 0,
+		markdownLines: 0,
+		maxDepth: 0,
+		outputs: 0,
+		properties: 0,
+		rawCells: 0,
+		totalNodes: 0
+	},
+	linesOfCode: 0,
+	markdown: {
+		blockQuotes: 0,
+		codeBlocks: 0,
+		files: 0,
+		headingLevel1: 0,
+		headingLevel2: 0,
+		headingLevel3: 0,
+		headingLevel4: 0,
+		headingLevel5: 0,
+		headingLevel6: 0,
+		images: 0,
+		inlineCode: 0,
+		lines: 0,
+		links: 0,
+		listItems: 0,
+		lists: 0,
+		paragraphs: 0,
+		tableRows: 0,
+		tables: 0,
+		taskListItems: 0,
+		thematicBreaks: 0
+	},
+	python: {
+		classes: 0,
+		commentLines: 0,
+		comments: 0,
+		constants: 0,
+		decorators: 0,
+		docstringLines: 0,
+		docstrings: 0,
+		files: 0,
+		functions: 0,
+		imports: 0,
+		lines: 0,
+		protocols: 0
+	},
+	repositoryBytes: 0,
+	shell: {
+		commentLines: 0,
+		comments: 0,
+		conditionals: 0,
+		exports: 0,
+		files: 0,
+		functions: 0,
+		lines: 0,
+		loops: 0,
+		pipelines: 0,
+		shebangs: 0,
+		variables: 0
+	},
+	sourceFiles: 0,
+	sql: {
+		comments: 0,
+		commonTableExpressions: 0,
+		creates: 0,
+		deletes: 0,
+		files: 0,
+		inserts: 0,
+		joins: 0,
+		lines: 0,
+		selects: 0,
+		statements: 0,
+		updates: 0
+	},
+	toml: {
+		arrays: 0,
+		arrayTables: 0,
+		comments: 0,
+		files: 0,
+		keys: 0,
+		lines: 0,
+		tables: 0
+	},
+	typescript: {
+		decorators: 0,
+		docComments: 0,
+		enums: 0,
+		files: 0,
+		genericDeclarations: 0,
+		interfaces: 0
+	},
+	yaml: {
+		aliases: 0,
+		anchors: 0,
+		comments: 0,
+		documents: 0,
+		files: 0,
+		keys: 0,
+		lines: 0,
+		mappings: 0,
+		maxDepth: 0,
+		scalars: 0,
+		sequences: 0
+	}
+}, Q = class {
+	discoveryService;
+	languagesService;
+	customizationService;
+	inputsService;
+	sizeService;
+	limitsService;
+	metricIndexService;
+	constructor(e, t, n, r, i, a, o) {
+		this.discoveryService = e, this.languagesService = t, this.customizationService = n, this.inputsService = r, this.sizeService = i, this.limitsService = a, this.metricIndexService = o;
+	}
+	analyzeFiles(e) {
+		let t = e.workingDirectory, { discoveredFiles: n } = e, r = this.languagesService.analyze({
+			commentCounters: e.commentCounters,
+			configuration: e.configuration,
+			discoveredFiles: n,
+			symbolCounters: e.symbolCounters,
+			workingDirectory: t
+		}), i = this.sizeService.analyze({
+			compression: "none",
+			files: n.files,
+			workingDirectory: t
+		}), a = {
+			...r.commentCounts,
+			...r.typescript.declarationCommentCounts
+		};
+		return {
+			css: { ...r.css },
+			custom: this.customizationService.analyze({
+				commentCounts: a,
+				files: n.files,
+				statistics: e.statistics,
+				symbolCounts: r.typescript.symbolCounts
+			}),
+			folders: this.getFolderCount(n.files),
+			hcl: { ...r.hcl },
+			javascript: this.buildJavascriptStatistics(r.typescript),
+			json: { ...r.json },
+			jupyter: { ...r.jupyter },
+			linesOfCode: r.typescript.lines + r.python.lines + r.jupyter.codeLines,
+			markdown: { ...r.markdown },
+			python: { ...r.python },
+			repositoryBytes: i.bytes,
+			shell: { ...r.shell },
+			sourceFiles: r.typescript.tsFiles + r.typescript.jsFiles + r.python.files,
+			sql: { ...r.sql },
+			toml: { ...r.toml },
+			typescript: this.buildTypescriptStatistics(r.typescript),
+			yaml: { ...r.yaml }
+		};
+	}
+	buildJavascriptStatistics(e) {
+		return {
+			asyncFunctions: e.asyncFunctions,
+			classes: e.classes,
+			commentLines: e.commentLines,
+			comments: e.comments,
+			constants: e.constants,
+			exported: e.exported,
+			externalPackages: e.externalPackages.size,
+			files: e.jsFiles,
+			functions: e.functions,
+			imports: e.imports,
+			methods: e.methods,
+			syncFunctions: e.syncFunctions,
+			testFiles: e.testFiles,
+			todos: e.todos
+		};
+	}
+	buildTypescriptStatistics(e) {
+		return {
+			decorators: e.decorators,
+			docComments: e.docComments,
+			enums: e.enums,
+			files: e.tsFiles,
+			genericDeclarations: e.genericDeclarations,
+			interfaces: e.interfaces
+		};
+	}
+	describeFailure(e) {
+		return e instanceof Error ? e.message : String(e);
+	}
+	discoverInputFiles(e, t) {
+		let n = e.name === m ? this.discoveryService.discoverFiles({
+			exclude: t.configuration.exclude,
+			excludeFrom: t.configuration.excludeFrom,
+			workingDirectory: t.workingDirectory
+		}).files : this.inputsService.matchFiles({
+			input: e,
+			workingDirectory: t.workingDirectory
+		});
+		return this.excludeOutputPaths(n, t.outputPaths);
+	}
+	excludeOutputPaths(e, t) {
+		if (t.length === 0) return e;
+		let n = new Set(t);
+		return e.filter((e) => !n.has(e));
+	}
+	getFolderCount(e) {
+		let t = /* @__PURE__ */ new Set();
+		for (let n of e) {
+			let e = n.split("/");
+			for (let n = 1; n < e.length; n++) t.add(e.slice(0, n).join("/"));
+		}
+		return t.size;
+	}
+	measureInput(e) {
+		let { input: t } = e, n = this.discoverInputFiles(t, e), r = this.runsAnalysis(t, "language") ? this.analyzeFiles({
+			commentCounters: e.commentCounters,
+			configuration: e.configuration,
+			discoveredFiles: this.discoveryService.categorize(n),
+			statistics: e.statistics,
+			symbolCounters: e.symbolCounters,
+			workingDirectory: e.workingDirectory
+		}) : void 0;
+		return {
+			files: n.length,
+			language: r,
+			name: t.name,
+			size: this.runsAnalysis(t, "size") ? this.sizeService.analyze({
+				compression: t.compression,
+				files: n,
+				workingDirectory: e.workingDirectory
+			}) : void 0
+		};
+	}
+	readLimitFailures(e) {
+		return e.map((e) => ({
+			kind: "limit",
+			reason: e.reason,
+			subject: e.metric
+		}));
+	}
+	runsAnalysis(e, t) {
+		return e.analyses.includes(t);
+	}
+	measure(e) {
+		let t = e.configuration.custom, n = this.customizationService.buildCommentCounters(t), r = this.customizationService.buildSymbolCounters(t), i = [], a = [];
+		for (let o of e.configuration.inputs) try {
+			a.push(this.measureInput({
+				commentCounters: n,
+				configuration: e.configuration,
+				input: o,
+				outputPaths: e.outputPaths,
+				statistics: t,
+				symbolCounters: r,
+				workingDirectory: e.workingDirectory
+			}));
+		} catch (e) {
+			i.push({
+				kind: "input",
+				reason: this.describeFailure(e),
+				subject: o.name
+			});
+		}
+		let { duplicates: o, indexes: s } = this.metricIndexService.index(a), c = this.limitsService.evaluate({
+			configuration: e.configuration,
+			indexes: s
+		}), l = a.find((e) => e.language !== void 0);
+		return {
+			failures: [
+				...i,
+				...o.map((e) => ({
+					kind: "input",
+					reason: e.reason,
+					subject: e.target
+				})),
+				...this.readLimitFailures(c.failures)
+			],
+			indexes: s,
+			inputs: a,
+			limits: c.limits,
+			statistics: l?.language ?? he
+		};
+	}
+};
+Q = b([n(), y("design:paramtypes", [
+	I === void 0 ? Object : I,
+	h === void 0 ? Object : h,
+	x === void 0 ? Object : x,
+	V === void 0 ? Object : V,
+	X === void 0 ? Object : X,
+	G === void 0 ? Object : G,
+	K === void 0 ? Object : K
+])], Q);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-measurement/src/modules/measure/measure.module.ts
+var $ = class {};
+$ = b([r({
+	controllers: [],
+	exports: [Q],
+	imports: [
+		p,
+		S,
+		L,
+		H,
+		te,
+		q,
+		T,
+		Z
+	],
+	providers: [Q]
+})], $);
+//#endregion
+export { S as CustomizationModule, x as CustomizationService, L as DiscoveryModule, I as DiscoveryService, U as EmptyTargetError, z as InputOutsideRepositoryError, H as InputsModule, V as InputsService, q as LimitsModule, G as LimitsService, $ as MeasureModule, Q as MeasureService, K as MetricIndexService, Z as SizeModule, X as SizeService, W as UnboundMetricError, J as UnreadableTargetFileError };