@eagleoutice/flowr 2.2.16 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.2.16",
+  "version": "2.3.0",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -176,7 +176,7 @@
   "devDependencies": {
     "@commitlint/cli": "^19.7.1",
     "@commitlint/config-angular": "^19.7.1",
-    "@eagleoutice/eslint-config-flowr": "^1.0.17",
+    "@eagleoutice/eslint-config-flowr": "^1.0.19",
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.20.0",
     "@j-ulrich/release-it-regex-bumper": "^5.3.0",

package/queries/catalog/df-shape-query/df-shape-query-executor.d.ts

@@ -0,0 +1,3 @@
+import type { DfShapeQuery, DfShapeQueryResult } from './df-shape-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+export declare function executeDfShapeQuery({ dataflow: { graph }, ast, config }: BasicQueryData, queries: readonly DfShapeQuery[]): DfShapeQueryResult;

package/queries/catalog/df-shape-query/df-shape-query-executor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDfShapeQuery = executeDfShapeQuery;
+const log_1 = require("../../../util/log");
+const extract_cfg_1 = require("../../../control-flow/extract-cfg");
+const shape_inference_1 = require("../../../abstract-interpretation/data-frame/shape-inference");
+const parse_1 = require("../../../slicing/criterion/parse");
+function executeDfShapeQuery({ dataflow: { graph }, ast, config }, queries) {
+    if (queries.length !== 1 && queries.some(query => query.criterion === undefined)) {
+        log_1.log.warn('The dataframe shape query expects only up to one query without slicing criterion, but got', queries.length);
+        queries = [{ type: 'df-shape' }];
+    }
+    const start = Date.now();
+    const cfg = (0, extract_cfg_1.extractCfg)(ast, config, graph);
+    const domains = (0, shape_inference_1.inferDataFrameShapes)(cfg, graph, ast, config);
+    if (queries.length === 1 && queries[0].criterion === undefined) {
+        return {
+            '.meta': {
+                timing: Date.now() - start
+            },
+            domains: domains
+        };
+    }
+    const result = new Map();
+    for (const query of queries) {
+        if (query.criterion === undefined) {
+            log_1.log.warn('Missing criterion in dataframe shape query');
+            continue;
+        }
+        else if (result.has(query.criterion)) {
+            log_1.log.warn('Duplicate criterion in dataframe shape query:', query.criterion);
+            continue;
+        }
+        const nodeId = (0, parse_1.slicingCriterionToId)(query.criterion, ast.idMap);
+        const node = ast.idMap.get(nodeId);
+        const value = (0, shape_inference_1.resolveIdToDataFrameShape)(node?.info.id, graph);
+        result.set(query.criterion, value);
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        domains: result
+    };
+}
+//# sourceMappingURL=df-shape-query-executor.js.map

package/queries/catalog/df-shape-query/df-shape-query-format.d.ts

@@ -0,0 +1,72 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import type { DataFrameDomain, DataFrameStateDomain } from '../../../abstract-interpretation/data-frame/domain';
+import { executeDfShapeQuery } from './df-shape-query-executor';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+/** Infer the shape of data frames using abstract interpretation. */
+export interface DfShapeQuery extends BaseQueryFormat {
+    readonly type: 'df-shape';
+    readonly criterion?: SingleSlicingCriterion;
+}
+export interface DfShapeQueryResult extends BaseQueryResult {
+    domains: DataFrameStateDomain | Map<SingleSlicingCriterion, DataFrameDomain | undefined>;
+}
+export declare const DfShapeQueryDefinition: {
+    readonly executor: typeof executeDfShapeQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
+        readonly name: "parse";
+        readonly humanReadableName: "parse with R shell";
+        readonly description: "Parse the given R code into an AST";
+        readonly processor: (_results: unknown, input: Partial<import("../../../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../../../r-bridge/parser").ParseStepOutput<string>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: {
+                (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+            };
+            readonly 5: ({ parsed }: import("../../../r-bridge/parser").ParseStepOutput<string>, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
+        };
+        readonly dependencies: readonly [];
+        readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+    } | {
+        readonly name: "normalize";
+        readonly humanReadableName: "normalize";
+        readonly description: "Normalize the AST to flowR's AST";
+        readonly processor: (results: {
+            parse?: import("../../../r-bridge/parser").ParseStepOutput<string>;
+        }, input: Partial<import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/normalize-printer").normalizedAstToJson;
+            readonly 5: typeof import("../../../core/print/normalize-printer").normalizedAstToQuads;
+            readonly 3: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaid;
+            readonly 4: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+        };
+        readonly dependencies: readonly ["parse"];
+        readonly requiredInput: import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+    } | {
+        readonly humanReadableName: "dataflow";
+        readonly processor: (results: {
+            normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        }, input: {
+            request?: import("../../../r-bridge/retriever").RParseRequests;
+            parser?: import("../../../r-bridge/parser").Parser<import("../../../r-bridge/parser").KnownParserType>;
+        }, config: import("../../../config").FlowrConfigOptions) => import("../../../dataflow/info").DataflowInformation;
+        readonly requiredInput: {};
+        readonly name: "dataflow";
+        readonly description: "Construct the dataflow graph";
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/dataflow-printer").dataflowGraphToJson;
+            readonly 5: typeof import("../../../core/print/dataflow-printer").dataflowGraphToQuads;
+            readonly 3: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaid;
+            readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+        };
+        readonly dependencies: readonly ["normalize"];
+    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
+};

package/queries/catalog/df-shape-query/df-shape-query-format.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfShapeQueryDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const time_1 = require("../../../util/text/time");
+const joi_1 = __importDefault(require("joi"));
+const df_shape_query_executor_1 = require("./df-shape-query-executor");
+const json_1 = require("../../../util/json");
+exports.DfShapeQueryDefinition = {
+    executor: df_shape_query_executor_1.executeDfShapeQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('df-shape', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(...out.domains.entries().take(20).map(([key, domain]) => {
+            return `   ╰ ${key}: ${JSON.stringify(domain, json_1.jsonReplacer)}`;
+        }));
+        if (out.domains.size > 20) {
+            result.push('   ╰ ... (see JSON)');
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('df-shape').required().description('The type of the query.'),
+        criterion: joi_1.default.string().optional().description('The slicing criterion of the node to get the dataframe shape for.')
+    }).description('The df-shape query retrieves information on the shape of dataframes'),
+    flattenInvolvedNodes: () => []
+};
+//# sourceMappingURL=df-shape-query-format.js.map

package/queries/query.d.ts

@@ -24,7 +24,8 @@ import type { OriginQuery } from './catalog/origin-query/origin-query-format';
 import type { LinterQuery } from './catalog/linter-query/linter-query-format';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ControlFlowQuery } from './catalog/control-flow-query/control-flow-query-format';
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
+import type { DfShapeQuery } from './catalog/df-shape-query/df-shape-query-format';
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -232,6 +233,65 @@ export declare const SupportedQueries: {
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
+    readonly 'df-shape': {
+        readonly executor: typeof import("./catalog/df-shape-query/df-shape-query-executor").executeDfShapeQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{
+            readonly name: "parse";
+            readonly humanReadableName: "parse with R shell";
+            readonly description: "Parse the given R code into an AST";
+            readonly processor: (_results: unknown, input: Partial<import("../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../r-bridge/parser").ParseStepOutput<string>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: {
+                    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+                };
+                readonly 5: ({ parsed }: import("../r-bridge/parser").ParseStepOutput<string>, config: import("../util/quads").QuadSerializationConfiguration) => string;
+            };
+            readonly dependencies: readonly [];
+            readonly requiredInput: import("../r-bridge/parser").ParseRequiredInput<string>;
+        } | {
+            readonly name: "normalize";
+            readonly humanReadableName: "normalize";
+            readonly description: "Normalize the AST to flowR's AST";
+            readonly processor: (results: {
+                parse?: import("../r-bridge/parser").ParseStepOutput<string>;
+            }, input: Partial<import("../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../r-bridge/lang-4.x/ast/model/model").RNode<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/normalize-printer").normalizedAstToJson;
+                readonly 5: typeof import("../core/print/normalize-printer").normalizedAstToQuads;
+                readonly 3: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaid;
+                readonly 4: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+            };
+            readonly dependencies: readonly ["parse"];
+            readonly requiredInput: import("../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+        } | {
+            readonly humanReadableName: "dataflow";
+            readonly processor: (results: {
+                normalize?: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            }, input: {
+                request?: import("../r-bridge/retriever").RParseRequests;
+                parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
+            }, config: import("../config").FlowrConfigOptions) => import("../dataflow/info").DataflowInformation;
+            readonly requiredInput: {};
+            readonly name: "dataflow";
+            readonly description: "Construct the dataflow graph";
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/dataflow-printer").dataflowGraphToJson;
+                readonly 5: typeof import("../core/print/dataflow-printer").dataflowGraphToQuads;
+                readonly 3: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaid;
+                readonly 4: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+            };
+            readonly dependencies: readonly ["normalize"];
+        }>>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
+    };
     readonly 'id-map': {
         readonly executor: typeof import("./catalog/id-map-query/id-map-query-executor").executeIdMapQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{

package/queries/query.js

@@ -31,12 +31,14 @@ const project_query_format_1 = require("./catalog/project-query/project-query-fo
 const origin_query_format_1 = require("./catalog/origin-query/origin-query-format");
 const linter_query_format_1 = require("./catalog/linter-query/linter-query-format");
 const control_flow_query_format_1 = require("./catalog/control-flow-query/control-flow-query-format");
+const df_shape_query_format_1 = require("./catalog/df-shape-query/df-shape-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
     'control-flow': control_flow_query_format_1.ControlFlowQueryDefinition,
     'dataflow': dataflow_query_format_1.DataflowQueryDefinition,
     'dataflow-lens': dataflow_lens_query_format_1.DataflowLensQueryDefinition,
+    'df-shape': df_shape_query_format_1.DfShapeQueryDefinition,
     'id-map': id_map_query_format_1.IdMapQueryDefinition,
     'normalized-ast': normalized_ast_query_format_1.NormalizedAstQueryDefinition,
     'dataflow-cluster': cluster_query_format_1.ClusterQueryDefinition,

package/util/files.d.ts

@@ -40,17 +40,23 @@ export declare function writeTableAsCsv(table: Table, file: string, sep?: string
 /**
  * Reads a file line by line and calls the given function for each line.
  * The `lineNumber` starts at `0`.
+ * The `maxLines` option limits the maximum number of read lines and is `Infinity` by default.
+ *
+ * @returns Whether all lines have been successfully read (`false` if `maxLines` was reached)
  *
  * See {@link readLineByLineSync} for a synchronous version.
  */
-export declare function readLineByLine(filePath: string, onLine: (line: Buffer, lineNumber: number) => Promise<void>): Promise<void>;
+export declare function readLineByLine(filePath: string, onLine: (line: Buffer, lineNumber: number) => Promise<void>, maxLines?: number): Promise<boolean>;
 /**
  * Reads a file line by line and calls the given function for each line.
  * The `lineNumber` starts at `0`.
+ * The `maxLines` option limits the maximum number of read lines and is `Infinity` by default.
+ *
+ * @returns Whether the file exists and all lines have been successfully read (`false` if `maxLines` was reached)
  *
  * See {@link readLineByLine} for an asynchronous version.
  */
-export declare function readLineByLineSync(filePath: string, onLine: (line: Buffer, lineNumber: number) => void): void;
+export declare function readLineByLineSync(filePath: string, onLine: (line: Buffer, lineNumber: number) => void, maxLines?: number): boolean;
 /**
  * Chops off the last part of the given directory path after a path separator, essentially returning the path's parent directory.
  * If an absolute path is passed, the returned path is also absolute.

package/util/files.js

@@ -124,36 +124,54 @@ function writeTableAsCsv(table, file, sep = ',', newline = '\n') {
 /**
  * Reads a file line by line and calls the given function for each line.
  * The `lineNumber` starts at `0`.
+ * The `maxLines` option limits the maximum number of read lines and is `Infinity` by default.
+ *
+ * @returns Whether all lines have been successfully read (`false` if `maxLines` was reached)
  *
  * See {@link readLineByLineSync} for a synchronous version.
  */
-async function readLineByLine(filePath, onLine) {
+async function readLineByLine(filePath, onLine, maxLines = Infinity) {
+    if (!(await fs_1.default.promises.stat(filePath).catch(() => { }))?.isFile()) {
+        log_1.log.warn(`File ${filePath} does not exist`);
+        return false;
+    }
     const reader = new n_readlines_1.default(filePath);
     let line;
     let counter = 0;
     // eslint-disable-next-line no-cond-assign
     while (line = reader.next()) {
+        if (counter >= maxLines) {
+            return false;
+        }
         await onLine(line, counter++);
     }
+    return true;
 }
 /**
  * Reads a file line by line and calls the given function for each line.
  * The `lineNumber` starts at `0`.
+ * The `maxLines` option limits the maximum number of read lines and is `Infinity` by default.
+ *
+ * @returns Whether the file exists and all lines have been successfully read (`false` if `maxLines` was reached)
  *
  * See {@link readLineByLine} for an asynchronous version.
  */
-function readLineByLineSync(filePath, onLine) {
-    if (!fs_1.default.existsSync(filePath)) {
+function readLineByLineSync(filePath, onLine, maxLines = Infinity) {
+    if (!fs_1.default.statSync(filePath, { throwIfNoEntry: false })?.isFile()) {
         log_1.log.warn(`File ${filePath} does not exist`);
-        return;
+        return false;
     }
     const reader = new n_readlines_1.default(filePath);
     let line;
     let counter = 0;
     // eslint-disable-next-line no-cond-assign
     while (line = reader.next()) {
+        if (counter >= maxLines) {
+            return false;
+        }
         onLine(line, counter++);
     }
+    return true;
 }
 /**
  * Chops off the last part of the given directory path after a path separator, essentially returning the path's parent directory.

package/util/r-value.d.ts

@@ -0,0 +1,23 @@
+import type { Value, ValueInterval, ValueLogical, ValueNumber, ValueString, ValueVector } from '../dataflow/eval/values/r-value';
+import type { RLogicalValue } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+import { type RNumberValue, type RStringValue } from '../r-bridge/lang-4.x/convert-values';
+export declare function isRStringValue(value: unknown): value is RStringValue;
+export declare function isRNumberValue(value: unknown): value is RNumberValue;
+export declare function isRLogicalValue(value: unknown): value is RLogicalValue;
+export declare function unwrapRValue(value: RStringValue | string): string;
+export declare function unwrapRValue(value: RNumberValue | number): number;
+export declare function unwrapRValue(value: RLogicalValue): boolean;
+export declare function unwrapRValue(value: RStringValue | RNumberValue | RLogicalValue | string | number): string | number | boolean;
+export declare function unwrapRValue(value: unknown): string | number | boolean | undefined;
+export declare function unwrapRVector(value: RStringValue[] | string[]): string[];
+export declare function unwrapRVector(value: RNumberValue[] | number[]): number[];
+export declare function unwrapRVector(value: RLogicalValue[]): boolean[];
+export declare function unwrapRVector(value: RStringValue[] | RNumberValue[] | RLogicalValue[] | string[] | number[]): string[] | number[] | boolean[];
+export declare function unwrapRVector(value: unknown): string[] | number[] | boolean[] | (string | number | boolean)[] | undefined;
+export declare function unwrapRValueToString(value: RStringValue | RNumberValue | RLogicalValue | string | number): string;
+export declare function unwrapRValueToString(value: unknown): string | undefined;
+export declare function unliftRValue(value: ValueString): RStringValue | undefined;
+export declare function unliftRValue(value: ValueNumber | ValueInterval): RNumberValue | undefined;
+export declare function unliftRValue(value: ValueLogical): RLogicalValue | undefined;
+export declare function unliftRValue(value: ValueVector): (RStringValue | RNumberValue | RLogicalValue)[] | undefined;
+export declare function unliftRValue(value: Value): RStringValue | RNumberValue | boolean | (RStringValue | RNumberValue | RLogicalValue)[] | undefined;

package/util/r-value.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRStringValue = isRStringValue;
+exports.isRNumberValue = isRNumberValue;
+exports.isRLogicalValue = isRLogicalValue;
+exports.unwrapRValue = unwrapRValue;
+exports.unwrapRVector = unwrapRVector;
+exports.unwrapRValueToString = unwrapRValueToString;
+exports.unliftRValue = unliftRValue;
+const r_value_1 = require("../dataflow/eval/values/r-value");
+const convert_values_1 = require("../r-bridge/lang-4.x/convert-values");
+const assert_1 = require("./assert");
+function isRValue(value) {
+    return isRStringValue(value) || isRNumberValue(value) || isRLogicalValue(value) || typeof value === 'string' || typeof value === 'number';
+}
+function isRStringValue(value) {
+    return typeof value === 'object' && value !== null && 'str' in value && typeof value.str === 'string';
+}
+function isRNumberValue(value) {
+    return typeof value === 'object' && value !== null && 'num' in value && typeof value.num === 'number';
+}
+function isRLogicalValue(value) {
+    return typeof value === 'boolean';
+}
+function unwrapRValue(value) {
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    else if (isRStringValue(value)) {
+        return value.str;
+    }
+    else if (isRNumberValue(value)) {
+        return value.num;
+    }
+    else {
+        return undefined;
+    }
+}
+function unwrapRVector(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    else if (value.every(entry => typeof entry === 'string') || value.every(entry => typeof entry === 'number') || value.every(entry => typeof entry === 'boolean')) {
+        return value;
+    }
+    else if (value.every(isRStringValue)) {
+        return value.map(entry => unwrapRValue(entry));
+    }
+    else if (value.every(isRNumberValue)) {
+        return value.map(entry => unwrapRValue(entry));
+    }
+    else if (value.every(isRValue)) {
+        return value.map(entry => unwrapRValue(entry));
+    }
+    else {
+        return undefined;
+    }
+}
+function unwrapRValueToString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    else if (typeof value === 'number') {
+        return value.toString();
+    }
+    else if (typeof value === 'boolean') {
+        return value ? convert_values_1.RTrue : convert_values_1.RFalse;
+    }
+    else if (isRStringValue(value)) {
+        return value.str;
+    }
+    else if (isRNumberValue(value)) {
+        return value.num.toString();
+    }
+    else {
+        return undefined;
+    }
+}
+function unliftRValue(value) {
+    if (!(0, r_value_1.isValue)(value)) {
+        return undefined;
+    }
+    const type = value.type;
+    switch (type) {
+        case 'string': {
+            return (0, r_value_1.isValue)(value.value) ? value.value : undefined;
+        }
+        case 'number': {
+            return (0, r_value_1.isValue)(value.value) ? value.value : undefined;
+        }
+        case 'logical': {
+            return (0, r_value_1.isValue)(value.value) && typeof value.value === 'boolean' ? value.value : undefined;
+        }
+        case 'interval': {
+            const start = unliftRValue(value.start);
+            const end = unliftRValue(value.end);
+            return start !== undefined && end !== undefined && start.num === end.num ? start : undefined;
+        }
+        case 'vector': {
+            const values = (0, r_value_1.isValue)(value.elements) ? value.elements.map(unliftRValue) : undefined;
+            return values?.every(assert_1.isNotUndefined) ? values.flat() : undefined;
+        }
+        case 'set': {
+            return (0, r_value_1.isValue)(value.elements) && value.elements.length === 1 ? unliftRValue(value.elements[0]) : undefined;
+        }
+        case 'missing': {
+            return undefined;
+        }
+        default:
+            (0, assert_1.assertUnreachable)(type);
+    }
+}
+//# sourceMappingURL=r-value.js.map

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.2.16';
+const version = '2.3.0';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }

package/util/cfg/cfg.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=cfg.js.map