@eagleoutice/flowr 1.3.11

package/cli/repl/server/server.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowRServer = exports.serverLog = void 0;
+const version_1 = require("../commands/version");
+const connection_1 = require("./connection");
+const send_1 = require("./send");
+const net_1 = require("./net");
+const log_1 = require("../../../util/log");
+// we detach from the main logger so that it can have its own switch
+exports.serverLog = new log_1.FlowrLogger({ name: 'server' });
+/**
+ * This class controls the TCP server, which can be started by calling {@link start}.
+ * Afterward, each incoming connection will be greeted with {@link helloClient} and from
+ * thereon be handled by a {@link FlowRServerConnection}.
+ */
+class FlowRServer {
+    server;
+    shell;
+    versionInformation;
+    /** maps names to the respective connection */
+    connections = new Map();
+    nameCounter = 0;
+    constructor(shell, server = new net_1.NetServer()) {
+        this.server = server;
+        this.server.onConnect(c => this.onConnect(c));
+        this.shell = shell;
+    }
+    async start(port) {
+        this.versionInformation = await (0, version_1.retrieveVersionInformation)(this.shell);
+        this.server.start(port);
+        exports.serverLog.info(`Server listening on port ${port}`);
+    }
+    onConnect(c) {
+        if (!this.versionInformation) {
+            notYetInitialized(c, undefined);
+            return;
+        }
+        const name = `client-${this.nameCounter++}`;
+        exports.serverLog.info(`Client connected: ${(0, send_1.getUnnamedSocketName)(c)} as "${name}"`);
+        this.connections.set(name, new connection_1.FlowRServerConnection(c, name, this.shell));
+        helloClient(c, name, this.versionInformation);
+        c.on('close', () => {
+            this.connections.delete(name);
+            exports.serverLog.info(`Client "${name}" disconnected (${(0, send_1.getUnnamedSocketName)(c)})`);
+        });
+    }
+}
+exports.FlowRServer = FlowRServer;
+function notYetInitialized(c, id) {
+    (0, send_1.sendMessage)(c, {
+        id,
+        type: 'error',
+        fatal: true,
+        reason: 'Server not initialized yet (or failed to), please try again later.'
+    });
+    c.end();
+}
+function helloClient(c, name, versionInformation) {
+    (0, send_1.sendMessage)(c, {
+        id: undefined,
+        type: 'hello',
+        clientName: name,
+        versions: versionInformation
+    });
+}
+//# sourceMappingURL=server.js.map

package/cli/repl/server/validate.d.ts

@@ -0,0 +1,15 @@
+import Joi from 'joi';
+import { FlowrMessage, IdMessageBase, MessageDefinition } from './messages/messages';
+import { Socket } from './net';
+export interface ValidationErrorResult {
+    type: 'error';
+    reason: Joi.ValidationError | Error;
+}
+export interface SuccessValidationResult<T extends IdMessageBase> {
+    type: 'success';
+    message: T;
+}
+export type ValidationResult<T extends IdMessageBase> = SuccessValidationResult<T> | ValidationErrorResult;
+export declare function validateBaseMessageFormat(input: string): ValidationResult<IdMessageBase>;
+export declare function validateMessage<T extends FlowrMessage | IdMessageBase>(input: IdMessageBase, def: MessageDefinition<T>): ValidationResult<T>;
+export declare function answerForValidationError(client: Socket, result: ValidationErrorResult, id?: string): void;

package/cli/repl/server/validate.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.answerForValidationError = exports.validateMessage = exports.validateBaseMessageFormat = void 0;
+const send_1 = require("./send");
+const messages_1 = require("./messages/messages");
+function validateBaseMessageFormat(input) {
+    try {
+        return validateMessage(JSON.parse(input), messages_1.baseMessage);
+    }
+    catch (e) {
+        return { type: 'error', reason: e };
+    }
+}
+exports.validateBaseMessageFormat = validateBaseMessageFormat;
+function validateMessage(input, def) {
+    try {
+        const result = def.schema.validate(input);
+        return result.error ? { type: 'error', reason: result.error } : { type: 'success', message: input };
+    }
+    catch (e) {
+        return { type: 'error', reason: e };
+    }
+}
+exports.validateMessage = validateMessage;
+function answerForValidationError(client, result, id) {
+    (0, send_1.sendMessage)(client, {
+        type: 'error',
+        fatal: false,
+        id: id,
+        reason: `Invalid message format: ${result.reason.message}`
+    });
+}
+exports.answerForValidationError = answerForValidationError;
+//# sourceMappingURL=validate.js.map

package/cli/slicer-app.d.ts

@@ -0,0 +1,11 @@
+export interface SlicerCliOptions {
+    verbose: boolean;
+    help: boolean;
+    input: string | undefined;
+    criterion: string | undefined;
+    output: string | undefined;
+    diff: boolean;
+    'input-is-text': boolean;
+    stats: boolean;
+    api: boolean;
+}

package/cli/slicer-app.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../util/log");
+const fs_1 = __importDefault(require("fs"));
+const assert_1 = require("../util/assert");
+const benchmark_1 = require("../benchmark");
+const common_1 = require("./common");
+const json_1 = require("../util/json");
+const slice_diff_ansi_1 = require("../core/print/slice-diff-ansi");
+const options = (0, common_1.processCommandLineArgs)('slicer', ['input', 'criterion'], {
+    subtitle: 'Slice R code based on a given slicing criterion',
+    examples: [
+        '{bold -c} {italic "12@product"} {italic test/testfiles/example.R}',
+        // why double escaped :C
+        '{bold -c} {italic "3@a"} {bold -r} {italic "a <- 3\\\\nb <- 4\\\\nprint(a)"} {bold --diff}',
+        '{bold -i} {italic example.R} {bold --stats} {bold --criterion} {italic "8:3;3:1;12@product"}',
+        '{bold --help}'
+    ]
+});
+async function getSlice() {
+    const slicer = new benchmark_1.BenchmarkSlicer();
+    (0, assert_1.guard)(options.input !== undefined, 'input must be given');
+    (0, assert_1.guard)(options.criterion !== undefined, 'a slicing criterion must be given');
+    await slicer.init(options['input-is-text'] ? { request: 'text', content: options.input } : { request: 'file', content: options.input });
+    let mappedSlices = [];
+    let reconstruct = undefined;
+    const doSlicing = options.criterion.trim() !== '';
+    let slice = undefined;
+    if (doSlicing) {
+        const slices = options.criterion.split(';').map(c => c.trim());
+        try {
+            const { stats: { reconstructedCode, slicingCriteria }, slice: sliced } = await slicer.slice(...slices);
+            slice = sliced;
+            mappedSlices = slicingCriteria;
+            reconstruct = reconstructedCode;
+            if (options.output) {
+                console.log('Written reconstructed code to', options.output);
+                console.log(`Automatically selected ${reconstructedCode.autoSelected} statements`);
+                fs_1.default.writeFileSync(options.output, reconstructedCode.code);
+            }
+            else if (!options.api && !options.diff) {
+                console.log(reconstructedCode.code);
+            }
+        }
+        catch (e) {
+            log_1.log.error(`[Skipped] Error while processing ${options.input}: ${e.message} (${e.stack ?? ''})`);
+        }
+    }
+    const { stats, normalize, parse, tokenMap, dataflow } = slicer.finish();
+    const mappedCriteria = mappedSlices.map(c => `    ${c.criterion} => ${c.id} (${JSON.stringify(normalize.idMap.get(c.id)?.location)})`).join('\n');
+    log_1.log.info(`Mapped criteria:\n${mappedCriteria}`);
+    const sliceStatsAsString = (0, benchmark_1.stats2string)(await (0, benchmark_1.summarizeSlicerStats)(stats));
+    if (options.api) {
+        const output = {
+            tokenMap,
+            parse,
+            normalize,
+            dataflow,
+            ...(options.stats ? { stats } : {}),
+            ...(doSlicing ? { slice: mappedSlices, reconstruct } : {})
+        };
+        console.log(JSON.stringify(output, json_1.jsonReplacer));
+    }
+    else {
+        if (doSlicing && options.diff) {
+            const originalCode = options['input-is-text'] ? options.input : fs_1.default.readFileSync(options.input).toString();
+            console.log((0, slice_diff_ansi_1.sliceDiffAnsi)(slice.result, normalize, new Set(mappedSlices.map(({ id }) => id)), originalCode));
+        }
+        if (options.stats) {
+            console.log(sliceStatsAsString);
+            const filename = `${options.input}.stats`;
+            console.log(`Writing stats for ${options.input} to "${filename}"`);
+            fs_1.default.writeFileSync(filename, sliceStatsAsString);
+        }
+    }
+}
+void getSlice();
+//# sourceMappingURL=slicer-app.js.map

package/cli/statistics-app.d.ts

@@ -0,0 +1,11 @@
+export interface StatsCliOptions {
+    readonly verbose: boolean;
+    readonly help: boolean;
+    readonly limit: number | undefined;
+    readonly input: string[];
+    readonly 'dump-json': boolean;
+    readonly 'output-dir': string;
+    readonly 'no-ansi': boolean;
+    readonly parallel: number;
+    readonly features: string[];
+}

package/cli/statistics-app.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const statistics_1 = require("../statistics");
+const log_1 = require("../util/log");
+const files_1 = require("../util/files");
+const common_1 = require("./common");
+const parallel_1 = require("../util/parallel");
+const features_1 = require("./common/features");
+const path_1 = __importDefault(require("path"));
+const json_1 = require("../util/json");
+const fs_1 = __importDefault(require("fs"));
+const options = (0, common_1.processCommandLineArgs)('stats', [], {
+    subtitle: 'Given input files or folders, this will collect usage statistics for the given features and write them to a file',
+    examples: [
+        '{bold -i} {italic example.R} {bold -i} {italic example2.R} {bold --output-dir} {italic "output-folder/"}',
+        '{italic "folder1/"} {bold --features} {italic all} {bold --output-dir} {italic "output-folder/"}',
+        '{bold --post-process} {italic "output-folder"} {bold --features} {italic assignments}',
+        '{bold --help}'
+    ]
+});
+if (options.input.length === 0) {
+    console.error('No input files given. Nothing to do. See \'--help\' if this is an error.');
+    process.exit(0);
+}
+if (options['no-ansi']) {
+    log_1.log.info('disabling ansi colors');
+    (0, statistics_1.setFormatter)(statistics_1.voidFormatter);
+}
+const processedFeatures = (0, features_1.validateFeatures)(options.features);
+(0, statistics_1.initFileProvider)(options['output-dir']);
+const testRegex = /[^/]*\/test/i;
+const exampleRegex = /[^/]*\/example/i;
+function getPrefixForFile(file) {
+    if (testRegex.test(file)) {
+        return 'test-';
+    }
+    else if (exampleRegex.test(file)) {
+        return 'example-';
+    }
+    else {
+        return '';
+    }
+}
+function getSuffixForFile(base, file) {
+    const subpath = path_1.default.relative(base, file);
+    return '--' + subpath.replace(/\//g, '／');
+}
+async function collectFileArguments(verboseAdd, dumpJson, features) {
+    const files = [];
+    let counter = 0;
+    let presentSteps = 5000;
+    let skipped = 0;
+    for await (const f of (0, files_1.allRFilesFrom)(options.input)) {
+        const outputDir = path_1.default.join(options['output-dir'], `${getPrefixForFile(f.content)}${getSuffixForFile(options.input.length === 1 ? options.input[0] : '', f.content)}`);
+        const target = (0, features_1.retrieveArchiveName)(outputDir);
+        if (fs_1.default.existsSync(target)) {
+            console.log(`Archive ${target} exists. Skip.`);
+            skipped++;
+            continue;
+        }
+        files.push(['--input', f.content, '--output-dir', outputDir, '--compress', '--root-dir', options.input.length === 1 ? options.input[0] : '""', ...verboseAdd, ...features, ...dumpJson]);
+        if (++counter % presentSteps === 0) {
+            console.log(`Collected ${counter} files`);
+            if (counter >= 10 * presentSteps) {
+                presentSteps *= 5;
+            }
+        }
+    }
+    console.log(`Total: ${counter} files (${skipped} skipped with archive existing)`);
+    return files;
+}
+async function getStats() {
+    console.log(`Processing features: ${JSON.stringify(processedFeatures, json_1.jsonReplacer)}`);
+    console.log(`Using ${options.parallel} parallel executors`);
+    const verboseAdd = options.verbose ? ['--verbose'] : [];
+    const features = [...processedFeatures].flatMap(s => ['--features', s]);
+    const dumpJson = options['dump-json'] ? ['--dump-json'] : [];
+    // we do not use the limit argument to be able to pick the limit randomly
+    const args = await collectFileArguments(verboseAdd, dumpJson, features);
+    if (options.limit) {
+        console.log('Shuffle...');
+        log_1.log.info(`limiting to ${options.limit} files`);
+        // shuffle and limit
+        args.sort(() => Math.random() - 0.5);
+    }
+    console.log('Prepare Pool...');
+    const limit = options.limit ?? args.length;
+    const pool = new parallel_1.LimitedThreadPool(`${__dirname}/statistics-helper-app`, args, limit, options.parallel);
+    console.log('Run Pool...');
+    await pool.run();
+    const stats = pool.getStats();
+    console.log(`Processed ${stats.counter} files, skipped ${stats.skipped.length} files due to errors`);
+}
+void getStats();
+//# sourceMappingURL=statistics-app.js.map

package/cli/statistics-helper-app.d.ts

@@ -0,0 +1,11 @@
+export interface StatsHelperCliOptions {
+    readonly verbose: boolean;
+    readonly help: boolean;
+    readonly input: string;
+    readonly compress: boolean;
+    readonly 'dump-json': boolean;
+    readonly 'output-dir': string;
+    readonly 'root-dir': string;
+    readonly 'no-ansi': boolean;
+    readonly features: string[];
+}

package/cli/statistics-helper-app.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const r_bridge_1 = require("../r-bridge");
+const statistics_1 = require("../statistics");
+const log_1 = require("../util/log");
+const common_1 = require("./common");
+const json_1 = require("../util/json");
+const cfg_1 = require("../util/cfg");
+const tar_1 = require("tar");
+const fs_1 = __importDefault(require("fs"));
+const assert_1 = require("../util/assert");
+const features_1 = require("./common/features");
+const core_1 = require("../core");
+const time_1 = require("../util/time");
+const options = (0, common_1.processCommandLineArgs)('stats-helper', [], {
+    subtitle: 'Given a single input file, this will collect usage statistics for the given features and write them to a file',
+    examples: [
+        '{bold -i} {italic example.R} {bold -i} {italic example2.R} {bold --output-dir} {italic "output-folder/"}',
+        '{bold --help}'
+    ]
+});
+if (options['no-ansi']) {
+    log_1.log.info('disabling ansi colors');
+    (0, statistics_1.setFormatter)(statistics_1.voidFormatter);
+}
+let target = undefined;
+if (options.compress) {
+    target = (0, features_1.retrieveArchiveName)(options['output-dir']);
+    if (fs_1.default.existsSync(target)) {
+        console.log(`Archive ${target} exists. Skip.`);
+        process.exit(0);
+    }
+}
+// assume correct
+const processedFeatures = new Set(options.features);
+const shell = new r_bridge_1.RShell();
+shell.tryToInjectHomeLibPath();
+(0, statistics_1.initFileProvider)(options['output-dir']);
+function compressFolder(folder, target) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    (0, tar_1.create)({
+        gzip: true,
+        file: target,
+        portable: true,
+        preservePaths: false
+    }, [folder]).then(() => {
+        // now, remove the folder
+        fs_1.default.rmSync(folder, { recursive: true, force: true });
+    }, () => {
+        console.log(`failed to compress ${folder}`);
+    });
+}
+async function getStatsForSingleFile() {
+    await shell.obtainTmpDir();
+    const stats = await (0, statistics_1.extractUsageStatistics)(shell, () => { }, processedFeatures, (0, statistics_1.staticRequests)({ request: 'file', content: options.input }), options['root-dir']);
+    // console.warn(`skipped ${stats.meta.failedRequests.length} requests due to errors (run with logs to get more info)`)
+    if (stats.outputs.size === 1) {
+        if (options['dump-json']) {
+            const [, output] = [...stats.outputs.entries()][0];
+            const cfg = (0, cfg_1.extractCFG)(output.normalize);
+            statistics_1.statisticsFileProvider.append('output-json', 'parse', await (0, core_1.printStepResult)('parse', output.parse, 2 /* StepOutputFormat.Json */));
+            statistics_1.statisticsFileProvider.append('output-json', 'normalize', await (0, core_1.printStepResult)('normalize', output.normalize, 2 /* StepOutputFormat.Json */));
+            statistics_1.statisticsFileProvider.append('output-json', 'dataflow', await (0, core_1.printStepResult)('dataflow', output.dataflow, 2 /* StepOutputFormat.Json */));
+            statistics_1.statisticsFileProvider.append('output-json', 'cfg', JSON.stringify(cfg, json_1.jsonReplacer));
+        }
+        statistics_1.statisticsFileProvider.append('meta', 'stats', JSON.stringify({ ...stats.meta, file: options.input }, json_1.jsonReplacer));
+        statistics_1.statisticsFileProvider.append('meta', 'features', JSON.stringify(stats.features, json_1.jsonReplacer));
+    }
+    else {
+        log_1.log.error(`expected exactly one output vs. ${stats.outputs.size}, got: ${JSON.stringify([...stats.outputs.keys()], json_1.jsonReplacer, 2)}`);
+    }
+    if (options.compress) {
+        (0, assert_1.guard)(target !== undefined, 'target must be defined given the compress option');
+        console.log(`[${(0, time_1.date2string)(new Date())}] Compressing ${options['output-dir']} to ${target}`);
+        compressFolder(options['output-dir'], target);
+    }
+    shell.close();
+}
+void getStatsForSingleFile();
+//# sourceMappingURL=statistics-helper-app.js.map

package/cli/summarizer-app.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The summarizer intends to post-process and summarize the results of
+ * * the benchmark tool, and
+ * * the statistics extraction.
+ *
+ * @module
+ */
+export interface SummarizerCliOptions {
+    verbose: boolean;
+    help: boolean;
+    'ultimate-only': boolean;
+    categorize: boolean;
+    input: string;
+    type: string;
+    output?: string;
+    graph?: boolean;
+    'project-skip': number;
+}

package/cli/summarizer-app.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * The summarizer intends to post-process and summarize the results of
+ * * the benchmark tool, and
+ * * the statistics extraction.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("./common");
+const summarizer_1 = require("../util/summarizer/benchmark/summarizer");
+const auto_detect_1 = require("../util/summarizer/auto-detect");
+const summarizer_2 = require("../util/summarizer/statistics/summarizer");
+const statistics_1 = require("../statistics");
+const options = (0, common_1.processCommandLineArgs)('summarizer', ['input'], {
+    subtitle: 'Summarize and explain the results of the benchmark tool. Summarizes in two stages: first per-request, and then overall',
+    examples: [
+        '{italic benchmark.json}',
+        '{bold --help}'
+    ]
+});
+const outputBase = (options.output ?? options.input).replace(/\.json$|\/$/, '-summary');
+console.log(`Writing outputs to base ${outputBase}`);
+function getBenchmarkSummarizer() {
+    return new summarizer_1.BenchmarkSummarizer({
+        graphOutputPath: options.graph ? `${outputBase}-graph.json` : undefined,
+        inputPath: options.input,
+        intermediateOutputPath: `${outputBase}.json`,
+        outputPath: `${outputBase}-ultimate.json`,
+        outputLogPath: `${outputBase}.log`,
+        logger: console.log
+    });
+}
+function getStatisticsSummarizer() {
+    return new summarizer_2.StatisticsSummarizer({
+        inputPath: options.input,
+        outputPath: `${outputBase}-final`,
+        intermediateOutputPath: `${outputBase}-intermediate/`,
+        projectSkip: options['project-skip'],
+        featuresToUse: statistics_1.allFeatureNames,
+        logger: console.log
+    });
+}
+async function retrieveSummarizer() {
+    const type = options.type === 'auto' ? await (0, auto_detect_1.detectSummarizationType)(options.input) : options.type;
+    if (type === "benchmark" /* SummarizerType.Benchmark */) {
+        console.log('Summarizing benchmark');
+        return getBenchmarkSummarizer();
+    }
+    else if (type === "statistics" /* SummarizerType.Statistics */) {
+        console.log('Summarizing statistics');
+        return getStatisticsSummarizer();
+    }
+    else {
+        console.error('Unknown type', type, 'either give "benchmark" or "statistics"');
+        process.exit(1);
+    }
+}
+async function run() {
+    const summarizer = await retrieveSummarizer();
+    if (!options['ultimate-only']) {
+        await summarizer.preparationPhase(options.categorize);
+    }
+    await summarizer.summarizePhase();
+}
+void run();
+//# sourceMappingURL=summarizer-app.js.map

package/core/index.d.ts

@@ -0,0 +1,4 @@
+export { SteppingSlicer } from './slicer';
+export * from './steps';
+export * from './input';
+export * from './output';

package/core/index.js

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

package/core/input.d.ts

@@ -0,0 +1,42 @@
+import { MergeableRecord } from '../util/objects';
+import { IdGenerator, NoInfo, RParseRequest, RShell, XmlParserHooks } from '../r-bridge';
+import { DeepPartial } from 'ts-essentials';
+import { AutoSelectPredicate, SlicingCriteria } from '../slicing';
+import { STEPS_PER_SLICE, StepName, STEPS_PER_FILE } from './steps';
+/**
+ * We split the types, as if you are only interested in what can be done per-file, you do not need a slicing criterion.
+ * Furthermore, if you are only interested in the parse result, you do not require the token map and you can not pass hooks
+ */
+interface BaseSteppingSlicerInput<InterestedIn extends StepName | undefined> extends MergeableRecord {
+    /**
+     * The step you are actually interested in.
+     * If you pass 'dataflow', the stepper will stop after analyzing the dataflow.
+     * The step is optional, if you do not pass a step, the stepper will execute all steps.
+     */
+    stepOfInterest?: InterestedIn;
+    /** This is the {@link RShell} connection to be used to obtain the original parses AST of the R code */
+    shell: RShell;
+    /** The request which essentially indicates the input to extract the AST from */
+    request: RParseRequest;
+    /** These hooks only make sense if you at least want to normalize the parsed R AST. They can augment the normalization process */
+    hooks?: DeepPartial<XmlParserHooks>;
+    /** This id generator is only necessary if you want to retrieve a dataflow from the parsed R AST, it determines the id generator to use and by default uses the {@link deterministicCountingIdGenerator}*/
+    getId?: IdGenerator<NoInfo>;
+    /** The slicing criterion is only of interest if you actually want to slice the R code */
+    criterion?: SlicingCriteria;
+    /** If you want to auto-select something in the reconstruction add it here, otherwise, it will use the default defined alongside {@link reconstructToCode}*/
+    autoSelectIf?: AutoSelectPredicate;
+}
+interface NormalizeSteppingSlicerInput<InterestedIn extends 'dataflow' | 'normalize'> extends BaseSteppingSlicerInput<InterestedIn> {
+    stepOfInterest: InterestedIn;
+}
+interface SliceSteppingSlicerInput<InterestedIn extends 'reconstruct' | 'slice' | undefined> extends BaseSteppingSlicerInput<InterestedIn> {
+    stepOfInterest?: InterestedIn;
+    criterion: SlicingCriteria;
+}
+/**
+ * For a given set of steps of interest, this essentially (statically) determines the required inputs for the {@link SteppingSlicer}.
+ * All arguments are documented alongside {@link BaseSteppingSlicerInput}.
+ */
+export type SteppingSlicerInput<InterestedIn extends StepName | undefined = undefined> = InterestedIn extends keyof typeof STEPS_PER_SLICE | undefined ? SliceSteppingSlicerInput<InterestedIn> : InterestedIn extends Exclude<keyof typeof STEPS_PER_FILE, 'parse'> ? NormalizeSteppingSlicerInput<InterestedIn> : BaseSteppingSlicerInput<InterestedIn>;
+export {};

package/core/input.js

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

package/core/output.d.ts

@@ -0,0 +1,15 @@
+import { LAST_STEP, StepName, StepResult } from './steps';
+/** Represents the return value of the processor linked to the step with the name 'K' */
+type Out<K extends StepName> = Record<K, StepResult<K>>;
+/**
+ * Essentially expresses an object that, if a step 'x' is of interest, contains the result of step 'x' and all steps before 'x'.
+ */
+export type StepResults<InterestedIn extends StepName | undefined> = InterestedIn extends never ? never : InterestedIn extends undefined ? StepResultsHelper<typeof LAST_STEP> : StepResultsHelper<Exclude<InterestedIn, undefined>>;
+type StepResultsHelper<InterestedIn extends StepName> = {
+    'parse': Out<'parse'>;
+    'normalize': StepResultsHelper<'parse'> & Out<'normalize'>;
+    'dataflow': StepResultsHelper<'normalize'> & Out<'dataflow'>;
+    'slice': StepResultsHelper<'dataflow'> & Out<'slice'>;
+    'reconstruct': StepResultsHelper<'slice'> & Out<'reconstruct'>;
+}[InterestedIn];
+export {};

package/core/output.js

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