@conformetry/languages 0.0.1

package/dist/src/index.js

@@ -0,0 +1,1184 @@
+import { Injectable as e, Module as t } from "@nestjs/common";
+import { ConfigurationModule as n, ConfigurationService as r } from "@conformetry/configuration";
+import i from "node:fs";
+import a from "node:path";
+import { parse as o } from "jsonc-parser";
+import { toString as s } from "mdast-util-to-string";
+import { remark as c } from "remark";
+import l from "remark-gfm";
+import { spawnSync as ee } from "node:child_process";
+import { fileURLToPath as te } from "node:url";
+import { ScriptKind as u, ScriptTarget as ne, SyntaxKind as d, createSourceFile as re, forEachChild as ie, getLeadingCommentRanges as ae, isBigIntLiteral as f, isCallExpression as p, isDecorator as m, isExportDeclaration as oe, isExpressionStatement as se, isIdentifier as h, isImportDeclaration as ce, isNoSubstitutionTemplateLiteral as le, isNumericLiteral as g, isPrivateIdentifier as ue, isPropertyAccessExpression as de, isStringLiteral as _ } from "typescript";
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/differences/differences.constants.ts
+var fe = [
+	"javascript",
+	"json",
+	"markdown",
+	"python",
+	"text",
+	"typescript"
+], v = [
+	"code",
+	"comment",
+	"directory",
+	"file",
+	"instance"
+];
+//#endregion
+//#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/conformetry/conformetry-languages/src/modules/differences/differences.service.ts
+var x = class {
+	constructor() {}
+	buildMissingDirectoryDifference(e) {
+		return {
+			differenceType: "directory",
+			fix: `Create the directory ${e.instanceDirectoryPath} to match the template at ${e.templateDirectoryPath}.`,
+			message: `Missing directory: ${e.instanceDirectoryPath}`
+		};
+	}
+	buildMissingFileDifference(e) {
+		return {
+			differenceType: "file",
+			fix: `Create the file using the generator, or manually from the template at ${e.templateFilePath}.`,
+			message: `Missing file: ${e.instanceFilePath}`
+		};
+	}
+	resolveDifferenceType(e) {
+		return v.find((t) => t === e) ?? "code";
+	}
+	resolveErrorLanguage(e) {
+		return fe.find((t) => t === e);
+	}
+};
+x = b([e(), y("design:paramtypes", [])], x);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/differences/differences.module.ts
+var S = class {};
+S = b([t({
+	controllers: [],
+	exports: [x],
+	imports: [],
+	providers: [x]
+})], S);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/files/files.service.ts
+var C = class {
+	configurationService;
+	errorsService;
+	constructor(e, t) {
+		this.configurationService = e, this.errorsService = t;
+	}
+	buildMissingDifference(e) {
+		let t = a.dirname(e.instanceFilePath);
+		return i.existsSync(t) ? {
+			...this.errorsService.buildMissingFileDifference(e),
+			weight: 1
+		} : {
+			...this.errorsService.buildMissingDirectoryDifference({
+				instanceDirectoryPath: t,
+				templateDirectoryPath: a.dirname(e.templateFilePath)
+			}),
+			weight: e.expectedFileCount
+		};
+	}
+	countExpectedFiles(e) {
+		return e.expectedFiles.filter((t) => a.dirname(t.instanceFilePath) === e.parentDirectoryPath).length;
+	}
+	checkInstanceFiles(e) {
+		let t = this.configurationService.resolveInstanceFiles(e.instances), n = /* @__PURE__ */ new Set(), r = [];
+		for (let e of t) {
+			if (i.existsSync(e.instanceFilePath)) continue;
+			let o = a.dirname(e.instanceFilePath);
+			if (n.has(o)) continue;
+			let s = this.buildMissingDifference({
+				expectedFileCount: this.countExpectedFiles({
+					expectedFiles: t,
+					parentDirectoryPath: o
+				}),
+				...e
+			});
+			s.differenceType === "directory" && n.add(o), r.push({
+				differences: [s],
+				filename: a.basename(e.instanceFilePath),
+				instanceFilePath: e.instanceFilePath,
+				templateFilePath: e.templateFilePath,
+				totalWeight: s.weight
+			});
+		}
+		return {
+			fileResults: r,
+			totalWeight: t.length
+		};
+	}
+};
+C = b([e(), y("design:paramtypes", [r === void 0 ? Object : r, x === void 0 ? Object : x])], C);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/files/files.module.ts
+var w = class {};
+w = b([t({
+	controllers: [],
+	exports: [C],
+	imports: [n, S],
+	providers: [C]
+})], w);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/scoring/scoring.constants.ts
+var T = 1, E = 1, pe = 1, D = class {
+	constructor() {}
+	calculateScore(e) {
+		if (e.totalWeight <= 0) return 1;
+		let t = (e.totalWeight - e.failedWeight) / e.totalWeight;
+		return Math.min(1, Math.max(0, t));
+	}
+	sumWeights(e) {
+		return e.reduce((e, t) => e + (t.weight ?? 1), 0);
+	}
+};
+D = b([e(), y("design:paramtypes", [])], D);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/json/json-comparison.service.ts
+var O = class {
+	scoringService;
+	constructor(e) {
+		this.scoringService = e;
+	}
+	buildError(e) {
+		return {
+			...e.actual === void 0 ? {} : { actual: e.actual },
+			differenceType: "code",
+			...e.expected === void 0 ? {} : { expected: e.expected },
+			fix: e.fix,
+			instancePath: e.pathValue,
+			language: e.language,
+			message: e.message,
+			templatePath: e.pathValue,
+			weight: e.weight
+		};
+	}
+	combine(e) {
+		return e.reduce((e, t) => ({
+			differences: [...e.differences, ...t.differences],
+			totalWeight: e.totalWeight + t.totalWeight
+		}), {
+			differences: [],
+			totalWeight: 0
+		});
+	}
+	compareArrayItem(e) {
+		let t = this.formatPath(e.pathSegments), n = this.countNodes(e.templateItem);
+		return this.isJsonPrimitive(e.templateItem) ? e.instanceArray.includes(e.templateItem) ? {
+			differences: [],
+			totalWeight: n
+		} : {
+			differences: [this.buildError({
+				expected: JSON.stringify(e.templateItem),
+				fix: `Add ${JSON.stringify(e.templateItem)} to the array at "${t}".`,
+				language: e.language,
+				message: `Missing required array value ${JSON.stringify(e.templateItem)} at "${t}"`,
+				pathValue: t,
+				weight: n
+			})],
+			totalWeight: n
+		} : e.instanceArray.length === 0 ? {
+			differences: [this.buildError({
+				fix: `Add the required entry to the array at "${t}".`,
+				language: e.language,
+				message: `Missing required array structure at "${t}"`,
+				pathValue: t,
+				weight: n
+			})],
+			totalWeight: n
+		} : this.pickClosestMatch(e.instanceArray.map((t, n) => this.compare({
+			instanceValue: t,
+			language: e.language,
+			pathSegments: [...e.pathSegments, n],
+			templateValue: e.templateItem
+		})));
+	}
+	compareArrays(e) {
+		return this.combine(e.templateArray.map((t) => this.compareArrayItem({
+			...e,
+			templateItem: t
+		})));
+	}
+	compareObjects(e) {
+		return this.combine(Object.entries(e.templateObject).map(([t, n]) => {
+			let r = [...e.pathSegments, t], i = this.formatPath(r), a = e.instanceObject[t];
+			if (a === void 0) {
+				let t = this.countNodes(n);
+				return {
+					differences: [this.buildError({
+						expected: JSON.stringify(n),
+						fix: `Add the key "${i}" to the instance document.`,
+						language: e.language,
+						message: `Missing required key "${i}"`,
+						pathValue: i,
+						weight: t
+					})],
+					totalWeight: t
+				};
+			}
+			return this.compare({
+				instanceValue: a,
+				language: e.language,
+				pathSegments: r,
+				templateValue: n
+			});
+		}));
+	}
+	countContainer(e) {
+		return {
+			...e,
+			totalWeight: e.totalWeight + 1
+		};
+	}
+	countNodes(e) {
+		return Array.isArray(e) ? e.reduce((e, t) => e + this.countNodes(t), 1) : this.isJsonObject(e) ? Object.values(e).reduce((e, t) => e + this.countNodes(t), 1) : 1;
+	}
+	formatPath(e) {
+		return e.reduce((e, t) => typeof t == "number" ? `${e}[${String(t)}]` : e === "" ? t : `${e}.${t}`, "");
+	}
+	isJsonObject(e) {
+		return typeof e == "object" && !!e && !Array.isArray(e);
+	}
+	isJsonPrimitive(e) {
+		return typeof e != "object" || !e;
+	}
+	pickClosestMatch(e) {
+		return e.reduce((e, t) => this.scoringService.sumWeights(t.differences) < this.scoringService.sumWeights(e.differences) ? t : e);
+	}
+	compare(e) {
+		let t = e.pathSegments ?? [];
+		if (Array.isArray(e.templateValue) && Array.isArray(e.instanceValue)) return this.countContainer(this.compareArrays({
+			instanceArray: e.instanceValue,
+			language: e.language,
+			pathSegments: t,
+			templateArray: e.templateValue
+		}));
+		if (this.isJsonObject(e.templateValue) && this.isJsonObject(e.instanceValue)) return this.countContainer(this.compareObjects({
+			instanceObject: e.instanceValue,
+			language: e.language,
+			pathSegments: t,
+			templateObject: e.templateValue
+		}));
+		let n = this.countNodes(e.templateValue);
+		if (e.templateValue === e.instanceValue) return {
+			differences: [],
+			totalWeight: n
+		};
+		let r = this.formatPath(t);
+		return {
+			differences: [this.buildError({
+				actual: JSON.stringify(e.instanceValue),
+				expected: JSON.stringify(e.templateValue),
+				fix: `Set "${r}" to ${JSON.stringify(e.templateValue)}.`,
+				language: e.language,
+				message: `Expected ${JSON.stringify(e.templateValue)} at "${r}" but found ${JSON.stringify(e.instanceValue)}`,
+				pathValue: r,
+				weight: n
+			})],
+			totalWeight: n
+		};
+	}
+};
+O = b([e(), y("design:paramtypes", [D === void 0 ? Object : D])], O);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/scoring/scoring.module.ts
+var k = class {};
+k = b([t({
+	controllers: [],
+	exports: [D],
+	imports: [],
+	providers: [D]
+})], k);
+var me = {
+	description: "Checks JSON and JSONC structural conformance",
+	fileExtensions: [".json", ".jsonc"],
+	name: "json"
+}, A = class {
+	jsonComparisonService;
+	constructor(e) {
+		this.jsonComparisonService = e;
+	}
+	descriptor = me;
+	validateDocument(e) {
+		return this.jsonComparisonService.compare({
+			instanceValue: o(e.instance),
+			language: "json",
+			templateValue: o(e.renderedTemplate)
+		});
+	}
+};
+A = b([e(), y("design:paramtypes", [O === void 0 ? Object : O])], A);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/json/json.module.ts
+var j = class {};
+j = b([t({
+	controllers: [],
+	exports: [O, A],
+	imports: [k],
+	providers: [O, A]
+})], j);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/jupyter/jupyter-notebook.service.ts
+var M = class {
+	constructor() {}
+	groupSourcesByKind(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n of e) {
+			let e = this.readCellKind(n), r = t.get(e) ?? [];
+			r.push(this.readCellSource(n)), t.set(e, r);
+		}
+		return t;
+	}
+	readCellKind(e) {
+		return e.cell_type === "code" || e.cell_type === "markdown" ? e.cell_type : "raw";
+	}
+	readCellSource(e) {
+		if (typeof e.source == "string") return e.source;
+		let t = e.source;
+		return Array.isArray(t) ? t.filter((e) => typeof e == "string").join("") : "";
+	}
+	pairCells(e) {
+		let t = [], n = [], r = this.groupSourcesByKind(e.instanceNotebook.cells), i = /* @__PURE__ */ new Map();
+		for (let [a, o] of e.templateNotebook.cells.entries()) {
+			let e = this.readCellKind(o), s = i.get(e) ?? 0, c = r.get(e)?.[s], l = {
+				index: a,
+				instanceSource: c ?? "",
+				kind: e,
+				templateSource: this.readCellSource(o)
+			};
+			i.set(e, s + 1), c === void 0 ? t.push(l) : n.push(l);
+		}
+		return {
+			missingCells: t,
+			pairedCells: n
+		};
+	}
+	parseNotebook(e) {
+		let t = o(e);
+		if (typeof t != "object" || !t) return { cells: [] };
+		let n = t.cells;
+		return Array.isArray(n) ? { cells: n.filter((e) => typeof e == "object" && !!e) } : { cells: [] };
+	}
+};
+M = b([e(), y("design:paramtypes", [])], M);
+var he = {
+	description: "Checks markdown structural conformance using mdast",
+	fileExtensions: [".md"],
+	name: "markdown"
+}, N = /* @__PURE__ */ new Set([
+	"blockquote",
+	"document",
+	"list",
+	"listItem",
+	"root",
+	"table",
+	"tableCell",
+	"tableRow"
+]), P = /* @__PURE__ */ new Set(["text"]), F = class {
+	constructor() {}
+	matchersByType = {
+		code: (e, t) => this.sameField(e.lang, t.lang) && this.sameField(e.value, t.value),
+		heading: (e, t) => e.depth === t.depth && this.readText(e) === this.readText(t),
+		html: (e, t) => this.sameField(e.value, t.value),
+		image: (e, t) => this.sameField(e.url, t.url) && this.sameField(e.alt, t.alt),
+		inlineCode: (e, t) => this.sameField(e.value, t.value),
+		link: (e, t) => this.sameField(e.url, t.url) && this.readText(e) === this.readText(t),
+		list: (e, t) => e.ordered === t.ordered,
+		table: (e, t) => this.readColumnCount(e) === this.readColumnCount(t),
+		tableRow: (e, t) => this.readChildren(e).length === this.readChildren(t).length,
+		text: (e, t) => this.sameField(e.value, t.value),
+		thematicBreak: () => !0
+	};
+	readColumnCount(e) {
+		let t = this.readChildren(e)[0];
+		return t === void 0 ? 0 : this.readChildren(t).length;
+	}
+	sameField(e, t) {
+		return (e ?? "") === (t ?? "");
+	}
+	countSubtree(e) {
+		return P.has(e.type) ? 0 : this.readChildren(e).reduce((e, t) => e + this.countSubtree(t), 1);
+	}
+	filterNodes(e) {
+		return e.filter((e) => typeof e == "object" && !!e && "type" in e);
+	}
+	matches(e) {
+		let { instanceNode: t, templateNode: n } = e;
+		if (n.type !== t.type) return !1;
+		let r = this.matchersByType[n.type];
+		return r === void 0 ? this.readText(n) === this.readText(t) : r(n, t);
+	}
+	readChildren(e) {
+		return e.children ?? [];
+	}
+	readText(e) {
+		return s(e);
+	}
+};
+F = b([e(), y("design:paramtypes", [])], F);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/markdown/markdown-tree.service.ts
+var I = class {
+	markdownNodesService;
+	scoringService;
+	constructor(e, t) {
+		this.markdownNodesService = e, this.scoringService = t;
+	}
+	buildError(e) {
+		let t = e.lastMatchedNode?.position?.end?.line;
+		return {
+			instanceLine: t === void 0 ? void 0 : t + 1,
+			nodeType: e.templateChild.type,
+			text: this.markdownNodesService.readText(e.templateChild),
+			weight: this.markdownNodesService.countSubtree(e.templateChild)
+		};
+	}
+	compareContainer(e) {
+		let t = this.findCandidates(e);
+		if (t.length === 0) {
+			let t = this.buildError(e);
+			return {
+				differences: [t],
+				lastMatchedNode: e.lastMatchedNode,
+				totalWeight: t.weight
+			};
+		}
+		let n = this.markdownNodesService.readChildren(e.templateChild);
+		return n.length === 0 ? {
+			differences: [],
+			lastMatchedNode: t.at(-1),
+			totalWeight: 1
+		} : t.map((e) => {
+			let t = this.compareChildren({
+				instanceChildren: this.markdownNodesService.readChildren(e),
+				templateChildren: n
+			});
+			return {
+				differences: t.differences,
+				lastMatchedNode: e,
+				totalWeight: t.totalWeight + 1
+			};
+		}).reduce((e, t) => this.scoringService.sumWeights(t.differences) < this.scoringService.sumWeights(e.differences) ? t : e);
+	}
+	compareLeaf(e) {
+		let t = this.findCandidates(e), n = this.markdownNodesService.countSubtree(e.templateChild);
+		return t.length === 0 ? {
+			differences: [this.buildError(e)],
+			lastMatchedNode: e.lastMatchedNode,
+			totalWeight: n
+		} : {
+			differences: [],
+			lastMatchedNode: t.at(-1),
+			totalWeight: n
+		};
+	}
+	findCandidates(e) {
+		return e.instanceChildren.filter((t) => this.markdownNodesService.matches({
+			instanceNode: t,
+			templateNode: e.templateChild
+		}));
+	}
+	compareChildren(e) {
+		let t = [], n, r = 0;
+		for (let i of e.templateChildren) {
+			if (P.has(i.type)) continue;
+			let a = N.has(i.type) ? this.compareContainer({
+				instanceChildren: e.instanceChildren,
+				lastMatchedNode: n,
+				templateChild: i
+			}) : this.compareLeaf({
+				instanceChildren: e.instanceChildren,
+				lastMatchedNode: n,
+				templateChild: i
+			});
+			t.push(...a.differences), n = a.lastMatchedNode, r += a.totalWeight;
+		}
+		return {
+			differences: t,
+			totalWeight: r
+		};
+	}
+};
+I = b([e(), y("design:paramtypes", [F === void 0 ? Object : F, D === void 0 ? Object : D])], I);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/markdown/markdown.service.ts
+var L = class {
+	markdownNodesService;
+	markdownTreeService;
+	constructor(e, t) {
+		this.markdownNodesService = e, this.markdownTreeService = t;
+	}
+	processor = c().use(l);
+	descriptor = he;
+	validateDocument(e) {
+		let t = this.processor.parse(e.renderedTemplate), n = this.processor.parse(e.instance), r = this.markdownTreeService.compareChildren({
+			instanceChildren: this.markdownNodesService.filterNodes(n.children),
+			templateChildren: this.markdownNodesService.filterNodes(t.children)
+		});
+		return {
+			differences: r.differences.map((e) => ({
+				differenceType: "code",
+				expected: e.text,
+				fix: `Add the ${e.nodeType} "${e.text}" to the instance file.`,
+				...e.instanceLine === void 0 ? {} : { instanceLine: e.instanceLine },
+				language: "markdown",
+				message: `Missing markdown ${e.nodeType}: "${e.text}"`,
+				weight: e.weight
+			})),
+			totalWeight: r.totalWeight
+		};
+	}
+};
+L = b([e(), y("design:paramtypes", [F === void 0 ? Object : F, I === void 0 ? Object : I])], L);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/markdown/markdown.module.ts
+var R = class {};
+R = b([t({
+	controllers: [],
+	exports: [L],
+	imports: [k],
+	providers: [
+		F,
+		L,
+		I
+	]
+})], R);
+var ge = {
+	description: "Checks Python structure and comments against templates",
+	fileExtensions: [".py"],
+	name: "python"
+}, z = "python3", _e = "python.bridge", ve = "Install Python 3 and ensure `python3` is on PATH; conformetry validates Python files through the interpreter's own ast module.", B = class {
+	errorsService;
+	scoringService;
+	constructor(e, t) {
+		this.errorsService = e, this.scoringService = t;
+	}
+	pythonRootPath = a.resolve(a.dirname(te(import.meta.url)), "..", "..");
+	buildBridgeError(e) {
+		return {
+			differences: [{
+				differenceType: "code",
+				fix: ve,
+				language: "python",
+				message: e
+			}],
+			totalWeight: 1
+		};
+	}
+	readLocations(e) {
+		let t = this.readNumber(e, "instance_column"), n = this.readNumber(e, "instance_line"), r = this.readNumber(e, "template_column"), i = this.readNumber(e, "template_line");
+		return {
+			...t === void 0 ? {} : { instanceColumn: t },
+			...n === void 0 ? {} : { instanceLine: n },
+			...r === void 0 ? {} : { templateColumn: r },
+			...i === void 0 ? {} : { templateLine: i }
+		};
+	}
+	readNumber(e, t) {
+		let n = e[t];
+		return typeof n == "number" ? n : void 0;
+	}
+	readString(e, t) {
+		let n = e[t];
+		return typeof n == "string" ? n : void 0;
+	}
+	readValues(e) {
+		let t = this.readString(e, "actual"), n = this.readString(e, "expected");
+		return {
+			...t === void 0 ? {} : { actual: t },
+			...n === void 0 ? {} : { expected: n }
+		};
+	}
+	toConformetryDifference(e) {
+		return {
+			...this.readValues(e),
+			...this.readLocations(e),
+			differenceType: this.errorsService.resolveDifferenceType(e.difference_type),
+			fix: this.readString(e, "fix") ?? "Fix the conformance issue.",
+			language: this.errorsService.resolveErrorLanguage(e.language) ?? "python",
+			message: this.readString(e, "message") ?? "Python conformance issue found.",
+			weight: this.readNumber(e, "weight") ?? 1
+		};
+	}
+	validatePythonSource(e) {
+		let t = ee(z, ["-m", _e], {
+			cwd: this.pythonRootPath,
+			encoding: "utf8",
+			env: {
+				...process.env,
+				PYTHONPATH: this.pythonRootPath
+			},
+			input: JSON.stringify(e)
+		});
+		if (t.error !== void 0) return this.buildBridgeError(`Could not run ${z}: ${t.error.message}`);
+		if (t.status !== 0) return this.buildBridgeError(`Python validator exited with status ${String(t.status)}: ${t.stderr || t.stdout}`);
+		try {
+			let e = JSON.parse(t.stdout), n = e.differences.map((e) => this.toConformetryDifference(e));
+			return {
+				differences: n,
+				totalWeight: typeof e.total_weight == "number" ? e.total_weight : this.scoringService.sumWeights(n)
+			};
+		} catch {
+			return this.buildBridgeError("Python validator returned output that could not be parsed.");
+		}
+	}
+};
+B = b([e(), y("design:paramtypes", [x === void 0 ? Object : x, D === void 0 ? Object : D])], B);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/python/python.service.ts
+var V = class {
+	pythonBridgeService;
+	constructor(e) {
+		this.pythonBridgeService = e;
+	}
+	descriptor = ge;
+	validateDocument(e) {
+		return this.pythonBridgeService.validatePythonSource({
+			filename: e.filename,
+			instance: e.instance,
+			template: e.renderedTemplate
+		});
+	}
+};
+V = b([e(), y("design:paramtypes", [B === void 0 ? Object : B])], V);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/python/python.module.ts
+var H = class {};
+H = b([t({
+	controllers: [],
+	exports: [B, V],
+	imports: [S, k],
+	providers: [B, V]
+})], H);
+var ye = {
+	description: "Checks Jupyter notebook structure, markdown cells, and code cells",
+	fileExtensions: [".ipynb"],
+	name: "jupyter"
+}, be = [
+	"metadata",
+	"nbformat",
+	"nbformat_minor"
+], U = class {
+	jsonComparisonService;
+	jupyterNotebookService;
+	markdownService;
+	pythonBridgeService;
+	constructor(e, t, n, r) {
+		this.jsonComparisonService = e, this.jupyterNotebookService = t, this.markdownService = n, this.pythonBridgeService = r;
+	}
+	descriptor = ye;
+	attributeToCell(e) {
+		return e.differences.map((t) => ({
+			...t,
+			message: `Cell ${String(e.cell.index + 1)} (${e.cell.kind}): ${t.message}`
+		}));
+	}
+	readEnvelope(e) {
+		let t = o(e);
+		if (typeof t != "object" || !t || Array.isArray(t)) return {};
+		let n = {};
+		for (let e of be) {
+			let r = t[e];
+			r !== void 0 && (n[e] = r);
+		}
+		return n;
+	}
+	validateCell(e) {
+		let { cell: t } = e;
+		if (t.kind === "markdown") {
+			let n = this.markdownService.validateDocument({
+				...e.document,
+				instance: t.instanceSource,
+				renderedTemplate: t.templateSource
+			});
+			return {
+				differences: this.attributeToCell({
+					cell: t,
+					differences: n.differences
+				}),
+				totalWeight: n.totalWeight
+			};
+		}
+		if (t.kind === "code") {
+			let n = this.pythonBridgeService.validatePythonSource({
+				filename: `${e.document.filename}#cell-${String(t.index + 1)}.py`,
+				instance: t.instanceSource,
+				template: t.templateSource
+			});
+			return {
+				differences: this.attributeToCell({
+					cell: t,
+					differences: n.differences
+				}),
+				totalWeight: n.totalWeight
+			};
+		}
+		return {
+			differences: [],
+			totalWeight: 0
+		};
+	}
+	weighMissingCell(e) {
+		return this.validateCell({
+			cell: {
+				...e.cell,
+				instanceSource: ""
+			},
+			document: e.document
+		}).totalWeight;
+	}
+	validateDocument(e) {
+		let t = this.jupyterNotebookService.parseNotebook(e.renderedTemplate), n = this.jupyterNotebookService.parseNotebook(e.instance), { missingCells: r, pairedCells: i } = this.jupyterNotebookService.pairCells({
+			instanceNotebook: n,
+			templateNotebook: t
+		}), a = this.jsonComparisonService.compare({
+			instanceValue: this.readEnvelope(e.instance),
+			language: "json",
+			templateValue: this.readEnvelope(e.renderedTemplate)
+		}), o = r.map((t) => {
+			let n = this.weighMissingCell({
+				cell: t,
+				document: e
+			});
+			return {
+				error: {
+					differenceType: "code",
+					expected: t.templateSource,
+					fix: `Add a ${t.kind} cell matching the template's cell ${String(t.index + 1)}.`,
+					language: "python",
+					message: `Missing ${t.kind} cell ${String(t.index + 1)}`,
+					weight: n
+				},
+				weight: n
+			};
+		}), s = i.map((t) => this.validateCell({
+			cell: t,
+			document: e
+		}));
+		return {
+			differences: [
+				...a.differences,
+				...o.map((e) => e.error),
+				...s.flatMap((e) => e.differences)
+			],
+			totalWeight: [
+				a.totalWeight,
+				...o.map((e) => e.weight),
+				...s.map((e) => e.totalWeight)
+			].reduce((e, t) => e + t, 0)
+		};
+	}
+};
+U = b([e(), y("design:paramtypes", [
+	O === void 0 ? Object : O,
+	M === void 0 ? Object : M,
+	L === void 0 ? Object : L,
+	B === void 0 ? Object : B
+])], U);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/jupyter/jupyter.module.ts
+var W = class {};
+W = b([t({
+	controllers: [],
+	exports: [U],
+	imports: [
+		j,
+		R,
+		H
+	],
+	providers: [M, U]
+})], W);
+var xe = {
+	description: "Checks text files using duplicate-aware line conformance",
+	fileExtensions: [".txt"],
+	name: "text"
+}, G = class {
+	constructor() {}
+	descriptor = xe;
+	countLines(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n of e.split("\n")) t.set(n, (t.get(n) ?? 0) + 1);
+		return t;
+	}
+	findMissingLines(e) {
+		let t = this.countLines(e.instance), n = [];
+		for (let [r, i] of e.renderedTemplate.split("\n").entries()) {
+			let e = t.get(i) ?? 0;
+			e === 0 ? n.push({
+				line: i,
+				templateLine: r + 1
+			}) : t.set(i, e - 1);
+		}
+		return n;
+	}
+	validateDocument(e) {
+		return {
+			differences: this.findMissingLines(e).map((e) => ({
+				differenceType: "code",
+				expected: e.line,
+				fix: `Add the line \`${e.line}\` to the instance file.`,
+				language: "text",
+				message: `Missing line: ${e.line}`,
+				templateLine: e.templateLine
+			})),
+			totalWeight: e.renderedTemplate.split("\n").length
+		};
+	}
+};
+G = b([e(), y("design:paramtypes", [])], G);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/text/text.module.ts
+var K = class {};
+K = b([t({
+	controllers: [],
+	exports: [G],
+	imports: [],
+	providers: [G]
+})], K);
+var Se = {
+	description: "Checks TypeScript AST structure and required comments",
+	fileExtensions: [".ts", ".tsx"],
+	name: "typescript"
+}, Ce = /\bTODO\b/u, q = class {
+	constructor() {}
+	compareComments(e) {
+		let t = this.extractComments(e.instanceSourceFile), n = this.extractComments(e.templateSourceFile), r = [], i = 0;
+		for (let e of n) {
+			let n = Ce.test(e.text), a = t.slice(i).findIndex((t) => n || t.text === e.text);
+			if (a === -1) {
+				r.push(e);
+				continue;
+			}
+			i += a + 1;
+		}
+		return {
+			missingComments: r,
+			totalWeight: n.length
+		};
+	}
+	extractComments(e) {
+		let t = /* @__PURE__ */ new Map(), n = (r) => {
+			let i = r.getChildren(e);
+			if (i.length === 0) {
+				for (let n of ae(e.text, r.getFullStart()) ?? []) t.set(n.pos, {
+					position: n.pos,
+					text: e.text.slice(n.pos, n.end).trim()
+				});
+				return;
+			}
+			for (let e of i) n(e);
+		};
+		return n(e), [...t.values()].toSorted((e, t) => e.position - t.position);
+	}
+};
+q = b([e(), y("design:paramtypes", [])], q);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/typescript/typescript-nodes.service.ts
+var J = class {
+	constructor() {}
+	buildDottedName(e) {
+		let t = [], n = e;
+		for (; de(n);) t.unshift(n.name.text), n = n.expression;
+		return h(n) ? (t.unshift(n.text), t.join(".")) : null;
+	}
+	isNode(e) {
+		return typeof e == "object" && !!e && "kind" in e && typeof e.kind == "number";
+	}
+	readDecoratorKey(e) {
+		return this.buildDottedName(p(e.expression) ? e.expression.expression : e.expression);
+	}
+	readExportKey(e) {
+		let { moduleSpecifier: t } = e;
+		return t === void 0 || !_(t) ? null : t.text;
+	}
+	readExpressionStatementKey(e) {
+		if (!p(e)) return null;
+		let t = this.buildDottedName(e.expression);
+		if (t === null) return null;
+		let n = e.arguments[0], r = n === void 0 ? void 0 : this.readLiteralKey(n);
+		return r === void 0 ? t : `${t}:${r}`;
+	}
+	readImportKey(e) {
+		return _(e.moduleSpecifier) ? e.moduleSpecifier.text : null;
+	}
+	readLiteralKey(e) {
+		if (h(e) || _(e) || g(e) || f(e) || le(e)) return e.text;
+	}
+	readNamedKey(e) {
+		if (!("name" in e)) return null;
+		let t = e.name;
+		return this.isNode(t) && (h(t) || ue(t) || _(t) || g(t)) ? t.text : null;
+	}
+	countSubtree(e) {
+		return this.readChildren(e).reduce((e, t) => e + this.countSubtree(t), 1);
+	}
+	readChildren(e) {
+		let t = [];
+		return ie(e, (e) => {
+			e.kind !== d.EndOfFileToken && t.push(e);
+		}), t;
+	}
+	readKey(e) {
+		if (ce(e)) return this.readImportKey(e);
+		if (oe(e)) return this.readExportKey(e);
+		if (m(e)) return this.readDecoratorKey(e);
+		if (se(e)) {
+			let t = this.readExpressionStatementKey(e.expression);
+			if (t !== null) return t;
+		}
+		return this.readLiteralKey(e) ?? this.readNamedKey(e);
+	}
+	readKindLabel(e) {
+		return d[e.kind];
+	}
+};
+J = b([e(), y("design:paramtypes", [])], J);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/typescript/typescript-tree.service.ts
+var Y = class {
+	scoringService;
+	typeScriptNodesService;
+	constructor(e, t) {
+		this.scoringService = e, this.typeScriptNodesService = t;
+	}
+	buildError(e) {
+		return {
+			instancePosition: e.instanceNode.getStart(),
+			kindLabel: this.typeScriptNodesService.readKindLabel(e.templateChild),
+			nodeKey: e.nodeKey ?? void 0,
+			templatePosition: e.templateChild.getStart(),
+			weight: this.typeScriptNodesService.countSubtree(e.templateChild)
+		};
+	}
+	compareBestCandidate(e) {
+		return e.candidates.map((t) => this.compareTree({
+			instanceNode: t,
+			templateNode: e.templateChild
+		})).reduce((e, t) => this.scoringService.sumWeights(t.differences) < this.scoringService.sumWeights(e.differences) ? t : e);
+	}
+	compareChild(e) {
+		let t = this.typeScriptNodesService.readKey(e.templateChild), n = t === null ? e.instanceChildren.filter((t) => t.kind === e.templateChild.kind) : e.instanceChildren.filter((e) => this.typeScriptNodesService.readKey(e) === t);
+		if (n.length === 0) {
+			let n = this.buildError({
+				instanceNode: e.instanceNode,
+				nodeKey: t,
+				templateChild: e.templateChild
+			});
+			return {
+				differences: [n],
+				totalWeight: n.weight
+			};
+		}
+		return this.compareBestCandidate({
+			candidates: n,
+			templateChild: e.templateChild
+		});
+	}
+	compareTree(e) {
+		let t = this.typeScriptNodesService.readChildren(e.instanceNode);
+		return this.typeScriptNodesService.readChildren(e.templateNode).map((n) => this.compareChild({
+			instanceChildren: t,
+			instanceNode: e.instanceNode,
+			templateChild: n
+		})).reduce((e, t) => ({
+			differences: [...e.differences, ...t.differences],
+			totalWeight: e.totalWeight + t.totalWeight
+		}), {
+			differences: [],
+			totalWeight: 1
+		});
+	}
+};
+Y = b([e(), y("design:paramtypes", [D === void 0 ? Object : D, J === void 0 ? Object : J])], Y);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/typescript/typescript.service.ts
+var X = class {
+	typeScriptCommentsService;
+	typeScriptTreeService;
+	constructor(e, t) {
+		this.typeScriptCommentsService = e, this.typeScriptTreeService = t;
+	}
+	descriptor = Se;
+	parseSourceFile(e) {
+		return re(e.filename, e.content, ne.Latest, !0, e.filename.endsWith(".tsx") ? u.TSX : u.TS);
+	}
+	readLocation(e) {
+		if (e.position === void 0 || e.position < 0) return;
+		let { character: t, line: n } = e.sourceFile.getLineAndCharacterOfPosition(e.position);
+		return {
+			column: t + 1,
+			line: n + 1
+		};
+	}
+	validateComments(e) {
+		let t = this.typeScriptCommentsService.compareComments(e);
+		return {
+			differences: t.missingComments.map((t) => {
+				let n = this.readLocation({
+					position: t.position,
+					sourceFile: e.templateSourceFile
+				});
+				return {
+					differenceType: "comment",
+					expected: t.text,
+					fix: `Add the comment ${t.text} to the instance file, in the order the template declares it.`,
+					language: "typescript",
+					message: `Missing comment ${t.text}`,
+					...n === void 0 ? {} : {
+						templateColumn: n.column,
+						templateLine: n.line
+					}
+				};
+			}),
+			totalWeight: t.totalWeight
+		};
+	}
+	validateStructure(e) {
+		let t = this.typeScriptTreeService.compareTree({
+			instanceNode: e.instanceSourceFile,
+			templateNode: e.templateSourceFile
+		});
+		return {
+			differences: t.differences.map((t) => {
+				let n = t.nodeKey === void 0 ? t.kindLabel : `${t.kindLabel} "${t.nodeKey}"`, r = this.readLocation({
+					position: t.instancePosition,
+					sourceFile: e.instanceSourceFile
+				}), i = this.readLocation({
+					position: t.templatePosition,
+					sourceFile: e.templateSourceFile
+				});
+				return {
+					differenceType: "code",
+					fix: `Add the missing ${n} to the instance file. See the template for the expected structure.`,
+					...r === void 0 ? {} : {
+						instanceColumn: r.column,
+						instanceLine: r.line
+					},
+					language: "typescript",
+					message: `Missing ${n}`,
+					...i === void 0 ? {} : {
+						templateColumn: i.column,
+						templateLine: i.line
+					},
+					weight: t.weight
+				};
+			}),
+			totalWeight: t.totalWeight
+		};
+	}
+	validateDocument(e) {
+		let t = {
+			instanceSourceFile: this.parseSourceFile({
+				content: e.instance,
+				filename: e.filename
+			}),
+			templateSourceFile: this.parseSourceFile({
+				content: e.renderedTemplate,
+				filename: e.filename
+			})
+		}, n = this.validateStructure(t), r = this.validateComments(t);
+		return {
+			differences: [...n.differences, ...r.differences],
+			totalWeight: n.totalWeight + r.totalWeight
+		};
+	}
+};
+X = b([e(), y("design:paramtypes", [q === void 0 ? Object : q, Y === void 0 ? Object : Y])], X);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/typescript/typescript.module.ts
+var Z = class {};
+Z = b([t({
+	controllers: [],
+	exports: [X],
+	imports: [k],
+	providers: [
+		q,
+		J,
+		Y,
+		X
+	]
+})], Z);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/languages/languages.service.ts
+var Q = class {
+	jsonService;
+	jupyterService;
+	markdownService;
+	pythonService;
+	textService;
+	typescriptService;
+	constructor(e, t, n, r, i, a) {
+		this.jsonService = e, this.jupyterService = t, this.markdownService = n, this.pythonService = r, this.textService = i, this.typescriptService = a;
+	}
+	claimingLanguages() {
+		return [
+			this.jsonService,
+			this.jupyterService,
+			this.markdownService,
+			this.pythonService,
+			this.typescriptService
+		];
+	}
+	widenFallback(e) {
+		let t = this.textService;
+		return {
+			descriptor: {
+				...t.descriptor,
+				fileExtensions: [...t.descriptor.fileExtensions, ...e]
+			},
+			validateDocument: (e) => t.validateDocument(e)
+		};
+	}
+	resolveValidators(e) {
+		let t = this.claimingLanguages().filter((t) => t.descriptor.fileExtensions.some((t) => e.extensions.includes(t))), n = new Set(t.flatMap((e) => [...e.descriptor.fileExtensions])), r = e.extensions.filter((e) => !n.has(e));
+		return r.length === 0 ? t : [...t, this.widenFallback(r)];
+	}
+};
+Q = b([e(), y("design:paramtypes", [
+	A === void 0 ? Object : A,
+	U === void 0 ? Object : U,
+	L === void 0 ? Object : L,
+	V === void 0 ? Object : V,
+	G === void 0 ? Object : G,
+	X === void 0 ? Object : X
+])], Q);
+//#endregion
+//#region packages/ic-suite/conformetry/conformetry-languages/src/modules/languages/languages.module.ts
+var $ = class {};
+$ = b([t({
+	controllers: [],
+	exports: [
+		j,
+		W,
+		Q,
+		R,
+		H,
+		K,
+		Z
+	],
+	imports: [
+		j,
+		W,
+		R,
+		H,
+		K,
+		Z
+	],
+	providers: [Q]
+})], $);
+//#endregion
+export { T as DEFAULT_ERROR_WEIGHT, S as DifferencesModule, x as DifferencesService, E as EMPTY_TEMPLATE_SCORE, w as FilesModule, C as FilesService, O as JsonComparisonService, j as JsonModule, A as JsonService, W as JupyterModule, M as JupyterNotebookService, U as JupyterService, $ as LanguagesModule, Q as LanguagesService, R as MarkdownModule, F as MarkdownNodesService, L as MarkdownService, I as MarkdownTreeService, pe as PERFECT_SCORE, B as PythonBridgeService, H as PythonModule, V as PythonService, k as ScoringModule, D as ScoringService, K as TextModule, G as TextService, q as TypescriptCommentsService, Z as TypescriptModule, J as TypescriptNodesService, X as TypescriptService, Y as TypescriptTreeService };