@eagleoutice/flowr 1.3.14 → 1.4.1

package/cli/repl/server/messages/analysis.js

@@ -1,41 +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 __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;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestAnalysisMessage = void 0;
-const Joi = __importStar(require("joi"));
+const joi_1 = __importDefault(require("joi"));
 exports.requestAnalysisMessage = {
     type: 'request-file-analysis',
-    schema: Joi.object({
-        type: Joi.string().valid('request-file-analysis').required(),
-        id: Joi.string().optional(),
-        filetoken: Joi.string().optional(),
-        filename: Joi.string().optional(),
-        content: Joi.string().optional(),
-        filepath: Joi.string().optional(),
-        cfg: Joi.boolean().optional(),
-        format: Joi.string().valid('json', 'n-quads').optional()
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('request-file-analysis').required(),
+        id: joi_1.default.string().optional(),
+        filetoken: joi_1.default.string().optional(),
+        filename: joi_1.default.string().optional(),
+        content: joi_1.default.string().optional(),
+        filepath: joi_1.default.string().optional(),
+        cfg: joi_1.default.boolean().optional(),
+        format: joi_1.default.string().valid('json', 'n-quads').optional()
     }).xor('content', 'filepath')
 };
 //# sourceMappingURL=analysis.js.map

package/cli/repl/server/messages/error.d.ts

@@ -1,4 +1,4 @@
-import { IdMessageBase } from './messages';
+import type { IdMessageBase } from './messages';
 /**
  * Sent in case of any error (e.g., if the analysis fails, or the message contains syntax errors).
  */

package/cli/repl/server/messages/hello.d.ts

@@ -1,5 +1,5 @@
-import { VersionInformation } from '../../commands/version';
-import { IdMessageBase } from './messages';
+import type { VersionInformation } from '../../commands/version';
+import type { IdMessageBase } from './messages';
 /**
  * The hello message is automatically send by the sever upon connection.
  */

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

@@ -4,11 +4,11 @@
  * @module
  */
 import * as Joi from 'joi';
-import { FlowrHelloResponseMessage } from './hello';
-import { FileAnalysisRequestMessage, FileAnalysisResponseMessageJson } from './analysis';
-import { ExecuteEndMessage, ExecuteIntermediateResponseMessage, ExecuteRequestMessage } from './repl';
-import { SliceRequestMessage, SliceResponseMessage } from './slice';
-import { FlowrErrorMessage } from './error';
+import type { FlowrHelloResponseMessage } from './hello';
+import type { FileAnalysisRequestMessage, FileAnalysisResponseMessageJson } from './analysis';
+import type { ExecuteEndMessage, ExecuteIntermediateResponseMessage, ExecuteRequestMessage } from './repl';
+import type { SliceRequestMessage, SliceResponseMessage } from './slice';
+import type { FlowrErrorMessage } from './error';
 /**
  * If you send a message it must *not* contain a newline but the message must be terminated by a newline.
  */

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

@@ -1,4 +1,4 @@
-import { IdMessageBase, MessageDefinition } from './messages';
+import type { IdMessageBase, MessageDefinition } from './messages';
 /**
  * Request the execution of the given expression as a REPL statement.
  * We strongly recommend that you make use of a unique {@link IdMessageBase#id}

package/cli/repl/server/messages/slice.d.ts

@@ -1,6 +1,6 @@
-import { SlicingCriteria } from '../../../../slicing';
-import { LAST_PER_FILE_STEP, LAST_STEP, StepResults } from '../../../../core';
-import { IdMessageBase, MessageDefinition } from './messages';
+import type { SlicingCriteria } from '../../../../slicing';
+import type { LAST_PER_FILE_STEP, LAST_STEP, StepResults } from '../../../../core';
+import type { IdMessageBase, MessageDefinition } from './messages';
 /**
  * Can only be sent after you have sent the {@link FileAnalysisRequestMessage}.
  * Using the same `filetoken` as in the {@link FileAnalysisRequestMessage} you

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import type WebSocket from 'ws';
 /** Function handler that should be triggered when the respective socket connects */
 export type OnConnect = (c: Socket) => void;
 /**
@@ -12,6 +13,12 @@ export interface Server {
     onConnect(handler: OnConnect): void;
     start(port: number): void;
 }
+export declare class WebSocketServerWrapper implements Server {
+    private server;
+    private connectHandler;
+    onConnect(handler: OnConnect): void;
+    start(port: number): void;
+}
 /**
  * The socket abstraction of *flowR*.
  * Essentially a subset of what the default `net.Socket` of `node` provides.
@@ -25,6 +32,15 @@ export interface Socket {
     write(data: string): void;
     end(): void;
 }
+export declare class WebSocketWrapper implements Socket {
+    private readonly socket;
+    remoteAddress?: string;
+    remotePort?: number;
+    constructor(socket: WebSocket);
+    write(data: string): void;
+    end(): void;
+    on(event: 'data' | 'close' | 'error', listener: (data: Buffer) => void): void;
+}
 export declare class NetServer implements Server {
     private readonly server;
     constructor();

package/cli/repl/server/net.js

@@ -3,11 +3,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetServer = void 0;
+exports.NetServer = exports.WebSocketWrapper = exports.WebSocketServerWrapper = void 0;
 /**
  * This is just a simple layer to allow me to mock the server's behavior in tests.
  */
 const node_net_1 = __importDefault(require("node:net"));
+const ws_1 = require("ws");
+const server_1 = require("./server");
+class WebSocketServerWrapper {
+    server;
+    connectHandler;
+    onConnect(handler) {
+        this.connectHandler = handler;
+    }
+    start(port) {
+        this.server = new ws_1.WebSocketServer({ port });
+        server_1.serverLog.info('WebSocket-Server wrapper is active!');
+        this.server.on('connection', c => this.connectHandler?.(new WebSocketWrapper(c)));
+    }
+}
+exports.WebSocketServerWrapper = WebSocketServerWrapper;
+class WebSocketWrapper {
+    socket;
+    remoteAddress;
+    remotePort;
+    constructor(socket) {
+        this.socket = socket;
+        this.remoteAddress = socket.url;
+    }
+    write(data) {
+        this.socket.send(data);
+    }
+    end() {
+        this.socket.close();
+    }
+    on(event, listener) {
+        if (event === 'data') {
+            this.socket.on('message', listener);
+        }
+        else {
+            this.socket.on(event, listener);
+        }
+    }
+}
+exports.WebSocketWrapper = WebSocketWrapper;
 class NetServer {
     server;
     constructor() {

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

@@ -1,4 +1,4 @@
-import { IdMessageBase } from './messages/messages';
-import { Socket } from './net';
+import type { IdMessageBase } from './messages/messages';
+import type { Socket } from './net';
 export declare function getUnnamedSocketName(c: Socket): string;
 export declare function sendMessage<T extends IdMessageBase>(c: Socket, message: T): void;

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

@@ -1,5 +1,5 @@
-import { RShell } from '../../../r-bridge';
-import { Server } from './net';
+import type { RShell } from '../../../r-bridge';
+import type { Server } from './net';
 import { FlowrLogger } from '../../../util/log';
 export declare const serverLog: FlowrLogger;
 /**

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

@@ -1,6 +1,6 @@
-import * as Joi from 'joi';
-import { FlowrMessage, IdMessageBase, MessageDefinition } from './messages/messages';
-import { Socket } from './net';
+import type * as Joi from 'joi';
+import type { FlowrMessage, IdMessageBase, MessageDefinition } from './messages/messages';
+import type { Socket } from './net';
 export interface ValidationErrorResult {
     type: 'error';
     reason: Joi.ValidationError | Error;

package/cli/statistics-helper-app.js

@@ -8,13 +8,13 @@ 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 tar_1 = require("tar");
+const cfg_1 = require("../util/cfg/cfg");
 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: [

package/core/input.d.ts

@@ -1,8 +1,8 @@
-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';
+import type { MergeableRecord } from '../util/objects';
+import type { IdGenerator, NoInfo, RParseRequest, RShell, XmlParserHooks } from '../r-bridge';
+import type { DeepPartial } from 'ts-essentials';
+import type { AutoSelectPredicate, SlicingCriteria } from '../slicing';
+import type { 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
@@ -27,7 +27,7 @@ interface BaseSteppingSlicerInput<InterestedIn extends StepName | undefined> ext
     /** 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> {
+interface NormalizeSteppingSlicerInput<InterestedIn extends 'ai' | 'dataflow' | 'normalize'> extends BaseSteppingSlicerInput<InterestedIn> {
     stepOfInterest: InterestedIn;
 }
 interface SliceSteppingSlicerInput<InterestedIn extends 'reconstruct' | 'slice' | undefined> extends BaseSteppingSlicerInput<InterestedIn> {

package/core/output.d.ts

@@ -1,4 +1,4 @@
-import { LAST_STEP, StepName, StepResult } from './steps';
+import type { 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>>;
 /**
@@ -9,7 +9,8 @@ type StepResultsHelper<InterestedIn extends StepName> = {
     'parse': Out<'parse'>;
     'normalize': StepResultsHelper<'parse'> & Out<'normalize'>;
     'dataflow': StepResultsHelper<'normalize'> & Out<'dataflow'>;
-    'slice': StepResultsHelper<'dataflow'> & Out<'slice'>;
+    'ai': StepResultsHelper<'dataflow'> & Out<'ai'>;
+    'slice': StepResultsHelper<'ai'> & Out<'slice'>;
     'reconstruct': StepResultsHelper<'slice'> & Out<'reconstruct'>;
 }[InterestedIn];
 export {};

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

@@ -1,6 +1,6 @@
-import { DataflowInformation } from '../../dataflow/internal/info';
-import { QuadSerializationConfiguration } from '../../util/quads';
-import { DataflowMap } from '../../dataflow';
+import type { DataflowInformation } from '../../dataflow/internal/info';
+import type { QuadSerializationConfiguration } from '../../util/quads';
+import type { 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;

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

@@ -1,5 +1,5 @@
-import { NormalizedAst } from '../../r-bridge';
-import { QuadSerializationConfiguration } from '../../util/quads';
+import type { NormalizedAst } from '../../r-bridge';
+import type { 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;

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

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

package/core/print/print.d.ts

@@ -1,4 +1,4 @@
-import { StepFunction } from '../steps';
+import type { StepFunction } from '../steps';
 /**
  * Defines the output format of a step that you are interested in.
  */

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

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

package/core/slicer.d.ts

@@ -1,7 +1,8 @@
-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';
+import type { LAST_PER_FILE_STEP, StepRequired, StepName, StepResult } from './steps';
+import { LAST_STEP, STEPS_PER_SLICE } from './steps';
+import type { SlicingCriteria } from '../slicing';
+import type { SteppingSlicerInput } from './input';
+import type { 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.

package/core/slicer.js

@@ -169,11 +169,15 @@ class SteppingSlicer {
                 result = (0, steps_1.executeSingleSubStep)(step, this.results.normalize);
                 break;
             case 3:
+                step = guardStep('ai');
+                result = (0, steps_1.executeSingleSubStep)(step, this.results.normalize, this.results.dataflow);
+                break;
+            case 4:
                 (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);
+                result = (0, steps_1.executeSingleSubStep)(step, this.results.ai.graph, this.results.normalize, this.criterion);
                 break;
-            case 4:
+            case 5:
                 step = guardStep('reconstruct');
                 result = (0, steps_1.executeSingleSubStep)(step, this.results.normalize, this.results.slice.result);
                 break;

package/core/steps.d.ts

@@ -12,14 +12,16 @@
  *
  * @module
  */
-import { MergeableRecord } from '../util/objects';
+import type { MergeableRecord } from '../util/objects';
 import { normalize, retrieveXmlFromRCode } from '../r-bridge';
 import { produceDataFlowGraph } from '../dataflow';
 import { reconstructToCode, staticSlicing } from '../slicing';
-import { internalPrinter, IStepPrinter, StepOutputFormat } from './print/print';
+import type { IStepPrinter } from './print/print';
+import { internalPrinter, StepOutputFormat } from './print/print';
 import { normalizedAstToJson, normalizedAstToQuads, printNormalizedAstToMermaid, printNormalizedAstToMermaidUrl } from './print/normalize-printer';
-import { dataflowGraphToJson, dataflowGraphToMermaid, dataflowGraphToMermaidUrl, dataflowGraphToQuads } from './print/dataflow-printer';
 import { parseToQuads } from './print/parse-printer';
+import { dataflowGraphToJson, dataflowGraphToMermaid, dataflowGraphToMermaidUrl, dataflowGraphToQuads } from './print/dataflow-printer';
+import type { DataflowInformation } from '../dataflow/internal/info';
 /**
  * This represents close a function that we know completely nothing about.
  * Nevertheless, this is the basis of what a step processor should look like.
@@ -79,6 +81,14 @@ export declare const STEPS_PER_FILE: {
             4: typeof dataflowGraphToMermaidUrl;
         };
     };
+    readonly ai: {
+        description: string;
+        processor: (_: import("../r-bridge").NormalizedAst<import("../r-bridge").ParentInformation>, dfInfo: DataflowInformation) => DataflowInformation;
+        required: "once-per-file";
+        printer: {
+            0: typeof internalPrinter;
+        };
+    };
 };
 export declare const STEPS_PER_SLICE: {
     readonly slice: {
@@ -149,8 +159,16 @@ export declare const STEPS: {
             4: typeof dataflowGraphToMermaidUrl;
         };
     };
+    readonly ai: {
+        description: string;
+        processor: (_: import("../r-bridge").NormalizedAst<import("../r-bridge").ParentInformation>, dfInfo: DataflowInformation) => DataflowInformation;
+        required: "once-per-file";
+        printer: {
+            0: typeof internalPrinter;
+        };
+    };
 };
-export declare const LAST_PER_FILE_STEP: "dataflow";
+export declare const LAST_PER_FILE_STEP: "ai";
 export declare const LAST_STEP: "reconstruct";
 export type StepName = keyof typeof STEPS;
 export type Step<Name extends StepName> = typeof STEPS[Name];

package/core/steps.js

@@ -21,8 +21,8 @@ const slicing_1 = require("../slicing");
 const print_1 = require("./print/print");
 const normalize_printer_1 = require("./print/normalize-printer");
 const assert_1 = require("../util/assert");
-const dataflow_printer_1 = require("./print/dataflow-printer");
 const parse_printer_1 = require("./print/parse-printer");
+const dataflow_printer_1 = require("./print/dataflow-printer");
 exports.STEPS_PER_FILE = {
     'parse': {
         description: 'Parse the given R code into an AST',
@@ -57,6 +57,14 @@ exports.STEPS_PER_FILE = {
             [3 /* StepOutputFormat.Mermaid */]: dataflow_printer_1.dataflowGraphToMermaid,
             [4 /* StepOutputFormat.MermaidUrl */]: dataflow_printer_1.dataflowGraphToMermaidUrl
         }
+    },
+    'ai': {
+        description: 'Run abstract interpretation',
+        processor: (_, dfInfo) => dfInfo, // Use runAbstractInterpretation here when it's ready
+        required: 'once-per-file',
+        printer: {
+            [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
+        }
     }
 };
 exports.STEPS_PER_SLICE = {
@@ -78,7 +86,7 @@ exports.STEPS_PER_SLICE = {
     }
 };
 exports.STEPS = { ...exports.STEPS_PER_FILE, ...exports.STEPS_PER_SLICE };
-exports.LAST_PER_FILE_STEP = 'dataflow';
+exports.LAST_PER_FILE_STEP = 'ai';
 exports.LAST_STEP = 'reconstruct';
 function executeSingleSubStep(subStep, ...input) {
     // @ts-expect-error - this is safe, as we know that the function arguments are correct by 'satisfies', this saves an explicit cast with 'as'

package/dataflow/environments/append.d.ts

@@ -1,4 +1,4 @@
-import { REnvironmentInformation } from './environment';
+import type { REnvironmentInformation } from './environment';
 /**
  * Adds all writes of `next` to `base` (i.e., the operations of `next` *might* happen).
  */

package/dataflow/environments/environment.d.ts

@@ -4,10 +4,10 @@
  *
  * @module
  */
-import { NodeId } from '../../r-bridge';
-import { DataflowGraph, DataflowGraphEdgeAttribute } from '../graph';
-import { DataflowScopeName } from './scopes';
-import { GenericDifferenceInformation } from '../../util/diff';
+import type { NodeId } from '../../r-bridge';
+import type { DataflowGraph, DataflowGraphEdgeAttribute } from '../graph';
+import type { DataflowScopeName } from './scopes';
+import type { GenericDifferenceInformation } from '../../util/diff';
 /** identifiers are branded to avoid confusion with other string-like types */
 export type Identifier = string & {
     __brand?: 'identifier';

package/dataflow/environments/overwrite.d.ts

@@ -1,4 +1,4 @@
-import { REnvironmentInformation, IEnvironment } from './environment';
+import type { REnvironmentInformation, IEnvironment } from './environment';
 export declare function overwriteIEnvironmentWith(base: IEnvironment | undefined, next: IEnvironment | undefined, includeParent?: boolean): IEnvironment;
 export declare function overwriteEnvironments(base: REnvironmentInformation, next: REnvironmentInformation | undefined): REnvironmentInformation;
 export declare function overwriteEnvironments(base: REnvironmentInformation | undefined, next: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/register.d.ts

@@ -1,5 +1,5 @@
-import { IdentifierDefinition, REnvironmentInformation } from './environment';
-import { DataflowScopeName } from './scopes';
+import type { IdentifierDefinition, REnvironmentInformation } from './environment';
+import type { DataflowScopeName } from './scopes';
 /**
  * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
  * Does not modify the passed along `environments` in-place! It returns the new reference.

package/dataflow/environments/resolve-by-name.d.ts

@@ -1,5 +1,5 @@
-import { Identifier, IdentifierDefinition, REnvironmentInformation } from './environment';
-import { DataflowScopeName } from './scopes';
+import type { Identifier, IdentifierDefinition, REnvironmentInformation } from './environment';
+import type { DataflowScopeName } from './scopes';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  *

package/dataflow/environments/scoping.d.ts

@@ -1,4 +1,4 @@
-import { REnvironmentInformation } from './environment';
+import type { REnvironmentInformation } from './environment';
 /** Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone) */
 export declare function pushLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;
 export declare function popLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;

package/dataflow/extractor.d.ts

@@ -1,6 +1,6 @@
-import { NormalizedAst, ParentInformation, RBinaryOp } from '../r-bridge';
-import { DataflowInformation } from './internal/info';
-import { DataflowProcessorInformation } from './processor';
-import { DataflowScopeName } from './environments';
+import type { NormalizedAst, ParentInformation, RBinaryOp } from '../r-bridge';
+import type { DataflowInformation } from './internal/info';
+import type { DataflowProcessorInformation } from './processor';
+import type { DataflowScopeName } from './environments';
 export declare function produceDataFlowGraph<OtherInfo>(ast: NormalizedAst<OtherInfo & ParentInformation>, initialScope?: DataflowScopeName): DataflowInformation;
 export declare function processBinaryOp<OtherInfo>(node: RBinaryOp<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/graph/diff.d.ts

@@ -1,6 +1,6 @@
-import { NodeId } from '../../r-bridge';
-import { DataflowGraph, FunctionArgument, OutgoingEdges } from './graph';
-import { GenericDifferenceInformation, DifferenceReport } from '../../util/diff';
+import type { NodeId } from '../../r-bridge';
+import type { DataflowGraph, FunctionArgument, OutgoingEdges } from './graph';
+import type { GenericDifferenceInformation, DifferenceReport } from '../../util/diff';
 export interface NamedGraph {
     name: string;
     graph: DataflowGraph;

package/dataflow/graph/graph.d.ts

@@ -1,10 +1,11 @@
-import { NodeId, NoInfo, RNodeWithParent } from '../../r-bridge';
-import { IdentifierDefinition, IdentifierReference } from '../environments';
-import { BiMap } from '../../util/bimap';
-import { DataflowGraphEdge, DataflowGraphEdgeAttribute, EdgeType } from './edge';
-import { DataflowInformation } from '../internal/info';
-import { DataflowGraphVertexArgument, DataflowGraphVertexInfo } from './vertex';
-import { DifferenceReport } from '../../util/diff';
+import type { NodeId, NoInfo, RNodeWithParent } from '../../r-bridge';
+import type { IdentifierDefinition, IdentifierReference } from '../environments';
+import type { BiMap } from '../../util/bimap';
+import type { DataflowGraphEdge, DataflowGraphEdgeAttribute } from './edge';
+import { EdgeType } from './edge';
+import type { DataflowInformation } from '../internal/info';
+import type { DataflowGraphVertexArgument, DataflowGraphVertexInfo } from './vertex';
+import type { DifferenceReport } from '../../util/diff';
 /** Used to get an entry point for every id, after that it allows reference-chasing of the graph */
 export type DataflowMap<OtherInfo = NoInfo> = BiMap<NodeId, RNodeWithParent<OtherInfo>>;
 export type DataflowFunctionFlowInformation = Omit<DataflowInformation, 'graph'> & {

package/dataflow/graph/quads.d.ts

@@ -1,5 +1,5 @@
-import { QuadSerializationConfiguration } from '../../util/quads';
-import { DataflowGraph } from './graph';
+import type { QuadSerializationConfiguration } from '../../util/quads';
+import type { DataflowGraph } from './graph';
 /**
  * @see cfg2quads
  * @see serialize2quads

package/dataflow/graph/vertex.d.ts

@@ -1,8 +1,8 @@
-import { MergeableRecord } from '../../util/objects';
-import { NodeId } from '../../r-bridge';
-import { DataflowScopeName, REnvironmentInformation } from '../environments';
-import { DataflowGraphEdgeAttribute } from './edge';
-import { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
+import type { MergeableRecord } from '../../util/objects';
+import type { NodeId } from '../../r-bridge';
+import type { DataflowScopeName, REnvironmentInformation } from '../environments';
+import type { DataflowGraphEdgeAttribute } from './edge';
+import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
 export type DataflowGraphVertices = Map<NodeId, DataflowGraphVertexInfo>;
 /**
  * Arguments required to construct a vertex in the dataflow graph.

package/dataflow/internal/info.d.ts

@@ -1,6 +1,6 @@
 import { DataflowGraph } from '../graph';
-import { REnvironmentInformation, IdentifierReference, DataflowScopeName } from '../environments';
-import { DataflowProcessorInformation } from '../processor';
+import type { REnvironmentInformation, IdentifierReference, DataflowScopeName } from '../environments';
+import type { DataflowProcessorInformation } from '../processor';
 /**
  * Continuously updated during the dataflow analysis to hold the current state.
  */

package/dataflow/internal/linker.d.ts

@@ -1,7 +1,7 @@
-import { DataflowGraph, DataflowGraphVertexInfo, FunctionArgument } from '../graph';
-import { DataflowScopeName, IdentifierReference, REnvironmentInformation } from '../environments';
+import type { DataflowGraph, DataflowGraphVertexInfo, FunctionArgument } from '../graph';
+import type { DataflowScopeName, IdentifierReference, REnvironmentInformation } from '../environments';
 import { DefaultMap } from '../../util/defaultmap';
-import { DecoratedAstMap, NodeId, ParentInformation, RParameter } from '../../r-bridge';
+import type { DecoratedAstMap, NodeId, ParentInformation, RParameter } from '../../r-bridge';
 export declare function linkIngoingVariablesInSameScope(graph: DataflowGraph, references: IdentifierReference[]): void;
 export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
 export declare function produceNameSharedIdMap(references: IdentifierReference[]): NameIdMap;

package/dataflow/internal/process/access.d.ts

@@ -1,4 +1,4 @@
-import { ParentInformation, RAccess } from '../../../r-bridge';
-import { DataflowInformation } from '../info';
-import { DataflowProcessorInformation } from '../../processor';
+import type { ParentInformation, RAccess } from '../../../r-bridge';
+import type { DataflowInformation } from '../info';
+import type { DataflowProcessorInformation } from '../../processor';
 export declare function processAccess<OtherInfo>(node: RAccess<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/expression-list.d.ts

@@ -2,7 +2,7 @@
  * Processes a list of expressions joining their dataflow graphs accordingly.
  * @module
  */
-import { DataflowInformation } from '../info';
-import { ParentInformation, RExpressionList } from '../../../r-bridge';
-import { DataflowProcessorInformation } from '../../processor';
+import type { DataflowInformation } from '../info';
+import type { ParentInformation, RExpressionList } from '../../../r-bridge';
+import type { DataflowProcessorInformation } from '../../processor';
 export declare function processExpressionList<OtherInfo>(exprList: RExpressionList<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;