@ttsc/graph 0.19.2 → 0.20.0

package/lib/model/loadGraph.js

@@ -36,6 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DUMP_SCHEMA_VERSION = void 0;
 exports.loadGraph = loadGraph;
 const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
 const node_child_process_1 = require("node:child_process");
@@ -54,8 +55,13 @@ const MAX_DUMP_BYTES = 1024 * 1024 * 1024;
  * `packages/ttsc/internal/graph/provenance.go`. The two are hand-synchronized,
  * and `dump_schema_version_matches_the_typescript_client_test.go` reads this
  * constant out of this file and fails if the pair drifts.
+ *
+ * Exported because the resident session reads the same dump body over the serve
+ * protocol and has to hold it to the same number: the envelope's version and
+ * the body's are independent, so a producer can speak this protocol and still
+ * send a body from another schema.
  */
-const DUMP_SCHEMA_VERSION = 1;
+exports.DUMP_SCHEMA_VERSION = 6;
 /**
  * Build the resident {@link TtscGraphMemory} for a project by running `ttscgraph
  * dump` once and loading its JSON. This is the one-shot path for direct callers
@@ -114,17 +120,31 @@ function parseDump(json) {
         return input => "object" === typeof input && null !== input && _io0(input);
     })()(value) ? value.provenance.schemaVersion
         : undefined;
-    if (version !== DUMP_SCHEMA_VERSION) {
-        throw new Error(`@ttsc/graph: ttscgraph dump is schema ${version === undefined ? "unknown" : `v${String(version)}`}, this client reads v${String(DUMP_SCHEMA_VERSION)}. ` +
+    if (version !== exports.DUMP_SCHEMA_VERSION) {
+        throw new Error(`@ttsc/graph: ttscgraph dump is schema ${version === undefined ? "unknown" : `v${String(version)}`}, this client reads v${String(exports.DUMP_SCHEMA_VERSION)}. ` +
             "Install a matching `ttsc` (the binary resolves from the target " +
             "project, or from TTSC_GRAPH_BINARY).");
     }
     return (() => {
         const _ip0 = input => "string" === typeof input["file"];
+        const _ip1 = input => "string" === typeof input["id"];
+        const _ip2 = input => true === _iv0.has(input["kind"]);
         const _iv0 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
-        const _ip1 = input => "string" === typeof input["name"];
+        const _ip3 = input => "string" === typeof input["name"];
+        const _ip4 = input => undefined === input["qualifiedName"] || "string" === typeof input["qualifiedName"];
+        const _ip5 = input => "boolean" === typeof input["external"];
+        const _ip6 = input => undefined === input["ignored"] || "boolean" === typeof input["ignored"];
+        const _ip7 = input => undefined === input["exported"] || "boolean" === typeof input["exported"];
+        const _ip8 = input => undefined === input["closure"] || "boolean" === typeof input["closure"];
+        const _ip9 = input => undefined === input["modifiers"] || Array.isArray(input["modifiers"]) && input["modifiers"].every(elem => true === _iv1.has(elem));
         const _iv1 = new Set(["abstract", "async", "const", "declare", "default", "export", "optional", "private", "protected", "public", "readonly", "static"]);
-        const _ip2 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io11(input["evidence"]);
+        const _ip10 = input => undefined === input["literals"] || Array.isArray(input["literals"]) && input["literals"].every(elem => "string" === typeof elem);
+        const _ip11 = input => undefined === input["enumMembers"] || Array.isArray(input["enumMembers"]) && input["enumMembers"].every(elem => "object" === typeof elem && null !== elem && _io9(elem));
+        const _ip12 = input => undefined === input["objectMembers"] || Array.isArray(input["objectMembers"]) && input["objectMembers"].every(elem => "object" === typeof elem && null !== elem && _io10(elem));
+        const _ip13 = input => undefined === input["decorators"] || Array.isArray(input["decorators"]) && input["decorators"].every(elem => "object" === typeof elem && null !== elem && _io11(elem));
+        const _ip14 = input => undefined === input["signature"] || "string" === typeof input["signature"];
+        const _ip15 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io13(input["evidence"]);
+        const _ip16 = input => undefined === input["implementation"] || "object" === typeof input["implementation"] && null !== input["implementation"] && _io13(input["implementation"]);
         const _iv2 = new Set(["accesses", "calls", "contains", "decorates", "dispatches", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
         const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["file"] || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
@@ -132,27 +152,181 @@ function parseDump(json) {
             expected: "string",
             value: input["file"]
         }, _errorFactory);
+        const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["id"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".id",
+            expected: "string",
+            value: input["id"]
+        }, _errorFactory);
+        const _ap2 = (input, _path, _exceptionable = true) => true === _av0.has(input["kind"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".kind",
+            expected: _ae0,
+            value: input["kind"]
+        }, _errorFactory);
         const _av0 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
         const _ae0 = "(\"class\" | \"enum\" | \"external_symbol\" | \"file\" | \"function\" | \"interface\" | \"method\" | \"module\" | \"namespace\" | \"package\" | \"parameter\" | \"property\" | \"type\" | \"variable\")";
-        const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ap3 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".name",
             expected: "string",
             value: input["name"]
         }, _errorFactory);
+        const _ap4 = (input, _path, _exceptionable = true) => undefined === input["qualifiedName"] || "string" === typeof input["qualifiedName"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".qualifiedName",
+            expected: "(string | undefined)",
+            value: input["qualifiedName"]
+        }, _errorFactory);
+        const _ap5 = (input, _path, _exceptionable = true) => "boolean" === typeof input["external"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".external",
+            expected: "boolean",
+            value: input["external"]
+        }, _errorFactory);
+        const _ap6 = (input, _path, _exceptionable = true) => undefined === input["ignored"] || "boolean" === typeof input["ignored"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".ignored",
+            expected: "(boolean | undefined)",
+            value: input["ignored"]
+        }, _errorFactory);
+        const _ap7 = (input, _path, _exceptionable = true) => undefined === input["exported"] || "boolean" === typeof input["exported"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".exported",
+            expected: "(boolean | undefined)",
+            value: input["exported"]
+        }, _errorFactory);
+        const _ap8 = (input, _path, _exceptionable = true) => undefined === input["closure"] || "boolean" === typeof input["closure"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".closure",
+            expected: "(boolean | undefined)",
+            value: input["closure"]
+        }, _errorFactory);
+        const _ap9 = (input, _path, _exceptionable = true) => undefined === input["modifiers"] || (Array.isArray(input["modifiers"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".modifiers",
+            expected: "(Array<TtscGraphNodeModifier> | undefined)",
+            value: input["modifiers"]
+        }, _errorFactory)) && input["modifiers"].every((elem, _index21) => true === _av1.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".modifiers[" + _index21 + "]",
+            expected: _ae1,
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".modifiers",
+            expected: "(Array<TtscGraphNodeModifier> | undefined)",
+            value: input["modifiers"]
+        }, _errorFactory);
         const _av1 = new Set(["abstract", "async", "const", "declare", "default", "export", "optional", "private", "protected", "public", "readonly", "static"]);
         const _ae1 = "(\"abstract\" | \"async\" | \"const\" | \"declare\" | \"default\" | \"export\" | \"optional\" | \"private\" | \"protected\" | \"public\" | \"readonly\" | \"static\")";
-        const _ap2 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ap10 = (input, _path, _exceptionable = true) => undefined === input["literals"] || (Array.isArray(input["literals"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".literals",
+            expected: "(Array<string> | undefined)",
+            value: input["literals"]
+        }, _errorFactory)) && input["literals"].every((elem, _index22) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".literals[" + _index22 + "]",
+            expected: "string",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".literals",
+            expected: "(Array<string> | undefined)",
+            value: input["literals"]
+        }, _errorFactory);
+        const _ap11 = (input, _path, _exceptionable = true) => undefined === input["enumMembers"] || (Array.isArray(input["enumMembers"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".enumMembers",
+            expected: "(Array<ITtscGraphNode.IEnumMember> | undefined)",
+            value: input["enumMembers"]
+        }, _errorFactory)) && input["enumMembers"].every((elem, _index23) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".enumMembers[" + _index23 + "]",
+            expected: "ITtscGraphNode.IEnumMember",
+            value: elem
+        }, _errorFactory)) && _ao9(elem, _path + ".enumMembers[" + _index23 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".enumMembers[" + _index23 + "]",
+            expected: "ITtscGraphNode.IEnumMember",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".enumMembers",
+            expected: "(Array<ITtscGraphNode.IEnumMember> | undefined)",
+            value: input["enumMembers"]
+        }, _errorFactory);
+        const _ap12 = (input, _path, _exceptionable = true) => undefined === input["objectMembers"] || (Array.isArray(input["objectMembers"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".objectMembers",
+            expected: "(Array<ITtscGraphNode.IObjectMember> | undefined)",
+            value: input["objectMembers"]
+        }, _errorFactory)) && input["objectMembers"].every((elem, _index24) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".objectMembers[" + _index24 + "]",
+            expected: "ITtscGraphNode.IObjectMember",
+            value: elem
+        }, _errorFactory)) && _ao10(elem, _path + ".objectMembers[" + _index24 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".objectMembers[" + _index24 + "]",
+            expected: "ITtscGraphNode.IObjectMember",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".objectMembers",
+            expected: "(Array<ITtscGraphNode.IObjectMember> | undefined)",
+            value: input["objectMembers"]
+        }, _errorFactory);
+        const _ap13 = (input, _path, _exceptionable = true) => undefined === input["decorators"] || (Array.isArray(input["decorators"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators",
+            expected: "(Array<ITtscGraphDecorator> | undefined)",
+            value: input["decorators"]
+        }, _errorFactory)) && input["decorators"].every((elem, _index25) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators[" + _index25 + "]",
+            expected: "ITtscGraphDecorator",
+            value: elem
+        }, _errorFactory)) && _ao11(elem, _path + ".decorators[" + _index25 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators[" + _index25 + "]",
+            expected: "ITtscGraphDecorator",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".decorators",
+            expected: "(Array<ITtscGraphDecorator> | undefined)",
+            value: input["decorators"]
+        }, _errorFactory);
+        const _ap14 = (input, _path, _exceptionable = true) => undefined === input["signature"] || "string" === typeof input["signature"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".signature",
+            expected: "(string | undefined)",
+            value: input["signature"]
+        }, _errorFactory);
+        const _ap15 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".evidence",
             expected: "(ITtscGraphSpan | undefined)",
             value: input["evidence"]
-        }, _errorFactory)) && _ao11(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao13(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".evidence",
             expected: "(ITtscGraphSpan | undefined)",
             value: input["evidence"]
         }, _errorFactory);
+        const _ap16 = (input, _path, _exceptionable = true) => undefined === input["implementation"] || ("object" === typeof input["implementation"] && null !== input["implementation"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".implementation",
+            expected: "(ITtscGraphSpan | undefined)",
+            value: input["implementation"]
+        }, _errorFactory)) && _ao13(input["implementation"], _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".implementation",
+            expected: "(ITtscGraphSpan | undefined)",
+            value: input["implementation"]
+        }, _errorFactory);
         const _av2 = new Set(["accesses", "calls", "contains", "decorates", "dispatches", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
         const _ae2 = "(\"accesses\" | \"calls\" | \"contains\" | \"decorates\" | \"dispatches\" | \"exports\" | \"extends\" | \"implements\" | \"imports\" | \"instantiates\" | \"overrides\" | \"renders\" | \"tests\" | \"type_ref\")";
         const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.project || _assertGuard_1._assertGuard(_exceptionable, {
@@ -180,14 +354,14 @@ function parseDump(json) {
             path: _path + ".diagnostics",
             expected: "Array<ITtscGraphDump.IDiagnostic>",
             value: input.diagnostics
-        }, _errorFactory)) && input.diagnostics.every((elem, _index11) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.diagnostics.every((elem, _index14) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".diagnostics[" + _index11 + "]",
+            path: _path + ".diagnostics[" + _index14 + "]",
             expected: "ITtscGraphDump.IDiagnostic",
             value: elem
-        }, _errorFactory)) && _ao7(elem, _path + ".diagnostics[" + _index11 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao7(elem, _path + ".diagnostics[" + _index14 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".diagnostics[" + _index11 + "]",
+            path: _path + ".diagnostics[" + _index14 + "]",
             expected: "ITtscGraphDump.IDiagnostic",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -200,14 +374,14 @@ function parseDump(json) {
             path: _path + ".nodes",
             expected: "Array<ITtscGraphDump.INode>",
             value: input.nodes
-        }, _errorFactory)) && input.nodes.every((elem, _index12) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.nodes.every((elem, _index15) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".nodes[" + _index12 + "]",
+            path: _path + ".nodes[" + _index15 + "]",
             expected: "ITtscGraphDump.INode",
             value: elem
-        }, _errorFactory)) && _ao8(elem, _path + ".nodes[" + _index12 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao8(elem, _path + ".nodes[" + _index15 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".nodes[" + _index12 + "]",
+            path: _path + ".nodes[" + _index15 + "]",
             expected: "ITtscGraphDump.INode",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -220,14 +394,14 @@ function parseDump(json) {
             path: _path + ".edges",
             expected: "Array<ITtscGraphDump.IEdge>",
             value: input.edges
-        }, _errorFactory)) && input.edges.every((elem, _index13) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.edges.every((elem, _index16) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".edges[" + _index13 + "]",
+            path: _path + ".edges[" + _index16 + "]",
             expected: "ITtscGraphDump.IEdge",
             value: elem
-        }, _errorFactory)) && _ao12(elem, _path + ".edges[" + _index13 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao14(elem, _path + ".edges[" + _index16 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".edges[" + _index13 + "]",
+            path: _path + ".edges[" + _index16 + "]",
             expected: "ITtscGraphDump.IEdge",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -246,9 +420,9 @@ function parseDump(json) {
             path: _path + ".capabilities",
             expected: "Array<string>",
             value: input.capabilities
-        }, _errorFactory)) && input.capabilities.every((elem, _index14) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.capabilities.every((elem, _index17) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".capabilities[" + _index14 + "]",
+            path: _path + ".capabilities[" + _index17 + "]",
             expected: "string",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -281,14 +455,14 @@ function parseDump(json) {
             path: _path + ".sources",
             expected: "Array<ITtscGraphDump.ISourceDigest>",
             value: input.sources
-        }, _errorFactory)) && input.sources.every((elem, _index15) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.sources.every((elem, _index18) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".sources[" + _index15 + "]",
+            path: _path + ".sources[" + _index18 + "]",
             expected: "ITtscGraphDump.ISourceDigest",
             value: elem
-        }, _errorFactory)) && _ao6(elem, _path + ".sources[" + _index15 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao6(elem, _path + ".sources[" + _index18 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".sources[" + _index15 + "]",
+            path: _path + ".sources[" + _index18 + "]",
             expected: "ITtscGraphDump.ISourceDigest",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -297,13 +471,45 @@ function parseDump(json) {
             expected: "Array<ITtscGraphDump.ISourceDigest>",
             value: input.sources
         }, _errorFactory));
-        const _ao10 = (input, _path, _exceptionable = true) => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ao10 = (input, _path, _exceptionable = true) => _ap3(input, _path, true && _exceptionable) && ("method" === input.kind || "property" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".kind",
+            expected: "(\"method\" | \"property\")",
+            value: input.kind
+        }, _errorFactory)) && (undefined === input.line || "number" === typeof input.line || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".line",
+            expected: "(number | undefined)",
+            value: input.line
+        }, _errorFactory)) && _ap14(input, _path, true && _exceptionable);
+        const _ao11 = (input, _path, _exceptionable = true) => _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.arguments) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments",
+            expected: "Array<ITtscGraphDecorator.IArgument>",
+            value: input.arguments
+        }, _errorFactory)) && input.arguments.every((elem, _index26) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments[" + _index26 + "]",
+            expected: "ITtscGraphDecorator.IArgument",
+            value: elem
+        }, _errorFactory)) && _ao12(elem, _path + ".arguments[" + _index26 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments[" + _index26 + "]",
+            expected: "ITtscGraphDecorator.IArgument",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".arguments",
+            expected: "Array<ITtscGraphDecorator.IArgument>",
+            value: input.arguments
+        }, _errorFactory));
+        const _ao12 = (input, _path, _exceptionable = true) => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".literal",
             expected: "(boolean | number | string | undefined)",
             value: input.literal
         }, _errorFactory);
-        const _ao11 = (input, _path, _exceptionable = true) => (undefined === input.file || "string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ao13 = (input, _path, _exceptionable = true) => (undefined === input.file || "string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".file",
             expected: "(string | undefined)",
@@ -329,7 +535,7 @@ function parseDump(json) {
             expected: "(number | undefined)",
             value: input.endCol
         }, _errorFactory));
-        const _ao12 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ao14 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".from",
             expected: "string",
@@ -344,7 +550,7 @@ function parseDump(json) {
             path: _path + ".kind",
             expected: _ae2,
             value: input.kind
-        }, _errorFactory)) && _ap2(input, _path, true && _exceptionable);
+        }, _errorFactory)) && _ap15(input, _path, true && _exceptionable);
         const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.tool || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
             path: _path + ".tool",
@@ -366,14 +572,14 @@ function parseDump(json) {
             path: _path + ".configs",
             expected: "Array<ITtscGraphDump.IFileDigest>",
             value: input.configs
-        }, _errorFactory)) && input.configs.every((elem, _index16) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.configs.every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".configs[" + _index16 + "]",
+            path: _path + ".configs[" + _index19 + "]",
             expected: "ITtscGraphDump.IFileDigest",
             value: elem
-        }, _errorFactory)) && _ao4(elem, _path + ".configs[" + _index16 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao4(elem, _path + ".configs[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".configs[" + _index16 + "]",
+            path: _path + ".configs[" + _index19 + "]",
             expected: "ITtscGraphDump.IFileDigest",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -386,14 +592,14 @@ function parseDump(json) {
             path: _path + ".roots",
             expected: "Array<ITtscGraphDump.IRootFile>",
             value: input.roots
-        }, _errorFactory)) && input.roots.every((elem, _index17) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && input.roots.every((elem, _index20) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".roots[" + _index17 + "]",
+            path: _path + ".roots[" + _index20 + "]",
             expected: "ITtscGraphDump.IRootFile",
             value: elem
-        }, _errorFactory)) && _ao5(elem, _path + ".roots[" + _index17 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        }, _errorFactory)) && _ao5(elem, _path + ".roots[" + _index20 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".roots[" + _index17 + "]",
+            path: _path + ".roots[" + _index20 + "]",
             expected: "ITtscGraphDump.IRootFile",
             value: elem
         }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
@@ -451,121 +657,28 @@ function parseDump(json) {
             expected: "string",
             value: input.message
         }, _errorFactory));
-        const _ao8 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
+        const _ao8 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable) && _ap12(input, _path, true && _exceptionable) && _ap13(input, _path, true && _exceptionable) && _ap14(input, _path, true && _exceptionable) && _ap15(input, _path, true && _exceptionable) && _ap16(input, _path, true && _exceptionable);
+        const _ao9 = (input, _path, _exceptionable = true) => _ap3(input, _path, true && _exceptionable) && (undefined === input.value || "string" === typeof input.value || _assertGuard_1._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + ".id",
-            expected: "string",
-            value: input.id
-        }, _errorFactory)) && (true === _av0.has(input.kind) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".kind",
-            expected: _ae0,
-            value: input.kind
-        }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".qualifiedName",
+            path: _path + ".value",
             expected: "(string | undefined)",
-            value: input.qualifiedName
-        }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && ("boolean" === typeof input.external || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".external",
-            expected: "boolean",
-            value: input.external
-        }, _errorFactory)) && (undefined === input.ignored || "boolean" === typeof input.ignored || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".ignored",
-            expected: "(boolean | undefined)",
-            value: input.ignored
-        }, _errorFactory)) && (undefined === input.exported || "boolean" === typeof input.exported || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".exported",
-            expected: "(boolean | undefined)",
-            value: input.exported
-        }, _errorFactory)) && (undefined === input.closure || "boolean" === typeof input.closure || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".closure",
-            expected: "(boolean | undefined)",
-            value: input.closure
-        }, _errorFactory)) && (undefined === input.modifiers || (Array.isArray(input.modifiers) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".modifiers",
-            expected: "(Array<TtscGraphNodeModifier> | undefined)",
-            value: input.modifiers
-        }, _errorFactory)) && input.modifiers.every((elem, _index18) => true === _av1.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".modifiers[" + _index18 + "]",
-            expected: _ae1,
-            value: elem
-        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".modifiers",
-            expected: "(Array<TtscGraphNodeModifier> | undefined)",
-            value: input.modifiers
-        }, _errorFactory)) && (undefined === input.decorators || (Array.isArray(input.decorators) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".decorators",
-            expected: "(Array<ITtscGraphDecorator> | undefined)",
-            value: input.decorators
-        }, _errorFactory)) && input.decorators.every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".decorators[" + _index19 + "]",
-            expected: "ITtscGraphDecorator",
-            value: elem
-        }, _errorFactory)) && _ao9(elem, _path + ".decorators[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".decorators[" + _index19 + "]",
-            expected: "ITtscGraphDecorator",
-            value: elem
-        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".decorators",
-            expected: "(Array<ITtscGraphDecorator> | undefined)",
-            value: input.decorators
-        }, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && (undefined === input.implementation || ("object" === typeof input.implementation && null !== input.implementation || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".implementation",
-            expected: "(ITtscGraphSpan | undefined)",
-            value: input.implementation
-        }, _errorFactory)) && _ao11(input.implementation, _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".implementation",
-            expected: "(ITtscGraphSpan | undefined)",
-            value: input.implementation
-        }, _errorFactory));
-        const _ao9 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ((Array.isArray(input.arguments) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".arguments",
-            expected: "Array<ITtscGraphDecorator.IArgument>",
-            value: input.arguments
-        }, _errorFactory)) && input.arguments.every((elem, _index20) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".arguments[" + _index20 + "]",
-            expected: "ITtscGraphDecorator.IArgument",
-            value: elem
-        }, _errorFactory)) && _ao10(elem, _path + ".arguments[" + _index20 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".arguments[" + _index20 + "]",
-            expected: "ITtscGraphDecorator.IArgument",
-            value: elem
-        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-            method: "typia.assert",
-            path: _path + ".arguments",
-            expected: "Array<ITtscGraphDecorator.IArgument>",
-            value: input.arguments
+            value: input.value
         }, _errorFactory));
-        const _io0 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && ("object" === typeof input.provenance && null !== input.provenance && _io1(input.provenance)) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io12(elem)));
+        const _io0 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && ("object" === typeof input.provenance && null !== input.provenance && _io1(input.provenance)) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io7(elem))) && (Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _io8(elem))) && (Array.isArray(input.edges) && input.edges.every(elem => "object" === typeof elem && null !== elem && _io14(elem)));
         const _io1 = input => "number" === typeof input.schemaVersion && (Array.isArray(input.capabilities) && input.capabilities.every(elem => "string" === typeof elem)) && ("object" === typeof input.producer && null !== input.producer && _io2(input.producer)) && ("object" === typeof input.universe && null !== input.universe && _io3(input.universe)) && (Array.isArray(input.sources) && input.sources.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
-        const _io10 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
-        const _io11 = input => (undefined === input.file || "string" === typeof input.file) && "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);
-        const _io12 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip2(input);
+        const _io10 = input => _ip3(input) && ("method" === input.kind || "property" === input.kind) && (undefined === input.line || "number" === typeof input.line) && _ip14(input);
+        const _io11 = input => _ip3(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io12(elem)));
+        const _io12 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
+        const _io13 = input => (undefined === input.file || "string" === typeof input.file) && "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);
+        const _io14 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip15(input);
         const _io2 = input => "string" === typeof input.tool && "string" === typeof input.version && "string" === typeof input.typescript;
         const _io3 = input => Array.isArray(input.configs) && input.configs.every(elem => "object" === typeof elem && null !== elem && _io4(elem)) && (Array.isArray(input.roots) && input.roots.every(elem => "object" === typeof elem && null !== elem && _io5(elem)));
         const _io4 = input => _ip0(input) && "string" === typeof input.digest;
         const _io5 = input => "string" === typeof input.config && _ip0(input);
         const _io6 = input => _ip0(input) && "string" === typeof input.checkerDigest && "string" === typeof input.diskDigest;
         const _io7 = input => _ip0(input) && "number" === typeof input.line && "number" === typeof input.column && "number" === typeof input.code && ("error" === input.category || "warning" === input.category) && "string" === typeof input.message;
-        const _io8 = input => "string" === typeof input.id && true === _iv0.has(input.kind) && _ip1(input) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName) && _ip0(input) && "boolean" === typeof input.external && (undefined === input.ignored || "boolean" === typeof input.ignored) && (undefined === input.exported || "boolean" === typeof input.exported) && (undefined === input.closure || "boolean" === typeof input.closure) && (undefined === input.modifiers || Array.isArray(input.modifiers) && input.modifiers.every(elem => true === _iv1.has(elem))) && (undefined === input.decorators || Array.isArray(input.decorators) && input.decorators.every(elem => "object" === typeof elem && null !== elem && _io9(elem))) && _ip2(input) && (undefined === input.implementation || "object" === typeof input.implementation && null !== input.implementation && _io11(input.implementation));
-        const _io9 = input => _ip1(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io10(elem)));
+        const _io8 = input => _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip0(input) && _ip5(input) && _ip6(input) && _ip7(input) && _ip8(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip13(input) && _ip14(input) && _ip15(input) && _ip16(input);
+        const _io9 = input => _ip3(input) && (undefined === input.value || "string" === typeof input.value);
         const __is = input => "object" === typeof input && null !== input && _io0(input);
         let _errorFactory;
         return (input, errorFactory) => {

package/lib/model/loadGraph.js.map

@@ -1 +1 @@
-{"version":3,"file":"loadGraph.js","sourceRoot":"","sources":["../../src/model/loadGraph.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"loadGraph.js","sourceRoot":"","sources":["../../src/model/loadGraph.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2DAA+C;AAC/C,kDAA0B;AAE1B,0DAAuD;AACvD,8DAA2D;AAE3D,uDAAoD;AAEpD,4EAA4E;AAC5E,+EAA+E;AAC/E,uDAAuD;AACvD,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACU,QAAA,mBAAmB,GAAG,CAAC,CAAC;AAErC;;;;;;;;;GASG;AACH,mBACE,OAAO,GAWH,EAAE;IAEN,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAAC;IACrD,8EAA8E;IAC9E,oEAAoE;IACpE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,IAAA,uCAAkB,EAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACtE,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CACb,uDAAuD;YACrD,qDAAqD;YACrD,+CAA+C,CAClD,CAAC;IACJ,CAAC;IACD,IAAA,mCAAgB,EAAC,MAAM,CAAC,CAAC;IAEzB,MAAM,MAAM,GAAG,IAAA,8BAAS,EACtB,MAAM,EACN,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,QAAQ,CAAC,EAC9C,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,WAAW,EAAE,IAAI,EAAE,CACnE,CAAC;IACF,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,uCAAuC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAC9D,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACb,2CAA2C,MAAM,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAC5F,CAAC;IACJ,CAAC;IAED,OAAO,iCAAe,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,SAAS,CAAC,IAAY;IAC7B,IAAI,KAAc,CAAC;IACnB,IAAI,CAAC;QACH,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,+CACE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAuB;;;;SAEjC,KAAK,EACN,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,aAAa;QAChC,CAAC,CAAC,SAAS,CAAC;IACd,IAAI,OAAO,KAAK,QAAA,mBAAmB,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CACb,yCACE,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,EACzD,wBAAwB,MAAM,CAAC,QAAA,mBAAmB,CAAC,IAAI;YACrD,iEAAiE;YACjE,sCAAsC,CACzC,CAAC;IACJ,CAAC;IACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAAoC,KAAK,EAAE;AAC7C,CAAC"}