@eagleoutice/flowr 2.2.12 → 2.2.13

package/util/diff-graph.d.ts

@@ -0,0 +1,47 @@
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { GenericDiffConfiguration, GenericDifferenceInformation, WriteableDifferenceReport } from './diff';
+import type { DataflowGraph } from '../dataflow/graph/graph';
+export interface NamedGraph<Graph = DataflowGraph> {
+    name: string;
+    graph: Graph;
+}
+interface ProblematicVertex {
+    tag: 'vertex';
+    id: NodeId;
+}
+interface ProblematicEdge {
+    tag: 'edge';
+    from: NodeId;
+    to: NodeId;
+}
+export type ProblematicDiffInfo = ProblematicVertex | ProblematicEdge;
+/**
+ * To be produced by a function differencing two graphs (e.g., {@link DataflowGraph|DFGs} or {@link ControlFlowGraph|CFGs}).
+ *
+ * @see {@link GraphDifferenceReport#isEqual|isEqual} - to check whether the graphs are equal
+ * @see {@link GraphDifferenceReport#addComment|addComment} - to add comments to the report
+ * @see {@link GraphDifferenceReport#comments|comments} - to get the attached comments
+ * @see {@link GraphDifferenceReport#problematic|problematic} - to get the problematic vertices/edges
+ */
+export declare class GraphDifferenceReport implements WriteableDifferenceReport {
+    _comments: string[] | undefined;
+    _problematic: ProblematicDiffInfo[] | undefined;
+    addComment(comment: string, ...related: readonly ProblematicDiffInfo[]): void;
+    comments(): readonly string[] | undefined;
+    problematic(): readonly ProblematicDiffInfo[] | undefined;
+    isEqual(): boolean;
+}
+/**
+ * A context that can be used by differencing functions to compare two graphs
+ * See {@link initDiffContext} for a function that creates such a context.
+ */
+export interface GraphDiffContext<Graph = DataflowGraph> extends GenericDifferenceInformation<GraphDifferenceReport> {
+    left: Graph;
+    right: Graph;
+    config: GenericDiffConfiguration;
+}
+/**
+ * Create the context for differencing two graphs
+ */
+export declare function initDiffContext<Graph>(left: NamedGraph<Graph>, right: NamedGraph<Graph>, config?: Partial<GenericDiffConfiguration>): GraphDiffContext<Graph>;
+export {};

package/util/diff-graph.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphDifferenceReport = void 0;
+exports.initDiffContext = initDiffContext;
+/**
+ * To be produced by a function differencing two graphs (e.g., {@link DataflowGraph|DFGs} or {@link ControlFlowGraph|CFGs}).
+ *
+ * @see {@link GraphDifferenceReport#isEqual|isEqual} - to check whether the graphs are equal
+ * @see {@link GraphDifferenceReport#addComment|addComment} - to add comments to the report
+ * @see {@link GraphDifferenceReport#comments|comments} - to get the attached comments
+ * @see {@link GraphDifferenceReport#problematic|problematic} - to get the problematic vertices/edges
+ */
+class GraphDifferenceReport {
+    _comments = undefined;
+    _problematic = undefined;
+    addComment(comment, ...related) {
+        if (this._comments === undefined) {
+            this._comments = [comment];
+        }
+        else {
+            this._comments.push(comment);
+        }
+        if (related.length > 0) {
+            if (this._problematic === undefined) {
+                this._problematic = [...related];
+            }
+            else {
+                this._problematic.push(...related);
+            }
+        }
+    }
+    comments() {
+        return this._comments;
+    }
+    problematic() {
+        return this._problematic;
+    }
+    isEqual() {
+        return this._comments === undefined;
+    }
+}
+exports.GraphDifferenceReport = GraphDifferenceReport;
+/**
+ * Create the context for differencing two graphs
+ */
+function initDiffContext(left, right, config) {
+    return {
+        left: left.graph,
+        leftname: left.name,
+        right: right.graph,
+        rightname: right.name,
+        report: new GraphDifferenceReport(),
+        position: '',
+        config: {
+            rightIsSubgraph: false,
+            leftIsSubgraph: false,
+            ...config
+        }
+    };
+}
+//# sourceMappingURL=diff-graph.js.map

package/util/diff.d.ts

@@ -12,14 +12,14 @@ import type { MergeableRecord } from './objects';
  */
 export interface DifferenceReport {
     /**
-   * A human-readable description of differences during the comparison
-   * In combination with {@link isEqual} this can be used to provide detailed
-   * explanation on equal structures as well (e.g., if structures _could_ be equal).
-   */
+     * A human-readable description of differences during the comparison
+     * In combination with {@link isEqual} this can be used to provide detailed
+     * explanation on equal structures as well (e.g., if structures _could_ be equal).
+     */
     comments(): readonly string[] | undefined;
     /**
-   * @returns true iff the compared structures are equal (i.e., the diff is empty)
-   */
+     * @returns true iff the compared structures are equal (i.e., the diff is empty)
+     */
     isEqual(): boolean;
 }
 export interface WriteableDifferenceReport extends DifferenceReport {

package/util/diff.js

@@ -7,7 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setDifference = setDifference;
-const set_1 = require("./set");
+const set_1 = require("./collections/set");
 function setDifference(left, right, info) {
     const lWithoutR = (0, set_1.setMinus)(left, right);
     const rWithoutL = (0, set_1.setMinus)(right, left);

package/util/mermaid/cfg.d.ts

@@ -1,6 +1,13 @@
-import type { ControlFlowInformation } from '../cfg/cfg';
 import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-export declare function cfgToMermaid(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, prefix?: string): string;
+import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
+/**
+ * Convert the control flow graph to a mermaid string.
+ * @param cfg              - The control flow graph to convert.
+ * @param normalizedAst    - The normalized AST to use for the vertex content.
+ * @param prefix           - The prefix to use for the mermaid string.
+ * @param simplify         - Whether to simplify the control flow graph (especially in the context of basic blocks).
+ */
+export declare function cfgToMermaid(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, prefix?: string, simplify?: boolean): string;
 /**
  * Use mermaid to visualize the normalized AST.
  */

package/util/mermaid/cfg.js

@@ -3,27 +3,79 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cfgToMermaid = cfgToMermaid;
 exports.cfgToMermaidUrl = cfgToMermaidUrl;
 const mermaid_1 = require("./mermaid");
+const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+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");
 function getLexeme(n) {
-    return n ? n.info.fullLexeme ?? n.lexeme ?? '<unknown>' : '';
+    return n ? n.info.fullLexeme ?? n.lexeme ?? '' : undefined;
 }
-function cfgToMermaid(cfg, normalizedAst, prefix = 'flowchart BT\n') {
+function cfgOfNode(vert, normalizedVertex, id, content, output) {
+    if (normalizedVertex && content !== undefined) {
+        const start = vert.type === control_flow_graph_1.CfgVertexType.Expression ? '([' : '[';
+        const end = vert.type === control_flow_graph_1.CfgVertexType.Expression ? '])' : ']';
+        const name = `"\`${(0, mermaid_1.escapeMarkdown)(normalizedVertex.type)} (${id})${content ? '\n' + (0, mermaid_1.escapeMarkdown)(JSON.stringify(content)) : ''}${vert.callTargets ? '\n calls:' + (0, mermaid_1.escapeMarkdown)(JSON.stringify([...vert.callTargets])) : ''}\`"`;
+        output += `    n${id}${start}${name}${end}\n`;
+    }
+    else {
+        output += String(id).endsWith('-exit') ? `    n${id}((${id}))\n` : `    n${id}[[${id}]]\n`;
+    }
+    return output;
+}
+const getDirRegex = /flowchart\s+([A-Za-z]+)/;
+/**
+ * Convert the control flow graph to a mermaid string.
+ * @param cfg              - The control flow graph to convert.
+ * @param normalizedAst    - The normalized AST to use for the vertex content.
+ * @param prefix           - The prefix to use for the mermaid string.
+ * @param simplify         - Whether to simplify the control flow graph (especially in the context of basic blocks).
+ */
+function cfgToMermaid(cfg, normalizedAst, prefix = 'flowchart BT\n', simplify = false) {
     let output = prefix;
-    for (const [id, vertex] of cfg.graph.vertices()) {
-        const normalizedVertex = normalizedAst.idMap.get(id);
+    const dirIs = getDirRegex.exec(prefix)?.at(1) ?? 'LR';
+    for (const [id, vertex] of cfg.graph.vertices(false)) {
+        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`;
+        if (vertex.name === type_1.RType.ExpressionList && vertex.type === control_flow_graph_1.CfgVertexType.Expression && cfg.graph.hasVertex(id + '-exit')) {
+            output += `    subgraph ${type_1.RType.ExpressionList} ${normalizedVertex?.info.fullLexeme ?? id}\n`;
+            output += `        direction ${dirIs}\n`;
+        }
+        if (vertex.type === control_flow_graph_1.CfgVertexType.Block) {
+            if (simplify) {
+                const ids = vertex.elems?.map(e => e.id) ?? [];
+                const reconstruct = (0, reconstruct_1.reconstructToCode)(normalizedAst, new Set(ids), auto_select_defaults_1.doNotAutoSelect).code;
+                const name = `"\`Basic Block (${id})\n${(0, mermaid_1.escapeMarkdown)(reconstruct)}\`"`;
+                output += `    n${id}[[${name}]]\n`;
+            }
+            else {
+                output += `    subgraph n${vertex.id} [Block ${normalizedVertex?.info.fullLexeme ?? id}]\n`;
+                output += `        direction ${dirIs}\n`;
+                let last = undefined;
+                for (const element of vertex.elems ?? []) {
+                    const childNormalizedVertex = normalizedAst?.idMap.get(element.id);
+                    const childContent = getLexeme(childNormalizedVertex);
+                    output = cfgOfNode(vertex, childNormalizedVertex, element.id, childContent, output);
+                    // just to keep the order
+                    if (last) {
+                        output += `    ${last} -.-> n${element.id}\n`;
+                    }
+                    last = `n${element.id}`;
+                }
+                output += '    end\n';
+            }
         }
         else {
-            output += String(id).endsWith('-exit') ? `    n${id}((${id}))\n` : `    n${id}[[${id}]]\n`;
+            output = cfgOfNode(vertex, normalizedVertex, id, content, output);
+        }
+        if (vertex.name === type_1.RType.ExpressionList && vertex.type === control_flow_graph_1.CfgVertexType.EndMarker) {
+            output += '    end\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`;
+            const edgeType = edge.label === 1 /* CfgEdgeType.Cd */ ? '-->' : '-.->';
+            const edgeSuffix = edge.label === 1 /* CfgEdgeType.Cd */ ? ` (${edge.when})` : '';
+            output += `    n${from} ${edgeType}|"${(0, mermaid_1.escapeMarkdown)((0, control_flow_graph_1.edgeTypeToString)(edge.label))}${edgeSuffix}"| n${to}\n`;
         }
     }
     for (const entryPoint of cfg.entryPoints) {
@@ -37,7 +89,7 @@ function cfgToMermaid(cfg, normalizedAst, prefix = 'flowchart BT\n') {
 /**
  * Use mermaid to visualize the normalized AST.
  */
-function cfgToMermaidUrl(cfg, normalizedAst, prefix = '') {
+function cfgToMermaidUrl(cfg, normalizedAst, prefix = 'flowchart BT\n') {
     return (0, mermaid_1.mermaidCodeToUrl)(cfgToMermaid(cfg, normalizedAst, prefix));
 }
 //# sourceMappingURL=cfg.js.map

package/util/mermaid/dfg.d.ts

@@ -17,12 +17,13 @@ interface MermaidGraph {
     markStyle: MermaidMarkStyle;
     /** in the form of from-\>to because I am lazy, see {@link encodeEdge} */
     presentEdges: Set<string>;
+    presentVertices: Set<string>;
     rootGraph: DataflowGraph;
     /** if given, the dataflow graph will only focus on the "important" parts */
     simplified?: boolean;
 }
 /**
- * Prints a {@link SourceRange|range} as a human readable string.
+ * Prints a {@link SourceRange|range} as a human-readable string.
  */
 export declare function formatRange(range: SourceRange | undefined): string;
 export declare function printIdentifier(id: IdentifierDefinition): string;

package/util/mermaid/dfg.js

@@ -9,14 +9,16 @@ exports.diffGraphsToMermaidUrl = diffGraphsToMermaidUrl;
 const assert_1 = require("../assert");
 const mermaid_1 = require("./mermaid");
 const graph_1 = require("../../dataflow/graph/graph");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const identifier_1 = require("../../dataflow/environments/identifier");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const edge_1 = require("../../dataflow/graph/edge");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const environment_1 = require("../../dataflow/environments/environment");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+const built_in_1 = require("../../dataflow/environments/built-in");
 /**
- * Prints a {@link SourceRange|range} as a human readable string.
+ * Prints a {@link SourceRange|range} as a human-readable string.
  */
 function formatRange(range) {
     if (range === undefined) {
@@ -36,14 +38,14 @@ function subflowToMermaid(nodeId, exitPoints, subflow, mermaid, idPrefix = '') {
     if (subflow === undefined) {
         return;
     }
-    const subflowId = `${idPrefix}flow-${nodeId}`;
+    const subflowId = (0, mermaid_1.escapeId)(`${idPrefix}flow-${nodeId}`);
     if (mermaid.simplified) {
         // get parent
         const idMap = mermaid.rootGraph.idMap;
         const node = idMap?.get(nodeId);
-        const nodeLexeme = node?.info.fullLexeme ?? node?.lexeme ?? '??';
+        const nodeLexeme = node?.info.fullLexeme ?? node?.lexeme ?? 'function';
         const location = node?.location?.[0] ? ` (L. ${node?.location?.[0]})` : '';
-        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${(0, mermaid_1.escapeMarkdown)(nodeLexeme ?? 'function')}${location}"]`);
+        mermaid.nodeLines.push(`\nsubgraph "${subflowId}" ["${(0, mermaid_1.escapeMarkdown)(nodeLexeme)}${location}"]`);
     }
     else {
         mermaid.nodeLines.push(`\nsubgraph "${subflowId}" [function ${nodeId}]`);
@@ -147,6 +149,7 @@ function printEnvironmentToLines(env) {
 function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     const fCall = info.tag === vertex_1.VertexType.FunctionCall;
     const { open, close } = mermaidNodeBrackets(info.tag);
+    id = (0, mermaid_1.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'));
@@ -162,24 +165,29 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     else {
         const escapedName = (0, mermaid_1.escapeMarkdown)(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 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}`);
+        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps}${lnks})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
     }
     if (mark?.has(id)) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} ${mermaid.markStyle.vertex} `);
     }
-    if (mermaid.rootGraph.unknownSideEffects.has(id)) {
+    if ([...mermaid.rootGraph.unknownSideEffects].some(l => (0, node_id_1.normalizeIdToNumberIfPossible)(l) === (0, node_id_1.normalizeIdToNumberIfPossible)(id))) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} stroke:red,stroke-width:5px; `);
     }
-    const edges = mermaid.rootGraph.get(id, true);
+    const edges = mermaid.rootGraph.get((0, node_id_1.normalizeIdToNumberIfPossible)(id), true);
     (0, assert_1.guard)(edges !== undefined, `node ${id} must be found`);
     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]) {
+    // eslint-disable-next-line prefer-const
+    for (let [target, edge] of [...edges[1], ...artificialCdEdges]) {
+        const originalTarget = target;
+        target = (0, mermaid_1.escapeId)(target);
         const edgeTypes = typeof edge.types == 'number' ? new Set((0, edge_1.splitEdgeTypes)(edge.types)) : edge.types;
         const edgeId = encodeEdge(idPrefix + id, idPrefix + target, edgeTypes);
         if (!mermaid.presentEdges.has(edgeId)) {
             mermaid.presentEdges.add(edgeId);
-            mermaid.edgeLines.push(`    ${idPrefix}${id} -->|"${[...edgeTypes].map(e => typeof e === 'number' ? (0, edge_1.edgeTypeToName)(e) : e).join(', ')}"| ${idPrefix}${target}`);
+            const style = (0, built_in_1.isBuiltIn)(target) ? '-.->' : '-->';
+            mermaid.edgeLines.push(`    ${idPrefix}${id} ${style}|"${[...edgeTypes].map(e => typeof e === 'number' ? (0, edge_1.edgeTypeToName)(e) : e).join(', ')}"| ${idPrefix}${target}`);
             if (mermaid.mark?.has(id + '->' + target)) {
                 // who invented this syntax?!
                 mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} ${mermaid.markStyle.edge}`);
@@ -187,6 +195,14 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
             if (edgeTypes.has('CD-True') || edgeTypes.has('CD-False')) {
                 mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} stroke:gray,color:gray;`);
             }
+            if ((0, built_in_1.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(`    style ${idPrefix}${target} stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;`);
+                    mermaid.presentVertices.add(target);
+                }
+            }
         }
     }
     if (info.tag === 'function-definition') {
@@ -195,7 +211,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
 }
 // make the passing of root ids more performant again
 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 };
+    const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, presentVertices: new Set(), mark, rootGraph: rootGraph ?? graph, includeEnvironments, markStyle, simplified };
     for (const [id, info] of graph.vertices(true)) {
         if (rootIds.has(id)) {
             vertexToMermaid(info, mermaid, id, idPrefix, mark);

package/util/mermaid/mermaid.d.ts

@@ -1,7 +1,9 @@
 export declare function escapeMarkdown(text: string): string;
+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;

package/util/mermaid/mermaid.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.escapeMarkdown = escapeMarkdown;
+exports.escapeId = escapeId;
 exports.mermaidCodeToUrl = mermaidCodeToUrl;
 const replacements = {
     // keep newlines
@@ -45,10 +46,15 @@ function escapeMarkdown(text) {
     }
     return text;
 }
+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 = {

package/util/quads.js

@@ -19,7 +19,7 @@ const namedNode = (v) => n3_1.DataFactory.namedNode(v);
 const quad = (s, p, o, g) => n3_1.DataFactory.quad(s, p, o, g);
 const objects_1 = require("./objects");
 const assert_1 = require("./assert");
-const defaultmap_1 = require("./defaultmap");
+const defaultmap_1 = require("./collections/defaultmap");
 const literal = (v, n) => n3_1.DataFactory.literal(v, n);
 const log_1 = require("./log");
 const domain = 'https://uni-ulm.de/r-ast/';

package/util/schema.d.ts

@@ -1,5 +1,5 @@
 import type Joi from 'joi';
-import type { OutputFormatter } from './ansi';
+import type { OutputFormatter } from './text/ansi';
 interface SchemaLine {
     level: number;
     text: string;

package/util/schema.js

@@ -4,7 +4,7 @@ exports.describeSchema = describeSchema;
 exports.genericDescription = genericDescription;
 exports.headerLine = headerLine;
 exports.describeObject = describeObject;
-const ansi_1 = require("./ansi");
+const ansi_1 = require("./text/ansi");
 function describeSchema(schema, f = ansi_1.formatter) {
     const description = schema.describe();
     const lines = genericDescription(1, f, f.format('.', { effect: ansi_1.ColorEffect.Foreground, color: 7 /* Colors.White */ }), description);

package/util/summarizer.js

@@ -4,7 +4,7 @@ exports.Summarizer = void 0;
 exports.summarizedMeasurement2Csv = summarizedMeasurement2Csv;
 exports.summarizedMeasurement2CsvHeader = summarizedMeasurement2CsvHeader;
 exports.summarizeMeasurement = summarizeMeasurement;
-const arrays_1 = require("./arrays");
+const arrays_1 = require("./collections/arrays");
 class Summarizer {
     config;
     log;

package/util/{text.js → text/text.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nth = nth;
-const assert_1 = require("./assert");
+const assert_1 = require("../assert");
 function nth(n) {
     (0, assert_1.guard)(isFinite(n) && n >= 1, 'n must be a non-negative number');
     const num = String(n);

package/util/{time.js → text/time.js}

@@ -13,7 +13,7 @@ function date2string(date = new Date()) {
 /**
  * Print a number of milliseconds in a human-readable format including correct spacing.
  */
-function printAsMs(ms, precision = 2) {
+function printAsMs(ms, precision = 1) {
     /* eslint-disable-next-line no-irregular-whitespace*/
     return `${ms.toFixed(precision)} ms`;
 }

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.12';
+const version = '2.2.13';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }

package/dataflow/graph/diff.d.ts

@@ -1,36 +0,0 @@
-import type { DataflowGraph, FunctionArgument, OutgoingEdges } from './graph';
-import type { GenericDiffConfiguration, GenericDifferenceInformation, WriteableDifferenceReport } from '../../util/diff';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-interface ProblematicVertex {
-    tag: 'vertex';
-    id: NodeId;
-}
-interface ProblematicEdge {
-    tag: 'edge';
-    from: NodeId;
-    to: NodeId;
-}
-export type ProblematicDiffInfo = ProblematicVertex | ProblematicEdge;
-export declare class DataflowDifferenceReport implements WriteableDifferenceReport {
-    _comments: string[] | undefined;
-    _problematic: ProblematicDiffInfo[] | undefined;
-    addComment(comment: string, ...related: readonly ProblematicDiffInfo[]): void;
-    comments(): readonly string[] | undefined;
-    problematic(): readonly ProblematicDiffInfo[] | undefined;
-    isEqual(): boolean;
-}
-export interface NamedGraph {
-    name: string;
-    graph: DataflowGraph;
-}
-interface DataflowDiffContext extends GenericDifferenceInformation<DataflowDifferenceReport> {
-    left: DataflowGraph;
-    right: DataflowGraph;
-    config: GenericDiffConfiguration;
-}
-export declare function diffOfDataflowGraphs(left: NamedGraph, right: NamedGraph, config?: Partial<GenericDiffConfiguration>): DataflowDifferenceReport;
-export declare function equalFunctionArguments(fn: NodeId, a: false | readonly FunctionArgument[], b: false | readonly FunctionArgument[]): boolean;
-export declare function diffFunctionArguments(fn: NodeId, a: false | readonly FunctionArgument[], b: false | readonly FunctionArgument[], ctx: GenericDifferenceInformation<DataflowDifferenceReport>): void;
-export declare function diffVertices(ctx: DataflowDiffContext): void;
-export declare function diffEdges(ctx: DataflowDiffContext, id: NodeId, lEdges: OutgoingEdges | undefined, rEdges: OutgoingEdges | undefined): void;
-export {};

package/util/cfg/happens-before.d.ts

@@ -1,7 +0,0 @@
-import type { ControlFlowGraph } from './cfg';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import { Ternary } from '../logic';
-/**
- * Determines if node `a` happens before node `b` in the control flow graph.
- */
-export declare function happensBefore(cfg: ControlFlowGraph, a: NodeId, b: NodeId): Ternary;

package/util/cfg/visitor.d.ts

@@ -1,9 +0,0 @@
-import type { ControlFlowGraph } from './cfg';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-/**
- * Visit all nodes reachable from the start node in the control flow graph, traversing the dependencies but ignoring cycles.
- * @param graph     - The control flow graph.
- * @param startNode - The node to start the traversal from.
- * @param visitor   - The visitor function to call for each node, if you return true the traversal from this node will be stopped.
- */
-export declare function visitCfgInReverseOrder(graph: ControlFlowGraph, startNode: NodeId, visitor: (node: NodeId) => boolean | void): void;

package/util/cfg/visitor.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.visitCfgInReverseOrder = visitCfgInReverseOrder;
-/**
- * Visit all nodes reachable from the start node in the control flow graph, traversing the dependencies but ignoring cycles.
- * @param graph     - The control flow graph.
- * @param startNode - The node to start the traversal from.
- * @param visitor   - The visitor function to call for each node, if you return true the traversal from this node will be stopped.
- */
-function visitCfgInReverseOrder(graph, startNode, 
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- void is used to indicate that the return value is ignored/we never stop
-visitor) {
-    const visited = new Set();
-    const queue = [startNode];
-    while (queue.length > 0) {
-        const current = queue.pop();
-        if (visited.has(current)) {
-            continue;
-        }
-        visited.add(current);
-        if (visitor(current)) {
-            continue;
-        }
-        const incoming = graph.outgoing(current) ?? [];
-        for (const [from] of incoming) {
-            queue.push(from);
-        }
-    }
-}
-//# sourceMappingURL=visitor.js.map

package/util/set.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setEquals = setEquals;
-exports.setMinus = setMinus;
-/**
- * Given both sets, this checks if they contain the same elements.
- */
-function setEquals(a, b) {
-    if (a.size !== b.size) {
-        return false;
-    }
-    for (const item of a) {
-        if (!b.has(item)) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Returns `A – B`
- */
-function setMinus(a, b) {
-    const result = new Set();
-    for (const item of a) {
-        if (!b.has(item)) {
-            result.add(item);
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=set.js.map