@shrkcrft/graph 0.1.0-alpha.10

package/dist/indexer/extract-elixir-file.js

@@ -0,0 +1,164 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { EdgeKind } from "../schema/edge-kind.js";
+import { NodeKind } from "../schema/node-kind.js";
+export const EXTRACT_ELIXIR_FILE_SOURCE = 'extract-elixir-file@v1';
+/**
+ * Regex-based Elixir extractor.
+ *
+ * Top-level constructs only (column-0):
+ *   - `defmodule Path.To.Mod do` → module
+ *   - `def name(...)` → function (exported)
+ *   - `defp name(...)` → function (local)
+ *   - `defstruct …` and `defprotocol` / `defimpl` headers → struct / protocol
+ *
+ * Nested `def`s under a `defmodule` show up at column 0 in this
+ * extractor's view; that's intentional because they're the publicly
+ * callable functions on that module.
+ *
+ * Imports: `alias Foo.Bar`, `alias Foo.{A, B}`, `import Enum`,
+ * `require Logger`, `use MyAppWeb, :controller`. Aliases inside
+ * `{...}` are expanded.
+ *
+ * Out of scope:
+ *   - Pipe operator chains.
+ *   - Macro definitions (`defmacro`/`defmacrop`).
+ *   - Inline guard clauses (`when ...`).
+ */
+export function extractElixirFile(fingerprint, absPath, content) {
+    const text = content ?? readFileSync(absPath, 'utf8');
+    const fileNode = makeFileNode(fingerprint, text);
+    const symbolNodes = [];
+    const edges = [];
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i];
+        if (raw.length === 0)
+            continue;
+        const trimmed = raw.trimStart();
+        if (trimmed.startsWith('#'))
+            continue;
+        // defmodule (can be nested under another defmodule, but we still
+        // emit it as a symbol; the file may declare multiple).
+        let m = /^\s*defmodule\s+([A-Z][\w.]*)\s+do/.exec(raw);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'module', i + 1, true);
+            continue;
+        }
+        // def / defp (top-of-line or under any indentation — we still want them).
+        m = /^\s*def\s+([a-z_][\w?!]*)\s*[\(,\s]/.exec(raw);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'function', i + 1, true);
+            continue;
+        }
+        m = /^\s*defp\s+([a-z_][\w?!]*)\s*[\(,\s]/.exec(raw);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'function', i + 1, false);
+            continue;
+        }
+        m = /^\s*defprotocol\s+([A-Z][\w.]*)/.exec(raw);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, m[1], 'interface', i + 1, true);
+            continue;
+        }
+        m = /^\s*defstruct\s+/.exec(raw);
+        if (m) {
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, '__struct__', 'class', i + 1, true);
+        }
+    }
+    return {
+        fileNode,
+        symbolNodes,
+        edges,
+        rawImportSpecifiers: scanElixirImports(text),
+        importBindings: [],
+        identifierReferences: [],
+    };
+}
+function pushSymbol(fp, nodes, edges, fileId, name, declKind, line, isExported) {
+    const sym = {
+        id: `symbol:${fp.path}#${name}`,
+        kind: NodeKind.Symbol,
+        label: name,
+        path: fp.path,
+        line,
+        data: { declKind, visibility: isExported ? 'export' : 'local', isExported, language: 'elixir' },
+    };
+    nodes.push(sym);
+    edges.push({
+        id: createHash('sha1').update(`${fileId}|${sym.id}|${EdgeKind.DeclaresSymbol}`).digest('hex'),
+        from: fileId,
+        to: sym.id,
+        kind: EdgeKind.DeclaresSymbol,
+        source: EXTRACT_ELIXIR_FILE_SOURCE,
+        data: { visibility: isExported ? 'export' : 'local', declKind, line },
+    });
+}
+function makeFileNode(fp, text) {
+    const label = fp.path.split('/').pop() ?? fp.path;
+    const tags = ['elixir'];
+    if (isElixirTestPath(fp.path))
+        tags.push('test');
+    // Capture the first defmodule name for convenience.
+    const modMatch = /^\s*defmodule\s+([A-Z][\w.]*)\s+do/m.exec(text);
+    return {
+        id: fp.nodeId,
+        kind: NodeKind.File,
+        label,
+        path: fp.path,
+        tags,
+        data: {
+            language: 'elixir',
+            sizeBytes: fp.sizeBytes,
+            sha1: fp.sha1,
+            hasDefaultExport: false,
+            exportCount: 0,
+            localCount: 0,
+            reExportCount: 0,
+            ...(modMatch ? { elixirModule: modMatch[1] } : {}),
+        },
+    };
+}
+function isElixirTestPath(rel) {
+    return (/(?:^|\/)test\//.test(rel) ||
+        /(?:^|\/)[\w-]+_test\.exs?$/.test(rel));
+}
+function scanElixirImports(text) {
+    const out = [];
+    // `alias Foo.Bar`, `alias Foo.Bar.{A, B}`, `import Foo`, `require Foo`, `use Foo, :opt`
+    const re = /^\s*(alias|import|require|use)\s+([A-Z][\w.]*)(?:\.\{([^}]+)\})?/gm;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const kind = `elixir-${m[1]}`;
+        const base = m[2];
+        const line = lineFromOffset(text, m.index);
+        if (m[3]) {
+            for (const item of m[3].split(',')) {
+                const part = item.trim();
+                if (part)
+                    out.push({ specifier: `${base}.${part}`, line, kind });
+            }
+        }
+        else {
+            out.push({ specifier: base, line, kind });
+        }
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const it of out) {
+        const k = `${it.kind}|${it.specifier}|${it.line}`;
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        deduped.push(it);
+    }
+    return deduped;
+}
+function lineFromOffset(text, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < text.length; i++) {
+        if (text.charCodeAt(i) === 10)
+            line += 1;
+    }
+    return line;
+}

package/dist/indexer/extract-go-file.d.ts

@@ -0,0 +1,28 @@
+import type { IFileFingerprint } from '../schema/file-fingerprint.js';
+import type { IExtractedFile } from './extract-ts-file.js';
+export declare const EXTRACT_GO_FILE_SOURCE = "extract-go-file@v1";
+/**
+ * Regex-based Go extractor.
+ *
+ * Top-level constructs only:
+ *   - `func Name(...)` → symbol (function). Methods (`func (r *T) Name`)
+ *     are also captured with the bare method name.
+ *   - `type Name struct {...}` → symbol (struct).
+ *   - `type Name interface {...}` → symbol (interface).
+ *   - `type Name = ...` → symbol (type-alias).
+ *
+ * Imports: handles both `import "path"` and the block form
+ * `import (\n "a"\n "b"\n)`. Specifiers stored without quotes.
+ *
+ * Visibility: Go uses leading-uppercase for exported. We tag symbols
+ * with `isExported: true` when the name starts with an uppercase
+ * letter, false otherwise.
+ *
+ * Out of scope:
+ *   - Constants / vars at the package level (would need a separate pass
+ *     for `var (...)` and `const (...)` blocks). MVP keeps the symbol
+ *     count tight; can be added later behind a flag.
+ *   - Embedded types and generic type parameters.
+ */
+export declare function extractGoFile(fingerprint: IFileFingerprint, absPath: string, content?: string): IExtractedFile;
+//# sourceMappingURL=extract-go-file.d.ts.map

package/dist/indexer/extract-go-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-go-file.d.ts","sourceRoot":"","sources":["../../src/indexer/extract-go-file.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,sBAAsB,uBAAuB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,gBAAgB,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,cAAc,CAoChB"}

package/dist/indexer/extract-go-file.js

@@ -0,0 +1,156 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { EdgeKind } from "../schema/edge-kind.js";
+import { NodeKind } from "../schema/node-kind.js";
+export const EXTRACT_GO_FILE_SOURCE = 'extract-go-file@v1';
+/**
+ * Regex-based Go extractor.
+ *
+ * Top-level constructs only:
+ *   - `func Name(...)` → symbol (function). Methods (`func (r *T) Name`)
+ *     are also captured with the bare method name.
+ *   - `type Name struct {...}` → symbol (struct).
+ *   - `type Name interface {...}` → symbol (interface).
+ *   - `type Name = ...` → symbol (type-alias).
+ *
+ * Imports: handles both `import "path"` and the block form
+ * `import (\n "a"\n "b"\n)`. Specifiers stored without quotes.
+ *
+ * Visibility: Go uses leading-uppercase for exported. We tag symbols
+ * with `isExported: true` when the name starts with an uppercase
+ * letter, false otherwise.
+ *
+ * Out of scope:
+ *   - Constants / vars at the package level (would need a separate pass
+ *     for `var (...)` and `const (...)` blocks). MVP keeps the symbol
+ *     count tight; can be added later behind a flag.
+ *   - Embedded types and generic type parameters.
+ */
+export function extractGoFile(fingerprint, absPath, content) {
+    const text = content ?? readFileSync(absPath, 'utf8');
+    const fileNode = makeFileNode(fingerprint, text);
+    const symbolNodes = [];
+    const edges = [];
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i];
+        const line = i + 1;
+        if (raw.length === 0)
+            continue;
+        if (raw.trimStart().startsWith('//'))
+            continue;
+        // func — with optional receiver `(r *T)`.
+        let m = /^func(?:\s*\([^)]*\))?\s+([A-Za-z_][\w]*)\s*[\(\[]/.exec(raw);
+        if (m) {
+            const name = m[1];
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, name, 'function', line);
+            continue;
+        }
+        // type Name struct { … } / interface { … } / = alias.
+        m = /^type\s+([A-Za-z_][\w]*)\s+(struct|interface|=)/.exec(raw);
+        if (m) {
+            const name = m[1];
+            const decl = m[2] === 'struct' ? 'class' : m[2] === 'interface' ? 'interface' : 'type-alias';
+            pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, name, decl, line);
+        }
+    }
+    return {
+        fileNode,
+        symbolNodes,
+        edges,
+        rawImportSpecifiers: scanGoImports(text),
+        importBindings: [],
+        identifierReferences: [],
+    };
+}
+function pushSymbol(fp, nodes, edges, fileId, name, declKind, line) {
+    const isExported = /^[A-Z]/.test(name);
+    const sym = {
+        id: `symbol:${fp.path}#${name}`,
+        kind: NodeKind.Symbol,
+        label: name,
+        path: fp.path,
+        line,
+        data: { declKind, visibility: isExported ? 'export' : 'local', isExported, language: 'go' },
+    };
+    nodes.push(sym);
+    edges.push({
+        id: createHash('sha1').update(`${fileId}|${sym.id}|${EdgeKind.DeclaresSymbol}`).digest('hex'),
+        from: fileId,
+        to: sym.id,
+        kind: EdgeKind.DeclaresSymbol,
+        source: EXTRACT_GO_FILE_SOURCE,
+        data: { visibility: isExported ? 'export' : 'local', declKind, line },
+    });
+}
+function makeFileNode(fp, text) {
+    const label = fp.path.split('/').pop() ?? fp.path;
+    const tags = ['go'];
+    if (isGoTestPath(fp.path))
+        tags.push('test');
+    const packageMatch = /^package\s+(\w+)/m.exec(text);
+    return {
+        id: fp.nodeId,
+        kind: NodeKind.File,
+        label,
+        path: fp.path,
+        tags,
+        data: {
+            language: 'go',
+            sizeBytes: fp.sizeBytes,
+            sha1: fp.sha1,
+            hasDefaultExport: false,
+            exportCount: 0,
+            localCount: 0,
+            reExportCount: 0,
+            ...(packageMatch ? { goPackage: packageMatch[1] } : {}),
+        },
+    };
+}
+function isGoTestPath(rel) {
+    return /(?:^|\/)[\w-]+_test\.go$/.test(rel);
+}
+function scanGoImports(text) {
+    const out = [];
+    // Single-line: import "path" or import alias "path"
+    const single = /^import\s+(?:[\w.]+\s+)?"([^"\n]+)"/gm;
+    let m;
+    while ((m = single.exec(text)) !== null) {
+        const line = lineFromOffset(text, m.index);
+        out.push({ specifier: m[1], line, kind: 'go-import' });
+    }
+    // Block form: import (\n  "a"\n  alias "b"\n)
+    const block = /^import\s*\(([^)]*)\)/gms;
+    while ((m = block.exec(text)) !== null) {
+        const body = m[1];
+        const startLine = lineFromOffset(text, m.index);
+        const bodyLines = body.split('\n');
+        for (let i = 0; i < bodyLines.length; i += 1) {
+            const ln = bodyLines[i].trim();
+            if (!ln || ln.startsWith('//'))
+                continue;
+            const inner = /^(?:[\w.]+\s+)?"([^"]+)"/.exec(ln);
+            if (inner)
+                out.push({ specifier: inner[1], line: startLine + i, kind: 'go-import' });
+        }
+    }
+    // De-dupe.
+    const seen = new Set();
+    const deduped = [];
+    for (const it of out) {
+        const k = `${it.specifier}|${it.line}`;
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        deduped.push(it);
+    }
+    return deduped;
+}
+function lineFromOffset(text, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < text.length; i++) {
+        if (text.charCodeAt(i) === 10)
+            line += 1;
+    }
+    return line;
+}

package/dist/indexer/extract-java-file.d.ts

@@ -0,0 +1,25 @@
+import type { IFileFingerprint } from '../schema/file-fingerprint.js';
+import type { IExtractedFile } from './extract-ts-file.js';
+export declare const EXTRACT_JAVA_FILE_SOURCE = "extract-java-file@v1";
+/**
+ * Regex-based Java extractor.
+ *
+ * Top-level constructs only — we don't track nested classes or class
+ * members. For a fuller view a future round can layer a real Java
+ * parser (`tree-sitter-java`) without changing the schema.
+ *
+ *   - `public class Name { … }` (and `final` / `abstract` / `sealed`
+ *     modifiers in any order) → symbol (class).
+ *   - `interface Name { … }` → symbol (interface).
+ *   - `enum Name { … }` → symbol (enum).
+ *   - `record Name(...)` → symbol (class).
+ *
+ * Visibility is derived from the modifier: `public` → exported,
+ * anything else → local (package-private / private / protected).
+ *
+ * Imports: classic Java `import a.b.C;` / `import a.b.*;` /
+ * `import static a.b.C.*;`. The specifier is the fully-qualified path
+ * (without trailing `;`).
+ */
+export declare function extractJavaFile(fingerprint: IFileFingerprint, absPath: string, content?: string): IExtractedFile;
+//# sourceMappingURL=extract-java-file.d.ts.map

package/dist/indexer/extract-java-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-java-file.d.ts","sourceRoot":"","sources":["../../src/indexer/extract-java-file.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,wBAAwB,yBAAyB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,gBAAgB,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,cAAc,CAoChB"}

package/dist/indexer/extract-java-file.js

@@ -0,0 +1,140 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { EdgeKind } from "../schema/edge-kind.js";
+import { NodeKind } from "../schema/node-kind.js";
+export const EXTRACT_JAVA_FILE_SOURCE = 'extract-java-file@v1';
+/**
+ * Regex-based Java extractor.
+ *
+ * Top-level constructs only — we don't track nested classes or class
+ * members. For a fuller view a future round can layer a real Java
+ * parser (`tree-sitter-java`) without changing the schema.
+ *
+ *   - `public class Name { … }` (and `final` / `abstract` / `sealed`
+ *     modifiers in any order) → symbol (class).
+ *   - `interface Name { … }` → symbol (interface).
+ *   - `enum Name { … }` → symbol (enum).
+ *   - `record Name(...)` → symbol (class).
+ *
+ * Visibility is derived from the modifier: `public` → exported,
+ * anything else → local (package-private / private / protected).
+ *
+ * Imports: classic Java `import a.b.C;` / `import a.b.*;` /
+ * `import static a.b.C.*;`. The specifier is the fully-qualified path
+ * (without trailing `;`).
+ */
+export function extractJavaFile(fingerprint, absPath, content) {
+    const text = content ?? readFileSync(absPath, 'utf8');
+    const fileNode = makeFileNode(fingerprint, text);
+    const symbolNodes = [];
+    const edges = [];
+    // Capture top-level type declarations. Modifiers can appear in any
+    // order and may include annotations (which we discard for the MVP).
+    // We require the declaration starts at column 0 to keep nested
+    // declarations (class bodies) out of the symbol list.
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i];
+        if (raw.length === 0)
+            continue;
+        if (raw.startsWith(' ') || raw.startsWith('\t'))
+            continue;
+        if (raw.trimStart().startsWith('//'))
+            continue;
+        // Strip leading annotations like `@Override`.
+        const stripped = raw.replace(/^(?:@\w+(?:\([^)]*\))?\s+)+/, '');
+        const m = /^(?:public\s+|protected\s+|private\s+|static\s+|final\s+|abstract\s+|sealed\s+|non-sealed\s+)*\s*(class|interface|enum|record)\s+([A-Za-z_][\w]*)/.exec(stripped);
+        if (!m)
+            continue;
+        const declKind = m[1] === 'class' || m[1] === 'record' ? 'class'
+            : m[1] === 'interface' ? 'interface'
+                : 'enum';
+        const name = m[2];
+        const isExported = /\bpublic\b/.test(stripped);
+        pushSymbol(fingerprint, symbolNodes, edges, fileNode.id, name, declKind, i + 1, isExported);
+    }
+    return {
+        fileNode,
+        symbolNodes,
+        edges,
+        rawImportSpecifiers: scanJavaImports(text),
+        importBindings: [],
+        identifierReferences: [],
+    };
+}
+function pushSymbol(fp, nodes, edges, fileId, name, declKind, line, isExported) {
+    const sym = {
+        id: `symbol:${fp.path}#${name}`,
+        kind: NodeKind.Symbol,
+        label: name,
+        path: fp.path,
+        line,
+        data: { declKind, visibility: isExported ? 'export' : 'local', isExported, language: 'java' },
+    };
+    nodes.push(sym);
+    edges.push({
+        id: createHash('sha1').update(`${fileId}|${sym.id}|${EdgeKind.DeclaresSymbol}`).digest('hex'),
+        from: fileId,
+        to: sym.id,
+        kind: EdgeKind.DeclaresSymbol,
+        source: EXTRACT_JAVA_FILE_SOURCE,
+        data: { visibility: isExported ? 'export' : 'local', declKind, line },
+    });
+}
+function makeFileNode(fp, text) {
+    const label = fp.path.split('/').pop() ?? fp.path;
+    const tags = ['java'];
+    if (isJavaTestPath(fp.path))
+        tags.push('test');
+    const packageMatch = /^package\s+([\w.]+)\s*;/m.exec(text);
+    return {
+        id: fp.nodeId,
+        kind: NodeKind.File,
+        label,
+        path: fp.path,
+        tags,
+        data: {
+            language: 'java',
+            sizeBytes: fp.sizeBytes,
+            sha1: fp.sha1,
+            hasDefaultExport: false,
+            exportCount: 0,
+            localCount: 0,
+            reExportCount: 0,
+            ...(packageMatch ? { javaPackage: packageMatch[1] } : {}),
+        },
+    };
+}
+function isJavaTestPath(rel) {
+    return (/(?:^|\/)src\/test\//.test(rel) ||
+        /(?:^|\/)[\w-]+Test\.java$/.test(rel) ||
+        /(?:^|\/)[\w-]+Tests\.java$/.test(rel));
+}
+function scanJavaImports(text) {
+    const out = [];
+    const re = /^import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;/gm;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const line = lineFromOffset(text, m.index);
+        out.push({ specifier: m[1], line, kind: 'java-import' });
+    }
+    // De-dupe.
+    const seen = new Set();
+    const deduped = [];
+    for (const it of out) {
+        const k = `${it.specifier}|${it.line}`;
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        deduped.push(it);
+    }
+    return deduped;
+}
+function lineFromOffset(text, offset) {
+    let line = 1;
+    for (let i = 0; i < offset && i < text.length; i++) {
+        if (text.charCodeAt(i) === 10)
+            line += 1;
+    }
+    return line;
+}

package/dist/indexer/extract-kotlin-file.d.ts

@@ -0,0 +1,20 @@
+import type { IFileFingerprint } from '../schema/file-fingerprint.js';
+import type { IExtractedFile } from './extract-ts-file.js';
+export declare const EXTRACT_KOTLIN_FILE_SOURCE = "extract-kotlin-file@v1";
+/**
+ * Regex-based Kotlin extractor.
+ *
+ * Top-level constructs only. Captured:
+ *   - `fun name(...)`, `inline fun`, `suspend fun` → function
+ *   - `class Name`, `data class Name`, `value class Name`, `inline class Name`, `sealed class Name`, `abstract class Name`, `open class Name` → class
+ *   - `interface Name`, `sealed interface Name` → interface
+ *   - `object Name` → object (rendered as `class`)
+ *   - `enum class Name` → enum
+ *   - `typealias Name = ...` → type-alias
+ *   - `val NAME: T`, `var NAME: T`, `const val NAME` → const
+ *
+ * Visibility: Kotlin's default is `public`. `private`, `internal`,
+ * and `protected` mark a symbol as local; everything else is exported.
+ */
+export declare function extractKotlinFile(fingerprint: IFileFingerprint, absPath: string, content?: string): IExtractedFile;
+//# sourceMappingURL=extract-kotlin-file.d.ts.map

package/dist/indexer/extract-kotlin-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-kotlin-file.d.ts","sourceRoot":"","sources":["../../src/indexer/extract-kotlin-file.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,KAAK,EACV,cAAc,EAEf,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,0BAA0B,2BAA2B,CAAC;AAEnE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,gBAAgB,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,GACf,cAAc,CA8DhB"}