@eagleoutice/flowr 1.3.11 → 1.3.12

package/dataflow/v1/graph/diff.js

@@ -1,206 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.diffEdges = exports.diffVertices = exports.diffFunctionArguments = exports.equalFunctionArguments = exports.equalExitPoints = exports.diffOfDataflowGraphs = void 0;
-const environments_1 = require("../../common/environments");
-const assert_1 = require("../../../util/assert");
-const diff_1 = require("../../../util/diff");
-const json_1 = require("../../../util/json");
-class DataflowDifferenceReport {
-    _comments = undefined;
-    addComment(comment) {
-        if (this._comments === undefined) {
-            this._comments = [comment];
-        }
-        else {
-            this._comments.push(comment);
-        }
-    }
-    comments() {
-        return this._comments;
-    }
-    isEqual() {
-        return this._comments === undefined;
-    }
-}
-function initDiffContext(left, right) {
-    return {
-        left: left.graph,
-        leftname: left.name,
-        right: right.graph,
-        rightname: right.name,
-        report: new DataflowDifferenceReport(),
-        position: ''
-    };
-}
-function diff(ctx) {
-    diffRootVertices(ctx);
-    diffVertices(ctx);
-    diffOutgoingEdges(ctx);
-    return true;
-}
-function diffOutgoingEdges(ctx) {
-    const lEdges = new Map(ctx.left.edges());
-    const rEdges = new Map(ctx.right.edges());
-    if (lEdges.size !== rEdges.size) {
-        ctx.report.addComment(`Detected different number of edges! ${ctx.leftname} has ${lEdges.size}, ${ctx.rightname} has ${rEdges.size}`);
-    }
-    for (const [id, edge] of lEdges) {
-        diffEdges(ctx, id, edge, rEdges.get(id));
-    }
-}
-function diffRootVertices(ctx) {
-    (0, diff_1.setDifference)(ctx.left.rootIds(), ctx.right.rootIds(), { ...ctx, position: `${ctx.position}Root vertices differ in graphs. ` });
-}
-function diffOfDataflowGraphs(left, right) {
-    if (left.graph === right.graph) {
-        return new DataflowDifferenceReport();
-    }
-    const ctx = initDiffContext(left, right);
-    diff(ctx);
-    return ctx.report;
-}
-exports.diffOfDataflowGraphs = diffOfDataflowGraphs;
-function diffFunctionArgumentsReferences(a, b, ctx) {
-    if (a === '<value>' || b === '<value>') {
-        if (a !== b) {
-            ctx.report.addComment(`${ctx.position}${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
-        }
-        return;
-    }
-    (0, environments_1.diffIdentifierReferences)(a, b, ctx);
-}
-function equalExitPoints(a, b) {
-    if (a === undefined || b === undefined) {
-        return a === b;
-    }
-    if (a.length !== b.length) {
-        return false;
-    }
-    for (let i = 0; i < a.length; ++i) {
-        if (a[i] !== b[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-exports.equalExitPoints = equalExitPoints;
-function equalFunctionArguments(a, b) {
-    const ctx = {
-        report: new DataflowDifferenceReport(),
-        leftname: 'left',
-        rightname: 'right',
-        position: ''
-    };
-    diffFunctionArguments(a, b, ctx);
-    return ctx.report.isEqual();
-}
-exports.equalFunctionArguments = equalFunctionArguments;
-function diffFunctionArguments(a, b, ctx) {
-    if (a === false || b === false) {
-        if (a !== b) {
-            ctx.report.addComment(`${ctx.position}${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
-        }
-        return;
-    }
-    else if (a.length !== b.length) {
-        ctx.report.addComment(`${ctx.position}Differs in number of arguments. ${ctx.leftname}: ${JSON.stringify(a, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(b, json_1.jsonReplacer)}`);
-        return;
-    }
-    for (let i = 0; i < a.length; ++i) {
-        const aArg = a[i];
-        const bArg = b[i];
-        if (Array.isArray(aArg) && Array.isArray(bArg)) {
-            // must have same name
-            if (aArg[0] !== bArg[0]) {
-                ctx.report.addComment(`${ctx.position}In the ${i}th argument (of ${ctx.leftname}, named) the name differs: ${aArg[0]} vs ${bArg[0]}.`);
-                continue;
-            }
-            diffFunctionArgumentsReferences(aArg[1], bArg[1], {
-                ...ctx,
-                position: `${ctx.position} In the ${i}th argument (of ${ctx.leftname}, named). `
-            });
-        }
-        else {
-            diffFunctionArgumentsReferences(aArg, bArg, { ...ctx, position: `${ctx.position} In the ${i}th argument (of ${ctx.leftname}, unnamed).` });
-        }
-    }
-}
-exports.diffFunctionArguments = diffFunctionArguments;
-function diffVertices(ctx) {
-    // collect vertices from both sides
-    const lVert = [...ctx.left.vertices(true)];
-    const rVert = [...ctx.right.vertices(true)];
-    if (lVert.length !== rVert.length) {
-        ctx.report.addComment(`Detected different number of vertices! ${ctx.leftname} has ${lVert.length}, ${ctx.rightname} has ${rVert.length}`);
-    }
-    for (const [id, lInfo] of lVert) {
-        const rInfoMay = ctx.right.get(id);
-        if (rInfoMay === undefined) {
-            ctx.report.addComment(`Vertex ${id} is not present in ${ctx.rightname}`);
-            continue;
-        }
-        const [rInfo] = rInfoMay;
-        if (lInfo.tag !== rInfo.tag) {
-            ctx.report.addComment(`Vertex ${id} has different tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`);
-        }
-        if (lInfo.name !== rInfo.name) {
-            ctx.report.addComment(`Vertex ${id} has different names. ${ctx.leftname}: ${lInfo.name} vs ${ctx.rightname}: ${rInfo.name}`);
-        }
-        if (lInfo.tag === 'variable-definition' || lInfo.tag === 'function-definition') {
-            (0, assert_1.guard)(lInfo.tag === rInfo.tag, () => `node ${id} does not match on tag (${lInfo.tag} vs ${rInfo.tag})`);
-            if (lInfo.scope !== rInfo.scope) {
-                ctx.report.addComment(`Vertex ${id} has different scopes. ${ctx.leftname}: ${lInfo.scope} vs ${ctx.rightname}: ${rInfo.scope}`);
-            }
-        }
-        if (lInfo.when !== rInfo.when) {
-            ctx.report.addComment(`Vertex ${id} has different when. ${ctx.leftname}: ${lInfo.when} vs ${ctx.rightname}: ${rInfo.when}`);
-        }
-        (0, environments_1.diffEnvironments)(lInfo.environment, rInfo.environment, { ...ctx, position: `${ctx.position}Vertex ${id} differs in environments. ` });
-        if (lInfo.tag === 'function-call') {
-            (0, assert_1.guard)(rInfo.tag === 'function-call', 'otherInfo must be a function call as well');
-            diffFunctionArguments(lInfo.args, rInfo.args, { ...ctx, position: `${ctx.position}Vertex ${id} (function call) differs in arguments. ` });
-        }
-        if (lInfo.tag === 'function-definition') {
-            (0, assert_1.guard)(rInfo.tag === 'function-definition', 'otherInfo must be a function definition as well');
-            if (!equalExitPoints(lInfo.exitPoints, rInfo.exitPoints)) {
-                ctx.report.addComment(`Vertex ${id} has different exit points. ${ctx.leftname}: ${JSON.stringify(lInfo.exitPoints, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.exitPoints, json_1.jsonReplacer)}`);
-            }
-            if (lInfo.subflow.scope !== rInfo.subflow.scope) {
-                ctx.report.addComment(`Vertex ${id} has different subflow scope. ${ctx.leftname}: ${JSON.stringify(lInfo.subflow, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.subflow, json_1.jsonReplacer)}`);
-            }
-            (0, environments_1.diffEnvironments)(lInfo.subflow.environments, rInfo.subflow.environments, { ...ctx, position: `${ctx.position}Vertex ${id} (function definition) differs in subflow environments. ` });
-            (0, diff_1.setDifference)(lInfo.subflow.graph, rInfo.subflow.graph, { ...ctx, position: `${ctx.position}Vertex ${id} differs in subflow graph. ` });
-        }
-    }
-}
-exports.diffVertices = diffVertices;
-function diffEdges(ctx, id, lEdges, rEdges) {
-    if (lEdges === undefined || rEdges === undefined) {
-        if (lEdges !== rEdges) {
-            ctx.report.addComment(`Vertex ${id} has undefined outgoing edges. ${ctx.leftname}: ${JSON.stringify(lEdges, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
-        }
-        return;
-    }
-    if (lEdges.size !== rEdges.size) {
-        ctx.report.addComment(`Vertex ${id} has different number of outgoing edges. ${ctx.leftname}: ${JSON.stringify(lEdges, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
-    }
-    // order independent compare
-    for (const [target, edge] of lEdges) {
-        const otherEdge = rEdges.get(target);
-        if (otherEdge === undefined) {
-            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} is not present in ${ctx.rightname}`);
-            continue;
-        }
-        if (edge.types.size !== otherEdge.types.size) {
-            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} has different number of edge types: ${JSON.stringify([...edge.types])} vs ${JSON.stringify([...otherEdge.types])}`);
-        }
-        if ([...edge.types].some(e => !otherEdge.types.has(e))) {
-            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} has different edge types: ${JSON.stringify([...edge.types])} vs ${JSON.stringify([...otherEdge.types])}`);
-        }
-        if (edge.attribute !== otherEdge.attribute) {
-            ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} has different attributes: ${JSON.stringify(edge.attribute)} vs ${JSON.stringify(otherEdge.attribute)}`);
-        }
-    }
-}
-exports.diffEdges = diffEdges;
-//# sourceMappingURL=diff.js.map

package/dataflow/v1/graph/edge.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EdgeType = void 0;
-/**
- * Represents the relationship between the source and the target vertex in the dataflow graph.
- */
-var EdgeType;
-(function (EdgeType) {
-    /** The edge determines that source reads target */
-    EdgeType["Reads"] = "reads";
-    /** The edge determines that source is defined by target */
-    EdgeType["DefinedBy"] = "defined-by";
-    /** The edge determines that both nodes reference the same variable in a lexical/scoping sense, source and target are interchangeable (reads for at construction unbound variables) */
-    EdgeType["SameReadRead"] = "same-read-read";
-    /** Similar to `same-read-read` but for def-def constructs without a read in-between */
-    EdgeType["SameDefDef"] = "same-def-def";
-    /** The edge determines that the source calls the target */
-    EdgeType["Calls"] = "calls";
-    /** The source returns target on call */
-    EdgeType["Returns"] = "returns";
-    /** The edge determines that source (probably argument) defines the target (probably parameter), currently automatically created by `addEdge` */
-    EdgeType["DefinesOnCall"] = "defines-on-call";
-    /** Inverse of `defines-on-call` currently only needed to get better results when slicing complex function calls */
-    EdgeType["DefinedByOnCall"] = "defined-by-on-call";
-    /** Formal used as argument to a function call */
-    EdgeType["Argument"] = "argument";
-    /** The edge determines that the source is a side effect that happens when the target is called */
-    EdgeType["SideEffectOnCall"] = "side-effect-on-call";
-    /** The source and edge relate to each other bidirectionally */
-    EdgeType["Relates"] = "relates";
-})(EdgeType || (exports.EdgeType = EdgeType = {}));
-//# sourceMappingURL=edge.js.map

package/dataflow/v1/graph/graph.js

@@ -1,298 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataflowGraph = void 0;
-const assert_1 = require("../../../util/assert");
-const environments_1 = require("../../common/environments");
-const log_1 = require("../../../util/log");
-const edge_1 = require("./edge");
-const diff_1 = require("./diff");
-/**
- * The dataflow graph holds the dataflow information found within the given AST.
- * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}
- *
- * The vertices of the graph are organized in a hierarchical fashion, with a function-definition node containing the node ids of its subgraph.
- * However, all *edges* are hoisted at the top level in the form of an (attributed) adjacency list.
- * After the dataflow analysis, all sources and targets of the edges *must* be part of the vertices.
- * However, this does not have to hold during the construction as edges may point from or to vertices which are yet to be constructed.
- *
- * All methods return the modified graph to allow for chaining.
- */
-class DataflowGraph {
-    static DEFAULT_ENVIRONMENT = (0, environments_1.initializeCleanEnvironments)();
-    /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
-    rootVertices = new Set();
-    /** All vertices in the complete graph (including those nested in function definition) */
-    vertexInformation = new Map();
-    /** All edges in the complete graph (including those nested in function definition) */
-    edgeInformation = new Map();
-    /**
-     * Get the {@link DataflowGraphVertexInfo} attached to a node as well as all outgoing edges.
-     *
-     * @param id                      - The id of the node to get
-     * @param includeDefinedFunctions - If true this will search function definitions as well and not just the toplevel
-     * @returns the node info for the given id (if it exists)
-     */
-    get(id, includeDefinedFunctions = true) {
-        // if we do not want to include function definitions, only retrieve the value if the id is part of the root vertices
-        const vertex = includeDefinedFunctions || this.rootVertices.has(id) ? this.vertexInformation.get(id) : undefined;
-        return vertex === undefined ? undefined : [vertex, this.outgoingEdges(id) ?? new Map()];
-    }
-    outgoingEdges(id) {
-        return this.edgeInformation.get(id);
-    }
-    ingoingEdges(id) {
-        const edges = new Map();
-        for (const [source, outgoing] of this.edgeInformation.entries()) {
-            if (outgoing.has(id)) {
-                edges.set(source, outgoing.get(id));
-            }
-        }
-        return edges;
-    }
-    /**
-   * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
-   * @returns the ids of all toplevel vertices in the graph together with their vertex information
-     *
-     * @see #edges
-   */
-    *vertices(includeDefinedFunctions) {
-        if (includeDefinedFunctions) {
-            yield* this.vertexInformation.entries();
-        }
-        else {
-            for (const id of this.rootVertices) {
-                yield [id, this.vertexInformation.get(id)];
-            }
-        }
-    }
-    /**
-     * @returns the ids of all edges in the graph together with their edge information
-     *
-     * @see #vertices
-     */
-    *edges() {
-        yield* this.edgeInformation.entries();
-    }
-    /**
-     * Returns true if the graph contains a node with the given id.
-     *
-     * @param id                      - The id to check for
-     * @param includeDefinedFunctions - If true this will check function definitions as well and not just the toplevel
-     */
-    hasNode(id, includeDefinedFunctions) {
-        return includeDefinedFunctions ? this.vertexInformation.has(id) : this.rootVertices.has(id);
-    }
-    /**
-     * Returns true if the root level of the graph contains a node with the given id.
-     */
-    isRoot(id) {
-        return this.rootVertices.has(id);
-    }
-    rootIds() {
-        return this.rootVertices;
-    }
-    /**
-   * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
-   *
-     * @param vertex - The vertex to add
-     * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds | root vertices} of the graph.
-     *                 This is probably only of use, when you construct dataflow graphs for tests.
-     *
-   * @see DataflowGraphVertexInfo
-   * @see DataflowGraphVertexArgument
-   */
-    addVertex(vertex, asRoot = true) {
-        const oldVertex = this.vertexInformation.get(vertex.id);
-        if (oldVertex !== undefined) {
-            (0, assert_1.guard)(oldVertex.name === vertex.name, 'vertex names must match for the same id if added');
-            return this;
-        }
-        // keep a clone of the original environment
-        const environment = vertex.environment === undefined ? DataflowGraph.DEFAULT_ENVIRONMENT : (0, environments_1.cloneEnvironments)(vertex.environment);
-        this.vertexInformation.set(vertex.id, {
-            ...vertex,
-            when: vertex.when ?? 'always',
-            environment
-        });
-        if (asRoot) {
-            this.rootVertices.add(vertex.id);
-        }
-        return this;
-    }
-    /**
-   * Will insert a new edge into the graph,
-   * if the direction of the edge is of no importance (`same-read-read` or `same-def-def`), source
-   * and target will be sorted so that `from` has the lower, and `to` the higher id (default ordering).
-   * <p>
-   * If you omit the last argument but set promote, this will make the edge `maybe` if at least one of the {@link IdentifierReference | references} or {@link DataflowGraphVertexInfo | nodes} has a used flag of `maybe`.
-   * Promote will probably only be used internally and not by tests etc.
-   */
-    addEdge(from, to, type, attribute, promote = false) {
-        const fromId = typeof from === 'object' ? from.nodeId : from;
-        const toId = typeof to === 'object' ? to.nodeId : to;
-        if (fromId === toId) {
-            log_1.log.trace(`ignoring self-edge from ${fromId} to ${toId} (${type}, ${attribute ?? '?'}, ${promote ? 'y' : 'n'})`);
-            return this;
-        }
-        if (promote) {
-            attribute ??= from.used === 'maybe' ? 'maybe' : to.used;
-            // reduce the load on attribute checks
-            if (attribute !== 'maybe') {
-                const fromInfo = this.get(fromId, true);
-                if (fromInfo?.[0].when === 'maybe') {
-                    log_1.log.trace(`automatically promoting edge from ${fromId} to ${toId} as maybe because at least one of the nodes is maybe`);
-                    attribute = 'maybe';
-                }
-                else {
-                    const toInfo = this.get(toId, true);
-                    if (toInfo?.[0].when === 'maybe') {
-                        log_1.log.trace(`automatically promoting edge from ${fromId} to ${toId} as maybe because at least one of the nodes is maybe`);
-                        attribute = 'maybe';
-                    }
-                }
-            }
-        }
-        (0, assert_1.guard)(attribute !== undefined, 'attribute must be set');
-        const edge = { types: new Set([type]), attribute };
-        const existingFrom = this.edgeInformation.get(fromId);
-        const edgeInFrom = existingFrom?.get(toId);
-        if (edgeInFrom === undefined) {
-            if (existingFrom === undefined) {
-                this.edgeInformation.set(fromId, new Map([[toId, edge]]));
-            }
-            else {
-                existingFrom.set(toId, edge);
-            }
-            // sort (on id so that sorting is the same, independent of the attribute)
-            const bidirectional = type === 'same-read-read' || type === 'same-def-def' || type === 'relates';
-            if (bidirectional) {
-                const existingTo = this.edgeInformation.get(toId);
-                if (existingTo === undefined) {
-                    this.edgeInformation.set(toId, new Map([[fromId, edge]]));
-                }
-                else {
-                    existingTo.set(fromId, edge);
-                }
-            }
-            else if (type === 'defines-on-call') {
-                const otherEdge = { ...edge,
-                    types: new Set([edge_1.EdgeType.DefinedByOnCall])
-                };
-                const existingTo = this.edgeInformation.get(toId);
-                if (existingTo === undefined) {
-                    this.edgeInformation.set(toId, new Map([[fromId, otherEdge]]));
-                }
-                else {
-                    existingTo.set(fromId, otherEdge);
-                }
-            }
-        }
-        else {
-            if (attribute === 'maybe') {
-                // as the data is shared, we can just set it for one direction
-                edgeInFrom.attribute = 'maybe';
-            }
-            if (!edgeInFrom.types.has(type)) {
-                // adding the type
-                edgeInFrom.types.add(type);
-            }
-        }
-        return this;
-    }
-    /**
-     * Merges the other graph into *this* one (in-place). The return value is only for convenience.
-     *
-     * @param otherGraph        - The graph to merge into this one
-     * @param mergeRootVertices - If false, this will only merge the vertices and edges but exclude the root vertices this is probably only of use
-     * 													  in the context of function definitions
-     */
-    mergeWith(otherGraph, mergeRootVertices = true) {
-        if (otherGraph === undefined) {
-            return this;
-        }
-        // merge root ids
-        if (mergeRootVertices) {
-            for (const root of otherGraph.rootVertices) {
-                this.rootVertices.add(root);
-            }
-        }
-        for (const [id, info] of otherGraph.vertexInformation) {
-            const currentInfo = this.vertexInformation.get(id);
-            this.vertexInformation.set(id, currentInfo === undefined ? info : mergeNodeInfos(currentInfo, info));
-        }
-        this.mergeEdges(otherGraph);
-        return this;
-    }
-    mergeEdges(otherGraph) {
-        for (const [id, edges] of otherGraph.edgeInformation.entries()) {
-            for (const [target, edge] of edges) {
-                const existing = this.edgeInformation.get(id);
-                if (existing === undefined) {
-                    this.edgeInformation.set(id, new Map([[target, edge]]));
-                }
-                else {
-                    const get = existing.get(target);
-                    if (get === undefined) {
-                        existing.set(target, edge);
-                    }
-                    else {
-                        get.types = new Set([...get.types, ...edge.types]);
-                        if (edge.attribute === 'maybe') {
-                            get.attribute = 'maybe';
-                        }
-                    }
-                }
-            }
-        }
-    }
-    equals(other, diff = false, names = { left: 'left', right: 'right' }) {
-        const report = (0, diff_1.diffOfDataflowGraphs)({ name: names.left, graph: this }, { name: names.right, graph: other });
-        if (diff) {
-            return report;
-        }
-        else {
-            return report.isEqual();
-        }
-    }
-    /**
-     * Marks a vertex in the graph to be a definition
-     * @param reference - The reference to the vertex to mark as definition
-     */
-    setDefinitionOfVertex(reference) {
-        const got = this.get(reference.nodeId, true);
-        (0, assert_1.guard)(got !== undefined, () => `node must be defined for ${JSON.stringify(reference)} to set definition scope to ${reference.scope}`);
-        const [node] = got;
-        if (node.tag === 'function-definition' || node.tag === 'variable-definition') {
-            (0, assert_1.guard)(node.scope === reference.scope, () => `node ${JSON.stringify(node)} must not be previously defined at position or have same scope for ${JSON.stringify(reference)}`);
-            (0, assert_1.guard)(node.when === reference.used || node.when === 'maybe' || reference.used === 'maybe', () => `node ${JSON.stringify(node)} must not be previously defined at position or have same scope for ${JSON.stringify(reference)}`);
-            node.scope = reference.scope;
-            node.when = reference.used === 'maybe' ? 'maybe' : node.when;
-        }
-        else {
-            this.vertexInformation.set(reference.nodeId, {
-                ...node,
-                tag: 'variable-definition',
-                scope: reference.scope,
-            });
-        }
-    }
-}
-exports.DataflowGraph = DataflowGraph;
-function mergeNodeInfos(current, next) {
-    (0, assert_1.guard)(current.tag === next.tag, () => `nodes to be joined for the same id must have the same tag, but ${JSON.stringify(current)} vs ${JSON.stringify(next)}`);
-    (0, assert_1.guard)(current.name === next.name, () => `nodes to be joined for the same id must have the same name, but ${JSON.stringify(current)} vs ${JSON.stringify(next)}`);
-    (0, assert_1.guard)(current.environment === next.environment, 'nodes to be joined for the same id must have the same environment');
-    if (current.tag === 'variable-definition') {
-        (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
-    }
-    else if (current.tag === 'function-call') {
-        (0, assert_1.guard)((0, diff_1.equalFunctionArguments)(current.args, next.args), 'nodes to be joined for the same id must have the same function call information');
-    }
-    else if (current.tag === 'function-definition') {
-        (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
-        (0, assert_1.guard)((0, diff_1.equalExitPoints)(current.exitPoints, next.exitPoints), 'nodes to be joined must have same exist points');
-    }
-    // make a copy
-    return { ...current };
-}
-//# sourceMappingURL=graph.js.map

package/dataflow/v1/graph/index.js

@@ -1,21 +0,0 @@
-"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("./graph"), exports);
-__exportStar(require("./edge"), exports);
-__exportStar(require("./vertex"), exports);
-__exportStar(require("./diff"), exports);
-//# sourceMappingURL=index.js.map

package/dataflow/v1/graph/quads.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.df2quads = void 0;
-const quads_1 = require("../../../util/quads");
-/**
- * @see cfg2quads
- * @see serialize2quads
- * @see graph2quads
- */
-function df2quads(graph, config) {
-    return (0, quads_1.graph2quads)({
-        rootIds: [...graph.rootIds()],
-        vertices: [...graph.vertices(true)]
-            .map(([id, v]) => ({
-            ...v,
-            id
-        })),
-        edges: [...graph.edges()].flatMap(([fromId, targets]) => [...targets].map(([toId, info]) => ({
-            from: fromId,
-            to: toId,
-            type: [...info.types],
-            when: info.attribute
-        })))
-    }, config);
-}
-exports.df2quads = df2quads;
-//# sourceMappingURL=quads.js.map

package/dataflow/v1/graph/vertex.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=vertex.js.map

package/dataflow/v1/index.js

@@ -1,24 +0,0 @@
-"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 });
-exports.dataflowLogger = void 0;
-const log_1 = require("../../util/log");
-exports.dataflowLogger = log_1.log.getSubLogger({ name: 'dataflow' });
-__exportStar(require("./graph"), exports);
-__exportStar(require("./extractor"), exports);
-__exportStar(require("../common/environments/environment"), exports);
-__exportStar(require("../../util/mermaid/dfg"), exports);
-//# sourceMappingURL=index.js.map

package/dataflow/v1/internal/info.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeCleanDataflowInformation = void 0;
-const graph_1 = require("../graph");
-function initializeCleanDataflowInformation(data) {
-    return {
-        unknownReferences: [],
-        in: [],
-        out: [],
-        scope: data.activeScope,
-        environments: data.environments,
-        graph: new graph_1.DataflowGraph()
-    };
-}
-exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
-//# sourceMappingURL=info.js.map