@eagleoutice/flowr 1.3.11

package/core/slicer.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SteppingSlicer = void 0;
+const steps_1 = require("./steps");
+const assert_1 = require("../util/assert");
+/**
+ * This is ultimately the root of flowR's static slicing procedure.
+ * It clearly defines the steps that are to be executed and splits them into two stages.
+ * - `once-per-file`: for steps that are executed once per file. These can be performed *without* the knowledge of a slicing criteria,
+ *   and they can be cached and re-used if you want to slice the same file multiple times.
+ * - `once-per-slice`: for steps that are executed once per slice. These can only be performed *with* a slicing criteria.
+ *
+ * Furthermore, this stepper follows an iterable fashion to be *as flexible as possible* (e.g., to be instrumented with measurements).
+ * So, you can use the stepping slicer like this:
+ *
+ * ```ts
+ * const slicer = new SteppingSlicer({ ... })
+ * while(slicer.hasNextStep()) {
+ *     await slicer.nextStep()
+ * }
+ *
+ * slicer.switchToSliceStage()
+ *
+ * while(slicer.hasNextStep()) {
+ *     await slicer.nextStep()
+ * }
+ *
+ * const result = slicer.getResults()
+ * ```
+ *
+ * Of course, you might think, that this is rather overkill if you simply want to receive the slice of a given input source or in general
+ * the result of any step. And this is true. Therefore, if you do not want to perform some kind of magic in-between steps, you can use the
+ * **{@link allRemainingSteps}** function like this:
+ *
+ * ```ts
+ * const slicer = new SteppingSlicer({ ... })
+ * const result = await slicer.allRemainingSteps()
+ * ```
+ *
+ * As the name suggest, you can combine this name with previous calls to {@link nextStep} to only execute the remaining steps.
+ *
+ * Giving the **step of interest** allows you to declare the maximum step to execute.
+ * So, if you pass `dataflow` as the step of interest, the stepping slicer will stop after the dataflow step.
+ * If you do not pass a step, the stepping slicer will execute all steps.
+ *
+ * By default, the {@link SteppingSlicer} does not offer an automatic way to repeat the per-slice steps for multiple slices (this is mostly to prevent accidental errors).
+ * However, you can use the **{@link updateCriterion}** function to reset the per-slice steps and re-execute them for a new slice. This allows something like the following:
+ *
+ * ```ts
+ * const slicer = new SteppingSlicer({ ... })
+ * const result = await slicer.allRemainingSteps()
+ *
+ * slicer.updateCriterion(...)
+ * const result2 = await slicer.allRemainingSteps()
+ * ```
+ *
+ * @note Even though, using the stepping slicer introduces some performance overhead, we consider
+ * it to be the baseline for performance benchmarking. It may very well be possible to squeeze out some more performance by
+ * directly constructing the steps in the right order. However, we consider this to be negligible when compared with the time required
+ * for, for example, the dataflow analysis.
+ *
+ * @see retrieveResultOfStep
+ * @see SteppingSlicer#doNextStep
+ * @see StepName
+ */
+class SteppingSlicer {
+    static maximumNumberOfStepsPerFile = Object.keys(steps_1.STEPS_PER_FILE).length;
+    static maximumNumberOfStepsPerSlice = SteppingSlicer.maximumNumberOfStepsPerFile + Object.keys(steps_1.STEPS_PER_SLICE).length;
+    shell;
+    stepOfInterest;
+    request;
+    hooks;
+    getId;
+    criterion;
+    results = {};
+    stage = 'once-per-file';
+    stepCounter = 0;
+    reachedWanted = false;
+    /**
+     * Create a new stepping slicer. For more details on the arguments please see {@link SteppingSlicerInput}.
+     */
+    constructor(input) {
+        this.shell = input.shell;
+        this.request = input.request;
+        this.hooks = input.hooks;
+        this.getId = input.getId;
+        this.stepOfInterest = (input.stepOfInterest ?? steps_1.LAST_STEP);
+        this.criterion = input.criterion;
+    }
+    /**
+     * Retrieve the current stage the stepping slicer is in.
+     * @see StepRequired
+     * @see switchToSliceStage
+     */
+    getCurrentStage() {
+        return this.stage;
+    }
+    /**
+     * Switch to the next stage of the stepping slicer.
+     * @see SteppingSlicer
+     * @see getCurrentStage
+     */
+    switchToSliceStage() {
+        (0, assert_1.guard)(this.stepCounter === SteppingSlicer.maximumNumberOfStepsPerFile, 'First need to complete all steps before switching');
+        (0, assert_1.guard)(this.stage === 'once-per-file', 'Cannot switch to next stage, already in once-per-slice stage');
+        this.stage = 'once-per-slice';
+    }
+    /**
+     * Returns the result of the step of interest, as well as the results of all steps before it.
+     *
+     * @param intermediate - normally you can only receive the results *after* the stepper completed the step of interested.
+     * 		 However, if you pass `true` to this parameter, you can also receive the results *before* the step of interest,
+     * 		 although the typing system then can not guarantee which of the steps have already happened.
+     */
+    getResults(intermediate = false) {
+        (0, assert_1.guard)(intermediate || this.reachedWanted, 'Before reading the results, we need to reach the step we are interested in');
+        return this.results;
+    }
+    /**
+     * Returns true only if 1) there are more steps to-do for the current stage and 2) we have not yet reached the step we are interested in
+     */
+    hasNextStep() {
+        return !this.reachedWanted && (this.stage === 'once-per-file' ?
+            this.stepCounter < SteppingSlicer.maximumNumberOfStepsPerFile
+            : this.stepCounter < SteppingSlicer.maximumNumberOfStepsPerSlice);
+    }
+    /**
+     * Execute the next step (guarded with {@link hasNextStep}) and return the name of the step that was executed, so you can guard if the step differs from what you are interested in.
+     * Furthermore, it returns the step's result.
+     *
+     * The `step` parameter is a safeguard if you want to retrieve the result.
+     * If given, it causes the execution to fail if the next step is not the one you expect.
+     * *Without step, please refrain from accessing the result.*
+     */
+    async nextStep(expectedStepName) {
+        (0, assert_1.guard)(this.hasNextStep(), 'No more steps to do');
+        const guardStep = this.getGuardStep(expectedStepName);
+        const { step, result } = await this.doNextStep(guardStep);
+        this.results[step] = result;
+        this.stepCounter += 1;
+        if (this.stepOfInterest === step) {
+            this.reachedWanted = true;
+        }
+        return { name: step, result: result };
+    }
+    getGuardStep(expectedStepName) {
+        return expectedStepName === undefined ?
+            (name) => name
+            :
+                (name) => {
+                    (0, assert_1.guard)(expectedStepName === name, `Expected step ${expectedStepName} but got ${name}`);
+                    return name;
+                };
+    }
+    async doNextStep(guardStep) {
+        let step;
+        let result;
+        switch (this.stepCounter) {
+            case 0:
+                step = guardStep('parse');
+                result = await (0, steps_1.executeSingleSubStep)(step, this.request, this.shell);
+                break;
+            case 1:
+                step = guardStep('normalize');
+                result = await (0, steps_1.executeSingleSubStep)(step, this.results.parse, await this.shell.tokenMap(), this.hooks, this.getId);
+                break;
+            case 2:
+                step = guardStep('dataflow');
+                result = (0, steps_1.executeSingleSubStep)(step, this.results.normalize);
+                break;
+            case 3:
+                (0, assert_1.guard)(this.criterion !== undefined, 'Cannot decode criteria without a criterion');
+                step = guardStep('slice');
+                result = (0, steps_1.executeSingleSubStep)(step, this.results.dataflow.graph, this.results.normalize, this.criterion);
+                break;
+            case 4:
+                step = guardStep('reconstruct');
+                result = (0, steps_1.executeSingleSubStep)(step, this.results.normalize, this.results.slice.result);
+                break;
+            default:
+                throw new Error(`Unknown step ${this.stepCounter}, reaching this should not happen!`);
+        }
+        return { step, result };
+    }
+    /**
+     * This only makes sense if you have already sliced a file (e.g., by running up to the `slice` step) and want to do so again while caching the results.
+     * Or if for whatever reason you did not pass a criterion with the constructor.
+     *
+     * @param newCriterion - the new slicing criterion to use for the next slice
+     */
+    updateCriterion(newCriterion) {
+        (0, assert_1.guard)(this.stepCounter >= SteppingSlicer.maximumNumberOfStepsPerFile, 'Cannot reset slice prior to once-per-slice stage');
+        this.criterion = newCriterion;
+        this.stepCounter = SteppingSlicer.maximumNumberOfStepsPerFile;
+        this.results.slice = undefined;
+        this.results.reconstruct = undefined;
+        if (this.stepOfInterest === 'slice' || this.stepOfInterest === 'reconstruct') {
+            this.reachedWanted = false;
+        }
+    }
+    /**
+     * Execute all remaining steps and automatically call {@link switchToSliceStage} if necessary.
+     * @param canSwitchStage - if true, automatically switch to the slice stage if necessary
+     *       (i.e., this is what you want if you have never executed {@link nextStep} and you want to execute *all* steps).
+     *       However, passing false allows you to only execute the steps of the 'once-per-file' stage (i.e., the steps that can be cached).
+     *
+     * @note There is a small type difference if you pass 'false' and already have manually switched to the 'once-per-slice' stage.
+     *       Because now, the results of these steps are no longer part of the result type (although they are still included).
+     *       In such a case, you may be better off with simply passing 'true' as the function will detect that the stage is already switched.
+     *       We could solve this type problem by separating the SteppingSlicer class into two for each stage, but this would break the improved readability and unified handling
+     *       of the slicer that I wanted to achieve with this class.
+     */
+    async allRemainingSteps(canSwitchStage = true) {
+        while (this.hasNextStep()) {
+            await this.nextStep();
+        }
+        if (canSwitchStage && !this.reachedWanted && this.stage === 'once-per-file') {
+            this.switchToSliceStage();
+            while (this.hasNextStep()) {
+                await this.nextStep();
+            }
+        }
+        return this.reachedWanted ? this.getResults() : this.getResults(true);
+    }
+}
+exports.SteppingSlicer = SteppingSlicer;
+//# sourceMappingURL=slicer.js.map

package/core/stepping-slicer.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SteppingSlicer = void 0;
+const steps_1 = require("./steps");
+const pipeline_1 = require("./steps/pipeline");
+const _00_parse_1 = require("./steps/all/core/00-parse");
+const _10_normalize_1 = require("./steps/all/core/10-normalize");
+const _20_dataflow_1 = require("./steps/all/core/20-dataflow");
+const _00_slice_1 = require("./steps/all/static-slicing/00-slice");
+const _10_reconstruct_1 = require("./steps/all/static-slicing/10-reconstruct");
+const pipeline_executor_1 = require("./pipeline-executor");
+const legacyPipelines = {
+    // brrh, but who cares, it is legacy!
+    'parse': (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP),
+    'normalize': (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE),
+    'dataflow': (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE, _20_dataflow_1.LEGACY_STATIC_DATAFLOW),
+    'slice': (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),
+    'reconstruct': (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)
+};
+function getLegacyPipeline(interestedIn) {
+    return legacyPipelines[interestedIn];
+}
+/**
+ * This is ultimately the root of flowR's static slicing procedure.
+ * It clearly defines the steps that are to be executed and splits them into two stages.
+ * - `once-per-file`: for steps that are executed once per file. These can be performed *without* the knowledge of a slicing criteria,
+ *   and they can be cached and re-used if you want to slice the same file multiple times.
+ * - `once-per-slice`: for steps that are executed once per slice. These can only be performed *with* a slicing criteria.
+ *
+ * Furthermore, this stepper follows an iterable fashion to be *as flexible as possible* (e.g., to be instrumented with measurements).
+ * So, you can use the stepping slicer like this:
+ *
+ * ```ts
+ * const slicer = new SteppingSlicer({ ... })
+ * while(slicer.hasNextStep()) {
+ *     await slicer.nextStep()
+ * }
+ *
+ * slicer.switchToSliceStage()
+ *
+ * while(slicer.hasNextStep()) {
+ *     await slicer.nextStep()
+ * }
+ *
+ * const result = slicer.getResults()
+ * ```
+ *
+ * Of course, you might think, that this is rather overkill if you simply want to receive the slice of a given input source or in general
+ * the result of any step. And this is true. Therefore, if you do not want to perform some kind of magic in-between steps, you can use the
+ * **{@link allRemainingSteps}** function like this:
+ *
+ * ```ts
+ * const slicer = new SteppingSlicer({ ... })
+ * const result = await slicer.allRemainingSteps()
+ * ```
+ *
+ * As the name suggest, you can combine this name with previous calls to {@link nextStep} to only execute the remaining steps.
+ *
+ * Giving the **step of interest** allows you to declare the maximum step to execute.
+ * So, if you pass `dataflow` as the step of interest, the stepping slicer will stop after the dataflow step.
+ * If you do not pass a step, the stepping slicer will execute all steps.
+ *
+ * By default, the {@link SteppingSlicer} does not offer an automatic way to repeat the per-slice steps for multiple slices (this is mostly to prevent accidental errors).
+ * However, you can use the **{@link updateCriterion}** function to reset the per-slice steps and re-execute them for a new slice. This allows something like the following:
+ *
+ * ```ts
+ * const slicer = new SteppingSlicer({ ... })
+ * const result = await slicer.allRemainingSteps()
+ *
+ * slicer.updateCriterion(...)
+ * const result2 = await slicer.allRemainingSteps()
+ * ```
+ *
+ * @note Even though, using the stepping slicer introduces some performance overhead, we consider
+ * it to be the baseline for performance benchmarking. It may very well be possible to squeeze out some more performance by
+ * directly constructing the steps in the right order. However, we consider this to be negligible when compared with the time required
+ * for, for example, the dataflow analysis.
+ *
+ * @see retrieveResultOfStep
+ * @see StepName
+ */
+class SteppingSlicer {
+    executor;
+    /**
+     * Create a new stepping slicer. For more details on the arguments please see {@link SteppingSlicerInput}.
+     */
+    constructor(input) {
+        this.executor = new pipeline_executor_1.PipelineExecutor(getLegacyPipeline(input.stepOfInterest ?? steps_1.LAST_STEP), input);
+    }
+    /**
+     * Retrieve the current stage the stepping slicer is in.
+     * @see PipelineStepStage
+     * @see switchToSliceStage
+     */
+    getCurrentStage() {
+        return this.executor.getCurrentStage();
+    }
+    /**
+     * Switch to the next stage of the stepping slicer.
+     * @see SteppingSlicer
+     * @see getCurrentStage
+     */
+    switchToSliceStage() {
+        this.executor.switchToRequestStage();
+    }
+    /**
+     * Returns the result of the step of interest, as well as the results of all steps before it.
+     *
+     * @param intermediate - normally you can only receive the results *after* the stepper completed the step of interested.
+     * 		 However, if you pass `true` to this parameter, you can also receive the results *before* the step of interest,
+     * 		 although the typing system then can not guarantee which of the steps have already happened.
+     */
+    getResults(intermediate = false) {
+        return this.executor.getResults(intermediate);
+    }
+    /**
+     * Returns true only if 1) there are more steps to-do for the current stage and 2) we have not yet reached the step we are interested in
+     */
+    hasNextStep() {
+        return this.executor.hasNextStep();
+    }
+    /**
+     * Execute the next step (guarded with {@link hasNextStep}) and return the name of the step that was executed, so you can guard if the step differs from what you are interested in.
+     * Furthermore, it returns the step's result.
+     *
+     * The `step` parameter is a safeguard if you want to retrieve the result.
+     * If given, it causes the execution to fail if the next step is not the one you expect.
+     * *Without step, please refrain from accessing the result.*
+     */
+    async nextStep(expectedStepName) {
+        return this.executor.nextStep(expectedStepName);
+    }
+    /**
+     * This only makes sense if you have already sliced a file (e.g., by running up to the `slice` step) and want to do so again while caching the results.
+     * Or if for whatever reason you did not pass a criterion with the constructor.
+     *
+     * @param newCriterion - the new slicing criterion to use for the next slice
+     */
+    updateCriterion(newCriterion) {
+        // @ts-expect-error -- it is legacy
+        this.executor.updateRequest({ criterion: newCriterion });
+    }
+    /**
+     * Execute all remaining steps and automatically call {@link switchToSliceStage} if necessary.
+     * @param canSwitchStage - if true, automatically switch to the slice stage if necessary
+     *       (i.e., this is what you want if you have never executed {@link nextStep} and you want to execute *all* steps).
+     *       However, passing false allows you to only execute the steps of the 'once-per-file' stage (i.e., the steps that can be cached).
+     *
+     * @note There is a small type difference if you pass 'false' and already have manually switched to the 'once-per-slice' stage.
+     *       Because now, the results of these steps are no longer part of the result type (although they are still included).
+     *       In such a case, you may be better off with simply passing 'true' as the function will detect that the stage is already switched.
+     *       We could solve this type problem by separating the SteppingSlicer class into two for each stage, but this would break the improved readability and unified handling
+     *       of the slicer that I wanted to achieve with this class.
+     */
+    async allRemainingSteps(canSwitchStage = true) {
+        return this.executor.allRemainingSteps(canSwitchStage);
+    }
+}
+exports.SteppingSlicer = SteppingSlicer;
+//# sourceMappingURL=stepping-slicer.js.map

package/core/steps/all/00-parse.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARSE_WITH_R_SHELL_STEP = void 0;
+const print_1 = require("../../print/print");
+const parse_printer_1 = require("../../print/parse-printer");
+const r_bridge_1 = require("../../../r-bridge");
+exports.PARSE_WITH_R_SHELL_STEP = {
+    name: '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
+    },
+    dependencies: []
+};
+//# sourceMappingURL=00-parse.js.map

package/core/steps/all/10-normalize.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NORMALIZE = void 0;
+const r_bridge_1 = require("../../../r-bridge");
+const print_1 = require("../../print/print");
+const normalize_printer_1 = require("../../print/normalize-printer");
+exports.NORMALIZE = {
+    name: '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
+    },
+    dependencies: ['parse']
+};
+//# sourceMappingURL=10-normalize.js.map

package/core/steps/all/20-dataflow.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_STATIC_DATAFLOW = void 0;
+const print_1 = require("../../print/print");
+const dataflow_1 = require("../../../dataflow");
+const dataflow_printer_1 = require("../../print/dataflow-printer");
+exports.LEGACY_STATIC_DATAFLOW = {
+    name: '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
+    },
+    dependencies: ['normalize']
+};
+//# sourceMappingURL=20-dataflow.js.map

package/core/steps/all/30-slice.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATIC_SLICE = void 0;
+const print_1 = require("../../print/print");
+const slicing_1 = require("../../../slicing");
+exports.STATIC_SLICE = {
+    name: '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
+    },
+    dependencies: ['dataflow']
+};
+//# sourceMappingURL=30-slice.js.map

package/core/steps/all/40-reconstruct.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAIVE_RECONSTRUCT = void 0;
+const print_1 = require("../../print/print");
+const slicing_1 = require("../../../slicing");
+exports.NAIVE_RECONSTRUCT = {
+    name: 'reconstruct',
+    description: 'Reconstruct R code from the static slice',
+    processor: slicing_1.reconstructToCode,
+    required: 'once-per-slice',
+    printer: {
+        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
+    },
+    dependencies: ['slice']
+};
+//# sourceMappingURL=40-reconstruct.js.map

package/core/steps/all/core/00-parse.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARSE_WITH_R_SHELL_STEP = void 0;
+const print_1 = require("../../../print/print");
+const parse_printer_1 = require("../../../print/parse-printer");
+const r_bridge_1 = require("../../../../r-bridge");
+function processor(_results, input) {
+    return (0, r_bridge_1.retrieveXmlFromRCode)(input.request, input.shell);
+}
+exports.PARSE_WITH_R_SHELL_STEP = {
+    name: 'parse',
+    humanReadableName: 'parse with R shell',
+    description: 'Parse the given R code into an AST',
+    processor,
+    executed: 0 /* PipelineStepStage.OncePerFile */,
+    printer: {
+        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
+        [2 /* StepOutputFormat.Json */]: text => text,
+        [5 /* StepOutputFormat.RdfQuads */]: parse_printer_1.parseToQuads
+    },
+    dependencies: [],
+    requiredInput: undefined
+};
+//# sourceMappingURL=00-parse.js.map

package/core/steps/all/core/10-normalize.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESUGAR_NORMALIZE = exports.NORMALIZE = void 0;
+const r_bridge_1 = require("../../../../r-bridge");
+const print_1 = require("../../../print/print");
+const normalize_printer_1 = require("../../../print/normalize-printer");
+const normalize_1 = require("../../../../r-bridge/lang-4.x/ast/parser/xml/v2/normalize");
+async function processor(results, input) {
+    return (0, r_bridge_1.normalize)(results.parse, await input.shell.tokenMap(), input.hooks, input.getId);
+}
+exports.NORMALIZE = {
+    name: 'normalize',
+    humanReadableName: 'v1 normalize',
+    description: 'Normalize the AST to flowR\'s AST',
+    processor,
+    executed: 0 /* PipelineStepStage.OncePerFile */,
+    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
+    },
+    dependencies: ['parse'],
+    requiredInput: undefined
+};
+async function desugarProcessor(results, input) {
+    return (0, normalize_1.normalize)(results.parse, await input.shell.tokenMap(), input.getId);
+}
+exports.DESUGAR_NORMALIZE = {
+    name: 'normalize',
+    humanReadableName: 'v2 normalize',
+    description: 'Normalize the AST to flowR\'s AST (v2, with desugaring)',
+    processor: desugarProcessor,
+    executed: 0 /* PipelineStepStage.OncePerFile */,
+    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
+    },
+    dependencies: ['parse'],
+    requiredInput: undefined
+};
+//# sourceMappingURL=10-normalize.js.map

package/core/steps/all/core/20-dataflow.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V2_STATIC_DATAFLOW = exports.LEGACY_STATIC_DATAFLOW = void 0;
+const print_1 = require("../../../print/print");
+const v1_1 = require("../../../../dataflow/v1");
+const dataflow_printer_1 = require("../../../print/dataflow-printer");
+const entry_1 = require("../../../../dataflow/v2/entry");
+const staticDataflowCommon = {
+    name: 'dataflow',
+    description: 'Construct the dataflow graph',
+    executed: 0 /* PipelineStepStage.OncePerFile */,
+    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
+    },
+    dependencies: ['normalize'],
+};
+function legacyProcessor(results) {
+    return (0, v1_1.produceDataFlowGraph)(results.normalize);
+}
+exports.LEGACY_STATIC_DATAFLOW = {
+    ...staticDataflowCommon,
+    humanReadableName: 'v1 dataflow',
+    processor: legacyProcessor,
+    requiredInput: {}
+};
+function v2Processor() {
+    return (0, entry_1.produceDataFlowGraph)();
+}
+exports.V2_STATIC_DATAFLOW = {
+    ...staticDataflowCommon,
+    humanReadableName: 'v2 dataflow',
+    processor: v2Processor,
+    requiredInput: {}
+};
+//# sourceMappingURL=20-dataflow.js.map

package/core/steps/all/static-slicing/00-slice.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATIC_SLICE = void 0;
+const print_1 = require("../../../print/print");
+const slicing_1 = require("../../../../slicing");
+function processor(results, input) {
+    return (0, slicing_1.staticSlicing)(results.dataflow.graph, results.normalize, input.criterion, input.threshold);
+}
+exports.STATIC_SLICE = {
+    name: 'slice',
+    humanReadableName: 'static slice',
+    description: 'Calculate the actual static slice from the dataflow graph and the given slicing criteria',
+    processor,
+    executed: 1 /* PipelineStepStage.OncePerRequest */,
+    printer: {
+        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
+    },
+    dependencies: ['dataflow'],
+    requiredInput: undefined
+};
+//# sourceMappingURL=00-slice.js.map

package/core/steps/all/static-slicing/10-reconstruct.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAIVE_RECONSTRUCT = void 0;
+const print_1 = require("../../../print/print");
+const slicing_1 = require("../../../../slicing");
+function processor(results, input) {
+    return (0, slicing_1.reconstructToCode)(results.normalize, results.slice.result, input.autoSelectIf);
+}
+exports.NAIVE_RECONSTRUCT = {
+    name: 'reconstruct',
+    humanReadableName: 'static code reconstruction',
+    description: 'Reconstruct R code from the static slice',
+    processor,
+    executed: 1 /* PipelineStepStage.OncePerRequest */,
+    printer: {
+        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
+    },
+    dependencies: ['slice'],
+    requiredInput: undefined
+};
+//# sourceMappingURL=10-reconstruct.js.map

package/core/steps/index.js

@@ -0,0 +1,21 @@
+"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("./output"), exports);
+__exportStar(require("./step"), exports);
+__exportStar(require("./steps"), exports);
+__exportStar(require("./input"), exports);
+//# sourceMappingURL=index.js.map