@eagleoutice/flowr 2.9.13 → 2.10.1

package/util/collections/arrays.d.ts

@@ -92,6 +92,10 @@ export declare function equidistantSampling<T>(list: readonly T[], sampleCount:
 export declare function cartesianProduct<T>(...arrays: T[][]): T[][];
 /** merge two arrays, removing duplicates */
 export declare function uniqueArrayMerge<T>(left: readonly T[], right: readonly T[]): T[];
+/**
+ * Returns a duplicate-free array.
+ */
+export declare function uniqueArray<T>(a: Iterable<T>): T[];
 /**
  * Groups the elements of the given array by the key returned by the given key function.
  */

package/util/collections/arrays.js

@@ -11,6 +11,7 @@ exports.arrayEqual = arrayEqual;
 exports.equidistantSampling = equidistantSampling;
 exports.cartesianProduct = cartesianProduct;
 exports.uniqueArrayMerge = uniqueArrayMerge;
+exports.uniqueArray = uniqueArray;
 exports.arraysGroupBy = arraysGroupBy;
 const assert_1 = require("../assert");
 /**
@@ -227,6 +228,12 @@ function uniqueArrayMerge(left, right) {
     }
     return Array.from(result);
 }
+/**
+ * Returns a duplicate-free array.
+ */
+function uniqueArray(a) {
+    return Array.from(new Set(a));
+}
 /**
  * Groups the elements of the given array by the key returned by the given key function.
  */

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;
+};

package/util/mermaid/dfg.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataflowMermaid = void 0;
 exports.mermaidNodeBrackets = mermaidNodeBrackets;
 exports.printIdentifier = printIdentifier;
-exports.graphToMermaid = graphToMermaid;
-exports.graphToMermaidUrl = graphToMermaidUrl;
 exports.diffGraphsToMermaid = diffGraphsToMermaid;
 exports.diffGraphsToMermaidUrl = diffGraphsToMermaidUrl;
 const mermaid_1 = require("./mermaid");
@@ -17,18 +16,19 @@ const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const info_1 = require("./info");
 const range_1 = require("../range");
 const model_1 = require("../../r-bridge/lang-4.x/ast/model/model");
+const info_2 = require("../../dataflow/info");
 function subflowToMermaid(nodeId, subflow, mermaid, idPrefix = '') {
     if (subflow === undefined) {
         return;
     }
-    const subflowId = (0, mermaid_1.escapeId)(`${idPrefix}flow-${nodeId}`);
+    const subflowId = mermaid_1.Mermaid.escapeId(`${idPrefix}flow-${nodeId}`);
     if (mermaid.simplified) {
         // get parent
         const idMap = mermaid.rootGraph.idMap;
         const node = idMap?.get(nodeId);
         const nodeLexeme = model_1.RNode.lexeme(node) ?? 'function';
         const location = node?.location?.[0] ? ` (L. ${node?.location?.[0]})` : '';
-        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${(0, mermaid_1.escapeMarkdown)(nodeLexeme)}${location}"]`);
+        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${mermaid_1.Mermaid.escape(nodeLexeme)}${location}"]`);
     }
     else {
         mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
@@ -83,7 +83,7 @@ function printArg(arg) {
 function displayFunctionArgMapping(argMapping) {
     const result = [];
     for (const arg of argMapping) {
-        result.push((0, mermaid_1.escapeMarkdown)(printArg(arg)));
+        result.push(mermaid_1.Mermaid.escape(printArg(arg)));
     }
     return result.length === 0 ? '' : `\n    (${result.join(', ')})`;
 }
@@ -139,7 +139,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
     const fCall = info.tag === vertex_1.VertexType.FunctionCall;
     const { open, close } = mermaidNodeBrackets(info.tag);
     const origId = id;
-    id = (0, mermaid_1.escapeId)(id);
+    id = mermaid_1.Mermaid.escapeId(id);
     if (info.environment && mermaid.includeEnvironments) {
         if (info.environment.level > 0 || info.environment.current.memory.size !== 0) {
             mermaid.nodeLines.push(`    %% Environment of ${id} [level: ${info.environment.level}]:`, printEnvironmentToLines(info.environment.current).map(x => `    %% ${x}`).join('\n'));
@@ -149,15 +149,16 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
     const lexeme = node?.lexeme ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0]?.lexeme : '') ?? '??';
     if (mermaid.simplified) {
         const location = node?.location?.[0] ? ` (L. ${node?.location?.[0]})` : '';
-        const escapedName = '**' + (0, mermaid_1.escapeMarkdown)(node ? `${lexeme}` : '??') + '**' + location + (node ? `\n*${node.type}*` : '');
+        const escapedName = '**' + mermaid_1.Mermaid.escape(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 escapedName = mermaid_1.Mermaid.escape(node ? `[${node.type}] ${lexeme}` : '??');
         const deps = info.cds ? ', :may:' + info.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
         const lnks = info.link?.origin ? ', :links:' + info.link.origin.join(',') : '';
+        const sources = info.source ? ', sources: ' + JSON.stringify(info.source) : '';
         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}${lnks})\n      *${range_1.SourceRange.format(n)}*${fCall ? displayFunctionArgMapping(info.args) : '' + (info.tag === vertex_1.VertexType.FunctionDefinition && info.mode && info.mode.length > 0 ? (0, mermaid_1.escapeMarkdown)(JSON.stringify(info.mode)) : '')}\`"${close}`);
+        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps}${lnks}${sources})\n      *${range_1.SourceRange.format(n)}*${fCall ? displayFunctionArgMapping(info.args) : '' + (info.tag === vertex_1.VertexType.FunctionDefinition && info.mode && info.mode.length > 0 ? mermaid_1.Mermaid.escape(JSON.stringify(info.mode)) : '')}\`"${close}`);
     }
     if (mark?.has(id)) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} ${mermaid.markStyle.vertex} `);
@@ -180,7 +181,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
             continue;
         }
         const originalTarget = target;
-        target = (0, mermaid_1.escapeId)(target);
+        target = mermaid_1.Mermaid.escapeId(target);
         const edgeTypes = typeof edge.types == 'number' ? new Set(edge_1.DfEdge.splitTypes(edge)) : edge.types;
         const edgeId = encodeEdge(idPrefix + id, idPrefix + target, edgeTypes);
         if (!mermaid.presentEdges.has(edgeId)) {
@@ -197,7 +198,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
             if (node_id_1.NodeId.isBuiltIn(target)) {
                 mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} stroke:gray;`);
                 if (!mermaid.presentVertices.has(target)) {
-                    mermaid.nodeLines.push(`    ${idPrefix}${target}["\`Built-In:\n${(0, mermaid_1.escapeMarkdown)(String(originalTarget).replace('built-in:', ''))}\`"]`);
+                    mermaid.nodeLines.push(`    ${idPrefix}${target}["\`Built-In:\n${mermaid_1.Mermaid.escape(String(originalTarget).replace('built-in:', ''))}\`"]`);
                     mermaid.nodeLines.push(`    style ${idPrefix}${target} stroke:gray,fill:gray,stroke-width:2px,opacity:.8;`);
                     mermaid.presentVertices.add(target);
                 }
@@ -215,34 +216,49 @@ function graphToMermaidGraph(rootIds, { simplified, graph, prefix = 'flowchart B
     }
     return mermaid;
 }
-/**
- * Converts a dataflow graph to mermaid graph code that visualizes the graph.
- */
-function graphToMermaid(config) {
-    const mermaid = graphToMermaidGraph(config.includeOnlyIds ? config.includeOnlyIds : config.graph.rootIds(), config);
-    return { string: `${mermaid.nodeLines.join('\n')}\n${mermaid.edgeLines.join('\n')}`, mermaid };
-}
-/**
- * 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
- */
-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 });
+    const { string: leftGraph, mermaid } = exports.DataflowMermaid.convert({ graph: left.graph, prefix: '', idPrefix: `l-${left.label}`, includeEnvironments: true, mark: left.mark });
+    const { string: rightGraph } = exports.DataflowMermaid.convert({ graph: right.graph, prefix: '', idPrefix: `r-${right.label}`, includeEnvironments: true, mark: right.mark, presentEdges: mermaid.presentEdges });
     return `${prefix}flowchart BT\nsubgraph "${left.label}"\n${leftGraph}\nend\nsubgraph "${right.label}"\n${rightGraph}\nend`;
 }
 /**
  * Converts two dataflow graphs to a mermaid url that visualizes their differences.
  */
 function diffGraphsToMermaidUrl(left, right, prefix) {
-    return (0, mermaid_1.mermaidCodeToUrl)(diffGraphsToMermaid(left, right, prefix));
+    return mermaid_1.Mermaid.codeToUrl(diffGraphsToMermaid(left, right, prefix));
 }
+/**
+ * The helper object for all things regarding the mermaid based visualization of dataflow graphs!
+ */
+exports.DataflowMermaid = {
+    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
+     */
+    convert(config) {
+        const mermaid = graphToMermaidGraph(config.includeOnlyIds ?? config.graph.rootIds(), config);
+        return { string: `${mermaid.nodeLines.join('\n')}\n${mermaid.edgeLines.join('\n')}`, mermaid };
+    },
+    /**
+     * This is a simplified version of {@link DataflowMermaid.convertToMermaid}
+     */
+    raw(graph, includeEnvironments, mark, simplified = false) {
+        graph = info_2.DataflowInformation.is(graph) ? graph.graph : graph;
+        return exports.DataflowMermaid.convert({ graph, includeEnvironments, mark, simplified }).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
+     */
+    url(graph, includeEnvironments, mark, simplified = false) {
+        return mermaid_1.Mermaid.codeToUrl(exports.DataflowMermaid.raw(graph, includeEnvironments, mark, simplified));
+    }
+};
 //# sourceMappingURL=dfg.js.map

package/util/mermaid/mermaid.d.ts

@@ -1,14 +1,59 @@
 /**
- * Escapes markdown special characters in a string.
+ * Global mermaid helper object with useful functions.
  */
-export declare function escapeMarkdown(text: string): string;
-/**
- * Escapes a string or number to be used as a mermaid node id.
- */
-export declare function escapeId(text: string | number): 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
- * @param edit - if true, the url will point to the editor, otherwise it will point to the viewer
- */
-export declare function mermaidCodeToUrl(code: string, edit?: boolean): string;
+export declare const Mermaid: {
+    readonly name: "Mermaid";
+    /**
+     * Replacements applied by escape functions!
+     */
+    readonly replacements: {
+        readonly '\\n': "\n";
+        readonly '`': "#96;";
+        readonly '[': "#91;";
+        readonly ']': "#93;";
+        readonly '<': "#60;";
+        readonly '>': "#62;";
+        readonly '*': "#42;";
+        readonly '+': "#43;";
+        readonly '-': "#45;";
+        readonly '"': "#34;";
+        readonly '\\': "#92;";
+        readonly _: "#95;";
+        readonly '{': "#123;";
+        readonly '}': "#125;";
+        readonly '&': "#38;";
+        readonly '\'': "#39;";
+        readonly ':': "#58;";
+        readonly '\u2228': "#8744;";
+        readonly '\u2227': "#8743;";
+        readonly '\u00AC': "#172;";
+        readonly '\u2192': "#8594;";
+        readonly '\u2194': "#8596;";
+        readonly '\u21D2': "#8658;";
+        readonly '\u21D4': "#8660;";
+        readonly '\u2200': "#8704;";
+        readonly '\u2203': "#8707;";
+        readonly '\u2208': "#8712;";
+        readonly '\u2209': "#8713;";
+        readonly '\u220B': "#8715;";
+        readonly '\u220C': "#8716;";
+        readonly '\u2229': "#8745;";
+        readonly '\u222A': "#8746;";
+        readonly '\u222B': "#8747;";
+        readonly '\u2295': "#8853;";
+    };
+    /**
+     * Escapes markdown special characters in a string.
+     */
+    readonly escape: (this: void, text: string) => string;
+    /**
+     * Escapes a string or number to be used as a mermaid node id.
+     */
+    readonly escapeId: (this: void, text: string | number) => string;
+    /**
+     * Converts mermaid code (potentially produced by {@link DataflowMermaid.convert}) to an url that presents the graph in the mermaid editor.
+     * @param code - code to convert
+     * @param edit - if true, the url will point to the editor, otherwise it will point to the viewer
+     */
+    readonly codeToUrl: (this: void, code: string, edit?: boolean) => string;
+};

package/util/mermaid/mermaid.js

@@ -1,73 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeMarkdown = escapeMarkdown;
-exports.escapeId = escapeId;
-exports.mermaidCodeToUrl = mermaidCodeToUrl;
-const replacements = {
-    // keep newlines
-    '\\n': '\n',
-    '`': '#96;',
-    '[': '#91;',
-    ']': '#93;',
-    '<': '#60;',
-    '>': '#62;',
-    '*': '#42;',
-    '+': '#43;',
-    '-': '#45;',
-    '"': '#34;',
-    '\\': '#92;',
-    '_': '#95;',
-    '{': '#123;',
-    '}': '#125;',
-    '&': '#38;',
-    '\'': '#39;',
-    ':': '#58;',
-    '∨': '#8744;',
-    '∧': '#8743;',
-    '¬': '#172;',
-    '→': '#8594;',
-    '↔': '#8596;',
-    '⇒': '#8658;',
-    '⇔': '#8660;',
-    '∀': '#8704;',
-    '∃': '#8707;',
-    '∈': '#8712;',
-    '∉': '#8713;',
-    '∋': '#8715;',
-    '∌': '#8716;',
-    '∩': '#8745;',
-    '∪': '#8746;',
-    '∫': '#8747;',
-    '⊕': '#8853;',
-};
-/**
- * Escapes markdown special characters in a string.
- */
-function escapeMarkdown(text) {
-    for (const [key, value] of Object.entries(replacements)) {
-        text = text.replaceAll(key, value);
-    }
-    return text;
-}
+exports.Mermaid = void 0;
 /**
- * Escapes a string or number to be used as a mermaid node id.
+ * Global mermaid helper object with useful functions.
  */
-function escapeId(text) {
-    text = String(text).replace(/[^a-zA-Z0-9:-]/g, '_');
-    return text;
-}
-/**
- * Converts mermaid code (potentially produced by {@link graphToMermaid}) to an url that presents the graph in the mermaid editor.
- * @param code - code to convert
- * @param edit - if true, the url will point to the editor, otherwise it will point to the viewer
- */
-function mermaidCodeToUrl(code, edit = false) {
-    const obj = {
-        code,
-        mermaid: {
-            autoSync: true
+exports.Mermaid = {
+    name: 'Mermaid',
+    /**
+     * Replacements applied by escape functions!
+     */
+    replacements: {
+        // keep newlines
+        '\\n': '\n',
+        '`': '#96;',
+        '[': '#91;',
+        ']': '#93;',
+        '<': '#60;',
+        '>': '#62;',
+        '*': '#42;',
+        '+': '#43;',
+        '-': '#45;',
+        '"': '#34;',
+        '\\': '#92;',
+        '_': '#95;',
+        '{': '#123;',
+        '}': '#125;',
+        '&': '#38;',
+        '\'': '#39;',
+        ':': '#58;',
+        '∨': '#8744;',
+        '∧': '#8743;',
+        '¬': '#172;',
+        '→': '#8594;',
+        '↔': '#8596;',
+        '⇒': '#8658;',
+        '⇔': '#8660;',
+        '∀': '#8704;',
+        '∃': '#8707;',
+        '∈': '#8712;',
+        '∉': '#8713;',
+        '∋': '#8715;',
+        '∌': '#8716;',
+        '∩': '#8745;',
+        '∪': '#8746;',
+        '∫': '#8747;',
+        '⊕': '#8853;',
+    },
+    /**
+     * Escapes markdown special characters in a string.
+     */
+    escape(text) {
+        for (const [key, value] of Object.entries(exports.Mermaid.replacements)) {
+            text = text.replaceAll(key, value);
         }
-    };
-    return `https://mermaid.live/${edit ? 'edit' : 'view'}#base64:${Buffer.from(JSON.stringify(obj)).toString('base64')}`;
-}
+        return text;
+    },
+    /**
+     * Escapes a string or number to be used as a mermaid node id.
+     */
+    escapeId(text) {
+        text = String(text).replace(/[^a-zA-Z0-9:-]/g, '_');
+        return text;
+    },
+    /**
+     * Converts mermaid code (potentially produced by {@link DataflowMermaid.convert}) to an url that presents the graph in the mermaid editor.
+     * @param code - code to convert
+     * @param edit - if true, the url will point to the editor, otherwise it will point to the viewer
+     */
+    codeToUrl(code, edit = false) {
+        const obj = {
+            code,
+            mermaid: {
+                autoSync: true
+            }
+        };
+        return `https://mermaid.live/${edit ? 'edit' : 'view'}#base64:${Buffer.from(JSON.stringify(obj)).toString('base64')}`;
+    }
+};
 //# sourceMappingURL=mermaid.js.map

package/util/range.d.ts

@@ -31,6 +31,14 @@ export declare const SourcePosition: {
      * returns an invalid source position
      */
     readonly invalid: (this: void) => SourcePosition;
+    /**
+     * Returns the line of a source position
+     */
+    readonly getLine: (this: void, pos: SourcePosition) => number;
+    /**
+     * Returns the column of a source position
+     */
+    readonly getColumn: (this: void, pos: SourcePosition) => number;
 };
 /**
  * **Please note** that for multi-file projects we also have a {@link SourceLocation|source location} type that includes the file name.

package/util/range.js

@@ -31,7 +31,19 @@ exports.SourcePosition = {
      */
     invalid() {
         return [-1, -1];
-    }
+    },
+    /**
+     * Returns the line of a source position
+     */
+    getLine(pos) {
+        return pos[0];
+    },
+    /**
+     * Returns the column of a source position
+     */
+    getColumn(pos) {
+        return pos[1];
+    },
 };
 /**
  * Utility functions for {@link SourceRange|source ranges}.

package/util/slice-direction.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The direction to slice a program.
+ */
+export declare enum SliceDirection {
+    Backward = "backward",
+    Forward = "forward"
+}

package/util/slice-direction.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SliceDirection = void 0;
+/**
+ * The direction to slice a program.
+ */
+var SliceDirection;
+(function (SliceDirection) {
+    SliceDirection["Backward"] = "backward";
+    SliceDirection["Forward"] = "forward";
+})(SliceDirection || (exports.SliceDirection = SliceDirection = {}));
+//# sourceMappingURL=slice-direction.js.map