kirograph 0.12.1

package/dist/architecture/manifest/csproj.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csproj_exports = {};
+__export(csproj_exports, {
+  csprojParser: () => csprojParser
+});
+module.exports = __toCommonJS(csproj_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+const csprojParser = {
+  name: "csproj",
+  manifestFiles: [".csproj"],
+  language: "csharp",
+  canParse(manifestPath) {
+    return manifestPath.endsWith(".csproj");
+  },
+  async parse(manifestPath, projectRoot) {
+    let content;
+    try {
+      content = fs.readFileSync(manifestPath, "utf8");
+    } catch {
+      return [];
+    }
+    const name = path.basename(manifestPath, ".csproj");
+    const version = content.match(/<Version>([^<]+)<\/Version>/)?.[1] ?? content.match(/<AssemblyVersion>([^<]+)<\/AssemblyVersion>/)?.[1];
+    const externalDeps = [];
+    for (const m of content.matchAll(/<PackageReference\s+Include="([^"]+)"/g)) {
+      externalDeps.push(m[1]);
+    }
+    const relDir = path.relative(projectRoot, path.dirname(manifestPath)).replace(/\\/g, "/") || ".";
+    const relManifest = path.relative(projectRoot, manifestPath).replace(/\\/g, "/");
+    return [{
+      id: `pkg:csproj:${relDir}`,
+      name,
+      path: relDir,
+      source: "manifest",
+      language: "csharp",
+      manifestPath: relManifest,
+      version,
+      externalDeps,
+      updatedAt: Date.now()
+    }];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  csprojParser
+});
+//# sourceMappingURL=csproj.js.map

package/dist/architecture/manifest/csproj.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/architecture/manifest/csproj.ts"],
+  "sourcesContent": ["/**\n * C# .csproj manifest parser.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { ManifestParser, ArchPackage } from '../types';\n\nexport const csprojParser: ManifestParser = {\n  name: 'csproj',\n  manifestFiles: ['.csproj'],\n  language: 'csharp',\n\n  canParse(manifestPath: string): boolean {\n    return manifestPath.endsWith('.csproj');\n  },\n\n  async parse(manifestPath: string, projectRoot: string): Promise<ArchPackage[]> {\n    let content: string;\n    try {\n      content = fs.readFileSync(manifestPath, 'utf8');\n    } catch {\n      return [];\n    }\n\n    const name = path.basename(manifestPath, '.csproj');\n    const version = content.match(/<Version>([^<]+)<\\/Version>/)?.[1]\n      ?? content.match(/<AssemblyVersion>([^<]+)<\\/AssemblyVersion>/)?.[1];\n\n    const externalDeps: string[] = [];\n    for (const m of content.matchAll(/<PackageReference\\s+Include=\"([^\"]+)\"/g)) {\n      externalDeps.push(m[1]);\n    }\n\n    const relDir = path.relative(projectRoot, path.dirname(manifestPath)).replace(/\\\\/g, '/') || '.';\n    const relManifest = path.relative(projectRoot, manifestPath).replace(/\\\\/g, '/');\n\n    return [{\n      id: `pkg:csproj:${relDir}`,\n      name,\n      path: relDir,\n      source: 'manifest',\n      language: 'csharp',\n      manifestPath: relManifest,\n      version,\n      externalDeps,\n      updatedAt: Date.now(),\n    }];\n  },\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,SAAoB;AACpB,WAAsB;AAGf,MAAM,eAA+B;AAAA,EAC1C,MAAM;AAAA,EACN,eAAe,CAAC,SAAS;AAAA,EACzB,UAAU;AAAA,EAEV,SAAS,cAA+B;AACtC,WAAO,aAAa,SAAS,SAAS;AAAA,EACxC;AAAA,EAEA,MAAM,MAAM,cAAsB,aAA6C;AAC7E,QAAI;AACJ,QAAI;AACF,gBAAU,GAAG,aAAa,cAAc,MAAM;AAAA,IAChD,QAAQ;AACN,aAAO,CAAC;AAAA,IACV;AAEA,UAAM,OAAO,KAAK,SAAS,cAAc,SAAS;AAClD,UAAM,UAAU,QAAQ,MAAM,6BAA6B,IAAI,CAAC,KAC3D,QAAQ,MAAM,6CAA6C,IAAI,CAAC;AAErE,UAAM,eAAyB,CAAC;AAChC,eAAW,KAAK,QAAQ,SAAS,wCAAwC,GAAG;AAC1E,mBAAa,KAAK,EAAE,CAAC,CAAC;AAAA,IACxB;AAEA,UAAM,SAAS,KAAK,SAAS,aAAa,KAAK,QAAQ,YAAY,CAAC,EAAE,QAAQ,OAAO,GAAG,KAAK;AAC7F,UAAM,cAAc,KAAK,SAAS,aAAa,YAAY,EAAE,QAAQ,OAAO,GAAG;AAE/E,WAAO,CAAC;AAAA,MACN,IAAI,cAAc,MAAM;AAAA,MACxB;AAAA,MACA,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,cAAc;AAAA,MACd;AAAA,MACA;AAAA,MACA,WAAW,KAAK,IAAI;AAAA,IACtB,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/architecture/manifest/go.d.ts

@@ -0,0 +1,3 @@
+import type { ManifestParser } from '../types';
+export declare const goParser: ManifestParser;
+//# sourceMappingURL=go.d.ts.map

package/dist/architecture/manifest/go.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"go.d.ts","sourceRoot":"","sources":["../../../src/architecture/manifest/go.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,UAAU,CAAC;AAE5D,eAAO,MAAM,QAAQ,EAAE,cAoDtB,CAAC"}

package/dist/architecture/manifest/go.js

@@ -0,0 +1,85 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var go_exports = {};
+__export(go_exports, {
+  goParser: () => goParser
+});
+module.exports = __toCommonJS(go_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+const goParser = {
+  name: "go",
+  manifestFiles: ["go.mod"],
+  language: "go",
+  canParse(manifestPath) {
+    return path.basename(manifestPath) === "go.mod";
+  },
+  async parse(manifestPath, projectRoot) {
+    let content;
+    try {
+      content = fs.readFileSync(manifestPath, "utf8");
+    } catch {
+      return [];
+    }
+    const moduleMatch = content.match(/^module\s+(\S+)/m);
+    const name = moduleMatch ? moduleMatch[1] : path.basename(path.dirname(manifestPath));
+    const goVersionMatch = content.match(/^go\s+(\S+)/m);
+    const version = goVersionMatch ? goVersionMatch[1] : void 0;
+    const externalDeps = [];
+    const requireBlock = content.match(/require\s*\(([^)]+)\)/s);
+    if (requireBlock) {
+      for (const line of requireBlock[1].split("\n")) {
+        const m = line.trim().match(/^(\S+)\s+/);
+        if (m && !m[1].startsWith("//")) externalDeps.push(m[1]);
+      }
+    }
+    for (const line of content.split("\n")) {
+      const m = line.trim().match(/^require\s+(\S+)\s+/);
+      if (m) externalDeps.push(m[1]);
+    }
+    const relDir = path.relative(projectRoot, path.dirname(manifestPath)).replace(/\\/g, "/") || ".";
+    const relManifest = path.relative(projectRoot, manifestPath).replace(/\\/g, "/");
+    return [{
+      id: `pkg:go:${relDir}`,
+      name,
+      path: relDir,
+      source: "manifest",
+      language: "go",
+      manifestPath: relManifest,
+      version,
+      externalDeps: [...new Set(externalDeps)],
+      updatedAt: Date.now()
+    }];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  goParser
+});
+//# sourceMappingURL=go.js.map

package/dist/architecture/manifest/go.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/architecture/manifest/go.ts"],
+  "sourcesContent": ["/**\n * Go module (go.mod) manifest parser.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { ManifestParser, ArchPackage } from '../types';\n\nexport const goParser: ManifestParser = {\n  name: 'go',\n  manifestFiles: ['go.mod'],\n  language: 'go',\n\n  canParse(manifestPath: string): boolean {\n    return path.basename(manifestPath) === 'go.mod';\n  },\n\n  async parse(manifestPath: string, projectRoot: string): Promise<ArchPackage[]> {\n    let content: string;\n    try {\n      content = fs.readFileSync(manifestPath, 'utf8');\n    } catch {\n      return [];\n    }\n\n    const moduleMatch = content.match(/^module\\s+(\\S+)/m);\n    const name = moduleMatch ? moduleMatch[1] : path.basename(path.dirname(manifestPath));\n\n    const goVersionMatch = content.match(/^go\\s+(\\S+)/m);\n    const version = goVersionMatch ? goVersionMatch[1] : undefined;\n\n    const externalDeps: string[] = [];\n    const requireBlock = content.match(/require\\s*\\(([^)]+)\\)/s);\n    if (requireBlock) {\n      for (const line of requireBlock[1].split('\\n')) {\n        const m = line.trim().match(/^(\\S+)\\s+/);\n        if (m && !m[1].startsWith('//')) externalDeps.push(m[1]);\n      }\n    }\n    // Single-line requires\n    for (const line of content.split('\\n')) {\n      const m = line.trim().match(/^require\\s+(\\S+)\\s+/);\n      if (m) externalDeps.push(m[1]);\n    }\n\n    const relDir = path.relative(projectRoot, path.dirname(manifestPath)).replace(/\\\\/g, '/') || '.';\n    const relManifest = path.relative(projectRoot, manifestPath).replace(/\\\\/g, '/');\n\n    return [{\n      id: `pkg:go:${relDir}`,\n      name,\n      path: relDir,\n      source: 'manifest',\n      language: 'go',\n      manifestPath: relManifest,\n      version,\n      externalDeps: [...new Set(externalDeps)],\n      updatedAt: Date.now(),\n    }];\n  },\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,SAAoB;AACpB,WAAsB;AAGf,MAAM,WAA2B;AAAA,EACtC,MAAM;AAAA,EACN,eAAe,CAAC,QAAQ;AAAA,EACxB,UAAU;AAAA,EAEV,SAAS,cAA+B;AACtC,WAAO,KAAK,SAAS,YAAY,MAAM;AAAA,EACzC;AAAA,EAEA,MAAM,MAAM,cAAsB,aAA6C;AAC7E,QAAI;AACJ,QAAI;AACF,gBAAU,GAAG,aAAa,cAAc,MAAM;AAAA,IAChD,QAAQ;AACN,aAAO,CAAC;AAAA,IACV;AAEA,UAAM,cAAc,QAAQ,MAAM,kBAAkB;AACpD,UAAM,OAAO,cAAc,YAAY,CAAC,IAAI,KAAK,SAAS,KAAK,QAAQ,YAAY,CAAC;AAEpF,UAAM,iBAAiB,QAAQ,MAAM,cAAc;AACnD,UAAM,UAAU,iBAAiB,eAAe,CAAC,IAAI;AAErD,UAAM,eAAyB,CAAC;AAChC,UAAM,eAAe,QAAQ,MAAM,wBAAwB;AAC3D,QAAI,cAAc;AAChB,iBAAW,QAAQ,aAAa,CAAC,EAAE,MAAM,IAAI,GAAG;AAC9C,cAAM,IAAI,KAAK,KAAK,EAAE,MAAM,WAAW;AACvC,YAAI,KAAK,CAAC,EAAE,CAAC,EAAE,WAAW,IAAI,EAAG,cAAa,KAAK,EAAE,CAAC,CAAC;AAAA,MACzD;AAAA,IACF;AAEA,eAAW,QAAQ,QAAQ,MAAM,IAAI,GAAG;AACtC,YAAM,IAAI,KAAK,KAAK,EAAE,MAAM,qBAAqB;AACjD,UAAI,EAAG,cAAa,KAAK,EAAE,CAAC,CAAC;AAAA,IAC/B;AAEA,UAAM,SAAS,KAAK,SAAS,aAAa,KAAK,QAAQ,YAAY,CAAC,EAAE,QAAQ,OAAO,GAAG,KAAK;AAC7F,UAAM,cAAc,KAAK,SAAS,aAAa,YAAY,EAAE,QAAQ,OAAO,GAAG;AAE/E,WAAO,CAAC;AAAA,MACN,IAAI,UAAU,MAAM;AAAA,MACpB;AAAA,MACA,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,cAAc;AAAA,MACd;AAAA,MACA,cAAc,CAAC,GAAG,IAAI,IAAI,YAAY,CAAC;AAAA,MACvC,WAAW,KAAK,IAAI;AAAA,IACtB,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/architecture/manifest/gradle.d.ts

@@ -0,0 +1,3 @@
+import type { ManifestParser } from '../types';
+export declare const gradleParser: ManifestParser;
+//# sourceMappingURL=gradle.d.ts.map

package/dist/architecture/manifest/gradle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle.d.ts","sourceRoot":"","sources":["../../../src/architecture/manifest/gradle.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,UAAU,CAAC;AAE5D,eAAO,MAAM,YAAY,EAAE,cAgD1B,CAAC"}

package/dist/architecture/manifest/gradle.js

@@ -0,0 +1,80 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gradle_exports = {};
+__export(gradle_exports, {
+  gradleParser: () => gradleParser
+});
+module.exports = __toCommonJS(gradle_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+const gradleParser = {
+  name: "gradle",
+  manifestFiles: ["build.gradle", "build.gradle.kts"],
+  language: "java",
+  canParse(manifestPath) {
+    const base = path.basename(manifestPath);
+    return base === "build.gradle" || base === "build.gradle.kts";
+  },
+  async parse(manifestPath, projectRoot) {
+    let content;
+    try {
+      content = fs.readFileSync(manifestPath, "utf8");
+    } catch {
+      return [];
+    }
+    const groupMatch = content.match(/group\s*[=:]\s*['"]([^'"]+)['"]/);
+    const versionMatch = content.match(/version\s*[=:]\s*['"]([^'"]+)['"]/);
+    const dirName = path.basename(path.dirname(manifestPath));
+    const name = groupMatch ? `${groupMatch[1]}:${dirName}` : dirName;
+    const version = versionMatch ? versionMatch[1] : void 0;
+    const externalDeps = [];
+    for (const m of content.matchAll(/(?:implementation|api|compile|testImplementation)\s*[\('"]([^'"()]+)['")]/g)) {
+      const parts = m[1].split(":");
+      if (parts.length >= 2) externalDeps.push(`${parts[0]}:${parts[1]}`);
+    }
+    const relDir = path.relative(projectRoot, path.dirname(manifestPath)).replace(/\\/g, "/") || ".";
+    const relManifest = path.relative(projectRoot, manifestPath).replace(/\\/g, "/");
+    return [{
+      id: `pkg:gradle:${relDir}`,
+      name,
+      path: relDir,
+      source: "manifest",
+      language: "java",
+      manifestPath: relManifest,
+      version,
+      externalDeps,
+      updatedAt: Date.now()
+    }];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gradleParser
+});
+//# sourceMappingURL=gradle.js.map

package/dist/architecture/manifest/gradle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/architecture/manifest/gradle.ts"],
+  "sourcesContent": ["/**\n * Gradle build.gradle / build.gradle.kts manifest parser.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { ManifestParser, ArchPackage } from '../types';\n\nexport const gradleParser: ManifestParser = {\n  name: 'gradle',\n  manifestFiles: ['build.gradle', 'build.gradle.kts'],\n  language: 'java',\n\n  canParse(manifestPath: string): boolean {\n    const base = path.basename(manifestPath);\n    return base === 'build.gradle' || base === 'build.gradle.kts';\n  },\n\n  async parse(manifestPath: string, projectRoot: string): Promise<ArchPackage[]> {\n    let content: string;\n    try {\n      content = fs.readFileSync(manifestPath, 'utf8');\n    } catch {\n      return [];\n    }\n\n    // Try to detect group/artifact\n    const groupMatch = content.match(/group\\s*[=:]\\s*['\"]([^'\"]+)['\"]/);\n    const versionMatch = content.match(/version\\s*[=:]\\s*['\"]([^'\"]+)['\"]/);\n    const dirName = path.basename(path.dirname(manifestPath));\n\n    const name = groupMatch ? `${groupMatch[1]}:${dirName}` : dirName;\n    const version = versionMatch ? versionMatch[1] : undefined;\n\n    const externalDeps: string[] = [];\n    // Match: implementation 'group:artifact:version' or implementation(\"group:artifact:version\")\n    for (const m of content.matchAll(/(?:implementation|api|compile|testImplementation)\\s*[\\('\"]([^'\"()]+)['\")]/g)) {\n      const parts = m[1].split(':');\n      if (parts.length >= 2) externalDeps.push(`${parts[0]}:${parts[1]}`);\n    }\n\n    const relDir = path.relative(projectRoot, path.dirname(manifestPath)).replace(/\\\\/g, '/') || '.';\n    const relManifest = path.relative(projectRoot, manifestPath).replace(/\\\\/g, '/');\n\n    return [{\n      id: `pkg:gradle:${relDir}`,\n      name,\n      path: relDir,\n      source: 'manifest',\n      language: 'java',\n      manifestPath: relManifest,\n      version,\n      externalDeps,\n      updatedAt: Date.now(),\n    }];\n  },\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,SAAoB;AACpB,WAAsB;AAGf,MAAM,eAA+B;AAAA,EAC1C,MAAM;AAAA,EACN,eAAe,CAAC,gBAAgB,kBAAkB;AAAA,EAClD,UAAU;AAAA,EAEV,SAAS,cAA+B;AACtC,UAAM,OAAO,KAAK,SAAS,YAAY;AACvC,WAAO,SAAS,kBAAkB,SAAS;AAAA,EAC7C;AAAA,EAEA,MAAM,MAAM,cAAsB,aAA6C;AAC7E,QAAI;AACJ,QAAI;AACF,gBAAU,GAAG,aAAa,cAAc,MAAM;AAAA,IAChD,QAAQ;AACN,aAAO,CAAC;AAAA,IACV;AAGA,UAAM,aAAa,QAAQ,MAAM,iCAAiC;AAClE,UAAM,eAAe,QAAQ,MAAM,mCAAmC;AACtE,UAAM,UAAU,KAAK,SAAS,KAAK,QAAQ,YAAY,CAAC;AAExD,UAAM,OAAO,aAAa,GAAG,WAAW,CAAC,CAAC,IAAI,OAAO,KAAK;AAC1D,UAAM,UAAU,eAAe,aAAa,CAAC,IAAI;AAEjD,UAAM,eAAyB,CAAC;AAEhC,eAAW,KAAK,QAAQ,SAAS,4EAA4E,GAAG;AAC9G,YAAM,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG;AAC5B,UAAI,MAAM,UAAU,EAAG,cAAa,KAAK,GAAG,MAAM,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE;AAAA,IACpE;AAEA,UAAM,SAAS,KAAK,SAAS,aAAa,KAAK,QAAQ,YAAY,CAAC,EAAE,QAAQ,OAAO,GAAG,KAAK;AAC7F,UAAM,cAAc,KAAK,SAAS,aAAa,YAAY,EAAE,QAAQ,OAAO,GAAG;AAE/E,WAAO,CAAC;AAAA,MACN,IAAI,cAAc,MAAM;AAAA,MACxB;AAAA,MACA,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,cAAc;AAAA,MACd;AAAA,MACA;AAAA,MACA,WAAW,KAAK,IAAI;AAAA,IACtB,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/architecture/manifest/index.d.ts

@@ -0,0 +1,12 @@
+import type { ManifestParser, ArchPackage } from '../types';
+export declare function getAllManifestParsers(): ManifestParser[];
+export declare function getManifestParser(name: string): ManifestParser | undefined;
+export declare function registerManifestParser(parser: ManifestParser): void;
+/**
+ * Walk projectRoot looking for manifest files, parse each, deduplicate, and
+ * return all detected packages. Packages from manifests take priority; the
+ * deduplication ensures that a workspace root pom.xml and a sub-module
+ * pom.xml don't produce overlapping directory mappings.
+ */
+export declare function parseAllManifests(projectRoot: string): Promise<ArchPackage[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/architecture/manifest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/architecture/manifest/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AA+B5D,wBAAgB,qBAAqB,IAAI,cAAc,EAAE,CAExD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAE1E;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAInE;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAsBnF"}

package/dist/architecture/manifest/index.js

@@ -0,0 +1,130 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var manifest_exports = {};
+__export(manifest_exports, {
+  getAllManifestParsers: () => getAllManifestParsers,
+  getManifestParser: () => getManifestParser,
+  parseAllManifests: () => parseAllManifests,
+  registerManifestParser: () => registerManifestParser
+});
+module.exports = __toCommonJS(manifest_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_npm = require("./npm");
+var import_go = require("./go");
+var import_cargo = require("./cargo");
+var import_python = require("./python");
+var import_maven = require("./maven");
+var import_gradle = require("./gradle");
+var import_csproj = require("./csproj");
+const MANIFEST_PARSERS = [
+  import_npm.npmParser,
+  import_go.goParser,
+  import_cargo.cargoParser,
+  import_python.pythonParser,
+  import_maven.mavenParser,
+  import_gradle.gradleParser,
+  import_csproj.csprojParser
+];
+const MANIFEST_FILENAMES = new Set(
+  MANIFEST_PARSERS.flatMap((p) => p.manifestFiles)
+);
+const SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "target",
+  ".gradle",
+  "__pycache__",
+  ".kirograph",
+  "vendor",
+  ".cache",
+  "coverage",
+  ".nyc_output"
+]);
+function getAllManifestParsers() {
+  return MANIFEST_PARSERS;
+}
+function getManifestParser(name) {
+  return MANIFEST_PARSERS.find((p) => p.name === name);
+}
+function registerManifestParser(parser) {
+  const idx = MANIFEST_PARSERS.findIndex((p) => p.name === parser.name);
+  if (idx >= 0) MANIFEST_PARSERS[idx] = parser;
+  else MANIFEST_PARSERS.push(parser);
+}
+async function parseAllManifests(projectRoot) {
+  const manifestPaths = _findManifests(projectRoot);
+  const all = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const manifestPath of manifestPaths) {
+    const parser = MANIFEST_PARSERS.find((p) => p.canParse(manifestPath));
+    if (!parser) continue;
+    try {
+      const pkgs = await parser.parse(manifestPath, projectRoot);
+      for (const pkg of pkgs) {
+        if (!seenIds.has(pkg.id)) {
+          seenIds.add(pkg.id);
+          all.push(pkg);
+        }
+      }
+    } catch {
+    }
+  }
+  return all;
+}
+function _findManifests(dir, results = []) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (!SKIP_DIRS.has(entry.name)) {
+        _findManifests(path.join(dir, entry.name), results);
+      }
+    } else if (entry.isFile()) {
+      if (MANIFEST_FILENAMES.has(entry.name) || entry.name.endsWith(".csproj")) {
+        results.push(path.join(dir, entry.name));
+      }
+    }
+  }
+  return results;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAllManifestParsers,
+  getManifestParser,
+  parseAllManifests,
+  registerManifestParser
+});
+//# sourceMappingURL=index.js.map

package/dist/architecture/manifest/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/architecture/manifest/index.ts"],
+  "sourcesContent": ["/**\n * Manifest Parser Registry\n *\n * Discovers and dispatches manifest parsers. Each parser handles one or more\n * manifest file types. The registry walks the project looking for manifest files\n * and assigns them to the correct parser.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { ManifestParser, ArchPackage } from '../types';\nimport { npmParser } from './npm';\nimport { goParser } from './go';\nimport { cargoParser } from './cargo';\nimport { pythonParser } from './python';\nimport { mavenParser } from './maven';\nimport { gradleParser } from './gradle';\nimport { csprojParser } from './csproj';\n\n// All registered manifest parsers, in priority order\nconst MANIFEST_PARSERS: ManifestParser[] = [\n  npmParser,\n  goParser,\n  cargoParser,\n  pythonParser,\n  mavenParser,\n  gradleParser,\n  csprojParser,\n];\n\n// All manifest filenames we care about (for fast lookup during directory walk)\nconst MANIFEST_FILENAMES = new Set(\n  MANIFEST_PARSERS.flatMap(p => p.manifestFiles)\n);\n\n// Directories to never descend into when scanning for manifests\nconst SKIP_DIRS = new Set([\n  'node_modules', '.git', 'dist', 'build', 'target', '.gradle', '__pycache__',\n  '.kirograph', 'vendor', '.cache', 'coverage', '.nyc_output',\n]);\n\nexport function getAllManifestParsers(): ManifestParser[] {\n  return MANIFEST_PARSERS;\n}\n\nexport function getManifestParser(name: string): ManifestParser | undefined {\n  return MANIFEST_PARSERS.find(p => p.name === name);\n}\n\nexport function registerManifestParser(parser: ManifestParser): void {\n  const idx = MANIFEST_PARSERS.findIndex(p => p.name === parser.name);\n  if (idx >= 0) MANIFEST_PARSERS[idx] = parser;\n  else MANIFEST_PARSERS.push(parser);\n}\n\n/**\n * Walk projectRoot looking for manifest files, parse each, deduplicate, and\n * return all detected packages. Packages from manifests take priority; the\n * deduplication ensures that a workspace root pom.xml and a sub-module\n * pom.xml don't produce overlapping directory mappings.\n */\nexport async function parseAllManifests(projectRoot: string): Promise<ArchPackage[]> {\n  const manifestPaths = _findManifests(projectRoot);\n  const all: ArchPackage[] = [];\n  const seenIds = new Set<string>();\n\n  for (const manifestPath of manifestPaths) {\n    const parser = MANIFEST_PARSERS.find(p => p.canParse(manifestPath));\n    if (!parser) continue;\n    try {\n      const pkgs = await parser.parse(manifestPath, projectRoot);\n      for (const pkg of pkgs) {\n        if (!seenIds.has(pkg.id)) {\n          seenIds.add(pkg.id);\n          all.push(pkg);\n        }\n      }\n    } catch {\n      // Ignore parse errors for individual manifests\n    }\n  }\n\n  return all;\n}\n\nfunction _findManifests(dir: string, results: string[] = []): string[] {\n  let entries: fs.Dirent[];\n  try {\n    entries = fs.readdirSync(dir, { withFileTypes: true });\n  } catch {\n    return results;\n  }\n\n  for (const entry of entries) {\n    if (entry.isDirectory()) {\n      if (!SKIP_DIRS.has(entry.name)) {\n        _findManifests(path.join(dir, entry.name), results);\n      }\n    } else if (entry.isFile()) {\n      // Check exact filename or extension match\n      if (MANIFEST_FILENAMES.has(entry.name) || entry.name.endsWith('.csproj')) {\n        results.push(path.join(dir, entry.name));\n      }\n    }\n  }\n\n  return results;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,SAAoB;AACpB,WAAsB;AAEtB,iBAA0B;AAC1B,gBAAyB;AACzB,mBAA4B;AAC5B,oBAA6B;AAC7B,mBAA4B;AAC5B,oBAA6B;AAC7B,oBAA6B;AAG7B,MAAM,mBAAqC;AAAA,EACzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAGA,MAAM,qBAAqB,IAAI;AAAA,EAC7B,iBAAiB,QAAQ,OAAK,EAAE,aAAa;AAC/C;AAGA,MAAM,YAAY,oBAAI,IAAI;AAAA,EACxB;AAAA,EAAgB;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAS;AAAA,EAAU;AAAA,EAAW;AAAA,EAC9D;AAAA,EAAc;AAAA,EAAU;AAAA,EAAU;AAAA,EAAY;AAChD,CAAC;AAEM,SAAS,wBAA0C;AACxD,SAAO;AACT;AAEO,SAAS,kBAAkB,MAA0C;AAC1E,SAAO,iBAAiB,KAAK,OAAK,EAAE,SAAS,IAAI;AACnD;AAEO,SAAS,uBAAuB,QAA8B;AACnE,QAAM,MAAM,iBAAiB,UAAU,OAAK,EAAE,SAAS,OAAO,IAAI;AAClE,MAAI,OAAO,EAAG,kBAAiB,GAAG,IAAI;AAAA,MACjC,kBAAiB,KAAK,MAAM;AACnC;AAQA,eAAsB,kBAAkB,aAA6C;AACnF,QAAM,gBAAgB,eAAe,WAAW;AAChD,QAAM,MAAqB,CAAC;AAC5B,QAAM,UAAU,oBAAI,IAAY;AAEhC,aAAW,gBAAgB,eAAe;AACxC,UAAM,SAAS,iBAAiB,KAAK,OAAK,EAAE,SAAS,YAAY,CAAC;AAClE,QAAI,CAAC,OAAQ;AACb,QAAI;AACF,YAAM,OAAO,MAAM,OAAO,MAAM,cAAc,WAAW;AACzD,iBAAW,OAAO,MAAM;AACtB,YAAI,CAAC,QAAQ,IAAI,IAAI,EAAE,GAAG;AACxB,kBAAQ,IAAI,IAAI,EAAE;AAClB,cAAI,KAAK,GAAG;AAAA,QACd;AAAA,MACF;AAAA,IACF,QAAQ;AAAA,IAER;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,eAAe,KAAa,UAAoB,CAAC,GAAa;AACrE,MAAI;AACJ,MAAI;AACF,cAAU,GAAG,YAAY,KAAK,EAAE,eAAe,KAAK,CAAC;AAAA,EACvD,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,aAAW,SAAS,SAAS;AAC3B,QAAI,MAAM,YAAY,GAAG;AACvB,UAAI,CAAC,UAAU,IAAI,MAAM,IAAI,GAAG;AAC9B,uBAAe,KAAK,KAAK,KAAK,MAAM,IAAI,GAAG,OAAO;AAAA,MACpD;AAAA,IACF,WAAW,MAAM,OAAO,GAAG;AAEzB,UAAI,mBAAmB,IAAI,MAAM,IAAI,KAAK,MAAM,KAAK,SAAS,SAAS,GAAG;AACxE,gBAAQ,KAAK,KAAK,KAAK,KAAK,MAAM,IAAI,CAAC;AAAA,MACzC;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/architecture/manifest/maven.d.ts

@@ -0,0 +1,3 @@
+import type { ManifestParser } from '../types';
+export declare const mavenParser: ManifestParser;
+//# sourceMappingURL=maven.d.ts.map

package/dist/architecture/manifest/maven.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maven.d.ts","sourceRoot":"","sources":["../../../src/architecture/manifest/maven.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,UAAU,CAAC;AAE5D,eAAO,MAAM,WAAW,EAAE,cAyCzB,CAAC"}

package/dist/architecture/manifest/maven.js

@@ -0,0 +1,76 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var maven_exports = {};
+__export(maven_exports, {
+  mavenParser: () => mavenParser
+});
+module.exports = __toCommonJS(maven_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+const mavenParser = {
+  name: "maven",
+  manifestFiles: ["pom.xml"],
+  language: "java",
+  canParse(manifestPath) {
+    return path.basename(manifestPath) === "pom.xml";
+  },
+  async parse(manifestPath, projectRoot) {
+    let content;
+    try {
+      content = fs.readFileSync(manifestPath, "utf8");
+    } catch {
+      return [];
+    }
+    const artifactId = content.match(/<artifactId>([^<]+)<\/artifactId>/)?.[1];
+    const version = content.match(/<version>([^<]+)<\/version>/)?.[1];
+    const name = content.match(/<name>([^<]+)<\/name>/)?.[1] ?? artifactId ?? path.basename(path.dirname(manifestPath));
+    const externalDeps = [];
+    for (const m of content.matchAll(/<dependency>[\s\S]*?<artifactId>([^<]+)<\/artifactId>[\s\S]*?<\/dependency>/g)) {
+      externalDeps.push(m[1]);
+    }
+    const relDir = path.relative(projectRoot, path.dirname(manifestPath)).replace(/\\/g, "/") || ".";
+    const relManifest = path.relative(projectRoot, manifestPath).replace(/\\/g, "/");
+    return [{
+      id: `pkg:maven:${relDir}`,
+      name,
+      path: relDir,
+      source: "manifest",
+      language: "java",
+      manifestPath: relManifest,
+      version,
+      externalDeps,
+      updatedAt: Date.now()
+    }];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mavenParser
+});
+//# sourceMappingURL=maven.js.map

package/dist/architecture/manifest/maven.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/architecture/manifest/maven.ts"],
+  "sourcesContent": ["/**\n * Maven pom.xml manifest parser.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { ManifestParser, ArchPackage } from '../types';\n\nexport const mavenParser: ManifestParser = {\n  name: 'maven',\n  manifestFiles: ['pom.xml'],\n  language: 'java',\n\n  canParse(manifestPath: string): boolean {\n    return path.basename(manifestPath) === 'pom.xml';\n  },\n\n  async parse(manifestPath: string, projectRoot: string): Promise<ArchPackage[]> {\n    let content: string;\n    try {\n      content = fs.readFileSync(manifestPath, 'utf8');\n    } catch {\n      return [];\n    }\n\n    const artifactId = content.match(/<artifactId>([^<]+)<\\/artifactId>/)?.[1];\n    const version = content.match(/<version>([^<]+)<\\/version>/)?.[1];\n    const name = content.match(/<name>([^<]+)<\\/name>/)?.[1] ?? artifactId ?? path.basename(path.dirname(manifestPath));\n\n    const externalDeps: string[] = [];\n    for (const m of content.matchAll(/<dependency>[\\s\\S]*?<artifactId>([^<]+)<\\/artifactId>[\\s\\S]*?<\\/dependency>/g)) {\n      externalDeps.push(m[1]);\n    }\n\n    const relDir = path.relative(projectRoot, path.dirname(manifestPath)).replace(/\\\\/g, '/') || '.';\n    const relManifest = path.relative(projectRoot, manifestPath).replace(/\\\\/g, '/');\n\n    return [{\n      id: `pkg:maven:${relDir}`,\n      name,\n      path: relDir,\n      source: 'manifest',\n      language: 'java',\n      manifestPath: relManifest,\n      version,\n      externalDeps,\n      updatedAt: Date.now(),\n    }];\n  },\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,SAAoB;AACpB,WAAsB;AAGf,MAAM,cAA8B;AAAA,EACzC,MAAM;AAAA,EACN,eAAe,CAAC,SAAS;AAAA,EACzB,UAAU;AAAA,EAEV,SAAS,cAA+B;AACtC,WAAO,KAAK,SAAS,YAAY,MAAM;AAAA,EACzC;AAAA,EAEA,MAAM,MAAM,cAAsB,aAA6C;AAC7E,QAAI;AACJ,QAAI;AACF,gBAAU,GAAG,aAAa,cAAc,MAAM;AAAA,IAChD,QAAQ;AACN,aAAO,CAAC;AAAA,IACV;AAEA,UAAM,aAAa,QAAQ,MAAM,mCAAmC,IAAI,CAAC;AACzE,UAAM,UAAU,QAAQ,MAAM,6BAA6B,IAAI,CAAC;AAChE,UAAM,OAAO,QAAQ,MAAM,uBAAuB,IAAI,CAAC,KAAK,cAAc,KAAK,SAAS,KAAK,QAAQ,YAAY,CAAC;AAElH,UAAM,eAAyB,CAAC;AAChC,eAAW,KAAK,QAAQ,SAAS,8EAA8E,GAAG;AAChH,mBAAa,KAAK,EAAE,CAAC,CAAC;AAAA,IACxB;AAEA,UAAM,SAAS,KAAK,SAAS,aAAa,KAAK,QAAQ,YAAY,CAAC,EAAE,QAAQ,OAAO,GAAG,KAAK;AAC7F,UAAM,cAAc,KAAK,SAAS,aAAa,YAAY,EAAE,QAAQ,OAAO,GAAG;AAE/E,WAAO,CAAC;AAAA,MACN,IAAI,aAAa,MAAM;AAAA,MACvB;AAAA,MACA,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,cAAc;AAAA,MACd;AAAA,MACA;AAAA,MACA,WAAW,KAAK,IAAI;AAAA,IACtB,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/architecture/manifest/npm.d.ts

@@ -0,0 +1,3 @@
+import type { ManifestParser } from '../types';
+export declare const npmParser: ManifestParser;
+//# sourceMappingURL=npm.d.ts.map

package/dist/architecture/manifest/npm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"npm.d.ts","sourceRoot":"","sources":["../../../src/architecture/manifest/npm.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,UAAU,CAAC;AAE5D,eAAO,MAAM,SAAS,EAAE,cAmDvB,CAAC"}