@samchon/graph 0.1.0

package/lib/indexer/buildGraphDump.js

@@ -0,0 +1,394 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraphDump = buildGraphDump;
+const _a = __importStar(require("typia/lib/internal/_assertGuard"));
+const node_path_1 = __importDefault(require("node:path"));
+const typia_1 = __importDefault(require("typia"));
+const lspIndexer_1 = require("./lspIndexer");
+const staticIndexer_1 = require("./staticIndexer");
+async function buildGraphDump(options = {}) {
+    const normalized = {
+        ...options,
+        cwd: node_path_1.default.resolve(options.cwd ?? process.cwd()),
+        mode: options.mode ?? "auto",
+    };
+    if (normalized.mode === "static") {
+        return validateDump((0, staticIndexer_1.buildStaticGraph)(normalized));
+    }
+    if (normalized.mode === "lsp") {
+        return validateDump((await (0, lspIndexer_1.buildLspGraph)(normalized)).dump);
+    }
+    return validateDump((await (0, lspIndexer_1.buildLspGraph)(normalized)).dump);
+}
+function validateDump(dump) {
+    return (() => {
+        const _iv0 = new Set(["bash", "c", "cpp", "csharp", "dart", "go", "java", "javascript", "kotlin", "lua", "php", "python", "ruby", "rust", "scala", "swift", "typescript", "unknown", "zig"]);
+        const _iv1 = new Set(["class", "constructor", "enum", "external_symbol", "field", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
+        const _ip0 = input => "string" === typeof input["name"];
+        const _ip1 = input => "string" === typeof input["file"];
+        const _ip2 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io3(input["evidence"]);
+        const _iv2 = new Set(["accesses", "calls", "contains", "decorates", "exports", "extends", "implements", "imports", "instantiates", "overrides", "references", "renders", "tests", "type_ref"]);
+        const _av0 = new Set(["bash", "c", "cpp", "csharp", "dart", "go", "java", "javascript", "kotlin", "lua", "php", "python", "ruby", "rust", "scala", "swift", "typescript", "unknown", "zig"]);
+        const _ae0 = "(\"bash\" | \"c\" | \"cpp\" | \"csharp\" | \"dart\" | \"go\" | \"java\" | \"javascript\" | \"kotlin\" | \"lua\" | \"php\" | \"python\" | \"ruby\" | \"rust\" | \"scala\" | \"swift\" | \"typescript\" | \"unknown\" | \"zig\")";
+        const _av1 = new Set(["class", "constructor", "enum", "external_symbol", "field", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
+        const _ae1 = "(\"class\" | \"constructor\" | \"enum\" | \"external_symbol\" | \"field\" | \"file\" | \"function\" | \"interface\" | \"method\" | \"module\" | \"namespace\" | \"package\" | \"parameter\" | \"property\" | \"type\" | \"variable\")";
+        const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".name",
+            expected: "string",
+            value: input["name"]
+        }, _errorFactory);
+        const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["file"] || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".file",
+            expected: "string",
+            value: input["file"]
+        }, _errorFactory);
+        const _ap2 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".evidence",
+            expected: "(IGraphEvidence | undefined)",
+            value: input["evidence"]
+        }, _errorFactory)) && _ao3(input["evidence"], _path + ".evidence", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".evidence",
+            expected: "(IGraphEvidence | undefined)",
+            value: input["evidence"]
+        }, _errorFactory);
+        const _av2 = new Set(["accesses", "calls", "contains", "decorates", "exports", "extends", "implements", "imports", "instantiates", "overrides", "references", "renders", "tests", "type_ref"]);
+        const _ae2 = "(\"accesses\" | \"calls\" | \"contains\" | \"decorates\" | \"exports\" | \"extends\" | \"implements\" | \"imports\" | \"instantiates\" | \"overrides\" | \"references\" | \"renders\" | \"tests\" | \"type_ref\")";
+        const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.project || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".project",
+            expected: "string",
+            value: input.project
+        }, _errorFactory)) && ((Array.isArray(input.languages) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".languages",
+            expected: "Array<GraphLanguage>",
+            value: input.languages
+        }, _errorFactory)) && input.languages.every((elem, _index9) => true === _av0.has(elem) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".languages[" + _index9 + "]",
+            expected: _ae0,
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".languages",
+            expected: "Array<GraphLanguage>",
+            value: input.languages
+        }, _errorFactory)) && ("string" === typeof input.generatedAt || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".generatedAt",
+            expected: "string",
+            value: input.generatedAt
+        }, _errorFactory)) && ("hybrid" === input.indexer || "lsp" === input.indexer || "static" === input.indexer || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".indexer",
+            expected: "(\"hybrid\" | \"lsp\" | \"static\")",
+            value: input.indexer
+        }, _errorFactory)) && ((Array.isArray(input.nodes) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".nodes",
+            expected: "Array<IGraphNode>",
+            value: input.nodes
+        }, _errorFactory)) && input.nodes.every((elem, _index10) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".nodes[" + _index10 + "]",
+            expected: "IGraphNode",
+            value: elem
+        }, _errorFactory)) && _ao1(elem, _path + ".nodes[" + _index10 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".nodes[" + _index10 + "]",
+            expected: "IGraphNode",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".nodes",
+            expected: "Array<IGraphNode>",
+            value: input.nodes
+        }, _errorFactory)) && ((Array.isArray(input.edges) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".edges",
+            expected: "Array<IGraphEdge>",
+            value: input.edges
+        }, _errorFactory)) && input.edges.every((elem, _index11) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".edges[" + _index11 + "]",
+            expected: "IGraphEdge",
+            value: elem
+        }, _errorFactory)) && _ao4(elem, _path + ".edges[" + _index11 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".edges[" + _index11 + "]",
+            expected: "IGraphEdge",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".edges",
+            expected: "Array<IGraphEdge>",
+            value: input.edges
+        }, _errorFactory)) && (undefined === input.diagnostics || (Array.isArray(input.diagnostics) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".diagnostics",
+            expected: "(Array<IGraphDiagnostic> | undefined)",
+            value: input.diagnostics
+        }, _errorFactory)) && input.diagnostics.every((elem, _index12) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".diagnostics[" + _index12 + "]",
+            expected: "IGraphDiagnostic",
+            value: elem
+        }, _errorFactory)) && _ao5(elem, _path + ".diagnostics[" + _index12 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".diagnostics[" + _index12 + "]",
+            expected: "IGraphDiagnostic",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".diagnostics",
+            expected: "(Array<IGraphDiagnostic> | undefined)",
+            value: input.diagnostics
+        }, _errorFactory)) && (undefined === input.warnings || (Array.isArray(input.warnings) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".warnings",
+            expected: "(Array<string> | undefined)",
+            value: input.warnings
+        }, _errorFactory)) && input.warnings.every((elem, _index13) => "string" === typeof elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".warnings[" + _index13 + "]",
+            expected: "string",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".warnings",
+            expected: "(Array<string> | undefined)",
+            value: input.warnings
+        }, _errorFactory));
+        const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".id",
+            expected: "string",
+            value: input.id
+        }, _errorFactory)) && (true === _av1.has(input.kind) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".kind",
+            expected: _ae1,
+            value: input.kind
+        }, _errorFactory)) && (true === _av0.has(input.language) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".language",
+            expected: _ae0,
+            value: input.language
+        }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".qualifiedName",
+            expected: "(string | undefined)",
+            value: input.qualifiedName
+        }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && ("boolean" === typeof input.external || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".external",
+            expected: "boolean",
+            value: input.external
+        }, _errorFactory)) && (undefined === input.ignored || "boolean" === typeof input.ignored || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".ignored",
+            expected: "(boolean | undefined)",
+            value: input.ignored
+        }, _errorFactory)) && (undefined === input.exported || "boolean" === typeof input.exported || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".exported",
+            expected: "(boolean | undefined)",
+            value: input.exported
+        }, _errorFactory)) && (undefined === input.signature || "string" === typeof input.signature || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".signature",
+            expected: "(string | undefined)",
+            value: input.signature
+        }, _errorFactory)) && (undefined === input.modifiers || (Array.isArray(input.modifiers) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".modifiers",
+            expected: "(Array<string> | undefined)",
+            value: input.modifiers
+        }, _errorFactory)) && input.modifiers.every((elem, _index14) => "string" === typeof elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".modifiers[" + _index14 + "]",
+            expected: "string",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".modifiers",
+            expected: "(Array<string> | undefined)",
+            value: input.modifiers
+        }, _errorFactory)) && (undefined === input.decorators || (Array.isArray(input.decorators) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators",
+            expected: "(Array<IGraphDecorator> | undefined)",
+            value: input.decorators
+        }, _errorFactory)) && input.decorators.every((elem, _index15) => ("object" === typeof elem && null !== elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators[" + _index15 + "]",
+            expected: "IGraphDecorator",
+            value: elem
+        }, _errorFactory)) && _ao2(elem, _path + ".decorators[" + _index15 + "]", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators[" + _index15 + "]",
+            expected: "IGraphDecorator",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators",
+            expected: "(Array<IGraphDecorator> | undefined)",
+            value: input.decorators
+        }, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && (undefined === input.implementation || ("object" === typeof input.implementation && null !== input.implementation || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".implementation",
+            expected: "(IGraphEvidence | undefined)",
+            value: input.implementation
+        }, _errorFactory)) && _ao3(input.implementation, _path + ".implementation", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".implementation",
+            expected: "(IGraphEvidence | undefined)",
+            value: input.implementation
+        }, _errorFactory));
+        const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && (undefined === input.arguments || (Array.isArray(input.arguments) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments",
+            expected: "(Array<string> | undefined)",
+            value: input.arguments
+        }, _errorFactory)) && input.arguments.every((elem, _index16) => "string" === typeof elem || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments[" + _index16 + "]",
+            expected: "string",
+            value: elem
+        }, _errorFactory)) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments",
+            expected: "(Array<string> | undefined)",
+            value: input.arguments
+        }, _errorFactory)) && _ap2(input, _path, true && _exceptionable);
+        const _ao3 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ("number" === typeof input.startLine || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".startLine",
+            expected: "number",
+            value: input.startLine
+        }, _errorFactory)) && (undefined === input.startCol || "number" === typeof input.startCol || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".startCol",
+            expected: "(number | undefined)",
+            value: input.startCol
+        }, _errorFactory)) && (undefined === input.endLine || "number" === typeof input.endLine || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".endLine",
+            expected: "(number | undefined)",
+            value: input.endLine
+        }, _errorFactory)) && (undefined === input.endCol || "number" === typeof input.endCol || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".endCol",
+            expected: "(number | undefined)",
+            value: input.endCol
+        }, _errorFactory)) && (undefined === input.text || "string" === typeof input.text || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".text",
+            expected: "(string | undefined)",
+            value: input.text
+        }, _errorFactory));
+        const _ao4 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".from",
+            expected: "string",
+            value: input.from
+        }, _errorFactory)) && ("string" === typeof input.to || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".to",
+            expected: "string",
+            value: input.to
+        }, _errorFactory)) && (true === _av2.has(input.kind) || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".kind",
+            expected: _ae2,
+            value: input.kind
+        }, _errorFactory)) && _ap2(input, _path, true && _exceptionable);
+        const _ao5 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ("string" === typeof input.message || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".message",
+            expected: "string",
+            value: input.message
+        }, _errorFactory)) && ("error" === input.severity || "hint" === input.severity || "information" === input.severity || "warning" === input.severity || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".severity",
+            expected: "(\"error\" | \"hint\" | \"information\" | \"warning\")",
+            value: input.severity
+        }, _errorFactory)) && (undefined === input.source || "string" === typeof input.source || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".source",
+            expected: "(string | undefined)",
+            value: input.source
+        }, _errorFactory)) && (undefined === input.code || "string" === typeof input.code || "number" === typeof input.code || _a._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".code",
+            expected: "(number | string | undefined)",
+            value: input.code
+        }, _errorFactory)) && _ap2(input, _path, true && _exceptionable);
+        const _io0 = input => "string" === typeof input.project && (Array.isArray(input.languages) && input.languages.every(elem => true === _iv0.has(elem))) && "string" === typeof input.generatedAt && ("hybrid" === input.indexer || "lsp" === input.indexer || "static" === input.indexer) && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && (undefined === input.diagnostics || Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io5(elem))) && (undefined === input.warnings || Array.isArray(input.warnings) && input.warnings.every(elem => "string" === typeof elem));
+        const _io1 = input => "string" === typeof input.id && true === _iv1.has(input.kind) && true === _iv0.has(input.language) && _ip0(input) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName) && _ip1(input) && "boolean" === typeof input.external && (undefined === input.ignored || "boolean" === typeof input.ignored) && (undefined === input.exported || "boolean" === typeof input.exported) && (undefined === input.signature || "string" === typeof input.signature) && (undefined === input.modifiers || Array.isArray(input.modifiers) && input.modifiers.every(elem => "string" === typeof elem)) && (undefined === input.decorators || Array.isArray(input.decorators) && input.decorators.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && _ip2(input) && (undefined === input.implementation || "object" === typeof input.implementation && null !== input.implementation && _io3(input.implementation));
+        const _io2 = input => _ip0(input) && (undefined === input.arguments || Array.isArray(input.arguments) && input.arguments.every(elem => "string" === typeof elem)) && _ip2(input);
+        const _io3 = input => _ip1(input) && "number" === typeof input.startLine && (undefined === input.startCol || "number" === typeof input.startCol) && (undefined === input.endLine || "number" === typeof input.endLine) && (undefined === input.endCol || "number" === typeof input.endCol) && (undefined === input.text || "string" === typeof input.text);
+        const _io4 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip2(input);
+        const _io5 = input => _ip1(input) && "string" === typeof input.message && ("error" === input.severity || "hint" === input.severity || "information" === input.severity || "warning" === input.severity) && (undefined === input.source || "string" === typeof input.source) && (undefined === input.code || "string" === typeof input.code || "number" === typeof input.code) && _ip2(input);
+        const __is = input => "object" === typeof input && null !== input && _io0(input);
+        let _errorFactory;
+        return (input, errorFactory) => {
+            if (false === __is(input)) {
+                _errorFactory = errorFactory;
+                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
+                    method: "typia.assert",
+                    path: _path + "",
+                    expected: "IGraphDump",
+                    value: input
+                }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
+                    method: "typia.assert",
+                    path: _path + "",
+                    expected: "IGraphDump",
+                    value: input
+                }, _errorFactory))(input, "$input", true);
+            }
+            return input;
+        };
+    })()(dump);
+}
+//# sourceMappingURL=buildGraphDump.js.map

package/lib/indexer/buildGraphDump.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildGraphDump.js","sourceRoot":"","sources":["../../src/indexer/buildGraphDump.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0DAA6B;AAE7B,kDAA0B;AAI1B,6CAA6C;AAC7C,mDAAmD;AAE5C,KAAK,yBACV,OAAO,GAAuB,EAAE;IAEhC,MAAM,UAAU,GAAuB;QACrC,GAAG,OAAO;QACV,GAAG,EAAE,mBAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;QAC/C,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,MAAM;KAC7B,CAAC;IACF,IAAI,UAAU,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QACjC,OAAO,YAAY,CAAC,IAAA,gCAAgB,EAAC,UAAU,CAAC,CAAC,CAAC;IACpD,CAAC;IACD,IAAI,UAAU,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;QAC9B,OAAO,YAAY,CAAC,CAAC,MAAM,IAAA,0BAAa,EAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC9D,CAAC;IACD,OAAO,YAAY,CAAC,CAAC,MAAM,IAAA,0BAAa,EAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC9D,CAAC;AAED,SAAS,YAAY,CAAC,IAAgB;IACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAgC,IAAI,EAAE;AACxC,CAAC"}

package/lib/indexer/buildLspGraph.d.ts

@@ -0,0 +1,3 @@
+import { IBuildGraphOptions } from "./IBuildGraphOptions";
+import { IIndexerResult } from "./IIndexerResult";
+export declare function buildLspGraph(options?: IBuildGraphOptions): Promise<IIndexerResult>;