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

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

@@ -0,0 +1,70 @@
+export const RUBY_SOURCE = {
+    languageName: "ruby",
+    moduleName: "@ast-grep/lang-ruby",
+};
+export const RUBY_TABLE = {
+    languageId: "ruby",
+    extensions: [".rb", ".rake", ".gemspec"],
+    supportLevel: "deep",
+    commentKinds: ["comment"],
+    stringContainerKinds: ["string", "string_array", "symbol_array", "regex", "heredoc_body"],
+    identifierLeafKinds: [
+        "identifier",
+        "constant",
+        "instance_variable",
+        "class_variable",
+        "global_variable",
+        "simple_symbol",
+        "hash_key_symbol",
+        "self",
+    ],
+    numberLeafKinds: ["integer", "float"],
+    booleanLeafKinds: ["true", "false"],
+    nullLeafKinds: ["nil"],
+    scopes: [
+        { kinds: ["module"], scopeKind: "namespace" },
+        { kinds: ["class", "singleton_class"], scopeKind: "class" },
+        {
+            kinds: ["method", "singleton_method"],
+            scopeKind: "method",
+            constructorNames: ["initialize"],
+        },
+    ],
+    decisions: {
+        ifKinds: ["if", "unless", "if_modifier", "unless_modifier"],
+        elseIfKinds: ["elsif"],
+        loopKinds: ["while", "until", "while_modifier", "until_modifier", "for"],
+        catchKinds: ["rescue", "rescue_modifier"],
+        ternaryKinds: ["ternary"],
+        switchKinds: ["case", "case_match"],
+        caseKinds: ["when", "in_clause"],
+        binaryKinds: ["binary"],
+        operatorField: "operator",
+        logicalAndOperators: ["&&", "and"],
+        logicalOrOperators: ["||", "or"],
+        jumpKinds: ["return", "break", "next", "redo", "retry"],
+        blockKinds: ["then", "body_statement"],
+        consequenceField: "consequence",
+        alternativeField: "alternative",
+    },
+    // Ruby hat keine Importanweisung — siehe Modulkopf.
+    imports: { kinds: [] },
+    calls: {
+        kinds: ["call"],
+        functionField: "method",
+        receiverField: "receiver",
+        argumentsField: "arguments",
+    },
+    declarationParentKinds: [
+        "method",
+        "singleton_method",
+        "class",
+        "module",
+        "optional_parameter",
+        "keyword_parameter",
+        "block_parameter",
+    ],
+    bodyField: "body",
+    fieldNames: ["name"],
+};
+//# sourceMappingURL=ruby.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ruby.js","sourceRoot":"","sources":["../../../../src/languages/astgrep-backend/lang/ruby.ts"],"names":[],"mappings":"AAmCA,MAAM,CAAC,MAAM,WAAW,GAA0B;IAChD,YAAY,EAAE,MAAM;IACpB,UAAU,EAAE,qBAAqB;CAClC,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAsB;IAC3C,UAAU,EAAE,MAAM;IAClB,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC;IACxC,YAAY,EAAE,MAAM;IACpB,YAAY,EAAE,CAAC,SAAS,CAAC;IACzB,oBAAoB,EAAE,CAAC,QAAQ,EAAE,cAAc,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,CAAC;IACzF,mBAAmB,EAAE;QACnB,YAAY;QACZ,UAAU;QACV,mBAAmB;QACnB,gBAAgB;QAChB,iBAAiB;QACjB,eAAe;QACf,iBAAiB;QACjB,MAAM;KACP;IACD,eAAe,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC;IACrC,gBAAgB,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC;IACnC,aAAa,EAAE,CAAC,KAAK,CAAC;IACtB,MAAM,EAAE;QACN,EAAE,KAAK,EAAE,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE;QAC7C,EAAE,KAAK,EAAE,CAAC,OAAO,EAAE,iBAAiB,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE;QAC3D;YACE,KAAK,EAAE,CAAC,QAAQ,EAAE,kBAAkB,CAAC;YACrC,SAAS,EAAE,QAAQ;YACnB,gBAAgB,EAAE,CAAC,YAAY,CAAC;SACjC;KACF;IACD,SAAS,EAAE;QACT,OAAO,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,aAAa,EAAE,iBAAiB,CAAC;QAC3D,WAAW,EAAE,CAAC,OAAO,CAAC;QACtB,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,KAAK,CAAC;QACxE,UAAU,EAAE,CAAC,QAAQ,EAAE,iBAAiB,CAAC;QACzC,YAAY,EAAE,CAAC,SAAS,CAAC;QACzB,WAAW,EAAE,CAAC,MAAM,EAAE,YAAY,CAAC;QACnC,SAAS,EAAE,CAAC,MAAM,EAAE,WAAW,CAAC;QAChC,WAAW,EAAE,CAAC,QAAQ,CAAC;QACvB,aAAa,EAAE,UAAU;QACzB,mBAAmB,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC;QAClC,kBAAkB,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;QAChC,SAAS,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;QACvD,UAAU,EAAE,CAAC,MAAM,EAAE,gBAAgB,CAAC;QACtC,gBAAgB,EAAE,aAAa;QAC/B,gBAAgB,EAAE,aAAa;KAChC;IACD,oDAAoD;IACpD,OAAO,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;IACtB,KAAK,EAAE;QACL,KAAK,EAAE,CAAC,MAAM,CAAC;QACf,aAAa,EAAE,QAAQ;QACvB,aAAa,EAAE,UAAU;QACzB,cAAc,EAAE,WAAW;KAC5B;IACD,sBAAsB,EAAE;QACtB,QAAQ;QACR,kBAAkB;QAClB,OAAO;QACP,QAAQ;QACR,oBAAoB;QACpB,mBAAmB;QACnB,iBAAiB;KAClB;IACD,SAAS,EAAE,MAAM;IACjB,UAAU,EAAE,CAAC,MAAM,CAAC;CACrB,CAAC"}

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

@@ -0,0 +1,34 @@
+/**
+ * Swift (WP-86).
+ *
+ * WIE KOTLIN OHNE FELDNAMEN — mit denselben zwei Folgen (Signatur = erste
+ * Zeile, `IdentifierFact.role` immer `reference`); die Begruendung steht im
+ * Kopf von `kotlin.ts` und wird hier nicht wiederholt.
+ *
+ * ABBILDUNGEN: `class_declaration` traegt in Swift AUCH `struct`, `enum`,
+ * `actor` und `extension` — unterschieden ueber das Schluesselwortkind.
+ * `extension` -> `namespace`: eine Erweiterung ist kein neuer Typ, sondern ein
+ * benannter Ort fuer weitere Mitglieder eines bestehenden.
+ * `protocol_declaration` -> `interface`.
+ *
+ * ENTSCHEIDUNGSPUNKTE (spec.md §16.2/§16.3):
+ *   - `guard_statement` zaehlt als `guard` — es IST die vorzeitige Rueckkehr,
+ *     fuer die die Art gedacht ist (`guardKinds`).
+ *   - `switch_entry` ist ein `case`; der `default`-Arm zaehlt nicht
+ *     (`caseExcludeChildKinds: ["default_keyword"]`).
+ *   - `catch_block` zaehlt als `catch`.
+ *   - `??` zaehlt als `short_circuit`, nur erweitert.
+ *   - `try?`/`try!` zaehlen NICHT: anders als Rusts `?` kehren sie nicht
+ *     zurueck, sondern liefern `nil` beziehungsweise brechen ab. Der Zweig
+ *     entsteht am `catch_block`, und der wird gezaehlt.
+ *
+ * EINE MESSGRENZE, AUSDRUECKLICH: `@ast-grep/lang-swift` steht bei Version
+ * 0.0.8. Geprueft ist die Grammatik an der Golden-Datei dieses Pakets
+ * (0 Fehlerknoten); an grossen echten Swift-Projekten ist sie hier NICHT
+ * erprobt.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+export declare const SWIFT_SOURCE: AstGrepLanguageSource;
+export declare const SWIFT_TABLE: LanguageKindTable;
+//# sourceMappingURL=swift.d.ts.map

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

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

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

@@ -0,0 +1,86 @@
+export const SWIFT_SOURCE = {
+    languageName: "swift",
+    moduleName: "@ast-grep/lang-swift",
+};
+export const SWIFT_TABLE = {
+    languageId: "swift",
+    extensions: [".swift"],
+    supportLevel: "deep",
+    commentKinds: ["comment", "multiline_comment"],
+    stringContainerKinds: ["line_string_literal", "multi_line_string_literal", "raw_string_literal"],
+    identifierLeafKinds: ["simple_identifier", "type_identifier", "self_expression"],
+    numberLeafKinds: ["integer_literal", "hex_literal", "oct_literal", "bin_literal", "real_literal"],
+    booleanLeafKinds: ["boolean_literal"],
+    nullLeafKinds: ["nil"],
+    scopes: [
+        {
+            kinds: ["class_declaration"],
+            scopeKind: "class",
+            nameKinds: ["type_identifier", "user_type"],
+            refine: [
+                { childKinds: ["enum"], scopeKind: "enum" },
+                { childKinds: ["extension"], scopeKind: "namespace" },
+            ],
+        },
+        {
+            kinds: ["protocol_declaration"],
+            scopeKind: "interface",
+            nameKinds: ["type_identifier"],
+        },
+        {
+            kinds: ["function_declaration", "protocol_function_declaration"],
+            scopeKind: "function",
+            nameKinds: ["simple_identifier"],
+        },
+        { kinds: ["init_declaration"], scopeKind: "constructor", nameKinds: ["init"] },
+        {
+            kinds: ["property_declaration"],
+            scopeKind: "property",
+            nameKindPath: ["pattern"],
+            nameKinds: ["simple_identifier"],
+            // Wie in Kotlin: `var i = 0` in einem Funktionsrumpf ist kein Symbol.
+            parentKinds: ["class_body", "protocol_body", "enum_class_body", "source_file"],
+        },
+    ],
+    decisions: {
+        ifKinds: ["if_statement"],
+        elseIfParentKinds: ["if_statement"],
+        guardKinds: ["guard_statement"],
+        loopKinds: ["for_statement", "while_statement", "repeat_while_statement"],
+        catchKinds: ["catch_block"],
+        ternaryKinds: ["ternary_expression"],
+        switchKinds: ["switch_statement"],
+        caseKinds: ["switch_entry"],
+        caseExcludeChildKinds: ["default_keyword"],
+        anonymousOperatorKinds: [
+            "conjunction_expression",
+            "disjunction_expression",
+            "nil_coalescing_expression",
+        ],
+        logicalAndOperators: ["&&"],
+        logicalOrOperators: ["||"],
+        shortCircuitOperators: ["??"],
+        jumpKinds: ["control_transfer_statement"],
+        blockKinds: ["statements"],
+    },
+    imports: {
+        kinds: ["import_declaration"],
+        pathKinds: ["identifier"],
+    },
+    calls: {
+        kinds: ["call_expression"],
+        memberKinds: ["navigation_expression"],
+        // Swift benutzt `call_expression` AUCH fuer Indexzugriffe: `items["a"]`
+        // waere sonst ein Aufruf von `items`. Nur ein Anhang, der mit `(` beginnt,
+        // ist ein Aufruf.
+        acceptCall: (node) => {
+            const last = node.children[node.children.length - 1];
+            return last !== undefined && last.text.trimStart().startsWith("(");
+        },
+    },
+    declarationParentKinds: [],
+    visibilityKinds: ["modifiers"],
+    visibilityWords: ["public", "internal", "fileprivate", "private", "open"],
+    fieldNames: ["name"],
+};
+//# sourceMappingURL=swift.js.map

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

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

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

@@ -0,0 +1,55 @@
+/**
+ * Die Sprachtabellen des ast-grep-Backends.
+ *
+ * Jede Sprache ist EINE Tabelle (`shared/table-profile.ts`) plus die Angabe,
+ * aus welchem npm-Paket ihre Grammatik kommt. Kein Motor, keine
+ * Fallunterscheidung, keine zweite Traversierung. Wer eine Sprache
+ * hinzufuegt, schreibt eine Tabelle wie die beiden hier und eine
+ * Registrierungszeile in `languages/index.ts` — sonst nichts.
+ *
+ * DIE KNOTENARTEN SIND NACHGESEHEN, NICHT GERATEN: jede Zeichenkette hier
+ * stammt aus einem echten Baum, den `adapter.test.ts` mit demselben Quelltext
+ * wieder erzeugt. Wer eine Art aendert, ohne den Test zu bewegen, sieht es
+ * sofort.
+ *
+ * SPRACHPAKETE WERDEN EINZELN AUFGENOMMEN. Die 22 Sprachpakete von ast-grep
+ * belegen zusammen 450 MB; eine Sammelabhaengigkeit waere respektlos gegen
+ * jeden, der nur Go analysieren will.
+ */
+import type { LanguageKindTable } from "../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "./adapter.js";
+/** Sprachpakete, wie ast-grep sie kennt (Name) und npm sie liefert (Paket). */
+export declare const GO_SOURCE: AstGrepLanguageSource;
+export declare const RUST_SOURCE: AstGrepLanguageSource;
+/**
+ * Go.
+ *
+ * Zwei Eigenheiten stehen in der Tabelle statt in einer Sonderbehandlung:
+ *  - `else if` ist in Go ein `if_statement` DIREKT unter einem `if_statement`
+ *    (kein `else_clause` wie in JS/Rust) — `elseIfParentKinds` sagt das.
+ *  - Ein Rumpf ist `block > statement_list`; die Guard-Clause-Erkennung muss
+ *    durch BEIDE Huellen hindurch (`blockKinds`).
+ *  - Sichtbarkeit steht nicht im Baum, sondern im Namen: Go exportiert, was
+ *    mit einem Grossbuchstaben beginnt.
+ */
+export declare const GO_TABLE: LanguageKindTable;
+/**
+ * Rust.
+ *
+ * Auch hier stehen die Eigenheiten in der Tabelle:
+ *  - Sichtbarkeit ist ein Knoten (`visibility_modifier`), kein Namensmuster.
+ *  - `use a::b as c` und `use a::{b, c}` werden ausgepackt, sonst stuende der
+ *    ganze Ausdruck als "Pfad" im Ergebnis.
+ *  - `impl Counter { ... }` oeffnet einen Scope der Art `class`, damit
+ *    Methoden `Counter.bump` heissen statt bloss `bump`. Dass eine Datei
+ *    dadurch `Counter` zweimal fuehren kann (einmal `struct_item`, einmal
+ *    `impl_item`), ist gewollt: es sind zwei Quelltextstellen, und die
+ *    Scope-Kennungen unterscheiden sich ueber die Ordnungszahl.
+ *
+ * BEKANNTE GRENZE: eine `fn` in einem `impl`-Block wird als `function`
+ * gefuehrt, nicht als `method` — die Knotenart ist in beiden Faellen
+ * `function_item`, und die Tabelle entscheidet nach Knotenart. Das ist eine
+ * Ungenauigkeit in der Symbolart, keine im Bereich oder in der Metrik.
+ */
+export declare const RUST_TABLE: LanguageKindTable;
+//# sourceMappingURL=languages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../../../src/languages/astgrep-backend/languages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D,+EAA+E;AAC/E,eAAO,MAAM,SAAS,EAAE,qBAGvB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,qBAGzB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,EAAE,iBAiFtB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,EAAE,iBA4FxB,CAAC"}

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

@@ -0,0 +1,214 @@
+/** Sprachpakete, wie ast-grep sie kennt (Name) und npm sie liefert (Paket). */
+export const GO_SOURCE = {
+    languageName: "go",
+    moduleName: "@ast-grep/lang-go",
+};
+export const RUST_SOURCE = {
+    languageName: "rust",
+    moduleName: "@ast-grep/lang-rust",
+};
+/**
+ * Go.
+ *
+ * Zwei Eigenheiten stehen in der Tabelle statt in einer Sonderbehandlung:
+ *  - `else if` ist in Go ein `if_statement` DIREKT unter einem `if_statement`
+ *    (kein `else_clause` wie in JS/Rust) — `elseIfParentKinds` sagt das.
+ *  - Ein Rumpf ist `block > statement_list`; die Guard-Clause-Erkennung muss
+ *    durch BEIDE Huellen hindurch (`blockKinds`).
+ *  - Sichtbarkeit steht nicht im Baum, sondern im Namen: Go exportiert, was
+ *    mit einem Grossbuchstaben beginnt.
+ */
+export const GO_TABLE = {
+    languageId: "go",
+    extensions: [".go"],
+    supportLevel: "deep",
+    commentKinds: ["comment"],
+    stringContainerKinds: ["interpreted_string_literal", "raw_string_literal", "rune_literal"],
+    identifierLeafKinds: [
+        "identifier",
+        "field_identifier",
+        "package_identifier",
+        "type_identifier",
+        "label_name",
+    ],
+    numberLeafKinds: ["int_literal", "float_literal", "imaginary_literal"],
+    booleanLeafKinds: ["true", "false"],
+    nullLeafKinds: ["nil"],
+    scopes: [
+        { kinds: ["function_declaration"], scopeKind: "function" },
+        {
+            kinds: ["method_declaration"],
+            scopeKind: "method",
+            qualifierField: "receiver",
+            qualifierNameKinds: ["type_identifier"],
+        },
+        { kinds: ["method_elem"], scopeKind: "method" },
+        {
+            kinds: ["type_spec"],
+            scopeKind: "type",
+            refine: [
+                { childKinds: ["struct_type"], scopeKind: "class" },
+                { childKinds: ["interface_type"], scopeKind: "interface" },
+            ],
+        },
+    ],
+    decisions: {
+        ifKinds: ["if_statement"],
+        elseIfParentKinds: ["if_statement"],
+        loopKinds: ["for_statement"],
+        switchKinds: ["expression_switch_statement", "type_switch_statement", "select_statement"],
+        // WP-86: `default_case` steht hier NICHT mehr. Gos `select` ist zwar kein
+        // C-`switch` — jeder `communication_case` ist ein echter, zur Laufzeit
+        // gewaehlter Zweig und zaehlt deshalb —, aber der `default`-Zweig ist in
+        // beiden Formen der Fall, der uebrig bleibt. Er eroeffnet keinen
+        // zusaetzlichen unabhaengigen Pfad: ein `switch` mit drei `case` und einem
+        // `default` hat DREI Entscheidungen, nicht vier. Vorher zaehlte er mit und
+        // jede Go-Datei mit `default` bekam eine zyklomatische Zahl zu viel.
+        caseKinds: ["expression_case", "type_case", "communication_case"],
+        binaryKinds: ["binary_expression"],
+        operatorField: "operator",
+        logicalAndOperators: ["&&"],
+        logicalOrOperators: ["||"],
+        jumpKinds: ["return_statement", "break_statement", "continue_statement", "goto_statement"],
+        blockKinds: ["block", "statement_list"],
+        consequenceField: "consequence",
+        alternativeField: "alternative",
+    },
+    imports: {
+        kinds: ["import_declaration"],
+        specKinds: ["import_spec"],
+        pathField: "path",
+        aliasField: "name",
+    },
+    calls: {
+        kinds: ["call_expression"],
+        functionField: "function",
+        argumentsField: "arguments",
+        memberKinds: ["selector_expression"],
+    },
+    declarationParentKinds: [
+        "function_declaration",
+        "method_declaration",
+        "method_elem",
+        "type_spec",
+        "const_spec",
+        "var_spec",
+        "import_spec",
+        "field_declaration",
+    ],
+    bodyField: "body",
+    isExported: (name) => /^\p{Lu}/u.test(name),
+    fieldNames: ["name"],
+};
+/**
+ * Rust.
+ *
+ * Auch hier stehen die Eigenheiten in der Tabelle:
+ *  - Sichtbarkeit ist ein Knoten (`visibility_modifier`), kein Namensmuster.
+ *  - `use a::b as c` und `use a::{b, c}` werden ausgepackt, sonst stuende der
+ *    ganze Ausdruck als "Pfad" im Ergebnis.
+ *  - `impl Counter { ... }` oeffnet einen Scope der Art `class`, damit
+ *    Methoden `Counter.bump` heissen statt bloss `bump`. Dass eine Datei
+ *    dadurch `Counter` zweimal fuehren kann (einmal `struct_item`, einmal
+ *    `impl_item`), ist gewollt: es sind zwei Quelltextstellen, und die
+ *    Scope-Kennungen unterscheiden sich ueber die Ordnungszahl.
+ *
+ * BEKANNTE GRENZE: eine `fn` in einem `impl`-Block wird als `function`
+ * gefuehrt, nicht als `method` — die Knotenart ist in beiden Faellen
+ * `function_item`, und die Tabelle entscheidet nach Knotenart. Das ist eine
+ * Ungenauigkeit in der Symbolart, keine im Bereich oder in der Metrik.
+ */
+export const RUST_TABLE = {
+    languageId: "rust",
+    extensions: [".rs"],
+    supportLevel: "deep",
+    commentKinds: ["line_comment", "block_comment"],
+    stringContainerKinds: ["string_literal", "raw_string_literal", "char_literal"],
+    identifierLeafKinds: [
+        "identifier",
+        "type_identifier",
+        "field_identifier",
+        "primitive_type",
+        "self",
+        "shorthand_field_identifier",
+    ],
+    numberLeafKinds: ["integer_literal", "float_literal"],
+    booleanLeafKinds: ["true", "false"],
+    scopes: [
+        { kinds: ["function_item"], scopeKind: "function" },
+        {
+            kinds: ["function_signature_item"],
+            scopeKind: "method",
+            ancestorKinds: ["trait_item"],
+        },
+        { kinds: ["struct_item", "union_item"], scopeKind: "class" },
+        { kinds: ["impl_item"], scopeKind: "class", nameField: "type" },
+        { kinds: ["trait_item"], scopeKind: "interface" },
+        { kinds: ["enum_item"], scopeKind: "enum" },
+        { kinds: ["type_item"], scopeKind: "type" },
+        { kinds: ["mod_item"], scopeKind: "namespace" },
+    ],
+    decisions: {
+        ifKinds: ["if_expression"],
+        elseIfParentKinds: ["else_clause"],
+        loopKinds: ["for_expression", "while_expression", "loop_expression"],
+        switchKinds: ["match_expression"],
+        // WP-86: gezaehlt wird das MUSTER, nicht der Arm — nur so ist der
+        // Auffangarm `_ => ...` zu erkennen (sein `match_pattern` besteht genau
+        // aus dem `_`). Er ist Rusts `default` und zaehlt nicht;
+        // `Some(_) => ...` zaehlt dagegen, weil es wirklich nur EINEN Fall abdeckt.
+        caseKinds: ["match_pattern"],
+        caseExcludeFirstChildText: "_",
+        // `Some(1) | Some(2)` ist eine Musteralternative — `DecisionKind`
+        // `pattern_alternative` existiert genau dafuer.
+        patternAlternativeKinds: ["or_pattern"],
+        // WP-86: der `?`-OPERATOR IST KONTROLLFLUSS — er kehrt bei `Err` sofort
+        // zurueck. Gezaehlt wird er KONSERVATIV als `short_circuit`, also nur
+        // ERWEITERT (spec.md §16.3), nicht klassisch (§16.2): `?` ist in
+        // idiomatischem Rust so haeufig wie ein Semikolon, und klassisch
+        // mitgezaehlt bekaeme jede Funktion, die drei Aufrufe weiterreicht,
+        // dieselbe Zahl wie eine mit drei `if`. Verschwiegen wird er nicht — die
+        // erweiterte Zahl zeigt ihn.
+        shortCircuitKinds: ["try_expression"],
+        binaryKinds: ["binary_expression"],
+        operatorField: "operator",
+        logicalAndOperators: ["&&"],
+        logicalOrOperators: ["||"],
+        jumpKinds: ["return_expression", "break_expression", "continue_expression"],
+        blockKinds: ["block"],
+        consequenceField: "consequence",
+        alternativeField: "alternative",
+    },
+    imports: {
+        kinds: ["use_declaration"],
+        pathField: "argument",
+        unwrap: [
+            { kinds: ["use_as_clause"], pathField: "path", aliasField: "alias" },
+            { kinds: ["scoped_use_list"], pathField: "path", namesField: "list" },
+        ],
+    },
+    calls: {
+        kinds: ["call_expression", "macro_invocation"],
+        functionField: "function",
+        argumentsField: "arguments",
+        memberKinds: ["field_expression", "scoped_identifier"],
+    },
+    declarationParentKinds: [
+        "function_item",
+        "function_signature_item",
+        "struct_item",
+        "enum_item",
+        "trait_item",
+        "mod_item",
+        "type_item",
+        "const_item",
+        "static_item",
+        "field_declaration",
+        "parameter",
+    ],
+    visibilityKinds: ["visibility_modifier"],
+    bodyField: "body",
+    isExported: (_name, node) => node.children.some((child) => child.type === "visibility_modifier"),
+    fieldNames: ["name", "type"],
+};
+//# sourceMappingURL=languages.js.map

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

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

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

@@ -0,0 +1,71 @@
+/** Die Knotenform von ast-grep, auf die Teilmenge reduziert, die wir benutzen. */
+export interface SgNode {
+    id(): number;
+    kind(): string;
+    text(): string;
+    range(): {
+        start: SgPos;
+        end: SgPos;
+    };
+    isLeaf(): boolean;
+    isNamed(): boolean;
+    children(): SgNode[];
+    namedChildren(): SgNode[];
+    parent(): SgNode | null;
+    prev(): SgNode | null;
+    field(name: string): SgNode | null;
+}
+export interface SgPos {
+    /** 0-basierte Zeile. */
+    line: number;
+    /** 0-basierte Spalte, in UTF-16-Einheiten. */
+    column: number;
+    /**
+     * ENTGEGEN der Typdefinition von ast-grep ("byte offset") ein
+     * UTF-16-Offset — nachgemessen an Umlauten und Emoji. Die Umrechnung in
+     * Bytes macht ausschliesslich die `ByteOffsetTable`.
+     */
+    index: number;
+}
+export interface SgRoot {
+    root(): SgNode;
+}
+/** Wie es einer angemeldeten Sprache ergangen ist. */
+export type AstGrepLanguageStatus = {
+    readonly state: "pending";
+} | {
+    readonly state: "available";
+} | {
+    readonly state: "unavailable";
+    readonly reason: string;
+};
+/**
+ * Meldet eine Sprache fuer die EINE spaetere Registrierung an. Kostet nichts:
+ * kein `require`, kein Laden einer Grammatik — genau wie die traege
+ * Registrierung der tree-sitter-Adapter (`registry.ts`).
+ */
+export declare function registerAstGrepLanguage(languageName: string, moduleName: string): void;
+/**
+ * Zustand einer angemeldeten Sprache — fuer `doctor` und fuer Tests. Loest die
+ * Registrierung NICHT aus: wer nur fragt, soll keine Grammatik laden.
+ */
+export declare function astGrepLanguageStatus(languageName: string): AstGrepLanguageStatus | null;
+/** Alle angemeldeten Sprachen mit ihrem Zustand (Reihenfolge der Anmeldung). */
+export declare function astGrepLanguageStates(): {
+    languageName: string;
+    status: AstGrepLanguageStatus;
+}[];
+/**
+ * Parst Quelltext mit ast-grep. Loest beim ERSTEN Aufruf die einmalige
+ * Registrierung aus (siehe Modulkopf) und wirft einen benannten
+ * `AdapterParseError`, wenn genau diese Sprache nicht verfuegbar ist.
+ */
+export declare function astGrepParse(languageName: string, source: string): SgNode;
+/**
+ * Nur fuer Tests: setzt Anmeldungen und Registrierungszustand zurueck. Der
+ * NATIVE Zustand laesst sich damit NICHT zuruecksetzen — `registerDynamicLanguage`
+ * bleibt im Prozess wirksam. Ein Test, der eine zweite, andere Registrierung
+ * erzwingen will, braucht einen eigenen Prozess.
+ */
+export declare function resetAstGrepRegistrationForTests(): void;
+//# sourceMappingURL=napi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"napi.d.ts","sourceRoot":"","sources":["../../../src/languages/astgrep-backend/napi.ts"],"names":[],"mappings":"AAyCA,kFAAkF;AAClF,MAAM,WAAW,MAAM;IACrB,EAAE,IAAI,MAAM,CAAC;IACb,IAAI,IAAI,MAAM,CAAC;IACf,IAAI,IAAI,MAAM,CAAC;IACf,KAAK,IAAI;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,GAAG,EAAE,KAAK,CAAA;KAAE,CAAC;IACtC,MAAM,IAAI,OAAO,CAAC;IAClB,OAAO,IAAI,OAAO,CAAC;IACnB,QAAQ,IAAI,MAAM,EAAE,CAAC;IACrB,aAAa,IAAI,MAAM,EAAE,CAAC;IAC1B,MAAM,IAAI,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,IAAI,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,KAAK;IACpB,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,MAAM;IACrB,IAAI,IAAI,MAAM,CAAC;CAChB;AAeD,sDAAsD;AACtD,MAAM,MAAM,qBAAqB,GAC7B;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAC7B;IAAE,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GAC/B;IAAE,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAc/D;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAwBtF;AA2DD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAExF;AAED,gFAAgF;AAChF,wBAAgB,qBAAqB,IAAI;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,qBAAqB,CAAA;CAAE,EAAE,CAKjG;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAmCzE;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,IAAI,IAAI,CAIvD"}