@eagleoutice/flowr 2.6.3 → 2.7.2

package/util/mermaid/ast.js

@@ -7,6 +7,7 @@ const visitor_1 = require("../../r-bridge/lang-4.x/ast/model/processing/visitor"
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const flowr_file_1 = require("../../project/context/flowr-file");
+const info_1 = require("./info");
 function identifyMermaidDirection(prefix) {
     const directionMatch = prefix.match(/flowchart (TD|LR|RL|BT)/);
     if (directionMatch) {
@@ -17,14 +18,20 @@ function identifyMermaidDirection(prefix) {
 /**
  * Serialize the normalized AST to mermaid format
  */
-function normalizedAstToMermaid(ast, prefix = 'flowchart TD\n') {
+function normalizedAstToMermaid(ast, { prefix = 'flowchart TD\n', markStyle = info_1.MermaidDefaultMarkStyle, includeOnlyIds, mark } = {}) {
     let output = prefix;
     function showNode(n) {
+        if (includeOnlyIds && !includeOnlyIds.has(n.info.id)) {
+            return;
+        }
         const name = `${n.type} (${n.info.id})\\n${n.lexeme ?? ' '}`;
         output += `    n${n.info.id}(["${(0, mermaid_1.escapeMarkdown)(name)}"])\n`;
-        if (n.info.parent !== undefined) {
+        if (mark?.has(n.info.id)) {
+            output += `    style n${n.info.id} ${markStyle.vertex}\n`;
+        }
+        if (n.info.parent !== undefined && (!includeOnlyIds || includeOnlyIds.has(n.info.parent))) {
             const context = n.info;
-            const roleSuffix = context.role === "expr-list-child" /* RoleInParent.ExpressionListChild */ || context.role === "call-argument" /* RoleInParent.FunctionCallArgument */ || context.role === "function-def-param" /* RoleInParent.FunctionDefinitionParameter */ ? `-${context.index}` : '';
+            const roleSuffix = context.role === "expr-list-child" /* RoleInParent.ExpressionListChild */ || context.role === "call-arg" /* RoleInParent.FunctionCallArgument */ || context.role === "param" /* RoleInParent.FunctionDefinitionParameter */ ? `-${context.index}` : '';
             output += `    n${n.info.parent} -->|"${context.role}${roleSuffix}"| n${n.info.id}\n`;
         }
         if (n.type === type_1.RType.ExpressionList && n.grouping !== undefined) {
@@ -49,9 +56,8 @@ function normalizedAstToMermaid(ast, prefix = 'flowchart TD\n') {
         for (const f of ast.files) {
             // add a subgraph for each file
             if (ast.files.length !== 1 || (f.filePath && f.filePath !== flowr_file_1.FlowrFile.INLINE_PATH)) {
-                output += `    subgraph "File: ${(0, mermaid_1.escapeMarkdown)(f.filePath ?? flowr_file_1.FlowrFile.INLINE_PATH)}"\n`;
                 const direction = identifyMermaidDirection(prefix);
-                output += `        direction ${direction}\n`;
+                output += `    subgraph "File: ${(0, mermaid_1.escapeMarkdown)(f.filePath ?? flowr_file_1.FlowrFile.INLINE_PATH)}" direction ${direction}\n`;
                 showAst(f.root);
                 output += '    end\n';
             }
@@ -68,7 +74,7 @@ function normalizedAstToMermaid(ast, prefix = 'flowchart TD\n') {
 /**
  * Use mermaid to visualize the normalized AST.
  */
-function normalizedAstToMermaidUrl(ast, prefix = 'flowchart TD\n') {
-    return (0, mermaid_1.mermaidCodeToUrl)(normalizedAstToMermaid(ast, prefix));
+function normalizedAstToMermaidUrl(ast, info) {
+    return (0, mermaid_1.mermaidCodeToUrl)(normalizedAstToMermaid(ast, info ?? {}));
 }
 //# sourceMappingURL=ast.js.map

package/util/mermaid/cfg.d.ts

@@ -1,5 +1,6 @@
 import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { type ControlFlowInformation } from '../../control-flow/control-flow-graph';
+import { type MermaidGraphPrinterInfo } from './info';
 /**
  * Convert the control flow graph to a mermaid string.
  * @param cfg              - The control flow graph to convert.
@@ -7,8 +8,8 @@ import { type ControlFlowInformation } from '../../control-flow/control-flow-gra
  * @param prefix           - The prefix to use for the mermaid string.
  * @param simplify         - Whether to simplify the control flow graph (especially in the context of basic blocks).
  */
-export declare function cfgToMermaid(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, prefix?: string, simplify?: boolean): string;
+export declare function cfgToMermaid(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, { prefix, simplify, markStyle, includeOnlyIds, mark }?: MermaidGraphPrinterInfo): string;
 /**
  * Use mermaid to visualize the normalized AST.
  */
-export declare function cfgToMermaidUrl(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, prefix?: string): string;
+export declare function cfgToMermaidUrl(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, info?: MermaidGraphPrinterInfo): string;

package/util/mermaid/cfg.js

@@ -7,6 +7,7 @@ const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const control_flow_graph_1 = require("../../control-flow/control-flow-graph");
 const reconstruct_1 = require("../../reconstruct/reconstruct");
 const auto_select_defaults_1 = require("../../reconstruct/auto-select/auto-select-defaults");
+const info_1 = require("./info");
 function getLexeme(n) {
     return n ? n.info.fullLexeme ?? n.lexeme ?? '' : undefined;
 }
@@ -30,7 +31,7 @@ const getDirRegex = /flowchart\s+([A-Za-z]+)/;
  * @param prefix           - The prefix to use for the mermaid string.
  * @param simplify         - Whether to simplify the control flow graph (especially in the context of basic blocks).
  */
-function cfgToMermaid(cfg, normalizedAst, prefix = 'flowchart BT\n', simplify = false) {
+function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify = false, markStyle = info_1.MermaidDefaultMarkStyle, includeOnlyIds, mark } = {}) {
     let output = prefix;
     const dirIs = getDirRegex.exec(prefix)?.at(1) ?? 'LR';
     for (const [id, vertex] of cfg.graph.vertices(false)) {
@@ -52,6 +53,10 @@ function cfgToMermaid(cfg, normalizedAst, prefix = 'flowchart BT\n', simplify =
                 output += `        direction ${dirIs}\n`;
                 let last = undefined;
                 for (const element of vertex.elems ?? []) {
+                    if (includeOnlyIds && !includeOnlyIds.has(element.id)) {
+                        last = undefined;
+                        continue;
+                    }
                     const childNormalizedVertex = normalizedAst?.idMap.get(element.id);
                     const childContent = getLexeme(childNormalizedVertex);
                     output = cfgOfNode(vertex, childNormalizedVertex, element.id, childContent, output);
@@ -64,7 +69,7 @@ function cfgToMermaid(cfg, normalizedAst, prefix = 'flowchart BT\n', simplify =
                 output += '    end\n';
             }
         }
-        else {
+        else if (!includeOnlyIds || includeOnlyIds.has(id)) {
             output = cfgOfNode(vertex, normalizedVertex, id, content, output);
         }
         if (vertex.name === type_1.RType.ExpressionList && vertex.type === control_flow_graph_1.CfgVertexType.EndMarker) {
@@ -72,24 +77,39 @@ function cfgToMermaid(cfg, normalizedAst, prefix = 'flowchart BT\n', simplify =
         }
     }
     for (const [from, targets] of cfg.graph.edges()) {
+        if (includeOnlyIds && !includeOnlyIds.has(from)) {
+            continue;
+        }
         for (const [to, edge] of targets) {
+            if (includeOnlyIds && !includeOnlyIds.has(to)) {
+                continue;
+            }
             const edgeType = edge.label === 1 /* CfgEdgeType.Cd */ ? '-->' : '-.->';
             const edgeSuffix = edge.label === 1 /* CfgEdgeType.Cd */ ? ` (${edge.when})` : '';
             output += `    n${from} ${edgeType}|"${(0, mermaid_1.escapeMarkdown)((0, control_flow_graph_1.edgeTypeToString)(edge.label))}${edgeSuffix}"| n${to}\n`;
         }
     }
     for (const entryPoint of cfg.entryPoints) {
-        output += `    style n${entryPoint} stroke:cyan,stroke-width:6.5px;`;
+        if (!includeOnlyIds || includeOnlyIds.has(entryPoint)) {
+            output += `    style n${entryPoint} stroke:cyan,stroke-width:6.5px;`;
+        }
     }
     for (const exitPoint of cfg.exitPoints) {
-        output += `    style n${exitPoint} stroke:green,stroke-width:6.5px;`;
+        if (!includeOnlyIds || includeOnlyIds.has(exitPoint)) {
+            output += `    style n${exitPoint} stroke:green,stroke-width:6.5px;`;
+        }
+    }
+    if (mark) {
+        for (const id of mark.values()) {
+            output += `    style n${id} ${markStyle.vertex}`;
+        }
     }
     return output;
 }
 /**
  * Use mermaid to visualize the normalized AST.
  */
-function cfgToMermaidUrl(cfg, normalizedAst, prefix = 'flowchart BT\n') {
-    return (0, mermaid_1.mermaidCodeToUrl)(cfgToMermaid(cfg, normalizedAst, prefix));
+function cfgToMermaidUrl(cfg, normalizedAst, info) {
+    return (0, mermaid_1.mermaidCodeToUrl)(cfgToMermaid(cfg, normalizedAst, info ?? {}));
 }
 //# sourceMappingURL=cfg.js.map

package/util/mermaid/dfg.d.ts

@@ -2,13 +2,7 @@ import type { SourceRange } from '../range';
 import { type DataflowGraph } from '../../dataflow/graph/graph';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { type IdentifierDefinition } from '../../dataflow/environments/identifier';
-type MarkVertex = NodeId;
-type MarkEdge = `${string}->${string}`;
-export type MermaidMarkdownMark = MarkVertex | MarkEdge;
-export interface MermaidMarkStyle {
-    readonly vertex: string;
-    readonly edge: string;
-}
+import { type MermaidMarkdownMark, type MermaidMarkStyle } from './info';
 interface MermaidGraph {
     nodeLines: string[];
     edgeLines: string[];
@@ -40,6 +34,7 @@ interface MermaidGraphConfiguration {
     rootGraph?: DataflowGraph;
     presentEdges?: Set<string>;
     simplified?: boolean;
+    includeOnlyIds?: ReadonlySet<NodeId>;
 }
 /**
  * Converts a dataflow graph to mermaid graph code that visualizes the graph.

package/util/mermaid/dfg.js

@@ -15,6 +15,7 @@ const edge_1 = require("../../dataflow/graph/edge");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const built_in_1 = require("../../dataflow/environments/built-in");
+const info_1 = require("./info");
 /**
  * Prints a {@link SourceRange|range} as a human-readable string.
  */
@@ -108,7 +109,7 @@ function encodeEdge(from, to, types) {
 function mermaidNodeBrackets(tag) {
     let open;
     let close;
-    if (tag === 'function-definition' || tag === 'variable-definition') {
+    if (tag === vertex_1.VertexType.FunctionDefinition || tag === vertex_1.VertexType.VariableDefinition) {
         open = '[';
         close = ']';
     }
@@ -147,7 +148,7 @@ function printEnvironmentToLines(env) {
     }
     return lines;
 }
-function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
+function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
     const fCall = info.tag === vertex_1.VertexType.FunctionCall;
     const { open, close } = mermaidNodeBrackets(info.tag);
     id = (0, mermaid_1.escapeId)(id);
@@ -184,6 +185,9 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
     const artificialCdEdges = (info.cds ?? []).map(x => [x.id, { types: new Set([x.when ? 'CD-True' : 'CD-False']) }]);
     // eslint-disable-next-line prefer-const
     for (let [target, edge] of [...edges[1], ...artificialCdEdges]) {
+        if (includeOnlyIds && !includeOnlyIds.has(target)) {
+            continue;
+        }
         const originalTarget = target;
         target = (0, mermaid_1.escapeId)(target);
         const edgeTypes = typeof edge.types == 'number' ? new Set((0, edge_1.splitEdgeTypes)(edge.types)) : edge.types;
@@ -209,16 +213,16 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark) {
             }
         }
     }
-    if (info.tag === 'function-definition') {
+    if (info.tag === vertex_1.VertexType.FunctionDefinition) {
         subflowToMermaid(id, info.exitPoints, info.subflow, mermaid, idPrefix);
     }
 }
 // make the passing of root ids more performant again
-function graphToMermaidGraph(rootIds, { simplified, graph, prefix = 'flowchart BT', idPrefix = '', includeEnvironments = !simplified, mark, rootGraph, presentEdges = new Set(), markStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' } }) {
+function graphToMermaidGraph(rootIds, { simplified, graph, prefix = 'flowchart BT', idPrefix = '', includeEnvironments = !simplified, mark, rootGraph, presentEdges = new Set(), markStyle = info_1.MermaidDefaultMarkStyle, includeOnlyIds }) {
     const mermaid = { nodeLines: prefix === null ? [] : [prefix], edgeLines: [], presentEdges, presentVertices: new Set(), mark, rootGraph: rootGraph ?? graph, includeEnvironments, markStyle, simplified };
     for (const [id, info] of graph.vertices(true)) {
         if (rootIds.has(id)) {
-            vertexToMermaid(info, mermaid, id, idPrefix, mark);
+            vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds);
         }
     }
     return mermaid;
@@ -227,7 +231,7 @@ function graphToMermaidGraph(rootIds, { simplified, graph, prefix = 'flowchart B
  * Converts a dataflow graph to mermaid graph code that visualizes the graph.
  */
 function graphToMermaid(config) {
-    const mermaid = graphToMermaidGraph(config.graph.rootIds(), config);
+    const mermaid = graphToMermaidGraph(config.includeOnlyIds ? config.includeOnlyIds : config.graph.rootIds(), config);
     return { string: `${mermaid.nodeLines.join('\n')}\n${mermaid.edgeLines.join('\n')}`, mermaid };
 }
 /**

package/util/mermaid/info.d.ts

@@ -0,0 +1,17 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+type MarkVertex = NodeId;
+type MarkEdge = `${string}->${string}`;
+export type MermaidMarkdownMark = MarkVertex | MarkEdge;
+export interface MermaidMarkStyle {
+    readonly vertex: string;
+    readonly edge: string;
+}
+export interface MermaidGraphPrinterInfo {
+    includeOnlyIds?: ReadonlySet<NodeId>;
+    mark?: ReadonlySet<MermaidMarkdownMark>;
+    markStyle?: MermaidMarkStyle;
+    prefix?: string;
+    simplify?: boolean;
+}
+export declare const MermaidDefaultMarkStyle: MermaidMarkStyle;
+export {};

package/util/mermaid/info.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MermaidDefaultMarkStyle = void 0;
+exports.MermaidDefaultMarkStyle = { vertex: 'stroke:teal,stroke-width:7px,stroke-opacity:.8;', edge: 'stroke:teal,stroke-width:4.2px,stroke-opacity:.8' };
+//# sourceMappingURL=info.js.map

package/util/prefix.d.ts

@@ -1,12 +1,16 @@
 /**
- * given a potentially partial prefix like `hell`, this finds the matching name in the map, but only
+ * Given a potentially partial prefix like `hell`, this finds the matching name in the keys, but only
  * if it is unique!
+ * Please note, that `...` is considered special here, anything *afteR* `...` will not be matched by prefix but only by exact name,
+ * following R's pmatch semantics.
  * @example
  * ```typescript
- * findByPrefixIfUnique('hell', { 'hello', 'bar' }) // => 'hello'
- * findByPrefixIfUnique('hell', { 'hello', 'hell' }) // => 'hell' (full match)
- * findByPrefixIfUnique('h', { 'hello', 'hell' }) // => undefined (not unique)
- * findByPrefixIfUnique('', { 'hello', 'hell' }) // => undefined (empty prefix)
+ * findByPrefixIfUnique('hello', [ 'hello', 'bar' ]) // => 'hello'
+ * findByPrefixIfUnique('hell', [ 'hello', 'bar' ]) // => 'hello'
+ * findByPrefixIfUnique('hell', [ 'hello', 'hell' ]) // => 'hell' (full/exact match)
+ * findByPrefixIfUnique('hell', [ 'bar', '...', 'hello' ]) // => undefined (not matched due to being after `...`)
+ * findByPrefixIfUnique('h', [ 'hello', 'hell' ]) // => undefined (not unique)
+ * findByPrefixIfUnique('', [ 'hello', 'hell' ]) // => undefined (empty prefix)
  * ```
  */
 export declare function findByPrefixIfUnique(prefix: string, keys: readonly string[] | MapIterator<string>): string | undefined;

package/util/prefix.js

@@ -2,14 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findByPrefixIfUnique = findByPrefixIfUnique;
 /**
- * given a potentially partial prefix like `hell`, this finds the matching name in the map, but only
+ * Given a potentially partial prefix like `hell`, this finds the matching name in the keys, but only
  * if it is unique!
+ * Please note, that `...` is considered special here, anything *afteR* `...` will not be matched by prefix but only by exact name,
+ * following R's pmatch semantics.
  * @example
  * ```typescript
- * findByPrefixIfUnique('hell', { 'hello', 'bar' }) // => 'hello'
- * findByPrefixIfUnique('hell', { 'hello', 'hell' }) // => 'hell' (full match)
- * findByPrefixIfUnique('h', { 'hello', 'hell' }) // => undefined (not unique)
- * findByPrefixIfUnique('', { 'hello', 'hell' }) // => undefined (empty prefix)
+ * findByPrefixIfUnique('hello', [ 'hello', 'bar' ]) // => 'hello'
+ * findByPrefixIfUnique('hell', [ 'hello', 'bar' ]) // => 'hello'
+ * findByPrefixIfUnique('hell', [ 'hello', 'hell' ]) // => 'hell' (full/exact match)
+ * findByPrefixIfUnique('hell', [ 'bar', '...', 'hello' ]) // => undefined (not matched due to being after `...`)
+ * findByPrefixIfUnique('h', [ 'hello', 'hell' ]) // => undefined (not unique)
+ * findByPrefixIfUnique('', [ 'hello', 'hell' ]) // => undefined (empty prefix)
  * ```
  */
 function findByPrefixIfUnique(prefix, keys) {
@@ -17,11 +21,15 @@ function findByPrefixIfUnique(prefix, keys) {
         return undefined;
     }
     let found = undefined;
+    let matchPartial = true;
     for (const key of keys) {
         if (key === prefix) {
             return key;
         }
-        if (key.startsWith(prefix)) {
+        if (key === '...') {
+            matchPartial = false;
+        }
+        else if (matchPartial && key.startsWith(prefix)) {
             if (found) {
                 return undefined;
             }

package/util/r-regex.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Represents R's `.standard_regexps` definitions.
+ * @see https://github.com/r-devel/r-svn/blob/44474af03ae77fd3b9a340279fa10cb698d106c3/src/library/base/R/utils.R#L52-L53
+ */
+export declare const RStandardRegexp: {
+    /** `[[:alpha:]][[:alnum:].]*[[:alnum:]]` */
+    ValidPackageName: RegExp;
+    /** `([[:digit:]]+[.-]){1,}[[:digit:]]+` */
+    ValidPackageVersion: RegExp;
+    /** `[[:digit:]]+\\.[[:digit:]]+\\.[[:digit:]]+` */
+    ValidRSystemVersion: RegExp;
+    /** `([[:digit:]]+[.-])*[[:digit:]]+` */
+    ValidNumericVersion: RegExp;
+};
+/**
+ * Based on the C-definition:
+ * ```txt
+ * !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+ * ```
+ */
+export declare const RPunctuationChars = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";

package/util/r-regex.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPunctuationChars = exports.RStandardRegexp = void 0;
+/**
+ * Represents R's `.standard_regexps` definitions.
+ * @see https://github.com/r-devel/r-svn/blob/44474af03ae77fd3b9a340279fa10cb698d106c3/src/library/base/R/utils.R#L52-L53
+ */
+exports.RStandardRegexp = {
+    /** `[[:alpha:]][[:alnum:].]*[[:alnum:]]` */
+    ValidPackageName: (/[A-Za-z][A-Za-z0-9._]*[A-Za-z0-9]/),
+    /** `([[:digit:]]+[.-]){1,}[[:digit:]]+` */
+    ValidPackageVersion: (/([0-9]+[.-])+[0-9]+/),
+    /** `[[:digit:]]+\\.[[:digit:]]+\\.[[:digit:]]+` */
+    ValidRSystemVersion: (/[0-9]+\.[0-9]+\.[0-9]+/),
+    /** `([[:digit:]]+[.-])*[[:digit:]]+` */
+    ValidNumericVersion: /([0-9]+[.-])*[0-9]+/
+};
+/**
+ * Based on the C-definition:
+ * ```txt
+ * !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+ * ```
+ */
+exports.RPunctuationChars = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~';
+//# sourceMappingURL=r-regex.js.map

package/util/simple-df/dfg-view.d.ts

@@ -2,6 +2,7 @@ import { DataflowGraph } from '../../dataflow/graph/graph';
 import { VertexType } from '../../dataflow/graph/vertex';
 import { type MergeableRecord } from '../objects';
 import type { DeepPartial } from 'ts-essentials';
+import type { REnvironmentInformation } from '../../dataflow/environments/environment';
 export interface ReduceVertexOptions extends MergeableRecord {
     tags: VertexType[];
     nameRegex: string;
@@ -16,4 +17,4 @@ export interface ReduceOptions extends MergeableRecord {
 /**
  * Produces a reduced version of the given dataflow graph according to the given options.
  */
-export declare function reduceDfg(dfg: DataflowGraph, options: DeepPartial<ReduceOptions>): DataflowGraph;
+export declare function reduceDfg(dfg: DataflowGraph, options: DeepPartial<ReduceOptions>, cleanEnv: REnvironmentInformation): DataflowGraph;

package/util/simple-df/dfg-view.js

@@ -36,7 +36,7 @@ function makeFilter(options, idMap) {
 /**
  * Produces a reduced version of the given dataflow graph according to the given options.
  */
-function reduceDfg(dfg, options) {
+function reduceDfg(dfg, options, cleanEnv) {
     const newDfg = new graph_1.DataflowGraph(dfg.idMap);
     const applyOptions = (0, objects_1.deepMergeObject)(defaultReduceOptions, options);
     // overwrite the tag set if possible
@@ -48,7 +48,7 @@ function reduceDfg(dfg, options) {
     for (const [id, info] of dfg.vertices(!applyOptions)) {
         const result = applyFilter(info);
         if (result) {
-            newDfg.addVertex(result, dfg.isRoot(id));
+            newDfg.addVertex(result, cleanEnv, dfg.isRoot(id));
         }
     }
     for (const [from, out] of dfg.edges()) {

package/util/text/args.js

@@ -55,10 +55,19 @@ function splitAtEscapeSensitive(inputString, escapeQuote = true, split = ' ') {
             current = '';
         }
         else if (c === '"' || c === "'") {
-            inQuotes = !inQuotes;
-            if (!escapeQuote) {
-                current += c;
+            if (!inQuotes) {
+                inQuotes = c;
+                if (escapeQuote) {
+                    continue;
+                }
             }
+            else if (inQuotes === c) {
+                inQuotes = false;
+                if (escapeQuote) {
+                    continue;
+                }
+            }
+            current += c;
         }
         else if (c === '\\' && escapeQuote) {
             escaped = true;

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.6.3';
+const version = '2.7.2';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */

package/abstract-interpretation/data-frame/absint-info.d.ts

@@ -1,109 +0,0 @@
-import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
-import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { DataFrameStateDomain } from './dataframe-domain';
-import type { ConstraintType, DataFrameOperationArgs, DataFrameOperationName, DataFrameOperationOptions } from './semantics';
-/**
- * An abstract data frame operation without additional options.
- * - `operation` contains the type of the abstract operation (see {@link DataFrameOperationName})
- * - `operand` contains the ID of the data frame operand of the operation (may be `undefined`)
- * - `...args` contains the arguments of the abstract operation (see {@link DataFrameOperationArgs})
- */
-export type DataFrameOperationType<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
-    [Name in OperationName]: {
-        operation: Name;
-        operand: NodeId | undefined;
-    } & DataFrameOperationArgs<Name>;
-}[OperationName];
-/**
- * An abstract data frame operation.
- * - `operation` contains the type of the abstract operation (see {@link DataFrameOperationName})
- * - `operand` contains the ID of the data frame operand of the operation (may be `undefined`)
- * - `type` optionally contains the constraint type to overwrite the default type of the operation (see {@link ConstraintType})
- * - `options` optionally contains additional options for the abstract operation (see {@link DataFrameOperationOptions})
- * - `...args` contains the arguments of the abstract operation (see {@link DataFrameOperationArgs})
- */
-export type DataFrameOperation<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
-    [Name in OperationName]: {
-        operation: Name;
-        operand: NodeId | undefined;
-        type?: ConstraintType;
-        options?: DataFrameOperationOptions<Name>;
-    } & DataFrameOperationArgs<Name>;
-}[OperationName];
-/**
- * Represents the base data frame information stored in the abstract interpretation info of an AST node.
- * - `type` optionally defines the type of the extra information stored in the data frame info
- * - `domain` contains the abstract data frame shape state of the node
- *   This may not be present if the data frame shape inference has not been executed yet or the program contains no data frames
- */
-interface DataFrameInfoBase {
-    type?: string;
-    domain?: DataFrameStateDomain;
-}
-/** Enum to mark nodes during the data frame shape inference */
-export declare enum DataFrameInfoMarker {
-    /** Marks the target symbol of assignments as "unassigned" until the assigned expression is evaluated */
-    Unassigned = "unassigned"
-}
-/**
- * Represents the data frame information for a node without extra data frame information,
- * i.e. for all nodes that do not represent a data frame assignment or data frame operation (this is the default).
- *
- * The `marker` can be used to mark nodes during the data frame shape inference.
- */
-interface DataFrameEmptyInfo extends DataFrameInfoBase {
-    type?: never;
-    marker?: DataFrameInfoMarker;
-}
-/**
- * Represents the data frame information for a data frame assignment with a target identifier (symbol/string) and an assigned expression.
- * This is used during data frame shape inference to mark assignments of data frame expressions to an identifier.
- *
- * Use {@link hasDataFrameAssignmentInfo} to check whether an AST node has attached data frame assignment information.
- */
-export interface DataFrameAssignmentInfo extends DataFrameInfoBase {
-    type: 'assignment';
-    identifier: NodeId;
-    expression: NodeId;
-}
-/**
- * Represents the data frame information for a data frame function/operation with mapped abstract operations.
- * This is used during data frame shape inference to store the abstract operations a data frame function/operation is mapped to.
- *
- * The order of the abstract operations is the order in which their semantics are applied (for example, access operations are typically before other operations in the list).
- * Moreover, abstract operations that take the result of previous abstract operation as data frame operand must have the `operand` set to `undefined`.
- *
- * Use {@link hasDataFrameExpressionInfo} to check whether an AST node has attached data frame expression information.
- */
-export interface DataFrameExpressionInfo extends DataFrameInfoBase {
-    type: 'expression';
-    operations: DataFrameOperation[];
-}
-/**
- * Represents the data frame shape inference information stored in the abstract interpretation info of AST nodes.
- */
-export type DataFrameInfo = DataFrameEmptyInfo | DataFrameAssignmentInfo | DataFrameExpressionInfo;
-/**
- * Represents the abstract interpretation information attached to AST nodes.
- */
-export interface AbstractInterpretationInfo {
-    dataFrame?: DataFrameInfo;
-}
-/**
- * Checks whether an AST node has attached data frame assignment information.
- */
-export declare function hasDataFrameAssignmentInfo<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>): node is RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo & {
-    dataFrame: DataFrameAssignmentInfo;
-}>;
-/**
- * Checks whether an AST node has attached data frame expression information.
- */
-export declare function hasDataFrameExpressionInfo<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>): node is RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo & {
-    dataFrame: DataFrameExpressionInfo;
-}>;
-/**
- * Checks whether an AST node has an attached data frame info marker.
- */
-export declare function hasDataFrameInfoMarker<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>, marker: DataFrameInfoMarker): boolean;
-export {};

package/abstract-interpretation/data-frame/absint-info.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFrameInfoMarker = void 0;
-exports.hasDataFrameAssignmentInfo = hasDataFrameAssignmentInfo;
-exports.hasDataFrameExpressionInfo = hasDataFrameExpressionInfo;
-exports.hasDataFrameInfoMarker = hasDataFrameInfoMarker;
-/** Enum to mark nodes during the data frame shape inference */
-var DataFrameInfoMarker;
-(function (DataFrameInfoMarker) {
-    /** Marks the target symbol of assignments as "unassigned" until the assigned expression is evaluated */
-    DataFrameInfoMarker["Unassigned"] = "unassigned";
-})(DataFrameInfoMarker || (exports.DataFrameInfoMarker = DataFrameInfoMarker = {}));
-/**
- * Checks whether an AST node has attached data frame assignment information.
- */
-function hasDataFrameAssignmentInfo(node) {
-    return node.info.dataFrame?.type === 'assignment';
-}
-/**
- * Checks whether an AST node has attached data frame expression information.
- */
-function hasDataFrameExpressionInfo(node) {
-    return node.info.dataFrame?.type === 'expression';
-}
-/**
- * Checks whether an AST node has an attached data frame info marker.
- */
-function hasDataFrameInfoMarker(node, marker) {
-    return node.info.dataFrame?.type === undefined && node.info.dataFrame?.marker === marker;
-}
-//# sourceMappingURL=absint-info.js.map