@eagleoutice/flowr 2.6.1 → 2.6.3

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

@@ -1,4 +1,4 @@
-import type { Bottom, Lattice, Top } from './lattice';
+import { type Lattice, Top } from './lattice';
 /**
  * The default limit of inferred constraints in {@link AbstractDomain|AbstractDomains}.
  */
@@ -6,51 +6,92 @@ export declare const DEFAULT_INFERENCE_LIMIT = 50;
 /**
  * An abstract domain as complete lattice with a widening operator, narrowing operator, concretization function, and abstraction function.
  * @template Concrete - Type of an concrete element of the concrete domain for the abstract domain
- * @template Abstract - Type of an abstract element of the abstract domain representing possible elements (may exclude `Top` and `Bot`)
- * @template Top      - Type of the Top element of the abstract domain representing all possible elements (defaults to {@link Top})
- * @template Bot      - Type of the Bottom element of the abstract domain representing no possible elements (defaults to {@link Bottom})
- * @template Lift     - Type of the abstract elements of the abstract domain (defaults to `Abstract` or `Top` or `Bot`)
+ * @template Abstract - Type of an abstract element of the abstract domain representing possible elements (excludes `Top` and `Bot`)
+ * @template Top      - Type of the Top element of the abstract domain representing all possible elements
+ * @template Bot      - Type of the Bottom element of the abstract domain representing no possible elements
+ * @template Value    - Type of the abstract elements of the abstract domain (defaults to `Abstract` or `Top` or `Bot`)
  */
-export interface AbstractDomain<Concrete, Abstract, Top = typeof Top, Bot = typeof Bottom, Lift extends Abstract | Top | Bot = Abstract | Top | Bot> extends Lattice<Abstract, Top, Bot, Lift> {
+export declare abstract class AbstractDomain<Concrete, Abstract, Top, Bot, Value extends Abstract | Top | Bot = Abstract | Top | Bot> implements Lattice<Abstract, Top, Bot, Value> {
+    protected readonly _value: Value;
+    constructor(value: Value);
+    get value(): Value;
+    abstract create(value: Abstract | Top | Bot): this;
+    abstract top(): this & AbstractDomain<Concrete, Abstract, Top, Bot, Top>;
+    abstract bottom(): this & AbstractDomain<Concrete, Abstract, Top, Bot, Bot>;
+    abstract equals(other: this): boolean;
+    abstract leq(other: this): boolean;
+    abstract join(other: this): this;
+    /**
+     * Joins the current abstract value with multiple other abstract values.
+     */
+    joinAll(values: readonly this[]): this;
+    abstract meet(other: this): this;
+    /**
+     * Meets the current abstract value with multiple other abstract values.
+     */
+    meetAll(values: readonly this[]): this;
     /**
      * Widens the current abstract value with another abstract value as a sound over-approximation of the join (least upper bound) for fixpoint iteration acceleration.
      */
-    widen(other: AbstractDomain<Concrete, Abstract, Top, Bot>): AbstractDomain<Concrete, Abstract, Top, Bot>;
+    abstract widen(other: this): this;
     /**
      * Narrows the current abstract value with another abstract value as a sound over-approximation of the meet (greatest lower bound) to refine the value after widening.
      */
-    narrow(other: AbstractDomain<Concrete, Abstract, Top, Bot>): AbstractDomain<Concrete, Abstract, Top, Bot>;
+    abstract narrow(other: this): this;
     /**
      * Maps the current abstract value into a set of possible concrete values as concretization function of the abstract domain.
      * The result should be `Top` if the number of concrete values would reach the `limit` or the resulting set would have infinite many elements.
      */
-    concretize(limit?: number): ReadonlySet<Concrete> | typeof Top;
+    abstract concretize(limit: number): ReadonlySet<Concrete> | typeof Top;
     /**
      * Maps a set of possible concrete values into an abstract value as abstraction function of the abstract domain (should additionally be provided as static function).
      */
-    abstract(concrete: ReadonlySet<Concrete> | typeof Top): AbstractDomain<Concrete, Abstract, Top, Bot>;
+    abstract abstract(concrete: ReadonlySet<Concrete> | typeof Top): this;
+    abstract toJson(): unknown;
+    abstract toString(): string;
+    abstract isTop(): this is AbstractDomain<Concrete, Abstract, Top, Bot, Top>;
+    abstract isBottom(): this is AbstractDomain<Concrete, Abstract, Top, Bot, Bot>;
+    abstract isValue(): this is AbstractDomain<Concrete, Abstract, Top, Bot, Abstract>;
+    /**
+     * Joins an array of abstract values by joining the first abstract value with the other values in the array.
+     * The provided array of abstract values cannot be empty!
+     */
+    static joinAll<Domain extends AnyAbstractDomain>(values: Domain[]): Domain;
+    /**
+     * Meets an array of abstract values by meeting the first abstract value with the other values in the array.
+     * The provided array of abstract values cannot be empty!
+     */
+    static meetAll<Domain extends AnyAbstractDomain>(values: Domain[]): Domain;
 }
+/**
+ * A type representing any abstract domain without additional information.
+ */
+export type AnyAbstractDomain = AbstractDomain<unknown, unknown, unknown, unknown>;
 /**
  * The type of the concrete domain of an abstract domain.
  * @template Domain - The abstract domain to get the concrete domain type for
  */
-export type ConcreteDomain<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<infer Concrete, unknown, unknown, unknown> ? Concrete : never;
+export type ConcreteDomain<Domain extends AnyAbstractDomain> = Domain extends AbstractDomain<infer Concrete, unknown, unknown, unknown> ? Concrete : never;
+/**
+ * The type of the abstract values of an abstract domain (including the Top and Bottom element).
+ * @template Domain - The abstract domain to get the abstract value type for
+ */
+export type AbstractDomainValue<Domain extends AnyAbstractDomain> = Domain extends AbstractDomain<unknown, infer Value, infer Top, infer Bot> ? Value | Top | Bot : never;
 /**
  * The type of the Top element (greatest element) of an abstract domain.
  * @template Domain - The abstract domain to get the Top element type for
  */
-export type AbstractDomainTop<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<unknown, unknown, infer Top, unknown> ? Top : never;
+export type AbstractDomainTop<Domain extends AnyAbstractDomain> = Domain extends AbstractDomain<unknown, unknown, infer Top, unknown> ? Top : never;
 /**
  * The type of the Bottom element (least element) of an abstract domain.
  * @template Domain - The abstract domain to get the Bottom element type for
  */
-export type AbstractDomainBottom<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<unknown, unknown, unknown, infer Bot> ? Bot : never;
+export type AbstractDomainBottom<Domain extends AnyAbstractDomain> = Domain extends AbstractDomain<unknown, unknown, unknown, infer Bot> ? Bot : never;
 /**
- * The type of the abstract values of an abstract domain (including the Top and Bottom element).
- * @template Domain - The abstract domain to get the abstract value type for
+ * Converts an element of an abstract domain into a string.
  */
-export type AbstractDomainValue<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Domain extends AbstractDomain<unknown, infer Value, infer Top, infer Bot> ? Value | Top | Bot : never;
+export declare function domainElementToString(value: AnyAbstractDomain | unknown): string;
 /**
- * Converts an element of an abstract domain into a string.
+ *
  */
-export declare function domainElementToString(value: AbstractDomain<unknown, unknown, unknown, unknown> | unknown): string;
+export declare function isAbstractDomain(value: unknown): value is AnyAbstractDomain;

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

@@ -1,11 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_INFERENCE_LIMIT = void 0;
+exports.AbstractDomain = exports.DEFAULT_INFERENCE_LIMIT = void 0;
 exports.domainElementToString = domainElementToString;
+exports.isAbstractDomain = isAbstractDomain;
+const assert_1 = require("../../util/assert");
+const lattice_1 = require("./lattice");
 /**
  * The default limit of inferred constraints in {@link AbstractDomain|AbstractDomains}.
  */
 exports.DEFAULT_INFERENCE_LIMIT = 50;
+/**
+ * An abstract domain as complete lattice with a widening operator, narrowing operator, concretization function, and abstraction function.
+ * @template Concrete - Type of an concrete element of the concrete domain for the abstract domain
+ * @template Abstract - Type of an abstract element of the abstract domain representing possible elements (excludes `Top` and `Bot`)
+ * @template Top      - Type of the Top element of the abstract domain representing all possible elements
+ * @template Bot      - Type of the Bottom element of the abstract domain representing no possible elements
+ * @template Value    - Type of the abstract elements of the abstract domain (defaults to `Abstract` or `Top` or `Bot`)
+ */
+class AbstractDomain {
+    _value;
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    ;
+    /**
+     * Joins the current abstract value with multiple other abstract values.
+     */
+    joinAll(values) {
+        let result = this.create(this.value);
+        for (const other of values) {
+            result = result.join(other);
+        }
+        return result;
+    }
+    /**
+     * Meets the current abstract value with multiple other abstract values.
+     */
+    meetAll(values) {
+        let result = this.create(this.value);
+        for (const other of values) {
+            result = result.meet(other);
+        }
+        return result;
+    }
+    /**
+     * Joins an array of abstract values by joining the first abstract value with the other values in the array.
+     * The provided array of abstract values cannot be empty!
+     */
+    static joinAll(values) {
+        (0, assert_1.guard)(values.length > 0, 'Abstract values to join cannot be empty');
+        return values[0].joinAll(values.slice(1));
+    }
+    /**
+     * Meets an array of abstract values by meeting the first abstract value with the other values in the array.
+     * The provided array of abstract values cannot be empty!
+     */
+    static meetAll(values) {
+        (0, assert_1.guard)(values.length > 0, 'Abstract values to meet cannot be empty');
+        return values[0].meetAll(values.slice(1));
+    }
+}
+exports.AbstractDomain = AbstractDomain;
 /**
  * Converts an element of an abstract domain into a string.
  */
@@ -14,6 +72,21 @@ function domainElementToString(value) {
         // eslint-disable-next-line @typescript-eslint/no-base-to-string
         return value.toString();
     }
+    else if (value === lattice_1.Top) {
+        return '⊤';
+    }
+    else if (value === lattice_1.Bottom) {
+        return '⊥';
+    }
     return JSON.stringify(value);
 }
+/**
+ *
+ */
+function isAbstractDomain(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return ['value', 'top', 'bottom', 'leq', 'join', 'meet', 'widen', 'narrow', 'concretize', 'abstract'].every(property => property in value);
+}
 //# sourceMappingURL=abstract-domain.js.map

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

@@ -1,43 +1,56 @@
-import { type AbstractDomain } from './abstract-domain';
+import { Ternary } from '../../util/logic';
+import { AbstractDomain } from './abstract-domain';
 import { Top } from './lattice';
+import type { SatisfiableDomain } from './satisfiable-domain';
+/** The Bottom element of the bounded set domain as empty set */
+export declare const BoundedSetBottom: ReadonlySet<never>;
 /** The type of the actual values of the bounded set domain as set */
-export type BoundedSetValue<T> = ReadonlySet<T>;
+type BoundedSetValue<T> = ReadonlySet<T>;
 /** The type of the Top element of the bounded set domain as {@link Top} symbol */
-export type BoundedSetTop = typeof Top;
+type BoundedSetTop = typeof Top;
 /** The type of the Bottom element of the bounded set domain as empty set */
-export type BoundedSetBottom = ReadonlySet<never>;
+type BoundedSetBottom = typeof BoundedSetBottom;
 /** The type of the abstract values of the bounded set domain that are Top, Bottom, or actual values */
-export type BoundedSetLift<T> = BoundedSetValue<T> | BoundedSetTop | BoundedSetBottom;
+type BoundedSetLift<T> = BoundedSetValue<T> | BoundedSetTop | BoundedSetBottom;
 /**
  * The bounded set abstract domain as sets of possible values bounded by a `limit` indicating the maximum number of inferred values.
  * The Bottom element is defined as the empty set 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 BoundedSetDomain<T, Value extends BoundedSetLift<T> = BoundedSetLift<T>> implements AbstractDomain<T, BoundedSetValue<T>, BoundedSetTop, BoundedSetBottom, Value> {
-    private readonly limit;
-    private _value;
-    constructor(value: Value, limit?: number);
-    get value(): Value;
-    static top<T>(limit?: number): BoundedSetDomain<T, BoundedSetTop>;
-    static bottom<T>(limit?: number): BoundedSetDomain<T, BoundedSetBottom>;
-    static abstract<T>(concrete: ReadonlySet<T> | typeof Top, limit?: number): BoundedSetDomain<T>;
-    top(): BoundedSetDomain<T, BoundedSetTop>;
-    bottom(): BoundedSetDomain<T, BoundedSetBottom>;
-    equals(other: BoundedSetDomain<T>): boolean;
-    leq(other: BoundedSetDomain<T>): boolean;
-    join(...values: BoundedSetDomain<T>[]): BoundedSetDomain<T>;
-    meet(...values: BoundedSetDomain<T>[]): BoundedSetDomain<T>;
+export declare class BoundedSetDomain<T, Value extends BoundedSetLift<T> = BoundedSetLift<T>> extends AbstractDomain<T, BoundedSetValue<T>, BoundedSetTop, BoundedSetBottom, Value> implements SatisfiableDomain<T> {
+    readonly limit: number;
+    private readonly setType;
+    /**
+     * @param limit   - A limit for the maximum number of elements to store in the set
+     * @param setType - An optional set constructor for the domain elements if the type `T` is not storable in a HashSet
+     */
+    constructor(value: Value | T[], limit?: number, setType?: typeof Set<T>);
+    create(value: BoundedSetLift<T> | T[]): this;
+    static top<T>(limit?: number, setType?: typeof Set<T>): BoundedSetDomain<T, BoundedSetTop>;
+    static bottom<T>(limit?: number, setType?: typeof Set<T>): BoundedSetDomain<T, BoundedSetBottom>;
+    static abstract<T>(concrete: ReadonlySet<T> | typeof Top, limit?: number, setType?: typeof Set<T>): BoundedSetDomain<T>;
+    top(): this & BoundedSetDomain<T, BoundedSetTop>;
+    bottom(): this & BoundedSetDomain<T, BoundedSetBottom>;
+    equals(other: this): boolean;
+    leq(other: this): boolean;
+    join(other: this): this;
+    join(other: BoundedSetLift<T> | T[]): this;
+    meet(other: this): this;
+    meet(other: BoundedSetLift<T> | T[]): this;
     /**
      * 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: BoundedSetDomain<T>): BoundedSetDomain<T>;
-    widen(other: BoundedSetDomain<T>): BoundedSetDomain<T>;
-    narrow(other: BoundedSetDomain<T>): BoundedSetDomain<T>;
-    concretize(limit?: number): ReadonlySet<T> | typeof Top;
-    abstract(concrete: ReadonlySet<T> | typeof Top): BoundedSetDomain<T>;
+    subtract(other: this | BoundedSetLift<T> | T[]): this;
+    widen(other: this): this;
+    narrow(other: this): this;
+    concretize(limit: number): ReadonlySet<T> | typeof Top;
+    abstract(concrete: ReadonlySet<T> | typeof Top): this;
+    satisfies(value: T): Ternary;
+    toJson(): unknown;
     toString(): string;
     isTop(): this is BoundedSetDomain<T, BoundedSetTop>;
     isBottom(): this is BoundedSetDomain<T, BoundedSetBottom>;
     isValue(): this is BoundedSetDomain<T, BoundedSetValue<T>>;
 }
+export {};

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

@@ -1,44 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BoundedSetDomain = void 0;
+exports.BoundedSetDomain = exports.BoundedSetBottom = void 0;
 const set_1 = require("../../util/collections/set");
+const logic_1 = require("../../util/logic");
 const abstract_domain_1 = require("./abstract-domain");
 const lattice_1 = require("./lattice");
+/* eslint-disable @typescript-eslint/unified-signatures */
+/** The Bottom element of the bounded set domain as empty set */
+exports.BoundedSetBottom = new Set();
 /**
  * The bounded set abstract domain as sets of possible values bounded by a `limit` indicating the maximum number of inferred values.
  * The Bottom element is defined as the empty set 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 BoundedSetDomain {
+class BoundedSetDomain extends abstract_domain_1.AbstractDomain {
     limit;
-    _value;
-    constructor(value, limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+    setType;
+    /**
+     * @param limit   - A limit for the maximum number of elements to store in the set
+     * @param setType - An optional set constructor for the domain elements if the type `T` is not storable in a HashSet
+     */
+    constructor(value, limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT, setType = Set) {
         if (value !== lattice_1.Top) {
-            this._value = (value.size > limit ? lattice_1.Top : new Set(value));
+            if (Array.isArray(value)) {
+                super((value.length > limit ? lattice_1.Top : new setType(value)));
+            }
+            else {
+                super((value.size > limit ? lattice_1.Top : new setType(value)));
+            }
         }
         else {
-            this._value = value;
+            super(value);
         }
         this.limit = limit;
+        this.setType = setType;
     }
-    get value() {
-        return this._value;
+    create(value) {
+        return new BoundedSetDomain(value, this.limit, this.setType);
     }
-    static top(limit) {
-        return new BoundedSetDomain(lattice_1.Top, limit);
+    static top(limit, setType) {
+        return new BoundedSetDomain(lattice_1.Top, limit, setType);
     }
-    static bottom(limit) {
-        return new BoundedSetDomain(new Set(), limit);
+    static bottom(limit, setType) {
+        return new BoundedSetDomain(exports.BoundedSetBottom, limit, setType);
     }
-    static abstract(concrete, limit) {
-        return new BoundedSetDomain(concrete, limit);
+    static abstract(concrete, limit, setType) {
+        return new BoundedSetDomain(concrete, limit, setType);
     }
     top() {
-        return BoundedSetDomain.top(this.limit);
+        return BoundedSetDomain.top(this.limit, this.setType);
     }
     bottom() {
-        return BoundedSetDomain.bottom(this.limit);
+        return BoundedSetDomain.bottom(this.limit, this.setType);
     }
     equals(other) {
         return this.value === other.value || (this.isValue() && other.isValue() && (0, set_1.setEquals)(this.value, other.value));
@@ -46,59 +60,68 @@ class BoundedSetDomain {
     leq(other) {
         return other.value === lattice_1.Top || (this.isValue() && this.value.isSubsetOf(other.value));
     }
-    join(...values) {
-        const result = new BoundedSetDomain(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 {
-                const join = result.value.union(other.value);
-                result._value = join.size > this.limit ? lattice_1.Top : join;
-            }
+    join(other) {
+        const otherValue = other instanceof BoundedSetDomain ? other.value : Array.isArray(other) ? new this.setType(other) : other;
+        if (this.value === lattice_1.Top || otherValue === lattice_1.Top) {
+            return this.top();
+        }
+        else {
+            return this.create(this.value.union(otherValue));
         }
-        return result;
     }
-    meet(...values) {
-        const result = new BoundedSetDomain(this.value, this.limit);
-        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 {
-                result._value = result.value.intersection(other.value);
-            }
+    meet(other) {
+        const otherValue = other instanceof BoundedSetDomain ? other.value : Array.isArray(other) ? new this.setType(other) : other;
+        if (this.value === lattice_1.Top) {
+            return this.create(otherValue);
+        }
+        else if (otherValue === lattice_1.Top) {
+            return this.create(this.value);
+        }
+        else {
+            return this.create(this.value.intersection(otherValue));
         }
-        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) {
+        const otherValue = other instanceof BoundedSetDomain ? other.value : Array.isArray(other) ? new this.setType(other) : other;
         if (this.value === lattice_1.Top) {
             return this.top();
         }
-        else if (other.value === lattice_1.Top) {
-            return new BoundedSetDomain(this.value, this.limit);
+        else if (otherValue === lattice_1.Top) {
+            return this.create(this.value);
         }
         else {
-            return new BoundedSetDomain(this.value.difference(other.value), this.limit);
+            return this.create(this.value.difference(otherValue));
         }
     }
     widen(other) {
-        return other.leq(this) ? new BoundedSetDomain(this.value, this.limit) : this.top();
+        return other.leq(this) ? this.create(this.value) : this.top();
     }
     narrow(other) {
-        return this.isTop() ? other : this;
+        return this.isTop() ? this.create(other.value) : this.create(this.value);
     }
-    concretize(limit = this.limit) {
+    concretize(limit) {
         return this.value === lattice_1.Top || this.value.size > limit ? lattice_1.Top : this.value;
     }
     abstract(concrete) {
-        return BoundedSetDomain.abstract(concrete, this.limit);
+        return BoundedSetDomain.abstract(concrete, this.limit, this.setType);
+    }
+    satisfies(value) {
+        if (this.isValue() && this.value.has(value)) {
+            return this.value.size === 1 ? logic_1.Ternary.Always : logic_1.Ternary.Maybe;
+        }
+        else if (this.isTop()) {
+            return logic_1.Ternary.Maybe;
+        }
+        return logic_1.Ternary.Never;
+    }
+    toJson() {
+        if (this.value === lattice_1.Top) {
+            return this.value.description;
+        }
+        return this.value.values().toArray();
     }
     toString() {
         if (this.value === lattice_1.Top) {

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

@@ -1,61 +1,69 @@
-import { type AbstractDomain } from './abstract-domain';
+import { Ternary } from '../../util/logic';
+import { AbstractDomain } from './abstract-domain';
 import { Bottom, Top } from './lattice';
+import { type SatisfiableDomain, NumericalComparator } from './satisfiable-domain';
+/** The Top element of the interval domain as interval [-∞, +∞] */
+export declare const IntervalTop: IntervalValue;
 /** The type of the actual values of the interval domain as tuple of the lower and upper bound */
-export type IntervalValue = readonly [number, number];
-/** The type of the Top element of the interval domain as interval [-∞, +∞] from -∞ to +∞ */
-export type IntervalTop = readonly [typeof Infinity, typeof Infinity];
+type IntervalValue = readonly [lower: number, upper: number];
+/** The type of the Top element of the interval domain as interval [-∞, +∞] */
+type IntervalTop = typeof IntervalTop;
 /** The type of the Bottom element of the interval domain as {@link Bottom} symbol */
-export type IntervalBottom = typeof Bottom;
+type IntervalBottom = typeof Bottom;
 /** The type of the abstract values of the interval domain that are Top, Bottom, or actual values */
-export type IntervalLift = IntervalValue | IntervalTop | IntervalBottom;
+type IntervalLift = IntervalValue | IntervalBottom;
 /**
  * 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)
  */
-export declare class IntervalDomain<Value extends IntervalLift = IntervalLift> implements AbstractDomain<number, IntervalValue, IntervalTop, IntervalBottom, Value> {
-    private _value;
+export declare class IntervalDomain<Value extends IntervalLift = IntervalLift> extends AbstractDomain<number, IntervalValue, IntervalTop, IntervalBottom, Value> implements SatisfiableDomain<number> {
     constructor(value: Value);
-    get value(): Value;
+    create(value: IntervalLift): this;
     static top(): IntervalDomain<IntervalTop>;
     static bottom(): IntervalDomain<IntervalBottom>;
     static abstract(concrete: ReadonlySet<number> | typeof Top): IntervalDomain;
-    top(): IntervalDomain<IntervalTop>;
-    bottom(): IntervalDomain<IntervalBottom>;
-    equals(other: IntervalDomain): boolean;
-    leq(other: IntervalDomain): boolean;
-    join(...values: IntervalDomain[]): IntervalDomain;
-    meet(...values: IntervalDomain[]): IntervalDomain;
-    widen(other: IntervalDomain): IntervalDomain;
-    narrow(other: IntervalDomain): IntervalDomain;
-    concretize(limit?: number): ReadonlySet<number> | typeof Top;
-    abstract(concrete: ReadonlySet<number> | typeof Top): IntervalDomain;
+    top(): this & IntervalDomain<IntervalTop>;
+    bottom(): this & IntervalDomain<IntervalBottom>;
+    equals(other: this): boolean;
+    leq(other: this): boolean;
+    join(other: this): this;
+    join(other: IntervalLift): this;
+    meet(other: this): this;
+    meet(other: IntervalLift): this;
+    widen(other: this): this;
+    narrow(other: this): this;
+    concretize(limit: number): ReadonlySet<number> | typeof Top;
+    abstract(concrete: ReadonlySet<number> | typeof Top): this;
+    satisfies(value: number, comparator?: NumericalComparator): Ternary;
     /**
      * Adds another abstract value to the current abstract value by adding the two lower and upper bounds, respectively.
      */
-    add(other: IntervalDomain): IntervalDomain;
+    add(other: this | IntervalLift): this;
     /**
      * Subtracts another abstract value from the current abstract value by subtracting the two lower and upper bounds from each other, respectively.
      */
-    subtract(other: IntervalDomain): IntervalDomain;
+    subtract(other: this | IntervalLift): this;
     /**
      * 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: IntervalDomain): IntervalDomain;
+    min(other: this | IntervalLift): this;
     /**
      * 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: IntervalDomain): IntervalDomain;
+    max(other: this | IntervalLift): this;
     /**
      * Extends the lower bound of the current abstract value down to -∞.
      */
-    extendDown(): IntervalDomain;
+    extendDown(): this;
     /**
      * Extends the upper bound of the current abstract value up to +∞.
      */
-    extendUp(): IntervalDomain;
+    extendUp(): this;
+    toJson(): unknown;
     toString(): string;
     isTop(): this is IntervalDomain<IntervalTop>;
     isBottom(): this is IntervalDomain<IntervalBottom>;
     isValue(): this is IntervalDomain<IntervalValue>;
 }
+export {};