@eagleoutice/flowr 2.6.1 → 2.6.3

package/util/r-value.d.ts

@@ -1,8 +1,17 @@
-import type { Value, ValueInterval, ValueLogical, ValueNumber, ValueString, ValueVector } from '../dataflow/eval/values/r-value';
+import { type Value, type ValueInterval, type ValueLogical, type ValueNumber, type ValueString, type ValueVector } from '../dataflow/eval/values/r-value';
 import type { RLogicalValue } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import { type RNumberValue, type RStringValue } from '../r-bridge/lang-4.x/convert-values';
+/**
+ * Checks whether the given value is an R string value.
+ */
 export declare function isRStringValue(value: unknown): value is RStringValue;
+/**
+ * Checks whether the given value is an R number value.
+ */
 export declare function isRNumberValue(value: unknown): value is RNumberValue;
+/**
+ * Checks whether the given value is an R logical value.
+ */
 export declare function isRLogicalValue(value: unknown): value is RLogicalValue;
 export declare function unwrapRValue(value: RStringValue | string): string;
 export declare function unwrapRValue(value: RNumberValue | number): number;

package/util/r-value.js

@@ -13,15 +13,27 @@ const assert_1 = require("./assert");
 function isRValue(value) {
     return isRStringValue(value) || isRNumberValue(value) || isRLogicalValue(value) || typeof value === 'string' || typeof value === 'number';
 }
+/**
+ * Checks whether the given value is an R string value.
+ */
 function isRStringValue(value) {
     return typeof value === 'object' && value !== null && 'str' in value && typeof value.str === 'string';
 }
+/**
+ * Checks whether the given value is an R number value.
+ */
 function isRNumberValue(value) {
     return typeof value === 'object' && value !== null && 'num' in value && typeof value.num === 'number';
 }
+/**
+ * Checks whether the given value is an R logical value.
+ */
 function isRLogicalValue(value) {
     return typeof value === 'boolean';
 }
+/**
+ * Unwraps an R value to a (TS) native value.
+ */
 function unwrapRValue(value) {
     if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
         return value;
@@ -36,6 +48,9 @@ function unwrapRValue(value) {
         return undefined;
     }
 }
+/**
+ * Unwraps an R vector to a (TS) native array.
+ */
 function unwrapRVector(value) {
     if (!Array.isArray(value)) {
         return undefined;
@@ -56,6 +71,9 @@ function unwrapRVector(value) {
         return undefined;
     }
 }
+/**
+ * Unwraps an R value to a string representation.
+ */
 function unwrapRValueToString(value) {
     if (typeof value === 'string') {
         return value;
@@ -76,6 +94,9 @@ function unwrapRValueToString(value) {
         return undefined;
     }
 }
+/**
+ * Unlifts an R value to its core representation.
+ */
 function unliftRValue(value) {
     if (!(0, r_value_1.isValue)(value)) {
         return undefined;

package/util/random.d.ts

@@ -1,4 +1,7 @@
 export declare const ALPHABET_LOWERCASE: readonly string[];
 export declare const ALPHABET_UPPERCASE: readonly string[];
 export declare const ALPHABET: readonly string[];
+/**
+ * Generates a random string of the given length using the provided symbols.
+ */
 export declare function randomString(length: number, symbols?: readonly string[]): string;

package/util/random.js

@@ -10,6 +10,9 @@ exports.ALPHABET = [...exports.ALPHABET_LOWERCASE, ...exports.ALPHABET_UPPERCASE
 function isPositiveFiniteInteger(length) {
     return isFinite(length) && length >= 0 && length === Math.floor(length);
 }
+/**
+ * Generates a random string of the given length using the provided symbols.
+ */
 function randomString(length, symbols = exports.ALPHABET) {
     (0, assert_1.guard)(isPositiveFiniteInteger(length), `length must be a positive, finite integer (${length} >= 0)`);
     (0, assert_1.guard)(symbols.length > 0, 'there must be at least one symbol to use');

package/util/range.d.ts

@@ -12,7 +12,6 @@ export type SourcePosition = [
 ];
 /**
  * Describe the start and end {@link SourcePosition|source position} of an element.
- *
  * @see {@link rangeFrom} - to create a range
  * @see {@link mergeRanges} - to merge multiple ranges
  * @see {@link getRangeStart} - to get the start of a range
@@ -38,13 +37,17 @@ export declare function getRangeEnd(p: SourceRange): SourcePosition;
 export declare function getRangeEnd(p: SourceRange | undefined): SourcePosition | undefined;
 /**
  * This does not ensure ordering of start and end!
- *
  * @param sl - start line
  * @param sc - start column
  * @param el - end line
  * @param ec - end column
  */
 export declare function rangeFrom(sl: number | string, sc: number | string, el: number | string, ec: number | string): SourceRange;
+/**
+ * Merges multiple source ranges into a single source range that spans from the earliest start to the latest end.
+ * If you are interested in combining overlapping ranges into a minimal set of ranges, see {@link combineRanges}.
+ * @throws if no ranges are provided
+ */
 export declare function mergeRanges(...rs: (SourceRange | undefined)[]): SourceRange;
 /**
  * @returns true iff `r1` starts and ends before `r2` starts (i.e., if `r1` and `r2` do not overlap and `r1` comes before `r2`
@@ -60,7 +63,6 @@ export declare function rangesOverlap([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2
 export declare function addRanges([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl, r2sc, r2el, r2ec]: SourceRange): SourceRange;
 /**
  * Provides a comparator for {@link SourceRange}s that sorts them in ascending order.
- *
  * @returns a positive number if `r1` comes after `r2`, a negative number if `r1` comes before `r2`, and `0` if they are equal
  */
 export declare function rangeCompare([r1sl, r1sc, ,]: SourceRange, [r2sl, r2sc, ,]: SourceRange): number;
@@ -68,4 +70,8 @@ export declare function rangeCompare([r1sl, r1sc, ,]: SourceRange, [r2sl, r2sc,
  * Checks if the first range is a subset of the second range.
  */
 export declare function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl, r2sc, r2el, r2ec]: SourceRange): boolean;
+/**
+ * Combines overlapping or subset ranges into a minimal set of ranges.
+ * If you are interested in merging overlapping ranges, see {@link mergeRanges}.
+ */
 export declare function combineRanges(...ranges: SourceRange[]): SourceRange[];

package/util/range.js

@@ -11,15 +11,20 @@ exports.rangeCompare = rangeCompare;
 exports.rangeIsSubsetOf = rangeIsSubsetOf;
 exports.combineRanges = combineRanges;
 const assert_1 = require("./assert");
+/**
+ * Returns the start position of a source range.
+ */
 function getRangeStart(p) {
     return p === undefined ? undefined : [p[0], p[1]];
 }
+/**
+ * Returns the end position of a source range.
+ */
 function getRangeEnd(p) {
     return p === undefined ? undefined : [p[2], p[3]];
 }
 /**
  * This does not ensure ordering of start and end!
- *
  * @param sl - start line
  * @param sc - start column
  * @param el - end line
@@ -28,6 +33,11 @@ function getRangeEnd(p) {
 function rangeFrom(sl, sc, el, ec) {
     return [Number(sl), Number(sc), Number(el), Number(ec)];
 }
+/**
+ * Merges multiple source ranges into a single source range that spans from the earliest start to the latest end.
+ * If you are interested in combining overlapping ranges into a minimal set of ranges, see {@link combineRanges}.
+ * @throws if no ranges are provided
+ */
 function mergeRanges(...rs) {
     const rsSafe = rs.filter(assert_1.isNotUndefined);
     (0, assert_1.guard)(rsSafe.length > 0, 'Cannot merge no ranges');
@@ -56,7 +66,6 @@ function addRanges([r1sl, r1sc, r1el, r1ec], [r2sl, r2sc, r2el, r2ec]) {
 }
 /**
  * Provides a comparator for {@link SourceRange}s that sorts them in ascending order.
- *
  * @returns a positive number if `r1` comes after `r2`, a negative number if `r1` comes before `r2`, and `0` if they are equal
  */
 function rangeCompare([r1sl, r1sc, ,], [r2sl, r2sc, ,]) {
@@ -73,6 +82,10 @@ function rangeCompare([r1sl, r1sc, ,], [r2sl, r2sc, ,]) {
 function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec], [r2sl, r2sc, r2el, r2ec]) {
     return (r1sl > r2sl || r1sl === r2sl && r1sc >= r2sc) && (r1el < r2el || r1sl === r2sl && r1ec <= r2ec);
 }
+/**
+ * Combines overlapping or subset ranges into a minimal set of ranges.
+ * If you are interested in merging overlapping ranges, see {@link mergeRanges}.
+ */
 function combineRanges(...ranges) {
     return ranges.filter(range => !ranges.some(other => range !== other && rangeIsSubsetOf(range, other)));
 }

package/util/schema.d.ts

@@ -1,11 +1,24 @@
 import type Joi from 'joi';
-import type { OutputFormatter } from './text/ansi';
+import { type OutputFormatter } from './text/ansi';
 interface SchemaLine {
     level: number;
     text: string;
 }
+/**
+ * Describes a Joi schema in a human-readable way.
+ */
 export declare function describeSchema(schema: Joi.Schema, f?: OutputFormatter): string;
+/**
+ * Provides a generic description for any Joi schema.
+ * You probably want to use {@link describeSchema}.
+ */
 export declare function genericDescription(level: number, formatter: OutputFormatter, name: string, desc: Joi.Description | undefined): SchemaLine[];
+/**
+ * Creates the header line(s) for a schema description.
+ */
 export declare function headerLine(level: number, formatter: OutputFormatter, name: string, type: string, flags: object | undefined): SchemaLine[];
+/**
+ * Describes a Joi object schema.
+ */
 export declare function describeObject(level: number, formatter: OutputFormatter, desc: Joi.Description): SchemaLine[];
 export {};

package/util/schema.js

@@ -5,12 +5,19 @@ exports.genericDescription = genericDescription;
 exports.headerLine = headerLine;
 exports.describeObject = describeObject;
 const ansi_1 = require("./text/ansi");
+/**
+ * Describes a Joi schema in a human-readable way.
+ */
 function describeSchema(schema, f = ansi_1.formatter) {
     const description = schema.describe();
     const lines = genericDescription(1, f, f.format('.', { effect: ansi_1.ColorEffect.Foreground, color: 7 /* Colors.White */ }), description);
     const indent = ' '.repeat(4);
     return lines.map(line => `${indent.repeat(line.level - 1)}${line.text}`).join('\n');
 }
+/**
+ * Provides a generic description for any Joi schema.
+ * You probably want to use {@link describeSchema}.
+ */
 function genericDescription(level, formatter, name, desc) {
     if (!desc) {
         return [];
@@ -52,6 +59,9 @@ function printFlags(flags) {
     }
     return flagText.trim().length > 0 ? '[' + flagText + ']' : '';
 }
+/**
+ * Creates the header line(s) for a schema description.
+ */
 function headerLine(level, formatter, name, type, flags) {
     const text = `- ${(0, ansi_1.bold)(name, formatter)} ${formatter.format(type, { effect: ansi_1.ColorEffect.Foreground, color: 7 /* Colors.White */ })} ${printFlags(flags)}`;
     const baseLine = { level, text };
@@ -60,15 +70,18 @@ function headerLine(level, formatter, name, type, flags) {
     }
     return [baseLine];
 }
+/**
+ * Describes a Joi object schema.
+ */
 function describeObject(level, formatter, desc) {
-    const lines = [];
+    let lines = [];
     if (!('keys' in desc)) {
         return lines;
     }
     for (const key in desc.keys) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         const keySchema = desc.keys[key];
-        lines.push(...genericDescription(level + 1, formatter, key, keySchema));
+        lines = lines.concat(genericDescription(level + 1, formatter, key, keySchema));
     }
     return lines;
 }

package/util/simple-df/dfg-view.d.ts

@@ -1,6 +1,6 @@
 import { DataflowGraph } from '../../dataflow/graph/graph';
 import { VertexType } from '../../dataflow/graph/vertex';
-import type { MergeableRecord } from '../objects';
+import { type MergeableRecord } from '../objects';
 import type { DeepPartial } from 'ts-essentials';
 export interface ReduceVertexOptions extends MergeableRecord {
     tags: VertexType[];
@@ -13,4 +13,7 @@ export interface ReduceVertexOptions extends MergeableRecord {
 export interface ReduceOptions extends MergeableRecord {
     vertices: ReduceVertexOptions;
 }
+/**
+ * Produces a reduced version of the given dataflow graph according to the given options.
+ */
 export declare function reduceDfg(dfg: DataflowGraph, options: DeepPartial<ReduceOptions>): DataflowGraph;

package/util/simple-df/dfg-view.js

@@ -7,7 +7,7 @@ const objects_1 = require("../objects");
 const assert_1 = require("../assert");
 const defaultReduceOptions = {
     vertices: {
-        tags: [...Object.values(vertex_1.VertexType)],
+        tags: Object.values(vertex_1.VertexType),
         nameRegex: '.*',
         blacklistWithName: false,
         keepEnv: false,
@@ -33,6 +33,9 @@ function makeFilter(options, idMap) {
         };
     };
 }
+/**
+ * Produces a reduced version of the given dataflow graph according to the given options.
+ */
 function reduceDfg(dfg, options) {
     const newDfg = new graph_1.DataflowGraph(dfg.idMap);
     const applyOptions = (0, objects_1.deepMergeObject)(defaultReduceOptions, options);

package/util/summarizer.d.ts

@@ -24,7 +24,6 @@ export declare abstract class Summarizer<Output, Configuration extends CommonSum
     /**
      * First phase of the summary, can be used to extract all data of interest from the individual
      * benchmark or statistic results. This can write temporary files based on the configuration.
-     *
      * @param useTypeClassification - Whether to split the analysis based on the detected type (e.g. 'test', 'example', ...)
      */
     abstract preparationPhase(useTypeClassification: boolean): Promise<void>;
@@ -34,6 +33,15 @@ export declare abstract class Summarizer<Output, Configuration extends CommonSum
      */
     abstract summarizePhase(): Promise<Output>;
 }
+/**
+ * Converts the summarized measurement to a CSV line.
+ */
 export declare function summarizedMeasurement2Csv(a: SummarizedMeasurement): string;
+/**
+ * Generates the CSV header for summarized measurements.
+ */
 export declare function summarizedMeasurement2CsvHeader(prefix?: string): string;
+/**
+ * Summarizes the given measurement data.
+ */
 export declare function summarizeMeasurement(data: number[], totalNumberOfDataPoints?: number): SummarizedMeasurement;

package/util/summarizer.js

@@ -14,13 +14,22 @@ class Summarizer {
     }
 }
 exports.Summarizer = Summarizer;
+/**
+ * Converts the summarized measurement to a CSV line.
+ */
 function summarizedMeasurement2Csv(a) {
     return `${a.min},${a.max},${a.median},${a.mean},${a.std},${a.total}`;
 }
 const summarizedKeys = ['min', 'max', 'median', 'mean', 'std', 'total'];
+/**
+ * Generates the CSV header for summarized measurements.
+ */
 function summarizedMeasurement2CsvHeader(prefix) {
     return summarizedKeys.map(k => prefix ? `${prefix}-${k}` : k).join(',');
 }
+/**
+ * Summarizes the given measurement data.
+ */
 function summarizeMeasurement(data, totalNumberOfDataPoints) {
     // just to avoid in-place modification
     const sorted = [...data].sort((a, b) => a - b);

package/util/text/ansi.d.ts

@@ -48,4 +48,7 @@ export declare const ansiFormatter: {
     getFormatString(options?: FormatOptions): string;
 };
 export declare let formatter: OutputFormatter;
+/**
+ * (Globally) sets the output formatter used by the utility functions in this module.
+ */
 export declare function setFormatter(setFormatter: OutputFormatter): void;

package/util/text/ansi.js

@@ -82,6 +82,9 @@ exports.ansiFormatter = {
     }
 };
 exports.formatter = exports.ansiFormatter;
+/**
+ * (Globally) sets the output formatter used by the utility functions in this module.
+ */
 function setFormatter(setFormatter) {
     exports.formatter = setFormatter;
 }

package/util/text/args.d.ts

@@ -1,6 +1,5 @@
 /**
  * Just to avoid another library for splitting arguments, we use this module to provide what we need.
- *
  * @module
  */
 /**
@@ -10,9 +9,8 @@
  * this splits the arguments similar to common shell interpreters (i.e., `a`, `b c`, and `d`).
  *
  * When escapeQuote is set to false instead, we keep quotation marks in the result (i.e., `a`, `"b c"`, and `d`.).
- *
  * @param inputString - The string to split
  * @param escapeQuote - Keep quotes in args
- * @param split       - The **single** character to split on (can not be backslash or quote)
+ * @param split       - The character or character sequence to split on (can not be backslash or quote!)
  */
-export declare function splitAtEscapeSensitive(inputString: string, escapeQuote?: boolean, split?: string): string[];
+export declare function splitAtEscapeSensitive(inputString: string, escapeQuote?: boolean, split?: RegExp | string): string[];

package/util/text/args.js

@@ -1,7 +1,6 @@
 "use strict";
 /**
  * Just to avoid another library for splitting arguments, we use this module to provide what we need.
- *
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -13,17 +12,18 @@ exports.splitAtEscapeSensitive = splitAtEscapeSensitive;
  * this splits the arguments similar to common shell interpreters (i.e., `a`, `b c`, and `d`).
  *
  * When escapeQuote is set to false instead, we keep quotation marks in the result (i.e., `a`, `"b c"`, and `d`.).
- *
  * @param inputString - The string to split
  * @param escapeQuote - Keep quotes in args
- * @param split       - The **single** character to split on (can not be backslash or quote)
+ * @param split       - The character or character sequence to split on (can not be backslash or quote!)
  */
 function splitAtEscapeSensitive(inputString, escapeQuote = true, split = ' ') {
     const args = [];
     let current = '';
     let inQuotes = false;
     let escaped = false;
-    for (const c of inputString) {
+    for (let i = 0; i < inputString.length; i++) {
+        const c = inputString[i];
+        const sub = inputString.slice(i);
         if (escaped) {
             escaped = false;
             switch (c) {
@@ -48,7 +48,9 @@ function splitAtEscapeSensitive(inputString, escapeQuote = true, split = ' ') {
                 default: current += c;
             }
         }
-        else if (c === split && !inQuotes && current !== '') {
+        else if (!inQuotes
+            && current !== ''
+            && (split instanceof RegExp ? split.test(sub) : inputString.slice(i, i + split.length) === split)) {
             args.push(current);
             current = '';
         }

package/util/text/text.d.ts

@@ -1 +1,5 @@
+/**
+ * Returns the nth ordinal representation of the given number.
+ * @example `nth(1)` returns '1st'
+ */
 export declare function nth(n: number): string;

package/util/text/text.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nth = nth;
 const assert_1 = require("../assert");
+/**
+ * Returns the nth ordinal representation of the given number.
+ * @example `nth(1)` returns '1st'
+ */
 function nth(n) {
     (0, assert_1.guard)(isFinite(n) && n >= 1, 'n must be a non-negative number');
     const num = String(n);

package/util/text/time.d.ts

@@ -1,6 +1,5 @@
 /**
  * Retrieve a string in the form of "YYYY-MM-DD-HH-MM-SS-MS" from a Date object.
- *
  * @param date - The date to convert, defaults to the current date
  */
 export declare function date2string(date?: Date): string;

package/util/text/time.js

@@ -4,7 +4,6 @@ exports.date2string = date2string;
 exports.printAsMs = printAsMs;
 /**
  * Retrieve a string in the form of "YYYY-MM-DD-HH-MM-SS-MS" from a Date object.
- *
  * @param date - The date to convert, defaults to the current date
  */
 function date2string(date = new Date()) {

package/util/version.d.ts

@@ -1,7 +1,10 @@
 import { SemVer } from 'semver';
 import type { KnownParser } from '../r-bridge/parser';
 import type { ReplOutput } from '../cli/repl/commands/repl-main';
-import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
+/**
+ * Retrieves the current flowR version as a new {@link SemVer} object.
+ */
 export declare function flowrVersion(): SemVer;
 type Version = `${number}.${number}.${number}`;
 /**
@@ -14,6 +17,12 @@ export interface VersionInformation {
     r: Version | 'unknown' | 'none';
     engine: string;
 }
-export declare function retrieveVersionInformation(input: KnownParser | FlowrAnalysisProvider): Promise<VersionInformation>;
-export declare function printVersionInformation(output: ReplOutput, input: KnownParser | FlowrAnalysisProvider): Promise<void>;
+/**
+ * Retrieves the version information for flowR and the given parser or analysis provider.
+ */
+export declare function retrieveVersionInformation(input: KnownParser | ReadonlyFlowrAnalysisProvider): Promise<VersionInformation>;
+/**
+ * Displays the version information to the given output.
+ */
+export declare function printVersionInformation(output: ReplOutput, input: KnownParser | ReadonlyFlowrAnalysisProvider): Promise<void>;
 export {};

package/util/version.js

@@ -6,11 +6,17 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.6.1';
+const version = '2.6.3';
+/**
+ * Retrieves the current flowR version as a new {@link SemVer} object.
+ */
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }
 const versionRegex = /^\d+\.\d+\.\d+/m;
+/**
+ * Retrieves the version information for flowR and the given parser or analysis provider.
+ */
 async function retrieveVersionInformation(input) {
     const flowr = flowrVersion().toString();
     let r;
@@ -20,14 +26,17 @@ async function retrieveVersionInformation(input) {
         name = input.name;
     }
     else {
-        const parserInformation = await input.parserInformation();
-        r = parserInformation.name === 'r-shell' ? parserInformation.rVersion : 'unknown';
+        const parserInformation = input.parserInformation();
+        r = parserInformation.name === 'r-shell' ? (await parserInformation.rVersion()) : 'unknown';
         name = parserInformation.name;
     }
     (0, assert_1.guard)(versionRegex.test(flowr), `flowR version ${flowr} does not match the expected format!`);
     (0, assert_1.guard)(r === 'unknown' || r === 'none' || versionRegex.test(r), `R version ${r} does not match the expected format!`);
     return { flowr: flowr, r: r, engine: name };
 }
+/**
+ * Displays the version information to the given output.
+ */
 async function printVersionInformation(output, input) {
     const { flowr, r, engine } = await retrieveVersionInformation(input);
     output.stdout(`Engine: ${engine}`);

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 {};