@eagleoutice/flowr 2.6.0 → 2.6.2

package/dataflow/environments/environment.js

@@ -29,16 +29,15 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
             }
         }
     }
-    const node = graph.get(ref.nodeId, true);
+    const node = graph.getVertex(ref.nodeId, true);
     if (node) {
-        const [fst] = node;
-        if (fst.cds) {
-            if (defaultCd && !fst.cds.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
-                fst.cds.push(defaultCd);
+        if (node.cds) {
+            if (defaultCd && !node.cds.find(c => c.id === defaultCd.id && c.when === defaultCd.when)) {
+                node.cds.push(defaultCd);
             }
         }
         else {
-            fst.cds = defaultCd ? [defaultCd] : [];
+            node.cds = defaultCd ? [defaultCd] : [];
         }
     }
     if (ref.controlDependencies) {
@@ -51,6 +50,9 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
     }
     return ref;
 }
+/**
+ *
+ */
 function makeAllMaybe(references, graph, environments, includeDefs, defaultCd = undefined) {
     return references?.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd)) ?? [];
 }

package/dataflow/environments/identifier.d.ts

@@ -14,7 +14,6 @@ export type Identifier = string & {
  * a function when resolving an {@link Identifier|identifier}.
  * In `c <- 3; print(c(1, 2))` the call to `c` works normally (as the vector constructor),
  * while writing `c <- function(...) ..1` overshadows the built-in and causes `print` to only output the first element.
- *
  * @see {@link isReferenceType} - for checking if a (potentially joint) reference type contains a certain type
  * @see {@link ReferenceTypeReverseMapping} - for debugging
  */
@@ -45,7 +44,6 @@ export declare function isReferenceType(t: ReferenceType, target: ReferenceType)
 /**
  * Describes all types of reference (definitions) that can appear within a graph (i.e., that are not built-in like the
  * default definition for the assignment operator `<-`).
- *
  * @see {@link InGraphIdentifierDefinition} - for the definition of an identifier within the graph
  */
 export type InGraphReferenceType = Exclude<ReferenceType, ReferenceType.BuiltInConstant | ReferenceType.BuiltInFunction>;
@@ -61,7 +59,6 @@ export type InGraphReferenceType = Exclude<ReferenceType, ReferenceType.BuiltInC
  * they indicate the references that are currently (during the analysis at this given node)
  * {@link DataflowInformation#in|read (`in`)}, {@link DataflowInformation#out|written (`out`)},
  * or {@link DataflowInformation#unknownReferences|unknown (`unknownReferences`)}.
- *
  * @see {@link InGraphIdentifierDefinition}
  */
 export interface IdentifierReference {
@@ -88,7 +85,6 @@ export interface IdentifierReference {
  * Within a code snippet like `a <- 3`, the symbol processor will first create an
  * {@link IdentifierReference|identifier reference} for `a` to reference the use
  * and then promote it to an {@link InGraphIdentifierDefinition|identifier definition}.
- *
  * @see {@link IdentifierReference}
  */
 export interface InGraphIdentifierDefinition extends IdentifierReference {

package/dataflow/environments/identifier.js

@@ -11,7 +11,6 @@ exports.isReferenceType = isReferenceType;
  * a function when resolving an {@link Identifier|identifier}.
  * In `c <- 3; print(c(1, 2))` the call to `c` works normally (as the vector constructor),
  * while writing `c <- function(...) ..1` overshadows the built-in and causes `print` to only output the first element.
- *
  * @see {@link isReferenceType} - for checking if a (potentially joint) reference type contains a certain type
  * @see {@link ReferenceTypeReverseMapping} - for debugging
  */

package/dataflow/environments/overwrite.d.ts

@@ -1,5 +1,8 @@
-import type { IEnvironment, REnvironmentInformation } from './environment';
+import { type IEnvironment, type REnvironmentInformation } from './environment';
 import type { ControlDependency } from '../info';
+/**
+ *
+ */
 export declare function overwriteIEnvironmentWith(base: IEnvironment | undefined, next: IEnvironment | undefined, includeParent?: boolean, applyCds?: readonly ControlDependency[]): IEnvironment;
 export declare function overwriteEnvironment(base: REnvironmentInformation, next: REnvironmentInformation | undefined, applyCds?: readonly ControlDependency[]): REnvironmentInformation;
 export declare function overwriteEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation, applyCds?: readonly ControlDependency[]): REnvironmentInformation;

package/dataflow/environments/overwrite.js

@@ -16,6 +16,9 @@ function anyIsMaybeOrEmpty(values) {
     }
     return false;
 }
+/**
+ *
+ */
 function overwriteIEnvironmentWith(base, next, includeParent = true, applyCds) {
     (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not overwrite environments with undefined');
     const map = new Map(base.memory);

package/dataflow/environments/resolve-by-name.d.ts

@@ -1,16 +1,16 @@
 import type { REnvironmentInformation } from './environment';
 import { Ternary } from '../../util/logic';
-import type { Identifier, IdentifierDefinition } from './identifier';
-import { ReferenceType } from './identifier';
+import { type Identifier, type IdentifierDefinition, ReferenceType } from './identifier';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
- *
  * @param name               - The name of the identifier to resolve
  * @param environment        - The current environment used for name resolution
  * @param target             - The target (meta) type of the identifier to resolve
- *
  * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
  *          if the identifier is undefined in the current scope/with the current environment information.
  */
 export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target?: ReferenceType): IdentifierDefinition[] | undefined;
+/**
+ *
+ */
 export declare function resolvesToBuiltInConstant(name: Identifier | undefined, environment: REnvironmentInformation, wantedValue: unknown): Ternary;

package/dataflow/environments/resolve-by-name.js

@@ -22,11 +22,9 @@ const TargetTypePredicate = {
 };
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
- *
  * @param name               - The name of the identifier to resolve
  * @param environment        - The current environment used for name resolution
  * @param target             - The target (meta) type of the identifier to resolve
- *
  * @returns A list of possible identifier definitions (one if the definition location is exactly and always known), or `undefined`
  *          if the identifier is undefined in the current scope/with the current environment information.
  */
@@ -56,6 +54,9 @@ function resolveByName(name, environment, target = identifier_1.ReferenceType.Un
         return builtIns;
     }
 }
+/**
+ *
+ */
 function resolvesToBuiltInConstant(name, environment, wantedValue) {
     if (name === undefined) {
         return logic_1.Ternary.Never;

package/dataflow/environments/scoping.d.ts

@@ -1,4 +1,7 @@
-import type { REnvironmentInformation } from './environment';
+import { type REnvironmentInformation } from './environment';
 /** Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone) */
 export declare function pushLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;
+/**
+ *
+ */
 export declare function popLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/scoping.js

@@ -11,6 +11,9 @@ function pushLocalEnvironment(base) {
         level: base.level + 1
     };
 }
+/**
+ *
+ */
 function popLocalEnvironment(base) {
     (0, assert_1.guard)(base.level > 0, 'cannot remove the global/root environment');
     const parent = base.current.parent;

package/dataflow/eval/resolve/alias-tracking.d.ts

@@ -1,10 +1,10 @@
 import { VariableResolve } from '../../../config';
 import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { REnvironmentInformation } from '../../environments/environment';
-import type { Identifier } from '../../environments/identifier';
+import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { type REnvironmentInformation } from '../../environments/environment';
+import { type Identifier } from '../../environments/identifier';
 import type { DataflowGraph } from '../../graph/graph';
-import type { Lift, Value, ValueSet } from '../values/r-value';
+import { type Lift, type Value, type ValueSet } from '../values/r-value';
 export type ResolveResult = Lift<ValueSet<Value[]>>;
 export interface ResolveInfo {
     /** The current environment used for name resolution */
@@ -26,7 +26,6 @@ export interface ResolveInfo {
  * the sourceIds value field of their InGraphIdentifierDefinition. This enables
  * us later, in the {@link trackAliasInEnvironments} function, to get all the
  * aliases of an identifier.
- *
  * @param sourceIds          - node ids to get the definitions for
  * @param dataflow           - dataflow graph
  * @param environment        - environment
@@ -45,7 +44,6 @@ export declare function getAliases(sourceIds: readonly NodeId[], dataflow: Dataf
  * This function is also used by the Resolve Value Query and the Dependency Query
  * to resolve values. For e.g. in the Dependency Query it is used to resolve calls
  * like `lapply(c("a", "b", "c"), library, character.only = TRUE)`
- *
  * @param id                 - The node id or node to resolve
  * @param environment        - The current environment used for name resolution
  * @param graph              - The graph to resolve in
@@ -59,8 +57,6 @@ export declare function resolveIdToValue(id: NodeId | RNodeWithParent | undefine
  *
  * Uses the aliases that were tracked in the environments (by the
  * {@link getAliases} function) to resolve a node to a value.
- *
- *
  * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
@@ -73,7 +69,6 @@ export declare function trackAliasInEnvironments(resolve: VariableResolve, ident
  * Please use {@link resolveIdToValue}
  *
  * Tries to resolve the value of a node by traversing the dataflow graph
- *
  * @param id    - node to resolve
  * @param graph - dataflow graph
  * @param idMap - idmap of dataflow graph
@@ -84,7 +79,6 @@ export declare function trackAliasesInGraph(id: NodeId, graph: DataflowGraph, id
  * Please use {@link resolveIdToValue}
  *
  * Resolve an Identifier to a constant, if the identifier is a constant
- *
  * @param name               - Identifier to resolve
  * @param environment        - Environment to use
  * @returns Value of Constant or Top

package/dataflow/eval/resolve/alias-tracking.js

@@ -77,7 +77,6 @@ function getUseAlias(sourceId, dataflow, environment) {
  * the sourceIds value field of their InGraphIdentifierDefinition. This enables
  * us later, in the {@link trackAliasInEnvironments} function, to get all the
  * aliases of an identifier.
- *
  * @param sourceIds          - node ids to get the definitions for
  * @param dataflow           - dataflow graph
  * @param environment        - environment
@@ -109,7 +108,6 @@ function getAliases(sourceIds, dataflow, environment) {
  * This function is also used by the Resolve Value Query and the Dependency Query
  * to resolve values. For e.g. in the Dependency Query it is used to resolve calls
  * like `lapply(c("a", "b", "c"), library, character.only = TRUE)`
- *
  * @param id                 - The node id or node to resolve
  * @param environment        - The current environment used for name resolution
  * @param graph              - The graph to resolve in
@@ -138,6 +136,8 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve
             else {
                 return r_value_1.Top;
             }
+        case type_1.RType.FunctionDefinition:
+            return (0, set_constants_1.setFrom)({ type: 'function-definition' });
         case type_1.RType.FunctionCall:
         case type_1.RType.BinaryOp:
         case type_1.RType.UnaryOp:
@@ -155,8 +155,6 @@ function resolveIdToValue(id, { environment, graph, idMap, full = true, resolve
  *
  * Uses the aliases that were tracked in the environments (by the
  * {@link getAliases} function) to resolve a node to a value.
- *
- *
  * @param resolve    - Variable resolve mode
  * @param identifier - Identifier to resolve
  * @param use        - Environment to use
@@ -254,20 +252,22 @@ function isNestedInLoop(node, ast) {
  * Please use {@link resolveIdToValue}
  *
  * Tries to resolve the value of a node by traversing the dataflow graph
- *
  * @param id    - node to resolve
  * @param graph - dataflow graph
  * @param idMap - idmap of dataflow graph
  * @returns Value of node or Top/Bottom
  */
 function trackAliasesInGraph(id, graph, idMap) {
+    if (!graph.get(id)) {
+        return r_value_1.Bottom;
+    }
     idMap ??= graph.idMap;
     (0, assert_1.guard)(idMap !== undefined, 'The ID map is required to get the lineage of a node');
     const queue = new visiting_queue_1.VisitingQueue(25);
     const clean = (0, environment_1.initializeCleanEnvironments)();
     const cleanFingerprint = (0, fingerprint_1.envFingerprint)(clean);
     queue.add(id, clean, cleanFingerprint, false);
-    let forceBot = false;
+    let forceTop = false;
     const resultIds = [];
     while (queue.nonEmpty()) {
         const { id, baseEnvironment } = queue.next();
@@ -282,15 +282,15 @@ function trackAliasesInGraph(id, graph, idMap) {
             if (target === undefined) {
                 continue;
             }
-            if (target.type === type_1.RType.WhileLoop || target.type === type_1.RType.RepeatLoop) {
-                forceBot = true;
+            if (target.type === type_1.RType.WhileLoop || target.type === type_1.RType.RepeatLoop || target.type === type_1.RType.ForLoop) {
+                forceTop = true;
                 break;
             }
         }
-        if (!forceBot && (cds?.length === 0 && isNestedInLoop(idMap.get(id), idMap))) {
-            forceBot = true;
+        if (!forceTop && (cds?.length === 0 && isNestedInLoop(idMap.get(id), idMap))) {
+            forceTop = true;
         }
-        if (forceBot) {
+        if (forceTop) {
             break;
         }
         if (vertex.tag === vertex_1.VertexType.Value) {
@@ -316,8 +316,8 @@ function trackAliasesInGraph(id, graph, idMap) {
             }
         }
     }
-    if (forceBot || resultIds.length === 0) {
-        return r_value_1.Bottom;
+    if (forceTop || resultIds.length === 0) {
+        return r_value_1.Top;
     }
     const values = new Set();
     for (const id of resultIds) {
@@ -332,7 +332,6 @@ function trackAliasesInGraph(id, graph, idMap) {
  * Please use {@link resolveIdToValue}
  *
  * Resolve an Identifier to a constant, if the identifier is a constant
- *
  * @param name               - Identifier to resolve
  * @param environment        - Environment to use
  * @returns Value of Constant or Top

package/dataflow/eval/resolve/resolve-argument.d.ts

@@ -1,4 +1,4 @@
-import type { DataflowGraph } from '../../graph/graph';
+import { type DataflowGraph } from '../../graph/graph';
 import type { DataflowGraphVertexFunctionCall } from '../../graph/vertex';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { VariableResolve } from '../../../config';

package/dataflow/eval/resolve/resolve.d.ts

@@ -1,8 +1,7 @@
 import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { REnvironmentInformation } from '../../environments/environment';
 import type { DataflowGraph } from '../../graph/graph';
-import type { Lift, Value, ValueNumber, ValueVector } from '../values/r-value';
-import { Top } from '../values/r-value';
+import { type Lift, type Value, type ValueNumber, type ValueVector, Top } from '../values/r-value';
 import type { VariableResolve } from '../../../config';
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
@@ -10,7 +9,6 @@ import type { VariableResolve } from '../../../config';
  *
  * This function converts an RNode to its Value, but also recursively resolves
  * aliases and vectors (in case of a vector).
- *
  * @param a       - Ast node to resolve
  * @param resolve - Variable resolve mode
  * @param env     - Environment to use
@@ -25,7 +23,6 @@ export declare function resolveNode(resolve: VariableResolve, a: RNodeWithParent
  *
  * This function resolves a vector function call `c` to a {@link ValueVector}
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve - Variable resolve mode
  * @param node    - Node of the vector function to resolve
  * @param env     - Environment to use
@@ -40,7 +37,6 @@ export declare function resolveAsVector(resolve: VariableResolve, node: RNodeWit
  *
  * This function resolves a binary sequence operator `:` to a {@link ValueVector} of {@link ValueNumber}s
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the sequence operator to resolve
  * @param env      - Environment to use
@@ -55,7 +51,6 @@ export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWi
  *
  * This function resolves a unary plus operator `+` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the plus operator to resolve
  * @param env      - Environment to use
@@ -70,7 +65,6 @@ export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeW
  *
  * This function resolves a unary minus operator `-` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the minus operator to resolve
  * @param env      - Environment to use

package/dataflow/eval/resolve/resolve.js

@@ -23,7 +23,6 @@ const scalar_consatnts_1 = require("../values/scalar/scalar-consatnts");
  *
  * This function converts an RNode to its Value, but also recursively resolves
  * aliases and vectors (in case of a vector).
- *
  * @param a       - Ast node to resolve
  * @param resolve - Variable resolve mode
  * @param env     - Environment to use
@@ -41,6 +40,9 @@ function resolveNode(resolve, a, env, graph, map) {
     else if (a.type === type_1.RType.Logical) {
         return a.content.valueOf() ? logical_constants_1.ValueLogicalTrue : logical_constants_1.ValueLogicalFalse;
     }
+    else if (a.type === type_1.RType.FunctionDefinition) {
+        return { type: 'function-definition' };
+    }
     else if ((a.type === type_1.RType.FunctionCall || a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) && graph) {
         const origin = (0, dfg_get_origin_1.getOriginInDfg)(graph, a.info.id)?.[0];
         if (origin === undefined || origin.type !== 3 /* OriginType.BuiltInFunctionOrigin */) {
@@ -72,7 +74,6 @@ function resolveNode(resolve, a, env, graph, map) {
  *
  * This function resolves a vector function call `c` to a {@link ValueVector}
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve - Variable resolve mode
  * @param node    - Node of the vector function to resolve
  * @param env     - Environment to use
@@ -94,7 +95,6 @@ function resolveAsVector(resolve, node, environment, graph, idMap) {
  *
  * This function resolves a binary sequence operator `:` to a {@link ValueVector} of {@link ValueNumber}s
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the sequence operator to resolve
  * @param env      - Environment to use
@@ -122,7 +122,6 @@ function resolveAsSeq(resolve, operator, environment, graph, idMap) {
  *
  * This function resolves a unary plus operator `+` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the plus operator to resolve
  * @param env      - Environment to use
@@ -151,7 +150,6 @@ function resolveAsPlus(resolve, operator, environment, graph, idMap) {
  *
  * This function resolves a unary minus operator `-` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- *
  * @param resolve  - Variable resolve mode
  * @param operator - Node of the minus operator to resolve
  * @param env      - Environment to use

package/dataflow/eval/values/general.d.ts

@@ -1,6 +1,5 @@
 import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { Lift, Value, ValueSet } from './r-value';
-import { Bottom, Top } from './r-value';
+import { type Lift, type Value, type ValueSet, Bottom, Top } from './r-value';
 /**
  * Takes n potentially lifted ops and returns `Top` or `Bottom` if any is `Top` or `Bottom`.
  */
@@ -8,7 +7,6 @@ export declare function bottomTopGuard(...a: Lift<unknown>[]): typeof Top | type
 /**
  * Returns a value set, if a is not bottom or top, otherwise undefined.
  * Useful when working with values returned by {@link resolveIdToValue}
- *
  * @param a - value set to check
  * @returns value set if a is not top or bottom
  */

package/dataflow/eval/values/general.js

@@ -23,7 +23,6 @@ function bottomTopGuard(...a) {
 /**
  * Returns a value set, if a is not bottom or top, otherwise undefined.
  * Useful when working with values returned by {@link resolveIdToValue}
- *
  * @param a - value set to check
  * @returns value set if a is not top or bottom
  */

package/dataflow/eval/values/intervals/interval-constants.d.ts

@@ -1,4 +1,10 @@
 import type { RNumberValue } from '../../../../r-bridge/lang-4.x/convert-values';
-import type { Lift, ValueInterval, ValueNumber } from '../r-value';
+import { type Lift, type ValueInterval, type ValueNumber } from '../r-value';
+/**
+ *
+ */
 export declare function intervalFrom(start: RNumberValue | number, end?: number | RNumberValue, startInclusive?: boolean, endInclusive?: boolean): ValueInterval;
+/**
+ *
+ */
 export declare function intervalFromValues(start: Lift<ValueNumber>, end?: Lift<ValueNumber<Lift<RNumberValue>>>, startInclusive?: boolean, endInclusive?: boolean): ValueInterval;

package/dataflow/eval/values/intervals/interval-constants.js

@@ -4,6 +4,9 @@ exports.intervalFrom = intervalFrom;
 exports.intervalFromValues = intervalFromValues;
 const r_value_1 = require("../r-value");
 const scalar_consatnts_1 = require("../scalar/scalar-consatnts");
+/**
+ *
+ */
 function intervalFrom(start, end = start, startInclusive = true, endInclusive = true) {
     return intervalFromValues(typeof start === 'number' ? (0, scalar_consatnts_1.getScalarFromInteger)(start) : (0, scalar_consatnts_1.liftScalar)(start), typeof end === 'number' ? (0, scalar_consatnts_1.getScalarFromInteger)(end) : (0, scalar_consatnts_1.liftScalar)(end), startInclusive, endInclusive);
 }
@@ -15,6 +18,9 @@ function shiftNum(v) {
         return v;
     }
 }
+/**
+ *
+ */
 function intervalFromValues(start, end = start, startInclusive = true, endInclusive = true) {
     return {
         type: 'interval',

package/dataflow/eval/values/logical/logical-constants.d.ts

@@ -1,4 +1,7 @@
-import type { Lift, TernaryLogical, ValueLogical } from '../r-value';
+import { type Lift, type TernaryLogical, type ValueLogical } from '../r-value';
+/**
+ *
+ */
 export declare function liftLogical(log: Lift<TernaryLogical>): ValueLogical;
 export declare const ValueLogicalTrue: ValueLogical;
 export declare const ValueLogicalFalse: ValueLogical;

package/dataflow/eval/values/logical/logical-constants.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueLogicalBot = exports.ValueLogicalTop = exports.ValueLogicalMaybe = exports.ValueLogicalFalse = exports.ValueLogicalTrue = void 0;
 exports.liftLogical = liftLogical;
 const r_value_1 = require("../r-value");
+/**
+ *
+ */
 function liftLogical(log) {
     if (log === r_value_1.Top) {
         return exports.ValueLogicalTop;

package/dataflow/eval/values/r-value.d.ts

@@ -37,6 +37,9 @@ export interface ValueString<Str extends Lift<RStringValue> = Lift<RStringValue>
     type: 'string';
     value: Str;
 }
+export interface ValueFunctionDefinition {
+    type: 'function-definition';
+}
 export interface ValueMissing {
     type: 'missing';
 }
@@ -45,14 +48,26 @@ export interface ValueLogical {
     type: 'logical';
     value: Lift<TernaryLogical>;
 }
-export type Value = Lift<ValueInterval | ValueVector | ValueSet | ValueNumber | ValueString | ValueLogical | ValueMissing>;
+export type Value = Lift<ValueInterval | ValueVector | ValueSet | ValueNumber | ValueString | ValueLogical | ValueMissing | ValueFunctionDefinition>;
 export type ValueType<V> = V extends {
     type: infer T;
 } ? T : never;
 export type ValueTypes = ValueType<Value>;
+/**
+ *
+ */
 export declare function typeOfValue<V extends Value>(value: V): V['type'];
+/** Checks whether the given value is the top value */
 export declare function isTop<V extends Lift<unknown>>(value: V): value is typeof Top;
+/** Checks whether the given value is the bottom value */
 export declare function isBottom<V extends Lift<unknown>>(value: V): value is typeof Bottom;
+/** Checks whether the given value is a proper value (neither top nor bottom) */
 export declare function isValue<V extends Lift<unknown>>(value: V): value is Unlift<V>;
+/**
+ * Treat a value as unlifted value, throws if it is top or bottom.
+ */
 export declare function asValue<V extends Lift<unknown>>(value: V): Unlift<V>;
+/**
+ *
+ */
 export declare function stringifyValue(value: Lift<Value>): string;

package/dataflow/eval/values/r-value.js

@@ -10,20 +10,29 @@ exports.stringifyValue = stringifyValue;
 const assert_1 = require("../../../util/assert");
 exports.Top = { type: Symbol('⊤') };
 exports.Bottom = { type: Symbol('⊥') };
+/**
+ *
+ */
 function typeOfValue(value) {
     return value.type;
 }
+/** Checks whether the given value is the top value */
 // @ts-expect-error -- this is a save cast
 function isTop(value) {
     return value === exports.Top;
 }
+/** Checks whether the given value is the bottom value */
 // @ts-expect-error -- this is a save cast
 function isBottom(value) {
     return value === exports.Bottom;
 }
+/** Checks whether the given value is a proper value (neither top nor bottom) */
 function isValue(value) {
     return !isTop(value) && !isBottom(value);
 }
+/**
+ * Treat a value as unlifted value, throws if it is top or bottom.
+ */
 function asValue(value) {
     (0, assert_1.guard)(isValue(value), 'Expected a value, but got a top or bottom value');
     return value;
@@ -60,6 +69,9 @@ function renderString(value) {
         return `${quote}${JSON.stringify(value.str).slice(1, -1)}${quote}`;
     }
 }
+/**
+ *
+ */
 function stringifyValue(value) {
     return tryStringifyBoTop(value, v => {
         const t = v.type;
@@ -82,6 +94,8 @@ function stringifyValue(value) {
                 return tryStringifyBoTop(v.value, l => l === 'maybe' ? 'maybe' : l ? 'TRUE' : 'FALSE', () => '⊤ (logical)', () => '⊥ (logical)');
             case 'missing':
                 return '(missing)';
+            case 'function-definition':
+                return 'fn-def';
             default:
                 (0, assert_1.assertUnreachable)(t);
         }

package/dataflow/eval/values/scalar/scalar-consatnts.d.ts

@@ -1,6 +1,12 @@
-import type { Lift, ValueNumber } from '../r-value';
+import { type Lift, type ValueNumber } from '../r-value';
 import type { RNumberValue } from '../../../../r-bridge/lang-4.x/convert-values';
+/**
+ *
+ */
 export declare function getScalarFromInteger(num: number, markedAsInt?: boolean, complexNumber?: boolean): ValueNumber<RNumberValue>;
+/**
+ *
+ */
 export declare function liftScalar(value: Lift<RNumberValue>): ValueNumber;
 export declare const ValueIntegerOne: ValueNumber<RNumberValue>;
 export declare const ValueNumberComplexOne: ValueNumber<RNumberValue>;

package/dataflow/eval/values/scalar/scalar-consatnts.js

@@ -4,6 +4,9 @@ exports.ValueIntegerBottom = exports.ValueIntegerTop = exports.ValueNumberOneHal
 exports.getScalarFromInteger = getScalarFromInteger;
 exports.liftScalar = liftScalar;
 const r_value_1 = require("../r-value");
+/**
+ *
+ */
 function getScalarFromInteger(num, markedAsInt = Number.isInteger(num), complexNumber = false) {
     return {
         type: 'number',
@@ -14,6 +17,9 @@ function getScalarFromInteger(num, markedAsInt = Number.isInteger(num), complexN
         }
     };
 }
+/**
+ *
+ */
 function liftScalar(value) {
     return {
         type: 'number',

package/dataflow/eval/values/sets/set-constants.d.ts

@@ -1,6 +1,11 @@
-import type { Lift, Value, ValueSet } from '../r-value';
-import { Top } from '../r-value';
+import { type Lift, type Value, type ValueSet, Top } from '../r-value';
+/**
+ *
+ */
 export declare function setFrom<V extends Value[]>(...elements: V): Lift<ValueSet<Value[]>>;
+/**
+ *
+ */
 export declare function isSet<V extends Value>(element: V): boolean;
 export declare const ValueEmptySet: Lift<ValueSet<Value[]>>;
 export declare const ValueSetTop: ValueSet<typeof Top>;