@eagleoutice/flowr 2.6.1 → 2.6.3

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

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PosIntervalDomain = void 0;
+exports.PosIntervalDomain = exports.PosIntervalTop = void 0;
 const interval_domain_1 = require("./interval-domain");
 const lattice_1 = require("./lattice");
+/** The Top element of the positive interval domain as interval [0, +∞] */
+exports.PosIntervalTop = [0, +Infinity];
 /**
  * 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, +∞].
@@ -17,8 +19,11 @@ class PosIntervalDomain extends interval_domain_1.IntervalDomain {
             super(value);
         }
     }
+    create(value) {
+        return new PosIntervalDomain(value);
+    }
     static top() {
-        return new PosIntervalDomain([0, +Infinity]);
+        return new PosIntervalDomain(exports.PosIntervalTop);
     }
     static bottom() {
         return new PosIntervalDomain(lattice_1.Bottom);
@@ -40,13 +45,13 @@ class PosIntervalDomain extends interval_domain_1.IntervalDomain {
     }
     widen(other) {
         if (this.value === lattice_1.Bottom) {
-            return new PosIntervalDomain(other.value);
+            return this.create(other.value);
         }
         else if (other.value === lattice_1.Bottom) {
-            return new PosIntervalDomain(this.value);
+            return this.create(this.value);
         }
         else {
-            return new PosIntervalDomain([
+            return this.create([
                 this.value[0] <= other.value[0] ? this.value[0] : 0,
                 this.value[1] >= other.value[1] ? this.value[1] : +Infinity
             ]);
@@ -54,9 +59,12 @@ class PosIntervalDomain extends interval_domain_1.IntervalDomain {
     }
     narrow(other) {
         if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
-            return PosIntervalDomain.bottom();
+            return this.bottom();
         }
-        return new PosIntervalDomain([
+        else if (Math.max(this.value[0], other.value[0]) > Math.min(this.value[1], other.value[1])) {
+            return this.bottom();
+        }
+        return this.create([
             this.value[0] === 0 ? other.value[0] : this.value[0],
             this.value[1] === +Infinity ? other.value[1] : this.value[1]
         ]);
@@ -65,11 +73,12 @@ class PosIntervalDomain extends interval_domain_1.IntervalDomain {
         return PosIntervalDomain.abstract(concrete);
     }
     subtract(other) {
-        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+        const otherValue = other instanceof PosIntervalDomain ? other.value : other;
+        if (this.value === lattice_1.Bottom || otherValue === 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)]);
+            return this.create([Math.max(this.value[0] - otherValue[0], 0), Math.max(this.value[1] - otherValue[1], 0)]);
         }
     }
     /**
@@ -80,11 +89,11 @@ class PosIntervalDomain extends interval_domain_1.IntervalDomain {
             return this.bottom();
         }
         else {
-            return new PosIntervalDomain([0, this.value[1]]);
+            return this.create([0, this.value[1]]);
         }
     }
     isTop() {
-        return this.value !== lattice_1.Bottom && this.value[0] === 0 && this.value[1] !== +Infinity;
+        return this.value !== lattice_1.Bottom && this.value[0] === 0 && this.value[1] === +Infinity;
     }
 }
 exports.PosIntervalDomain = PosIntervalDomain;

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

@@ -1,7 +1,7 @@
-import { type AbstractDomain } from './abstract-domain';
+import { AbstractDomain, type AnyAbstractDomain } 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>>;
+export type AbstractProduct = Record<string, AnyAbstractDomain>;
 /** 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;
@@ -12,26 +12,21 @@ export type ConcreteProduct<Product extends AbstractProduct> = {
  * 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>;
+export declare abstract class ProductDomain<Product extends AbstractProduct> extends AbstractDomain<ConcreteProduct<Product>, Product, Product, Product> {
+    abstract create(value: Product): this;
+    bottom(): this;
+    top(): this;
+    equals(other: this): boolean;
+    leq(other: this): boolean;
+    join(other: this): this;
+    meet(other: this): this;
+    widen(other: this): this;
+    narrow(other: this): this;
+    concretize(limit: number): ReadonlySet<ConcreteProduct<Product>> | typeof Top;
+    abstract(concrete: ReadonlySet<ConcreteProduct<Product>> | typeof Top): this;
+    toJson(): unknown;
     toString(): string;
-    isTop(): this is ProductDomain<Product>;
-    isBottom(): this is ProductDomain<Product>;
-    isValue(): this is ProductDomain<Product>;
+    isTop(): this is this;
+    isBottom(): this is this;
+    isValue(): this is this;
 }

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

@@ -9,14 +9,7 @@ const lattice_1 = require("./lattice");
  * 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;
-    }
+class ProductDomain extends abstract_domain_1.AbstractDomain {
     bottom() {
         const result = this.create(this.value);
         for (const key in result.value) {
@@ -53,21 +46,17 @@ class ProductDomain {
         }
         return true;
     }
-    join(...values) {
+    join(other) {
         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]);
-            }
+        for (const key in result.value) {
+            result._value[key] = result.value[key].join(other.value[key]);
         }
         return result;
     }
-    meet(...values) {
+    meet(other) {
         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]);
-            }
+        for (const key in result.value) {
+            result._value[key] = result.value[key].meet(other.value[key]);
         }
         return result;
     }
@@ -85,7 +74,7 @@ class ProductDomain {
         }
         return result;
     }
-    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+    concretize(limit) {
         let result = new Set([{}]);
         for (const key in this.value) {
             const concrete = this.value[key].concretize(limit);
@@ -116,6 +105,9 @@ class ProductDomain {
         }
         return result;
     }
+    toJson() {
+        return Object.fromEntries(Object.entries(this.value).map(([key, value]) => [key, value.toJson()]));
+    }
     toString() {
         return '(' + Object.entries(this.value).map(([key, value]) => `${key}: ${value.toString()}`).join(', ') + ')';
     }

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

@@ -0,0 +1,29 @@
+import type { Ternary } from '../../util/logic';
+/**
+ * An abstract domain with satisfiability checks for concrete values.
+ */
+export interface SatisfiableDomain<T> {
+    /**
+     * Checks whether the current abstract value satisfies a concrete value (i.e. includes a concrete value).
+     * @see {@link Ternary} for the returned satisfiability result
+     */
+    satisfies(value: T): Ternary;
+}
+/**
+ * Represents the different types of numerical comparators for satifiability checks for an abstract domain.
+ */
+export declare enum NumericalComparator {
+    Equal = 0,
+    Less = 1,
+    LessOrEqual = 2,
+    Greater = 3,
+    GreaterOrEqual = 4
+}
+/**
+ * Represents the different types of set comparators for satifiability checks for an abstract domain.
+ */
+export declare enum SetComparator {
+    Equal = 0,
+    Subset = 1,
+    SubsetOrEqual = 2
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetComparator = exports.NumericalComparator = void 0;
+/**
+ * Represents the different types of numerical comparators for satifiability checks for an abstract domain.
+ */
+var NumericalComparator;
+(function (NumericalComparator) {
+    NumericalComparator[NumericalComparator["Equal"] = 0] = "Equal";
+    NumericalComparator[NumericalComparator["Less"] = 1] = "Less";
+    NumericalComparator[NumericalComparator["LessOrEqual"] = 2] = "LessOrEqual";
+    NumericalComparator[NumericalComparator["Greater"] = 3] = "Greater";
+    NumericalComparator[NumericalComparator["GreaterOrEqual"] = 4] = "GreaterOrEqual";
+})(NumericalComparator || (exports.NumericalComparator = NumericalComparator = {}));
+/**
+ * Represents the different types of set comparators for satifiability checks for an abstract domain.
+ */
+var SetComparator;
+(function (SetComparator) {
+    SetComparator[SetComparator["Equal"] = 0] = "Equal";
+    SetComparator[SetComparator["Subset"] = 1] = "Subset";
+    SetComparator[SetComparator["SubsetOrEqual"] = 2] = "SubsetOrEqual";
+})(SetComparator || (exports.SetComparator = SetComparator = {}));
+//# sourceMappingURL=satisfiable-domain.js.map

package/abstract-interpretation/domains/set-upper-bound-domain.d.ts

@@ -0,0 +1,54 @@
+import { Ternary } from '../../util/logic';
+import { AbstractDomain } from './abstract-domain';
+import { Bottom, Top } from './lattice';
+import { type SatisfiableDomain, SetComparator } from './satisfiable-domain';
+/** The type of the actual values of the set upper bound domain as set */
+type SetUpperBoundValue<T> = ReadonlySet<T>;
+/** The type of the Top element of the set upper bound domain as {@link Top} symbol */
+type SetUpperBoundTop = typeof Top;
+/** The type of the Bottom element of the set upper bound domain as {@link Bottom} symbol */
+type SetUpperBoundBottom = typeof Bottom;
+/** The type of the abstract values of the set upper bound domain that are Top, Bottom, or actual values */
+type SetUpperBoundLift<T> = SetUpperBoundValue<T> | SetUpperBoundTop | SetUpperBoundBottom;
+/**
+ * The set upper bound 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 SetUpperBoundDomain<T, Value extends SetUpperBoundLift<T> = SetUpperBoundLift<T>> extends AbstractDomain<ReadonlySet<T>, SetUpperBoundValue<T>, SetUpperBoundTop, SetUpperBoundBottom, Value> implements SatisfiableDomain<ReadonlySet<T>> {
+    readonly limit: number;
+    private readonly setType;
+    /**
+     * @param limit -  A limit for the maximum number of elements to store in the set
+     * @param newSet - 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: SetUpperBoundLift<T> | T[]): this;
+    static top<T>(limit?: number, setType?: typeof Set<T>): SetUpperBoundDomain<T, SetUpperBoundTop>;
+    static bottom<T>(limit?: number, setType?: typeof Set<T>): SetUpperBoundDomain<T, SetUpperBoundBottom>;
+    static abstract<T>(concrete: ReadonlySet<ReadonlySet<T>> | typeof Top, limit?: number, setType?: typeof Set<T>): SetUpperBoundDomain<T>;
+    top(): this & SetUpperBoundDomain<T, SetUpperBoundTop>;
+    bottom(): this & SetUpperBoundDomain<T, SetUpperBoundBottom>;
+    equals(other: this): boolean;
+    leq(other: this): boolean;
+    join(other: this): this;
+    join(other: SetUpperBoundLift<T> | T[]): this;
+    meet(other: this): this;
+    meet(other: SetUpperBoundLift<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: this | SetUpperBoundLift<T> | T[]): this;
+    widen(other: this): this;
+    narrow(other: this): this;
+    concretize(limit: number): ReadonlySet<ReadonlySet<T>> | typeof Top;
+    abstract(concrete: ReadonlySet<ReadonlySet<T>> | typeof Top): this;
+    satisfies(set: ReadonlySet<T> | T[], comparator?: SetComparator): Ternary;
+    toJson(): unknown;
+    toString(): string;
+    isTop(): this is SetUpperBoundDomain<T, SetUpperBoundTop>;
+    isBottom(): this is SetUpperBoundDomain<T, SetUpperBoundBottom>;
+    isValue(): this is SetUpperBoundDomain<T, SetUpperBoundValue<T>>;
+}
+export {};

package/abstract-interpretation/domains/set-upper-bound-domain.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpperBoundDomain = void 0;
+const assert_1 = require("../../util/assert");
+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");
+const satisfiable_domain_1 = require("./satisfiable-domain");
+/**
+ * The set upper bound 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 SetUpperBoundDomain extends abstract_domain_1.AbstractDomain {
+    limit;
+    setType;
+    /**
+     * @param limit -  A limit for the maximum number of elements to store in the set
+     * @param newSet - 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 && value !== lattice_1.Bottom) {
+            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 {
+            super(value);
+        }
+        this.limit = limit;
+        this.setType = setType;
+    }
+    create(value) {
+        return new SetUpperBoundDomain(value, this.limit, this.setType);
+    }
+    static top(limit, setType) {
+        return new SetUpperBoundDomain(lattice_1.Top, limit, setType);
+    }
+    static bottom(limit, setType) {
+        return new SetUpperBoundDomain(lattice_1.Bottom, limit, setType);
+    }
+    static abstract(concrete, limit, setType) {
+        if (concrete === lattice_1.Top) {
+            return SetUpperBoundDomain.top(limit, setType);
+        }
+        else if (concrete.size === 0) {
+            return SetUpperBoundDomain.bottom(limit, setType);
+        }
+        return new SetUpperBoundDomain(concrete.values().reduce((result, set) => result.union(set)), limit, setType);
+    }
+    top() {
+        return SetUpperBoundDomain.top(this.limit, this.setType);
+    }
+    bottom() {
+        return SetUpperBoundDomain.bottom(this.limit, this.setType);
+    }
+    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(other) {
+        const otherValue = other instanceof SetUpperBoundDomain ? other.value : Array.isArray(other) ? new this.setType(other) : other;
+        if (this.value === lattice_1.Top || otherValue === lattice_1.Top) {
+            return this.top();
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return this.create(otherValue);
+        }
+        else if (otherValue === lattice_1.Bottom) {
+            return this.create(this.value);
+        }
+        else {
+            return this.create(this.value.union(otherValue));
+        }
+    }
+    meet(other) {
+        const otherValue = other instanceof SetUpperBoundDomain ? other.value : Array.isArray(other) ? new this.setType(other) : other;
+        if (this.value === lattice_1.Bottom || otherValue === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else 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));
+        }
+    }
+    /**
+     * 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 SetUpperBoundDomain ? other.value : Array.isArray(other) ? new this.setType(other) : other;
+        if (this.value === lattice_1.Top) {
+            return this.top();
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else if (otherValue === lattice_1.Top || otherValue === lattice_1.Bottom) {
+            return this.create(this.value);
+        }
+        else {
+            return this.create(this.value.difference(otherValue));
+        }
+    }
+    widen(other) {
+        if (this.value === lattice_1.Bottom) {
+            return this.create(other.value);
+        }
+        else if (other.value === lattice_1.Bottom) {
+            return this.create(this.value);
+        }
+        return other.leq(this) ? this.create(this.value) : this.top();
+    }
+    narrow(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        return this.isTop() ? this.create(other.value) : this.create(this.value);
+    }
+    concretize(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 this.setType()];
+        for (const element of this.value.values()) {
+            const newSubsets = subsets.map(subset => new this.setType([...subset, element]));
+            for (const subset of newSubsets) {
+                subsets.push(subset);
+            }
+        }
+        return new Set(subsets);
+    }
+    abstract(concrete) {
+        return SetUpperBoundDomain.abstract(concrete, this.limit, this.setType);
+    }
+    satisfies(set, comparator = satisfiable_domain_1.SetComparator.Equal) {
+        switch (comparator) {
+            case satisfiable_domain_1.SetComparator.Equal:
+            case satisfiable_domain_1.SetComparator.SubsetOrEqual: {
+                if (this.isTop() || (this.isValue() && [...set].length <= this.value.size && [...set].every(value => this.value.has(value)))) {
+                    return logic_1.Ternary.Maybe;
+                }
+                return logic_1.Ternary.Never;
+            }
+            case satisfiable_domain_1.SetComparator.Subset: {
+                if (this.isTop() || (this.isValue() && [...set].length < this.value.size && [...set].every(value => this.value.has(value)))) {
+                    return logic_1.Ternary.Maybe;
+                }
+                return logic_1.Ternary.Never;
+            }
+            default: {
+                (0, assert_1.assertUnreachable)(comparator);
+            }
+        }
+    }
+    toJson() {
+        if (this.value === lattice_1.Top || this.value === lattice_1.Bottom) {
+            return this.value.description;
+        }
+        return this.value.values().toArray();
+    }
+    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.SetUpperBoundDomain = SetUpperBoundDomain;
+//# sourceMappingURL=set-upper-bound-domain.js.map

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

@@ -1,38 +1,43 @@
-import { type AbstractDomain } from './abstract-domain';
+import { Ternary } from '../../util/logic';
+import { AbstractDomain } from './abstract-domain';
 import { Bottom, Top } from './lattice';
+import type { SatisfiableDomain } from './satisfiable-domain';
 /** The type of the actual values of the singleton domain as single value */
-export type SingletonValue<T> = T;
+type SingletonValue<T> = T;
 /** The type of the Top element of the singleton domain as {@link Top} symbol */
-export type SingletonTop = typeof Top;
+type SingletonTop = typeof Top;
 /** The type of the Bottom element of the singleton domain as {@link Bottom} symbol */
-export type SingletonBottom = typeof Bottom;
+type SingletonBottom = typeof Bottom;
 /** The type of the abstract values of the singleton domain that are Top, Bottom, or actual values */
-export type SingletonLift<T> = SingletonValue<T> | SingletonTop | SingletonBottom;
+type SingletonLift<T> = SingletonValue<T> | SingletonTop | SingletonBottom;
 /**
- * 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)
  */
-export declare class SingletonDomain<T, Value extends SingletonLift<T> = SingletonLift<T>> implements AbstractDomain<T, SingletonValue<T>, SingletonTop, SingletonBottom, Value> {
-    private _value;
-    constructor(value: Value);
-    get value(): Value;
+export declare class SingletonDomain<T, Value extends SingletonLift<T> = SingletonLift<T>> extends AbstractDomain<T, SingletonValue<T>, SingletonTop, SingletonBottom, Value> implements SatisfiableDomain<T> {
+    create(value: SingletonLift<T>): this;
     static top<T>(): SingletonDomain<T, SingletonTop>;
     static bottom<T>(): SingletonDomain<T, SingletonBottom>;
     static abstract<T>(concrete: ReadonlySet<T> | typeof Top): SingletonDomain<T>;
-    top(): SingletonDomain<T, SingletonTop>;
-    bottom(): SingletonDomain<T, SingletonBottom>;
-    equals(other: SingletonDomain<T>): boolean;
-    leq(other: SingletonDomain<T>): boolean;
-    join(...values: SingletonDomain<T>[]): SingletonDomain<T>;
-    meet(...values: SingletonDomain<T>[]): SingletonDomain<T>;
-    widen(other: SingletonDomain<T>): SingletonDomain<T>;
-    narrow(other: SingletonDomain<T>): SingletonDomain<T>;
+    top(): this & SingletonDomain<T, SingletonTop>;
+    bottom(): this & SingletonDomain<T, SingletonBottom>;
+    equals(other: this): boolean;
+    leq(other: this): boolean;
+    join(other: this): this;
+    join(other: SingletonLift<T>): this;
+    meet(other: this): this;
+    meet(other: SingletonLift<T>): this;
+    widen(other: this): this;
+    narrow(other: this): this;
     concretize(): ReadonlySet<T> | typeof Top;
-    abstract(concrete: ReadonlySet<T> | typeof Top): SingletonDomain<T>;
+    abstract(concrete: ReadonlySet<T> | typeof Top): this;
+    satisfies(value: T): Ternary;
+    toJson(): unknown;
     toString(): string;
     isTop(): this is SingletonDomain<T, SingletonTop>;
     isBottom(): this is SingletonDomain<T, SingletonBottom>;
     isValue(): this is SingletonDomain<T, SingletonValue<T>>;
 }
+export {};