@eagleoutice/flowr 2.4.5 → 2.4.7

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

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntervalDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * The interval abstract domain as intervals with possibly infinite bounds representing possible numeric values.
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as the interval [-∞, +∞].
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+class IntervalDomain {
+    _value;
+    constructor(value) {
+        if (Array.isArray(value)) {
+            if (value.some(isNaN) || value[0] > value[1] || value[0] === +Infinity || value[1] === -Infinity) {
+                this._value = lattice_1.Bottom;
+            }
+            else {
+                this._value = [value[0], value[1]];
+            }
+        }
+        else {
+            this._value = value;
+        }
+    }
+    get value() {
+        return this._value;
+    }
+    static top() {
+        return new IntervalDomain([-Infinity, +Infinity]);
+    }
+    static bottom() {
+        return new IntervalDomain(lattice_1.Bottom);
+    }
+    static abstract(concrete) {
+        if (concrete === lattice_1.Top) {
+            return IntervalDomain.top();
+        }
+        else if (concrete.size === 0 || concrete.values().some(isNaN)) {
+            return IntervalDomain.bottom();
+        }
+        return new IntervalDomain([Math.min(...concrete), Math.max(...concrete)]);
+    }
+    top() {
+        return IntervalDomain.top();
+    }
+    bottom() {
+        return IntervalDomain.bottom();
+    }
+    equals(other) {
+        return this.value === other.value || (this.isValue() && other.isValue() && this.value[0] === other.value[0] && this.value[1] === other.value[1]);
+    }
+    leq(other) {
+        return this.value === lattice_1.Bottom || (other.isValue() && other.value[0] <= this.value[0] && this.value[1] <= other.value[1]);
+    }
+    join(...values) {
+        const result = new IntervalDomain(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 {
+                result._value = [Math.min(result.value[0], other.value[0]), Math.max(result.value[1], other.value[1])];
+            }
+        }
+        return result;
+    }
+    meet(...values) {
+        const result = new IntervalDomain(this.value);
+        for (const other of values) {
+            if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+                result._value = lattice_1.Bottom;
+            }
+            else if (Math.max(this.value[0], other.value[0]) > Math.min(this.value[1], other.value[1])) {
+                result._value = lattice_1.Bottom;
+            }
+            else {
+                result._value = [Math.max(this.value[0], other.value[0]), Math.min(this.value[1], other.value[1])];
+            }
+        }
+        return result;
+    }
+    widen(other) {
+        if (this.value === lattice_1.Bottom) {
+            return new IntervalDomain(other.value);
+        }
+        else if (other.value === lattice_1.Bottom) {
+            return new IntervalDomain(this.value);
+        }
+        else {
+            return new IntervalDomain([
+                this.value[0] <= other.value[0] ? this.value[0] : -Infinity,
+                this.value[1] >= other.value[1] ? this.value[1] : +Infinity
+            ]);
+        }
+    }
+    narrow(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        return new IntervalDomain([
+            this.value[0] === -Infinity ? other.value[0] : this.value[0],
+            this.value[1] === +Infinity ? other.value[1] : this.value[1]
+        ]);
+    }
+    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+        if (this.value === lattice_1.Bottom) {
+            return new Set();
+        }
+        else if (!isFinite(this.value[0]) || !isFinite(this.value[1]) || this.value[1] - this.value[0] + 1 > limit) {
+            return lattice_1.Top;
+        }
+        const set = new Set();
+        for (let x = this.value[0]; x <= this.value[1]; x++) {
+            set.add(x);
+        }
+        return set;
+    }
+    abstract(concrete) {
+        return IntervalDomain.abstract(concrete);
+    }
+    /**
+     * Adds another abstract value to the current abstract value by adding the two lower and upper bounds, respectively.
+     */
+    add(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return new IntervalDomain([this.value[0] + other.value[0], this.value[1] + other.value[1]]);
+        }
+    }
+    /**
+     * Subtracts another abstract value from the current abstract value by subtracting the two lower and upper bounds from each other, respectively.
+     */
+    subtract(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return new IntervalDomain([this.value[0] - other.value[0], this.value[1] - other.value[1]]);
+        }
+    }
+    /**
+     * Creates the minimum between the current abstract value and another abstract value by creating the minimum of the two lower and upper bounds, respectively.
+     */
+    min(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return new IntervalDomain([Math.min(this.value[0], other.value[0]), Math.min(this.value[1], other.value[1])]);
+        }
+    }
+    /**
+     * Creates the maximum between the current abstract value and another abstract value by creating the maximum of the two lower and upper bounds, respectively.
+     */
+    max(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return new IntervalDomain([Math.max(this.value[0], other.value[0]), Math.max(this.value[1], other.value[1])]);
+        }
+    }
+    /**
+     * Extends the lower bound of the current abstract value down to -∞.
+     */
+    extendDown() {
+        if (this.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return new IntervalDomain([-Infinity, this.value[1]]);
+        }
+    }
+    /**
+     * Extends the upper bound of the current abstract value up to +∞.
+     */
+    extendUp() {
+        if (this.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return new IntervalDomain([this.value[0], +Infinity]);
+        }
+    }
+    toString() {
+        if (this.value === lattice_1.Bottom) {
+            return '⊥';
+        }
+        return `[${isFinite(this.value[0]) ? this.value[0] : '-∞'}, ${isFinite(this.value[1]) ? this.value[1] : '+∞'}]`;
+    }
+    isTop() {
+        return this.value !== lattice_1.Bottom && this.value[0] === -Infinity && this.value[1] === +Infinity;
+    }
+    isBottom() {
+        return this.value === lattice_1.Bottom;
+    }
+    isValue() {
+        return this.value !== lattice_1.Bottom;
+    }
+}
+exports.IntervalDomain = IntervalDomain;
+//# sourceMappingURL=interval-domain.js.map

package/abstract-interpretation/domains/lattice.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The Top symbol to represent the Top element of complete lattices (e.g. of abstract domains).
+ */
+export declare const Top: unique symbol;
+/**
+ * The Bottom symbol to represent the Bottom element of complete lattices (e.g. of abstract domains).
+ */
+export declare const Bottom: unique symbol;
+/**
+ * A complete lattice with a partially ordered set, join operator (LUB), meet operator (GLB), top element, and bottom element (e.g. for abstract domains).
+ * @template Value - Type of a lattice element representing a value (may exclude `Top` and `Bot`)
+ * @template Top   - Type of the Top element (greatest element) of the complete lattice (defaults to {@link Top})
+ * @template Bot   - Type of the Bottom element (least element) of the complete lattice (defaults to {@link Bottom})
+ * @template Lift  - Type of the lattice elements (defaults to `Value` or `Top` or `Bot`)
+ */
+export interface Lattice<Value, Top = typeof Top, Bot = typeof Bottom, Lift extends Value | Top | Bot = Value | Top | Bot> {
+    /**
+     * The current abstract value of the lattice.
+     */
+    get value(): Lift;
+    /**
+     * Gets the Top element (greatest element) of the complete lattice (should additionally be provided as static function).
+     */
+    top(): Lattice<Value, Top, Bot, Top>;
+    /**
+     * Gets the Bottom element (least element) of the complete lattice (should additionally be provided as static function).
+     */
+    bottom(): Lattice<Value, Top, Bot, Bot>;
+    /**
+     * Checks whether the current abstract value equals to another abstract value.
+     */
+    equals(other: Lattice<Value, Top, Bot>): boolean;
+    /**
+     * Checks whether the current abstract value is less than or equal to another abstract value with respect to the partial order of the lattice.
+     */
+    leq(other: Lattice<Value, Top, Bot>): boolean;
+    /**
+     * Joins the current abstract value with other abstract values by creating the least upper bound (LUB) in the lattice.
+     */
+    join(...values: Lattice<Value, Top, Bot>[]): Lattice<Value, Top, Bot>;
+    /**
+     * Meets the current abstract value with other abstract values by creating the greatest lower bound (GLB) in the lattice.
+     */
+    meet(...values: Lattice<Value, Top, Bot>[]): Lattice<Value, Top, Bot>;
+    /**
+     * Converts the lattice into a human-readable string.
+     */
+    toString(): string;
+    /**
+     * Checks whether the current abstract value is the Top element of the complete lattice.
+     */
+    isTop(): this is Lattice<Value, Top, Bot, Top>;
+    /**
+     * Checks whether the current abstract value is the Bottom element of the complete lattice.
+     */
+    isBottom(): this is Lattice<Value, Top, Bot, Bot>;
+    /**
+     * Checks whether the current abstract value is an actual value of the complete lattice
+     * (this may include the Top or Bottom element if they are also values and no separate symbols, for example).
+     */
+    isValue(): this is Lattice<Value, Top, Bot, Value>;
+}

package/abstract-interpretation/domains/lattice.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bottom = exports.Top = void 0;
+/**
+ * The Top symbol to represent the Top element of complete lattices (e.g. of abstract domains).
+ */
+exports.Top = Symbol('top');
+/**
+ * The Bottom symbol to represent the Bottom element of complete lattices (e.g. of abstract domains).
+ */
+exports.Bottom = Symbol('bottom');
+//# sourceMappingURL=lattice.js.map

package/abstract-interpretation/domains/positive-interval-domain.d.ts

@@ -0,0 +1,32 @@
+import { IntervalDomain } from './interval-domain';
+import { Bottom, Top } from './lattice';
+/** The type of the actual values of the positive interval domain as tuple of the lower and upper bound */
+export type PosIntervalValue = readonly [number, number];
+/** The type of the Top element of the positive interval domain as interval [0, +∞] from 0 to +∞ */
+export type PosIntervalTop = readonly [0, typeof Infinity];
+/** The type of the Bottom element of the positive interval domain as {@link Bottom} symbol */
+export type PosIntervalBottom = typeof Bottom;
+/** The type of the abstract values of the positive interval domain that are Top, Bottom, or actual values */
+export type PosIntervalLift = PosIntervalValue | PosIntervalTop | PosIntervalBottom;
+/**
+ * The positive interval abstract domain as positive intervals with possibly zero lower bounds and infinite upper bounds representing possible numeric values.
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as the interval [0, +∞].
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+export declare class PosIntervalDomain<Value extends PosIntervalLift = PosIntervalLift> extends IntervalDomain<Value> {
+    constructor(value: Value);
+    static top(): PosIntervalDomain<PosIntervalTop>;
+    static bottom(): PosIntervalDomain<PosIntervalBottom>;
+    static abstract(concrete: ReadonlySet<number> | typeof Top): PosIntervalDomain;
+    top(): PosIntervalDomain<PosIntervalTop>;
+    bottom(): PosIntervalDomain<PosIntervalBottom>;
+    widen(other: PosIntervalDomain): PosIntervalDomain;
+    narrow(other: PosIntervalDomain): PosIntervalDomain;
+    abstract(concrete: ReadonlySet<number> | typeof Top): PosIntervalDomain;
+    subtract(other: PosIntervalDomain): PosIntervalDomain;
+    /**
+     * Extends the lower bound of the current abstract value down to 0.
+     */
+    extendDown(): PosIntervalDomain;
+    isTop(): this is PosIntervalDomain<PosIntervalTop>;
+}

package/abstract-interpretation/domains/positive-interval-domain.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PosIntervalDomain = void 0;
+const interval_domain_1 = require("./interval-domain");
+const lattice_1 = require("./lattice");
+/**
+ * The positive interval abstract domain as positive intervals with possibly zero lower bounds and infinite upper bounds representing possible numeric values.
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as the interval [0, +∞].
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+class PosIntervalDomain extends interval_domain_1.IntervalDomain {
+    constructor(value) {
+        if (Array.isArray(value) && value[0] < 0) {
+            super(lattice_1.Bottom);
+        }
+        else {
+            super(value);
+        }
+    }
+    static top() {
+        return new PosIntervalDomain([0, +Infinity]);
+    }
+    static bottom() {
+        return new PosIntervalDomain(lattice_1.Bottom);
+    }
+    static abstract(concrete) {
+        if (concrete === lattice_1.Top) {
+            return PosIntervalDomain.top();
+        }
+        else if (concrete.size === 0 || concrete.values().some(value => isNaN(value) || value < 0)) {
+            return PosIntervalDomain.bottom();
+        }
+        return new PosIntervalDomain([Math.min(...concrete), Math.max(...concrete)]);
+    }
+    top() {
+        return PosIntervalDomain.top();
+    }
+    bottom() {
+        return PosIntervalDomain.bottom();
+    }
+    widen(other) {
+        if (this.value === lattice_1.Bottom) {
+            return new PosIntervalDomain(other.value);
+        }
+        else if (other.value === lattice_1.Bottom) {
+            return new PosIntervalDomain(this.value);
+        }
+        else {
+            return new PosIntervalDomain([
+                this.value[0] <= other.value[0] ? this.value[0] : 0,
+                this.value[1] >= other.value[1] ? this.value[1] : +Infinity
+            ]);
+        }
+    }
+    narrow(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return PosIntervalDomain.bottom();
+        }
+        return new PosIntervalDomain([
+            this.value[0] === 0 ? other.value[0] : this.value[0],
+            this.value[1] === +Infinity ? other.value[1] : this.value[1]
+        ]);
+    }
+    abstract(concrete) {
+        return PosIntervalDomain.abstract(concrete);
+    }
+    subtract(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return new PosIntervalDomain([Math.max(this.value[0] - other.value[0], 0), Math.max(this.value[1] - other.value[1], 0)]);
+        }
+    }
+    /**
+     * Extends the lower bound of the current abstract value down to 0.
+     */
+    extendDown() {
+        if (this.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else {
+            return new PosIntervalDomain([0, this.value[1]]);
+        }
+    }
+    isTop() {
+        return this.value !== lattice_1.Bottom && this.value[0] === 0 && this.value[1] !== +Infinity;
+    }
+}
+exports.PosIntervalDomain = PosIntervalDomain;
+//# sourceMappingURL=positive-interval-domain.js.map

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

@@ -0,0 +1,37 @@
+import { type AbstractDomain } from './abstract-domain';
+import { Top } from './lattice';
+/** The type of an abstract product of a product domain mapping named properties of the product to abstract domains */
+export type AbstractProduct = Record<string, AbstractDomain<unknown, unknown, unknown, unknown>>;
+/** The type of the concrete product of an abstract product mapping each property to a concrete value in the respective concrete domain */
+export type ConcreteProduct<Product extends AbstractProduct> = {
+    [Key in keyof Product]: Product[Key] extends AbstractDomain<infer Concrete, unknown, unknown, unknown> ? Concrete : never;
+};
+/**
+ * A product abstract domain as named Cartesian product of sub abstract domains.
+ * The sub abstract domains are represented a record mapping property names to abstract domains.
+ * The Bottom element is defined as mapping every sub abstract domain to Bottom and the Top element is defined as mapping every sub abstract domain to Top.
+ * @template Product - Type of the abstract product of the product domain mapping property names to abstract domains
+ */
+export declare abstract class ProductDomain<Product extends AbstractProduct> implements AbstractDomain<ConcreteProduct<Product>, Product, Product, Product> {
+    private _value;
+    constructor(value: Product);
+    /**
+     * Creates an abstract value of the product domain for a given abstract value.
+     */
+    abstract create(value: Product): ProductDomain<Product>;
+    get value(): Product;
+    bottom(): ProductDomain<Product>;
+    top(): ProductDomain<Product>;
+    equals(other: ProductDomain<Product>): boolean;
+    leq(other: ProductDomain<Product>): boolean;
+    join(...values: ProductDomain<Product>[]): ProductDomain<Product>;
+    meet(...values: ProductDomain<Product>[]): ProductDomain<Product>;
+    widen(other: ProductDomain<Product>): ProductDomain<Product>;
+    narrow(other: ProductDomain<Product>): ProductDomain<Product>;
+    concretize(limit?: number): ReadonlySet<ConcreteProduct<Product>> | typeof Top;
+    abstract(concrete: ReadonlySet<ConcreteProduct<Product>> | typeof Top): ProductDomain<Product>;
+    toString(): string;
+    isTop(): this is ProductDomain<Product>;
+    isBottom(): this is ProductDomain<Product>;
+    isValue(): this is ProductDomain<Product>;
+}

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * A product abstract domain as named Cartesian product of sub abstract domains.
+ * The sub abstract domains are represented a record mapping property names to abstract domains.
+ * The Bottom element is defined as mapping every sub abstract domain to Bottom and the Top element is defined as mapping every sub abstract domain to Top.
+ * @template Product - Type of the abstract product of the product domain mapping property names to abstract domains
+ */
+class ProductDomain {
+    _value;
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    bottom() {
+        const result = this.create(this.value);
+        for (const key in result.value) {
+            result._value[key] = result.value[key].bottom();
+        }
+        return result;
+    }
+    top() {
+        const result = this.create(this.value);
+        for (const key in result.value) {
+            result._value[key] = result.value[key].top();
+        }
+        return result;
+    }
+    equals(other) {
+        if (this.value === other.value) {
+            return true;
+        }
+        for (const key in this.value) {
+            if (!this.value[key].equals(other.value[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    leq(other) {
+        if (this.value === other.value) {
+            return true;
+        }
+        for (const key in this.value) {
+            if (!this.value[key].leq(other.value[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    join(...values) {
+        const result = this.create(this.value);
+        for (const value of values) {
+            for (const key in result.value) {
+                result._value[key] = result.value[key].join(value.value[key]);
+            }
+        }
+        return result;
+    }
+    meet(...values) {
+        const result = this.create(this.value);
+        for (const value of values) {
+            for (const key in result.value) {
+                result._value[key] = result.value[key].meet(value.value[key]);
+            }
+        }
+        return result;
+    }
+    widen(other) {
+        const result = this.create(this.value);
+        for (const key in result.value) {
+            result._value[key] = result.value[key].widen(other.value[key]);
+        }
+        return result;
+    }
+    narrow(other) {
+        const result = this.create(this.value);
+        for (const key in result.value) {
+            result._value[key] = result.value[key].narrow(other.value[key]);
+        }
+        return result;
+    }
+    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+        let result = new Set([{}]);
+        for (const key in this.value) {
+            const concrete = this.value[key].concretize(limit);
+            if (concrete === lattice_1.Top) {
+                return lattice_1.Top;
+            }
+            const newResult = new Set();
+            for (const value of concrete) {
+                for (const entry of result) {
+                    if (newResult.size >= limit) {
+                        return lattice_1.Top;
+                    }
+                    newResult.add({ ...entry, [key]: value });
+                }
+            }
+            result = newResult;
+        }
+        return result;
+    }
+    abstract(concrete) {
+        if (concrete === lattice_1.Top) {
+            return this.top();
+        }
+        const result = this.create(this.value);
+        for (const key in result.value) {
+            const concreteValues = new Set(concrete.values().map(value => value[key]));
+            result._value[key] = result.value[key].abstract(concreteValues);
+        }
+        return result;
+    }
+    toString() {
+        return '(' + Object.entries(this.value).map(([key, value]) => `${key}: ${value.toString()}`).join(', ') + ')';
+    }
+    isTop() {
+        return Object.values(this.value).every(value => value.isTop());
+    }
+    isBottom() {
+        return Object.values(this.value).every(value => value.isBottom());
+    }
+    isValue() {
+        return true;
+    }
+}
+exports.ProductDomain = ProductDomain;
+//# sourceMappingURL=product-domain.js.map

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

@@ -0,0 +1,43 @@
+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>>;
+}