@ttsc/graph 0.19.0 → 0.19.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/model/TtscGraphSession.js +449 -162
- package/lib/model/TtscGraphSession.js.map +1 -1
- package/lib/model/loadGraph.js +321 -88
- package/lib/model/loadGraph.js.map +1 -1
- package/lib/structures/ITtscGraphDump.d.ts +169 -6
- package/lib/structures/ITtscGraphSnapshot.d.ts +55 -0
- package/lib/structures/ITtscGraphSnapshot.js +3 -0
- package/lib/structures/ITtscGraphSnapshot.js.map +1 -0
- package/lib/structures/index.d.ts +1 -0
- package/lib/structures/index.js +1 -0
- package/lib/structures/index.js.map +1 -1
- package/package.json +2 -2
- package/src/model/TtscGraphSession.ts +62 -16
- package/src/model/loadGraph.ts +31 -0
- package/src/structures/ITtscGraphDump.ts +194 -6
- package/src/structures/ITtscGraphSnapshot.ts +69 -0
- package/src/structures/index.ts +1 -0
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"TtscGraphSession.js","sourceRoot":"","sources":["../../src/model/TtscGraphSession.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2DAA2E;AAC3E,kEAAqC;AACrC,kDAA0B;AAE1B,0DAAuD;AACvD,8DAA2D;AAE3D,uDAAoD;
|
|
1
|
+
{"version":3,"file":"TtscGraphSession.js","sourceRoot":"","sources":["../../src/model/TtscGraphSession.ts"],"names":[],"mappings":"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"}
|
package/lib/model/loadGraph.js
CHANGED
|
@@ -47,6 +47,15 @@ const TtscGraphMemory_1 = require("./TtscGraphMemory");
|
|
|
47
47
|
// monorepo runs to many megabytes, well past spawnSync's 1 MiB default, so the
|
|
48
48
|
// buffer is raised to a ceiling no real graph reaches.
|
|
49
49
|
const MAX_DUMP_BYTES = 1024 * 1024 * 1024;
|
|
50
|
+
/**
|
|
51
|
+
* The dump schema version this client reads.
|
|
52
|
+
*
|
|
53
|
+
* Keep it equal to `DumpSchemaVersion` in
|
|
54
|
+
* `packages/ttsc/internal/graph/provenance.go`. The two are hand-synchronized,
|
|
55
|
+
* and `dump_schema_version_matches_the_typescript_client_test.go` reads this
|
|
56
|
+
* constant out of this file and fails if the pair drifts.
|
|
57
|
+
*/
|
|
58
|
+
const DUMP_SCHEMA_VERSION = 1;
|
|
50
59
|
/**
|
|
51
60
|
* Build the resident {@link TtscGraphMemory} for a project by running `ttscgraph
|
|
52
61
|
* dump` once and loading its JSON. This is the one-shot path for direct callers
|
|
@@ -83,6 +92,13 @@ function loadGraph(options = {}) {
|
|
|
83
92
|
* {@link ITtscGraphDump} shape so a malformed or stale dump fails loudly here
|
|
84
93
|
* rather than producing wrong answers downstream, and the schema version is
|
|
85
94
|
* checked so an incompatible producer is refused.
|
|
95
|
+
*
|
|
96
|
+
* The version is read before the shape: a dump from another schema is entitled
|
|
97
|
+
* to another shape, so asserting first would report the mismatch as a field
|
|
98
|
+
* complaint about a contract that producer never agreed to. A dump also
|
|
99
|
+
* outlives the process that wrote it — this is the one-shot path, and the JSON
|
|
100
|
+
* on disk may be from any build — so the version is the first question to ask
|
|
101
|
+
* of it.
|
|
86
102
|
*/
|
|
87
103
|
function parseDump(json) {
|
|
88
104
|
let value;
|
|
@@ -92,15 +108,33 @@ function parseDump(json) {
|
|
|
92
108
|
catch (error) {
|
|
93
109
|
throw new Error(`@ttsc/graph: dump output is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
|
|
94
110
|
}
|
|
111
|
+
const version = (() => {
|
|
112
|
+
const _io0 = input => "object" === typeof input.provenance && null !== input.provenance && _io1(input.provenance);
|
|
113
|
+
const _io1 = input => "number" === typeof input.schemaVersion;
|
|
114
|
+
return input => "object" === typeof input && null !== input && _io0(input);
|
|
115
|
+
})()(value) ? value.provenance.schemaVersion
|
|
116
|
+
: undefined;
|
|
117
|
+
if (version !== DUMP_SCHEMA_VERSION) {
|
|
118
|
+
throw new Error(`@ttsc/graph: ttscgraph dump is schema ${version === undefined ? "unknown" : `v${String(version)}`}, this client reads v${String(DUMP_SCHEMA_VERSION)}. ` +
|
|
119
|
+
"Install a matching `ttsc` (the binary resolves from the target " +
|
|
120
|
+
"project, or from TTSC_GRAPH_BINARY).");
|
|
121
|
+
}
|
|
95
122
|
return (() => {
|
|
123
|
+
const _ip0 = input => "string" === typeof input["file"];
|
|
96
124
|
const _iv0 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
|
|
97
|
-
const
|
|
125
|
+
const _ip1 = input => "string" === typeof input["name"];
|
|
98
126
|
const _iv1 = new Set(["abstract", "async", "const", "declare", "default", "export", "optional", "private", "protected", "public", "readonly", "static"]);
|
|
99
|
-
const
|
|
127
|
+
const _ip2 = input => undefined === input["evidence"] || "object" === typeof input["evidence"] && null !== input["evidence"] && _io11(input["evidence"]);
|
|
100
128
|
const _iv2 = new Set(["accesses", "calls", "contains", "decorates", "dispatches", "exports", "extends", "implements", "imports", "instantiates", "overrides", "renders", "tests", "type_ref"]);
|
|
129
|
+
const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["file"] || _assertGuard_1._assertGuard(_exceptionable, {
|
|
130
|
+
method: "typia.assert",
|
|
131
|
+
path: _path + ".file",
|
|
132
|
+
expected: "string",
|
|
133
|
+
value: input["file"]
|
|
134
|
+
}, _errorFactory);
|
|
101
135
|
const _av0 = new Set(["class", "enum", "external_symbol", "file", "function", "interface", "method", "module", "namespace", "package", "parameter", "property", "type", "variable"]);
|
|
102
136
|
const _ae0 = "(\"class\" | \"enum\" | \"external_symbol\" | \"file\" | \"function\" | \"interface\" | \"method\" | \"module\" | \"namespace\" | \"package\" | \"parameter\" | \"property\" | \"type\" | \"variable\")";
|
|
103
|
-
const
|
|
137
|
+
const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
|
|
104
138
|
method: "typia.assert",
|
|
105
139
|
path: _path + ".name",
|
|
106
140
|
expected: "string",
|
|
@@ -108,12 +142,12 @@ function parseDump(json) {
|
|
|
108
142
|
}, _errorFactory);
|
|
109
143
|
const _av1 = new Set(["abstract", "async", "const", "declare", "default", "export", "optional", "private", "protected", "public", "readonly", "static"]);
|
|
110
144
|
const _ae1 = "(\"abstract\" | \"async\" | \"const\" | \"declare\" | \"default\" | \"export\" | \"optional\" | \"private\" | \"protected\" | \"public\" | \"readonly\" | \"static\")";
|
|
111
|
-
const
|
|
145
|
+
const _ap2 = (input, _path, _exceptionable = true) => undefined === input["evidence"] || ("object" === typeof input["evidence"] && null !== input["evidence"] || _assertGuard_1._assertGuard(_exceptionable, {
|
|
112
146
|
method: "typia.assert",
|
|
113
147
|
path: _path + ".evidence",
|
|
114
148
|
expected: "(ITtscGraphSpan | undefined)",
|
|
115
149
|
value: input["evidence"]
|
|
116
|
-
}, _errorFactory)) &&
|
|
150
|
+
}, _errorFactory)) && _ao11(input["evidence"], _path + ".evidence", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
117
151
|
method: "typia.assert",
|
|
118
152
|
path: _path + ".evidence",
|
|
119
153
|
expected: "(ITtscGraphSpan | undefined)",
|
|
@@ -131,19 +165,49 @@ function parseDump(json) {
|
|
|
131
165
|
path: _path + ".tsconfig",
|
|
132
166
|
expected: "string",
|
|
133
167
|
value: input.tsconfig
|
|
168
|
+
}, _errorFactory)) && (("object" === typeof input.provenance && null !== input.provenance || _assertGuard_1._assertGuard(_exceptionable, {
|
|
169
|
+
method: "typia.assert",
|
|
170
|
+
path: _path + ".provenance",
|
|
171
|
+
expected: "ITtscGraphDump.IProvenance",
|
|
172
|
+
value: input.provenance
|
|
173
|
+
}, _errorFactory)) && _ao1(input.provenance, _path + ".provenance", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
174
|
+
method: "typia.assert",
|
|
175
|
+
path: _path + ".provenance",
|
|
176
|
+
expected: "ITtscGraphDump.IProvenance",
|
|
177
|
+
value: input.provenance
|
|
178
|
+
}, _errorFactory)) && ((Array.isArray(input.diagnostics) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
179
|
+
method: "typia.assert",
|
|
180
|
+
path: _path + ".diagnostics",
|
|
181
|
+
expected: "Array<ITtscGraphDump.IDiagnostic>",
|
|
182
|
+
value: input.diagnostics
|
|
183
|
+
}, _errorFactory)) && input.diagnostics.every((elem, _index11) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
184
|
+
method: "typia.assert",
|
|
185
|
+
path: _path + ".diagnostics[" + _index11 + "]",
|
|
186
|
+
expected: "ITtscGraphDump.IDiagnostic",
|
|
187
|
+
value: elem
|
|
188
|
+
}, _errorFactory)) && _ao7(elem, _path + ".diagnostics[" + _index11 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
189
|
+
method: "typia.assert",
|
|
190
|
+
path: _path + ".diagnostics[" + _index11 + "]",
|
|
191
|
+
expected: "ITtscGraphDump.IDiagnostic",
|
|
192
|
+
value: elem
|
|
193
|
+
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
194
|
+
method: "typia.assert",
|
|
195
|
+
path: _path + ".diagnostics",
|
|
196
|
+
expected: "Array<ITtscGraphDump.IDiagnostic>",
|
|
197
|
+
value: input.diagnostics
|
|
134
198
|
}, _errorFactory)) && ((Array.isArray(input.nodes) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
135
199
|
method: "typia.assert",
|
|
136
200
|
path: _path + ".nodes",
|
|
137
201
|
expected: "Array<ITtscGraphDump.INode>",
|
|
138
202
|
value: input.nodes
|
|
139
|
-
}, _errorFactory)) && input.nodes.every((elem,
|
|
203
|
+
}, _errorFactory)) && input.nodes.every((elem, _index12) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
140
204
|
method: "typia.assert",
|
|
141
|
-
path: _path + ".nodes[" +
|
|
205
|
+
path: _path + ".nodes[" + _index12 + "]",
|
|
142
206
|
expected: "ITtscGraphDump.INode",
|
|
143
207
|
value: elem
|
|
144
|
-
}, _errorFactory)) &&
|
|
208
|
+
}, _errorFactory)) && _ao8(elem, _path + ".nodes[" + _index12 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
145
209
|
method: "typia.assert",
|
|
146
|
-
path: _path + ".nodes[" +
|
|
210
|
+
path: _path + ".nodes[" + _index12 + "]",
|
|
147
211
|
expected: "ITtscGraphDump.INode",
|
|
148
212
|
value: elem
|
|
149
213
|
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
@@ -156,14 +220,14 @@ function parseDump(json) {
|
|
|
156
220
|
path: _path + ".edges",
|
|
157
221
|
expected: "Array<ITtscGraphDump.IEdge>",
|
|
158
222
|
value: input.edges
|
|
159
|
-
}, _errorFactory)) && input.edges.every((elem,
|
|
223
|
+
}, _errorFactory)) && input.edges.every((elem, _index13) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
160
224
|
method: "typia.assert",
|
|
161
|
-
path: _path + ".edges[" +
|
|
225
|
+
path: _path + ".edges[" + _index13 + "]",
|
|
162
226
|
expected: "ITtscGraphDump.IEdge",
|
|
163
227
|
value: elem
|
|
164
|
-
}, _errorFactory)) &&
|
|
228
|
+
}, _errorFactory)) && _ao12(elem, _path + ".edges[" + _index13 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
165
229
|
method: "typia.assert",
|
|
166
|
-
path: _path + ".edges[" +
|
|
230
|
+
path: _path + ".edges[" + _index13 + "]",
|
|
167
231
|
expected: "ITtscGraphDump.IEdge",
|
|
168
232
|
value: elem
|
|
169
233
|
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
@@ -172,7 +236,222 @@ function parseDump(json) {
|
|
|
172
236
|
expected: "Array<ITtscGraphDump.IEdge>",
|
|
173
237
|
value: input.edges
|
|
174
238
|
}, _errorFactory));
|
|
175
|
-
const _ao1 = (input, _path, _exceptionable = true) => ("
|
|
239
|
+
const _ao1 = (input, _path, _exceptionable = true) => ("number" === typeof input.schemaVersion || _assertGuard_1._assertGuard(_exceptionable, {
|
|
240
|
+
method: "typia.assert",
|
|
241
|
+
path: _path + ".schemaVersion",
|
|
242
|
+
expected: "number",
|
|
243
|
+
value: input.schemaVersion
|
|
244
|
+
}, _errorFactory)) && ((Array.isArray(input.capabilities) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
245
|
+
method: "typia.assert",
|
|
246
|
+
path: _path + ".capabilities",
|
|
247
|
+
expected: "Array<string>",
|
|
248
|
+
value: input.capabilities
|
|
249
|
+
}, _errorFactory)) && input.capabilities.every((elem, _index14) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
250
|
+
method: "typia.assert",
|
|
251
|
+
path: _path + ".capabilities[" + _index14 + "]",
|
|
252
|
+
expected: "string",
|
|
253
|
+
value: elem
|
|
254
|
+
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
255
|
+
method: "typia.assert",
|
|
256
|
+
path: _path + ".capabilities",
|
|
257
|
+
expected: "Array<string>",
|
|
258
|
+
value: input.capabilities
|
|
259
|
+
}, _errorFactory)) && (("object" === typeof input.producer && null !== input.producer || _assertGuard_1._assertGuard(_exceptionable, {
|
|
260
|
+
method: "typia.assert",
|
|
261
|
+
path: _path + ".producer",
|
|
262
|
+
expected: "ITtscGraphDump.IProducer",
|
|
263
|
+
value: input.producer
|
|
264
|
+
}, _errorFactory)) && _ao2(input.producer, _path + ".producer", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
265
|
+
method: "typia.assert",
|
|
266
|
+
path: _path + ".producer",
|
|
267
|
+
expected: "ITtscGraphDump.IProducer",
|
|
268
|
+
value: input.producer
|
|
269
|
+
}, _errorFactory)) && (("object" === typeof input.universe && null !== input.universe || _assertGuard_1._assertGuard(_exceptionable, {
|
|
270
|
+
method: "typia.assert",
|
|
271
|
+
path: _path + ".universe",
|
|
272
|
+
expected: "ITtscGraphDump.IUniverse",
|
|
273
|
+
value: input.universe
|
|
274
|
+
}, _errorFactory)) && _ao3(input.universe, _path + ".universe", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
275
|
+
method: "typia.assert",
|
|
276
|
+
path: _path + ".universe",
|
|
277
|
+
expected: "ITtscGraphDump.IUniverse",
|
|
278
|
+
value: input.universe
|
|
279
|
+
}, _errorFactory)) && ((Array.isArray(input.sources) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
280
|
+
method: "typia.assert",
|
|
281
|
+
path: _path + ".sources",
|
|
282
|
+
expected: "Array<ITtscGraphDump.ISourceDigest>",
|
|
283
|
+
value: input.sources
|
|
284
|
+
}, _errorFactory)) && input.sources.every((elem, _index15) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
285
|
+
method: "typia.assert",
|
|
286
|
+
path: _path + ".sources[" + _index15 + "]",
|
|
287
|
+
expected: "ITtscGraphDump.ISourceDigest",
|
|
288
|
+
value: elem
|
|
289
|
+
}, _errorFactory)) && _ao6(elem, _path + ".sources[" + _index15 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
290
|
+
method: "typia.assert",
|
|
291
|
+
path: _path + ".sources[" + _index15 + "]",
|
|
292
|
+
expected: "ITtscGraphDump.ISourceDigest",
|
|
293
|
+
value: elem
|
|
294
|
+
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
295
|
+
method: "typia.assert",
|
|
296
|
+
path: _path + ".sources",
|
|
297
|
+
expected: "Array<ITtscGraphDump.ISourceDigest>",
|
|
298
|
+
value: input.sources
|
|
299
|
+
}, _errorFactory));
|
|
300
|
+
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, {
|
|
301
|
+
method: "typia.assert",
|
|
302
|
+
path: _path + ".literal",
|
|
303
|
+
expected: "(boolean | number | string | undefined)",
|
|
304
|
+
value: input.literal
|
|
305
|
+
}, _errorFactory);
|
|
306
|
+
const _ao11 = (input, _path, _exceptionable = true) => (undefined === input.file || "string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
|
|
307
|
+
method: "typia.assert",
|
|
308
|
+
path: _path + ".file",
|
|
309
|
+
expected: "(string | undefined)",
|
|
310
|
+
value: input.file
|
|
311
|
+
}, _errorFactory)) && ("number" === typeof input.startLine || _assertGuard_1._assertGuard(_exceptionable, {
|
|
312
|
+
method: "typia.assert",
|
|
313
|
+
path: _path + ".startLine",
|
|
314
|
+
expected: "number",
|
|
315
|
+
value: input.startLine
|
|
316
|
+
}, _errorFactory)) && (undefined === input.startCol || "number" === typeof input.startCol || _assertGuard_1._assertGuard(_exceptionable, {
|
|
317
|
+
method: "typia.assert",
|
|
318
|
+
path: _path + ".startCol",
|
|
319
|
+
expected: "(number | undefined)",
|
|
320
|
+
value: input.startCol
|
|
321
|
+
}, _errorFactory)) && (undefined === input.endLine || "number" === typeof input.endLine || _assertGuard_1._assertGuard(_exceptionable, {
|
|
322
|
+
method: "typia.assert",
|
|
323
|
+
path: _path + ".endLine",
|
|
324
|
+
expected: "(number | undefined)",
|
|
325
|
+
value: input.endLine
|
|
326
|
+
}, _errorFactory)) && (undefined === input.endCol || "number" === typeof input.endCol || _assertGuard_1._assertGuard(_exceptionable, {
|
|
327
|
+
method: "typia.assert",
|
|
328
|
+
path: _path + ".endCol",
|
|
329
|
+
expected: "(number | undefined)",
|
|
330
|
+
value: input.endCol
|
|
331
|
+
}, _errorFactory));
|
|
332
|
+
const _ao12 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
|
|
333
|
+
method: "typia.assert",
|
|
334
|
+
path: _path + ".from",
|
|
335
|
+
expected: "string",
|
|
336
|
+
value: input.from
|
|
337
|
+
}, _errorFactory)) && ("string" === typeof input.to || _assertGuard_1._assertGuard(_exceptionable, {
|
|
338
|
+
method: "typia.assert",
|
|
339
|
+
path: _path + ".to",
|
|
340
|
+
expected: "string",
|
|
341
|
+
value: input.to
|
|
342
|
+
}, _errorFactory)) && (true === _av2.has(input.kind) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
343
|
+
method: "typia.assert",
|
|
344
|
+
path: _path + ".kind",
|
|
345
|
+
expected: _ae2,
|
|
346
|
+
value: input.kind
|
|
347
|
+
}, _errorFactory)) && _ap2(input, _path, true && _exceptionable);
|
|
348
|
+
const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.tool || _assertGuard_1._assertGuard(_exceptionable, {
|
|
349
|
+
method: "typia.assert",
|
|
350
|
+
path: _path + ".tool",
|
|
351
|
+
expected: "string",
|
|
352
|
+
value: input.tool
|
|
353
|
+
}, _errorFactory)) && ("string" === typeof input.version || _assertGuard_1._assertGuard(_exceptionable, {
|
|
354
|
+
method: "typia.assert",
|
|
355
|
+
path: _path + ".version",
|
|
356
|
+
expected: "string",
|
|
357
|
+
value: input.version
|
|
358
|
+
}, _errorFactory)) && ("string" === typeof input.typescript || _assertGuard_1._assertGuard(_exceptionable, {
|
|
359
|
+
method: "typia.assert",
|
|
360
|
+
path: _path + ".typescript",
|
|
361
|
+
expected: "string",
|
|
362
|
+
value: input.typescript
|
|
363
|
+
}, _errorFactory));
|
|
364
|
+
const _ao3 = (input, _path, _exceptionable = true) => ((Array.isArray(input.configs) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
365
|
+
method: "typia.assert",
|
|
366
|
+
path: _path + ".configs",
|
|
367
|
+
expected: "Array<ITtscGraphDump.IFileDigest>",
|
|
368
|
+
value: input.configs
|
|
369
|
+
}, _errorFactory)) && input.configs.every((elem, _index16) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
370
|
+
method: "typia.assert",
|
|
371
|
+
path: _path + ".configs[" + _index16 + "]",
|
|
372
|
+
expected: "ITtscGraphDump.IFileDigest",
|
|
373
|
+
value: elem
|
|
374
|
+
}, _errorFactory)) && _ao4(elem, _path + ".configs[" + _index16 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
375
|
+
method: "typia.assert",
|
|
376
|
+
path: _path + ".configs[" + _index16 + "]",
|
|
377
|
+
expected: "ITtscGraphDump.IFileDigest",
|
|
378
|
+
value: elem
|
|
379
|
+
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
380
|
+
method: "typia.assert",
|
|
381
|
+
path: _path + ".configs",
|
|
382
|
+
expected: "Array<ITtscGraphDump.IFileDigest>",
|
|
383
|
+
value: input.configs
|
|
384
|
+
}, _errorFactory)) && ((Array.isArray(input.roots) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
385
|
+
method: "typia.assert",
|
|
386
|
+
path: _path + ".roots",
|
|
387
|
+
expected: "Array<ITtscGraphDump.IRootFile>",
|
|
388
|
+
value: input.roots
|
|
389
|
+
}, _errorFactory)) && input.roots.every((elem, _index17) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
390
|
+
method: "typia.assert",
|
|
391
|
+
path: _path + ".roots[" + _index17 + "]",
|
|
392
|
+
expected: "ITtscGraphDump.IRootFile",
|
|
393
|
+
value: elem
|
|
394
|
+
}, _errorFactory)) && _ao5(elem, _path + ".roots[" + _index17 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
395
|
+
method: "typia.assert",
|
|
396
|
+
path: _path + ".roots[" + _index17 + "]",
|
|
397
|
+
expected: "ITtscGraphDump.IRootFile",
|
|
398
|
+
value: elem
|
|
399
|
+
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
400
|
+
method: "typia.assert",
|
|
401
|
+
path: _path + ".roots",
|
|
402
|
+
expected: "Array<ITtscGraphDump.IRootFile>",
|
|
403
|
+
value: input.roots
|
|
404
|
+
}, _errorFactory));
|
|
405
|
+
const _ao4 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.digest || _assertGuard_1._assertGuard(_exceptionable, {
|
|
406
|
+
method: "typia.assert",
|
|
407
|
+
path: _path + ".digest",
|
|
408
|
+
expected: "string",
|
|
409
|
+
value: input.digest
|
|
410
|
+
}, _errorFactory));
|
|
411
|
+
const _ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.config || _assertGuard_1._assertGuard(_exceptionable, {
|
|
412
|
+
method: "typia.assert",
|
|
413
|
+
path: _path + ".config",
|
|
414
|
+
expected: "string",
|
|
415
|
+
value: input.config
|
|
416
|
+
}, _errorFactory)) && _ap0(input, _path, true && _exceptionable);
|
|
417
|
+
const _ao6 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.checkerDigest || _assertGuard_1._assertGuard(_exceptionable, {
|
|
418
|
+
method: "typia.assert",
|
|
419
|
+
path: _path + ".checkerDigest",
|
|
420
|
+
expected: "string",
|
|
421
|
+
value: input.checkerDigest
|
|
422
|
+
}, _errorFactory)) && ("string" === typeof input.diskDigest || _assertGuard_1._assertGuard(_exceptionable, {
|
|
423
|
+
method: "typia.assert",
|
|
424
|
+
path: _path + ".diskDigest",
|
|
425
|
+
expected: "string",
|
|
426
|
+
value: input.diskDigest
|
|
427
|
+
}, _errorFactory));
|
|
428
|
+
const _ao7 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("number" === typeof input.line || _assertGuard_1._assertGuard(_exceptionable, {
|
|
429
|
+
method: "typia.assert",
|
|
430
|
+
path: _path + ".line",
|
|
431
|
+
expected: "number",
|
|
432
|
+
value: input.line
|
|
433
|
+
}, _errorFactory)) && ("number" === typeof input.column || _assertGuard_1._assertGuard(_exceptionable, {
|
|
434
|
+
method: "typia.assert",
|
|
435
|
+
path: _path + ".column",
|
|
436
|
+
expected: "number",
|
|
437
|
+
value: input.column
|
|
438
|
+
}, _errorFactory)) && ("number" === typeof input.code || _assertGuard_1._assertGuard(_exceptionable, {
|
|
439
|
+
method: "typia.assert",
|
|
440
|
+
path: _path + ".code",
|
|
441
|
+
expected: "number",
|
|
442
|
+
value: input.code
|
|
443
|
+
}, _errorFactory)) && ("error" === input.category || "warning" === input.category || _assertGuard_1._assertGuard(_exceptionable, {
|
|
444
|
+
method: "typia.assert",
|
|
445
|
+
path: _path + ".category",
|
|
446
|
+
expected: "(\"error\" | \"warning\")",
|
|
447
|
+
value: input.category
|
|
448
|
+
}, _errorFactory)) && ("string" === typeof input.message || _assertGuard_1._assertGuard(_exceptionable, {
|
|
449
|
+
method: "typia.assert",
|
|
450
|
+
path: _path + ".message",
|
|
451
|
+
expected: "string",
|
|
452
|
+
value: input.message
|
|
453
|
+
}, _errorFactory));
|
|
454
|
+
const _ao8 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
|
|
176
455
|
method: "typia.assert",
|
|
177
456
|
path: _path + ".id",
|
|
178
457
|
expected: "string",
|
|
@@ -182,17 +461,12 @@ function parseDump(json) {
|
|
|
182
461
|
path: _path + ".kind",
|
|
183
462
|
expected: _ae0,
|
|
184
463
|
value: input.kind
|
|
185
|
-
}, _errorFactory)) &&
|
|
464
|
+
}, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName || _assertGuard_1._assertGuard(_exceptionable, {
|
|
186
465
|
method: "typia.assert",
|
|
187
466
|
path: _path + ".qualifiedName",
|
|
188
467
|
expected: "(string | undefined)",
|
|
189
468
|
value: input.qualifiedName
|
|
190
|
-
}, _errorFactory)) && ("
|
|
191
|
-
method: "typia.assert",
|
|
192
|
-
path: _path + ".file",
|
|
193
|
-
expected: "string",
|
|
194
|
-
value: input.file
|
|
195
|
-
}, _errorFactory)) && ("boolean" === typeof input.external || _assertGuard_1._assertGuard(_exceptionable, {
|
|
469
|
+
}, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && ("boolean" === typeof input.external || _assertGuard_1._assertGuard(_exceptionable, {
|
|
196
470
|
method: "typia.assert",
|
|
197
471
|
path: _path + ".external",
|
|
198
472
|
expected: "boolean",
|
|
@@ -217,9 +491,9 @@ function parseDump(json) {
|
|
|
217
491
|
path: _path + ".modifiers",
|
|
218
492
|
expected: "(Array<TtscGraphNodeModifier> | undefined)",
|
|
219
493
|
value: input.modifiers
|
|
220
|
-
}, _errorFactory)) && input.modifiers.every((elem,
|
|
494
|
+
}, _errorFactory)) && input.modifiers.every((elem, _index18) => true === _av1.has(elem) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
221
495
|
method: "typia.assert",
|
|
222
|
-
path: _path + ".modifiers[" +
|
|
496
|
+
path: _path + ".modifiers[" + _index18 + "]",
|
|
223
497
|
expected: _ae1,
|
|
224
498
|
value: elem
|
|
225
499
|
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
@@ -232,14 +506,14 @@ function parseDump(json) {
|
|
|
232
506
|
path: _path + ".decorators",
|
|
233
507
|
expected: "(Array<ITtscGraphDecorator> | undefined)",
|
|
234
508
|
value: input.decorators
|
|
235
|
-
}, _errorFactory)) && input.decorators.every((elem,
|
|
509
|
+
}, _errorFactory)) && input.decorators.every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
|
|
236
510
|
method: "typia.assert",
|
|
237
|
-
path: _path + ".decorators[" +
|
|
511
|
+
path: _path + ".decorators[" + _index19 + "]",
|
|
238
512
|
expected: "ITtscGraphDecorator",
|
|
239
513
|
value: elem
|
|
240
|
-
}, _errorFactory)) &&
|
|
514
|
+
}, _errorFactory)) && _ao9(elem, _path + ".decorators[" + _index19 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
241
515
|
method: "typia.assert",
|
|
242
|
-
path: _path + ".decorators[" +
|
|
516
|
+
path: _path + ".decorators[" + _index19 + "]",
|
|
243
517
|
expected: "ITtscGraphDecorator",
|
|
244
518
|
value: elem
|
|
245
519
|
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
@@ -247,30 +521,30 @@ function parseDump(json) {
|
|
|
247
521
|
path: _path + ".decorators",
|
|
248
522
|
expected: "(Array<ITtscGraphDecorator> | undefined)",
|
|
249
523
|
value: input.decorators
|
|
250
|
-
}, _errorFactory)) &&
|
|
524
|
+
}, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && (undefined === input.implementation || ("object" === typeof input.implementation && null !== input.implementation || _assertGuard_1._assertGuard(_exceptionable, {
|
|
251
525
|
method: "typia.assert",
|
|
252
526
|
path: _path + ".implementation",
|
|
253
527
|
expected: "(ITtscGraphSpan | undefined)",
|
|
254
528
|
value: input.implementation
|
|
255
|
-
}, _errorFactory)) &&
|
|
529
|
+
}, _errorFactory)) && _ao11(input.implementation, _path + ".implementation", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
256
530
|
method: "typia.assert",
|
|
257
531
|
path: _path + ".implementation",
|
|
258
532
|
expected: "(ITtscGraphSpan | undefined)",
|
|
259
533
|
value: input.implementation
|
|
260
534
|
}, _errorFactory));
|
|
261
|
-
const
|
|
535
|
+
const _ao9 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ((Array.isArray(input.arguments) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
262
536
|
method: "typia.assert",
|
|
263
537
|
path: _path + ".arguments",
|
|
264
538
|
expected: "Array<ITtscGraphDecorator.IArgument>",
|
|
265
539
|
value: input.arguments
|
|
266
|
-
}, _errorFactory)) && input.arguments.every((elem,
|
|
540
|
+
}, _errorFactory)) && input.arguments.every((elem, _index20) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
267
541
|
method: "typia.assert",
|
|
268
|
-
path: _path + ".arguments[" +
|
|
542
|
+
path: _path + ".arguments[" + _index20 + "]",
|
|
269
543
|
expected: "ITtscGraphDecorator.IArgument",
|
|
270
544
|
value: elem
|
|
271
|
-
}, _errorFactory)) &&
|
|
545
|
+
}, _errorFactory)) && _ao10(elem, _path + ".arguments[" + _index20 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
272
546
|
method: "typia.assert",
|
|
273
|
-
path: _path + ".arguments[" +
|
|
547
|
+
path: _path + ".arguments[" + _index20 + "]",
|
|
274
548
|
expected: "ITtscGraphDecorator.IArgument",
|
|
275
549
|
value: elem
|
|
276
550
|
}, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
@@ -279,60 +553,19 @@ function parseDump(json) {
|
|
|
279
553
|
expected: "Array<ITtscGraphDecorator.IArgument>",
|
|
280
554
|
value: input.arguments
|
|
281
555
|
}, _errorFactory));
|
|
282
|
-
const
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
const
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
path: _path + ".startLine",
|
|
296
|
-
expected: "number",
|
|
297
|
-
value: input.startLine
|
|
298
|
-
}, _errorFactory)) && (undefined === input.startCol || "number" === typeof input.startCol || _assertGuard_1._assertGuard(_exceptionable, {
|
|
299
|
-
method: "typia.assert",
|
|
300
|
-
path: _path + ".startCol",
|
|
301
|
-
expected: "(number | undefined)",
|
|
302
|
-
value: input.startCol
|
|
303
|
-
}, _errorFactory)) && (undefined === input.endLine || "number" === typeof input.endLine || _assertGuard_1._assertGuard(_exceptionable, {
|
|
304
|
-
method: "typia.assert",
|
|
305
|
-
path: _path + ".endLine",
|
|
306
|
-
expected: "(number | undefined)",
|
|
307
|
-
value: input.endLine
|
|
308
|
-
}, _errorFactory)) && (undefined === input.endCol || "number" === typeof input.endCol || _assertGuard_1._assertGuard(_exceptionable, {
|
|
309
|
-
method: "typia.assert",
|
|
310
|
-
path: _path + ".endCol",
|
|
311
|
-
expected: "(number | undefined)",
|
|
312
|
-
value: input.endCol
|
|
313
|
-
}, _errorFactory));
|
|
314
|
-
const _ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.from || _assertGuard_1._assertGuard(_exceptionable, {
|
|
315
|
-
method: "typia.assert",
|
|
316
|
-
path: _path + ".from",
|
|
317
|
-
expected: "string",
|
|
318
|
-
value: input.from
|
|
319
|
-
}, _errorFactory)) && ("string" === typeof input.to || _assertGuard_1._assertGuard(_exceptionable, {
|
|
320
|
-
method: "typia.assert",
|
|
321
|
-
path: _path + ".to",
|
|
322
|
-
expected: "string",
|
|
323
|
-
value: input.to
|
|
324
|
-
}, _errorFactory)) && (true === _av2.has(input.kind) || _assertGuard_1._assertGuard(_exceptionable, {
|
|
325
|
-
method: "typia.assert",
|
|
326
|
-
path: _path + ".kind",
|
|
327
|
-
expected: _ae2,
|
|
328
|
-
value: input.kind
|
|
329
|
-
}, _errorFactory)) && _ap1(input, _path, true && _exceptionable);
|
|
330
|
-
const _io0 = input => "string" === typeof input.project && "string" === typeof input.tsconfig && (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 && _io5(elem)));
|
|
331
|
-
const _io1 = input => "string" === typeof input.id && true === _iv0.has(input.kind) && _ip0(input) && (undefined === input.qualifiedName || "string" === typeof input.qualifiedName) && "string" === typeof input.file && "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 && _io2(elem))) && _ip1(input) && (undefined === input.implementation || "object" === typeof input.implementation && null !== input.implementation && _io4(input.implementation));
|
|
332
|
-
const _io2 = input => _ip0(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io3(elem)));
|
|
333
|
-
const _io3 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
|
|
334
|
-
const _io4 = 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);
|
|
335
|
-
const _io5 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip1(input);
|
|
556
|
+
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)));
|
|
557
|
+
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)));
|
|
558
|
+
const _io10 = input => undefined === input.literal || "string" === typeof input.literal || "number" === typeof input.literal || "boolean" === typeof input.literal;
|
|
559
|
+
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);
|
|
560
|
+
const _io12 = input => "string" === typeof input.from && "string" === typeof input.to && true === _iv2.has(input.kind) && _ip2(input);
|
|
561
|
+
const _io2 = input => "string" === typeof input.tool && "string" === typeof input.version && "string" === typeof input.typescript;
|
|
562
|
+
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)));
|
|
563
|
+
const _io4 = input => _ip0(input) && "string" === typeof input.digest;
|
|
564
|
+
const _io5 = input => "string" === typeof input.config && _ip0(input);
|
|
565
|
+
const _io6 = input => _ip0(input) && "string" === typeof input.checkerDigest && "string" === typeof input.diskDigest;
|
|
566
|
+
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;
|
|
567
|
+
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));
|
|
568
|
+
const _io9 = input => _ip1(input) && (Array.isArray(input.arguments) && input.arguments.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io10(elem)));
|
|
336
569
|
const __is = input => "object" === typeof input && null !== input && _io0(input);
|
|
337
570
|
let _errorFactory;
|
|
338
571
|
return (input, errorFactory) => {
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"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;;;;;;;;;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
|
|
1
|
+
{"version":3,"file":"loadGraph.js","sourceRoot":"","sources":["../../src/model/loadGraph.ts"],"names":[],"mappings":"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"}
|