@ltm-alpha/alpha-cs 1.6.0

package/dist/extraction/kernel/loader.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Native-kernel loader — finds, loads, and contract-verifies the
+ * codegraph-kernel .node addon.
+ *
+ * The kernel is OPTIONAL everywhere. Every failure mode here (no binary for
+ * this platform, dlopen error, ABI/kind-table mismatch) resolves to `null`
+ * and the extraction path silently keeps using the wasm pipeline — a missing
+ * or stale kernel must never break indexing, only skip the speedup. Set
+ * CODEGRAPH_KERNEL_DEBUG=1 to see why a kernel didn't load.
+ *
+ * Kill switch: CODEGRAPH_KERNEL=0 disables the kernel entirely (checked per
+ * call so tests and embedders can flip it at runtime).
+ *
+ * Search order:
+ *   1. CODEGRAPH_KERNEL_PATH — explicit .node path (dev/testing override)
+ *   2. <up3>/kernel/codegraph-kernel.node — the release bundle layout
+ *      (lib/dist/** next to lib/kernel/; see scripts/build-bundle.sh)
+ *   3. <up3>/codegraph-kernel/prebuilds/<platform>-<arch>/codegraph-kernel.node
+ *      — from-source runs and tests (staged by scripts/build-kernel.sh)
+ *
+ * "up3" = three directories above this file, which is the package root both
+ * from src/extraction/kernel/ and from dist/extraction/kernel/.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKernel = getKernel;
+exports.kernelSupports = kernelSupports;
+exports.resetKernelForTests = resetKernelForTests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const module_1 = require("module");
+const types_1 = require("../../types");
+const layout_1 = require("./layout");
+const debugEnabled = () => process.env.CODEGRAPH_KERNEL_DEBUG === '1';
+function debug(msg) {
+    if (debugEnabled())
+        process.stderr.write(`[codegraph-kernel] ${msg}\n`);
+}
+/** Languages the loaded binary supports (contract-verified). Empty when no kernel. */
+let kernelLanguages = new Set();
+/** undefined = not attempted yet; null = attempted and unavailable. */
+let cached;
+function candidatePaths() {
+    const candidates = [];
+    if (process.env.CODEGRAPH_KERNEL_PATH)
+        candidates.push(process.env.CODEGRAPH_KERNEL_PATH);
+    const packageRoot = path.resolve(__dirname, '..', '..', '..');
+    candidates.push(path.join(packageRoot, 'kernel', 'codegraph-kernel.node'));
+    candidates.push(path.join(packageRoot, 'codegraph-kernel', 'prebuilds', `${process.platform}-${process.arch}`, 'codegraph-kernel.node'));
+    return candidates;
+}
+/**
+ * Verify the binary speaks our wire contract: same ABI version and byte-equal
+ * NodeKind/EdgeKind tables (kinds cross the boundary as indexes into these).
+ */
+function verifyContract(mod, from) {
+    const info = mod.contractInfo();
+    if (info.abiVersion !== layout_1.KERNEL_ABI_VERSION) {
+        debug(`${from}: ABI ${info.abiVersion} != expected ${layout_1.KERNEL_ABI_VERSION} — ignoring kernel`);
+        return false;
+    }
+    const sameTable = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+    if (!sameTable(info.nodeKinds, types_1.NODE_KINDS) || !sameTable(info.edgeKinds, types_1.EDGE_KINDS)) {
+        debug(`${from}: NodeKind/EdgeKind tables differ from src/types.ts — ignoring kernel`);
+        return false;
+    }
+    return true;
+}
+/**
+ * Load (once per process) and return the kernel module, or null when
+ * unavailable. The kill switch is NOT checked here — callers route through
+ * `kernelAvailable()` / `tryKernelExtract()` which check it per call.
+ */
+function getKernel() {
+    if (cached !== undefined)
+        return cached;
+    cached = null;
+    for (const candidate of candidatePaths()) {
+        try {
+            if (!fs.existsSync(candidate))
+                continue;
+            // createRequire: works identically from CJS output and future ESM.
+            const req = (0, module_1.createRequire)(__filename);
+            const mod = req(candidate);
+            if (typeof mod.extractFile !== 'function' || typeof mod.contractInfo !== 'function') {
+                debug(`${candidate}: missing expected exports — ignoring`);
+                continue;
+            }
+            if (!verifyContract(mod, candidate))
+                continue;
+            kernelLanguages = new Set(mod.contractInfo().languages);
+            debug(`loaded ${candidate} (languages: ${[...kernelLanguages].join(', ')})`);
+            cached = mod;
+            break;
+        }
+        catch (err) {
+            debug(`${candidate}: failed to load — ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return cached;
+}
+/** True when the kill switch is off, a verified binary is loaded, and it supports `language`. */
+function kernelSupports(language) {
+    if (process.env.CODEGRAPH_KERNEL === '0')
+        return false;
+    return getKernel() !== null && kernelLanguages.has(language);
+}
+/** Test hook: forget the loaded module so a changed env is re-evaluated. */
+function resetKernelForTests() {
+    cached = undefined;
+    kernelLanguages = new Set();
+}
+//# sourceMappingURL=loader.js.map

package/dist/extraction/kernel/loader.js.map

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

package/dist/extraction/languages/arkts.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const arktsExtractor: LanguageExtractor;
+//# sourceMappingURL=arkts.d.ts.map

package/dist/extraction/languages/arkts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arkts.d.ts","sourceRoot":"","sources":["../../../src/extraction/languages/arkts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAgG9D,eAAO,MAAM,cAAc,EAAE,iBA+B5B,CAAC"}

package/dist/extraction/languages/arkts.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arktsExtractor = void 0;
+const typescript_1 = require("./typescript");
+/**
+ * ArkTS (HarmonyOS / OpenHarmony, `.ets`) — a TypeScript superset whose
+ * headline feature is declarative UI: an `@Component struct` with a `build()`
+ * method describing the view tree, `@State`/`@Prop`/`@Link` reactive
+ * properties, and global `@Builder`/`@Extend`/`@Styles` functions.
+ *
+ * The vendored grammar (harmony-contrib/tree-sitter-arkts) extends
+ * tree-sitter-javascript exactly the way tree-sitter-typescript does, so every
+ * TS node type — and therefore the whole typescriptExtractor — applies
+ * verbatim. ArkTS-specific shapes it adds:
+ *
+ *   - `struct_declaration` / `struct_body` — the `@Component struct`. Same
+ *     `name:`/`body:` fields as class_declaration; members are ordinary
+ *     `method_definition` / `public_field_definition` nodes, so struct members
+ *     extract through the standard class-member paths.
+ *   - `arkui_component_expression` — a build()-DSL component instantiation
+ *     (`Column() { … }`). Carries a `function:` field (the component), an
+ *     optional `children:` block, and — unlike TS — the CHAINED ATTRIBUTES as
+ *     repeated `property:`/`arguments:` field pairs on the SAME node
+ *     (`Text(x).fontSize(16).opacity(0.6)` is ONE node, not nested calls).
+ *     Handled by the arkts branch in extractCall (tree-sitter.ts).
+ *   - Decorators on functions (`@Builder function F() {}`) — invalid in TS,
+ *     first-class here (a `decorator:` field on function_declaration), so the
+ *     core's existing extractDecoratorsFor path captures them.
+ */
+/** Reactive/state decorators that make a member worth flagging (searchable). */
+const DECORATED_MEMBER_TYPES = new Set([
+    'struct_declaration',
+    'public_field_definition',
+    'method_definition',
+    'function_declaration',
+]);
+/**
+ * Collect decorator names for a declaration from BOTH positions the grammar
+ * produces: direct `decorator` children (`@Entry @Component struct X`,
+ * `@State count` on a field) and preceding `decorator` siblings (`@Builder`
+ * before a method_definition inside struct_body; `@Component` on the
+ * export_statement wrapping `export struct X`). The backwards sibling walk
+ * stops at the first non-decorator so an earlier declaration's decorators
+ * never leak in (mirrors extractDecoratorsFor's sibling pass).
+ */
+function collectDecoratorNames(node) {
+    const names = [];
+    const nameOf = (dec) => {
+        for (let i = 0; i < dec.namedChildCount; i++) {
+            const child = dec.namedChild(i);
+            if (!child)
+                continue;
+            if (child.type === 'identifier')
+                return child.text;
+            if (child.type === 'call_expression') {
+                // `@StorageLink('theme')` / `@Extend(Text)` — the decorator name is
+                // the callee.
+                const fn = child.childForFieldName('function');
+                if (fn?.type === 'identifier')
+                    return fn.text;
+            }
+        }
+        return undefined;
+    };
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'decorator') {
+            const n = nameOf(child);
+            if (n)
+                names.push(n);
+        }
+    }
+    const parent = node.parent;
+    if (parent) {
+        // Find this node among the parent's named children by start offset
+        // (wrapper identity is not stable across navigation), then walk backwards.
+        const start = node.startIndex;
+        let idx = -1;
+        for (let i = 0; i < parent.namedChildCount; i++) {
+            const sib = parent.namedChild(i);
+            if (sib && sib.startIndex === start) {
+                idx = i;
+                break;
+            }
+        }
+        for (let i = idx - 1; i >= 0; i--) {
+            const sib = parent.namedChild(i);
+            if (!sib || sib.type !== 'decorator')
+                break;
+            const n = nameOf(sib);
+            if (n)
+                names.unshift(n);
+        }
+    }
+    return names.length > 0 ? names : undefined;
+}
+exports.arktsExtractor = {
+    ...typescript_1.typescriptExtractor,
+    // `@Component struct X { … }` — extractStruct handles it (kind `struct`,
+    // members extracted like class members, `this.m()` resolution and the
+    // class/struct containment gates in the name-matcher all apply as-is). The
+    // component-ness is preserved on the node's decorators (`Component`,
+    // `Entry`, `CustomDialog`, `Reusable`), captured by extractModifiers below.
+    structTypes: ['struct_declaration'],
+    // build()-DSL component instantiations are call sites: `TodoRow({...})`
+    // inside a parent's build() is the parent→child component edge, resolved by
+    // the ordinary call pipeline against the child's struct node. The arkts
+    // branch in extractCall also lifts each chained `.attr(...)` (emitted
+    // dot-prefixed so it can ONLY resolve to `@Extend`/`@Styles`/`@Builder`
+    // attribute helpers — see matchReference) and `.onXxx(this.handler)`
+    // method-reference bindings. `leading_dot_expression` is the detached-chain
+    // shape the grammar produces when a nested component's chain starts on the
+    // line after its closing `}` inside arkui_children.
+    callTypes: ['call_expression', 'arkui_component_expression', 'leading_dot_expression'],
+    // Surface ArkTS decorators on the node's `decorators` list (searchable, and
+    // the hook a future ArkUI state→build synthesizer keys off). Core paths
+    // already emit `decorates` REFERENCES for classes/methods/properties/
+    // functions; this hook is what puts the names on struct nodes too —
+    // extractStruct has no extractDecoratorsFor call, and node.decorators is
+    // only populated via extractModifiers (see createNode).
+    extractModifiers: (node) => {
+        if (!DECORATED_MEMBER_TYPES.has(node.type))
+            return undefined;
+        return collectDecoratorNames(node);
+    },
+};
+//# sourceMappingURL=arkts.js.map

package/dist/extraction/languages/arkts.js.map

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

package/dist/extraction/languages/c-cpp.d.ts

@@ -0,0 +1,167 @@
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+import type { LanguageExtractor } from '../tree-sitter-types';
+/**
+ * Normalize a C++ return type to the bare class name a method could be called
+ * on. Unwraps smart-pointer / optional wrappers to their element type
+ * (`std::unique_ptr<Widget>` → `Widget`) so a factory's `->method()` resolves on
+ * the pointee. Strips cv-qualifiers, `&`/`*`, namespace qualifiers, and other
+ * template args. Returns undefined for primitives / void / `auto` / empty.
+ */
+export declare function normalizeCppReturnType(raw: string): string | undefined;
+/**
+ * Strip C++ template arguments from a base-type reference name so it matches the
+ * bare class/struct the template was DEFINED as. `template<typename T> class
+ * Base { … }` is indexed as a node named `Base`, but a derived class
+ * `class D : public Base<int>` records its base as the full `Base<int>` (and
+ * `class Q : public ns::Tpl<int>` as `ns::Tpl<int>`) — neither name-matches
+ * `Base` / `ns::Tpl`, so the `extends` edge never resolves and the derived class
+ * looks like it inherits from nothing (#1043).
+ *
+ * Removes every balanced `<…>` group regardless of nesting or position, so
+ * `Base<int>` → `Base`, `ns::Tpl<Foo<int>>` → `ns::Tpl`, and the rare
+ * `Outer<int>::Inner` → `Outer::Inner`. The remaining qualified head is exactly
+ * what the non-templated base case already produces, so resolution treats them
+ * identically. A name with no template args passes through unchanged.
+ */
+export declare function stripCppTemplateArgs(name: string): string;
+/**
+ * Is this C++ `field_declaration` a pure-virtual method (`virtual int read(int key) = 0;`)?
+ * tree-sitter-cpp shapes those as a field_declaration whose declarator unwraps to a
+ * `function_declarator`, with the pure-virtual `= 0` as a DIRECT `number_literal` "0"
+ * child of the field_declaration (default-arg `= 0` lives inside parameter_declaration
+ * and must not match). Bodiless method prototypes (`int foo();`) and data members
+ * (`int x = 0;`) are excluded — prototypes usually have an out-of-line definition that
+ * already mints the method node; pure virtuals never do (#1727).
+ */
+export declare function isCppPureVirtualMethodDecl(node: SyntaxNode): boolean;
+export declare const cExtractor: LanguageExtractor;
+/**
+ * Blank an export/visibility macro in a `class/struct EXPORT_MACRO Name …`
+ * *definition* header before parsing. Not knowing the macro, tree-sitter reads
+ * `class EXPORT_MACRO` as an elaborated type specifier and the rest as a
+ * function, so the whole class — its name, base clause, and members — drops out
+ * of the index (#946 catches the resulting phantom function but can't recover
+ * the class), which silently breaks type-hierarchy / inheritance-impact queries
+ * for effectively every Unreal-Engine (`*_API`), Qt/Boost (`*_EXPORT`), LLVM
+ * (`*_ABI`), … class. Replacing the macro with equal-length spaces preserves
+ * every byte offset (and thus line/column), so the declaration then parses as a
+ * normal class_specifier and the existing extraction emits the node, members,
+ * and `extends` edge. (#1061, follow-up to #946.)
+ *
+ * Matched tightly so it can't touch the same macro used as an ordinary value
+ * elsewhere (`int x = SOME_API;`): the macro is the ALL-CAPS token sitting
+ * *between* `class`/`struct` and the type name, and the trailing `[:{]`
+ * definition-guard fires only when a base clause or body follows — the only
+ * shape that misparses. That guard also leaves elaborated-type variable
+ * declarations (`struct FOO var;`, `class FOO obj = …`) untouched, since those
+ * end in `;` / `=` / `[`, never `:` / `{`. C++-only (wired into cppExtractor),
+ * so C's heavier use of `struct TAG var;` never reaches it.
+ */
+export declare function blankCppExportMacros(source: string): string;
+export declare function blankCppInlineMacros(source: string): string;
+/**
+ * Universal fallback (any macro, no list) for a C/C++ function name still mangled
+ * because a macro we don't blank sat in front of the return type: `MACRO Ret
+ * name(…)` / `Ret MACRO name(…)` misparse so the return type is glued onto the
+ * name ("Ret name", "char_t* to_str(double v)"). Recover the real identifier —
+ * the token immediately before the parameter list (or the last token). This runs
+ * AFTER the curated pre-parse blank, so it only ever sees the residual tail that
+ * blanking didn't already fix cleanly (which also recovers the return type).
+ *
+ * Safe by construction: only touches an ALREADY-mangled name — one with an
+ * internal space that isn't a legit `operator …`/destructor — so a well-formed
+ * name is returned unchanged. Guarded against the two ways it could mis-pick:
+ * the `Ret (name)` parenthesized-name idiom (left as-is, ambiguous), and a token
+ * that is a bare primitive/keyword rather than a real identifier.
+ */
+export declare function recoverMangledCppName(name: string): string;
+export declare function blankMetalAttributes(source: string): string;
+/**
+ * Blank annotation-style macro invocations that decorate a declaration but carry
+ * NO terminating semicolon — the pervasive Unreal-Engine reflection markup
+ * (`UPROPERTY(...)`, `UFUNCTION(...)`, `UCLASS(...)`, `GENERATED_BODY()`,
+ * `UE_DEPRECATED_FORGAME(...)`, `DECLARE_DELEGATE_*(...)`, …) that sits on its
+ * own line right before a member/type. tree-sitter's C++ grammar doesn't know
+ * these are macros, so each one drops into error recovery; in a big reflected
+ * class (`CharacterMovementComponent.h` has ~240 of them) the errors accumulate
+ * until the enclosing `class_specifier` can't close and collapses into an ERROR
+ * node — the whole class definition, its members, and its `extends` edges vanish
+ * from the graph. Neither `blankCppExportMacros` (class-header export macros) nor
+ * `blankCppInlineMacros` (return-type inline specifiers) touches these in-body
+ * markup macros. Replacing each with equal-length spaces preserves every byte
+ * offset (so line/column stay exact) and the class then parses normally.
+ *
+ * Deliberately name-list-FREE — UE alone has hundreds of such macros and projects
+ * add their own — so it keys on structure, not a curated list, matched tightly to
+ * avoid touching legitimate C++:
+ *  - the macro must be the FIRST non-whitespace token on its line (`^[ \t]*`),
+ *    which is where declaration markup lives — so a macro used inside an
+ *    expression or condition (`if (CHECK(x))`, `x = MACRO(a) + b`) is never
+ *    matched (it isn't line-leading);
+ *  - the name must be ALL-CAPS (`[A-Z][A-Z0-9_]{2,}`), since ordinary
+ *    function/type names called at line start are lower/mixed case;
+ *  - the char after the balanced `(...)` must START A DECLARATION — a letter,
+ *    `_`, `~` (destructor), or `#` (a following directive). Declaration markup is
+ *    always followed by the thing it decorates (`UPROPERTY(...)\n float X;`,
+ *    `UE_DEPRECATED(...) UPROPERTY(...)`), whereas a statement call is followed by
+ *    `;` (`FOO(x);`), an init-list item by `,`/`{`, and an expression fragment by
+ *    an operator (`MAKE(a) + 1`) — all rejected. String/char literals inside the
+ *    args are skipped so an embedded `)` can't mis-close the balance.
+ *
+ * C++-only (wired into cppExtractor). A blanked macro inside a block comment is
+ * harmless (comments don't parse), and the rare line-leading no-semicolon
+ * ALL-CAPS call that isn't markup only loses that one annotation, never a whole
+ * class.
+ */
+export declare function blankCppAnnotationMacroCalls(source: string): string;
+export declare function blankLoneMacroLines(source: string): string;
+export declare function blankCppApiPrefixMacros(source: string): string;
+export declare function blankCppInlineAnnotationMacros(source: string): string;
+export declare function blankCudaConstructs(source: string): string;
+export declare function blankCLeadingAttrMacros(source: string): string;
+export declare function blankCCplusplusGuardBodies(source: string): string;
+export declare function blankCStatementMacroCalls(source: string): string;
+export declare function blankCSandwichedAnnotations(source: string): string;
+export declare function blankCAutoInference(source: string): string;
+export declare function blankCTrailingParamAttrMacros(source: string): string;
+export declare function blankCKernelAnnotations(source: string): string;
+export declare function blankCParameterizedAnnotationMacros(source: string): string;
+export declare function blankCTypeKeywordArgs(source: string): string;
+export declare function blankCFileScopePrefixedDeclMacros(source: string): string;
+export declare function rewriteCPrefixedDeclMacroInitializers(source: string): string;
+export declare function blankCVaArgQualifiedTypeArgs(source: string): string;
+export declare function blankCNamedVariadicDefineDots(source: string): string;
+/** C source pre-processing: neutralize `#ifdef __cplusplus` compat-guard
+ * bodies (invisible to a C compiler; `extern "C" {` otherwise errors every
+ * public header), blank declaration-markup macro calls and lone macro lines
+ * (`REDIS_NO_SANITIZE("bounds")` before a definition, jemalloc's diagnostic
+ * toggles — the same structural shapes the C++ side already blanks), recover
+ * functions hidden behind a leading attribute macro (#1211), then — for
+ * C-detected headers in CUDA projects (llm.c keeps `__device__` helpers and
+ * kernel prototypes in plain `.h`) — the same content-gated CUDA blank as
+ * C++. Offset-preserving. */
+/**
+ * Blank the argument list of a statement-level `MACRO( … );` call whose
+ * arguments are designated initializers — betaflight's
+ *
+ *     RESET_CONFIG(pidProfile_t, pidProfile,
+ *         .pid = { [PID_ROLL] = PID_ROLL_DEFAULT, … },
+ *         .pidSumLimit = PIDSUM_LIMIT,
+ *         …
+ *     );
+ *
+ * tree-sitter-c has no rule for `.field = value` as a call argument. Even a
+ * small statement-level `M(a, b, .x = 1, .y = { 1, 2 },);` with a trailing
+ * comma recovers by extending the enclosing `function_definition` to EOF —
+ * the next function vanishes and later ones nest under the first (#1729 —
+ * 310 functions in 73 files on a betaflight tree, which name matching then
+ * treated as unreachable closures). Emptying the argument list to spaces,
+ * newlines kept, leaves `RESET_CONFIG(\n\n…\n);` — a call the grammar parses
+ * cleanly — at the cost of the references inside the initializer, which the
+ * broken parse was not yielding either. Statement-level only (`);` follows),
+ * macro-cased name only, offsets preserved. Runs before the kernel route
+ * point, so both the wasm and kernel C arms see the same bytes.
+ */
+export declare function blankCDesignatedMacroArgs(source: string): string;
+export declare const cppExtractor: LanguageExtractor;
+//# sourceMappingURL=c-cpp.d.ts.map

package/dist/extraction/languages/c-cpp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c-cpp.d.ts","sourceRoot":"","sources":["../../../src/extraction/languages/c-cpp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAgH9D;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAkBtE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAUzD;AAGD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAiBpE;AAaD,eAAO,MAAM,UAAU,EAAE,iBAiExB,CAAC;AAoCF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAM3D;AA8ED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAG3D;AAWD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ1D;AAyBD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAG3D;AAkDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA0CnE;AA8BD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA2B1D;AA4BD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAG9D;AAuBD,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAmCrE;AAiDD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAmB1D;AAyGD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAK9D;AAoCD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAwBjE;AAgCD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA2GhE;AAoBD,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAQlE;AAWD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAK1D;AAmBD,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAUpE;AA+CD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAkB9D;AA8BD,wBAAgB,mCAAmC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAwB1E;AAwCD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAwE5D;AAyBD,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAuCxE;AAoBD,wBAAgB,qCAAqC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAyB5E;AAaD,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAOnE;AAiBD,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAapE;AAED;;;;;;;;6BAQ6B;AAC7B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA0BhE;AAiCD,eAAO,MAAM,YAAY,EAAE,iBAyG1B,CAAC"}