@untangle-code/parser-registry 0.0.0-stage → 0.1.1

package/dist/languages/astgrep-backend/adapter.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Die Adapterfabrik des ast-grep-Backends.
+ *
+ * Sie baut aus einer Sprachtabelle (`shared/table-profile.ts`) einen
+ * vollstaendigen `LanguageAdapter` (domain `analysis.ts`) — mit DEMSELBEN
+ * Walk, DENSELBEN Diagnosen, DENSELBEN Fingerabdruecken und DEMSELBEN
+ * Regionenbau wie der tree-sitter-Weg. `chunker`, `complexity`, `file-graph`
+ * und `symbol-graph` koennen nicht erkennen, welches Backend gelaufen ist;
+ * genau das ist die Zusage.
+ *
+ * WAS SICH ZWISCHEN DEN BACKENDS UNTERSCHEIDET, und wo es steht:
+ *
+ *  1. GROESSENGRENZE. Die 32-KiB-Puffergrenze der nativen tree-sitter-Bindung
+ *     (`shared/parse-limits.ts`, WP-215) gibt es hier NICHT: ast-grep nimmt
+ *     84 KB, 167 KB, 1 MB und 4 MB ohne jede Option. Dafuer kostet der Walk
+ *     mehr Speicher, also gilt eine EIGENE, niedrigere Obergrenze
+ *     ({@link MAX_ASTGREP_SOURCE_BYTES}) — begruendet unten.
+ *
+ *  2. FEHLENDE KNOTEN. tree-sitter misst sie (`nodeIsMissing`), ast-grep hat
+ *     dafuer nichts. Der Cursor liefert hier eine Heuristik, und JEDE daraus
+ *     entstehende Diagnose sagt das in ihrem Text
+ *     (`collectParseDiagnostics(..., "heuristic")`). `missingNodeCount` bleibt
+ *     eine Zahl — aber eine, deren Herkunft in der Ausgabe steht (E4).
+ *
+ *  3. VERSIONIERUNG. Ein anderer Parser erzeugt eine andere AST-Form und damit
+ *     andere Chunk-IDs und Fingerabdruecke. Sichtbar wird das ueber
+ *     `parserVersionForLanguage` (domain `versions.ts`), das fuer jede
+ *     ast-grep-Sprache eine eigene `parser_version` liefert. Ohne sie lieferten
+ *     die inhaltsadressierten Caches aus WP-100 stillschweigend Altes.
+ */
+import type { LanguageAdapter, SourceFile } from "@untangle-code/domain";
+import type { LanguageProfile } from "../shared/profile.js";
+import type { SyntaxNode } from "../shared/syntax.js";
+import type { LanguageKindTable } from "../shared/table-profile.js";
+/**
+ * Obergrenze fuer eine einzelne Quelldatei, in Bytes — 5 MiB.
+ *
+ * WARUM NIEDRIGER ALS BEIM TREE-SITTER-WEG (8 MiB, `shared/parse-limits.ts`):
+ * der Walk kostet hier mehr Speicher, weil jeder Abstieg ueber `children()`
+ * geht und dabei je Knoten JS-Wrapper entstehen. SELBST GEMESSEN ueber diesen
+ * Adapter (`parse()` + `computeComplexity()`, generierter Go-Quelltext, je
+ * Groesse ein EIGENER Prozess, `maxRSS` aus `process.resourceUsage()`,
+ * darwin/arm64, Node 26.7.0):
+ *
+ *     Bytes     Knoten      parse     walk      Spitzen-RSS
+ *     1 MiB       490.959   1.897 ms  12.289 ms   1.048 MiB
+ *     2 MiB       976.521   3.087 ms  11.699 ms   2.719 MiB
+ *     4 MiB     1.937.712   5.803 ms  45.863 ms   2.098 MiB
+ *
+ * Die RSS-Spalte ist ERKENNBAR VERRAUSCHT (4 MiB unter 2 MiB), weil die
+ * napi-Finalisierer auf der Ereignisschleife laufen und ein synchroner Lauf
+ * sie nicht drankommen laesst — dieselbe Beobachtung machte die Erkundung.
+ * Verlaesslich ist nur die Groessenordnung: rund ein Gigabyte je Megabyte
+ * Quelltext, und damit rund das Vierfache des tree-sitter-Weges.
+ *
+ * DIE GRENZE IST DESHALB DIE SCANNERGRENZE: 5 MiB, genau die Vorgabe aus
+ * `packages/scanner/src/discovery.ts`. Damit ist der Parser bei
+ * Standardkonfiguration NIE die engere, unausgesprochene Grenze — jede Datei,
+ * die der Scanner durchlaesst, nimmt er auch an —, und zugleich bleibt der
+ * Speicherbedarf im messbaren Bereich. Wer die Scannergrenze bewusst anhebt,
+ * bekommt hier einen benannten Grund (`file_too_large`) statt eines Absturzes.
+ *
+ * NICHT GELOEST, und hier ausdruecklich vermerkt: 12 bis 46 Sekunden Walk je
+ * Megabyte sind ein eigener Leistungsdefekt dieses Weges (der tree-sitter-Weg
+ * misst an vergleichbarer Stelle rund sechs Sekunden je Megabyte). Diese
+ * Grenze verhindert nur, dass er in einen Speicherabsturz umschlaegt.
+ */
+export declare const MAX_ASTGREP_SOURCE_BYTES: number;
+/** Welches npm-Paket die Grammatik einer Sprache liefert. */
+export interface AstGrepLanguageSource {
+    /** Name, unter dem ast-grep die Sprache fuehrt (`parse(name, ...)`). */
+    languageName: string;
+    /** Sprachpaket, EINZELN aufgenommen — nie eine Sammelabhaengigkeit (450 MB fuer 22 Sprachen). */
+    moduleName: string;
+}
+/**
+ * Haken fuer eine Sprache, deren Regeln eine Tabelle NICHT ausdrueckt.
+ *
+ * WOFUER, an einem echten Fall: Python bindet den Doc-Kommentar nicht an ein
+ * Kommentarzeichen, sondern an die erste Anweisung des Rumpfes; seine
+ * Sichtbarkeit steht in einer Namenskonvention statt in einem Modifikator;
+ * und `__all__` gilt je DATEI, nicht je Knoten. Das erste und zweite koennte
+ * eine Tabelle notfalls noch beschreiben, das dritte nicht: es braucht einen
+ * Zustand, den es erst gibt, wenn die Datei geparst ist.
+ *
+ * Deshalb DIESER Zuschnitt und kein anderer: der Haken bekommt das fertige
+ * Tabellenprofil, den Wurzelknoten und die Datei und darf daraus ein
+ * VERFEINERTES Profil bauen. Er laeuft genau einmal je Parse — nicht je
+ * Knoten —, und wer ihn nicht setzt, bezahlt nichts.
+ */
+export interface AstGrepAdapterHooks {
+    readonly profileForFile?: (base: LanguageProfile, root: SyntaxNode, file: SourceFile) => LanguageProfile;
+}
+/**
+ * Baut einen `LanguageAdapter` ueber ast-grep. Die Anmeldung der Sprache
+ * kostet hier nichts: kein `require`, keine Grammatik, kein natives Modul —
+ * das passiert erst beim ersten `parse()` einer ast-grep-Sprache, und dann
+ * fuer alle angemeldeten auf einmal (`napi.ts`, Eigenheit 1).
+ */
+export declare function createAstGrepAdapter(table: LanguageKindTable, source: AstGrepLanguageSource, hooks?: AstGrepAdapterHooks): LanguageAdapter;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/languages/astgrep-backend/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/languages/astgrep-backend/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EAIV,eAAe,EAKf,UAAU,EACX,MAAM,uBAAuB,CAAC;AAU/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAMpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,wBAAwB,QAAkB,CAAC;AA+BxD,6DAA6D;AAC7D,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,YAAY,EAAE,MAAM,CAAC;IACrB,iGAAiG;IACjG,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,CACxB,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,KACb,eAAe,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,qBAAqB,EAC7B,KAAK,GAAE,mBAAwB,GAC9B,eAAe,CA4EjB"}

package/dist/languages/astgrep-backend/adapter.js

@@ -0,0 +1,130 @@
+import { AdapterParseError } from "@untangle-code/domain";
+import { buildByteOffsetTable } from "../../text/byte-offset-table.js";
+import { buildFileRegion } from "../shared/chunks.js";
+import { analyzeTree } from "../shared/engine.js";
+import { extractedSymbolsOf } from "../shared/extract-symbols.js";
+import { collectParseDiagnostics } from "../shared/parse-diagnostics.js";
+import { createTableProfile, fieldNamesOf } from "../shared/table-profile.js";
+import { astGrepParse, registerAstGrepLanguage } from "./napi.js";
+import { AstGrepSyntaxNode } from "./syntax.js";
+/**
+ * Obergrenze fuer eine einzelne Quelldatei, in Bytes — 5 MiB.
+ *
+ * WARUM NIEDRIGER ALS BEIM TREE-SITTER-WEG (8 MiB, `shared/parse-limits.ts`):
+ * der Walk kostet hier mehr Speicher, weil jeder Abstieg ueber `children()`
+ * geht und dabei je Knoten JS-Wrapper entstehen. SELBST GEMESSEN ueber diesen
+ * Adapter (`parse()` + `computeComplexity()`, generierter Go-Quelltext, je
+ * Groesse ein EIGENER Prozess, `maxRSS` aus `process.resourceUsage()`,
+ * darwin/arm64, Node 26.7.0):
+ *
+ *     Bytes     Knoten      parse     walk      Spitzen-RSS
+ *     1 MiB       490.959   1.897 ms  12.289 ms   1.048 MiB
+ *     2 MiB       976.521   3.087 ms  11.699 ms   2.719 MiB
+ *     4 MiB     1.937.712   5.803 ms  45.863 ms   2.098 MiB
+ *
+ * Die RSS-Spalte ist ERKENNBAR VERRAUSCHT (4 MiB unter 2 MiB), weil die
+ * napi-Finalisierer auf der Ereignisschleife laufen und ein synchroner Lauf
+ * sie nicht drankommen laesst — dieselbe Beobachtung machte die Erkundung.
+ * Verlaesslich ist nur die Groessenordnung: rund ein Gigabyte je Megabyte
+ * Quelltext, und damit rund das Vierfache des tree-sitter-Weges.
+ *
+ * DIE GRENZE IST DESHALB DIE SCANNERGRENZE: 5 MiB, genau die Vorgabe aus
+ * `packages/scanner/src/discovery.ts`. Damit ist der Parser bei
+ * Standardkonfiguration NIE die engere, unausgesprochene Grenze — jede Datei,
+ * die der Scanner durchlaesst, nimmt er auch an —, und zugleich bleibt der
+ * Speicherbedarf im messbaren Bereich. Wer die Scannergrenze bewusst anhebt,
+ * bekommt hier einen benannten Grund (`file_too_large`) statt eines Absturzes.
+ *
+ * NICHT GELOEST, und hier ausdruecklich vermerkt: 12 bis 46 Sekunden Walk je
+ * Megabyte sind ein eigener Leistungsdefekt dieses Weges (der tree-sitter-Weg
+ * misst an vergleichbarer Stelle rund sechs Sekunden je Megabyte). Diese
+ * Grenze verhindert nur, dass er in einen Speicherabsturz umschlaegt.
+ */
+export const MAX_ASTGREP_SOURCE_BYTES = 5 * 1024 * 1024;
+const analysisCache = new WeakMap();
+/**
+ * Wie in `shared/create-adapter.ts`: `ComplexityFacts.parseDiagnostics` ist der
+ * EINZIGE Kanal, ueber den nachgelagerte Rechnungen von einem beschaedigten
+ * Baum erfahren. `analyzeTree` sieht die Diagnosen nicht — sie entstehen in
+ * `parse()` und haengen am `ParsedAst`.
+ */
+function getAnalysis(ast) {
+    const cached = analysisCache.get(ast);
+    if (cached !== undefined)
+        return cached;
+    const root = ast.root;
+    const analyzed = analyzeTree(root.root, root.ctx, root.fileId, root.profile);
+    const result = {
+        ...analyzed,
+        facts: { ...analyzed.facts, parseDiagnostics: ast.diagnostics },
+    };
+    analysisCache.set(ast, result);
+    return result;
+}
+/**
+ * Baut einen `LanguageAdapter` ueber ast-grep. Die Anmeldung der Sprache
+ * kostet hier nichts: kein `require`, keine Grammatik, kein natives Modul —
+ * das passiert erst beim ersten `parse()` einer ast-grep-Sprache, und dann
+ * fuer alle angemeldeten auf einmal (`napi.ts`, Eigenheit 1).
+ */
+export function createAstGrepAdapter(table, source, hooks = {}) {
+    const profile = createTableProfile(table);
+    const fieldNames = fieldNamesOf(table);
+    registerAstGrepLanguage(source.languageName, source.moduleName);
+    return {
+        languageId: table.languageId,
+        extensions: [...table.extensions],
+        supportLevel: table.supportLevel,
+        parse(file) {
+            const byteLength = Buffer.byteLength(file.content, "utf8");
+            if (byteLength > MAX_ASTGREP_SOURCE_BYTES) {
+                throw new AdapterParseError("file_too_large", `Source text with ${String(byteLength)} bytes exceeds the ast-grep parser limit of ` +
+                    `${String(MAX_ASTGREP_SOURCE_BYTES)} Bytes.`, {
+                    measurements: { sizeBytes: byteLength, limitBytes: MAX_ASTGREP_SOURCE_BYTES },
+                });
+            }
+            // KEIN `bufferSize` und keine 32-KiB-Grenze: die gibt es nur in der
+            // nativen tree-sitter-Bindung (`shared/parse-limits.ts`). Nachgeprueft
+            // an 84 KB, 167 KB, 1 MB und 4 MB — ast-grep nimmt sie ohne Option an.
+            const rootNode = astGrepParse(source.languageName, file.content);
+            const root = new AstGrepSyntaxNode(rootNode, fieldNames);
+            const byteTable = buildByteOffsetTable(file.content);
+            const ctx = { sourceText: file.content, byteTable };
+            const { parseQuality, diagnostics, errorNodeCount, missingNodeCount } = collectParseDiagnostics(root, ctx, "heuristic");
+            if (parseQuality === "failed") {
+                return { parseQuality, ast: null, diagnostics, errorNodeCount, missingNodeCount };
+            }
+            const fileProfile = hooks.profileForFile?.(profile, root, file) ?? profile;
+            const astRoot = { root, ctx, fileId: file.fileId, profile: fileProfile };
+            return {
+                parseQuality,
+                ast: { languageId: table.languageId, parseQuality, root: astRoot, diagnostics },
+                diagnostics,
+                errorNodeCount,
+                missingNodeCount,
+            };
+        },
+        extractChunks(ast) {
+            const { scopeTree } = getAnalysis(ast);
+            const root = ast.root;
+            return [buildFileRegion(scopeTree, root.ctx, root.profile)];
+        },
+        extractSymbols(ast) {
+            return extractedSymbolsOf(getAnalysis(ast).scopeTree);
+        },
+        extractImports(ast) {
+            return getAnalysis(ast).imports;
+        },
+        extractCalls(ast) {
+            return getAnalysis(ast).calls;
+        },
+        computeComplexity(ast) {
+            return getAnalysis(ast).facts;
+        },
+        tokenizeForHalstead(ast) {
+            const { facts } = getAnalysis(ast);
+            return { operators: facts.operators, operands: facts.operands };
+        },
+    };
+}
+//# sourceMappingURL=adapter.js.map

package/dist/languages/astgrep-backend/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../../src/languages/astgrep-backend/adapter.ts"],"names":[],"mappings":"AAyCA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAElE,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAIzE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE9E,OAAO,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AAUxD,MAAM,aAAa,GAAG,IAAI,OAAO,EAA6B,CAAC;AAE/D;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAc;IACjC,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,MAAM,IAAI,GAAG,GAAG,CAAC,IAAsB,CAAC;IACxC,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7E,MAAM,MAAM,GAAmB;QAC7B,GAAG,QAAQ;QACX,KAAK,EAAE,EAAE,GAAG,QAAQ,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,CAAC,WAAW,EAAE;KAChE,CAAC;IACF,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,MAAM,CAAC;AAChB,CAAC;AAiCD;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAwB,EACxB,MAA6B,EAC7B,QAA6B,EAAE;IAE/B,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,UAAU,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IACvC,uBAAuB,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;IAEhE,OAAO;QACL,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,UAAU,EAAE,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC;QACjC,YAAY,EAAE,KAAK,CAAC,YAAY;QAEhC,KAAK,CAAC,IAAgB;YACpB,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC3D,IAAI,UAAU,GAAG,wBAAwB,EAAE,CAAC;gBAC1C,MAAM,IAAI,iBAAiB,CACzB,gBAAgB,EAChB,oBAAoB,MAAM,CAAC,UAAU,CAAC,8CAA8C;oBAClF,GAAG,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAC9C;oBACE,YAAY,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,wBAAwB,EAAE;iBAC9E,CACF,CAAC;YACJ,CAAC;YAED,oEAAoE;YACpE,uEAAuE;YACvE,uEAAuE;YACvE,MAAM,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACjE,MAAM,IAAI,GAAG,IAAI,iBAAiB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YAEzD,MAAM,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrD,MAAM,GAAG,GAAoB,EAAE,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC;YACrE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,gBAAgB,EAAE,GACnE,uBAAuB,CAAC,IAAI,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC;YAElD,IAAI,YAAY,KAAK,QAAQ,EAAE,CAAC;gBAC9B,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,EAAE,gBAAgB,EAAE,CAAC;YACpF,CAAC;YAED,MAAM,WAAW,GAAG,KAAK,CAAC,cAAc,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,OAAO,CAAC;YAC3E,MAAM,OAAO,GAAmB,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;YACzF,OAAO;gBACL,YAAY;gBACZ,GAAG,EAAE,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE;gBAC/E,WAAW;gBACX,cAAc;gBACd,gBAAgB;aACjB,CAAC;QACJ,CAAC;QAED,aAAa,CAAC,GAAG;YACf,MAAM,EAAE,SAAS,EAAE,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;YACvC,MAAM,IAAI,GAAG,GAAG,CAAC,IAAsB,CAAC;YACxC,OAAO,CAAC,eAAe,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9D,CAAC;QAED,cAAc,CAAC,GAAG;YAChB,OAAO,kBAAkB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;QACxD,CAAC;QAED,cAAc,CAAC,GAAG;YAChB,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;QAClC,CAAC;QAED,YAAY,CAAC,GAAG;YACd,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;QAChC,CAAC;QAED,iBAAiB,CAAC,GAAG;YACnB,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;QAChC,CAAC;QAED,mBAAmB,CAAC,GAAG;YACrB,MAAM,EAAE,KAAK,EAAE,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;YACnC,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;QAClE,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/languages/astgrep-backend/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Oeffentliche Einstiegspunkte des ast-grep-Backends.
+ *
+ * WELCHE SPRACHE UEBER WELCHEN WEG LAEUFT, steht in `README.md` neben dieser
+ * Datei — mit der Messung, auf der die Aufteilung beruht.
+ */
+import type { LanguageAdapter } from "@untangle-code/domain";
+export { createAstGrepAdapter, MAX_ASTGREP_SOURCE_BYTES } from "./adapter.js";
+export type { AstGrepAdapterHooks, AstGrepLanguageSource } from "./adapter.js";
+export { GO_SOURCE, GO_TABLE, RUST_SOURCE, RUST_TABLE } from "./languages.js";
+export { AST_GREP_LANGUAGES } from "./lang/index.js";
+export type { AstGrepLanguage } from "./lang/index.js";
+export { astGrepLanguageStates, astGrepLanguageStatus } from "./napi.js";
+export type { AstGrepLanguageStatus } from "./napi.js";
+/** Go-Adapter ueber ast-grep (`@ast-grep/lang-go`). */
+export declare function createGoAdapter(): LanguageAdapter;
+/** Rust-Adapter ueber ast-grep (`@ast-grep/lang-rust`). */
+export declare function createRustAdapter(): LanguageAdapter;
+/**
+ * Die WEITEREN Sprachen aus WP-86 (Java, C#, Ruby, PHP, Kotlin, C, C++, Swift,
+ * Bash) — je eine Tabelle unter `lang/`, kein Motor.
+ *
+ * Sie kommen als LISTE und nicht als neun einzelne Fabriken, damit
+ * `languages/index.ts` mit EINER Schleife auskommt: wer die zehnte Sprache
+ * aufnimmt, schreibt eine Tabelle und eine Zeile in `lang/index.ts` — und
+ * faesst weder diese Datei noch die Registrierung an.
+ */
+export declare function createBreadthAdapters(): LanguageAdapter[];
+//# sourceMappingURL=index.d.ts.map

package/dist/languages/astgrep-backend/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/languages/astgrep-backend/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAM7D,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAC9E,YAAY,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AACzE,YAAY,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAEvD,uDAAuD;AACvD,wBAAgB,eAAe,IAAI,eAAe,CAEjD;AAED,2DAA2D;AAC3D,wBAAgB,iBAAiB,IAAI,eAAe,CAEnD;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,IAAI,eAAe,EAAE,CAIzD"}

package/dist/languages/astgrep-backend/index.js

@@ -0,0 +1,28 @@
+import { createAstGrepAdapter } from "./adapter.js";
+import { AST_GREP_LANGUAGES } from "./lang/index.js";
+import { GO_SOURCE, GO_TABLE, RUST_SOURCE, RUST_TABLE } from "./languages.js";
+export { createAstGrepAdapter, MAX_ASTGREP_SOURCE_BYTES } from "./adapter.js";
+export { GO_SOURCE, GO_TABLE, RUST_SOURCE, RUST_TABLE } from "./languages.js";
+export { AST_GREP_LANGUAGES } from "./lang/index.js";
+export { astGrepLanguageStates, astGrepLanguageStatus } from "./napi.js";
+/** Go-Adapter ueber ast-grep (`@ast-grep/lang-go`). */
+export function createGoAdapter() {
+    return createAstGrepAdapter(GO_TABLE, GO_SOURCE);
+}
+/** Rust-Adapter ueber ast-grep (`@ast-grep/lang-rust`). */
+export function createRustAdapter() {
+    return createAstGrepAdapter(RUST_TABLE, RUST_SOURCE);
+}
+/**
+ * Die WEITEREN Sprachen aus WP-86 (Java, C#, Ruby, PHP, Kotlin, C, C++, Swift,
+ * Bash) — je eine Tabelle unter `lang/`, kein Motor.
+ *
+ * Sie kommen als LISTE und nicht als neun einzelne Fabriken, damit
+ * `languages/index.ts` mit EINER Schleife auskommt: wer die zehnte Sprache
+ * aufnimmt, schreibt eine Tabelle und eine Zeile in `lang/index.ts` — und
+ * faesst weder diese Datei noch die Registrierung an.
+ */
+export function createBreadthAdapters() {
+    return AST_GREP_LANGUAGES.map((language) => createAstGrepAdapter(language.table, language.source));
+}
+//# sourceMappingURL=index.js.map

package/dist/languages/astgrep-backend/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/languages/astgrep-backend/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE9E,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE9E,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAGzE,uDAAuD;AACvD,MAAM,UAAU,eAAe;IAC7B,OAAO,oBAAoB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AACnD,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,iBAAiB;IAC/B,OAAO,oBAAoB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CACzC,oBAAoB,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CACtD,CAAC;AACJ,CAAC"}

package/dist/languages/astgrep-backend/lang/bash.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Bash (WP-86).
+ *
+ * WAS EINE SHELL AN SYMBOLEN HAT: Funktionen. Mehr nicht — keine Klassen,
+ * keine Typen, keine Namensraeume. Das ist kein Mangel des Adapters, sondern
+ * der Sprache, und deshalb steht hier eine kurze Tabelle statt einer
+ * erfundenen Struktur.
+ *
+ * VARIABLENZUWEISUNGEN AUF OBERSTER EBENE SIND KEINE SYMBOLE. In einer Shell
+ * ist jede Zuweisung eine Anweisung; die Grenze zwischen "Konstante" und
+ * "Zwischenwert" steht nicht im Syntaxbaum. `MAX_RETRIES=3` und
+ * `attempt=$((attempt + 1))` als gleichrangige Symbole zu fuehren waere eine
+ * falsche Aussage ueber die Datei.
+ *
+ * ENTSCHEIDUNGSPUNKTE (spec.md §16.2/§16.3):
+ *   - `while_statement` deckt AUCH `until` ab — dieselbe Knotenart mit anderem
+ *     Schluesselwort.
+ *   - `elif_clause` ist eine eigene Knotenart und damit direkt ein `else_if`.
+ *   - `case_item` zaehlt als `case`. Der Auffangzweig `*)` zaehlt NICHT: sein
+ *     Muster ist genau `*` (`caseExcludeFirstChildText`).
+ *   - `&&`/`||` zwischen Kommandos stehen in einem `list`-Knoten und tragen
+ *     den Operator als anonymes Kind (`anonymousOperatorKinds`). Sie zaehlen
+ *     nur ERWEITERT. In der Shell ist `cmd || exit 1` idiomatisch ein
+ *     Fehlerpfad und kein reiner Kurzschluss; die konservative Auslegung haelt
+ *     die Zahl mit den anderen zehn Sprachen vergleichbar.
+ *   - PIPES (`|`) zaehlen NICHT: sie verketten, sie verzweigen nicht.
+ *
+ * IMPORTE: `source datei` und `. datei` sind gewoehnliche Kommandos, keine
+ * eigene Knotenart. Die Tabelle koennte sie nicht von einer selbstgeschriebenen
+ * Funktion gleichen Namens unterscheiden — dieser Adapter meldet deshalb KEINE
+ * Importe. Wer sie braucht, sieht sie in `extractCalls` als Aufruf von
+ * `source`.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+export declare const BASH_SOURCE: AstGrepLanguageSource;
+export declare const BASH_TABLE: LanguageKindTable;
+//# sourceMappingURL=bash.d.ts.map

package/dist/languages/astgrep-backend/lang/bash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../../../src/languages/astgrep-backend/lang/bash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE3D,eAAO,MAAM,WAAW,EAAE,qBAGzB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,iBAoCxB,CAAC"}

package/dist/languages/astgrep-backend/lang/bash.js

@@ -0,0 +1,42 @@
+export const BASH_SOURCE = {
+    languageName: "bash",
+    moduleName: "@ast-grep/lang-bash",
+};
+export const BASH_TABLE = {
+    languageId: "shell",
+    extensions: [".sh", ".bash", ".zsh", ".ksh"],
+    supportLevel: "deep",
+    commentKinds: ["comment"],
+    stringContainerKinds: ["string", "raw_string", "ansi_c_string", "heredoc_body"],
+    identifierLeafKinds: [
+        "variable_name",
+        "special_variable_name",
+        "word",
+        "extglob_pattern",
+        "simple_expansion",
+    ],
+    numberLeafKinds: ["number"],
+    scopes: [{ kinds: ["function_definition"], scopeKind: "function", nameKinds: ["word"] }],
+    decisions: {
+        ifKinds: ["if_statement"],
+        elseIfKinds: ["elif_clause"],
+        loopKinds: ["while_statement", "for_statement", "c_style_for_statement"],
+        switchKinds: ["case_statement"],
+        caseKinds: ["case_item"],
+        caseExcludeFirstChildText: "*",
+        anonymousOperatorKinds: ["list"],
+        logicalAndOperators: ["&&"],
+        logicalOrOperators: ["||"],
+        jumpKinds: [],
+        blockKinds: ["compound_statement", "do_group"],
+    },
+    // Siehe Modulkopf: die Shell hat keine Importanweisung.
+    imports: { kinds: [] },
+    calls: {
+        kinds: ["command"],
+        functionField: "name",
+    },
+    declarationParentKinds: [],
+    fieldNames: ["name"],
+};
+//# sourceMappingURL=bash.js.map

package/dist/languages/astgrep-backend/lang/bash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.js","sourceRoot":"","sources":["../../../../src/languages/astgrep-backend/lang/bash.ts"],"names":[],"mappings":"AAoCA,MAAM,CAAC,MAAM,WAAW,GAA0B;IAChD,YAAY,EAAE,MAAM;IACpB,UAAU,EAAE,qBAAqB;CAClC,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAsB;IAC3C,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC;IAC5C,YAAY,EAAE,MAAM;IACpB,YAAY,EAAE,CAAC,SAAS,CAAC;IACzB,oBAAoB,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,CAAC;IAC/E,mBAAmB,EAAE;QACnB,eAAe;QACf,uBAAuB;QACvB,MAAM;QACN,iBAAiB;QACjB,kBAAkB;KACnB;IACD,eAAe,EAAE,CAAC,QAAQ,CAAC;IAC3B,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,qBAAqB,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;IACxF,SAAS,EAAE;QACT,OAAO,EAAE,CAAC,cAAc,CAAC;QACzB,WAAW,EAAE,CAAC,aAAa,CAAC;QAC5B,SAAS,EAAE,CAAC,iBAAiB,EAAE,eAAe,EAAE,uBAAuB,CAAC;QACxE,WAAW,EAAE,CAAC,gBAAgB,CAAC;QAC/B,SAAS,EAAE,CAAC,WAAW,CAAC;QACxB,yBAAyB,EAAE,GAAG;QAC9B,sBAAsB,EAAE,CAAC,MAAM,CAAC;QAChC,mBAAmB,EAAE,CAAC,IAAI,CAAC;QAC3B,kBAAkB,EAAE,CAAC,IAAI,CAAC;QAC1B,SAAS,EAAE,EAAE;QACb,UAAU,EAAE,CAAC,oBAAoB,EAAE,UAAU,CAAC;KAC/C;IACD,wDAAwD;IACxD,OAAO,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;IACtB,KAAK,EAAE;QACL,KAAK,EAAE,CAAC,SAAS,CAAC;QAClB,aAAa,EAAE,MAAM;KACtB;IACD,sBAAsB,EAAE,EAAE;IAC1B,UAAU,EAAE,CAAC,MAAM,CAAC;CACrB,CAAC"}

package/dist/languages/astgrep-backend/lang/c.d.ts

@@ -0,0 +1,33 @@
+/**
+ * C (WP-86).
+ *
+ * DER EINE BESONDERE PUNKT: C schreibt den Namen einer Funktion nicht in ein
+ * `name`-Feld, sondern in eine Kette von Deklaratoren.
+ * `ring_t *ring_new(size_t cap)` ergibt
+ * `function_definition.declarator` -> `pointer_declarator.declarator`
+ * -> `function_declarator.declarator` -> `identifier`. Dafuer gibt es
+ * `nameDescend`: demselben Feld folgen, solange es weiterfuehrt. Ohne das
+ * hiesse jede zeigerwertige Funktion `*ring_new(size_t cap)`.
+ *
+ * ABBILDUNGEN: `struct`/`union` -> `class`, `typedef` -> `type`.
+ *
+ * ENTSCHEIDUNGSPUNKTE (spec.md §16.2/§16.3):
+ *   - `case_statement` traegt `case X:` UND `default:` — nur die `case`-Form
+ *     zaehlt (`caseExcludeChildKinds`).
+ *   - C hat kein `try`/`catch`; die Art `catch` entsteht in C-Dateien nie.
+ *   - PRAEPROZESSORZWEIGE (`#ifdef`, `#if`) zaehlen NICHT. Sie sind
+ *     Uebersetzungs-, nicht Laufzeitverzweigungen: die uebersetzte Datei
+ *     enthaelt genau EINEN der Zweige. Beide zu zaehlen ergaebe eine Zahl, die
+ *     kein ausgefuehrter Pfad je erreicht. Das ist die konservative Auslegung;
+ *     sie UNTERSCHAETZT Dateien, die schwer per `#ifdef` verzweigen, und das
+ *     steht hier, damit niemand es aus der Zahl erraten muss.
+ *   - Es gibt keine Sichtbarkeit im Baum: `static` ist eine Speicherklasse,
+ *     kein Zugriffsmodifikator. `exportedNames` bleibt deshalb leer, ausser
+ *     bei einer Funktion OHNE `static` — die ist aus der Uebersetzungseinheit
+ *     heraus sichtbar, und das ist die einzige Aussage, die der Baum hergibt.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+export declare const C_SOURCE: AstGrepLanguageSource;
+export declare const C_TABLE: LanguageKindTable;
+//# sourceMappingURL=c.d.ts.map

package/dist/languages/astgrep-backend/lang/c.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c.d.ts","sourceRoot":"","sources":["../../../../src/languages/astgrep-backend/lang/c.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE3D,eAAO,MAAM,QAAQ,EAAE,qBAGtB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,iBAkFrB,CAAC"}

package/dist/languages/astgrep-backend/lang/c.js

@@ -0,0 +1,85 @@
+export const C_SOURCE = {
+    languageName: "c",
+    moduleName: "@ast-grep/lang-c",
+};
+export const C_TABLE = {
+    languageId: "c",
+    extensions: [".c", ".h"],
+    supportLevel: "deep",
+    commentKinds: ["comment"],
+    stringContainerKinds: ["string_literal", "char_literal", "system_lib_string"],
+    identifierLeafKinds: [
+        "identifier",
+        "field_identifier",
+        "type_identifier",
+        "primitive_type",
+        "statement_identifier",
+    ],
+    numberLeafKinds: ["number_literal"],
+    booleanLeafKinds: ["true", "false"],
+    nullLeafKinds: ["null"],
+    scopes: [
+        {
+            kinds: ["function_definition"],
+            scopeKind: "function",
+            nameField: "declarator",
+            nameDescend: true,
+        },
+        { kinds: ["struct_specifier", "union_specifier"], scopeKind: "class" },
+        { kinds: ["enum_specifier"], scopeKind: "enum" },
+        {
+            kinds: ["type_definition"],
+            scopeKind: "type",
+            nameField: "declarator",
+            nameDescend: true,
+        },
+        {
+            kinds: ["field_declaration"],
+            scopeKind: "property",
+            nameField: "declarator",
+            nameDescend: true,
+        },
+    ],
+    decisions: {
+        ifKinds: ["if_statement"],
+        elseIfParentKinds: ["else_clause"],
+        loopKinds: ["for_statement", "while_statement", "do_statement"],
+        ternaryKinds: ["conditional_expression"],
+        switchKinds: ["switch_statement"],
+        caseKinds: ["case_statement"],
+        caseExcludeChildKinds: ["default"],
+        binaryKinds: ["binary_expression"],
+        operatorField: "operator",
+        logicalAndOperators: ["&&"],
+        logicalOrOperators: ["||"],
+        jumpKinds: ["return_statement", "break_statement", "continue_statement", "goto_statement"],
+        blockKinds: ["compound_statement"],
+        consequenceField: "consequence",
+        alternativeField: "alternative",
+    },
+    imports: {
+        kinds: ["preproc_include"],
+        // Der Spezifizierer behaelt seine SPITZEN KLAMMERN: `<stdlib.h>` ist eine
+        // Systemeinbindung, `"ring.h"` eine im Projekt. Die Klammern hier zu
+        // entfernen wuerde die beiden Faelle ununterscheidbar machen — und die
+        // Aufloesung im `file-graph` haengt genau daran.
+        pathField: "path",
+    },
+    calls: {
+        kinds: ["call_expression"],
+        functionField: "function",
+        argumentsField: "arguments",
+        memberKinds: ["field_expression"],
+    },
+    declarationParentKinds: [
+        "struct_specifier",
+        "union_specifier",
+        "enum_specifier",
+        "enumerator",
+        "function_declarator",
+    ],
+    bodyField: "body",
+    isExported: (_name, node) => !node.children.some((child) => child.type === "storage_class_specifier" && child.text === "static"),
+    fieldNames: ["name", "declarator"],
+};
+//# sourceMappingURL=c.js.map

package/dist/languages/astgrep-backend/lang/c.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"c.js","sourceRoot":"","sources":["../../../../src/languages/astgrep-backend/lang/c.ts"],"names":[],"mappings":"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"}

package/dist/languages/astgrep-backend/lang/cpp.d.ts

@@ -0,0 +1,27 @@
+/**
+ * C++ (WP-86) — DER BELEG FUER DIE RATSCHE.
+ *
+ * Die C++-Grammatik ist eine ERWEITERUNG der C-Grammatik: jede Knotenart aus
+ * `c.ts` kommt in C++ genauso vor. Deshalb steht hier keine zweite Tabelle,
+ * sondern die DIFFERENZ — Klassen, Namensraeume, `try`/`catch`, Lambdas,
+ * bereichsbasierte `for`-Schleifen. Elf Sprachen ergaenzen heisst nicht elfmal
+ * dieselbe Arbeit; wo zwei Sprachen verwandt sind, muss die zweite billiger
+ * sein als die erste, sonst haben wir nichts gewonnen.
+ *
+ * ABBILDUNGEN ZUSAETZLICH ZU C: `class` -> `class`, `namespace` ->
+ * `namespace`. `template_declaration` ist KEIN eigenes Symbol: es umhuellt
+ * die Funktion oder Klasse, die es parametrisiert, und die ist der Scope.
+ *
+ * ENTSCHEIDUNGSPUNKTE ZUSAETZLICH ZU C: `catch_clause` zaehlt als `catch`,
+ * `for_range_loop` als Schleife. `co_await`/`co_yield` zaehlen NICHT — sie
+ * unterbrechen den Ablauf, verzweigen ihn aber nicht.
+ *
+ * SICHTBARKEIT: C++ fuehrt sie als ABSCHNITTSMARKE (`access_specifier`
+ * `public:`), nicht am Mitglied. Sie ist damit ohne Positionsvergleich nicht
+ * am Symbol ablesbar — der Adapter meldet deshalb keine, statt eine zu raten.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+export declare const CPP_SOURCE: AstGrepLanguageSource;
+export declare const CPP_TABLE: LanguageKindTable;
+//# sourceMappingURL=cpp.d.ts.map

package/dist/languages/astgrep-backend/lang/cpp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpp.d.ts","sourceRoot":"","sources":["../../../../src/languages/astgrep-backend/lang/cpp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAI3D,eAAO,MAAM,UAAU,EAAE,qBAGxB,CAAC;AAIF,eAAO,MAAM,SAAS,EAAE,iBA8BvB,CAAC"}

package/dist/languages/astgrep-backend/lang/cpp.js

@@ -0,0 +1,38 @@
+import { C_TABLE } from "./c.js";
+export const CPP_SOURCE = {
+    languageName: "cpp",
+    moduleName: "@ast-grep/lang-cpp",
+};
+const { isExported: _cIsExported, ...C_TABLE_WITHOUT_EXPORT } = C_TABLE;
+export const CPP_TABLE = {
+    ...C_TABLE_WITHOUT_EXPORT,
+    languageId: "cpp",
+    extensions: [".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx"],
+    identifierLeafKinds: [
+        ...C_TABLE.identifierLeafKinds,
+        "namespace_identifier",
+        "qualified_identifier",
+        "this",
+        "destructor_name",
+        "operator_name",
+    ],
+    nullLeafKinds: [...(C_TABLE.nullLeafKinds ?? []), "nullptr"],
+    scopes: [
+        ...C_TABLE.scopes,
+        { kinds: ["class_specifier"], scopeKind: "class" },
+        { kinds: ["namespace_definition"], scopeKind: "namespace" },
+    ],
+    decisions: {
+        ...C_TABLE.decisions,
+        catchKinds: ["catch_clause"],
+        loopKinds: [...C_TABLE.decisions.loopKinds, "for_range_loop"],
+        jumpKinds: [...(C_TABLE.decisions.jumpKinds ?? []), "throw_statement"],
+    },
+    declarationParentKinds: [
+        ...C_TABLE.declarationParentKinds,
+        "class_specifier",
+        "namespace_definition",
+        "type_parameter_declaration",
+    ],
+};
+//# sourceMappingURL=cpp.js.map

package/dist/languages/astgrep-backend/lang/cpp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpp.js","sourceRoot":"","sources":["../../../../src/languages/astgrep-backend/lang/cpp.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC,MAAM,CAAC,MAAM,UAAU,GAA0B;IAC/C,YAAY,EAAE,KAAK;IACnB,UAAU,EAAE,oBAAoB;CACjC,CAAC;AAEF,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,sBAAsB,EAAE,GAAG,OAAO,CAAC;AAExE,MAAM,CAAC,MAAM,SAAS,GAAsB;IAC1C,GAAG,sBAAsB;IACzB,UAAU,EAAE,KAAK;IACjB,UAAU,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC;IAC1D,mBAAmB,EAAE;QACnB,GAAG,OAAO,CAAC,mBAAmB;QAC9B,sBAAsB;QACtB,sBAAsB;QACtB,MAAM;QACN,iBAAiB;QACjB,eAAe;KAChB;IACD,aAAa,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,IAAI,EAAE,CAAC,EAAE,SAAS,CAAC;IAC5D,MAAM,EAAE;QACN,GAAG,OAAO,CAAC,MAAM;QACjB,EAAE,KAAK,EAAE,CAAC,iBAAiB,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE;QAClD,EAAE,KAAK,EAAE,CAAC,sBAAsB,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE;KAC5D;IACD,SAAS,EAAE;QACT,GAAG,OAAO,CAAC,SAAS;QACpB,UAAU,EAAE,CAAC,cAAc,CAAC;QAC5B,SAAS,EAAE,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,EAAE,gBAAgB,CAAC;QAC7D,SAAS,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,IAAI,EAAE,CAAC,EAAE,iBAAiB,CAAC;KACvE;IACD,sBAAsB,EAAE;QACtB,GAAG,OAAO,CAAC,sBAAsB;QACjC,iBAAiB;QACjB,sBAAsB;QACtB,4BAA4B;KAC7B;CACF,CAAC"}

package/dist/languages/astgrep-backend/lang/csharp.d.ts

@@ -0,0 +1,24 @@
+/**
+ * C# (WP-86).
+ *
+ * ABBILDUNGEN: `struct` und `record` -> `class`, `namespace` -> `namespace`.
+ * Eine `property_declaration` (`public string Name { get; set; }`) ist eine
+ * `property`, keine Methode — die Zugriffsmethoden gehoeren zu ihr.
+ *
+ * ENTSCHEIDUNGSPUNKTE (spec.md §16.2/§16.3):
+ *   - `case_switch_label` zaehlt; `default_switch_label` ist eine EIGENE
+ *     Knotenart und steht deshalb gar nicht erst in `caseKinds`.
+ *   - `switch_expression_arm` (C# 8, `x switch { ... }`) zaehlt ebenfalls als
+ *     `case`.
+ *   - `catch_clause` zaehlt, `finally_clause` nicht.
+ *   - `??` zaehlt als `short_circuit`, also NUR erweitert.
+ *   - `?.` (`conditional_access_expression`) zaehlt NICHT. Es verzweigt zwar,
+ *     ist aber in idiomatischem C# die normale Null-Absicherung; klassisch
+ *     mitgezaehlt bekaeme jede defensive Kette dieselbe Zahl wie eine echte
+ *     Fallunterscheidung. Konservative Auslegung, hier benannt.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+export declare const CSHARP_SOURCE: AstGrepLanguageSource;
+export declare const CSHARP_TABLE: LanguageKindTable;
+//# sourceMappingURL=csharp.d.ts.map

package/dist/languages/astgrep-backend/lang/csharp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csharp.d.ts","sourceRoot":"","sources":["../../../../src/languages/astgrep-backend/lang/csharp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE3D,eAAO,MAAM,aAAa,EAAE,qBAG3B,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,iBAiG1B,CAAC"}