@eagleoutice/flowr 1.3.11

package/dataflow/v1/internal/process/functions/parameter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFunctionParameter = void 0;
+const processor_1 = require("../../../processor");
+const environments_1 = require("../../../../common/environments");
+const log_1 = require("../../../../../util/log");
+const graph_1 = require("../../../graph");
+const scopes_1 = require("../../../../common/environments/scopes");
+function processFunctionParameter(parameter, data) {
+    const name = (0, processor_1.processDataflowFor)(parameter.name, data);
+    const defaultValue = parameter.defaultValue === undefined ? undefined : (0, processor_1.processDataflowFor)(parameter.defaultValue, data);
+    const graph = defaultValue !== undefined ? name.graph.mergeWith(defaultValue.graph) : name.graph;
+    const writtenNodes = name.unknownReferences.map(n => ({
+        ...n,
+        kind: 'parameter',
+        used: 'always',
+        definedAt: parameter.info.id,
+        scope: scopes_1.LocalScope
+    }));
+    let environments = name.environments;
+    for (const writtenNode of writtenNodes) {
+        log_1.log.trace(`parameter ${writtenNode.name} (${writtenNode.nodeId}) is defined at id ${writtenNode.definedAt} with ${defaultValue === undefined ? 'no default value' : ' no default value'}`);
+        graph.setDefinitionOfVertex(writtenNode);
+        environments = (0, environments_1.define)(writtenNode, scopes_1.LocalScope, environments);
+        if (defaultValue !== undefined) {
+            if (parameter.defaultValue?.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+                graph.addEdge(writtenNode, parameter.defaultValue.info.id, graph_1.EdgeType.DefinedBy, 'maybe' /* default arguments can be overridden! */);
+            }
+            else {
+                const definedBy = [...defaultValue.in, ...defaultValue.unknownReferences];
+                for (const node of definedBy) {
+                    graph.addEdge(writtenNode, node, graph_1.EdgeType.DefinedBy, 'maybe' /* default arguments can be overridden! */);
+                }
+            }
+        }
+    }
+    return {
+        unknownReferences: [],
+        in: defaultValue === undefined ? [] : [...defaultValue.in, ...defaultValue.unknownReferences, ...name.in],
+        out: [...(defaultValue?.out ?? []), ...name.out, ...name.unknownReferences],
+        graph: graph,
+        environments: environments,
+        scope: data.activeScope
+    };
+}
+exports.processFunctionParameter = processFunctionParameter;
+//# sourceMappingURL=parameter.js.map

package/dataflow/v1/internal/process/if-then-else.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processIfThenElse = void 0;
+const processor_1 = require("../../processor");
+const environments_1 = require("../../../common/environments");
+const linker_1 = require("../linker");
+function processIfThenElse(ifThen, data) {
+    const cond = (0, processor_1.processDataflowFor)(ifThen.condition, data);
+    data = { ...data, environments: cond.environments };
+    let then;
+    let makeThenMaybe = false;
+    if (ifThen.condition.lexeme !== 'FALSE') {
+        then = (0, processor_1.processDataflowFor)(ifThen.then, data);
+        if (ifThen.condition.lexeme !== 'TRUE') {
+            makeThenMaybe = true;
+        }
+    }
+    let otherwise;
+    let makeOtherwiseMaybe = false;
+    if (ifThen.otherwise !== undefined && ifThen.condition.lexeme !== 'TRUE') {
+        otherwise = (0, processor_1.processDataflowFor)(ifThen.otherwise, data);
+        if (ifThen.condition.lexeme !== 'FALSE') {
+            makeOtherwiseMaybe = true;
+        }
+    }
+    const nextGraph = cond.graph.mergeWith(then?.graph).mergeWith(otherwise?.graph);
+    const thenEnvironment = then?.environments ?? cond.environments;
+    // if there is no "else" case we have to recover whatever we had before as it may be not executed
+    const finalEnvironment = (0, environments_1.appendEnvironments)(thenEnvironment, otherwise ? otherwise.environments : cond.environments);
+    // again within an if-then-else we consider all actives to be read
+    const ingoing = [
+        ...cond.in,
+        ...(makeThenMaybe ? (0, environments_1.makeAllMaybe)(then?.in, nextGraph, finalEnvironment) : then?.in ?? []),
+        ...(makeOtherwiseMaybe ? (0, environments_1.makeAllMaybe)(otherwise?.in, nextGraph, finalEnvironment) : otherwise?.in ?? []),
+        ...cond.unknownReferences,
+        ...(makeThenMaybe ? (0, environments_1.makeAllMaybe)(then?.unknownReferences, nextGraph, finalEnvironment) : then?.unknownReferences ?? []),
+        ...(makeOtherwiseMaybe ? (0, environments_1.makeAllMaybe)(otherwise?.unknownReferences, nextGraph, finalEnvironment) : otherwise?.unknownReferences ?? []),
+    ];
+    // we assign all with a maybe marker
+    // we do not merge even if they appear in both branches because the maybe links will refer to different ids
+    const outgoing = [
+        ...cond.out,
+        ...(makeThenMaybe ? (0, environments_1.makeAllMaybe)(then?.out, nextGraph, finalEnvironment) : then?.out ?? []),
+        ...(makeOtherwiseMaybe ? (0, environments_1.makeAllMaybe)(otherwise?.out, nextGraph, finalEnvironment) : otherwise?.out ?? []),
+    ];
+    (0, linker_1.linkIngoingVariablesInSameScope)(nextGraph, ingoing);
+    return {
+        unknownReferences: [],
+        in: ingoing,
+        out: outgoing,
+        environments: finalEnvironment,
+        graph: nextGraph,
+        scope: data.activeScope,
+    };
+}
+exports.processIfThenElse = processIfThenElse;
+//# sourceMappingURL=if-then-else.js.map

package/dataflow/v1/internal/process/loops/for-loop.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processForLoop = void 0;
+const linker_1 = require("../../linker");
+const processor_1 = require("../../../processor");
+const environments_1 = require("../../../../common/environments");
+const graph_1 = require("../../../graph");
+const scopes_1 = require("../../../../common/environments/scopes");
+function processForLoop(loop, data) {
+    const variable = (0, processor_1.processDataflowFor)(loop.variable, data);
+    const vector = (0, processor_1.processDataflowFor)(loop.vector, data);
+    let headEnvironments = (0, environments_1.overwriteEnvironments)(vector.environments, variable.environments);
+    const headGraph = variable.graph.mergeWith(vector.graph);
+    const writtenVariable = variable.unknownReferences;
+    for (const write of writtenVariable) {
+        headEnvironments = (0, environments_1.define)({ ...write, used: 'always', definedAt: loop.info.id, kind: 'variable' }, scopes_1.LocalScope, headEnvironments);
+    }
+    data = { ...data, environments: headEnvironments };
+    const body = (0, processor_1.processDataflowFor)(loop.body, data);
+    const nextGraph = headGraph.mergeWith(body.graph);
+    const outEnvironments = (0, environments_1.appendEnvironments)(headEnvironments, body.environments);
+    // again within an if-then-else we consider all actives to be read
+    // currently i add it at the end, but is this correct?
+    const ingoing = [...vector.in, ...(0, environments_1.makeAllMaybe)(body.in, nextGraph, outEnvironments), ...vector.unknownReferences, ...(0, environments_1.makeAllMaybe)(body.unknownReferences, nextGraph, outEnvironments)];
+    // now we have to bind all open reads with the given name to the locally defined writtenVariable!
+    const nameIdShares = (0, linker_1.produceNameSharedIdMap)(ingoing);
+    for (const write of writtenVariable) {
+        for (const link of [...vector.in, ...vector.unknownReferences]) {
+            nextGraph.addEdge(write.nodeId, link.nodeId, graph_1.EdgeType.DefinedBy, 'always', true);
+        }
+        const name = write.name;
+        const readIdsToLink = nameIdShares.get(name);
+        for (const readId of readIdsToLink) {
+            nextGraph.addEdge(readId.nodeId, write.nodeId, graph_1.EdgeType.Reads, 'always', true);
+        }
+        // now, we remove the name from the id shares as they are no longer needed
+        nameIdShares.delete(name);
+        nextGraph.setDefinitionOfVertex(write);
+    }
+    const outgoing = [...variable.out, ...writtenVariable, ...(0, environments_1.makeAllMaybe)(body.out, nextGraph, outEnvironments)];
+    (0, linker_1.linkIngoingVariablesInSameScope)(nextGraph, ingoing);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(nextGraph, nameIdShares, body.out);
+    return {
+        unknownReferences: [],
+        // we only want those not bound by a local variable
+        in: [...variable.in, ...[...nameIdShares.values()].flat()],
+        out: outgoing,
+        graph: nextGraph,
+        environments: outEnvironments,
+        scope: data.activeScope
+    };
+}
+exports.processForLoop = processForLoop;
+//# sourceMappingURL=for-loop.js.map

package/dataflow/v1/internal/process/loops/repeat-loop.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRepeatLoop = void 0;
+const processor_1 = require("../../../processor");
+const linker_1 = require("../../linker");
+function processRepeatLoop(loop, data) {
+    const body = (0, processor_1.processDataflowFor)(loop.body, data);
+    const graph = body.graph;
+    const namedIdShares = (0, linker_1.produceNameSharedIdMap)([...body.in, ...body.unknownReferences]);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(graph, namedIdShares, body.out);
+    return {
+        unknownReferences: [],
+        in: [...body.in, ...body.unknownReferences],
+        out: body.out,
+        environments: body.environments,
+        scope: data.activeScope,
+        graph: body.graph
+    };
+}
+exports.processRepeatLoop = processRepeatLoop;
+//# sourceMappingURL=repeat-loop.js.map

package/dataflow/v1/internal/process/loops/while-loop.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processWhileLoop = void 0;
+const processor_1 = require("../../../processor");
+const environments_1 = require("../../../../common/environments");
+const linker_1 = require("../../linker");
+function processWhileLoop(loop, data) {
+    const condition = (0, processor_1.processDataflowFor)(loop.condition, data);
+    data = { ...data, environments: condition.environments };
+    const body = (0, processor_1.processDataflowFor)(loop.body, data);
+    const environments = condition.environments;
+    const nextGraph = condition.graph.mergeWith(body.graph);
+    const finalEnvironments = (0, environments_1.appendEnvironments)(condition.environments, body.environments);
+    // this is theoretically redundant, but we would have to manually mark all affected edges as maybe this way. This does that for us.
+    const remainingInputs = (0, linker_1.linkInputs)([
+        ...(0, environments_1.makeAllMaybe)(body.unknownReferences, nextGraph, finalEnvironments),
+        ...(0, environments_1.makeAllMaybe)(body.in, nextGraph, finalEnvironments)
+    ], data.activeScope, environments, [...condition.in, ...condition.unknownReferences], nextGraph, true);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(nextGraph, (0, linker_1.produceNameSharedIdMap)(remainingInputs), body.out);
+    return {
+        unknownReferences: [],
+        in: remainingInputs,
+        out: [...(0, environments_1.makeAllMaybe)(body.out, nextGraph, finalEnvironments), ...condition.out],
+        graph: nextGraph,
+        /* the body might not happen if the condition is false */
+        environments: finalEnvironments,
+        scope: data.activeScope
+    };
+}
+exports.processWhileLoop = processWhileLoop;
+//# sourceMappingURL=while-loop.js.map

package/dataflow/v1/internal/process/operators/assignment.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAssignment = void 0;
+const r_bridge_1 = require("../../../../../r-bridge");
+const processor_1 = require("../../../processor");
+const graph_1 = require("../../../graph");
+const environments_1 = require("../../../../common/environments");
+const log_1 = require("../../../../../util/log");
+const index_1 = require("../../../index");
+const scopes_1 = require("../../../../common/environments/scopes");
+function processAssignment(op, data) {
+    index_1.dataflowLogger.trace(`Processing assignment with id ${op.info.id}`);
+    const lhs = (0, processor_1.processDataflowFor)(op.lhs, data);
+    const rhs = (0, processor_1.processDataflowFor)(op.rhs, data);
+    const { readTargets, newWriteNodes, writeTargets, environments, swap } = processReadAndWriteForAssignmentBasedOnOp(op, lhs, rhs, data);
+    const nextGraph = lhs.graph.mergeWith(rhs.graph);
+    // deal with special cases based on the source node and the determined read targets
+    const isFunctionSide = swap ? op.lhs : op.rhs;
+    const isFunction = isFunctionSide.type === "RFunctionDefinition" /* RType.FunctionDefinition */;
+    for (const write of newWriteNodes) {
+        nextGraph.setDefinitionOfVertex(write);
+        if (isFunction) {
+            nextGraph.addEdge(write, isFunctionSide.info.id, graph_1.EdgeType.DefinedBy, 'always', true);
+        }
+        else {
+            const impactReadTargets = determineImpactOfSource(swap ? op.lhs : op.rhs, readTargets);
+            for (const read of impactReadTargets) {
+                nextGraph.addEdge(write, read, graph_1.EdgeType.DefinedBy, undefined, true);
+            }
+        }
+    }
+    return {
+        unknownReferences: [],
+        in: readTargets,
+        out: writeTargets,
+        graph: nextGraph,
+        environments,
+        scope: data.activeScope
+    };
+}
+exports.processAssignment = processAssignment;
+function identifySourceAndTarget(op, lhs, rhs) {
+    let source;
+    let target;
+    let global = false;
+    let swap = false;
+    switch (op.lexeme) {
+        case '<-':
+        case '=':
+        case ':=':
+            [target, source] = [lhs, rhs];
+            break;
+        case '<<-':
+            [target, source, global] = [lhs, rhs, true];
+            break;
+        case '->':
+            [target, source, swap] = [rhs, lhs, true];
+            break;
+        case '->>':
+            [target, source, global, swap] = [rhs, lhs, true, true];
+            break;
+        default:
+            throw new Error(`Unknown assignment operator ${JSON.stringify(op)}`);
+    }
+    return { source, target, global, swap };
+}
+function produceWrittenNodes(op, target, global, data, functionTypeCheck) {
+    const writeNodes = [];
+    const isFunctionDef = functionTypeCheck.type === "RFunctionDefinition" /* RType.FunctionDefinition */;
+    for (const active of target.unknownReferences) {
+        writeNodes.push({
+            ...active,
+            scope: global ? scopes_1.GlobalScope : data.activeScope,
+            kind: isFunctionDef ? 'function' : 'variable',
+            definedAt: op.info.id
+        });
+    }
+    return writeNodes;
+}
+function processReadAndWriteForAssignmentBasedOnOp(op, lhs, rhs, data) {
+    // what is written/read additionally is based on lhs/rhs - assignments read written variables as well
+    const read = [...lhs.in, ...rhs.in];
+    const { source, target, global, swap } = identifySourceAndTarget(op, lhs, rhs);
+    const funcTypeCheck = swap ? op.lhs : op.rhs;
+    const writeNodes = produceWrittenNodes(op, target, global, data, funcTypeCheck);
+    if (writeNodes.length !== 1) {
+        log_1.log.warn(`Unexpected write number in assignment: ${JSON.stringify(writeNodes)}`);
+    }
+    const readFromSourceWritten = source.out;
+    let environments = (0, environments_1.overwriteEnvironments)(source.environments, target.environments);
+    // install assigned variables in environment
+    for (const write of writeNodes) {
+        environments = (0, environments_1.define)(write, global ? scopes_1.GlobalScope : scopes_1.LocalScope, environments);
+    }
+    return {
+        readTargets: [...source.unknownReferences, ...read, ...readFromSourceWritten],
+        writeTargets: [...writeNodes, ...target.out, ...readFromSourceWritten],
+        environments: environments,
+        newWriteNodes: writeNodes,
+        swap
+    };
+}
+/**
+ * Some R-constructs like loops are known to return values completely independent of their input (loops return an invisible `NULL`).
+ * This returns only those of `readTargets` that actually impact the target.
+ */
+function determineImpactOfSource(source, readTargets) {
+    // collect all ids from the source but stop at Loops, function calls, definitions and everything which links its own return
+    // for loops this is necessary as they *always* return an invisible null, for function calls we do not know if they do
+    // yet, we need to keep the ids of these elements
+    const keepEndIds = [];
+    const allIds = new Set((0, r_bridge_1.collectAllIds)(source, n => {
+        if (n.type === "RFunctionCall" /* RType.FunctionCall */ || n.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+            keepEndIds.push(n.info.id);
+            return true;
+        }
+        return n.type === "RForLoop" /* RType.ForLoop */ || n.type === "RWhileLoop" /* RType.WhileLoop */ || n.type === "RRepeatLoop" /* RType.RepeatLoop */;
+    }));
+    for (const id of keepEndIds) {
+        allIds.add(id);
+    }
+    if (allIds.size === 0) {
+        return new Set();
+    }
+    else {
+        return new Set(readTargets.filter(ref => allIds.has(ref.nodeId)));
+    }
+}
+//# sourceMappingURL=assignment.js.map

package/dataflow/v1/internal/process/operators/non-assignment-binary-op.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processNonAssignmentBinaryOp = void 0;
+const processor_1 = require("../../../processor");
+const linker_1 = require("../../linker");
+const environments_1 = require("../../../../common/environments");
+function processNonAssignmentBinaryOp(op, data) {
+    const lhs = (0, processor_1.processDataflowFor)(op.lhs, data);
+    const rhs = (0, processor_1.processDataflowFor)(op.rhs, data);
+    const ingoing = [...lhs.in, ...rhs.in, ...lhs.unknownReferences, ...rhs.unknownReferences];
+    const nextGraph = lhs.graph.mergeWith(rhs.graph);
+    (0, linker_1.linkIngoingVariablesInSameScope)(nextGraph, ingoing);
+    // logical operations may not execute the right hand side (e.g., `FALSE && (x <- TRUE)`)
+    const merger = op.flavor === 'logical' ? environments_1.appendEnvironments : environments_1.overwriteEnvironments;
+    return {
+        unknownReferences: [], // binary ops require reads as without assignments there is no definition
+        in: ingoing,
+        out: [...lhs.out, ...rhs.out],
+        environments: merger(lhs.environments, rhs.environments),
+        graph: nextGraph,
+        scope: data.activeScope,
+    };
+}
+exports.processNonAssignmentBinaryOp = processNonAssignmentBinaryOp;
+//# sourceMappingURL=non-assignment-binary-op.js.map

package/dataflow/v1/internal/process/operators/pipe.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPipeOperation = void 0;
+const processor_1 = require("../../../processor");
+const linker_1 = require("../../linker");
+const environments_1 = require("../../../../common/environments");
+const index_1 = require("../../../index");
+const assert_1 = require("../../../../../util/assert");
+const argument_1 = require("../functions/argument");
+function processPipeOperation(op, data) {
+    const lhs = (0, processor_1.processDataflowFor)(op.lhs, data);
+    const rhs = (0, processor_1.processDataflowFor)(op.rhs, data);
+    // in-and outgoing are similar to that of a binary operation, we only 1) expect the rhs to be a function call and 2) modify the arguments.
+    const ingoing = [...lhs.in, ...rhs.in, ...lhs.unknownReferences, ...rhs.unknownReferences];
+    const nextGraph = lhs.graph.mergeWith(rhs.graph);
+    (0, linker_1.linkIngoingVariablesInSameScope)(nextGraph, ingoing);
+    if (op.rhs.type !== "RFunctionCall" /* RType.FunctionCall */) {
+        index_1.dataflowLogger.warn(`Expected rhs of pipe to be a function call, but got ${op.rhs.type} instead.`);
+    }
+    else {
+        const maybeFunctionCallNode = nextGraph.get(op.rhs.info.id, true);
+        (0, assert_1.guard)(maybeFunctionCallNode !== undefined, () => `Expected function call node with id ${op.rhs.info.id} to be present in graph, but got undefined instead (graph: ${(0, index_1.graphToMermaidUrl)(nextGraph, data.completeAst.idMap)}).`);
+        const functionCallNode = maybeFunctionCallNode[0];
+        (0, assert_1.guard)(functionCallNode.tag === 'function-call', () => `Expected function call node with id ${op.rhs.info.id} to be a function call node, but got ${functionCallNode.tag} instead.`);
+        // make the lhs an argument node:
+        const argId = op.lhs.info.id;
+        index_1.dataflowLogger.trace(`Linking pipe arg ${argId} as first argument of ${op.rhs.info.id}`);
+        functionCallNode.args.unshift({
+            nodeId: argId,
+            name: `${argument_1.UnnamedArgumentPrefix}${argId}`,
+            scope: data.activeScope,
+            used: 'always'
+        });
+        nextGraph.addEdge(functionCallNode.id, argId, index_1.EdgeType.Argument, 'always');
+    }
+    return {
+        unknownReferences: [],
+        in: ingoing,
+        out: [...lhs.out, ...rhs.out],
+        environments: (0, environments_1.overwriteEnvironments)(lhs.environments, rhs.environments),
+        graph: nextGraph,
+        scope: data.activeScope,
+    };
+}
+exports.processPipeOperation = processPipeOperation;
+//# sourceMappingURL=pipe.js.map

package/dataflow/v1/internal/process/operators/unary-op.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUnaryOp = void 0;
+const processor_1 = require("../../../processor");
+function processUnaryOp(op, data) {
+    /* nothing has to happen to our knowledge */
+    return (0, processor_1.processDataflowFor)(op.operand, data);
+}
+exports.processUnaryOp = processUnaryOp;
+//# sourceMappingURL=unary-op.js.map

package/dataflow/v1/internal/process/symbol.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSymbol = void 0;
+const r_bridge_1 = require("../../../../r-bridge");
+const graph_1 = require("../../graph");
+const info_1 = require("../info");
+function processSymbol(symbol, data) {
+    if (symbol.content === r_bridge_1.RNull || symbol.content === r_bridge_1.RNa) {
+        return (0, info_1.initializeCleanDataflowInformation)(data);
+    }
+    return {
+        unknownReferences: [{ nodeId: symbol.info.id, scope: data.activeScope, name: symbol.content, used: 'always' }],
+        in: [],
+        out: [],
+        environments: data.environments,
+        scope: data.activeScope,
+        graph: new graph_1.DataflowGraph().addVertex({ tag: 'use', id: symbol.info.id, name: symbol.content, environment: data.environments })
+    };
+}
+exports.processSymbol = processSymbol;
+//# sourceMappingURL=symbol.js.map

package/dataflow/v1/internal/process/uninteresting-leaf.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUninterestingLeaf = void 0;
+const info_1 = require("../info");
+function processUninterestingLeaf(_leaf, info) {
+    return (0, info_1.initializeCleanDataflowInformation)(info);
+}
+exports.processUninterestingLeaf = processUninterestingLeaf;
+//# sourceMappingURL=uninteresting-leaf.js.map

package/dataflow/v1/processor.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDataflowFor = void 0;
+/**
+ * Originally, dataflow processor was written as a two-way fold, but this produced problems when trying to resolve function calls
+ * which require information regarding the calling *and* definition context. While this only is a problem for late bindings as they happen
+ * with functions (and probably quote'd R-expressions) it is still a problem that must be dealt with.
+ * Therefore, the dataflow processor has no complete control over the traversal and merge strategy of the graph, with each processor being in
+ * the position to call the other processors as needed for its children.
+ * <p>
+ * Now this method can be called recursively within the other processors to parse the dataflow for nodes that you can not narrow down.
+ *
+ * @param current - The current node to start processing from
+ * @param data    - The initial information to be passed down
+ */
+function processDataflowFor(current, data) {
+    return data.processors[current.type](current, data);
+}
+exports.processDataflowFor = processDataflowFor;
+//# sourceMappingURL=processor.js.map

package/dataflow/v2/entry.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.produceDataFlowGraph = void 0;
+const info_1 = require("../v1/internal/info");
+const environments_1 = require("../common/environments");
+const scopes_1 = require("../common/environments/scopes");
+function produceDataFlowGraph() {
+    return (0, info_1.initializeCleanDataflowInformation)({ environments: (0, environments_1.initializeCleanEnvironments)(), activeScope: scopes_1.GlobalScope });
+}
+exports.produceDataFlowGraph = produceDataFlowGraph;
+//# sourceMappingURL=entry.js.map

package/flowr.d.ts

@@ -0,0 +1,26 @@
+import commandLineUsage, { OptionDefinition } from 'command-line-usage';
+export declare const toolName = "flowr";
+export declare const optionDefinitions: OptionDefinition[];
+export interface FlowrCliOptions {
+    verbose: boolean;
+    version: boolean;
+    help: boolean;
+    server: boolean;
+    port: number;
+    'no-ansi': boolean;
+    execute: string | undefined;
+    script: string | undefined;
+}
+export declare const optionHelp: ({
+    header: string;
+    content: string;
+    optionList?: undefined;
+} | {
+    header: string;
+    content: string[];
+    optionList?: undefined;
+} | {
+    header: string;
+    optionList: commandLineUsage.OptionDefinition[];
+    content?: undefined;
+})[];