@eagleoutice/flowr 2.2.8 → 2.2.9

package/queries/query.d.ts

@@ -18,7 +18,8 @@ import type { ConfigQuery } from './catalog/config-query/config-query-format';
 import type { SearchQuery } from './catalog/search-query/search-query-format';
 import type { HappensBeforeQuery } from './catalog/happens-before-query/happens-before-query-format';
 import type { ResolveValueQuery } from './catalog/resolve-value-query/resolve-value-query-format';
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery;
+import type { DataflowLensQuery } from './catalog/dataflow-lens-query/dataflow-lens-query-format';
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | DataflowLensQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -100,6 +101,64 @@ export declare const SupportedQueries: {
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
     };
+    readonly 'dataflow-lens': {
+        readonly executor: typeof import("./catalog/dataflow-lens-query/dataflow-lens-query-executor").executeDataflowLensQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{
+            readonly name: "parse";
+            readonly humanReadableName: "parse with R shell";
+            readonly description: "Parse the given R code into an AST";
+            readonly processor: (_results: unknown, input: Partial<import("../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../r-bridge/parser").ParseStepOutput<string>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: {
+                    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+                };
+                readonly 5: ({ parsed }: import("../r-bridge/parser").ParseStepOutput<string>, config: import("../util/quads").QuadSerializationConfiguration) => string;
+            };
+            readonly dependencies: readonly [];
+            readonly requiredInput: import("../r-bridge/parser").ParseRequiredInput<string>;
+        } | {
+            readonly name: "normalize";
+            readonly humanReadableName: "normalize";
+            readonly description: "Normalize the AST to flowR's AST";
+            readonly processor: (results: {
+                parse?: import("../r-bridge/parser").ParseStepOutput<string>;
+            }, input: Partial<import("../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../r-bridge/lang-4.x/ast/model/model").RNode<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/normalize-printer").normalizedAstToJson;
+                readonly 5: typeof import("../core/print/normalize-printer").normalizedAstToQuads;
+                readonly 3: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaid;
+                readonly 4: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+            };
+            readonly dependencies: readonly ["parse"];
+            readonly requiredInput: import("../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+        } | {
+            readonly humanReadableName: "dataflow";
+            readonly processor: (results: {
+                normalize?: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            }, input: {
+                request?: import("../r-bridge/retriever").RParseRequests;
+                parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
+            }) => import("../dataflow/info").DataflowInformation;
+            readonly requiredInput: {};
+            readonly name: "dataflow";
+            readonly description: "Construct the dataflow graph";
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/dataflow-printer").dataflowGraphToJson;
+                readonly 5: typeof import("../core/print/dataflow-printer").dataflowGraphToQuads;
+                readonly 3: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaid;
+                readonly 4: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+            };
+            readonly dependencies: readonly ["normalize"];
+        }>>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly schema: Joi.ObjectSchema<any>;
+    };
     readonly 'id-map': {
         readonly executor: typeof import("./catalog/id-map-query/id-map-query-executor").executeIdMapQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{

package/queries/query.js

@@ -26,10 +26,12 @@ const config_query_format_1 = require("./catalog/config-query/config-query-forma
 const search_query_format_1 = require("./catalog/search-query/search-query-format");
 const happens_before_query_format_1 = require("./catalog/happens-before-query/happens-before-query-format");
 const resolve_value_query_format_1 = require("./catalog/resolve-value-query/resolve-value-query-format");
+const dataflow_lens_query_format_1 = require("./catalog/dataflow-lens-query/dataflow-lens-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
     'dataflow': dataflow_query_format_1.DataflowQueryDefinition,
+    'dataflow-lens': dataflow_lens_query_format_1.DataflowLensQueryDefinition,
     'id-map': id_map_query_format_1.IdMapQueryDefinition,
     'normalized-ast': normalized_ast_query_format_1.NormalizedAstQueryDefinition,
     'dataflow-cluster': cluster_query_format_1.ClusterQueryDefinition,

package/r-bridge/retriever.d.ts

@@ -25,6 +25,8 @@ export interface RParseRequestFromText {
  * A provider for an {@link RParseRequests} that can be used, for example, to override source file parsing behavior in tests
  */
 export interface RParseRequestProvider {
+    /** returns the path if it exists, otherwise undefined */
+    exists(path: string, ignoreCase: boolean): string | undefined;
     createRequest(path: string): RParseRequest;
 }
 export type RParseRequest = RParseRequestFromFile | RParseRequestFromText;
@@ -40,7 +42,6 @@ export declare function requestProviderFromFile(): RParseRequestProvider;
 export declare function requestProviderFromText(text: Readonly<{
     [path: string]: string;
 }>): RParseRequestProvider;
-export declare function requestFingerprint(request: RParseRequest): string;
 export declare function isEmptyRequest(request: RParseRequest): boolean;
 export declare function retrieveParseDataFromRCode(request: RParseRequest, shell: RShell): Promise<string>;
 export declare function retrieveParseDataFromRCode(request: RParseRequest, shell: RShellExecutor): string;
@@ -55,6 +56,6 @@ export declare function retrieveNormalizedAstFromRCode(request: RParseRequest, s
  */
 export declare function removeRQuotes(str: string): string;
 /**
- * Needs to be called *after*  {@link retrieveParseDataFromRCode} (or {@link retrieveNormalizedAstFromRCode})
+ * Needs to be called *after* {@link retrieveParseDataFromRCode} (or {@link retrieveNormalizedAstFromRCode})
  */
 export declare function retrieveNumberOfRTokensOfLastParse(shell: RShell, ignoreComments?: boolean): Promise<number>;

package/r-bridge/retriever.js

@@ -7,7 +7,6 @@ exports.fileProtocol = void 0;
 exports.requestFromInput = requestFromInput;
 exports.requestProviderFromFile = requestProviderFromFile;
 exports.requestProviderFromText = requestProviderFromText;
-exports.requestFingerprint = requestFingerprint;
 exports.isEmptyRequest = isEmptyRequest;
 exports.retrieveParseDataFromRCode = retrieveParseDataFromRCode;
 exports.retrieveNormalizedAstFromRCode = retrieveNormalizedAstFromRCode;
@@ -16,12 +15,13 @@ exports.retrieveNumberOfRTokensOfLastParse = retrieveNumberOfRTokensOfLastParse;
 const strings_1 = require("../util/strings");
 const assert_1 = require("../util/assert");
 const shell_executor_1 = require("./shell-executor");
-const object_hash_1 = __importDefault(require("object-hash"));
 const parser_1 = require("./lang-4.x/ast/parser/json/parser");
 const init_1 = require("./init");
 const convert_values_1 = require("./lang-4.x/convert-values");
 const decorate_1 = require("./lang-4.x/ast/model/processing/decorate");
 const type_1 = require("./lang-4.x/ast/model/type");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 exports.fileProtocol = 'file://';
 /**
  * Creates a {@link RParseRequests} from a given input.
@@ -42,6 +42,22 @@ function requestFromInput(input) {
 }
 function requestProviderFromFile() {
     return {
+        exists(p, ignoreCase) {
+            try {
+                if (!ignoreCase) {
+                    return fs_1.default.existsSync(p) ? p : undefined;
+                }
+                // walk the directory and find the first match
+                const dir = path_1.default.dirname(p);
+                const file = path_1.default.basename(p);
+                const files = fs_1.default.readdirSync(dir);
+                const found = files.find(f => f.toLowerCase() === file.toLowerCase());
+                return found ? path_1.default.join(dir, found) : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        },
         createRequest(path) {
             return {
                 request: 'file',
@@ -52,17 +68,20 @@ function requestProviderFromFile() {
 }
 function requestProviderFromText(text) {
     return {
+        exists(path, ignoreCase) {
+            if (ignoreCase) {
+                return Object.keys(text).find(p => p.toLowerCase() === path.toLowerCase());
+            }
+            return text[path] ? path : undefined;
+        },
         createRequest(path) {
             return {
                 request: 'text',
-                content: text[path]
+                content: text[path] ?? ''
             };
         }
     };
 }
-function requestFingerprint(request) {
-    return (0, object_hash_1.default)(request);
-}
 function isEmptyRequest(request) {
     return request.content.trim().length === 0;
 }
@@ -107,7 +126,7 @@ function removeRQuotes(str) {
     }
 }
 /**
- * Needs to be called *after*  {@link retrieveParseDataFromRCode} (or {@link retrieveNormalizedAstFromRCode})
+ * Needs to be called *after* {@link retrieveParseDataFromRCode} (or {@link retrieveNormalizedAstFromRCode})
  */
 async function retrieveNumberOfRTokensOfLastParse(shell, ignoreComments = false) {
     const rows = ignoreComments ? `flowr_output[flowr_output$token != "${type_1.RawRType.Comment}", ]` : 'flowr_output';

package/slicing/static/static-slicer.js

@@ -60,9 +60,9 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
         }
         const [currentVertex, currentEdges] = currentInfo;
         // we only add control dependencies iff 1) we are in different function call or 2) they have, at least, the same nesting as the slicing seed
-        if (currentVertex.controlDependencies && currentVertex.controlDependencies.length > 0) {
+        if (currentVertex.cds && currentVertex.cds.length > 0) {
             const topLevel = graph.isRoot(id) || sliceSeedIds.has(id);
-            for (const cd of currentVertex.controlDependencies.filter(({ id }) => !queue.hasId(id))) {
+            for (const cd of currentVertex.cds.filter(({ id }) => !queue.hasId(id))) {
                 if (!topLevel || (idMap.get(cd.id)?.info.nesting ?? 0) >= minNesting) {
                     queue.add(cd.id, baseEnvironment, baseEnvFingerprint, false);
                 }

package/util/mermaid/cfg.js

@@ -7,7 +7,7 @@ function getLexeme(n) {
     return n ? n.info.fullLexeme ?? n.lexeme ?? '<unknown>' : '';
 }
 function cfgToMermaid(cfg, normalizedAst, prefix = '') {
-    let output = prefix + 'flowchart TD\n';
+    let output = prefix + 'flowchart BT\n';
     for (const [id, vertex] of cfg.graph.vertices()) {
         const normalizedVertex = normalizedAst.idMap.get(id);
         const content = getLexeme(normalizedVertex);

package/util/mermaid/dfg.d.ts

@@ -44,11 +44,12 @@ export declare function graphToMermaid(config: MermaidGraphConfiguration): {
 /**
  * Converts a dataflow graph to a mermaid url that visualizes the graph.
  *
- * @param graph         - The graph to convert
+ * @param graph               - The graph to convert
  * @param includeEnvironments - Whether to include the environments in the mermaid graph code
- * @param mark          - Special nodes to mark (e.g., those included in the slice)
+ * @param mark                - Special nodes to mark (e.g., those included in the slice)
+ * @param simplified          - Whether to simplify the graph
  */
-export declare function graphToMermaidUrl(graph: DataflowGraph, includeEnvironments?: boolean, mark?: ReadonlySet<NodeId>): string;
+export declare function graphToMermaidUrl(graph: DataflowGraph, includeEnvironments?: boolean, mark?: ReadonlySet<NodeId>, simplified?: boolean): string;
 export interface LabeledDiffGraph {
     label: string;
     graph: DataflowGraph;

package/util/mermaid/dfg.js

@@ -42,7 +42,8 @@ function subflowToMermaid(nodeId, exitPoints, subflow, mermaid, idPrefix = '') {
         const idMap = mermaid.rootGraph.idMap;
         const node = idMap?.get(nodeId);
         const nodeLexeme = node?.info.fullLexeme ?? node?.lexeme ?? '??';
-        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${(0, mermaid_1.escapeMarkdown)(nodeLexeme ?? 'function')}"]`);
+        const location = node?.location?.[0] ? ` (L. ${node?.location?.[0]})` : '';
+        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${(0, mermaid_1.escapeMarkdown)(nodeLexeme ?? 'function')}${location}"]`);
     }
     else {
         mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
@@ -154,12 +155,13 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     const node = mermaid.rootGraph.idMap?.get(info.id);
     const lexeme = node?.lexeme ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0]?.lexeme : '') ?? '??';
     if (mermaid.simplified) {
-        const escapedName = '**' + (0, mermaid_1.escapeMarkdown)(node ? `${lexeme}` : '??') + '**' + (node ? `\n*${node.type}*` : '');
+        const location = node?.location?.[0] ? ` (L. ${node?.location?.[0]})` : '';
+        const escapedName = '**' + (0, mermaid_1.escapeMarkdown)(node ? `${lexeme}` : '??') + '**' + location + (node ? `\n*${node.type}*` : '');
         mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}\`"${close}`);
     }
     else {
         const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${lexeme}` : '??');
-        const deps = info.controlDependencies ? ', :may:' + info.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
+        const deps = info.cds ? ', :may:' + info.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
         const n = node?.info.fullRange ?? node?.location ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0].location : undefined);
         mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
     }
@@ -171,7 +173,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     }
     const edges = mermaid.rootGraph.get(id, true);
     (0, assert_1.guard)(edges !== undefined, `node ${id} must be found`);
-    const artificialCdEdges = (info.controlDependencies ?? []).map(x => [x.id, { types: new Set([x.when ? 'CD-True' : 'CD-False']) }]);
+    const artificialCdEdges = (info.cds ?? []).map(x => [x.id, { types: new Set([x.when ? 'CD-True' : 'CD-False']) }]);
     for (const [target, edge] of [...edges[1], ...artificialCdEdges]) {
         const edgeTypes = typeof edge.types == 'number' ? new Set((0, edge_1.splitEdgeTypes)(edge.types)) : edge.types;
         const edgeId = encodeEdge(idPrefix + id, idPrefix + target, edgeTypes);
@@ -192,7 +194,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     }
 }
 // make the passing of root ids more performant again
-function graphToMermaidGraph(rootIds, { simplified, graph, prefix = 'flowchart TD', idPrefix = '', includeEnvironments = !simplified, mark, rootGraph, presentEdges = new Set(), markStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' } }) {
+function graphToMermaidGraph(rootIds, { simplified, graph, prefix = 'flowchart BT', idPrefix = '', includeEnvironments = !simplified, mark, rootGraph, presentEdges = new Set(), markStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' } }) {
     const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, mark, rootGraph: rootGraph ?? graph, includeEnvironments, markStyle, simplified };
     for (const [id, info] of graph.vertices(true)) {
         if (rootIds.has(id)) {
@@ -208,19 +210,20 @@ function graphToMermaid(config) {
 /**
  * Converts a dataflow graph to a mermaid url that visualizes the graph.
  *
- * @param graph         - The graph to convert
+ * @param graph               - The graph to convert
  * @param includeEnvironments - Whether to include the environments in the mermaid graph code
- * @param mark          - Special nodes to mark (e.g., those included in the slice)
+ * @param mark                - Special nodes to mark (e.g., those included in the slice)
+ * @param simplified          - Whether to simplify the graph
  */
-function graphToMermaidUrl(graph, includeEnvironments, mark) {
-    return (0, mermaid_1.mermaidCodeToUrl)(graphToMermaid({ graph, includeEnvironments, mark }).string);
+function graphToMermaidUrl(graph, includeEnvironments, mark, simplified = false) {
+    return (0, mermaid_1.mermaidCodeToUrl)(graphToMermaid({ graph, includeEnvironments, mark, simplified }).string);
 }
 /** uses same id map but ensures, it is different from the rhs so that mermaid can work with that */
 function diffGraphsToMermaid(left, right, prefix) {
     // we add the prefix ourselves
     const { string: leftGraph, mermaid } = graphToMermaid({ graph: left.graph, prefix: '', idPrefix: `l-${left.label}`, includeEnvironments: true, mark: left.mark });
     const { string: rightGraph } = graphToMermaid({ graph: right.graph, prefix: '', idPrefix: `r-${right.label}`, includeEnvironments: true, mark: right.mark, presentEdges: mermaid.presentEdges });
-    return `${prefix}flowchart TD\nsubgraph "${left.label}"\n${leftGraph}\nend\nsubgraph "${right.label}"\n${rightGraph}\nend`;
+    return `${prefix}flowchart BT\nsubgraph "${left.label}"\n${leftGraph}\nend\nsubgraph "${right.label}"\n${rightGraph}\nend`;
 }
 function diffGraphsToMermaidUrl(left, right, prefix) {
     return (0, mermaid_1.mermaidCodeToUrl)(diffGraphsToMermaid(left, right, prefix));

package/util/objects.d.ts

@@ -10,8 +10,8 @@ export type Mergeable = MergeableRecord | MergeableArray;
  * Given two objects deeply merges them, if an object is an array it will merge the array values!
  * Guarantees some type safety by requiring objects to merge to be from the same type (allows undefined)
  */
-export declare function deepMergeObject<T extends Mergeable>(base: Required<T>, addon?: T): Required<T>;
-export declare function deepMergeObject<T extends Mergeable>(base: DeepRequired<T>, addon?: T): DeepRequired<T>;
+export declare function deepMergeObject<T extends Mergeable>(base: Required<T>, addon?: T | DeepPartial<T> | Partial<T>): Required<T>;
+export declare function deepMergeObject<T extends Mergeable>(base: DeepRequired<T>, addon?: T | DeepPartial<T> | Partial<T>): DeepRequired<T>;
 export declare function deepMergeObject<T extends Mergeable>(base: T, addon?: DeepPartial<T> | Partial<T>): T;
 export declare function deepMergeObject(base: Mergeable, addon: Mergeable): Mergeable;
 export declare function deepMergeObject(base?: Mergeable, addon?: Mergeable): Mergeable | undefined;

package/util/simple-df/dfg-view.d.ts

@@ -0,0 +1,16 @@
+import { DataflowGraph } from '../../dataflow/graph/graph';
+import { VertexType } from '../../dataflow/graph/vertex';
+import type { MergeableRecord } from '../objects';
+import type { DeepPartial } from 'ts-essentials';
+export interface ReduceVertexOptions extends MergeableRecord {
+    tags: VertexType[];
+    nameRegex: string;
+    blacklistWithName: boolean;
+    keepEnv: boolean;
+    keepCd: boolean;
+    compactFunctions: boolean;
+}
+export interface ReduceOptions extends MergeableRecord {
+    vertices: ReduceVertexOptions;
+}
+export declare function reduceDfg(dfg: DataflowGraph, options: DeepPartial<ReduceOptions>): DataflowGraph;

package/util/simple-df/dfg-view.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceDfg = reduceDfg;
+const graph_1 = require("../../dataflow/graph/graph");
+const vertex_1 = require("../../dataflow/graph/vertex");
+const objects_1 = require("../objects");
+const assert_1 = require("../assert");
+const defaultReduceOptions = {
+    vertices: {
+        tags: [...Object.values(vertex_1.VertexType)],
+        nameRegex: '.*',
+        blacklistWithName: false,
+        keepEnv: false,
+        keepCd: true,
+        compactFunctions: true
+    }
+};
+function makeFilter(options, idMap) {
+    const nameRegex = new RegExp(options.nameRegex);
+    return (arg) => {
+        if (!options.tags.includes(arg.tag)) {
+            return undefined;
+        }
+        const lexeme = idMap?.get(arg.id)?.lexeme;
+        if (lexeme && (nameRegex.test(lexeme) === options.blacklistWithName)) {
+            return undefined;
+        }
+        return {
+            ...arg,
+            environment: options.keepEnv ? arg.environment : undefined,
+            controlDependencies: options.keepCd ? arg.controlDependencies : undefined,
+            functionInformation: options.compactFunctions ? arg.functionInformation : undefined
+        };
+    };
+}
+function reduceDfg(dfg, options) {
+    const newDfg = new graph_1.DataflowGraph(dfg.idMap);
+    const applyOptions = (0, objects_1.deepMergeObject)(defaultReduceOptions, options);
+    // overwrite the tag set if possible
+    if (options.vertices?.tags) {
+        applyOptions.vertices.tags = options.vertices.tags.filter(assert_1.isNotUndefined);
+    }
+    const applyFilter = makeFilter(applyOptions.vertices, dfg.idMap);
+    // go over the vertices
+    for (const [id, info] of dfg.vertices(!applyOptions)) {
+        const result = applyFilter(info);
+        if (result) {
+            newDfg.addVertex(result, dfg.isRoot(id));
+        }
+    }
+    for (const [from, out] of dfg.edges()) {
+        if (!newDfg.hasVertex(from)) {
+            continue;
+        }
+        for (const [to, { types }] of out) {
+            if (!newDfg.hasVertex(to)) {
+                continue;
+            }
+            newDfg.addEdge(from, to, types);
+        }
+    }
+    return newDfg;
+}
+//# sourceMappingURL=dfg-view.js.map

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.2.8';
+const version = '2.2.9';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }