@eagleoutice/flowr 2.6.1 → 2.6.2

package/abstract-interpretation/domains/singleton-domain.js

@@ -1,21 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SingletonDomain = void 0;
+const logic_1 = require("../../util/logic");
 const abstract_domain_1 = require("./abstract-domain");
 const lattice_1 = require("./lattice");
 /**
- * The singleton abstract domain as single possible value.
+ * The singleton abstract domain as a single possible value.
  * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as {@link Top} symbol.
  * @template T     - Type of the value in the abstract domain
  * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
  */
-class SingletonDomain {
-    _value;
-    constructor(value) {
-        this._value = value;
-    }
-    get value() {
-        return this._value;
+class SingletonDomain extends abstract_domain_1.AbstractDomain {
+    create(value) {
+        return new SingletonDomain(value);
     }
     static top() {
         return new SingletonDomain(lattice_1.Top);
@@ -44,35 +41,35 @@ class SingletonDomain {
     leq(other) {
         return this.value === lattice_1.Bottom || other.value === lattice_1.Top || (this.isValue() && other.isValue() && this.value <= other.value);
     }
-    join(...values) {
-        const result = new SingletonDomain(this.value);
-        for (const other of values) {
-            if (result.value === lattice_1.Bottom) {
-                result._value = other.value;
-            }
-            else if (other.value === lattice_1.Bottom) {
-                result._value = result.value;
-            }
-            else if (result.value !== other.value) {
-                result._value = lattice_1.Top;
-            }
-        }
-        return result;
-    }
-    meet(...values) {
-        const result = new SingletonDomain(this.value);
-        for (const other of values) {
-            if (result.value === lattice_1.Top) {
-                result._value = other.value;
-            }
-            else if (other.value === lattice_1.Top) {
-                result._value = result.value;
-            }
-            else if (result.value !== other.value) {
-                result._value = lattice_1.Bottom;
-            }
-        }
-        return result;
+    join(other) {
+        const otherValue = other instanceof SingletonDomain ? other.value : other;
+        if (this.value === lattice_1.Bottom) {
+            return this.create(otherValue);
+        }
+        else if (otherValue === lattice_1.Bottom) {
+            return this.create(this.value);
+        }
+        else if (this.value !== otherValue) {
+            return this.top();
+        }
+        else {
+            return this.create(this.value);
+        }
+    }
+    meet(other) {
+        const otherValue = other instanceof SingletonDomain ? other.value : other;
+        if (this.value === lattice_1.Top) {
+            return this.create(otherValue);
+        }
+        else if (otherValue === lattice_1.Top) {
+            return this.create(this.value);
+        }
+        else if (this.value !== otherValue) {
+            return this.bottom();
+        }
+        else {
+            return this.create(this.value);
+        }
     }
     widen(other) {
         return this.join(other); // Using join for widening as the lattice is finite
@@ -92,6 +89,24 @@ class SingletonDomain {
     abstract(concrete) {
         return SingletonDomain.abstract(concrete);
     }
+    satisfies(value) {
+        if (this.isValue() && this.value === value) {
+            return logic_1.Ternary.Always;
+        }
+        else if (this.isTop()) {
+            return logic_1.Ternary.Maybe;
+        }
+        return logic_1.Ternary.Never;
+    }
+    toJson() {
+        if (this.value === lattice_1.Top) {
+            return lattice_1.Top.description;
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return lattice_1.Bottom.description;
+        }
+        return this.value;
+    }
     toString() {
         if (this.value === lattice_1.Top) {
             return '⊤';

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

@@ -1,32 +1,16 @@
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { AbstractDomain, ConcreteDomain } from './abstract-domain';
-import { Top } from './lattice';
-/** The type of the abstract state for a abstract domain mapping AST node IDs to abstract values of an abstract domain */
-export type AbstractState<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Map<NodeId, Domain>;
-/** The type of the concrete state for the concrete domain of an abstract domain mapping AST node IDs to a concrete value in the concrete domain */
-export type ConcreteState<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = ReadonlyMap<NodeId, ConcreteDomain<Domain>>;
+import type { AnyAbstractDomain } from './abstract-domain';
+import { MappedAbstractDomain } from './mapped-abstract-domain';
 /**
  * A state abstract domain as mapping of AST node IDs of a program 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 mapped AST node ID to Top.
  * @template Domain - Type of the abstract domain to map the AST node IDs to
  * @see {@link NodeId} for the node IDs of the AST nodes
  */
-export declare class StateAbstractDomain<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> implements AbstractDomain<ConcreteState<Domain>, AbstractState<Domain>, AbstractState<Domain>, AbstractState<Domain>> {
-    private _value;
-    constructor(value: AbstractState<Domain>);
-    get value(): AbstractState<Domain>;
-    bottom(): StateAbstractDomain<Domain>;
-    top(): StateAbstractDomain<Domain>;
-    equals(other: StateAbstractDomain<Domain>): boolean;
-    leq(other: StateAbstractDomain<Domain>): boolean;
-    join(...values: StateAbstractDomain<Domain>[]): StateAbstractDomain<Domain>;
-    meet(...values: StateAbstractDomain<Domain>[]): StateAbstractDomain<Domain>;
-    widen(other: StateAbstractDomain<Domain>): StateAbstractDomain<Domain>;
-    narrow(other: StateAbstractDomain<Domain>): StateAbstractDomain<Domain>;
-    concretize(limit?: number): ReadonlySet<ConcreteState<Domain>> | typeof Top;
-    abstract(concrete: ReadonlySet<ConcreteState<Domain>> | typeof Top): StateAbstractDomain<Domain>;
-    toString(): string;
-    isTop(): this is StateAbstractDomain<Domain>;
-    isBottom(): this is StateAbstractDomain<Domain>;
-    isValue(): this is StateAbstractDomain<Domain>;
+export declare abstract class StateAbstractDomain<Domain extends AnyAbstractDomain> extends MappedAbstractDomain<NodeId, Domain> {
 }
+/**
+ * The type of the value abstract domain of a state abstract domain (i.e. the abstract domain a state abstract domain maps to).
+ * @template StateDomain - The state abstract domain to get the value abstract domain type for
+ */
+export type ValueAbstractDomain<StateDomain extends StateAbstractDomain<AnyAbstractDomain>> = StateDomain extends StateAbstractDomain<infer Domain> ? Domain : never;

package/abstract-interpretation/domains/state-abstract-domain.js

@@ -1,179 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StateAbstractDomain = void 0;
-const abstract_domain_1 = require("./abstract-domain");
-const lattice_1 = require("./lattice");
+const mapped_abstract_domain_1 = require("./mapped-abstract-domain");
 /**
  * A state abstract domain as mapping of AST node IDs of a program 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 mapped AST node ID to Top.
  * @template Domain - Type of the abstract domain to map the AST node IDs to
  * @see {@link NodeId} for the node IDs of the AST nodes
  */
-class StateAbstractDomain {
-    _value;
-    constructor(value) {
-        this._value = new Map(value);
-    }
-    get value() {
-        return this._value;
-    }
-    bottom() {
-        return new StateAbstractDomain(new Map());
-    }
-    top() {
-        const result = new StateAbstractDomain(this.value);
-        for (const [key, value] of result.value) {
-            result._value.set(key, value.top());
-        }
-        return result;
-    }
-    equals(other) {
-        if (this.value === other.value) {
-            return true;
-        }
-        else if (this.value.size !== other.value.size) {
-            return false;
-        }
-        for (const [nodeId, value] of this.value) {
-            const otherValue = other.value.get(nodeId);
-            if (otherValue === undefined || !value.equals(otherValue)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    leq(other) {
-        if (this.value === other.value) {
-            return true;
-        }
-        for (const [nodeId, value] of this.value) {
-            const otherValue = other.value.get(nodeId);
-            if (otherValue === undefined || !value.leq(otherValue)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    join(...values) {
-        const result = new StateAbstractDomain(this.value);
-        for (const other of values) {
-            for (const [nodeId, value] of other.value) {
-                const currValue = result.value.get(nodeId);
-                if (currValue === undefined) {
-                    result.value.set(nodeId, value);
-                }
-                else {
-                    result.value.set(nodeId, currValue.join(value));
-                }
-            }
-        }
-        return result;
-    }
-    meet(...values) {
-        const result = new StateAbstractDomain(this.value);
-        for (const other of values) {
-            for (const [nodeId] of result.value) {
-                if (!other.value.has(nodeId)) {
-                    result.value.delete(nodeId);
-                }
-            }
-            for (const [nodeId, value] of other.value) {
-                const currValue = result.value.get(nodeId);
-                if (currValue !== undefined) {
-                    result.value.set(nodeId, currValue.meet(value));
-                }
-            }
-        }
-        return result;
-    }
-    widen(other) {
-        const result = new StateAbstractDomain(this.value);
-        for (const [nodeId, value] of other.value) {
-            const currValue = result.value.get(nodeId);
-            if (currValue === undefined) {
-                result.value.set(nodeId, value);
-            }
-            else {
-                result.value.set(nodeId, currValue.widen(value));
-            }
-        }
-        return result;
-    }
-    narrow(other) {
-        const result = new StateAbstractDomain(this.value);
-        for (const [nodeId] of this.value) {
-            if (!other.value.has(nodeId)) {
-                result.value.delete(nodeId);
-            }
-        }
-        for (const [nodeId, value] of other.value) {
-            const currValue = result.value.get(nodeId);
-            if (currValue !== undefined) {
-                result.value.set(nodeId, currValue.narrow(value));
-            }
-        }
-        return result;
-    }
-    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
-        if (this.value.values().some(value => value.isBottom())) {
-            return new Set();
-        }
-        let states = new Set([new Map()]);
-        for (const [nodeId, value] of this.value) {
-            const concreteValues = value.concretize(limit);
-            if (concreteValues === lattice_1.Top) {
-                return lattice_1.Top;
-            }
-            const newStates = new Set();
-            for (const state of states) {
-                for (const concrete of concreteValues) {
-                    if (newStates.size > limit) {
-                        return lattice_1.Top;
-                    }
-                    const map = new Map(state);
-                    map.set(nodeId, concrete);
-                    newStates.add(map);
-                }
-            }
-            states = newStates;
-        }
-        return states;
-    }
-    abstract(concrete) {
-        const entry = [...this.value.values()][0];
-        if (concrete === lattice_1.Top || entry === undefined) {
-            return new StateAbstractDomain(new Map());
-        }
-        const mappings = new Map();
-        for (const state of concrete) {
-            for (const [nodeId, value] of state) {
-                const mapping = mappings.get(nodeId);
-                if (mapping === undefined) {
-                    mappings.set(nodeId, new Set([value]));
-                }
-                else {
-                    mapping.add(value);
-                }
-            }
-        }
-        const result = new Map();
-        for (const [nodeId, values] of mappings) {
-            result.set(nodeId, entry.abstract(values));
-        }
-        return new StateAbstractDomain(result);
-    }
-    toString() {
-        return '(' + this.value.entries().toArray().map(([key, value]) => `${key} -> ${value.toString()}`).join(', ') + ')';
-    }
-    isTop() {
-        return this.value.values().every(value => value.isTop());
-    }
-    isBottom() {
-        return this.value.size === 0;
-    }
-    isValue() {
-        return true;
-    }
+class StateAbstractDomain extends mapped_abstract_domain_1.MappedAbstractDomain {
 }
 exports.StateAbstractDomain = StateAbstractDomain;
 //# sourceMappingURL=state-abstract-domain.js.map

package/abstract-interpretation/normalized-ast-fold.d.ts

@@ -1,7 +1,6 @@
 import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
-import type { RFunctionCall } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionCall, EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RFunctionDefinition } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-definition';
 import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 import type { RForLoop } from '../r-bridge/lang-4.x/ast/model/nodes/r-for-loop';
@@ -48,10 +47,8 @@ export type EntryExitVisitor<Info> = ((node: RNode<Info>) => void) | undefined;
  * You can control the value passing (`Returns` generic)
  * by providing sensible Monoid behavior overwriting the {@link DefaultNormalizedAstFold#concat|concat} method
  * and supplying the empty value in the constructor.
- *
  * @note By providing `entry` and `exit` you can use this as an extension to the simpler {@link visitAst} function but without
  *       the early termination within the visitors (for this, you can overwrite the respective `fold*` methods).
- *
  * @example First you want to create your own fold:
  *
  * ```ts
@@ -84,15 +81,12 @@ export declare class DefaultNormalizedAstFold<Returns = void, Info = NoInfo> imp
     constructor(empty: Returns, enter?: EntryExitVisitor<Info>, exit?: EntryExitVisitor<Info>);
     /**
      * Monoid::concat
-     *
-     *
      * @see {@link https://en.wikipedia.org/wiki/Monoid}
      * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
      */
     protected concat(_a: Returns, _b: Returns): Returns;
     /**
      * overwrite this method, if you have a faster way to concat multiple nodes
-     *
      * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
      */
     protected concatAll(nodes: readonly Returns[]): Returns;

package/abstract-interpretation/normalized-ast-fold.js

@@ -9,10 +9,8 @@ const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
  * You can control the value passing (`Returns` generic)
  * by providing sensible Monoid behavior overwriting the {@link DefaultNormalizedAstFold#concat|concat} method
  * and supplying the empty value in the constructor.
- *
  * @note By providing `entry` and `exit` you can use this as an extension to the simpler {@link visitAst} function but without
  *       the early termination within the visitors (for this, you can overwrite the respective `fold*` methods).
- *
  * @example First you want to create your own fold:
  *
  * ```ts
@@ -49,8 +47,6 @@ class DefaultNormalizedAstFold {
     }
     /**
      * Monoid::concat
-     *
-     *
      * @see {@link https://en.wikipedia.org/wiki/Monoid}
      * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
      */
@@ -59,7 +55,6 @@ class DefaultNormalizedAstFold {
     }
     /**
      * overwrite this method, if you have a faster way to concat multiple nodes
-     *
      * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
      */
     concatAll(nodes) {

package/benchmark/slicer.d.ts

@@ -9,11 +9,11 @@ import type { ReconstructionResult } from '../reconstruct/reconstruct';
 import type { PerSliceStats, SlicerStats, SlicerStatsDfShape } from './stats/stats';
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { SlicingCriteria } from '../slicing/criterion/parse';
-import type { RParseRequestFromFile, RParseRequestFromText } from '../r-bridge/retriever';
-import type { SlicingCriteriaFilter } from '../slicing/criterion/collect-all';
+import { type RParseRequestFromFile, type RParseRequestFromText } from '../r-bridge/retriever';
+import { type SlicingCriteriaFilter } from '../slicing/criterion/collect-all';
 import type { AutoSelectPredicate } from '../reconstruct/auto-select/auto-select-defaults';
 import type { KnownParserName } from '../r-bridge/parser';
-import type { FlowrConfigOptions } from '../config';
+import { type FlowrConfigOptions } from '../config';
 /**
  * The logger to be used for benchmarking as a global object.
  */
@@ -93,7 +93,6 @@ export declare class BenchmarkSlicer {
     /**
      * Slice for the given {@link SlicingCriteria}.
      * @see SingleSlicingCriterion
-     *
      * @returns The per slice stats retrieved for this slicing criteria
      */
     slice(...slicingCriteria: SlicingCriteria): Promise<BenchmarkSingleSliceStats>;
@@ -103,7 +102,6 @@ export declare class BenchmarkSlicer {
     extractCFG(): void;
     /**
      * Infer the shape of data frames using abstract interpretation with {@link inferDataFrameShapes}
-     *
      * @returns The statistics of the data frame shape inference
      */
     inferDataFrameShapes(): SlicerStatsDfShape;
@@ -118,9 +116,7 @@ export declare class BenchmarkSlicer {
      * See {@link collectAllSlicingCriteria} for details.
      * <p>
      * the `report` function will be called *before* each *individual* slice is performed.
-     *
      * @returns The number of slices that were produced
-     *
      * @see collectAllSlicingCriteria
      * @see SlicingCriteriaFilter
      */

package/benchmark/slicer.js

@@ -27,7 +27,6 @@ const arrays_1 = require("../util/collections/arrays");
 const config_1 = require("../config");
 const extract_cfg_1 = require("../control-flow/extract-cfg");
 const absint_info_1 = require("../abstract-interpretation/data-frame/absint-info");
-const domain_1 = require("../abstract-interpretation/data-frame/domain");
 const shape_inference_1 = require("../abstract-interpretation/data-frame/shape-inference");
 const fs_1 = __importDefault(require("fs"));
 /**
@@ -222,7 +221,6 @@ class BenchmarkSlicer {
     /**
      * Slice for the given {@link SlicingCriteria}.
      * @see SingleSlicingCriterion
-     *
      * @returns The per slice stats retrieved for this slicing criteria
      */
     async slice(...slicingCriteria) {
@@ -281,7 +279,6 @@ class BenchmarkSlicer {
     }
     /**
      * Infer the shape of data frames using abstract interpretation with {@link inferDataFrameShapes}
-     *
      * @returns The statistics of the data frame shape inference
      */
     inferDataFrameShapes() {
@@ -309,12 +306,12 @@ class BenchmarkSlicer {
             perNodeStats: new Map()
         };
         const result = this.measureSimpleStep('infer data frame shapes', () => (0, shape_inference_1.inferDataFrameShapes)(cfinfo, dfg, ast, config));
-        stats.numberOfResultConstraints = result.size;
-        for (const value of result.values()) {
-            if ((0, domain_1.equalDataFrameDomain)(value, domain_1.DataFrameTop)) {
+        stats.numberOfResultConstraints = result.value.size;
+        for (const value of result.value.values()) {
+            if (value.isTop()) {
                 stats.numberOfResultingTop++;
             }
-            else if ((0, domain_1.equalDataFrameDomain)(value, domain_1.DataFrameBottom)) {
+            else if (value.isBottom()) {
                 stats.numberOfResultingBottom++;
             }
             else {
@@ -334,17 +331,17 @@ class BenchmarkSlicer {
                 return;
             }
             const nodeStats = {
-                numberOfEntries: node.info.dataFrame?.domain?.size ?? 0
+                numberOfEntries: node.info.dataFrame?.domain?.value.size ?? 0
             };
             if (expression !== undefined) {
                 nodeStats.mappedOperations = expression.operations.map(op => op.operation);
                 stats.numberOfOperationNodes++;
                 if (value !== undefined) {
-                    nodeStats.inferredColNames = value.colnames === domain_1.ColNamesTop ? 'top' : value.colnames.length;
+                    nodeStats.inferredColNames = value.colnames.isValue() ? value.colnames.value.size : value.colnames.isTop() ? 'top' : 'bottom';
                     nodeStats.inferredColCount = this.getInferredSize(value.cols);
                     nodeStats.inferredRowCount = this.getInferredSize(value.rows);
-                    nodeStats.approxRangeColCount = value.cols === domain_1.IntervalBottom ? 0 : value.cols[1] - value.cols[0];
-                    nodeStats.approxRangeRowCount = value.rows === domain_1.IntervalBottom ? 0 : value.rows[1] - value.rows[0];
+                    nodeStats.approxRangeColCount = value.cols.isValue() ? value.cols.value[1] - value.cols.value[0] : 0;
+                    nodeStats.approxRangeRowCount = value.rows.isValue() ? value.rows.value[1] - value.rows.value[0] : 0;
                 }
             }
             if (value !== undefined) {
@@ -362,16 +359,16 @@ class BenchmarkSlicer {
         return stats;
     }
     getInferredSize(value) {
-        if ((0, domain_1.equalInterval)(value, domain_1.IntervalTop)) {
+        if (value.isTop()) {
             return 'top';
         }
-        else if (value === domain_1.IntervalBottom) {
-            return 'bottom';
-        }
-        else if (!isFinite(value[1])) {
+        else if (value.isValue() && !isFinite(value.value[1])) {
             return 'infinite';
         }
-        return Math.floor((value[0] + value[1]) / 2);
+        else if (value.isValue()) {
+            return Math.floor((value.value[0] + value.value[1]) / 2);
+        }
+        return 'bottom';
     }
     /** Bridging the gap between the new internal and the old names for the benchmarking */
     async measureCommonStep(expectedStep, keyToMeasure) {
@@ -410,9 +407,7 @@ class BenchmarkSlicer {
      * See {@link collectAllSlicingCriteria} for details.
      * <p>
      * the `report` function will be called *before* each *individual* slice is performed.
-     *
      * @returns The number of slices that were produced
-     *
      * @see collectAllSlicingCriteria
      * @see SlicingCriteriaFilter
      */

package/benchmark/stats/print.d.ts

@@ -1,8 +1,14 @@
 import type { SummarizedSlicerStats, UltimateSlicerStats } from '../summarizer/data';
+/**
+ * Formats the given nanoseconds into a human-readable string.
+ */
 export declare function formatNanoseconds(nanoseconds: bigint | number): string;
 /**
  * Converts the given stats to a human-readable string.
  * You may have to {@link summarizeSlicerStats | summarize} the stats first.
  */
 export declare function stats2string(stats: SummarizedSlicerStats): string;
+/**
+ * Converts reduction stats to a human-readable string.
+ */
 export declare function ultimateStats2String(stats: UltimateSlicerStats): string;

package/benchmark/stats/print.js

@@ -8,6 +8,9 @@ const padSize = 15;
 function pad(string) {
     return String(string).padStart(padSize, ' ');
 }
+/**
+ * Formats the given nanoseconds into a human-readable string.
+ */
 function formatNanoseconds(nanoseconds) {
     if (nanoseconds < 0) {
         return '??';
@@ -186,6 +189,9 @@ Dataframe shape inference:
     }
     return result;
 }
+/**
+ * Converts reduction stats to a human-readable string.
+ */
 function ultimateStats2String(stats) {
     let result = `
 Summarized: ${stats.totalRequests} requests and ${stats.totalSlices} slices

package/benchmark/stats/size-of.d.ts

@@ -3,7 +3,6 @@ import type { DataflowGraph } from '../../dataflow/graph/graph';
 export declare function getSizeOfDfGraph(df: DataflowGraph): number;
 /**
  * Calculates the size of an array in bytes.
- *
  * @param array - The array to calculate the size of.
  * @returns The size of the array in bytes.
  */

package/benchmark/stats/size-of.js

@@ -70,7 +70,6 @@ function getSizeOfDfGraph(df) {
 }
 /**
  * Calculates the size of an array in bytes.
- *
  * @param array - The array to calculate the size of.
  * @returns The size of the array in bytes.
  */

package/benchmark/stats/stats.d.ts

@@ -60,7 +60,7 @@ export interface SlicerStatsDfShape<T = number> {
 export interface PerNodeStatsDfShape<T = number> {
     numberOfEntries: T;
     mappedOperations?: DataFrameOperationName[];
-    inferredColNames?: T | 'top';
+    inferredColNames?: T | 'bottom' | 'top';
     inferredColCount?: T | 'bottom' | 'infinite' | 'top';
     inferredRowCount?: T | 'bottom' | 'infinite' | 'top';
     /** difference between upper and lower bound of interval domain (to estimate approximation) */
@@ -70,7 +70,7 @@ export interface PerNodeStatsDfShape<T = number> {
 /**
  * Please note, that these measurement can be negative as there is no guarantee that the memory usage will increase
  * due to, e.g., garbage collection.
-*/
+ */
 export interface BenchmarkMemoryMeasurement<T = number> extends MergeableRecord {
     heap: T;
     rss: T;

package/benchmark/stopwatch.d.ts

@@ -10,26 +10,24 @@ export interface IStoppableStopwatch {
 export declare class Measurements<T> {
     private measurements;
     /**
-   * Start a timer for the given key, and guards that this is the first time this key is started.
-   * Call {@link IStoppableStopwatch#stop} on the returned stopwatch to stop the timer.
-   */
+     * Start a timer for the given key, and guards that this is the first time this key is started.
+     * Call {@link IStoppableStopwatch#stop} on the returned stopwatch to stop the timer.
+     */
     start(key: T): IStoppableStopwatch;
     /**
-   * Automatically call {@link Measurements#start | start} and the corresponding stop to measure the execution time of the given function.
-   * @see {@link measureAsync}
-   */
+     * Automatically call {@link Measurements#start | start} and the corresponding stop to measure the execution time of the given function.
+     * @see {@link measureAsync}
+     */
     measure<Out>(key: T, fn: () => Out): Out;
     /**
-   * Similar to {@link measure}, but await the promise as part of the measurement
-   *
+     * Similar to {@link measure}, but await the promise as part of the measurement
      * @param key - The key to write the resulting measurement to
      * @param fn  - The function to measure
-     *
-   * @see measure
-   */
+     * @see measure
+     */
     measureAsync<Out>(key: T, fn: () => Promise<Out>): Promise<Out>;
     /**
-   * Retrieve all measure-results, requires that all stop-watches that have been started have also been stopped.
-   */
+     * Retrieve all measure-results, requires that all stop-watches that have been started have also been stopped.
+     */
     get(): Map<T, bigint>;
 }