@eagleoutice/flowr 1.3.11

package/core/pipeline-executor.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineExecutor = void 0;
+const assert_1 = require("../util/assert");
+/**
+ * The pipeline executor allows to execute arbitrary {@link Pipeline|pipelines} in a step-by-step fashion.
+ * If you are not yet in the possession of a {@link Pipeline|pipeline}, you can use the {@link createPipeline} function
+ * to create one for yourself, based on the steps that you want to execute.
+ *
+ * Those steps are split into two phases or "stages" (which is the name that we will use in the following), represented
+ * by the {@link PipelineStepStage} type. These allow us to separate things that have to be done
+ * once per-file, e.g., actually parsing the AST, from those, that we need to repeat 'once per request' (whatever this
+ * request may be). In other words, what can be cached between operations and what can not.
+ *
+ * Furthermore, this executor follows an iterable fashion to be *as flexible as possible*
+ * (e.g., to be instrumented with measurements). So, you can use the pipeline executor like this:
+ *
+ * ```ts
+ * const stepper = new PipelineExecutor( ... )
+ * while(stepper.hasNextStep()) {
+ *     await stepper.nextStep()
+ * }
+ *
+ * stepper.switchToRequestStage()
+ *
+ * while(stepper.hasNextStep()) {
+ *     await stepper.nextStep()
+ * }
+ *
+ * const result = stepper.getResults()
+ * ```
+ *
+ * Of course, you might think, that this is rather overkill if you simply want to receive the result.
+ * 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 stepper = new PipelineExecutor( ... )
+ * const result = await stepper.allRemainingSteps()
+ * ```
+ *
+ * As the name suggest, you can combine this name with previous calls to {@link nextStep} to only execute the remaining
+ * steps in case, for whatever reason you only want to instrument some steps.
+ *
+ * By default, the {@link PipelineExecutor} does not offer an automatic way to repeat requests (mostly to prevent accidental errors).
+ * However, you can use the
+ * **{@link updateRequest}** function to reset the request steps and re-execute them for a new request. This allows something like the following:
+ *
+ * ```ts
+ * const stepper = new PipelineExecutor( ... )
+ * const result = await stepper.allRemainingSteps()
+ *
+ * stepper.updateRequest( ... )
+ * const result2 = await stepper.allRemainingSteps()
+ * ```
+ *
+ * **Example - Slicing With the Pipeline Executor**:
+ *
+ * Suppose, you want to... you know _slice_ a file (which was, at one point the origin of flowR), then you can
+ * either create a pipeline yourself with the respective steps, or you can use the {@link DEFAULT_SLICING_PIPELINE} (and friends).
+ * With it, slicing essentially becomes 'easy-as-pie':
+ *
+ * ```ts
+ * const slicer = new PipelineExecutor(DEFAULT_SLICING_PIPELINE, {
+ *    shell:     new RShell(),
+ *    // of course, the criterion and request given here are just examples, you can use whatever you want to slice!
+ *    criterion: ['2@b'],
+ *    request:   requestFromInput('b <- 3; x <- 5\ncat(b)'),
+ * })
+ * const result = await slicer.allRemainingSteps()
+ * ```
+ *
+ * But now, we want to slice for `x` in the first line as well! We can do that by adding:
+ *
+ * ```ts
+ * stepper.updateRequest({ criterion: ['1@x'] })
+ * const result2 = await stepper.allRemainingSteps()
+ * ```
+ *
+ * @note Even though using the pipeline executor introduces a small performance overhead, we consider
+ * it to be the baseline for performance benchmarking. It may very well be possible to squeeze out a little bit more 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 of larger files.
+ *
+ * @see PipelineExecutor#allRemainingSteps
+ * @see PipelineExecutor#nextStep
+ */
+class PipelineExecutor {
+    pipeline;
+    length;
+    input;
+    output = {};
+    currentExecutionStage = 0 /* PipelineStepStage.OncePerFile */;
+    stepCounter = 0;
+    /**
+     * Construct a new pipeline executor.
+     * The required additional input is specified by the {@link IPipelineStep#requiredInput|required input configuration} of each step in the `pipeline`.
+     *
+     * @param pipeline - The {@link Pipeline} to execute, probably created with {@link createPipeline}.
+     * @param input    - External {@link PipelineInput|configuration and input} required to execute the given pipeline.
+     */
+    constructor(pipeline, input) {
+        this.pipeline = pipeline;
+        this.length = pipeline.order.length;
+        this.input = input;
+    }
+    /**
+     * Retrieve the current {@link PipelineStepStage|stage} the pipeline executor is in.
+     *
+     * @see currentExecutionStage
+     * @see switchToRequestStage
+     * @see PipelineStepStage
+     */
+    getCurrentStage() {
+        return this.currentExecutionStage;
+    }
+    /**
+     * Switch to the next {@link PipelineStepStage|stage} of the pipeline executor.
+     *
+     * This will fail if either a step change is currently not valid (as not all steps have been executed),
+     * or if there is no next stage (i.e., the pipeline is already completed or in the last stage).
+     *
+     * @see PipelineExecutor
+     * @see getCurrentStage
+     */
+    switchToRequestStage() {
+        (0, assert_1.guard)(this.stepCounter === this.pipeline.firstStepPerRequest, 'First need to complete all steps before switching');
+        (0, assert_1.guard)(this.currentExecutionStage === 0 /* PipelineStepStage.OncePerFile */, 'Cannot switch to next stage, already in per-request stage.');
+        this.currentExecutionStage = 1 /* PipelineStepStage.OncePerRequest */;
+    }
+    /**
+     * Returns the results of the pipeline.
+     *
+     * @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 {@link PipelineExecutor|pipeline executor}
+     * 		 completed, although the typing system then can not guarantee which of the steps have already happened.
+     */
+    getResults(intermediate = false) {
+        (0, assert_1.guard)(intermediate || this.stepCounter >= this.length, 'Without the intermediate flag, the pipeline must be completed before providing access to the results.');
+        return this.output;
+    }
+    /**
+     * Returns true only if
+     * 1) there are more {@link IPipelineStep|steps} to-do for the current {@link PipelineStepStage|stage} and
+     * 2) we have not yet reached the end of the {@link Pipeline|pipeline}.
+     */
+    hasNextStep() {
+        return (this.stepCounter < this.length && this.currentExecutionStage !== 0 /* PipelineStepStage.OncePerFile */)
+            || this.stepCounter < this.pipeline.firstStepPerRequest;
+    }
+    /**
+     * Execute the next {@link IPipelineStep|step} and return the name of the {@link IPipelineStep|step} that was executed,
+     * so you can guard if the {@link IPipelineStep|step} differs from what you are interested in.
+     * Furthermore, it returns the {@link IPipelineStep|step's} result.
+     *
+     * @param expectedStepName - 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 `expectedStepName`, please refrain from accessing the result, as you have no safeguards if the pipeline changes._
+     */
+    async nextStep(expectedStepName) {
+        const [step, result] = this._doNextStep(expectedStepName);
+        const awaitedResult = await result;
+        this.output[step] = awaitedResult;
+        this.stepCounter++;
+        return { name: step, result: awaitedResult };
+    }
+    _doNextStep(expectedStepName) {
+        const step = this.pipeline.steps.get(this.pipeline.order[this.stepCounter]);
+        (0, assert_1.guard)(step !== undefined, () => `Cannot execute next step, step ${this.pipeline.order[this.stepCounter]} does not exist.`);
+        if (expectedStepName !== undefined) {
+            (0, assert_1.guard)(step.name === expectedStepName, () => `Cannot execute next step, expected step ${JSON.stringify(expectedStepName)} but got ${step.name}.`);
+        }
+        return [step.name, step.processor(this.output, this.input)];
+    }
+    /**
+     * This only makes sense if you have already run a request and want to re-use the per-file results for a new one.
+     * (or if for whatever reason you did not pass information for the pipeline with the constructor).
+     *
+     * @param newRequestData - Data for the new request
+     */
+    updateRequest(newRequestData) {
+        const requestStep = this.pipeline.firstStepPerRequest;
+        (0, assert_1.guard)(this.stepCounter >= requestStep, 'Cannot reset request prior to once-per-request stage');
+        this.input = {
+            ...this.input,
+            ...newRequestData
+        };
+        this.stepCounter = requestStep;
+        // clear the results for all steps with an index >= firstStepPerRequest, this is more of a sanity check
+        for (let i = requestStep; i < this.length; i++) {
+            this.output[this.pipeline.order[i]] = undefined;
+        }
+    }
+    /**
+     * Execute all remaining steps and automatically call {@link switchToRequestStage} if necessary.
+     * @param canSwitchStage - If true, automatically switch to the request 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-request' 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 {@link PipelineExecutor} class into two for each stage,
+     *       but this would break the improved readability and unified handling of the executor that I wanted to achieve with this class.
+     */
+    async allRemainingSteps(canSwitchStage = true) {
+        while (this.hasNextStep()) {
+            await this.nextStep();
+        }
+        if (canSwitchStage && this.stepCounter < this.length && this.currentExecutionStage === 0 /* PipelineStepStage.OncePerFile */) {
+            this.switchToRequestStage();
+            while (this.hasNextStep()) {
+                await this.nextStep();
+            }
+        }
+        return this.stepCounter < this.length ? this.getResults(true) : this.getResults();
+    }
+}
+exports.PipelineExecutor = PipelineExecutor;
+//# sourceMappingURL=pipeline-executor.js.map

package/core/print/dataflow-printer.d.ts

@@ -0,0 +1,8 @@
+import { DataflowInformation } from '../../dataflow/internal/info';
+import { QuadSerializationConfiguration } from '../../util/quads';
+import { DataflowMap } from '../../dataflow';
+/** Should work with larger things as well */
+export declare function dataflowGraphToJson(df: DataflowInformation): string;
+export declare function dataflowGraphToMermaid(df: DataflowInformation, idMap: DataflowMap): string;
+export declare function dataflowGraphToMermaidUrl(df: DataflowInformation, idMap: DataflowMap): string;
+export declare function dataflowGraphToQuads(df: DataflowInformation, config: QuadSerializationConfiguration): string;

package/core/print/dataflow-printer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataflowGraphToQuads = exports.dataflowGraphToMermaidUrl = exports.dataflowGraphToMermaid = exports.dataflowGraphToJson = void 0;
+const json_1 = require("../../util/json");
+const quads_1 = require("../../dataflow/graph/quads");
+const mermaid_1 = require("../../util/mermaid");
+function mayObjectJson(d) {
+    if (typeof d === 'object') {
+        return objectJson(d);
+    }
+    else {
+        return JSON.stringify(d, json_1.jsonReplacer);
+    }
+}
+function objectJson(df) {
+    const elems = [];
+    for (const [key, value] of Object.entries(df)) {
+        switch (typeof value) {
+            case 'undefined':
+            case 'function':
+                continue;
+            case 'object':
+                if (Array.isArray(value)) {
+                    elems.push([key, `[${value.map(x => mayObjectJson(x)).join(',')}]`]);
+                }
+                else if (value instanceof Set) {
+                    elems.push([key, `[${[...value].map(x => mayObjectJson(x)).join(',')}]`]);
+                }
+                else if (value instanceof Map) {
+                    elems.push([key, `[${[...value].map(([k, v]) => `[${mayObjectJson(k)},${mayObjectJson(v)}]`).join(',')}]`]);
+                }
+                else {
+                    elems.push([key, objectJson(value)]);
+                }
+                break;
+            case 'bigint':
+                elems.push([key, `${value.toString()}n`]);
+                break;
+            default:
+                elems.push([key, JSON.stringify(value, json_1.jsonReplacer)]);
+        }
+    }
+    return `{${elems.map(([key, value]) => `"${key}":${value}`).join(',')}}`;
+}
+/** Should work with larger things as well */
+function dataflowGraphToJson(df) {
+    return objectJson(df);
+}
+exports.dataflowGraphToJson = dataflowGraphToJson;
+function dataflowGraphToMermaid(df, idMap) {
+    return (0, mermaid_1.graphToMermaid)(df.graph, idMap);
+}
+exports.dataflowGraphToMermaid = dataflowGraphToMermaid;
+function dataflowGraphToMermaidUrl(df, idMap) {
+    return (0, mermaid_1.graphToMermaidUrl)(df.graph, idMap);
+}
+exports.dataflowGraphToMermaidUrl = dataflowGraphToMermaidUrl;
+function dataflowGraphToQuads(df, config) {
+    return (0, quads_1.df2quads)(df.graph, config);
+}
+exports.dataflowGraphToQuads = dataflowGraphToQuads;
+//# sourceMappingURL=dataflow-printer.js.map

package/core/print/normalize-printer.d.ts

@@ -0,0 +1,7 @@
+import { NormalizedAst } from '../../r-bridge';
+import { QuadSerializationConfiguration } from '../../util/quads';
+/** Should work with larger things as well */
+export declare function normalizedAstToJson(ast: NormalizedAst): string;
+export declare function normalizedAstToQuads(ast: NormalizedAst, config: QuadSerializationConfiguration): string;
+export declare function printNormalizedAstToMermaid(ast: NormalizedAst): string;
+export declare function printNormalizedAstToMermaidUrl(ast: NormalizedAst): string;

package/core/print/normalize-printer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printNormalizedAstToMermaidUrl = exports.printNormalizedAstToMermaid = exports.normalizedAstToQuads = exports.normalizedAstToJson = void 0;
+const json_1 = require("../../util/json");
+const quads_1 = require("../../util/quads");
+const mermaid_1 = require("../../util/mermaid");
+/** Should work with larger things as well */
+function normalizedAstToJson(ast) {
+    // we never serialize the idmap, as it just duplicates the ast, additionally we now miss the full-lexeme to further safe memory
+    return JSON.stringify({ ...ast.ast, idMap: undefined }, (k, v) => {
+        if (k === 'fullLexeme') {
+            return undefined;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return (0, json_1.jsonReplacer)(k, v);
+    });
+}
+exports.normalizedAstToJson = normalizedAstToJson;
+function normalizedAstToQuads(ast, config) {
+    return (0, quads_1.serialize2quads)(ast.ast, config);
+}
+exports.normalizedAstToQuads = normalizedAstToQuads;
+function printNormalizedAstToMermaid(ast) {
+    return (0, mermaid_1.normalizedAstToMermaid)(ast.ast);
+}
+exports.printNormalizedAstToMermaid = printNormalizedAstToMermaid;
+function printNormalizedAstToMermaidUrl(ast) {
+    return (0, mermaid_1.normalizedAstToMermaidUrl)(ast.ast);
+}
+exports.printNormalizedAstToMermaidUrl = printNormalizedAstToMermaidUrl;
+//# sourceMappingURL=normalize-printer.js.map

package/core/print/parse-printer.d.ts

@@ -0,0 +1,3 @@
+import { QuadSerializationConfiguration } from '../../util/quads';
+import { XmlParserConfig } from '../../r-bridge';
+export declare function parseToQuads(code: string, config: QuadSerializationConfiguration, parseConfig: XmlParserConfig): Promise<string>;

package/core/print/parse-printer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseToQuads = void 0;
+const quads_1 = require("../../util/quads");
+const internal_1 = require("../../r-bridge/lang-4.x/ast/parser/xml/internal");
+function filterObject(obj, keys) {
+    if (typeof obj !== 'object') {
+        return obj;
+    }
+    else if (Array.isArray(obj)) {
+        return obj.map(e => filterObject(e, keys));
+    }
+    if (Object.keys(obj).some(k => keys.has(k))) {
+        return Object.fromEntries(Object.entries(obj)
+            .filter(([k]) => keys.has(k))
+            .map(([k, v]) => [k, filterObject(v, keys)]));
+    }
+    else {
+        return Object.fromEntries(Object.entries(obj)
+            .map(([k, v]) => [k, filterObject(v, keys)]));
+    }
+}
+async function parseToQuads(code, config, parseConfig) {
+    const obj = await (0, internal_1.xlm2jsonObject)(parseConfig, code);
+    // recursively filter so that if the object contains one of the keys 'a', 'b' or 'c', all other keys are ignored
+    return (0, quads_1.serialize2quads)(filterObject(obj, new Set([parseConfig.attributeName, parseConfig.childrenName, parseConfig.contentName])), config);
+}
+exports.parseToQuads = parseToQuads;
+//# sourceMappingURL=parse-printer.js.map

package/core/print/print.d.ts

@@ -0,0 +1,47 @@
+import { StepFunction } from '../steps';
+/**
+ * Defines the output format of a step that you are interested in.
+ */
+export declare const enum StepOutputFormat {
+    /**
+     * [Internal]
+     * This output format is special as it corresponds to whatever the step would normally produce - unchanged - as a typescript object.
+     * There is no special way to influence this output format, and it is not to be serialized.
+     */
+    Internal = 0,
+    /**
+     * A human-readable textual representation of the result. Depending on the step this may be of lesser use as the results
+     * of the dataflow analysis are not easily readable in text form.
+     */
+    Text = 1,
+    /**
+     * This is usually a one-to-one serialization of the internal format, although it is possible that some recursive references are broken.
+     */
+    Json = 2,
+    /**
+     * If possible, this will produce a mermaid graph of the result and contain the mermaid code.
+     * This is only really possible for some of the step (e.g., the dataflow analysis).
+     */
+    Mermaid = 3,
+    /**
+     * This is an extension of the {@link Mermaid} format. Instead of returning
+     * the mermaid code, it will return an url to mermaid live.
+     */
+    MermaidUrl = 4,
+    /**
+     * Produce n-quads as the output.
+     * See {@link serialize2quads}
+     */
+    RdfQuads = 5
+}
+/**
+ * Helper function to support the {@link Internal} format, as it is simply returning the input.
+ *
+ * @see IStepPrinter
+ */
+export declare function internalPrinter<Input>(input: Input): Input;
+/**
+ * A mapping function that maps the result of a step (i.e., the dataflow graph)
+ * to another representation (linked by {@link StepOutputFormat} in an {@link IStep}).
+ */
+export type IStepPrinter<StepInput extends StepFunction, Format extends StepOutputFormat, AdditionalInput extends unknown[]> = Format extends StepOutputFormat.Internal ? (input: Awaited<ReturnType<StepInput>>) => Awaited<ReturnType<StepInput>> : (input: Awaited<ReturnType<StepInput>>, ...additional: AdditionalInput) => Promise<string> | string;

package/core/print/print.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalPrinter = void 0;
+/**
+ * Helper function to support the {@link Internal} format, as it is simply returning the input.
+ *
+ * @see IStepPrinter
+ */
+function internalPrinter(input) {
+    return input;
+}
+exports.internalPrinter = internalPrinter;
+//# sourceMappingURL=print.js.map

package/core/print/slice-diff-ansi.d.ts

@@ -0,0 +1,2 @@
+import { NodeId, NormalizedAst } from '../../r-bridge';
+export declare function sliceDiffAnsi(slice: Set<NodeId>, normalized: NormalizedAst, criteriaIds: Set<NodeId>, originalCode: string): string;

package/core/print/slice-diff-ansi.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sliceDiffAnsi = void 0;
+const range_1 = require("../../util/range");
+const assert_1 = require("../../util/assert");
+const statistics_1 = require("../../statistics");
+function grayOut() {
+    return statistics_1.ansiFormatter.getFormatString({ color: 7 /* Colors.White */, effect: statistics_1.ColorEffect.Foreground, style: 2 /* FontStyles.Faint */ });
+}
+function mergeJointRangesInSorted(loc) {
+    return loc.reduce((acc, curr) => {
+        if ((0, range_1.rangesOverlap)(acc[acc.length - 1].location, curr.location)) {
+            return [
+                ...acc.slice(0, -1), {
+                    selected: curr.selected || acc[acc.length - 1].selected,
+                    location: (0, range_1.mergeRanges)(acc[acc.length - 1].location, curr.location)
+                }
+            ];
+        }
+        else {
+            return [...acc, curr];
+        }
+    }, [loc[0]]);
+}
+function highlight(s, selected) {
+    const primary = statistics_1.ansiFormatter.format(s, { color: 3 /* Colors.Yellow */, effect: statistics_1.ColorEffect.Foreground, style: 1 /* FontStyles.Bold */ });
+    return selected ? statistics_1.ansiFormatter.format(primary, { style: 4 /* FontStyles.Underline */ }) : primary;
+}
+function sliceDiffAnsi(slice, normalized, criteriaIds, originalCode) {
+    let importantLocations = Array.from(normalized.idMap.entries())
+        .filter(([id, { location }]) => slice.has(id) && (0, assert_1.isNotUndefined)(location))
+        .map(([id, { location }]) => ({ selected: criteriaIds.has(id), location: location }));
+    if (importantLocations.length === 0) {
+        return `${grayOut()}${originalCode}${statistics_1.ansiFormatter.reset()}`;
+    }
+    // we sort all locations from back to front so that replacements do not screw up the indices
+    importantLocations.sort((a, b) => -(0, range_1.rangeCompare)(a.location, b.location));
+    // we need to merge all ranges that overlap, otherwise even reversed traversal can still crew us up
+    importantLocations = mergeJointRangesInSorted(importantLocations);
+    const lines = originalCode.split('\n');
+    for (const { selected, location } of importantLocations) {
+        const { start, end } = location;
+        const line = lines[start.line - 1];
+        lines[start.line - 1] = `${line.substring(0, start.column - 1)}${statistics_1.ansiFormatter.reset()}${highlight(line.substring(start.column - 1, end.column), selected)}${grayOut()}${line.substring(end.column)}`;
+    }
+    return `${grayOut()}${lines.join('\n')}${statistics_1.ansiFormatter.reset()}`;
+}
+exports.sliceDiffAnsi = sliceDiffAnsi;
+//# sourceMappingURL=slice-diff-ansi.js.map

package/core/slicer.d.ts

@@ -0,0 +1,123 @@
+import { LAST_PER_FILE_STEP, LAST_STEP, StepRequired, STEPS_PER_SLICE, StepName, StepResult } from './steps';
+import { SlicingCriteria } from '../slicing';
+import { SteppingSlicerInput } from './input';
+import { StepResults } from './output';
+/**
+ * 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
+ */
+export declare class SteppingSlicer<InterestedIn extends StepName | undefined = typeof LAST_STEP> {
+    static readonly maximumNumberOfStepsPerFile: number;
+    static readonly maximumNumberOfStepsPerSlice: number;
+    private readonly shell;
+    private readonly stepOfInterest;
+    private readonly request;
+    private readonly hooks?;
+    private readonly getId?;
+    private criterion?;
+    private results;
+    private stage;
+    private stepCounter;
+    private reachedWanted;
+    /**
+     * Create a new stepping slicer. For more details on the arguments please see {@link SteppingSlicerInput}.
+     */
+    constructor(input: SteppingSlicerInput<InterestedIn>);
+    /**
+     * Retrieve the current stage the stepping slicer is in.
+     * @see StepRequired
+     * @see switchToSliceStage
+     */
+    getCurrentStage(): StepRequired;
+    /**
+     * Switch to the next stage of the stepping slicer.
+     * @see SteppingSlicer
+     * @see getCurrentStage
+     */
+    switchToSliceStage(): void;
+    getResults(intermediate?: false): StepResults<InterestedIn>;
+    getResults(intermediate: true): Partial<StepResults<InterestedIn>>;
+    /**
+     * 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(): boolean;
+    /**
+     * 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.*
+     */
+    nextStep<PassedName extends StepName>(expectedStepName?: PassedName): Promise<{
+        name: typeof expectedStepName extends undefined ? StepName : PassedName;
+        result: typeof expectedStepName extends undefined ? unknown : StepResult<Exclude<PassedName, undefined>>;
+    }>;
+    private getGuardStep;
+    private doNextStep;
+    /**
+     * 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: SlicingCriteria): void;
+    allRemainingSteps(canSwitchStage: false): Promise<Partial<StepResults<InterestedIn extends keyof typeof STEPS_PER_SLICE | undefined ? typeof LAST_PER_FILE_STEP : InterestedIn>>>;
+    allRemainingSteps(canSwitchStage?: true): Promise<StepResults<InterestedIn>>;
+}