@eagleoutice/flowr 2.9.14 → 2.10.2

package/r-bridge/lang-4.x/ast/model/nodes/r-while-loop.d.ts

@@ -1,4 +1,5 @@
-import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo } from '../model';
+import { RNode } from '../model';
 import { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
@@ -20,4 +21,18 @@ export declare const RWhileLoop: {
      * Type guard for {@link RWhileLoop} nodes.
      */
     readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RWhileLoop<Info>;
+    readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
+    readonly getId: (this: void, node: RNode<import("../processing/decorate").ParentInformation>) => import("../processing/node-id").NodeId;
+    readonly getType: (this: void, node: RNode) => RType;
+    readonly visitAst: <OtherInfo = object>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo>>, onVisit?: import("../processing/visitor").OnEnter<OtherInfo>, onExit?: import("../processing/visitor").OnExit<OtherInfo>) => void;
+    readonly collectAllIds: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Set<import("../processing/node-id").NodeId>;
+    readonly directChildren: <OtherInfo>(this: void, node: RNode<OtherInfo>) => readonly (RNode<OtherInfo> | typeof import("./r-function-call").EmptyArgument)[];
+    readonly directParent: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined;
+    readonly iterateParents: <OtherInfo>(this: void, node: RNode<OtherInfo & import("../processing/decorate").ParentInformation> | undefined, idMap: Map<import("../processing/node-id").NodeId, RNode<OtherInfo & import("../processing/decorate").ParentInformation>>) => Generator<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>;
+    readonly depth: (this: void, node: RNode<import("../processing/decorate").ParentInformation>, idMap: Map<import("../processing/node-id").NodeId, RNode<import("../processing/decorate").ParentInformation>>) => number;
+    readonly collectAllIdsWithStop: <OtherInfo>(this: void, nodes: import("../../../../../abstract-interpretation/normalized-ast-fold").SingleOrArrayOrNothing<RNode<OtherInfo & import("../processing/decorate").ParentInformation>>, stop: (node: RNode<OtherInfo & import("../processing/decorate").ParentInformation>) => boolean) => Set<import("../processing/node-id").NodeId>;
+    readonly lexeme: <R extends RNode<import("../processing/decorate").ParentInformation>>(this: void, node: R | undefined) => R extends {
+        lexeme: string;
+    } ? string : string | undefined;
+    readonly documentation: typeof import("../../../../roxygen2/documentation-provider").getDocumentationOf;
 };

package/r-bridge/lang-4.x/ast/model/nodes/r-while-loop.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RWhileLoop = void 0;
+const model_1 = require("../model");
 const type_1 = require("../type");
 /**
  * Helper for working with {@link RWhileLoop} AST nodes.
  */
 exports.RWhileLoop = {
+    ...model_1.RNode,
     name: 'RWhileLoop',
     /**
      * Type guard for {@link RWhileLoop} nodes.

package/r-bridge/lang-4.x/ast/model/versions.d.ts

@@ -4,5 +4,7 @@
  */
 export declare const MIN_VERSION_PIPE = "4.1.0";
 export declare const MIN_VERSION_LAMBDA = "4.1.0";
+export declare const MIN_VERSION_PIPE_PLACEHOLDER = "4.2.0";
+export declare const MIN_VERSION_PIPE_PLACEHOLDER_EXTRACT = "4.3.0";
 /** between 4.0.0 and (i think) 4.1.0 the parser handled them differently. We ignore that for now. */
 export declare const MIN_VERSION_RAW_STABLE = "4.1.0";

package/r-bridge/lang-4.x/ast/model/versions.js

@@ -4,9 +4,11 @@
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MIN_VERSION_RAW_STABLE = exports.MIN_VERSION_LAMBDA = exports.MIN_VERSION_PIPE = void 0;
+exports.MIN_VERSION_RAW_STABLE = exports.MIN_VERSION_PIPE_PLACEHOLDER_EXTRACT = exports.MIN_VERSION_PIPE_PLACEHOLDER = exports.MIN_VERSION_LAMBDA = exports.MIN_VERSION_PIPE = void 0;
 exports.MIN_VERSION_PIPE = '4.1.0';
 exports.MIN_VERSION_LAMBDA = '4.1.0';
+exports.MIN_VERSION_PIPE_PLACEHOLDER = '4.2.0';
+exports.MIN_VERSION_PIPE_PLACEHOLDER_EXTRACT = '4.3.0';
 /** between 4.0.0 and (i think) 4.1.0 the parser handled them differently. We ignore that for now. */
 exports.MIN_VERSION_RAW_STABLE = '4.1.0';
 //# sourceMappingURL=versions.js.map

package/r-bridge/roxygen2/documentation-provider.js

@@ -85,30 +85,39 @@ function getDocumentationOfByName(name, idMap) {
         return getDocumentationOf(node.info.id, idMap);
     }
 }
-function filterDocumentationForParams(doc, filter) {
+function filterDocumentationForParamsInherited(doc, filter) {
     if (!doc) {
         return doc;
     }
     if (Array.isArray(doc)) {
-        return doc.filter(filter);
+        const ds = doc.filter(filter);
+        for (const d of ds) {
+            d.inherited = true;
+        }
+        return ds;
     }
     else {
-        return filter(doc) ? doc : undefined;
+        const d = doc;
+        if (filter(d)) {
+            d.inherited = true;
+            return d;
+        }
+        return undefined;
     }
 }
 function expandInheritOfTag(tag, otherTags, idMap) {
     if (tag.type === roxygen_ast_1.KnownRoxygenTags.Inherit) {
         const inheritDoc = getDocumentationOfByName(tag.value.source, idMap);
-        return filterDocumentationForParams(inheritDoc, t => tag.value.components.includes(t.type));
+        return filterDocumentationForParamsInherited(inheritDoc, t => tag.value.components.includes(t.type));
     }
     else if (tag.type === roxygen_ast_1.KnownRoxygenTags.InheritDotParams) {
         const inheritDoc = getDocumentationOfByName(tag.value.source, idMap);
-        return filterDocumentationForParams(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && t.value.name === '...');
+        return filterDocumentationForParamsInherited(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && t.value.name === '...');
     }
     else if (tag.type === roxygen_ast_1.KnownRoxygenTags.InheritParams) {
         const inheritDoc = getDocumentationOfByName(tag.value, idMap);
         const alreadyExplainedParams = new Set(otherTags.filter(t => t.type === roxygen_ast_1.KnownRoxygenTags.Param).map(t => t.value.name));
-        return filterDocumentationForParams(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && !alreadyExplainedParams.has(t.value.name));
+        return filterDocumentationForParamsInherited(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && !alreadyExplainedParams.has(t.value.name));
     }
     return tag;
 }

package/r-bridge/roxygen2/roxygen-ast.d.ts

@@ -196,7 +196,9 @@ export type RoxygenOtherTag = RoxygenTagAuthor | RoxygenUnknownTag | RoxygenDocT
 /**
  * All known Roxygen tag types.
  */
-export type RoxygenTag = RoxygenCrossrefTag | RoxygenNamespaceTag | RoxygenFormattingTag | RoxygenDatasetDocumentationTag | RoxygenFunctionDocumentationTag | RoxygenReusingDocumentationTag | RoxygenOtherTag;
+export type RoxygenTag = (RoxygenCrossrefTag | RoxygenNamespaceTag | RoxygenFormattingTag | RoxygenDatasetDocumentationTag | RoxygenFunctionDocumentationTag | RoxygenReusingDocumentationTag | RoxygenOtherTag) & {
+    inherited?: boolean;
+};
 /**
  * A roxygen comment block, consisting of multiple {@link RoxygenTag|roxygen tags}.
  */

package/search/flowr-search-builder.js

@@ -5,6 +5,7 @@ exports.getFlowrSearch = getFlowrSearch;
 const search_optimizer_1 = require("./search-optimizer/search-optimizer");
 const assert_1 = require("../util/assert");
 const search_mappers_1 = require("./search-executor/search-mappers");
+const AllGeneratorObj = { type: 'generator', name: 'all', args: undefined };
 /**
  * This object holds all the methods to generate search queries.
  * For compatibility, please use the {@link Q} identifier object to access these methods.
@@ -37,7 +38,7 @@ exports.FlowrSearchGenerator = {
      * Returns all elements (nodes/dataflow vertices) from the given data.
      */
     all() {
-        return new FlowrSearchBuilder({ type: 'generator', name: 'all', args: undefined });
+        return new FlowrSearchBuilder(AllGeneratorObj);
     },
     /**
      * Returns all elements that match the given {@link FlowrSearchGetFilters|filters}.
@@ -46,7 +47,7 @@ exports.FlowrSearchGenerator = {
      */
     get(filter) {
         (0, assert_1.guard)(!filter.nameIsRegex || filter.name, 'If nameIsRegex is set, a name should be provided');
-        (0, assert_1.guard)(!filter.line || filter.line != 0, 'If line is set, it must be different from 0 as there is no 0 line');
+        (0, assert_1.guard)(!filter.line || filter.line !== 0, 'If line is set, it must be different from 0 as there is no 0 line');
         (0, assert_1.guard)(!filter.column || filter.column > 0, 'If column is set, it must be greater than 0, but was ' + filter.column);
         return new FlowrSearchBuilder({ type: 'generator', name: 'get', args: { filter } });
     },

package/search/search-executor/search-generators.js

@@ -133,7 +133,7 @@ async function generateSyntax(input, args) {
 }
 async function generateCriterion(input, args) {
     const idMap = (await input.normalize()).idMap;
-    return new flowr_search_1.FlowrSearchElements(args.criterion.map(c => ({ node: idMap.get(parse_1.SingleSlicingCriterion.parse(c, idMap)) })));
+    return new flowr_search_1.FlowrSearchElements(args.criterion.map(c => ({ node: idMap.get(parse_1.SlicingCriterion.parse(c, idMap)) })));
 }
 /**
  * Gets the search generator function for the given name

package/slicing/criterion/parse.d.ts

@@ -1,33 +1,34 @@
 import { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /** Either `line:column`, `line@variable-name`, or `$id` */
-export type SingleSlicingCriterion = `${number}:${number}` | `${number}@${string}` | `$${NodeId | number}`;
+export type SlicingCriterion = `${number}:${number}` | `${number}@${string}` | `$${NodeId | number}`;
 /**
- * The helper object associated with {@link SingleSlicingCriterion} which makes it easy
+ * The helper object associated with {@link SlicingCriterion} which makes it easy
  * to parse, validate and resolve slicing criteria.
  */
-export declare const SingleSlicingCriterion: {
+export declare const SlicingCriterion: {
+    readonly name: "SlicingCriterion";
     /**
      * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
-     * @see {@link SingleSlicingCriterion.tryParse} for a version that does not throw an error
+     * @see {@link SlicingCriterion.tryParse} for a version that does not throw an error
      */
-    readonly parse: (this: void, criterion: SingleSlicingCriterion, idMap: AstIdMap) => NodeId;
+    readonly parse: (this: void, criterion: SlicingCriterion, idMap: AstIdMap) => NodeId;
     /**
      * Tries to resolve a slicing criterion to an id, but does not throw an error if it fails.
-     * @see {@link SingleSlicingCriterion.parse} for the version that throws an error
+     * @see {@link SlicingCriterion.parse} for the version that throws an error
      */
-    readonly tryParse: (this: void, criterion: SingleSlicingCriterion | NodeId, idMap: AstIdMap) => NodeId | undefined;
+    readonly tryParse: (this: void, criterion: SlicingCriterion | NodeId, idMap: AstIdMap) => NodeId | undefined;
     /**
      * Converts a node id to a slicing criterion in the form of `$id`
      */
-    readonly fromId: (this: void, id: NodeId) => SingleSlicingCriterion;
+    readonly fromId: (this: void, id: NodeId) => SlicingCriterion;
 };
 /**
  * A slicing criterion is a list of single slicing criteria, which can be in the form of `line:column`, `line@variable-name`, or `$id`.
  */
-export type SlicingCriteria = SingleSlicingCriterion[];
+export type SlicingCriteria = SlicingCriterion[];
 export interface DecodedCriterion {
-    criterion: SingleSlicingCriterion;
+    criterion: SlicingCriterion;
     id: NodeId;
 }
 export type DecodedCriteria = ReadonlyArray<DecodedCriterion>;

package/slicing/criterion/parse.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CriteriaParseError = exports.SlicingCriteria = exports.SingleSlicingCriterion = void 0;
+exports.CriteriaParseError = exports.SlicingCriteria = exports.SlicingCriterion = void 0;
 const log_1 = require("../../util/log");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const static_slicer_1 = require("../static/static-slicer");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 /**
- * The helper object associated with {@link SingleSlicingCriterion} which makes it easy
+ * The helper object associated with {@link SlicingCriterion} which makes it easy
  * to parse, validate and resolve slicing criteria.
  */
-exports.SingleSlicingCriterion = {
+exports.SlicingCriterion = {
+    name: 'SlicingCriterion',
     /**
      * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
-     * @see {@link SingleSlicingCriterion.tryParse} for a version that does not throw an error
+     * @see {@link SlicingCriterion.tryParse} for a version that does not throw an error
      */
     parse(criterion, idMap) {
-        const resolved = exports.SingleSlicingCriterion.tryParse(criterion, idMap);
+        const resolved = exports.SlicingCriterion.tryParse(criterion, idMap);
         if (resolved === undefined) {
             throw new CriteriaParseError(`invalid slicing criterion ${criterion}`);
         }
@@ -23,7 +24,7 @@ exports.SingleSlicingCriterion = {
     },
     /**
      * Tries to resolve a slicing criterion to an id, but does not throw an error if it fails.
-     * @see {@link SingleSlicingCriterion.parse} for the version that throws an error
+     * @see {@link SlicingCriterion.parse} for the version that throws an error
      */
     tryParse(criterion, idMap) {
         criterion = criterion.toString(); // in case it's a number
@@ -58,14 +59,14 @@ exports.SlicingCriteria = {
      * @see {@link SlicingCriteria.convertAll}
      */
     decodeAll(criteria, decorated) {
-        return criteria.map(l => ({ criterion: l, id: exports.SingleSlicingCriterion.parse(l, decorated) }));
+        return criteria.map(l => ({ criterion: l, id: exports.SlicingCriterion.parse(l, decorated) }));
     },
     /**
      * Converts all criteria to their id in the AST if possible, this keeps the original criterion if it can not be resolved.
      * @see {@link SlicingCriteria.decodeAll}
      */
     convertAll(criteria, decorated) {
-        return criteria.map(l => exports.SingleSlicingCriterion.tryParse(l, decorated) ?? l);
+        return criteria.map(l => exports.SlicingCriterion.tryParse(l, decorated) ?? l);
     }
 };
 /**

package/slicing/static/static-slicer.js

@@ -11,6 +11,7 @@ const vertex_1 = require("../../dataflow/graph/vertex");
 const edge_1 = require("../../dataflow/graph/edge");
 const df_helper_1 = require("../../dataflow/graph/df-helper");
 const slice_direction_1 = require("../../util/slice-direction");
+const model_1 = require("../../r-bridge/lang-4.x/ast/model/model");
 exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
 /**
  * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
@@ -99,7 +100,29 @@ function staticSlice(ctx, info, { idMap }, ids, direction, threshold = 75, cache
             }
         }
     }
-    return { ...queue.status(), slicedFor: ids };
+    if (ctx.config.solver.slicer?.autoExtend) {
+        return { ...queue.status(), slicedFor: ids, result: extendSlices(queue.status().result, idMap) };
+    }
+    else {
+        return { ...queue.status(), slicedFor: ids };
+    }
+}
+function extendSlices(results, ast) {
+    const res = new Set();
+    for (const id of results) {
+        res.add(id);
+        let parent = ast.get(id);
+        while (parent && parent.info.role !== "root" /* RoleInParent.Root */ && parent.info.role !== "el-c" /* RoleInParent.ExpressionListChild */) {
+            parent = parent.info.parent ? ast.get(parent.info.parent) : undefined;
+        }
+        if (!parent) {
+            continue; // no parent, no need to extend
+        }
+        for (const id of model_1.RNode.collectAllIds(parent)) {
+            res.add(id);
+        }
+    }
+    return res;
 }
 /**
  * Updates the potential addition for the given target node in the visiting queue.

package/util/collections/arrays.d.ts

@@ -92,6 +92,10 @@ export declare function equidistantSampling<T>(list: readonly T[], sampleCount:
 export declare function cartesianProduct<T>(...arrays: T[][]): T[][];
 /** merge two arrays, removing duplicates */
 export declare function uniqueArrayMerge<T>(left: readonly T[], right: readonly T[]): T[];
+/**
+ * Returns a duplicate-free array.
+ */
+export declare function uniqueArray<T>(a: Iterable<T>): T[];
 /**
  * Groups the elements of the given array by the key returned by the given key function.
  */

package/util/collections/arrays.js

@@ -11,6 +11,7 @@ exports.arrayEqual = arrayEqual;
 exports.equidistantSampling = equidistantSampling;
 exports.cartesianProduct = cartesianProduct;
 exports.uniqueArrayMerge = uniqueArrayMerge;
+exports.uniqueArray = uniqueArray;
 exports.arraysGroupBy = arraysGroupBy;
 const assert_1 = require("../assert");
 /**
@@ -227,6 +228,12 @@ function uniqueArrayMerge(left, right) {
     }
     return Array.from(result);
 }
+/**
+ * Returns a duplicate-free array.
+ */
+function uniqueArray(a) {
+    return Array.from(new Set(a));
+}
 /**
  * Groups the elements of the given array by the key returned by the given key function.
  */

package/util/mermaid/ast.js

@@ -57,7 +57,8 @@ function normalizedAstToMermaid(ast, { prefix = 'flowchart TD\n', markStyle = in
             // add a subgraph for each file
             if (ast.files.length !== 1 || (f.filePath && f.filePath !== flowr_file_1.FlowrFile.INLINE_PATH)) {
                 const direction = identifyMermaidDirection(prefix);
-                output += `    subgraph "File: ${mermaid_1.Mermaid.escape(f.filePath ?? flowr_file_1.FlowrFile.INLINE_PATH)}" direction ${direction}\n`;
+                output += `    subgraph "File: ${mermaid_1.Mermaid.escape(f.filePath ?? flowr_file_1.FlowrFile.INLINE_PATH)}"\n`;
+                output += `    direction ${direction}\n`;
                 showAst(f.root);
                 output += '    end\n';
             }

package/util/mermaid/dfg.js

@@ -156,8 +156,9 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
         const escapedName = mermaid_1.Mermaid.escape(node ? `[${node.type}] ${lexeme}` : '??');
         const deps = info.cds ? ', :may:' + info.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
         const lnks = info.link?.origin ? ', :links:' + info.link.origin.join(',') : '';
+        const sources = info.source ? ', sources: ' + JSON.stringify(info.source) : '';
         const n = node?.info.fullRange ?? node?.location ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0].location : undefined);
-        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps}${lnks})\n      *${range_1.SourceRange.format(n)}*${fCall ? displayFunctionArgMapping(info.args) : '' + (info.tag === vertex_1.VertexType.FunctionDefinition && info.mode && info.mode.length > 0 ? mermaid_1.Mermaid.escape(JSON.stringify(info.mode)) : '')}\`"${close}`);
+        mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps}${lnks}${sources})\n      *${range_1.SourceRange.format(n)}*${fCall ? displayFunctionArgMapping(info.args) : '' + (info.tag === vertex_1.VertexType.FunctionDefinition && info.mode && info.mode.length > 0 ? mermaid_1.Mermaid.escape(JSON.stringify(info.mode)) : '')}\`"${close}`);
     }
     if (mark?.has(id)) {
         mermaid.nodeLines.push(`    style ${idPrefix}${id} ${mermaid.markStyle.vertex} `);

package/util/record.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Helper for transforming records.
+ */
+export declare const Record: {
+    /**
+     * Transforms a record by applying a callback function to each key-value pair in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each key-value pair of the record.
+     */
+    map<K1 extends string, K2 extends string, V1, V2>(this: void, object: Record<K1, V1>, callbackfn: (entry: [K1, V1], index: number, entries: [K1, V1][]) => [K2, V2]): Record<K2, V2>;
+    /**
+     * Transforms a record by applying a callback function to each key in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each key of the record.
+     */
+    mapKeys<K1 extends string, K2 extends string, V>(this: void, object: Record<K1, V>, callbackfn: (key: K1, index: number, entries: [K1, V][]) => K2): Record<K2, V>;
+    /**
+     * Transforms a record by applying a callback function to each property value in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each property value of the record.
+     */
+    mapProperties<K extends string, V1, V2>(this: void, object: Record<K, V1>, callbackfn: (value: V1, index: number, entries: [K, V1][]) => V2): Record<K, V2>;
+};

package/util/record.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Record = void 0;
+/**
+ * Helper for transforming records.
+ */
+exports.Record = {
+    /**
+     * Transforms a record by applying a callback function to each key-value pair in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each key-value pair of the record.
+     */
+    map(object, callbackfn) {
+        return Object.fromEntries(Object.entries(object).map(callbackfn));
+    },
+    /**
+     * Transforms a record by applying a callback function to each key in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each key of the record.
+     */
+    mapKeys(object, callbackfn) {
+        return exports.Record.map(object, ([key, value], index, entries) => [callbackfn(key, index, entries), value]);
+    },
+    /**
+     * Transforms a record by applying a callback function to each property value in the record.
+     * @param object - The record that should be transformed.
+     * @param callbackfn - The callback function that transforms each property value of the record.
+     */
+    mapProperties(object, callbackfn) {
+        return exports.Record.map(object, ([keys, value], index, entries) => [keys, callbackfn(value, index, entries)]);
+    }
+};
+//# sourceMappingURL=record.js.map

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.9.14';
+const version = '2.10.2';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */

package/abstract-interpretation/domains/mapped-abstract-domain.d.ts

@@ -1,41 +0,0 @@
-import { AbstractDomain, type AnyAbstractDomain, type ConcreteDomain } from './abstract-domain';
-import { Top } from './lattice';
-/** The type of the concrete mapping of the concrete domain of a mapped abstract domain mapping keys to a concrete value in the concrete domain */
-export type ConcreteMap<Key, Domain extends AnyAbstractDomain> = ReadonlyMap<Key, ConcreteDomain<Domain>>;
-/**
- * A mapped abstract domain as mapping of keys to abstract values of an abstract domain.
- * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing key to Top.
- * @template Key       - Type of the keys of the mapping to abstract values
- * @template Domain    - Type of the abstract domain to map the keys to
- */
-export declare class MappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends AbstractDomain<ConcreteMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>, ReadonlyMap<Key, Domain>> {
-    constructor(value: ReadonlyMap<Key, Domain>);
-    create(value: ReadonlyMap<Key, Domain>): this;
-    get(key: Key): Domain | undefined;
-    has(key: Key): boolean;
-    protected set(key: Key, value: Domain): void;
-    protected remove(key: Key): void;
-    bottom(): this;
-    top(): this;
-    equals(other: this): boolean;
-    leq(other: this): boolean;
-    join(other: this): this;
-    meet(other: this): this;
-    widen(other: this): this;
-    narrow(other: this): this;
-    concretize(limit: number): ReadonlySet<ConcreteMap<Key, Domain>> | typeof Top;
-    abstract(concrete: ReadonlySet<ConcreteMap<Key, Domain>> | typeof Top): this;
-    toJson(): unknown;
-    toString(): string;
-    isTop(): this is this;
-    isBottom(): this is this;
-    isValue(): this is this;
-}
-/**
- * A mutable version of the {@link MappedAbstractDomain} with {@link MutableMappedAbstractDomain#set|`set`} and {@link MutableMappedAbstractDomain#remove|`remove`}.
- */
-export declare class MutableMappedAbstractDomain<Key, Domain extends AnyAbstractDomain> extends MappedAbstractDomain<Key, Domain> {
-    create(value: ReadonlyMap<Key, Domain>): this;
-    set(key: Key, value: Domain): void;
-    remove(key: Key): void;
-}