@eagleoutice/flowr 1.3.11

package/util/files.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import { RParseRequestFromFile } from '../r-bridge';
+/**
+ * Represents a table, identified by a header and a list of rows.
+ */
+export interface Table {
+    header: string[];
+    rows: string[][];
+}
+/**
+ * Retrieves all files in the given directory recursively
+ * @param dir    - Directory-path to start the search from
+ * @param suffix - Suffix of the files to be retrieved
+ * Based on {@link https://stackoverflow.com/a/45130990}
+ */
+export declare function getAllFiles(dir: string, suffix?: RegExp): AsyncGenerator<string>;
+/**
+ * Retrieves all R files in a given directory (asynchronously)
+ *
+ *
+ * @param input - directory-path to start the search from, can be a file as well. Will just return the file then.
+ * @param limit - limit the number of files to be retrieved
+ *
+ * @returns Number of files processed (normally &le; `limit`, is &ge; `limit` if limit was reached).
+ *          Will be `1`, if `input` is an R file (and `0` if it isn't).
+ *
+ * @see getAllFiles
+ */
+export declare function allRFiles(input: string, limit?: number): AsyncGenerator<RParseRequestFromFile, number>;
+/**
+ * Retrieves all R files in a given set of directories and files (asynchronously)
+ *
+ * @param inputs - Files or directories to validate for R-files
+ * @param limit  - Limit the number of files to be retrieved
+ * @returns Number of files processed (&le; limit)
+ *
+ * @see allRFiles
+ */
+export declare function allRFilesFrom(inputs: string[], limit?: number): AsyncGenerator<RParseRequestFromFile, number>;
+export declare function writeTableAsCsv(table: Table, file: string, sep?: string, newline?: string): void;
+/**
+ * Reads a file line by line and calls the given function for each line.
+ * The `lineNumber` starts at `0`.
+ *
+ * See {@link readLineByLineSync} for a synchronous version.
+ */
+export declare function readLineByLine(filePath: string, onLine: (line: Buffer, lineNumber: number) => Promise<void>): Promise<void>;
+/**
+ * Reads a file line by line and calls the given function for each line.
+ * The `lineNumber` starts at `0`.
+ *
+ * See {@link readLineByLine} for an asynchronous version.
+ */
+export declare function readLineByLineSync(filePath: string, onLine: (line: Buffer, lineNumber: number) => void): void;

package/util/files.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readLineByLineSync = exports.readLineByLine = exports.writeTableAsCsv = exports.allRFilesFrom = exports.allRFiles = exports.getAllFiles = void 0;
+const fs_1 = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const log_1 = require("./log");
+const n_readlines_1 = __importDefault(require("n-readlines"));
+/**
+ * Retrieves all files in the given directory recursively
+ * @param dir    - Directory-path to start the search from
+ * @param suffix - Suffix of the files to be retrieved
+ * Based on {@link https://stackoverflow.com/a/45130990}
+ */
+async function* getAllFiles(dir, suffix = /.*/) {
+    const entries = await fs_1.promises.readdir(dir, { withFileTypes: true, recursive: false });
+    for (const subEntries of entries) {
+        const res = path_1.default.resolve(dir, subEntries.name);
+        if (subEntries.isDirectory()) {
+            yield* getAllFiles(res, suffix);
+        }
+        else if (suffix.test(subEntries.name)) {
+            yield res;
+        }
+    }
+}
+exports.getAllFiles = getAllFiles;
+const rFileRegex = /\.[rR]$/;
+/**
+ * Retrieves all R files in a given directory (asynchronously)
+ *
+ *
+ * @param input - directory-path to start the search from, can be a file as well. Will just return the file then.
+ * @param limit - limit the number of files to be retrieved
+ *
+ * @returns Number of files processed (normally ≤ `limit`, is ≥ `limit` if limit was reached).
+ *          Will be `1`, if `input` is an R file (and `0` if it isn't).
+ *
+ * @see getAllFiles
+ */
+async function* allRFiles(input, limit = Number.MAX_VALUE) {
+    let count = 0;
+    if (fs_1.default.statSync(input).isFile()) {
+        if (rFileRegex.test(input)) {
+            yield { request: 'file', content: input };
+            return 1;
+        }
+        log_1.log.warn(`Input ${input} is not an R file`);
+        return 0;
+    }
+    for await (const f of getAllFiles(input, rFileRegex)) {
+        if (++count > limit) {
+            return count;
+        }
+        yield { request: 'file', content: f };
+    }
+    return count;
+}
+exports.allRFiles = allRFiles;
+/**
+ * Retrieves all R files in a given set of directories and files (asynchronously)
+ *
+ * @param inputs - Files or directories to validate for R-files
+ * @param limit  - Limit the number of files to be retrieved
+ * @returns Number of files processed (≤ limit)
+ *
+ * @see allRFiles
+ */
+async function* allRFilesFrom(inputs, limit) {
+    limit ??= Number.MAX_VALUE;
+    if (inputs.length === 0) {
+        log_1.log.info('No inputs given, nothing to do');
+        return 0;
+    }
+    let count = 0;
+    for (const input of inputs) {
+        count += yield* allRFiles(input, limit - count);
+    }
+    return count;
+}
+exports.allRFilesFrom = allRFilesFrom;
+function writeTableAsCsv(table, file, sep = ',', newline = '\n') {
+    const csv = [table.header.join(sep), ...table.rows.map(row => row.join(sep))].join(newline);
+    fs_1.default.writeFileSync(file, csv);
+}
+exports.writeTableAsCsv = writeTableAsCsv;
+/**
+ * Reads a file line by line and calls the given function for each line.
+ * The `lineNumber` starts at `0`.
+ *
+ * See {@link readLineByLineSync} for a synchronous version.
+ */
+async function readLineByLine(filePath, onLine) {
+    const reader = new n_readlines_1.default(filePath);
+    let line;
+    let counter = 0;
+    // eslint-disable-next-line no-cond-assign
+    while (line = reader.next()) {
+        await onLine(line, counter++);
+    }
+}
+exports.readLineByLine = readLineByLine;
+/**
+ * Reads a file line by line and calls the given function for each line.
+ * The `lineNumber` starts at `0`.
+ *
+ * See {@link readLineByLine} for an asynchronous version.
+ */
+function readLineByLineSync(filePath, onLine) {
+    const reader = new n_readlines_1.default(filePath);
+    let line;
+    let counter = 0;
+    // eslint-disable-next-line no-cond-assign
+    while (line = reader.next()) {
+        onLine(line, counter++);
+    }
+}
+exports.readLineByLineSync = readLineByLineSync;
+//# sourceMappingURL=files.js.map

package/util/json.d.ts

@@ -0,0 +1,2 @@
+export declare function jsonReplacer(key: any, value: any): any;
+export declare function jsonRetriever(key: string, value: unknown): unknown;

package/util/json.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonRetriever = exports.jsonReplacer = void 0;
+// to get the types within JSON.stringify
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function jsonReplacer(key, value) {
+    if (value instanceof Map || value instanceof Set) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return [...value];
+    }
+    else if (typeof value === 'bigint') {
+        return `${value.toString()}n`;
+    }
+    else {
+        return value;
+    }
+}
+exports.jsonReplacer = jsonReplacer;
+function jsonRetriever(key, value) {
+    if (typeof value === 'string' && value.endsWith('n')) {
+        return BigInt(value.slice(0, -1));
+    }
+    else {
+        return value;
+    }
+}
+exports.jsonRetriever = jsonRetriever;
+//# sourceMappingURL=json.js.map

package/util/log.d.ts

@@ -0,0 +1,22 @@
+import { type ILogObj, type ISettingsParam, Logger } from 'tslog';
+import { type Options } from 'rotating-file-stream';
+export declare class FlowrLogger extends Logger<ILogObj> {
+    /** by keeping track of all children we can propagate updates of the settings (e.g., in tests) */
+    private readonly childLoggers;
+    getSubLogger(settings?: ISettingsParam<ILogObj>, logObj?: ILogObj): Logger<ILogObj>;
+    updateSettings(updater: (logger: Logger<ILogObj>) => void): void;
+    /**
+   * make the logger log to a file as well
+   */
+    logToFile(filename?: string, options?: Options): void;
+}
+export declare const enum LogLevel {
+    Silly = 0,
+    Trace = 1,
+    Debug = 2,
+    Info = 3,
+    Warn = 4,
+    Error = 5,
+    Fatal = 6
+}
+export declare const log: FlowrLogger;

package/util/log.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.FlowrLogger = void 0;
+const tslog_1 = require("tslog");
+const rotating_file_stream_1 = require("rotating-file-stream");
+class FlowrLogger extends tslog_1.Logger {
+    /** by keeping track of all children we can propagate updates of the settings (e.g., in tests) */
+    childLoggers = [];
+    getSubLogger(settings, logObj) {
+        const newSubLogger = super.getSubLogger(settings, logObj);
+        this.childLoggers.push(newSubLogger);
+        return newSubLogger;
+    }
+    updateSettings(updater) {
+        updater(this);
+        this.childLoggers.forEach((child) => {
+            updater(child);
+        });
+    }
+    /**
+   * make the logger log to a file as well
+   */
+    logToFile(filename = 'flowr.log', options = {
+        size: '10M',
+        interval: '1d',
+        compress: 'gzip',
+    }) {
+        const stream = (0, rotating_file_stream_1.createStream)(filename, options);
+        exports.log.attachTransport((logObj) => {
+            stream.write(`${JSON.stringify(logObj)}\n`);
+        });
+    }
+}
+exports.FlowrLogger = FlowrLogger;
+function getActiveLog() {
+    return new FlowrLogger({
+        type: 'pretty',
+        name: 'main',
+        stylePrettyLogs: true,
+        prettyLogStyles: {
+            logLevelName: {
+                '*': ['bold', 'black', 'dim']
+            }
+        }
+    });
+}
+exports.log = getActiveLog();
+//# sourceMappingURL=log.js.map

package/util/mermaid/ast.d.ts

@@ -0,0 +1,6 @@
+import { RNodeWithParent } from '../../r-bridge';
+export declare function normalizedAstToMermaid(ast: RNodeWithParent, prefix?: string): string;
+/**
+ * Use mermaid to visualize the normalized AST.
+ */
+export declare function normalizedAstToMermaidUrl(ast: RNodeWithParent, prefix?: string): string;

package/util/mermaid/ast.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizedAstToMermaidUrl = exports.normalizedAstToMermaid = void 0;
+const r_bridge_1 = require("../../r-bridge");
+const mermaid_1 = require("./mermaid");
+function normalizedAstToMermaid(ast, prefix = '') {
+    let output = prefix + 'flowchart TD\n';
+    (0, r_bridge_1.visitAst)(ast, n => {
+        const name = `${n.type} (${n.info.id})\\n${n.lexeme ?? ' '}`;
+        output += `    n${n.info.id}(["${(0, mermaid_1.escapeMarkdown)(name)}"])\n`;
+        if (n.info.parent !== undefined) {
+            const context = n.info;
+            const roleSuffix = context.role === "expr-list-child" /* RoleInParent.ExpressionListChild */ || context.role === "call-argument" /* RoleInParent.FunctionCallArgument */ || context.role === "function-def-param" /* RoleInParent.FunctionDefinitionParameter */ ? `-${context.index}` : '';
+            output += `    n${n.info.parent} -->|"${context.role}${roleSuffix}"| n${n.info.id}\n`;
+        }
+        return false;
+    });
+    return output;
+}
+exports.normalizedAstToMermaid = normalizedAstToMermaid;
+/**
+ * Use mermaid to visualize the normalized AST.
+ */
+function normalizedAstToMermaidUrl(ast, prefix = '') {
+    return (0, mermaid_1.mermaidCodeToUrl)(normalizedAstToMermaid(ast, prefix));
+}
+exports.normalizedAstToMermaidUrl = normalizedAstToMermaidUrl;
+//# sourceMappingURL=ast.js.map

package/util/mermaid/cfg.d.ts

@@ -0,0 +1,7 @@
+import { NormalizedAst } from '../../r-bridge';
+import { ControlFlowInformation } from '../cfg';
+export declare function cfgToMermaid(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, prefix?: string): string;
+/**
+ * Use mermaid to visualize the normalized AST.
+ */
+export declare function cfgToMermaidUrl(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, prefix?: string): string;

package/util/mermaid/cfg.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cfgToMermaidUrl = exports.cfgToMermaid = void 0;
+const mermaid_1 = require("./mermaid");
+function getLexeme(n) {
+    return n ? n.info.fullLexeme ?? n.lexeme ?? '<unknown>' : '';
+}
+function cfgToMermaid(cfg, normalizedAst, prefix = '') {
+    let output = prefix + 'flowchart TD\n';
+    for (const [id, vertex] of cfg.graph.vertices()) {
+        const normalizedVertex = normalizedAst.idMap.get(id);
+        const content = getLexeme(normalizedVertex);
+        if (content.length > 0) {
+            const name = `"\`${(0, mermaid_1.escapeMarkdown)(vertex.name)} (${id})\n${(0, mermaid_1.escapeMarkdown)(JSON.stringify(content))}\`"`;
+            output += `    n${id}[${name}]\n`;
+        }
+        else {
+            output += `    n${id}(( ))\n`;
+        }
+    }
+    for (const [from, targets] of cfg.graph.edges()) {
+        for (const [to, edge] of targets) {
+            const edgeType = edge.label === 'CD' ? '-->' : '-.->';
+            const edgeSuffix = edge.label === 'CD' ? ` (${edge.when})` : '';
+            output += `    n${from} ${edgeType}|"${(0, mermaid_1.escapeMarkdown)(edge.label)}${edgeSuffix}"| n${to}\n`;
+        }
+    }
+    for (const entryPoint of cfg.entryPoints) {
+        output += `    style n${entryPoint} stroke:cyan,stroke-width:6.5px;`;
+    }
+    for (const exitPoint of cfg.exitPoints) {
+        output += `    style n${exitPoint} stroke:green,stroke-width:6.5px;`;
+    }
+    return output;
+}
+exports.cfgToMermaid = cfgToMermaid;
+/**
+ * Use mermaid to visualize the normalized AST.
+ */
+function cfgToMermaidUrl(cfg, normalizedAst, prefix = '') {
+    return (0, mermaid_1.mermaidCodeToUrl)(cfgToMermaid(cfg, normalizedAst, prefix));
+}
+exports.cfgToMermaidUrl = cfgToMermaidUrl;
+//# sourceMappingURL=cfg.js.map

package/util/mermaid/dfg.d.ts

@@ -0,0 +1,21 @@
+import { NodeId } from '../../r-bridge';
+import { SourceRange } from '../range';
+import { DataflowGraph, DataflowMap } from '../../dataflow';
+export declare function formatRange(range: SourceRange | undefined): string;
+export declare function graphToMermaid(graph: DataflowGraph, dataflowIdMap: DataflowMap | undefined, prefix?: string | null, idPrefix?: string, includeEnvironments?: boolean, mark?: Set<NodeId>, rootGraph?: DataflowGraph): string;
+/**
+ * Converts a dataflow graph to a mermaid url that visualizes the graph.
+ *
+ * @param graph         - The graph to convert
+ * @param dataflowIdMap - ID map to use to get access to the graph id mappings
+ * @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)
+ */
+export declare function graphToMermaidUrl(graph: DataflowGraph, dataflowIdMap: DataflowMap, includeEnvironments?: boolean, mark?: Set<NodeId>): string;
+export interface LabeledDiffGraph {
+    label: string;
+    graph: DataflowGraph;
+}
+/** uses same id map but ensures, it is different from the rhs so that mermaid can work with that */
+export declare function diffGraphsToMermaid(left: LabeledDiffGraph, right: LabeledDiffGraph, dataflowIdMap: DataflowMap | undefined, prefix: string): string;
+export declare function diffGraphsToMermaidUrl(left: LabeledDiffGraph, right: LabeledDiffGraph, dataflowIdMap: DataflowMap | undefined, prefix: string): string;

package/util/mermaid/dfg.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffGraphsToMermaidUrl = exports.diffGraphsToMermaid = exports.graphToMermaidUrl = exports.graphToMermaid = exports.formatRange = void 0;
+const dataflow_1 = require("../../dataflow");
+const assert_1 = require("../assert");
+const json_1 = require("../json");
+const mermaid_1 = require("./mermaid");
+function formatRange(range) {
+    if (range === undefined) {
+        return '??';
+    }
+    return `${range.start.line}.${range.start.column}-${range.end.line}.${range.end.column}`;
+}
+exports.formatRange = formatRange;
+function scopeToMermaid(scope, when) {
+    const whenText = when === 'always' ? '' : `, ${when}`;
+    return `, *${scope.replace('<', '#lt;')}${whenText}*`;
+}
+function createArtificialExitPoints(exitPoints, mermaid, dataflowIdMap, idPrefix) {
+    for (const exitPoint of exitPoints) {
+        if (!mermaid.rootGraph.hasNode(exitPoint, true)) {
+            const node = dataflowIdMap.get(exitPoint);
+            (0, assert_1.guard)(node !== undefined, 'exit point not found');
+            mermaid.nodeLines.push(` ${idPrefix}${exitPoint}{{"${node.lexeme ?? '??'} (${exitPoint})\n      ${formatRange(dataflowIdMap.get(exitPoint)?.location)}"}}`);
+        }
+        mermaid.nodeLines.push(`    style ${idPrefix}${exitPoint} stroke-width:6.5px;`);
+    }
+}
+function subflowToMermaid(nodeId, exitPoints, subflow, dataflowIdMap, mermaid, idPrefix = '') {
+    if (subflow === undefined) {
+        return;
+    }
+    const subflowId = `${idPrefix}flow-${nodeId}`;
+    mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
+    const subgraph = graphToMermaidGraph(subflow.graph, mermaid.rootGraph, dataflowIdMap, null, idPrefix, mermaid.includeEnvironments, mermaid.mark, mermaid.rootGraph);
+    mermaid.nodeLines.push(...subgraph.nodeLines);
+    mermaid.edgeLines.push(...subgraph.edgeLines);
+    for (const [color, pool] of [['purple', subflow.in], ['green', subflow.out], ['orange', subflow.unknownReferences]]) {
+        for (const out of pool) {
+            if (!mermaid.mark?.has(out.nodeId)) {
+                // in/out/active for unmarked
+                mermaid.nodeLines.push(`    style ${idPrefix}${out.nodeId} stroke:${color},stroke-width:4px; `);
+            }
+        }
+    }
+    if (dataflowIdMap !== undefined) {
+        createArtificialExitPoints(exitPoints, mermaid, dataflowIdMap, idPrefix);
+    }
+    mermaid.nodeLines.push('end');
+    mermaid.edgeLines.push(`${idPrefix}${nodeId} -.-|function| ${subflowId}\n`);
+}
+function printArg(arg) {
+    if (arg === 'empty') {
+        return '';
+    }
+    if (arg === undefined || arg === '<value>') {
+        return '??';
+    }
+    return `${arg.nodeId}`;
+}
+function displayFunctionArgMapping(argMapping) {
+    const result = [];
+    for (const arg of argMapping) {
+        result.push(Array.isArray(arg) ? `${arg[0]} -> ${printArg(arg[1])}` : `${printArg(arg)}`);
+    }
+    return result.length === 0 ? '' : `\n    (${result.join(', ')})`;
+}
+function encodeEdge(from, to, types, attribute) {
+    // sort from and to for same edges and relates be order independent
+    if (types.has(dataflow_1.EdgeType.SameReadRead) || types.has(dataflow_1.EdgeType.SameDefDef) || types.has(dataflow_1.EdgeType.Relates)) {
+        if (from > to) {
+            ({ from, to } = { from: to, to: from });
+        }
+    }
+    return `${from}->${to}["${[...types].join(':')} (${attribute})"]`;
+}
+function mermaidNodeBrackets(def, fCall) {
+    let open;
+    let close;
+    if (def) {
+        open = '[';
+        close = ']';
+    }
+    else if (fCall) {
+        open = '[[';
+        close = ']]';
+    }
+    else {
+        open = '([';
+        close = '])';
+    }
+    return { open, close };
+}
+function nodeToMermaid(graph, info, mermaid, id, idPrefix, dataflowIdMap, mark) {
+    const def = info.tag === 'variable-definition' || info.tag === 'function-definition';
+    const fCall = info.tag === 'function-call';
+    const defText = def ? scopeToMermaid(info.scope, info.when) : '';
+    const { open, close } = mermaidNodeBrackets(def, fCall);
+    if (mermaid.includeEnvironments) {
+        mermaid.nodeLines.push(`    %% ${id}: ${JSON.stringify(info.environment, json_1.jsonReplacer)}`);
+    }
+    mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${(0, mermaid_1.escapeMarkdown)(info.name)} (${id}${defText})\n      *${formatRange(dataflowIdMap?.get(id)?.location)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
+    if (mark?.has(id)) {
+        mermaid.nodeLines.push(`    style ${idPrefix}${id} stroke:black,stroke-width:7px; `);
+    }
+    const edges = mermaid.rootGraph.get(id, true);
+    (0, assert_1.guard)(edges !== undefined, `node ${id} must be found`);
+    for (const [target, edge] of [...edges[1]]) {
+        const dotEdge = edge.types.has(dataflow_1.EdgeType.SameDefDef) || edge.types.has(dataflow_1.EdgeType.SameReadRead) || edge.types.has(dataflow_1.EdgeType.Relates);
+        const edgeId = encodeEdge(idPrefix + id, idPrefix + target, edge.types, edge.attribute);
+        if (!mermaid.presentEdges.has(edgeId)) {
+            mermaid.presentEdges.add(edgeId);
+            mermaid.edgeLines.push(`    ${idPrefix}${id} ${dotEdge ? '-.-' : '-->'}|"${[...edge.types].join(', ')} (${edge.attribute})"| ${idPrefix}${target}`);
+            if (target === dataflow_1.BuiltIn) {
+                mermaid.hasBuiltIn = true;
+            }
+        }
+    }
+    if (info.tag === 'function-definition') {
+        subflowToMermaid(id, info.exitPoints, info.subflow, dataflowIdMap, mermaid, idPrefix);
+    }
+}
+// make the passing of root ids more performant again
+function graphToMermaidGraph(rootIds, graph, dataflowIdMap, prefix = 'flowchart TD', idPrefix = '', includeEnvironments = true, mark, rootGraph) {
+    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges: new Set(), hasBuiltIn: false, mark, rootGraph: rootGraph ?? graph, includeEnvironments };
+    for (const [id, info] of graph.vertices(true)) {
+        if (rootIds.has(id)) {
+            nodeToMermaid(graph, info, mermaid, id, idPrefix, dataflowIdMap, mark);
+        }
+    }
+    if (mermaid.hasBuiltIn) {
+        mermaid.nodeLines.push(`    ${idPrefix}${dataflow_1.BuiltIn}["Built-in"]`);
+    }
+    return mermaid;
+}
+function graphToMermaid(graph, dataflowIdMap, prefix = 'flowchart TD', idPrefix = '', includeEnvironments, mark, rootGraph) {
+    const mermaid = graphToMermaidGraph(graph.rootIds(), graph, dataflowIdMap, prefix, idPrefix, includeEnvironments, mark, rootGraph);
+    return `${mermaid.nodeLines.join('\n')}\n${mermaid.edgeLines.join('\n')}`;
+}
+exports.graphToMermaid = graphToMermaid;
+/**
+ * Converts a dataflow graph to a mermaid url that visualizes the graph.
+ *
+ * @param graph         - The graph to convert
+ * @param dataflowIdMap - ID map to use to get access to the graph id mappings
+ * @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)
+ */
+function graphToMermaidUrl(graph, dataflowIdMap, includeEnvironments, mark) {
+    return (0, mermaid_1.mermaidCodeToUrl)(graphToMermaid(graph, dataflowIdMap, undefined, undefined, includeEnvironments, mark));
+}
+exports.graphToMermaidUrl = graphToMermaidUrl;
+/** uses same id map but ensures, it is different from the rhs so that mermaid can work with that */
+function diffGraphsToMermaid(left, right, dataflowIdMap, prefix) {
+    // we add the prefix ourselves
+    const leftGraph = graphToMermaid(left.graph, dataflowIdMap, '', `l-${left.label}`);
+    const rightGraph = graphToMermaid(right.graph, dataflowIdMap, '', `r-${right.label}`);
+    return `${prefix}flowchart TD\nsubgraph "${left.label}"\n${leftGraph}\nend\nsubgraph "${right.label}"\n${rightGraph}\nend`;
+}
+exports.diffGraphsToMermaid = diffGraphsToMermaid;
+function diffGraphsToMermaidUrl(left, right, dataflowIdMap, prefix) {
+    return (0, mermaid_1.mermaidCodeToUrl)(diffGraphsToMermaid(left, right, dataflowIdMap, prefix));
+}
+exports.diffGraphsToMermaidUrl = diffGraphsToMermaidUrl;
+//# sourceMappingURL=dfg.js.map

package/util/mermaid/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ast';
+export * from './cfg';
+export * from './dfg';

package/util/mermaid/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ast"), exports);
+__exportStar(require("./cfg"), exports);
+__exportStar(require("./dfg"), exports);
+//# sourceMappingURL=index.js.map

package/util/mermaid/mermaid.d.ts

@@ -0,0 +1,7 @@
+export declare function escapeMarkdown(text: string): string;
+/**
+ * Converts mermaid code (potentially produced by {@link graphToMermaid}) to an url that presents the graph in the mermaid editor.
+ *
+ * @param code - code to convert
+ */
+export declare function mermaidCodeToUrl(code: string): string;

package/util/mermaid/mermaid.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mermaidCodeToUrl = exports.escapeMarkdown = void 0;
+function escapeMarkdown(text) {
+    return text.replaceAll(/([+*])/g, '\\$1').replaceAll('"', '\'\'');
+}
+exports.escapeMarkdown = escapeMarkdown;
+/**
+ * Converts mermaid code (potentially produced by {@link graphToMermaid}) to an url that presents the graph in the mermaid editor.
+ *
+ * @param code - code to convert
+ */
+function mermaidCodeToUrl(code) {
+    const obj = {
+        code,
+        mermaid: {},
+        updateEditor: false,
+        autoSync: true,
+        updateDiagram: false
+    };
+    return `https://mermaid.live/edit#base64:${Buffer.from(JSON.stringify(obj)).toString('base64')}`;
+}
+exports.mermaidCodeToUrl = mermaidCodeToUrl;
+//# sourceMappingURL=mermaid.js.map

package/util/numbers.d.ts

@@ -0,0 +1 @@
+export declare function bigint2number(a: bigint | string): number;

package/util/numbers.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigint2number = void 0;
+function bigint2number(a) {
+    // we have to remove the trailing `n`
+    return Number(String(a).slice(0, -1));
+}
+exports.bigint2number = bigint2number;
+//# sourceMappingURL=numbers.js.map