@eagleoutice/flowr 2.6.1 → 2.6.3

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

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

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

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

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

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

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

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

package/cli/repl/commands/repl-lineage.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lineageCommand = void 0;
-exports.getLineage = getLineage;
-const parse_1 = require("../../../slicing/criterion/parse");
-const edge_1 = require("../../../dataflow/graph/edge");
-const assert_1 = require("../../../util/assert");
-function splitAt(str, idx) {
-    return [str.slice(0, idx), str.slice(idx)];
-}
-function filterRelevantEdges(edge) {
-    return (0, edge_1.edgeIncludesType)(edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.Returns | edge_1.EdgeType.Reads, edge.types);
-}
-function pushRelevantEdges(queue, outgoingEdges) {
-    queue.push(...[...outgoingEdges].filter(([_, edge]) => filterRelevantEdges(edge)));
-}
-/**
- * Get the lineage of a node in the dataflow graph
- *
- * @param criterion - The criterion to get the lineage of
- * @param graph - The dataflow graph to search in
- * @param idMap - The ID map to use for resolving the criterion (will default to that shipped with the dfgraph)
- * @returns The lineage of the node represented as a set of node ids
- */
-function getLineage(criterion, graph, idMap) {
-    idMap ??= graph.idMap;
-    (0, assert_1.guard)(idMap !== undefined, 'The ID map is required to get the lineage of a node');
-    const src = graph.get((0, parse_1.slicingCriterionToId)(criterion, idMap));
-    (0, assert_1.guard)(src !== undefined, 'The ID pointed to by the criterion does not exist in the dataflow graph');
-    const [vertex, outgoingEdges] = src;
-    const result = new Set([vertex.id]);
-    const edgeQueue = [];
-    pushRelevantEdges(edgeQueue, outgoingEdges);
-    while (edgeQueue.length > 0) {
-        const [target] = edgeQueue.shift();
-        if (result.has(target)) {
-            continue;
-        }
-        result.add(target);
-        const outgoingEdges = graph.outgoingEdges(target);
-        if (outgoingEdges !== undefined) {
-            pushRelevantEdges(edgeQueue, outgoingEdges);
-        }
-    }
-    return result;
-}
-exports.lineageCommand = {
-    description: 'Get the lineage of an R object',
-    isCodeCommand: true,
-    usageExample: ':lineage',
-    aliases: ['lin'],
-    script: false,
-    argsParser: (args) => {
-        const [criterion, rest] = splitAt(args, args.indexOf(' '));
-        const code = rest.trim();
-        return {
-            input: code.startsWith('"') ? JSON.parse(code) : code,
-            remaining: [criterion]
-        };
-    },
-    fn: async ({ output, analyzer, remainingArgs }) => {
-        const lineageIds = getLineage(remainingArgs[0], (await analyzer.dataflow()).graph);
-        output.stdout([...lineageIds].join('\n'));
-    }
-};
-//# sourceMappingURL=repl-lineage.js.map

package/cli/repl/server/messages/message-lineage.d.ts

@@ -1,17 +0,0 @@
-import type { SingleSlicingCriterion } from '../../../../slicing/criterion/parse';
-import type { IdMessageBase, MessageDefinition } from './all-messages';
-import type { NodeId } from '../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-export interface LineageRequestMessage extends IdMessageBase {
-    type: 'request-lineage';
-    /** The {@link FileAnalysisRequestMessage#filetoken} of the file/data */
-    filetoken: string;
-    /** The criterion to start the lineage from */
-    criterion: SingleSlicingCriterion;
-}
-export declare const requestLineageMessage: MessageDefinition<LineageRequestMessage>;
-export interface LineageResponseMessage extends IdMessageBase {
-    type: 'response-lineage';
-    /** The lineage of the given criterion. With this being the representation of a set, there is no guarantee about order. */
-    lineage: NodeId[];
-}
-export declare const responseLineageMessage: MessageDefinition<LineageResponseMessage>;

package/cli/repl/server/messages/message-lineage.js

@@ -1,25 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.responseLineageMessage = exports.requestLineageMessage = void 0;
-const joi_1 = __importDefault(require("joi"));
-exports.requestLineageMessage = {
-    type: 'request-lineage',
-    schema: joi_1.default.object({
-        type: joi_1.default.string().valid('request-lineage').required().description('The type of the message.'),
-        id: joi_1.default.string().optional().description('If you give the id, the response will be sent to the client with the same id.'),
-        filetoken: joi_1.default.string().required().description('The filetoken of the file/data retrieved from the analysis request.'),
-        criterion: joi_1.default.string().required().description('The criterion to start the lineage from.')
-    })
-};
-exports.responseLineageMessage = {
-    type: 'response-lineage',
-    schema: joi_1.default.object({
-        type: joi_1.default.string().valid('response-lineage').required(),
-        id: joi_1.default.string().optional().description('The id of the message, will be the same for the request.'),
-        lineage: joi_1.default.array().items(joi_1.default.string()).required().description('The lineage of the given criterion.')
-    })
-};
-//# sourceMappingURL=message-lineage.js.map

package/documentation/print-analyzer-wiki.d.ts

@@ -1 +0,0 @@
-export {};