@eagleoutice/flowr 2.9.13 → 2.9.14

package/slicing/criterion/parse.d.ts

@@ -2,30 +2,54 @@ import { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /** Either `line:column`, `line@variable-name`, or `$id` */
 export type SingleSlicingCriterion = `${number}:${number}` | `${number}@${string}` | `$${NodeId | number}`;
-export type SlicingCriteria = SingleSlicingCriterion[];
-/**
- * Thrown if the given slicing criteria can not be found
- */
-export declare class CriteriaParseError extends Error {
-    constructor(message: string);
-}
 /**
- * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
- * @see {@link tryResolveSliceCriterionToId} for a version that does not throw an error
+ * The helper object associated with {@link SingleSlicingCriterion} which makes it easy
+ * to parse, validate and resolve slicing criteria.
  */
-export declare function slicingCriterionToId(criterion: SingleSlicingCriterion, idMap: AstIdMap): NodeId;
+export declare const SingleSlicingCriterion: {
+    /**
+     * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
+     * @see {@link SingleSlicingCriterion.tryParse} for a version that does not throw an error
+     */
+    readonly parse: (this: void, criterion: SingleSlicingCriterion, idMap: AstIdMap) => NodeId;
+    /**
+     * Tries to resolve a slicing criterion to an id, but does not throw an error if it fails.
+     * @see {@link SingleSlicingCriterion.parse} for the version that throws an error
+     */
+    readonly tryParse: (this: void, criterion: SingleSlicingCriterion | NodeId, idMap: AstIdMap) => NodeId | undefined;
+    /**
+     * Converts a node id to a slicing criterion in the form of `$id`
+     */
+    readonly fromId: (this: void, id: NodeId) => SingleSlicingCriterion;
+};
 /**
- * Tries to resolve a slicing criterion to an id, but does not throw an error if it fails.
- * @see {@link slicingCriterionToId} for the version that throws an error
+ * A slicing criterion is a list of single slicing criteria, which can be in the form of `line:column`, `line@variable-name`, or `$id`.
  */
-export declare function tryResolveSliceCriterionToId(criterion: string | NodeId, idMap: AstIdMap): NodeId | undefined;
+export type SlicingCriteria = SingleSlicingCriterion[];
 export interface DecodedCriterion {
     criterion: SingleSlicingCriterion;
     id: NodeId;
 }
 export type DecodedCriteria = ReadonlyArray<DecodedCriterion>;
 /**
- * Converts all slicing criteria to their corresponding node ids
- * @throws CriteriaParseError if any of the criteria can not be resolved
+ * The helper object associated with {@link SlicingCriteria} which makes it easy to parse, validate and resolve slicing criteria.
+ */
+export declare const SlicingCriteria: {
+    /**
+     * Decodes all slicing criteria to their corresponding node ids
+     * @throws CriteriaParseError if any of the criteria can not be resolved
+     * @see {@link SlicingCriteria.convertAll}
+     */
+    readonly decodeAll: (this: void, criteria: SlicingCriteria, decorated: AstIdMap) => DecodedCriteria;
+    /**
+     * Converts all criteria to their id in the AST if possible, this keeps the original criterion if it can not be resolved.
+     * @see {@link SlicingCriteria.decodeAll}
+     */
+    readonly convertAll: (this: void, criteria: SlicingCriteria, decorated: AstIdMap) => NodeId[];
+};
+/**
+ * Thrown if the given slicing criteria can not be found
  */
-export declare function convertAllSlicingCriteriaToIds(criteria: SlicingCriteria, decorated: AstIdMap): DecodedCriteria;
+export declare class CriteriaParseError extends Error {
+    constructor(message: string);
+}

package/slicing/criterion/parse.js

@@ -1,63 +1,83 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CriteriaParseError = void 0;
-exports.slicingCriterionToId = slicingCriterionToId;
-exports.tryResolveSliceCriterionToId = tryResolveSliceCriterionToId;
-exports.convertAllSlicingCriteriaToIds = convertAllSlicingCriteriaToIds;
+exports.CriteriaParseError = exports.SlicingCriteria = exports.SingleSlicingCriterion = void 0;
 const log_1 = require("../../util/log");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const static_slicer_1 = require("../static/static-slicer");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 /**
- * Thrown if the given slicing criteria can not be found
+ * The helper object associated with {@link SingleSlicingCriterion} which makes it easy
+ * to parse, validate and resolve slicing criteria.
  */
-class CriteriaParseError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'CriteriaParseError';
+exports.SingleSlicingCriterion = {
+    /**
+     * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
+     * @see {@link SingleSlicingCriterion.tryParse} for a version that does not throw an error
+     */
+    parse(criterion, idMap) {
+        const resolved = exports.SingleSlicingCriterion.tryParse(criterion, idMap);
+        if (resolved === undefined) {
+            throw new CriteriaParseError(`invalid slicing criterion ${criterion}`);
+        }
+        return resolved;
+    },
+    /**
+     * Tries to resolve a slicing criterion to an id, but does not throw an error if it fails.
+     * @see {@link SingleSlicingCriterion.parse} for the version that throws an error
+     */
+    tryParse(criterion, idMap) {
+        criterion = criterion.toString(); // in case it's a number
+        if (criterion.startsWith('$')) {
+            return node_id_1.NodeId.normalize(criterion.substring(1));
+        }
+        else if (criterion.includes('@')) {
+            const at = criterion.indexOf('@');
+            const line = parseInt(criterion.substring(0, at));
+            const name = criterion.substring(at + 1);
+            return conventionalCriteriaToId(line, name, idMap);
+        }
+        else if (criterion.includes(':')) {
+            const [line, column] = criterion.split(':').map(c => parseInt(c));
+            return locationToId([line, column], idMap);
+        }
+    },
+    /**
+     * Converts a node id to a slicing criterion in the form of `$id`
+     */
+    fromId(id) {
+        return `$${id}`;
     }
-}
-exports.CriteriaParseError = CriteriaParseError;
+};
 /**
- * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
- * @see {@link tryResolveSliceCriterionToId} for a version that does not throw an error
+ * The helper object associated with {@link SlicingCriteria} which makes it easy to parse, validate and resolve slicing criteria.
  */
-function slicingCriterionToId(criterion, idMap) {
-    let resolved;
-    if (criterion.startsWith('$')) {
-        resolved = node_id_1.NodeId.normalize(criterion.substring(1));
-    }
-    else if (criterion.includes('@')) {
-        const at = criterion.indexOf('@');
-        const line = parseInt(criterion.substring(0, at));
-        const name = criterion.substring(at + 1);
-        resolved = conventionalCriteriaToId(line, name, idMap);
+exports.SlicingCriteria = {
+    /**
+     * Decodes all slicing criteria to their corresponding node ids
+     * @throws CriteriaParseError if any of the criteria can not be resolved
+     * @see {@link SlicingCriteria.convertAll}
+     */
+    decodeAll(criteria, decorated) {
+        return criteria.map(l => ({ criterion: l, id: exports.SingleSlicingCriterion.parse(l, decorated) }));
+    },
+    /**
+     * Converts all criteria to their id in the AST if possible, this keeps the original criterion if it can not be resolved.
+     * @see {@link SlicingCriteria.decodeAll}
+     */
+    convertAll(criteria, decorated) {
+        return criteria.map(l => exports.SingleSlicingCriterion.tryParse(l, decorated) ?? l);
     }
-    else if (criterion.includes(':')) {
-        const [line, column] = criterion.split(':').map(c => parseInt(c));
-        resolved = locationToId([line, column], idMap);
-    }
-    if (resolved === undefined) {
-        throw new CriteriaParseError(`invalid slicing criterion ${criterion}`);
-    }
-    return resolved;
-}
+};
 /**
- * Tries to resolve a slicing criterion to an id, but does not throw an error if it fails.
- * @see {@link slicingCriterionToId} for the version that throws an error
+ * Thrown if the given slicing criteria can not be found
  */
-function tryResolveSliceCriterionToId(criterion, idMap) {
-    try {
-        return slicingCriterionToId(criterion, idMap);
-    }
-    catch (e) {
-        if (e instanceof CriteriaParseError) {
-            (0, log_1.expensiveTrace)(static_slicer_1.slicerLogger, () => `could not resolve slicing criterion ${criterion}: ${e.message}`);
-            return undefined;
-        }
-        throw e; // rethrow other errors
+class CriteriaParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CriteriaParseError';
     }
 }
+exports.CriteriaParseError = CriteriaParseError;
 function locationToId(location, dataflowIdMap) {
     let candidate;
     for (const [id, nodeInfo] of dataflowIdMap.entries()) {
@@ -71,36 +91,20 @@ function locationToId(location, dataflowIdMap) {
         }
         candidate = nodeInfo;
     }
-    const id = candidate?.info.id;
-    if (id) {
-        (0, log_1.expensiveTrace)(static_slicer_1.slicerLogger, () => `resolve id ${id} (${JSON.stringify(candidate?.info)}) for location ${JSON.stringify(location)}`);
-    }
-    return id;
+    return candidate?.info.id;
 }
 function conventionalCriteriaToId(line, name, dataflowIdMap) {
     let candidate;
-    for (const [id, nodeInfo] of dataflowIdMap.entries()) {
+    for (const nodeInfo of dataflowIdMap.values()) {
         if (nodeInfo.location === undefined || nodeInfo.location[0] !== line || nodeInfo.lexeme !== name) {
             continue;
         }
-        static_slicer_1.slicerLogger.trace(`can resolve id ${id} (${JSON.stringify(nodeInfo)}) for line ${line} and name ${name}`);
         // function calls have the same location as the symbol they refer to, so we need to prefer the function call
         if (candidate !== undefined && nodeInfo.type !== type_1.RType.FunctionCall || nodeInfo.type === type_1.RType.Argument || nodeInfo.type === type_1.RType.ExpressionList) {
             continue;
         }
         candidate = nodeInfo;
     }
-    const id = candidate?.info.id;
-    if (id) {
-        static_slicer_1.slicerLogger.trace(`resolve id ${id} (${JSON.stringify(candidate?.info)}) for line ${line} and name ${name}`);
-    }
-    return id;
-}
-/**
- * Converts all slicing criteria to their corresponding node ids
- * @throws CriteriaParseError if any of the criteria can not be resolved
- */
-function convertAllSlicingCriteriaToIds(criteria, decorated) {
-    return criteria.map(l => ({ criterion: l, id: slicingCriterionToId(l, decorated) }));
+    return candidate?.info.id;
 }
 //# sourceMappingURL=parse.js.map

package/slicing/static/slicer-types.d.ts

@@ -1,6 +1,5 @@
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../../dataflow/environments/environment';
-import type { DecodedCriteria } from '../criterion/parse';
 /**
  * Represents a node during the slicing process, together with the environment it is traversed in
  * (modified by function calls) and whether it is only used for its side effects.
@@ -29,7 +28,7 @@ export interface SliceResult {
      */
     readonly result: ReadonlySet<NodeId>;
     /**
-     * The mapping produced to decode the entered criteria
+     * The ids of the nodes in the normalized ast that were used as seed ids for slicing. This is a subset of {@link result}.
      */
-    readonly decodedCriteria: DecodedCriteria;
+    readonly slicedFor: readonly NodeId[];
 }

package/slicing/static/static-slicer.d.ts

@@ -2,12 +2,11 @@ import type { SliceResult } from './slicer-types';
 import { type Fingerprint } from './fingerprint';
 import { VisitingQueue } from './visiting-queue';
 import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { type SlicingCriteria } from '../criterion/parse';
 import { type REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import { SliceDirection } from '../../core/steps/all/static-slicing/00-slice';
 import type { DataflowInformation } from '../../dataflow/info';
 import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
+import { SliceDirection } from '../../util/slice-direction';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
@@ -16,12 +15,12 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  * @param ctx  - The analyzer context used for slicing.
  * @param info      - The dataflow information used for slicing.
  * @param idMap     - The mapping from node ids to their information in the AST.
- * @param criteria  - The criteria to slice on.
+ * @param ids       - The seed ids to slice with. Must be at least one.
  * @param direction - The direction to slice in.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  * @param cache     - A cache to store the results of the slice. If provided, the slice may use this cache to speed up the slicing process.
  */
-export declare function staticSlice(ctx: ReadOnlyFlowrAnalyzerContext, info: DataflowInformation, { idMap }: NormalizedAst, criteria: SlicingCriteria, direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
+export declare function staticSlice(ctx: ReadOnlyFlowrAnalyzerContext, info: DataflowInformation, { idMap }: NormalizedAst, ids: readonly NodeId[], direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
 /**
  * Updates the potential addition for the given target node in the visiting queue.
  * This describes vertices that might be added *if* another path reaches them.

package/slicing/static/static-slicer.js

@@ -7,11 +7,10 @@ const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
 const visiting_queue_1 = require("./visiting-queue");
 const slice_call_1 = require("./slice-call");
-const parse_1 = require("../criterion/parse");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const edge_1 = require("../../dataflow/graph/edge");
-const _00_slice_1 = require("../../core/steps/all/static-slicing/00-slice");
-const invert_dfg_1 = require("../../dataflow/graph/invert-dfg");
+const df_helper_1 = require("../../dataflow/graph/df-helper");
+const slice_direction_1 = require("../../util/slice-direction");
 exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
 /**
  * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
@@ -20,18 +19,16 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * @param ctx  - The analyzer context used for slicing.
  * @param info      - The dataflow information used for slicing.
  * @param idMap     - The mapping from node ids to their information in the AST.
- * @param criteria  - The criteria to slice on.
+ * @param ids       - The seed ids to slice with. Must be at least one.
  * @param direction - The direction to slice in.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  * @param cache     - A cache to store the results of the slice. If provided, the slice may use this cache to speed up the slicing process.
  */
-function staticSlice(ctx, info, { idMap }, criteria, direction, threshold = 75, cache) {
-    (0, assert_1.guard)(criteria.length > 0, 'must have at least one seed id to calculate slice');
-    const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, idMap);
-    (0, log_1.expensiveTrace)(exports.slicerLogger, () => `calculating ${direction} slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
+function staticSlice(ctx, info, { idMap }, ids, direction, threshold = 75, cache) {
+    (0, assert_1.guard)(ids.length > 0, 'must have at least one seed id to calculate slice');
     let { graph } = info;
-    if (direction === _00_slice_1.SliceDirection.Forward) {
-        graph = (0, invert_dfg_1.invertDfg)(graph, ctx.env.makeCleanEnv());
+    if (direction === slice_direction_1.SliceDirection.Forward) {
+        graph = df_helper_1.Dataflow.invertGraph(graph, ctx.env.makeCleanEnv());
     }
     const queue = new visiting_queue_1.VisitingQueue(threshold, cache);
     let minNesting = Number.MAX_SAFE_INTEGER;
@@ -40,7 +37,7 @@ function staticSlice(ctx, info, { idMap }, criteria, direction, threshold = 75,
     {
         const emptyEnv = ctx.env.makeCleanEnv();
         const basePrint = ctx.env.getCleanEnvFingerprint();
-        for (const { id: startId } of decodedCriteria) {
+        for (const startId of ids) {
             queue.add(startId, emptyEnv, basePrint, false);
             // retrieve the minimum nesting of all nodes to only add control dependencies if they are "part" of the current execution
             minNesting = Math.min(minNesting, idMap.get(startId)?.info.nesting ?? minNesting);
@@ -102,7 +99,7 @@ function staticSlice(ctx, info, { idMap }, criteria, direction, threshold = 75,
             }
         }
     }
-    return { ...queue.status(), decodedCriteria };
+    return { ...queue.status(), slicedFor: ids };
 }
 /**
  * Updates the potential addition for the given target node in the visiting queue.

package/util/diff.d.ts

@@ -42,12 +42,12 @@ export interface GenericDifferenceInformation<Report extends WriteableDifference
 }
 export interface GenericDiffConfiguration {
     /**
-     * The left graph may contain more vertices and or edges than the right graph.
+     * The left/first graph may contain more vertices and or edges than the right/second graph.
      * However, those which are the same (based on their ids) have to be equal
      */
     readonly rightIsSubgraph?: boolean;
     /**
-     * Similar to {@link rightIsSubgraph}, but for the left graph.
+     * Similar to {@link rightIsSubgraph}, but for the left/first graph.
      */
     readonly leftIsSubgraph?: boolean;
 }

package/util/mermaid/ast.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizedAstToMermaid = normalizedAstToMermaid;
 exports.normalizedAstToMermaidUrl = normalizedAstToMermaidUrl;
-const mermaid_1 = require("./mermaid");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const flowr_file_1 = require("../../project/context/flowr-file");
 const info_1 = require("./info");
 const model_1 = require("../../r-bridge/lang-4.x/ast/model/model");
+const mermaid_1 = require("./mermaid");
 function identifyMermaidDirection(prefix) {
     const directionMatch = prefix.match(/flowchart (TD|LR|RL|BT)/);
     if (directionMatch) {
@@ -25,7 +25,7 @@ function normalizedAstToMermaid(ast, { prefix = 'flowchart TD\n', markStyle = in
             return;
         }
         const name = `${n.type} (${n.info.id})\\n${n.lexeme ?? ' '}`;
-        output += `    n${n.info.id}(["${(0, mermaid_1.escapeMarkdown)(name)}"])\n`;
+        output += `    n${n.info.id}(["${mermaid_1.Mermaid.escape(name)}"])\n`;
         if (mark?.has(n.info.id)) {
             output += `    style n${n.info.id} ${markStyle.vertex}\n`;
         }
@@ -57,7 +57,7 @@ function normalizedAstToMermaid(ast, { prefix = 'flowchart TD\n', markStyle = in
             // add a subgraph for each file
             if (ast.files.length !== 1 || (f.filePath && f.filePath !== flowr_file_1.FlowrFile.INLINE_PATH)) {
                 const direction = identifyMermaidDirection(prefix);
-                output += `    subgraph "File: ${(0, mermaid_1.escapeMarkdown)(f.filePath ?? flowr_file_1.FlowrFile.INLINE_PATH)}" direction ${direction}\n`;
+                output += `    subgraph "File: ${mermaid_1.Mermaid.escape(f.filePath ?? flowr_file_1.FlowrFile.INLINE_PATH)}" direction ${direction}\n`;
                 showAst(f.root);
                 output += '    end\n';
             }
@@ -75,6 +75,6 @@ function normalizedAstToMermaid(ast, { prefix = 'flowchart TD\n', markStyle = in
  * Use mermaid to visualize the normalized AST.
  */
 function normalizedAstToMermaidUrl(ast, info) {
-    return (0, mermaid_1.mermaidCodeToUrl)(normalizedAstToMermaid(ast, info ?? {}));
+    return mermaid_1.Mermaid.codeToUrl(normalizedAstToMermaid(ast, info ?? {}));
 }
 //# sourceMappingURL=ast.js.map

package/util/mermaid/cfg.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MermaidExitPointDefaultMarkStyle = exports.MermaidEntryPointDefaultMarkStyle = void 0;
 exports.cfgToMermaid = cfgToMermaid;
 exports.cfgToMermaidUrl = cfgToMermaidUrl;
-const mermaid_1 = require("./mermaid");
 const control_flow_graph_1 = require("../../control-flow/control-flow-graph");
 const reconstruct_1 = require("../../reconstruct/reconstruct");
 const auto_select_defaults_1 = require("../../reconstruct/auto-select/auto-select-defaults");
 const info_1 = require("./info");
 const model_1 = require("../../r-bridge/lang-4.x/ast/model/model");
+const mermaid_1 = require("./mermaid");
 exports.MermaidEntryPointDefaultMarkStyle = 'stroke:cyan,stroke-width:6.5px;';
 exports.MermaidExitPointDefaultMarkStyle = 'stroke:green,stroke-width:6.5px;';
 function getLexeme(n) {
@@ -18,7 +18,7 @@ function cfgOfNode(vert, normalizedVertex, id, content, output) {
     if (normalizedVertex && content !== undefined) {
         const start = control_flow_graph_1.CfgVertex.isExpression(vert) ? '([' : '[';
         const end = control_flow_graph_1.CfgVertex.isExpression(vert) ? '])' : ']';
-        const name = `"\`${(0, mermaid_1.escapeMarkdown)(normalizedVertex.type)} (${id})${content ? '\n' + (0, mermaid_1.escapeMarkdown)(JSON.stringify(content)) : ''}${control_flow_graph_1.CfgVertex.getCallTargets(vert) ? '\n calls:' + (0, mermaid_1.escapeMarkdown)(JSON.stringify([...control_flow_graph_1.CfgVertex.getCallTargets(vert)])) : ''}\`"`;
+        const name = `"\`${mermaid_1.Mermaid.escape(normalizedVertex.type)} (${id})${content ? '\n' + mermaid_1.Mermaid.escape(JSON.stringify(content)) : ''}${control_flow_graph_1.CfgVertex.getCallTargets(vert) ? '\n calls:' + mermaid_1.Mermaid.escape(JSON.stringify([...control_flow_graph_1.CfgVertex.getCallTargets(vert)])) : ''}\`"`;
         output += `    n${id}${start}${name}${end}\n`;
     }
     else {
@@ -83,7 +83,7 @@ function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify
                 }
                 const ids = elems?.map(control_flow_graph_1.CfgVertex.getId) ?? [];
                 const reconstruct = limitTo((0, reconstruct_1.reconstructToCode)(normalizedAst, { nodes: new Set(ids) }, auto_select_defaults_1.doNotAutoSelect).code, basicBlockCharacterLimit);
-                const name = `"\`${includeBasicBlockLabel ? `Basic Block (${id})\n` : ''}${(0, mermaid_1.escapeMarkdown)(reconstruct)}\`"`;
+                const name = `"\`${includeBasicBlockLabel ? `Basic Block (${id})\n` : ''}${mermaid_1.Mermaid.escape(reconstruct)}\`"`;
                 output += `    n${id}[[${name}]]\n`;
                 diagramIncludedIds.add(control_flow_graph_1.CfgVertex.getId(vertex));
             }
@@ -130,7 +130,7 @@ function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify
             const isCd = control_flow_graph_1.CfgEdge.isControlDependency(edge);
             const edgeType = isCd ? '-->' : '-.->';
             const edgeSuffix = isCd ? ` (${control_flow_graph_1.CfgEdge.unpackWhen(edge)})` : '';
-            output += `    n${from} ${edgeType}|"${(0, mermaid_1.escapeMarkdown)(control_flow_graph_1.CfgEdge.typeToString(edge))}${edgeSuffix}"| n${to}\n`;
+            output += `    n${from} ${edgeType}|"${mermaid_1.Mermaid.escape(control_flow_graph_1.CfgEdge.typeToString(edge))}${edgeSuffix}"| n${to}\n`;
         }
     }
     for (const entryPoint of cfg.entryPoints) {
@@ -156,7 +156,7 @@ function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify
  * Use mermaid to visualize the normalized AST.
  */
 function cfgToMermaidUrl(cfg, normalizedAst, info) {
-    return (0, mermaid_1.mermaidCodeToUrl)(cfgToMermaid(cfg, normalizedAst, info ?? {}));
+    return mermaid_1.Mermaid.codeToUrl(cfgToMermaid(cfg, normalizedAst, info ?? {}));
 }
 /**
  * Limits a string to n chars, after which the remainder will be replaced with ...

package/util/mermaid/dfg.d.ts

@@ -3,7 +3,11 @@ import { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { type IdentifierDefinition } from '../../dataflow/environments/identifier';
 import { type DataflowGraphVertexInfo } from '../../dataflow/graph/vertex';
 import { type MermaidMarkdownMark, type MermaidMarkStyle } from './info';
-interface MermaidGraph {
+import { DataflowInformation } from '../../dataflow/info';
+/**
+ * Internal representation of a mermaid graph in flowR
+ */
+export interface MermaidGraph {
     nodeLines: string[];
     edgeLines: string[];
     includeEnvironments: boolean;
@@ -27,7 +31,7 @@ export declare function mermaidNodeBrackets(tag: DataflowGraphVertexInfo['tag'])
  * Prints an identifier definition in a human-readable format.
  */
 export declare function printIdentifier(id: IdentifierDefinition): string;
-interface MermaidGraphConfiguration {
+export interface MermaidGraphConfiguration {
     graph: DataflowGraph;
     prefix?: string | null;
     idPrefix?: string;
@@ -39,21 +43,6 @@ interface MermaidGraphConfiguration {
     simplified?: boolean;
     includeOnlyIds?: ReadonlySet<NodeId>;
 }
-/**
- * Converts a dataflow graph to mermaid graph code that visualizes the graph.
- */
-export declare function graphToMermaid(config: MermaidGraphConfiguration): {
-    string: string;
-    mermaid: MermaidGraph;
-};
-/**
- * Converts a dataflow graph to a mermaid url that visualizes the graph.
- * @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 simplified          - Whether to simplify the graph
- */
-export declare function graphToMermaidUrl(graph: DataflowGraph, includeEnvironments?: boolean, mark?: ReadonlySet<NodeId>, simplified?: boolean): string;
 export interface LabeledDiffGraph {
     label: string;
     graph: DataflowGraph;
@@ -65,4 +54,30 @@ export declare function diffGraphsToMermaid(left: LabeledDiffGraph, right: Label
  * Converts two dataflow graphs to a mermaid url that visualizes their differences.
  */
 export declare function diffGraphsToMermaidUrl(left: LabeledDiffGraph, right: LabeledDiffGraph, prefix: string): string;
-export {};
+/**
+ * The helper object for all things regarding the mermaid based visualization of dataflow graphs!
+ */
+export declare const DataflowMermaid: {
+    readonly name: "DataflowMermaid";
+    /**
+     * Converts a dataflow graph to mermaid graph code that visualizes the graph.
+     * @see {@link DataflowMermaid.url} - render the given graph to a url to mermaid.live
+     */
+    readonly convert: (this: void, config: MermaidGraphConfiguration) => {
+        string: string;
+        mermaid: MermaidGraph;
+    };
+    /**
+     * This is a simplified version of {@link DataflowMermaid.convertToMermaid}
+     */
+    readonly raw: (this: void, graph: DataflowGraph | DataflowInformation, includeEnvironments?: boolean, mark?: ReadonlySet<NodeId>, simplified?: boolean) => string;
+    /**
+     * Converts a dataflow graph to a mermaid url that visualizes the graph.
+     * This is basically a combination of {@link DataflowMermaid.mermaidRaw} and {@link Mermaid.codeToUrl}.
+     * @param graph               - the dataflow graph to render
+     * @param includeEnvironments - whether to include the environment content in the output
+     * @param mark                - which vertices to highlight in the visualization
+     * @param simplified          - whether to show a simplified use of the graph with fewer details on the vertices and edges
+     */
+    readonly url: (this: void, graph: DataflowGraph | DataflowInformation, includeEnvironments?: boolean, mark?: ReadonlySet<NodeId>, simplified?: boolean) => string;
+};