@eagleoutice/flowr 1.3.13 → 1.4.1

package/abstract-interpretation/domain.d.ts

@@ -0,0 +1,27 @@
+interface IntervalBound {
+    readonly value: number;
+    readonly inclusive: boolean;
+}
+export declare class Interval {
+    readonly min: IntervalBound;
+    readonly max: IntervalBound;
+    constructor(min: IntervalBound, max: IntervalBound);
+    toString(): string;
+}
+export declare class Domain {
+    private readonly _intervals;
+    private constructor();
+    static bottom(): Domain;
+    static fromIntervals(intervals: Interval[] | Set<Interval>): Domain;
+    static fromScalar(n: number): Domain;
+    get intervals(): Set<Interval>;
+    private set intervals(value);
+    addInterval(interval: Interval): void;
+    toString(): string;
+}
+export declare function doIntervalsOverlap(interval1: Interval, interval2: Interval): boolean;
+export declare function unifyDomains(domains: Domain[]): Domain;
+export declare function unifyOverlappingIntervals(intervals: Interval[]): Interval[];
+export declare function addDomains(domain1: Domain, domain2: Domain): Domain;
+export declare function subtractDomains(domain1: Domain, domain2: Domain): Domain;
+export {};

package/abstract-interpretation/domain.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subtractDomains = exports.addDomains = exports.unifyOverlappingIntervals = exports.unifyDomains = exports.doIntervalsOverlap = exports.Domain = exports.Interval = void 0;
+const assert_1 = require("../util/assert");
+class Interval {
+    min;
+    max;
+    constructor(min, max) {
+        this.min = min;
+        this.max = max;
+        (0, assert_1.guard)(min.value <= max.value, () => `The interval ${this.toString()} has a minimum that is greater than its maximum`);
+        (0, assert_1.guard)(min.value !== max.value || (min.inclusive === max.inclusive), `The bound ${min.value} cannot be in- and exclusive at the same time`);
+    }
+    toString() {
+        return `${this.min.inclusive ? '[' : '('}${this.min.value}, ${this.max.value}${this.max.inclusive ? ']' : ')'}`;
+    }
+}
+exports.Interval = Interval;
+class Domain {
+    _intervals;
+    constructor(intervals = []) {
+        this._intervals = new Set(unifyOverlappingIntervals(intervals));
+    }
+    static bottom() {
+        return new Domain();
+    }
+    static fromIntervals(intervals) {
+        return new Domain(Array.from(intervals));
+    }
+    static fromScalar(n) {
+        return new Domain([new Interval({ value: n, inclusive: true }, { value: n, inclusive: true })]);
+    }
+    get intervals() {
+        return this._intervals;
+    }
+    set intervals(intervals) {
+        this._intervals.clear();
+        for (const interval of intervals) {
+            this._intervals.add(interval);
+        }
+    }
+    addInterval(interval) {
+        this.intervals = unifyOverlappingIntervals([...this.intervals, interval]);
+    }
+    toString() {
+        return `{${Array.from(this.intervals).join(', ')}}`;
+    }
+}
+exports.Domain = Domain;
+function compareIntervals(compareType, interval1, interval2) {
+    const diff = interval1.value - interval2.value;
+    if (diff !== 0 || compareType === 2 /* CompareType.IgnoreInclusivity */) {
+        return diff;
+    }
+    switch (compareType) {
+        case 0 /* CompareType.Min */:
+            return Number(!interval1.inclusive) - Number(!interval2.inclusive);
+        case 1 /* CompareType.Max */:
+            return Number(interval1.inclusive) - Number(interval2.inclusive);
+        default:
+            (0, assert_1.assertUnreachable)(compareType);
+    }
+}
+function compareIntervalsByTheirMinimum(interval1, interval2) {
+    return compareIntervals(0 /* CompareType.Min */, interval1.min, interval2.min);
+}
+function compareIntervalsByTheirMaximum(interval1, interval2) {
+    return compareIntervals(1 /* CompareType.Max */, interval1.max, interval2.max);
+}
+function doIntervalsOverlap(interval1, interval2) {
+    const diff1 = compareIntervals(2 /* CompareType.IgnoreInclusivity */, interval1.max, interval2.min);
+    const diff2 = compareIntervals(2 /* CompareType.IgnoreInclusivity */, interval2.max, interval1.min);
+    // If one interval ends before the other starts, they don't overlap
+    if (diff1 < 0 || diff2 < 0) {
+        return false;
+    }
+    // If their end and start are equal, they only overlap if both are inclusive
+    if (diff1 === 0) {
+        return interval1.max.inclusive && interval2.min.inclusive;
+    }
+    if (diff2 === 0) {
+        return interval2.max.inclusive && interval1.min.inclusive;
+    }
+    return true;
+}
+exports.doIntervalsOverlap = doIntervalsOverlap;
+function unifyDomains(domains) {
+    const unifiedIntervals = unifyOverlappingIntervals(domains.flatMap(domain => Array.from(domain.intervals)));
+    return Domain.fromIntervals(unifiedIntervals);
+}
+exports.unifyDomains = unifyDomains;
+function unifyOverlappingIntervals(intervals) {
+    if (intervals.length === 0) {
+        return [];
+    }
+    const sortedIntervals = intervals.sort(compareIntervalsByTheirMinimum);
+    const unifiedIntervals = [];
+    let currentInterval = sortedIntervals[0];
+    for (const nextInterval of sortedIntervals) {
+        if (doIntervalsOverlap(currentInterval, nextInterval)) {
+            const intervalWithEarlierStart = compareIntervalsByTheirMinimum(currentInterval, nextInterval) < 0 ? currentInterval : nextInterval;
+            const intervalWithLaterEnd = compareIntervalsByTheirMaximum(currentInterval, nextInterval) > 0 ? currentInterval : nextInterval;
+            currentInterval = new Interval(intervalWithEarlierStart.min, intervalWithLaterEnd.max);
+        }
+        else {
+            unifiedIntervals.push(currentInterval);
+            currentInterval = nextInterval;
+        }
+    }
+    unifiedIntervals.push(currentInterval);
+    return unifiedIntervals;
+}
+exports.unifyOverlappingIntervals = unifyOverlappingIntervals;
+function addDomains(domain1, domain2) {
+    const intervals = new Set();
+    for (const interval1 of domain1.intervals) {
+        for (const interval2 of domain2.intervals) {
+            intervals.add(new Interval({
+                value: interval1.min.value + interval2.min.value,
+                inclusive: interval1.min.inclusive && interval2.min.inclusive
+            }, {
+                value: interval1.max.value + interval2.max.value,
+                inclusive: interval1.max.inclusive && interval2.max.inclusive
+            }));
+        }
+    }
+    return Domain.fromIntervals(intervals);
+}
+exports.addDomains = addDomains;
+function subtractDomains(domain1, domain2) {
+    const intervals = new Set();
+    for (const interval1 of domain1.intervals) {
+        for (const interval2 of domain2.intervals) {
+            intervals.add(new Interval({
+                value: interval1.min.value - interval2.max.value,
+                inclusive: interval1.min.inclusive && interval2.max.inclusive
+            }, {
+                value: interval1.max.value - interval2.min.value,
+                inclusive: interval1.max.inclusive && interval2.min.inclusive
+            }));
+        }
+    }
+    return Domain.fromIntervals(intervals);
+}
+exports.subtractDomains = subtractDomains;
+//# sourceMappingURL=domain.js.map

package/abstract-interpretation/handler/binop/binop.d.ts

@@ -0,0 +1,16 @@
+import type { Handler } from '../handler';
+import type { AINode } from '../../processor';
+import type { BinaryOperatorFlavor, ParentInformation, RBinaryOp } from '../../../r-bridge';
+export type BinOpOperators = {
+    [key in BinaryOperatorFlavor]: (lhs: AINode, rhs: AINode, node: RBinaryOp<ParentInformation>) => AINode;
+};
+export declare class BinOp implements Handler<AINode> {
+    readonly node: RBinaryOp<ParentInformation>;
+    lhs: AINode | undefined;
+    rhs: AINode | undefined;
+    constructor(node: RBinaryOp<ParentInformation>);
+    getName(): string;
+    enter(): void;
+    exit(): AINode;
+    next(node: AINode): void;
+}

package/abstract-interpretation/handler/binop/binop.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinOp = void 0;
+const processor_1 = require("../../processor");
+const assert_1 = require("../../../util/assert");
+const operators_1 = require("./operators");
+class BinOp {
+    node;
+    lhs;
+    rhs;
+    constructor(node) {
+        this.node = node;
+    }
+    getName() {
+        return `Bin Op (${this.node.flavor})`;
+    }
+    enter() {
+        processor_1.aiLogger.trace(`Entered ${this.getName()}`);
+    }
+    exit() {
+        processor_1.aiLogger.trace(`Exited ${this.getName()}`);
+        (0, assert_1.guard)(this.lhs !== undefined, `No LHS found for assignment ${this.node.info.id}`);
+        (0, assert_1.guard)(this.rhs !== undefined, `No RHS found for assignment ${this.node.info.id}`);
+        return operators_1.operators[this.node.flavor](this.lhs, this.rhs, this.node);
+    }
+    next(node) {
+        processor_1.aiLogger.trace(`${this.getName()} received`);
+        if (this.lhs === undefined) {
+            this.lhs = node;
+        }
+        else if (this.rhs === undefined) {
+            this.rhs = node;
+        }
+        else {
+            (0, assert_1.guard)(false, `BinOp ${this.node.info.id} already has both LHS and RHS`);
+        }
+    }
+}
+exports.BinOp = BinOp;
+//# sourceMappingURL=binop.js.map

package/abstract-interpretation/handler/binop/operators.d.ts

@@ -0,0 +1,2 @@
+import type { BinOpOperators } from './binop';
+export declare const operators: BinOpOperators;

package/abstract-interpretation/handler/binop/operators.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operators = void 0;
+const assert_1 = require("../../../util/assert");
+const domain_1 = require("../../domain");
+exports.operators = {
+    'assignment': (lhs, rhs, node) => {
+        return {
+            id: lhs.id,
+            domain: rhs.domain,
+            astNode: node.lhs,
+        };
+    },
+    'arithmetic': (lhs, rhs, node) => {
+        switch (node.operator) {
+            case '+':
+                return {
+                    id: lhs.id,
+                    domain: (0, domain_1.addDomains)(lhs.domain, rhs.domain),
+                    astNode: node,
+                };
+            case '-':
+                return {
+                    id: lhs.id,
+                    domain: (0, domain_1.subtractDomains)(lhs.domain, rhs.domain),
+                    astNode: node,
+                };
+            default:
+                (0, assert_1.guard)(false, `Unknown binary operator ${node.operator}`);
+        }
+    },
+    'logical': () => {
+        (0, assert_1.guard)(false, 'Not implemented yet');
+    },
+    'model formula': () => {
+        (0, assert_1.guard)(false, 'Not implemented yet');
+    },
+    'comparison': () => {
+        (0, assert_1.guard)(false, 'Not implemented yet');
+    },
+};
+//# sourceMappingURL=operators.js.map

package/abstract-interpretation/handler/handler.d.ts

@@ -0,0 +1,6 @@
+export interface Handler<ValueType> {
+    getName: () => string;
+    enter: () => void;
+    exit: () => ValueType;
+    next: (value: ValueType) => void;
+}

package/abstract-interpretation/handler/handler.js

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

package/abstract-interpretation/processor.d.ts

@@ -0,0 +1,10 @@
+import type { DataflowInformation } from '../dataflow/internal/info';
+import type { NodeId, NormalizedAst, ParentInformation, RNodeWithParent } from '../r-bridge';
+import { Domain } from './domain';
+export declare const aiLogger: import("tslog").Logger<import("tslog").ILogObj>;
+export interface AINode {
+    readonly id: NodeId;
+    readonly domain: Domain;
+    readonly astNode: RNodeWithParent<ParentInformation>;
+}
+export declare function runAbstractInterpretation(ast: NormalizedAst, dfg: DataflowInformation): DataflowInformation;

package/abstract-interpretation/processor.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAbstractInterpretation = exports.aiLogger = void 0;
+const cfg_1 = require("../util/cfg/cfg");
+const visitor_1 = require("../util/cfg/visitor");
+const assert_1 = require("../util/assert");
+const dataflow_1 = require("../dataflow");
+const binop_1 = require("./handler/binop/binop");
+const domain_1 = require("./domain");
+const log_1 = require("../util/log");
+exports.aiLogger = log_1.log.getSubLogger({ name: 'abstract-interpretation' });
+class Stack {
+    backingStore = [];
+    size() { return this.backingStore.length; }
+    peek() { return this.backingStore[this.size() - 1]; }
+    pop() { return this.backingStore.pop(); }
+    push(item) {
+        this.backingStore.push(item);
+        return item;
+    }
+}
+function getDomainOfDfgChild(node, dfg, nodeMap) {
+    const dfgNode = dfg.graph.get(node);
+    (0, assert_1.guard)(dfgNode !== undefined, `No DFG-Node found with ID ${node}`);
+    const [_, children] = dfgNode;
+    const ids = Array.from(children.entries())
+        .filter(([_, edge]) => edge.types.has(dataflow_1.EdgeType.Reads))
+        .map(([id, _]) => id);
+    const domains = [];
+    for (const id of ids) {
+        const domain = nodeMap.get(id)?.domain;
+        (0, assert_1.guard)(domain !== undefined, `No domain found for ID ${id}`);
+        domains.push(domain);
+    }
+    return (0, domain_1.unifyDomains)(domains);
+}
+function runAbstractInterpretation(ast, dfg) {
+    const cfg = (0, cfg_1.extractCFG)(ast);
+    const operationStack = new Stack();
+    const nodeMap = new Map();
+    (0, visitor_1.visitCfg)(cfg, (node, _) => {
+        const astNode = ast.idMap.get(node.id);
+        if (astNode?.type === "RBinaryOp" /* RType.BinaryOp */) {
+            operationStack.push(new binop_1.BinOp(astNode)).enter();
+        }
+        else if (astNode?.type === "RSymbol" /* RType.Symbol */) {
+            operationStack.peek()?.next({
+                id: astNode.info.id,
+                domain: getDomainOfDfgChild(node.id, dfg, nodeMap),
+                astNode: astNode,
+            });
+        }
+        else if (astNode?.type === "RNumber" /* RType.Number */) {
+            const num = astNode.content.num;
+            operationStack.peek()?.next({
+                id: astNode.info.id,
+                domain: domain_1.Domain.fromScalar(num),
+                astNode: astNode,
+            });
+        }
+        else if (node.type === "end-marker" /* CfgVertexType.EndMarker */) {
+            const operation = operationStack.pop();
+            if (operation === undefined) {
+                return;
+            }
+            const operationResult = operation.exit();
+            (0, assert_1.guard)(!nodeMap.has(operationResult.id), `Domain for ID ${operationResult.id} already exists`);
+            nodeMap.set(operationResult.id, operationResult);
+            operationStack.peek()?.next(operationResult);
+        }
+        else {
+            exports.aiLogger.warn(`Unknown node type ${node.type}`);
+        }
+    });
+    return dfg;
+}
+exports.runAbstractInterpretation = runAbstractInterpretation;
+//# sourceMappingURL=processor.js.map

package/benchmark/slicer.d.ts

@@ -2,11 +2,11 @@
  * Provides a top-level slicer that can be used to slice code *and* retrieve stats.
  * @module
  */
-import { NormalizedAst, RParseRequestFromFile, RParseRequestFromText } from '../r-bridge';
-import { DataflowInformation } from '../dataflow/internal/info';
-import { SlicingCriteria, SlicingCriteriaFilter, SliceResult, ReconstructionResult } from '../slicing';
-import { PerSliceStats, SlicerStats } from './stats';
-import { MergeableRecord } from '../util/objects';
+import type { NormalizedAst, RParseRequestFromFile, RParseRequestFromText } from '../r-bridge';
+import type { DataflowInformation } from '../dataflow/internal/info';
+import type { SlicingCriteria, SlicingCriteriaFilter, SliceResult, ReconstructionResult } from '../slicing';
+import type { PerSliceStats, SlicerStats } from './stats';
+import type { MergeableRecord } from '../util/objects';
 export declare const benchmarkLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * Returns the stats but also the result of all setup steps (parsing, normalization, and the dataflow analysis) during the slicing.
@@ -54,6 +54,7 @@ export declare class BenchmarkSlicer {
     private loadedXml;
     private tokenMap;
     private dataflow;
+    private ai;
     private normalizedAst;
     private totalStopwatch;
     private finished;

package/benchmark/slicer.js

@@ -35,6 +35,7 @@ class BenchmarkSlicer {
     loadedXml;
     tokenMap;
     dataflow;
+    ai;
     normalizedAst;
     totalStopwatch;
     finished = false;
@@ -68,6 +69,7 @@ class BenchmarkSlicer {
         this.loadedXml = await this.measureCommonStep('parse', 'retrieve AST from R code');
         this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST');
         this.dataflow = await this.measureCommonStep('dataflow', 'produce dataflow information');
+        this.ai = await this.measureCommonStep('ai', 'run abstract interpretation');
         this.stepper.switchToSliceStage();
         await this.calculateStatsAfterInit(request);
     }

package/benchmark/stats/print.d.ts

@@ -1,4 +1,4 @@
-import { SummarizedSlicerStats, UltimateSlicerStats } from '../../util/summarizer/benchmark/data';
+import type { SummarizedSlicerStats, UltimateSlicerStats } from '../../util/summarizer/benchmark/data';
 /**
  * Converts the given stats to a human-readable string.
  * You may have to {@link summarizeSlicerStats | summarize} the stats first.

package/benchmark/stats/stats.d.ts

@@ -1,7 +1,7 @@
-import { SingleSlicingCriterion, SlicingCriteria } from '../../slicing';
-import { NodeId, RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge';
-import { ReconstructionResult } from '../../slicing';
-export declare const CommonSlicerMeasurements: readonly ["initialize R session", "inject home path", "ensure installation of xmlparsedata", "retrieve token map", "retrieve AST from R code", "normalize R AST", "produce dataflow information", "close R session", "total"];
+import type { SingleSlicingCriterion, SlicingCriteria } from '../../slicing';
+import type { NodeId, RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge';
+import type { ReconstructionResult } from '../../slicing';
+export declare const CommonSlicerMeasurements: readonly ["initialize R session", "inject home path", "ensure installation of xmlparsedata", "retrieve token map", "retrieve AST from R code", "normalize R AST", "produce dataflow information", "run abstract interpretation", "close R session", "total"];
 export type CommonSlicerMeasurements = typeof CommonSlicerMeasurements[number];
 export declare const PerSliceMeasurements: readonly ["static slicing", "reconstruct code", "total"];
 export type PerSliceMeasurements = typeof PerSliceMeasurements[number];

package/benchmark/stats/stats.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PerSliceMeasurements = exports.CommonSlicerMeasurements = void 0;
-exports.CommonSlicerMeasurements = ['initialize R session', 'inject home path', 'ensure installation of xmlparsedata', 'retrieve token map', 'retrieve AST from R code', 'normalize R AST', 'produce dataflow information', 'close R session', 'total'];
+exports.CommonSlicerMeasurements = ['initialize R session', 'inject home path', 'ensure installation of xmlparsedata', 'retrieve token map', 'retrieve AST from R code', 'normalize R AST', 'produce dataflow information', 'run abstract interpretation', 'close R session', 'total'];
 exports.PerSliceMeasurements = ['static slicing', 'reconstruct code', 'total'];
 //# sourceMappingURL=stats.js.map

package/cli/common/features.d.ts

@@ -1,3 +1,3 @@
-import { FeatureKey } from '../../statistics';
+import type { FeatureKey } from '../../statistics';
 export declare function validateFeatures(features: (string[] | ['all'] | FeatureKey[])): Set<FeatureKey>;
 export declare function retrieveArchiveName(p: string): string;

package/cli/common/options.d.ts

@@ -1,4 +1,4 @@
-import { OptionDefinition } from 'command-line-usage';
+import type { OptionDefinition } from 'command-line-usage';
 /**
  * This interface describes options, that every script *must* provide.
  */

package/cli/common/script.d.ts

@@ -4,7 +4,7 @@
  * @module
  */
 import { scripts } from './scripts-info';
-import { CommonOptions } from './options';
+import type { CommonOptions } from './options';
 /**
  * Just a helping data structure to allow the user to provide example usages of the respective script.
  * The subtitle will be displayed next to the title.

package/cli/common/scripts-info.d.ts

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { MergeableRecord } from '../../util/objects';
-import { OptionDefinition } from 'command-line-usage';
+import type { MergeableRecord } from '../../util/objects';
+import type { OptionDefinition } from 'command-line-usage';
 interface BaseScriptInformation extends MergeableRecord {
     toolName: string;
     target: string;

package/cli/repl/commands/cfg.d.ts

@@ -1,3 +1,3 @@
-import { ReplCommand } from './main';
+import type { ReplCommand } from './main';
 export declare const controlflowCommand: ReplCommand;
 export declare const controlflowStarCommand: ReplCommand;

package/cli/repl/commands/cfg.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.controlflowStarCommand = exports.controlflowCommand = void 0;
 const core_1 = require("../../../core");
 const r_bridge_1 = require("../../../r-bridge");
-const cfg_1 = require("../../../util/cfg");
+const cfg_1 = require("../../../util/cfg/cfg");
 const mermaid_1 = require("../../../util/mermaid");
 async function controlflow(shell, remainingLine) {
     return await new core_1.SteppingSlicer({

package/cli/repl/commands/commands.d.ts

@@ -1,4 +1,4 @@
-import { ReplCommand } from './main';
+import type { ReplCommand } from './main';
 export declare const helpCommand: ReplCommand;
 /**
  * The names of all commands including their aliases (but without the leading `:`)

package/cli/repl/commands/dataflow.d.ts

@@ -1,3 +1,3 @@
-import { ReplCommand } from './main';
+import type { ReplCommand } from './main';
 export declare const dataflowCommand: ReplCommand;
 export declare const dataflowStarCommand: ReplCommand;

package/cli/repl/commands/execute.d.ts

@@ -1,4 +1,4 @@
-import { RShell } from '../../../r-bridge';
-import { ReplCommand, ReplOutput } from './main';
+import type { RShell } from '../../../r-bridge';
+import type { ReplCommand, ReplOutput } from './main';
 export declare function executeRShellCommand(output: ReplOutput, shell: RShell, statement: string): Promise<void>;
 export declare const executeCommand: ReplCommand;

package/cli/repl/commands/main.d.ts

@@ -1,5 +1,5 @@
-import { RShell } from '../../../r-bridge';
-import { OutputFormatter } from '../../../statistics';
+import type { RShell } from '../../../r-bridge';
+import type { OutputFormatter } from '../../../statistics';
 /**
  * Defines the main interface for output of the repl.
  * This allows us to redirect it (e.g., in the case of a server connection or tests).

package/cli/repl/commands/normalize.d.ts

@@ -1,3 +1,3 @@
-import { ReplCommand } from './main';
+import type { ReplCommand } from './main';
 export declare const normalizeCommand: ReplCommand;
 export declare const normalizeStarCommand: ReplCommand;

package/cli/repl/commands/parse.d.ts

@@ -1,2 +1,2 @@
-import { ReplCommand } from './main';
+import type { ReplCommand } from './main';
 export declare const parseCommand: ReplCommand;

package/cli/repl/commands/quit.d.ts

@@ -1,2 +1,2 @@
-import { ReplCommand } from './main';
+import type { ReplCommand } from './main';
 export declare const quitCommand: ReplCommand;

package/cli/repl/commands/version.d.ts

@@ -1,4 +1,4 @@
-import { ReplCommand, ReplOutput } from './main';
+import type { ReplCommand, ReplOutput } from './main';
 import { RShell } from '../../../r-bridge';
 type Version = `${number}.${number}.${number}`;
 /**

package/cli/repl/core.d.ts

@@ -1,19 +1,17 @@
 /// <reference types="node" />
-/// <reference types="node" />
 /**
  * Basically a helper file to allow the main 'flowr' script (located in the source root) to provide its repl
  *
  * @module
  */
 import { RShell } from '../../r-bridge';
-import readline from 'readline/promises';
-import { ReplOutput } from './commands';
-import { ReadLineOptions } from 'node:readline';
+import type { ReplOutput } from './commands';
+import * as readline from 'node:readline';
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
 export declare function replCompleter(line: string): [string[], string];
-export declare const DEFAULT_REPL_READLINE_CONFIGURATION: ReadLineOptions;
+export declare const DEFAULT_REPL_READLINE_CONFIGURATION: readline.ReadLineOptions;
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *

package/cli/repl/core.js

@@ -1,6 +1,26 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.repl = exports.replProcessAnswer = exports.DEFAULT_REPL_READLINE_CONFIGURATION = exports.replCompleter = void 0;
@@ -10,10 +30,10 @@ exports.repl = exports.replProcessAnswer = exports.DEFAULT_REPL_READLINE_CONFIGU
  * @module
  */
 const r_bridge_1 = require("../../r-bridge");
-const promises_1 = __importDefault(require("readline/promises"));
 const statistics_1 = require("../../statistics");
 const prompt_1 = require("./prompt");
 const commands_1 = require("./commands");
+const readline = __importStar(require("node:readline"));
 const args_1 = require("../../util/args");
 const execute_1 = require("./commands/execute");
 const replCompleterKeywords = Array.from(commands_1.commandNames, s => `:${s}`);
@@ -77,12 +97,19 @@ exports.replProcessAnswer = replProcessAnswer;
  * For the execution, this function makes use of {@link replProcessAnswer}
  *
  */
-async function repl(shell = new r_bridge_1.RShell({ revive: 'always' }), rl = promises_1.default.createInterface(exports.DEFAULT_REPL_READLINE_CONFIGURATION), output = commands_1.standardReplOutput) {
+async function repl(shell = new r_bridge_1.RShell({ revive: 'always' }), rl = readline.createInterface(exports.DEFAULT_REPL_READLINE_CONFIGURATION), output = commands_1.standardReplOutput) {
     // the incredible repl :D, we kill it with ':quit'
     // eslint-disable-next-line no-constant-condition,@typescript-eslint/no-unnecessary-condition
     while (true) {
-        const answer = await rl.question((0, prompt_1.prompt)());
-        await replProcessAnswer(output, answer, shell);
+        await new Promise((resolve, reject) => {
+            rl.question((0, prompt_1.prompt)(), answer => {
+                rl.pause();
+                replProcessAnswer(output, answer, shell).then(() => {
+                    rl.resume();
+                    resolve();
+                }).catch(reject);
+            });
+        });
     }
 }
 exports.repl = repl;