@eagleoutice/flowr 1.3.11

package/core/steps/input.js

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

package/core/steps/output.js

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

package/core/steps/pipeline/create.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAndBuildPipeline = void 0;
+const invalid_pipeline_error_1 = require("./invalid-pipeline-error");
+const json_1 = require("../../../util/json");
+const arrays_1 = require("../../../util/arrays");
+/**
+ * Given a set of {@link IPipelineStep|steps} with their dependencies, this function verifies all requirements of {@link createPipeline}.
+ */
+function verifyAndBuildPipeline(steps) {
+    if (steps.length === 0) {
+        throw new invalid_pipeline_error_1.InvalidPipelineError('0) Pipeline is empty');
+    }
+    const [perFileSteps, perRequestSteps] = (0, arrays_1.partitionArray)(steps, s => s.executed === 0 /* PipelineStepStage.OncePerFile */);
+    // we construct a map linking each name to its respective step
+    const perFileStepMap = new Map();
+    const initsPerFile = [];
+    const visited = new Set();
+    // we start by working on the per-file steps
+    initializeSteps(perFileSteps, perFileStepMap, initsPerFile, visited);
+    // first, we sort the per-file steps
+    const sortedPerFile = topologicalSort(initsPerFile, perFileStepMap, visited);
+    validateStepOutput(sortedPerFile, perFileStepMap, steps);
+    const perRequestStepMap = new Map(perFileStepMap);
+    // we track all elements without dependencies, i.e., those that start the pipeline
+    const initsPerRequest = [];
+    // now, we do the same for the per-request steps, keeping the per-file steps known
+    initializeSteps(perRequestSteps, perRequestStepMap, initsPerRequest, visited);
+    const sortedPerRequest = topologicalSort(initsPerRequest, perRequestStepMap, visited);
+    const sorted = [...sortedPerFile, ...sortedPerRequest];
+    validateStepOutput(sorted, perRequestStepMap, steps);
+    return {
+        steps: perRequestStepMap,
+        order: sorted,
+        firstStepPerRequest: sortedPerFile.length
+    };
+}
+exports.verifyAndBuildPipeline = verifyAndBuildPipeline;
+function validateStepOutput(sorted, stepMap, steps) {
+    if (sorted.length !== stepMap.size) {
+        // check if any of the dependencies in the map are invalid
+        checkForInvalidDependency(steps, stepMap);
+        // otherwise, we assume a cycle
+        throw new invalid_pipeline_error_1.InvalidPipelineError(`3) Pipeline contains at least one cycle; sorted: ${JSON.stringify(sorted)}, steps: ${JSON.stringify([...stepMap.keys()])}`);
+    }
+}
+function allDependenciesAreVisited(step, visited) {
+    return step.dependencies.every(d => visited.has(d));
+}
+function handleStep(step, init, visited, sorted, elem, decoratorsOfLastOthers, inits) {
+    if (step.decorates === init) {
+        if (allDependenciesAreVisited(step, visited)) {
+            sorted.push(elem);
+            visited.add(elem);
+        }
+        else {
+            decoratorsOfLastOthers.add(elem);
+        }
+    }
+    else if (step.decorates === undefined && allDependenciesAreVisited(step, visited)) {
+        inits.push(elem);
+    }
+}
+function topologicalSort(inits, stepMap, visited) {
+    const sorted = [];
+    while (inits.length > 0) {
+        const init = inits.pop();
+        sorted.push(init);
+        visited.add(init);
+        // these decorators still have dependencies open; we have to check if they can be satisfied by the other steps to add
+        const decoratorsOfLastOthers = new Set();
+        for (const [elem, step] of stepMap.entries()) {
+            if (visited.has(elem)) {
+                continue;
+            }
+            handleStep(step, init, visited, sorted, elem, decoratorsOfLastOthers, inits);
+        }
+        // for the other decorators we have to cycle until we find a solution, or know, that no solution exists
+        topologicallyInsertDecoratorElements(decoratorsOfLastOthers, stepMap, visited, sorted);
+    }
+    return sorted;
+}
+function topologicallyInsertDecoratorElements(decoratorsOfLastOthers, stepMap, visited, sorted) {
+    if (decoratorsOfLastOthers.size === 0) {
+        return;
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const elem of [...decoratorsOfLastOthers]) {
+            const step = stepMap.get(elem);
+            if (allDependenciesAreVisited(step, visited)) {
+                decoratorsOfLastOthers.delete(elem);
+                sorted.push(elem);
+                visited.add(elem);
+                changed = true;
+            }
+        }
+    }
+    if (decoratorsOfLastOthers.size > 0) {
+        throw new invalid_pipeline_error_1.InvalidPipelineError(`5) Pipeline contains at least one decoration cycle: ${JSON.stringify(decoratorsOfLastOthers, json_1.jsonReplacer)}`);
+    }
+}
+function checkForInvalidDependency(steps, stepMap) {
+    for (const step of steps) {
+        for (const dep of step.dependencies) {
+            if (!stepMap.has(dep)) {
+                throw new invalid_pipeline_error_1.InvalidPipelineError(`2) Step "${step.name}" depends on step "${dep}" which does not exist`);
+            }
+        }
+        if (step.decorates && !stepMap.has(step.decorates)) {
+            throw new invalid_pipeline_error_1.InvalidPipelineError(`4) Step "${step.name}" decorates step "${step.decorates}" which does not exist`);
+        }
+    }
+}
+function initializeSteps(steps, stepMap, inits, visited) {
+    for (const step of steps) {
+        const name = step.name;
+        // if the name is already in the map we have a duplicate
+        if (stepMap.has(name)) {
+            throw new invalid_pipeline_error_1.InvalidPipelineError(`1) Step name "${name}" is not unique in the pipeline`);
+        }
+        stepMap.set(name, step);
+        // only steps that have no dependencies and do not decorate others can be initial steps
+        if (allDependenciesAreVisited(step, visited) && (step.decorates === undefined || visited.has(step.decorates))) {
+            inits.push(name);
+        }
+    }
+}
+//# sourceMappingURL=create.js.map

package/core/steps/pipeline/default.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V2_DATAFLOW_PIPELINE = exports.DEFAULT_SLICING_PIPELINE = void 0;
+/**
+ * Contains the default pipeline for working with flowr
+ */
+const pipeline_1 = require("./pipeline");
+const _00_parse_1 = require("../all/core/00-parse");
+const _10_normalize_1 = require("../all/core/10-normalize");
+const _20_dataflow_1 = require("../all/core/20-dataflow");
+const _00_slice_1 = require("../all/static-slicing/00-slice");
+const _10_reconstruct_1 = require("../all/static-slicing/10-reconstruct");
+exports.DEFAULT_SLICING_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE, _20_dataflow_1.LEGACY_STATIC_DATAFLOW, _00_slice_1.STATIC_SLICE, _10_reconstruct_1.NAIVE_RECONSTRUCT);
+exports.V2_DATAFLOW_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.DESUGAR_NORMALIZE, _20_dataflow_1.V2_STATIC_DATAFLOW);
+//# sourceMappingURL=default.js.map

package/core/steps/pipeline/dependency-checker.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPipeline = void 0;
+const invalid_pipeline_error_1 = require("./invalid-pipeline-error");
+/**
+ * Given a set of {@link IStep|steps} with their dependencies, this function verifies that
+ * 1) all names of steps are unique for the given pipeline
+ * 2) all dependencies of steps are valid (i.e., refer to existing steps)
+ * 3) there are no cycles in the dependency graph
+ * If successful, it returns the topologically sorted list of steps in order of desired execution.
+ */
+function verifyPipeline(steps) {
+    if (steps.length === 0) {
+        throw new invalid_pipeline_error_1.InvalidPipelineError('Pipeline is empty');
+    }
+    // we construct a map linking each name to its respective step
+    const stepMap = new Map();
+    // we track all elements without dependencies, i.e. those that start the pipeline
+    const inits = [];
+    initializeSteps(steps, stepMap, inits);
+    if (inits.length === 0) {
+        throw new invalid_pipeline_error_1.InvalidPipelineError('Pipeline has no initial steps (i.e., it contains no step without dependencies)');
+    }
+    const sorted = topoSort(inits, stepMap);
+    if (sorted.length !== stepMap.size) {
+        // check if any of the dependencies in the map are invalid
+        checkForInvalidDependency(steps, stepMap);
+        // otherwise, we assume a cycle
+        throw new invalid_pipeline_error_1.InvalidPipelineError('Pipeline contains at least one cycle');
+    }
+    return {
+        steps: stepMap,
+        order: sorted
+    };
+}
+exports.verifyPipeline = verifyPipeline;
+function topoSort(inits, stepMap) {
+    // now, we topo-sort the steps
+    const sorted = [];
+    const visited = new Set();
+    while (inits.length > 0) {
+        const init = inits.pop();
+        sorted.push(init);
+        visited.add(init);
+        // TODO: improve this check, maybe really remove?
+        for (const [key, step] of stepMap.entries()) {
+            if (!visited.has(key) && step.dependencies.filter(dep => !visited.has(dep)).length === 0) {
+                inits.push(key);
+            }
+        }
+    }
+    return sorted;
+}
+function checkForInvalidDependency(steps, stepMap) {
+    for (const step of steps) {
+        for (const dep of step.dependencies) {
+            if (!stepMap.has(dep)) {
+                throw new invalid_pipeline_error_1.InvalidPipelineError(`Step "${step.name}" depends on step "${dep}" which does not exist`);
+            }
+        }
+    }
+}
+function initializeSteps(steps, stepMap, inits) {
+    for (const step of steps) {
+        const name = step.name;
+        // if the name is already in the map we have a duplicate
+        if (stepMap.has(name)) {
+            throw new invalid_pipeline_error_1.InvalidPipelineError(`Step name "${name}" is not unique in the pipeline`);
+        }
+        stepMap.set(name, step);
+        if (step.dependencies.length === 0) {
+            inits.push(name);
+        }
+    }
+}
+//# sourceMappingURL=dependency-checker.js.map

package/core/steps/pipeline/index.js

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

package/core/steps/pipeline/invalid-pipeline-error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidPipelineError = void 0;
+/**
+ * Thrown if for whatever reason, the pipeline is invalid.
+ */
+class InvalidPipelineError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidPipelineError';
+    }
+}
+exports.InvalidPipelineError = InvalidPipelineError;
+//# sourceMappingURL=invalid-pipeline-error.js.map

package/core/steps/pipeline/pipeline.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipeline = void 0;
+const create_1 = require("./create");
+/**
+ * Creates a {@link Pipeline|pipeline} from a given collection of {@link IPipelineStep|steps}.
+ * In order to be valid, the collection of {@link IPipelineStep|steps} must satisfy the following set of constraints
+ * (which should be logical, when you consider what a pipeline should accomplish):
+ *
+ * 0) the collection of {@link IPipelineStep|steps} is not empty
+ * 1) all {@link IPipelineStepOrder#name|names} of {@link IPipelineStep|steps} are unique for the given pipeline
+ * 2) all {@link IPipelineStepOrder#dependencies|dependencies} of all {@link IPipelineStep|steps} are exist
+ * 3) there are no cycles in the dependency graph
+ * 4) the target of a {@link IPipelineStepOrder#decorates|step's decoration} exists
+ * 5) if a {@link IPipelineStepOrder#decorates|decoration} applies, all of its {@link IPipelineStepOrder#dependencies|dependencies} are already in the pipeline
+ * 6) in the resulting {@link Pipeline|pipeline}, there is a strict cut between {@link IPipelineStep|steps} that are executed
+ * 		{@link PipelineStepStage#OncePerFile|once per file} and {@link PipelineStepStage#OncePerRequest|once per request}.
+ *
+ * @returns The function will try to order your collection steps so that all the constraints hold.
+ * If it succeeds it will return the resulting {@link Pipeline|pipeline}, otherwise it will throw an {@link InvalidPipelineError}.
+ *
+ * @throws InvalidPipelineError If any of the constraints listed above are not satisfied.
+ */
+function createPipeline(...steps) {
+    return (0, create_1.verifyAndBuildPipeline)(steps);
+}
+exports.createPipeline = createPipeline;
+//# sourceMappingURL=pipeline.js.map

package/core/steps/step.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Defines the {@link IPipelineStep} interface which specifies all data available for a single step.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=step.js.map

package/core/steps/steps-provider.js

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

package/core/steps/steps.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * This file defines *all* steps of the slicing process and the data they require.
+ *
+ * Note, that the order of elements here also describes the *desired* order of their desired execution for readability.
+ * However, it is the {@link SteppingSlicer} which controls the order of execution and the steps required to achieve a given result.
+ *
+ * If you add a new step, you have to (at least) update the {@link SteppingSlicer} as well as the corresponding type predicate {@link SteppingSlicerInput}.
+ * Furthermore, if your step is the new *last* step, please update {@link LAST_STEP}.
+ *
+ * Please note that the combination of `satisfies` and `as` seems to be required.
+ * With `satisfies` we make sure that the respective element has all the keys it requires, and the `as` force the type to be exactly the given one
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAST_STEP = exports.LAST_PER_FILE_STEP = exports.STEPS = exports.STEPS_PER_SLICE = exports.STEPS_PER_FILE = void 0;
+const _00_parse_1 = require("./all/core/00-parse");
+const _10_normalize_1 = require("./all/core/10-normalize");
+const _20_dataflow_1 = require("./all/core/20-dataflow");
+const _00_slice_1 = require("./all/static-slicing/00-slice");
+const _10_reconstruct_1 = require("./all/static-slicing/10-reconstruct");
+exports.STEPS_PER_FILE = {
+    'parse': _00_parse_1.PARSE_WITH_R_SHELL_STEP,
+    'normalize': _10_normalize_1.NORMALIZE,
+    'dataflow': _20_dataflow_1.LEGACY_STATIC_DATAFLOW
+};
+exports.STEPS_PER_SLICE = {
+    'slice': _00_slice_1.STATIC_SLICE,
+    'reconstruct': _10_reconstruct_1.NAIVE_RECONSTRUCT
+};
+exports.STEPS = { ...exports.STEPS_PER_FILE, ...exports.STEPS_PER_SLICE };
+exports.LAST_PER_FILE_STEP = 'dataflow';
+exports.LAST_STEP = 'reconstruct';
+//# sourceMappingURL=steps.js.map

package/core/steps.d.ts

@@ -0,0 +1,166 @@
+/**
+ * This file defines *all* steps of the slicing process and the data they require.
+ *
+ * Note, that the order of elements here also describes the *desired* order of their desired execution for readability.
+ * However, it is the {@link SteppingSlicer} which controls the order of execution and the steps required to achieve a given result.
+ *
+ * If you add a new step, you have to (at least) update the {@link SteppingSlicer} as well as the corresponding type predicate {@link SteppingSlicerInput}.
+ * Furthermore, if your step is the new *last* step, please update {@link LAST_STEP}.
+ *
+ * Please note that the combination of `satisfies` and `as` seems to be required.
+ * With `satisfies` we make sure that the respective element has all the keys it requires, and the `as` force the type to be exactly the given one
+ *
+ * @module
+ */
+import { MergeableRecord } from '../util/objects';
+import { normalize, retrieveXmlFromRCode } from '../r-bridge';
+import { produceDataFlowGraph } from '../dataflow';
+import { reconstructToCode, staticSlicing } from '../slicing';
+import { internalPrinter, IStepPrinter, StepOutputFormat } from './print/print';
+import { normalizedAstToJson, normalizedAstToQuads, printNormalizedAstToMermaid, printNormalizedAstToMermaidUrl } from './print/normalize-printer';
+import { dataflowGraphToJson, dataflowGraphToMermaid, dataflowGraphToMermaidUrl, dataflowGraphToQuads } from './print/dataflow-printer';
+import { parseToQuads } from './print/parse-printer';
+/**
+ * This represents close a function that we know completely nothing about.
+ * Nevertheless, this is the basis of what a step processor should look like.
+ */
+export type StepFunction = (...args: never[]) => unknown;
+/**
+ * This represents the required execution frequency of a step.
+ */
+export type StepRequired = 'once-per-file' | 'once-per-slice';
+/**
+ * Defines what is to be known of a single step in the slicing process.
+ */
+export interface IStep<Fn extends StepFunction> extends MergeableRecord {
+    /** Human-readable description of this step */
+    description: string;
+    /** The main processor that essentially performs the logic of this step */
+    processor: (...input: Parameters<Fn>) => ReturnType<Fn>;
+    required: StepRequired;
+    printer: {
+        [K in StepOutputFormat]?: IStepPrinter<Fn, K, never[]>;
+    } & {
+        [StepOutputFormat.Internal]: IStepPrinter<Fn, StepOutputFormat.Internal, []>;
+    };
+}
+export declare const STEPS_PER_FILE: {
+    readonly parse: {
+        description: string;
+        processor: typeof retrieveXmlFromRCode;
+        required: "once-per-file";
+        printer: {
+            0: typeof internalPrinter;
+            2: (text: string) => string;
+            5: typeof parseToQuads;
+        };
+    };
+    readonly normalize: {
+        description: string;
+        processor: typeof normalize;
+        required: "once-per-file";
+        printer: {
+            0: typeof internalPrinter;
+            2: typeof normalizedAstToJson;
+            5: typeof normalizedAstToQuads;
+            3: typeof printNormalizedAstToMermaid;
+            4: typeof printNormalizedAstToMermaidUrl;
+        };
+    };
+    readonly dataflow: {
+        description: string;
+        processor: typeof produceDataFlowGraph;
+        required: "once-per-file";
+        printer: {
+            0: typeof internalPrinter;
+            2: typeof dataflowGraphToJson;
+            5: typeof dataflowGraphToQuads;
+            3: typeof dataflowGraphToMermaid;
+            4: typeof dataflowGraphToMermaidUrl;
+        };
+    };
+};
+export declare const STEPS_PER_SLICE: {
+    readonly slice: {
+        description: string;
+        processor: typeof staticSlicing;
+        required: "once-per-slice";
+        printer: {
+            0: typeof internalPrinter;
+        };
+    };
+    readonly reconstruct: {
+        description: string;
+        processor: typeof reconstructToCode;
+        required: "once-per-slice";
+        printer: {
+            0: typeof internalPrinter;
+        };
+    };
+};
+export declare const STEPS: {
+    readonly slice: {
+        description: string;
+        processor: typeof staticSlicing;
+        required: "once-per-slice";
+        printer: {
+            0: typeof internalPrinter;
+        };
+    };
+    readonly reconstruct: {
+        description: string;
+        processor: typeof reconstructToCode;
+        required: "once-per-slice";
+        printer: {
+            0: typeof internalPrinter;
+        };
+    };
+    readonly parse: {
+        description: string;
+        processor: typeof retrieveXmlFromRCode;
+        required: "once-per-file";
+        printer: {
+            0: typeof internalPrinter;
+            2: (text: string) => string;
+            5: typeof parseToQuads;
+        };
+    };
+    readonly normalize: {
+        description: string;
+        processor: typeof normalize;
+        required: "once-per-file";
+        printer: {
+            0: typeof internalPrinter;
+            2: typeof normalizedAstToJson;
+            5: typeof normalizedAstToQuads;
+            3: typeof printNormalizedAstToMermaid;
+            4: typeof printNormalizedAstToMermaidUrl;
+        };
+    };
+    readonly dataflow: {
+        description: string;
+        processor: typeof produceDataFlowGraph;
+        required: "once-per-file";
+        printer: {
+            0: typeof internalPrinter;
+            2: typeof dataflowGraphToJson;
+            5: typeof dataflowGraphToQuads;
+            3: typeof dataflowGraphToMermaid;
+            4: typeof dataflowGraphToMermaidUrl;
+        };
+    };
+};
+export declare const LAST_PER_FILE_STEP: "dataflow";
+export declare const LAST_STEP: "reconstruct";
+export type StepName = keyof typeof STEPS;
+export type Step<Name extends StepName> = typeof STEPS[Name];
+export type StepProcessor<Name extends StepName> = Step<Name>['processor'];
+export type StepResult<Name extends StepName> = Awaited<ReturnType<StepProcessor<Name>>>;
+export declare function executeSingleSubStep<Name extends StepName, Processor extends StepProcessor<Name>>(subStep: Name, ...input: Parameters<Processor>): ReturnType<Processor>;
+type Tail<T extends unknown[]> = T extends [infer _, ...infer Rest] ? Rest : never;
+/**
+ * For a `step` of the given name, which returned the given `data`. Convert that data into the given `format`.
+ * Depending on your step and the format this may require `additional` inputs.
+ */
+export declare function printStepResult<Name extends StepName, Processor extends StepProcessor<Name>, Format extends Exclude<keyof (typeof STEPS)[Name]['printer'], StepOutputFormat.Internal> & number, Printer extends (typeof STEPS)[Name]['printer'][Format], AdditionalInput extends Tail<Parameters<Printer>>>(step: Name, data: Awaited<ReturnType<Processor>>, format: Format, ...additional: AdditionalInput): Promise<string>;
+export {};

package/core/steps.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * This file defines *all* steps of the slicing process and the data they require.
+ *
+ * Note, that the order of elements here also describes the *desired* order of their desired execution for readability.
+ * However, it is the {@link SteppingSlicer} which controls the order of execution and the steps required to achieve a given result.
+ *
+ * If you add a new step, you have to (at least) update the {@link SteppingSlicer} as well as the corresponding type predicate {@link SteppingSlicerInput}.
+ * Furthermore, if your step is the new *last* step, please update {@link LAST_STEP}.
+ *
+ * Please note that the combination of `satisfies` and `as` seems to be required.
+ * With `satisfies` we make sure that the respective element has all the keys it requires, and the `as` force the type to be exactly the given one
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printStepResult = exports.executeSingleSubStep = exports.LAST_STEP = exports.LAST_PER_FILE_STEP = exports.STEPS = exports.STEPS_PER_SLICE = exports.STEPS_PER_FILE = void 0;
+const r_bridge_1 = require("../r-bridge");
+const dataflow_1 = require("../dataflow");
+const slicing_1 = require("../slicing");
+const print_1 = require("./print/print");
+const normalize_printer_1 = require("./print/normalize-printer");
+const assert_1 = require("../util/assert");
+const dataflow_printer_1 = require("./print/dataflow-printer");
+const parse_printer_1 = require("./print/parse-printer");
+exports.STEPS_PER_FILE = {
+    'parse': {
+        description: 'Parse the given R code into an AST',
+        processor: r_bridge_1.retrieveXmlFromRCode,
+        required: 'once-per-file',
+        printer: {
+            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
+            [2 /* StepOutputFormat.Json */]: text => text,
+            [5 /* StepOutputFormat.RdfQuads */]: parse_printer_1.parseToQuads
+        }
+    },
+    'normalize': {
+        description: 'Normalize the AST to flowR\'s AST (first step of the normalization)',
+        processor: r_bridge_1.normalize,
+        required: 'once-per-file',
+        printer: {
+            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
+            [2 /* StepOutputFormat.Json */]: normalize_printer_1.normalizedAstToJson,
+            [5 /* StepOutputFormat.RdfQuads */]: normalize_printer_1.normalizedAstToQuads,
+            [3 /* StepOutputFormat.Mermaid */]: normalize_printer_1.printNormalizedAstToMermaid,
+            [4 /* StepOutputFormat.MermaidUrl */]: normalize_printer_1.printNormalizedAstToMermaidUrl
+        }
+    },
+    'dataflow': {
+        description: 'Construct the dataflow graph',
+        processor: dataflow_1.produceDataFlowGraph,
+        required: 'once-per-file',
+        printer: {
+            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
+            [2 /* StepOutputFormat.Json */]: dataflow_printer_1.dataflowGraphToJson,
+            [5 /* StepOutputFormat.RdfQuads */]: dataflow_printer_1.dataflowGraphToQuads,
+            [3 /* StepOutputFormat.Mermaid */]: dataflow_printer_1.dataflowGraphToMermaid,
+            [4 /* StepOutputFormat.MermaidUrl */]: dataflow_printer_1.dataflowGraphToMermaidUrl
+        }
+    }
+};
+exports.STEPS_PER_SLICE = {
+    'slice': {
+        description: 'Calculate the actual static slice from the dataflow graph and the given slicing criteria',
+        processor: slicing_1.staticSlicing,
+        required: 'once-per-slice',
+        printer: {
+            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
+        }
+    },
+    'reconstruct': {
+        description: 'Reconstruct R code from the static slice',
+        processor: slicing_1.reconstructToCode,
+        required: 'once-per-slice',
+        printer: {
+            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
+        }
+    }
+};
+exports.STEPS = { ...exports.STEPS_PER_FILE, ...exports.STEPS_PER_SLICE };
+exports.LAST_PER_FILE_STEP = 'dataflow';
+exports.LAST_STEP = 'reconstruct';
+function executeSingleSubStep(subStep, ...input) {
+    // @ts-expect-error - this is safe, as we know that the function arguments are correct by 'satisfies', this saves an explicit cast with 'as'
+    return exports.STEPS[subStep].processor(...input);
+}
+exports.executeSingleSubStep = executeSingleSubStep;
+/**
+ * For a `step` of the given name, which returned the given `data`. Convert that data into the given `format`.
+ * Depending on your step and the format this may require `additional` inputs.
+ */
+function printStepResult(step, data, format, ...additional) {
+    const base = exports.STEPS[step].printer;
+    const printer = base[format];
+    (0, assert_1.guard)(printer !== undefined, `printer for ${step} does not support ${String(format)}`);
+    return printer(data, ...additional);
+}
+exports.printStepResult = printStepResult;
+//# sourceMappingURL=steps.js.map

package/dataflow/common/environments/append.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendEnvironments = void 0;
+const assert_1 = require("../../../util/assert");
+const environment_1 = require("./environment");
+function uniqueMergeValues(old, value) {
+    const result = old;
+    for (const v of value) {
+        const find = result.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
+        if (find < 0) {
+            result.push(v);
+        }
+    }
+    return result;
+}
+function appendIEnvironmentWith(base, next) {
+    (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not append environments with undefined');
+    (0, assert_1.guard)(base.name === next.name, 'cannot overwrite environments with different names');
+    const map = new Map(base.memory);
+    for (const [key, value] of next.memory) {
+        const old = map.get(key);
+        if (old) {
+            map.set(key, uniqueMergeValues(old, value));
+        }
+        else {
+            map.set(key, value);
+        }
+    }
+    const parent = base.parent === undefined ? undefined : appendIEnvironmentWith(base.parent, next.parent);
+    const out = new environment_1.Environment(base.name, parent);
+    out.memory = map;
+    return out;
+}
+function appendEnvironments(base, next) {
+    if (base === undefined) {
+        return next;
+    }
+    else if (next === undefined) {
+        return base;
+    }
+    (0, assert_1.guard)(base.level === next.level, 'environments must have the same level to be handled, it is up to the caller to ensure that');
+    return {
+        current: appendIEnvironmentWith(base.current, next.current),
+        level: base.level,
+    };
+}
+exports.appendEnvironments = appendEnvironments;
+//# sourceMappingURL=append.js.map