@eagleoutice/flowr 2.6.1 → 2.6.2

package/abstract-interpretation/data-frame/domain.d.ts

@@ -1,107 +0,0 @@
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-type Interval = [number, number];
-/** The bottom element (least element) of the positive interval domain representing no possible values, explicitly given as "bottom". */
-export declare const IntervalBottom = "bottom";
-/** The top element (greatest element) of the positive interval domain representing all possible values, defined as the interval from 0 to infinity. */
-export declare const IntervalTop: [0, number];
-/** The positive interval domain representing possible integer values. */
-export type IntervalDomain = Interval | typeof IntervalBottom;
-/** The bottom element (least element) of the column names domain representing no possible column name, defined as the empty list []. */
-export declare const ColNamesBottom: [];
-/** The top element (greatest element) of the column names domain representing all possible values, explicitly given as "top". */
-export declare const ColNamesTop = "top";
-/** The column names domain defined as bounded string set domain representing possible column names. */
-export type ColNamesDomain = string[] | typeof ColNamesTop;
-/**
- * The data frame shape domain representing possible data frame shapes, defined as product domain of
- * the {@link ColNamesDomain} for the columns names and {@link IntervalDomain} for the number of columns and rows.
- * */
-export interface DataFrameDomain {
-    colnames: ColNamesDomain;
-    cols: IntervalDomain;
-    rows: IntervalDomain;
-}
-/**
- * The bottom element (least element) of the data frame shape domain representing no possible value, mapping the columns names to {@link ColNamesBottom}
- * and the number of columns and rows to {@link IntervalBottom}.
- */
-export declare const DataFrameBottom: {
-    readonly colnames: [];
-    readonly cols: "bottom";
-    readonly rows: "bottom";
-};
-/**
- * The top element (greatest element) of the data frame shape domain representing all possible value, mapping the columns names to {@link ColNamesTop}
- * and the number of columns and rows to {@link IntervalTop}.
- */
-export declare const DataFrameTop: {
-    readonly colnames: "top";
-    readonly cols: [0, number];
-    readonly rows: [0, number];
-};
-/**
- * The data frame shape state domain representing possible memory states, mapping AST node IDs to data frame shape values of the {@link DataFrameDomain}.
- */
-export type DataFrameStateDomain = Map<NodeId, DataFrameDomain>;
-/** Checks if two abstract values of the column names domain are equal. */
-export declare function equalColNames(set1: ColNamesDomain, set2: ColNamesDomain): boolean;
-/** Checks if two abstract values of the column names domain are ordered according to the partial ordering of the column names lattice. */
-export declare function leqColNames(set1: ColNamesDomain, set2: ColNamesDomain): boolean;
-/** Joins two abstract values of the columns names domain according to the column names lattice by creating the least upper bound (LUB). */
-export declare function joinColNames(set1: ColNamesDomain, set2: ColNamesDomain, maxColNames?: number): ColNamesDomain;
-/** Meets two abstract values of the columns names domain according to the column names lattice by creating the greatest lower bound (GLB). */
-export declare function meetColNames(set1: ColNamesDomain, set2: ColNamesDomain): ColNamesDomain;
-/** Subtracts an abstract value from another abstract value of the column names domain by performing a set minus. */
-export declare function subtractColNames(set1: ColNamesDomain, set2: ColNamesDomain): ColNamesDomain;
-/**
- * Widens two abstract values of the column names domain via naive widening to soundly over-approximate the join in (possibly infinite) fixpoint iterations.
- *
- * This is technically not necessary, as the join is limited by the maximum number of inferred column names.
- * However, this speeds up the iteration in larger loops significantly, as we are over-approximating the column names much earlier.
- */
-export declare function wideningColNames(set1: ColNamesDomain, set2: ColNamesDomain): ColNamesDomain;
-/** Checks whether an abstract value of the column names domain satisfies a column name */
-export declare function satisfiesColsNames(set: ColNamesDomain, value: string): boolean;
-/** Checks if two abstract values of the positive interval domain are equal. */
-export declare function equalInterval(interval1: IntervalDomain, interval2: IntervalDomain): boolean;
-/** Checks if two abstract values of the positive interval domain are ordered according to the partial ordering of the positive interval lattice. */
-export declare function leqInterval(interval1: IntervalDomain, interval2: IntervalDomain): boolean;
-/** Joins two abstract values of the positive interval domain according to the positive interval lattice by creating the least upper bound (LUB). */
-export declare function joinInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
-/** Meets two abstract values of the positive interval domain according to the positive interval lattice by creating the greatest lower bound (GLB). */
-export declare function meetInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
-/** Adds two abstract values of the positive interval domain, by adding the lower bounds and upper bounds. */
-export declare function addInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
-/** Subtracts an abstract value from another abstract values of the positive interval domain, by subtracting the lower bounds and upper bounds. */
-export declare function subtractInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
-/** Creates the minium of two abstract values of the positive interval domain, by creating the minimum of the lower bounds and upper bounds. */
-export declare function minInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
-/** Creates the maximum of two abstract values of the positive interval domain, by creating the maximum of the lower bounds and upper bounds. */
-export declare function maxInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
-/** Extrends the lower bound of an abstract value of the positive interval domain to 0. */
-export declare function extendIntervalToZero(interval: IntervalDomain): IntervalDomain;
-/** Extrends the upper bound of an abstract value of the positive interval domain to infinity. */
-export declare function extendIntervalToInfinity(interval: IntervalDomain): IntervalDomain;
-/** Widens two abstract values of the positive interval domain via naive widening to soundly over-approximate the join in (possibly infinite) fixpoint iterations. */
-export declare function wideningInterval(interval1: IntervalDomain, interval2: IntervalDomain): IntervalDomain;
-/** Checks whether an abstract value of the positive interval domain satisfies a numeric value. */
-export declare function satisfiesInterval(interval: IntervalDomain, value: number): boolean;
-/** Checks whether a numeric value satisfies the less-than relation with an abstract value of the positive interval domain. */
-export declare function satisfiesLeqInterval(interval: IntervalDomain, value: number): boolean;
-/** Checks if two abstract values of the data frame shape domain are equal. */
-export declare function equalDataFrameDomain(value1: DataFrameDomain, value2: DataFrameDomain): boolean;
-/** Joins multiple abstract values of the data frame shape domain by creating the least upper bound (LUB). */
-export declare function joinDataFrames(...values: DataFrameDomain[]): DataFrameDomain;
-/** Meets multiple abstract values of the data frame shape domain by creating the greatest lower bound (GLB). */
-export declare function meetDataFrames(...values: DataFrameDomain[]): DataFrameDomain;
-/** Widens two abstract values of the data frame shape domain by widening the column names and number of columns and rows. */
-export declare function wideningDataFrames(value1: DataFrameDomain, value2: DataFrameDomain): DataFrameDomain;
-/** Checks if two abstract states of the data frame shape state domain are equal. */
-export declare function equalDataFrameState(state1: DataFrameStateDomain, state2: DataFrameStateDomain): boolean;
-/** Joins multiple abstract states of the data frame shape state domain by joining each data frame shape of the states. */
-export declare function joinDataFrameStates(...states: DataFrameStateDomain[]): DataFrameStateDomain;
-/** Meets multiple abstract states of the data frame shape state domain by meeting each data frame shape of the states. */
-export declare function meetDataFrameStates(...states: DataFrameStateDomain[]): DataFrameStateDomain;
-/** Widens two abstract states of the data frame shape state domain by widening each data frame shape of the states. */
-export declare function wideningDataFrameStates(state1: DataFrameStateDomain, state2: DataFrameStateDomain): DataFrameStateDomain;
-export {};

package/abstract-interpretation/data-frame/domain.js

@@ -1,315 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFrameTop = exports.DataFrameBottom = exports.ColNamesTop = exports.ColNamesBottom = exports.IntervalTop = exports.IntervalBottom = void 0;
-exports.equalColNames = equalColNames;
-exports.leqColNames = leqColNames;
-exports.joinColNames = joinColNames;
-exports.meetColNames = meetColNames;
-exports.subtractColNames = subtractColNames;
-exports.wideningColNames = wideningColNames;
-exports.satisfiesColsNames = satisfiesColsNames;
-exports.equalInterval = equalInterval;
-exports.leqInterval = leqInterval;
-exports.joinInterval = joinInterval;
-exports.meetInterval = meetInterval;
-exports.addInterval = addInterval;
-exports.subtractInterval = subtractInterval;
-exports.minInterval = minInterval;
-exports.maxInterval = maxInterval;
-exports.extendIntervalToZero = extendIntervalToZero;
-exports.extendIntervalToInfinity = extendIntervalToInfinity;
-exports.wideningInterval = wideningInterval;
-exports.satisfiesInterval = satisfiesInterval;
-exports.satisfiesLeqInterval = satisfiesLeqInterval;
-exports.equalDataFrameDomain = equalDataFrameDomain;
-exports.joinDataFrames = joinDataFrames;
-exports.meetDataFrames = meetDataFrames;
-exports.wideningDataFrames = wideningDataFrames;
-exports.equalDataFrameState = equalDataFrameState;
-exports.joinDataFrameStates = joinDataFrameStates;
-exports.meetDataFrameStates = meetDataFrameStates;
-exports.wideningDataFrameStates = wideningDataFrameStates;
-const config_1 = require("../../config");
-const set_1 = require("../../util/collections/set");
-const MaxColNames = config_1.defaultConfigOptions.abstractInterpretation.dataFrame.maxColNames;
-/** The bottom element (least element) of the positive interval domain representing no possible values, explicitly given as "bottom". */
-exports.IntervalBottom = 'bottom';
-/** The top element (greatest element) of the positive interval domain representing all possible values, defined as the interval from 0 to infinity. */
-exports.IntervalTop = [0, Infinity];
-/** The bottom element (least element) of the column names domain representing no possible column name, defined as the empty list []. */
-exports.ColNamesBottom = [];
-/** The top element (greatest element) of the column names domain representing all possible values, explicitly given as "top". */
-exports.ColNamesTop = 'top';
-/**
- * The bottom element (least element) of the data frame shape domain representing no possible value, mapping the columns names to {@link ColNamesBottom}
- * and the number of columns and rows to {@link IntervalBottom}.
- */
-exports.DataFrameBottom = {
-    colnames: exports.ColNamesBottom,
-    cols: exports.IntervalBottom,
-    rows: exports.IntervalBottom
-};
-/**
- * The top element (greatest element) of the data frame shape domain representing all possible value, mapping the columns names to {@link ColNamesTop}
- * and the number of columns and rows to {@link IntervalTop}.
- */
-exports.DataFrameTop = {
-    colnames: exports.ColNamesTop,
-    cols: exports.IntervalTop,
-    rows: exports.IntervalTop
-};
-/** Checks if two abstract values of the column names domain are equal. */
-function equalColNames(set1, set2) {
-    return set1 === set2 || (set1 !== exports.ColNamesTop && set2 !== exports.ColNamesTop && (0, set_1.setEquals)(new Set(set1), new Set(set2)));
-}
-/** Checks if two abstract values of the column names domain are ordered according to the partial ordering of the column names lattice. */
-function leqColNames(set1, set2) {
-    return set2 === exports.ColNamesTop || (set1 !== exports.ColNamesTop && new Set(set1).isSubsetOf(new Set(set2)));
-}
-/** Joins two abstract values of the columns names domain according to the column names lattice by creating the least upper bound (LUB). */
-function joinColNames(set1, set2, maxColNames = MaxColNames) {
-    if (set1 === exports.ColNamesTop || set2 === exports.ColNamesTop) {
-        return exports.ColNamesTop;
-    }
-    const join = Array.from(new Set(set1).union(new Set(set2)));
-    return join.length > maxColNames ? exports.ColNamesTop : join;
-}
-/** Meets two abstract values of the columns names domain according to the column names lattice by creating the greatest lower bound (GLB). */
-function meetColNames(set1, set2) {
-    if (set1 === exports.ColNamesTop) {
-        return set2;
-    }
-    else if (set2 === exports.ColNamesTop) {
-        return set1;
-    }
-    else {
-        return Array.from(new Set(set1).intersection(new Set(set2)));
-    }
-}
-/** Subtracts an abstract value from another abstract value of the column names domain by performing a set minus. */
-function subtractColNames(set1, set2) {
-    if (set1 === exports.ColNamesTop) {
-        return exports.ColNamesTop;
-    }
-    else if (set2 === exports.ColNamesTop) {
-        return set1;
-    }
-    else {
-        return Array.from(new Set(set1).difference(new Set(set2)));
-    }
-}
-/**
- * Widens two abstract values of the column names domain via naive widening to soundly over-approximate the join in (possibly infinite) fixpoint iterations.
- *
- * This is technically not necessary, as the join is limited by the maximum number of inferred column names.
- * However, this speeds up the iteration in larger loops significantly, as we are over-approximating the column names much earlier.
- */
-function wideningColNames(set1, set2) {
-    return leqColNames(set2, set1) ? set1 : exports.ColNamesTop;
-}
-/** Checks whether an abstract value of the column names domain satisfies a column name */
-function satisfiesColsNames(set, value) {
-    return set === exports.ColNamesTop || set.includes(value);
-}
-/** Checks if two abstract values of the positive interval domain are equal. */
-function equalInterval(interval1, interval2) {
-    return interval1 === interval2 || (interval1 !== exports.IntervalBottom && interval2 !== exports.IntervalBottom && interval1[0] === interval2[0] && interval1[1] === interval2[1]);
-}
-/** Checks if two abstract values of the positive interval domain are ordered according to the partial ordering of the positive interval lattice. */
-function leqInterval(interval1, interval2) {
-    return interval1 === exports.IntervalBottom || (interval2 !== exports.IntervalBottom && interval2[0] <= interval1[0] && interval1[1] <= interval2[1]);
-}
-/** Joins two abstract values of the positive interval domain according to the positive interval lattice by creating the least upper bound (LUB). */
-function joinInterval(interval1, interval2) {
-    if (interval1 === exports.IntervalBottom) {
-        return interval2;
-    }
-    else if (interval2 === exports.IntervalBottom) {
-        return interval1;
-    }
-    else {
-        return [Math.min(interval1[0], interval2[0]), Math.max(interval1[1], interval2[1])];
-    }
-}
-/** Meets two abstract values of the positive interval domain according to the positive interval lattice by creating the greatest lower bound (GLB). */
-function meetInterval(interval1, interval2) {
-    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
-        return exports.IntervalBottom;
-    }
-    else if (Math.max(interval1[0], interval2[0]) > Math.min(interval1[1], interval2[1])) {
-        return exports.IntervalBottom;
-    }
-    else {
-        return [Math.max(interval1[0], interval2[0]), Math.min(interval1[1], interval2[1])];
-    }
-}
-/** Adds two abstract values of the positive interval domain, by adding the lower bounds and upper bounds. */
-function addInterval(interval1, interval2) {
-    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
-        return exports.IntervalBottom;
-    }
-    else {
-        return [interval1[0] + interval2[0], interval1[1] + interval2[1]];
-    }
-}
-/** Subtracts an abstract value from another abstract values of the positive interval domain, by subtracting the lower bounds and upper bounds. */
-function subtractInterval(interval1, interval2) {
-    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
-        return exports.IntervalBottom;
-    }
-    else {
-        return [Math.max(interval1[0] - interval2[0], 0), Math.max(interval1[1] - interval2[1], 0)];
-    }
-}
-/** Creates the minium of two abstract values of the positive interval domain, by creating the minimum of the lower bounds and upper bounds. */
-function minInterval(interval1, interval2) {
-    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
-        return exports.IntervalBottom;
-    }
-    else {
-        return [Math.min(interval1[0], interval2[0]), Math.min(interval1[1], interval2[1])];
-    }
-}
-/** Creates the maximum of two abstract values of the positive interval domain, by creating the maximum of the lower bounds and upper bounds. */
-function maxInterval(interval1, interval2) {
-    if (interval1 === exports.IntervalBottom || interval2 === exports.IntervalBottom) {
-        return exports.IntervalBottom;
-    }
-    else {
-        return [Math.max(interval1[0], interval2[0]), Math.max(interval1[1], interval2[1])];
-    }
-}
-/** Extrends the lower bound of an abstract value of the positive interval domain to 0. */
-function extendIntervalToZero(interval) {
-    if (interval === exports.IntervalBottom) {
-        return exports.IntervalBottom;
-    }
-    else {
-        return [0, interval[1]];
-    }
-}
-/** Extrends the upper bound of an abstract value of the positive interval domain to infinity. */
-function extendIntervalToInfinity(interval) {
-    if (interval === exports.IntervalBottom) {
-        return exports.IntervalBottom;
-    }
-    else {
-        return [interval[0], Infinity];
-    }
-}
-/** Widens two abstract values of the positive interval domain via naive widening to soundly over-approximate the join in (possibly infinite) fixpoint iterations. */
-function wideningInterval(interval1, interval2) {
-    if (interval1 === exports.IntervalBottom) {
-        return interval2;
-    }
-    else if (interval2 === exports.IntervalBottom) {
-        return interval1;
-    }
-    else {
-        return [interval1[0] <= interval2[0] ? interval1[0] : 0, interval1[1] >= interval2[1] ? interval1[1] : Infinity];
-    }
-}
-/** Checks whether an abstract value of the positive interval domain satisfies a numeric value. */
-function satisfiesInterval(interval, value) {
-    return interval !== exports.IntervalBottom && interval[0] <= value && value <= interval[1];
-}
-/** Checks whether a numeric value satisfies the less-than relation with an abstract value of the positive interval domain. */
-function satisfiesLeqInterval(interval, value) {
-    return interval !== exports.IntervalBottom && value <= interval[1];
-}
-/** Checks if two abstract values of the data frame shape domain are equal. */
-function equalDataFrameDomain(value1, value2) {
-    return value1 === value2 || (equalColNames(value1.colnames, value2.colnames) && equalInterval(value1.cols, value2.cols) && equalInterval(value1.rows, value2.rows));
-}
-/** Joins multiple abstract values of the data frame shape domain by creating the least upper bound (LUB). */
-function joinDataFrames(...values) {
-    let result = values[0] ?? exports.DataFrameTop;
-    for (let i = 1; i < values.length; i++) {
-        result = {
-            colnames: joinColNames(result.colnames, values[i].colnames),
-            cols: joinInterval(result.cols, values[i].cols),
-            rows: joinInterval(result.rows, values[i].rows)
-        };
-    }
-    return result;
-}
-/** Meets multiple abstract values of the data frame shape domain by creating the greatest lower bound (GLB). */
-function meetDataFrames(...values) {
-    let result = values[0] ?? exports.DataFrameTop;
-    for (let i = 1; i < values.length; i++) {
-        result = {
-            colnames: meetColNames(result.colnames, values[i].colnames),
-            cols: meetInterval(result.cols, values[i].cols),
-            rows: meetInterval(result.rows, values[i].rows)
-        };
-    }
-    return result;
-}
-/** Widens two abstract values of the data frame shape domain by widening the column names and number of columns and rows. */
-function wideningDataFrames(value1, value2) {
-    return {
-        colnames: wideningColNames(value1.colnames, value2.colnames),
-        cols: wideningInterval(value1.cols, value2.cols),
-        rows: wideningInterval(value1.rows, value2.rows)
-    };
-}
-/** Checks if two abstract states of the data frame shape state domain are equal. */
-function equalDataFrameState(state1, state2) {
-    if (state1 === state2) {
-        return true;
-    }
-    else if (state1.size !== state2.size) {
-        return false;
-    }
-    for (const [nodeId, value] of state1) {
-        const other = state2.get(nodeId);
-        if (other === undefined || !equalDataFrameDomain(value, other)) {
-            return false;
-        }
-    }
-    return true;
-}
-/** Joins multiple abstract states of the data frame shape state domain by joining each data frame shape of the states. */
-function joinDataFrameStates(...states) {
-    const result = new Map(states[0]);
-    for (let i = 1; i < states.length; i++) {
-        for (const [nodeId, value] of states[i]) {
-            if (result.has(nodeId)) {
-                result.set(nodeId, joinDataFrames(result.get(nodeId) ?? exports.DataFrameTop, value));
-            }
-            else {
-                result.set(nodeId, value);
-            }
-        }
-    }
-    return result;
-}
-/** Meets multiple abstract states of the data frame shape state domain by meeting each data frame shape of the states. */
-function meetDataFrameStates(...states) {
-    const result = new Map(states[0]);
-    for (let i = 1; i < states.length; i++) {
-        for (const [nodeId, value] of states[i]) {
-            if (result.has(nodeId)) {
-                result.set(nodeId, meetDataFrames(result.get(nodeId) ?? exports.DataFrameTop, value));
-            }
-            else {
-                result.set(nodeId, value);
-            }
-        }
-    }
-    return result;
-}
-/** Widens two abstract states of the data frame shape state domain by widening each data frame shape of the states. */
-function wideningDataFrameStates(state1, state2) {
-    const result = new Map(state1);
-    for (const [nodeId, value] of state2) {
-        if (result.has(nodeId)) {
-            result.set(nodeId, wideningDataFrames(result.get(nodeId) ?? exports.DataFrameTop, value));
-        }
-        else {
-            result.set(nodeId, value);
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=domain.js.map

package/abstract-interpretation/domains/set-bounded-set-domain.d.ts

@@ -1,43 +0,0 @@
-import { type AbstractDomain } from './abstract-domain';
-import { Bottom, Top } from './lattice';
-/** The type of the actual values of the set bounded set domain as set */
-export type SetBoundedSetValue<T> = ReadonlySet<T>;
-/** The type of the Top element of the set bounded set domain as {@link Top} symbol */
-export type SetBoundedSetTop = typeof Top;
-/** The type of the Bottom element of the set bounded set domain as {@link Bottom} */
-export type SetBoundedSetBottom = typeof Bottom;
-/** The type of the abstract values of the set bounded set domain that are Top, Bottom, or actual values */
-export type SetBoundedSetLift<T> = SetBoundedSetValue<T> | SetBoundedSetTop | SetBoundedSetBottom;
-/**
- * The set bounded set abstract domain as sets capturing possible values of the concrete set bounded by a `limit` for the maximum number of inferred values.
- * The Bottom element is defined as the{@link Bottom} and the Top element is defined as {@link Top} symbol.
- * @template T     - Type of the values in the abstract domain
- * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
- */
-export declare class SetBoundedSetDomain<T, Value extends SetBoundedSetLift<T> = SetBoundedSetLift<T>> implements AbstractDomain<ReadonlySet<T>, SetBoundedSetValue<T>, SetBoundedSetTop, SetBoundedSetBottom, Value> {
-    private readonly limit;
-    private _value;
-    constructor(value: Value, limit?: number);
-    get value(): Value;
-    static top<T>(limit?: number): SetBoundedSetDomain<T, SetBoundedSetTop>;
-    static bottom<T>(limit?: number): SetBoundedSetDomain<T, SetBoundedSetBottom>;
-    static abstract<T>(concrete: ReadonlySet<ReadonlySet<T>> | typeof Top, limit?: number): SetBoundedSetDomain<T>;
-    top(): SetBoundedSetDomain<T, SetBoundedSetTop>;
-    bottom(): SetBoundedSetDomain<T, SetBoundedSetBottom>;
-    equals(other: SetBoundedSetDomain<T>): boolean;
-    leq(other: SetBoundedSetDomain<T>): boolean;
-    join(...values: SetBoundedSetDomain<T>[]): SetBoundedSetDomain<T>;
-    meet(...values: SetBoundedSetDomain<T>[]): SetBoundedSetDomain<T>;
-    /**
-     * Subtracts another abstract value from the current abstract value by removing all elements of the other abstract value from the current abstract value.
-     */
-    subtract(other: SetBoundedSetDomain<T>): SetBoundedSetDomain<T>;
-    widen(other: SetBoundedSetDomain<T>): SetBoundedSetDomain<T>;
-    narrow(other: SetBoundedSetDomain<T>): SetBoundedSetDomain<T>;
-    concretize(limit?: number): ReadonlySet<ReadonlySet<T>> | typeof Top;
-    abstract(concrete: ReadonlySet<ReadonlySet<T>> | typeof Top): SetBoundedSetDomain<T>;
-    toString(): string;
-    isTop(): this is SetBoundedSetDomain<T, SetBoundedSetTop>;
-    isBottom(): this is SetBoundedSetDomain<T, SetBoundedSetBottom>;
-    isValue(): this is SetBoundedSetDomain<T, SetBoundedSetValue<T>>;
-}

package/abstract-interpretation/domains/set-bounded-set-domain.js

@@ -1,164 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetBoundedSetDomain = void 0;
-const set_1 = require("../../util/collections/set");
-const abstract_domain_1 = require("./abstract-domain");
-const lattice_1 = require("./lattice");
-/**
- * The set bounded set abstract domain as sets capturing possible values of the concrete set bounded by a `limit` for the maximum number of inferred values.
- * The Bottom element is defined as the{@link Bottom} and the Top element is defined as {@link Top} symbol.
- * @template T     - Type of the values in the abstract domain
- * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
- */
-class SetBoundedSetDomain {
-    limit;
-    _value;
-    constructor(value, limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
-        if (value !== lattice_1.Top && value !== lattice_1.Bottom) {
-            this._value = (value.size > limit ? lattice_1.Top : new Set(value));
-        }
-        else {
-            this._value = value;
-        }
-        this.limit = limit;
-    }
-    get value() {
-        return this._value;
-    }
-    static top(limit) {
-        return new SetBoundedSetDomain(lattice_1.Top, limit);
-    }
-    static bottom(limit) {
-        return new SetBoundedSetDomain(lattice_1.Bottom, limit);
-    }
-    static abstract(concrete, limit) {
-        if (concrete === lattice_1.Top) {
-            return SetBoundedSetDomain.top(limit);
-        }
-        else if (concrete.size === 0) {
-            return SetBoundedSetDomain.bottom(limit);
-        }
-        return new SetBoundedSetDomain(concrete.values().reduce((result, set) => result.union(set)), limit);
-    }
-    top() {
-        return SetBoundedSetDomain.top(this.limit);
-    }
-    bottom() {
-        return SetBoundedSetDomain.bottom(this.limit);
-    }
-    equals(other) {
-        return this.value === other.value || (this.isValue() && other.isValue() && (0, set_1.setEquals)(this.value, other.value));
-    }
-    leq(other) {
-        return this.value === lattice_1.Bottom || other.value === lattice_1.Top || (this.isValue() && other.isValue() && this.value.isSubsetOf(other.value));
-    }
-    join(...values) {
-        const result = new SetBoundedSetDomain(this.value, this.limit);
-        for (const other of values) {
-            if (result.value === lattice_1.Top || other.value === lattice_1.Top) {
-                result._value = lattice_1.Top;
-            }
-            else if (result.value === lattice_1.Bottom) {
-                result._value = other.value;
-            }
-            else if (other.value === lattice_1.Bottom) {
-                result._value = result.value;
-            }
-            else {
-                const join = result.value.union(other.value);
-                result._value = join.size > this.limit ? lattice_1.Top : join;
-            }
-        }
-        return result;
-    }
-    meet(...values) {
-        const result = new SetBoundedSetDomain(this.value, this.limit);
-        for (const other of values) {
-            if (result.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
-                result._value = lattice_1.Bottom;
-            }
-            else if (result.value === lattice_1.Top) {
-                result._value = other.value;
-            }
-            else if (other.value === lattice_1.Top) {
-                result._value = result.value;
-            }
-            else {
-                result._value = result.value.intersection(other.value);
-            }
-        }
-        return result;
-    }
-    /**
-     * Subtracts another abstract value from the current abstract value by removing all elements of the other abstract value from the current abstract value.
-     */
-    subtract(other) {
-        if (this.value === lattice_1.Top) {
-            return this.top();
-        }
-        else if (this.value === lattice_1.Bottom) {
-            return this.bottom();
-        }
-        else if (other.value === lattice_1.Top || other.value === lattice_1.Bottom) {
-            return new SetBoundedSetDomain(this.value, this.limit);
-        }
-        else {
-            return new SetBoundedSetDomain(this.value.difference(other.value), this.limit);
-        }
-    }
-    widen(other) {
-        if (this.value === lattice_1.Bottom) {
-            return new SetBoundedSetDomain(other.value, this.limit);
-        }
-        else if (other.value === lattice_1.Bottom) {
-            return new SetBoundedSetDomain(this.value, this.limit);
-        }
-        return other.leq(this) ? new SetBoundedSetDomain(this.value, this.limit) : this.top();
-    }
-    narrow(other) {
-        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
-            return this.bottom();
-        }
-        return this.isTop() ? other : this;
-    }
-    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
-        if (this.value === lattice_1.Bottom) {
-            return new Set();
-        }
-        else if (this.value === lattice_1.Top || 2 ** (this.value.size) > limit) {
-            return lattice_1.Top;
-        }
-        const subsets = [new Set()];
-        for (const element of this.value.values()) {
-            const newSubsets = subsets.map(subset => new Set([...subset, element]));
-            for (const subset of newSubsets) {
-                subsets.push(subset);
-            }
-        }
-        return new Set(subsets);
-    }
-    abstract(concrete) {
-        return SetBoundedSetDomain.abstract(concrete, this.limit);
-    }
-    toString() {
-        if (this.value === lattice_1.Top) {
-            return '⊤';
-        }
-        else if (this.value === lattice_1.Bottom) {
-            return '⊥';
-        }
-        const string = this.value.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
-        return `{${string}}`;
-    }
-    isTop() {
-        return this.value === lattice_1.Top;
-    }
-    isBottom() {
-        return this.value == lattice_1.Bottom;
-    }
-    isValue() {
-        return this.value !== lattice_1.Top && this.value !== lattice_1.Bottom;
-    }
-}
-exports.SetBoundedSetDomain = SetBoundedSetDomain;
-//# sourceMappingURL=set-bounded-set-domain.js.map

package/cli/repl/commands/repl-lineage.d.ts

@@ -1,15 +0,0 @@
-import type { ReplCodeCommand } from './repl-main';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
-import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { DataflowGraph } from '../../../dataflow/graph/graph';
-import type { AstIdMap } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-/**
- * Get the lineage of a node in the dataflow graph
- *
- * @param criterion - The criterion to get the lineage of
- * @param graph - The dataflow graph to search in
- * @param idMap - The ID map to use for resolving the criterion (will default to that shipped with the dfgraph)
- * @returns The lineage of the node represented as a set of node ids
- */
-export declare function getLineage(criterion: SingleSlicingCriterion, graph: DataflowGraph, idMap?: AstIdMap): Set<NodeId>;
-export declare const lineageCommand: ReplCodeCommand;