@eagleoutice/flowr 2.6.1 → 2.6.3

package/util/assert.d.ts

@@ -1,12 +1,66 @@
 /** use this to ensure that all cases are covered in case of a selection */
+/**
+ * Verifies, that the given code path is never reached.
+ * @example
+ * ```ts
+ * type Shape = Circle | Square;
+ * function area(s: Shape): number {
+ *   switch(s.type) {
+ *     case 'circle': return Math.PI * s.radius ** 2;
+ *     case 'square': return s.sideLength ** 2;
+ *     default:       return assertUnreachable(s); // ensures that all cases are covered
+ *   }
+ * }
+ * ```
+ */
 export declare function assertUnreachable(x: never): never;
+/**
+ * Verifies that the given value is not undefined.
+ * This especially helps with a `.filter`
+ * @example
+ * ```ts
+ * const values: (number | undefined)[] = [1, 2, undefined, 4];
+ * const definedValues: number[] = values.filter(isNotUndefined);
+ * // definedValues is now of type number[]
+ * ```
+ * @see {@link isUndefined}
+ * @see {@link isNotNull}
+ */
 export declare function isNotUndefined<T>(x: T | undefined): x is T;
+/**
+ * Verifies that the given value is undefined.
+ * This especially helps with a `.filter`
+ * @example
+ * ```ts
+ * const values: (number | undefined)[] = [1, 2, undefined, 4];
+ * const undefinedValues: undefined[] = values.filter(isUndefined);
+ * // undefinedValues is now of type undefined[]
+ * ```
+ * @see {@link isNotUndefined}
+ * @see {@link isNotNull}
+ */
 export declare function isUndefined<T>(x: T | undefined): x is undefined;
+/**
+ * Verifies that the given value is not null.
+ * This especially helps with a `.filter`
+ * @example
+ * ```ts
+ * const values: (number | null)[] = [1, 2, null, 4];
+ * const nonNullValues: number[] = values.filter(isNotNull);
+ * // nonNullValues is now of type number[]
+ * ```
+ * @see {@link isUndefined}
+ * @see {@link isNotUndefined}
+ */
 export declare function isNotNull<T>(x: T | null): x is T;
+/**
+ * Generates a GitHub issue URL for reporting guard errors
+ */
+export declare function getGuardIssueUrl(message: string): string;
 export type GuardMessage = string | (() => string);
 /**
- * @param assertion - will be asserted
- * @param message - if a string, we will use it as the error message, if it is a function, we will call it to produce the error message (can be used to avoid costly message generations)
+ * @param assertion   - will be asserted
+ * @param message     - if a string, we will use it as the error message, if it is a function, we will call it to produce the error message (can be used to avoid costly message generations)
  * @throws GuardError - if the assertion fails
  */
 export declare function guard(assertion: unknown | undefined, message?: GuardMessage): asserts assertion;

package/util/assert.js

@@ -5,18 +5,69 @@ exports.assertUnreachable = assertUnreachable;
 exports.isNotUndefined = isNotUndefined;
 exports.isUndefined = isUndefined;
 exports.isNotNull = isNotNull;
+exports.getGuardIssueUrl = getGuardIssueUrl;
 exports.guard = guard;
 /* v8 ignore next */
 const version_1 = require("./version");
+/**
+ * Verifies, that the given code path is never reached.
+ * @example
+ * ```ts
+ * type Shape = Circle | Square;
+ * function area(s: Shape): number {
+ *   switch(s.type) {
+ *     case 'circle': return Math.PI * s.radius ** 2;
+ *     case 'square': return s.sideLength ** 2;
+ *     default:       return assertUnreachable(s); // ensures that all cases are covered
+ *   }
+ * }
+ * ```
+ */
 function assertUnreachable(x) {
     throw new Error(`Unexpected object: ${JSON.stringify(x)}`);
 }
+/**
+ * Verifies that the given value is not undefined.
+ * This especially helps with a `.filter`
+ * @example
+ * ```ts
+ * const values: (number | undefined)[] = [1, 2, undefined, 4];
+ * const definedValues: number[] = values.filter(isNotUndefined);
+ * // definedValues is now of type number[]
+ * ```
+ * @see {@link isUndefined}
+ * @see {@link isNotNull}
+ */
 function isNotUndefined(x) {
     return x !== undefined;
 }
+/**
+ * Verifies that the given value is undefined.
+ * This especially helps with a `.filter`
+ * @example
+ * ```ts
+ * const values: (number | undefined)[] = [1, 2, undefined, 4];
+ * const undefinedValues: undefined[] = values.filter(isUndefined);
+ * // undefinedValues is now of type undefined[]
+ * ```
+ * @see {@link isNotUndefined}
+ * @see {@link isNotNull}
+ */
 function isUndefined(x) {
     return x === undefined;
 }
+/**
+ * Verifies that the given value is not null.
+ * This especially helps with a `.filter`
+ * @example
+ * ```ts
+ * const values: (number | null)[] = [1, 2, null, 4];
+ * const nonNullValues: number[] = values.filter(isNotNull);
+ * // nonNullValues is now of type number[]
+ * ```
+ * @see {@link isUndefined}
+ * @see {@link isNotUndefined}
+ */
 function isNotNull(x) {
     return x !== null;
 }
@@ -36,6 +87,9 @@ function prepareStack(stack) {
     }
     return lines.map(l => l.replaceAll(/\(\/.*(src|test)/g, '(<>/$1')).join('\n');
 }
+/**
+ * Generates a GitHub issue URL for reporting guard errors
+ */
 function getGuardIssueUrl(message) {
     const body = encodeURIComponent(`<!-- Please describe your issue in more detail below! -->
 
@@ -61,8 +115,8 @@ class GuardError extends Error {
     }
 }
 /**
- * @param assertion - will be asserted
- * @param message - if a string, we will use it as the error message, if it is a function, we will call it to produce the error message (can be used to avoid costly message generations)
+ * @param assertion   - will be asserted
+ * @param message     - if a string, we will use it as the error message, if it is a function, we will call it to produce the error message (can be used to avoid costly message generations)
  * @throws GuardError - if the assertion fails
  */
 function guard(assertion, message = 'Assertion failed') {

package/util/collections/arrays.d.ts

@@ -18,7 +18,6 @@ export type LastOfArray<T extends AnyArray> = T extends [...infer _, infer L] ?
 /**
  * Splits the array every time the given predicate fires.
  * The element the split appears on will not be included!
- *
  * @example with this we can split on all empty strings:
  * ```
  * splitArrayOn(['a', '', 'b', '', '', 'c'], elem => elem === '')
@@ -38,11 +37,14 @@ export declare function splitArrayOn<T>(arr: readonly T[], predicate: (elem: T)
 export declare function partitionArray<T>(arr: readonly T[], predicate: (elem: T) => boolean): [T[], T[]];
 /**
  * Generate all permutations of the given array using Heap's algorithm (with its non-recursive variant).
- *
  * @param arr - The array to permute
  * @see getUniqueCombinationsOfSize
  */
 export declare function allPermutations<T>(arr: T[]): Generator<T[], void, void>;
+/**
+ * Returns a tuple of two arrays, where the first one contains all elements for which the predicate returned true,
+ * and the second one contains all elements for which the predicate returned false.
+ */
 export declare function partition<T>(arr: T[], predicate: (elem: T) => boolean): [T[], T[]];
 /**
  * Generate all unique combinations of the array with the given size.
@@ -50,7 +52,6 @@ export declare function partition<T>(arr: T[], predicate: (elem: T) => boolean):
  * but not, e.g., `[a,a]` or `[b,a]`.
  *
  * If `minSize!=maxSize`, the result is guaranteed to be sorted by size.
- *
  * @param array   - The array to generate combinations from
  * @param minSize - The inclusive minimum size of the combinations, must be at least `0` and at most `maxSize`
  * @param maxSize - The inclusive maximum size of the combinations, must be at least `minSize` and at most `array.length`
@@ -64,13 +65,15 @@ export declare function arraySum(arr: readonly number[]): number;
  * Converts an array into a bag data-structure (in the form of a map mapping the entries/keys to their counts)
  */
 export declare function array2bag<T>(arr: T[]): Map<T, number>;
+/**
+ * Compares two arrays for equality, using the given comparison function for the elements.
+ */
 export declare function arrayEqual<T>(a: readonly T[] | undefined, b: readonly T[] | undefined, cmp?: (a: T, b: T) => boolean): boolean;
 /**
  * Samples elements from a list such that the distance between the sampled elements is as equal as possible.
  *
  * If the number of elements to sample is greater or equal to the number of elements in the list, the list is returned as is.
  * If the number of elements to sample is less than or equal to 0, an empty list is returned.
- *
  * @param list - list of elements
  * @param sampleCount - number of elements to sample
  * @param rounding - rounding mode to use for the index calculation
@@ -85,9 +88,11 @@ export declare function equidistantSampling<T>(list: readonly T[], sampleCount:
  * cartesianProduct([1, 2], ['a', 'b', 'c'], [true, false])
  * // -> [[1, 'a', true], [1, 'a', false], [1, 'b', true], [1, 'b', false], [1, 'c', true], [1, 'c', false], [2, 'a', true], [2, 'a', false], [2, 'b', true], [2, 'b', false], [2, 'c', true], [2, 'c', false]]
  * ```
- *
  */
 export declare function cartesianProduct<T>(...arrays: T[][]): T[][];
 /** merge two arrays, removing duplicates */
 export declare function uniqueArrayMerge<T>(left: readonly T[], right: readonly T[]): T[];
+/**
+ * Groups the elements of the given array by the key returned by the given key function.
+ */
 export declare function arraysGroupBy<T, K>(arr: readonly T[], keyFn: (elem: T) => K): Map<K, T[]>;

package/util/collections/arrays.js

@@ -16,7 +16,6 @@ const assert_1 = require("../assert");
 /**
  * Splits the array every time the given predicate fires.
  * The element the split appears on will not be included!
- *
  * @example with this we can split on all empty strings:
  * ```
  * splitArrayOn(['a', '', 'b', '', '', 'c'], elem => elem === '')
@@ -66,7 +65,6 @@ function partitionArray(arr, predicate) {
 }
 /**
  * Generate all permutations of the given array using Heap's algorithm (with its non-recursive variant).
- *
  * @param arr - The array to permute
  * @see getUniqueCombinationsOfSize
  */
@@ -91,6 +89,10 @@ function* allPermutations(arr) {
         }
     }
 }
+/**
+ * Returns a tuple of two arrays, where the first one contains all elements for which the predicate returned true,
+ * and the second one contains all elements for which the predicate returned false.
+ */
 function partition(arr, predicate) {
     const left = [];
     const right = [];
@@ -110,7 +112,6 @@ function partition(arr, predicate) {
  * but not, e.g., `[a,a]` or `[b,a]`.
  *
  * If `minSize!=maxSize`, the result is guaranteed to be sorted by size.
- *
  * @param array   - The array to generate combinations from
  * @param minSize - The inclusive minimum size of the combinations, must be at least `0` and at most `maxSize`
  * @param maxSize - The inclusive maximum size of the combinations, must be at least `minSize` and at most `array.length`
@@ -164,6 +165,9 @@ function array2bag(arr) {
     }
     return result;
 }
+/**
+ * Compares two arrays for equality, using the given comparison function for the elements.
+ */
 function arrayEqual(a, b, cmp = (a, b) => a === b) {
     if (a === undefined || b === undefined) {
         return a === b;
@@ -183,7 +187,6 @@ function arrayEqual(a, b, cmp = (a, b) => a === b) {
  *
  * If the number of elements to sample is greater or equal to the number of elements in the list, the list is returned as is.
  * If the number of elements to sample is less than or equal to 0, an empty list is returned.
- *
  * @param list - list of elements
  * @param sampleCount - number of elements to sample
  * @param rounding - rounding mode to use for the index calculation
@@ -212,7 +215,6 @@ function equidistantSampling(list, sampleCount, rounding = 'ceil') {
  * cartesianProduct([1, 2], ['a', 'b', 'c'], [true, false])
  * // -> [[1, 'a', true], [1, 'a', false], [1, 'b', true], [1, 'b', false], [1, 'c', true], [1, 'c', false], [2, 'a', true], [2, 'a', false], [2, 'b', true], [2, 'b', false], [2, 'c', true], [2, 'c', false]]
  * ```
- *
  */
 function cartesianProduct(...arrays) {
     return arrays.reduce((a, b) => a.flatMap(x => b.map(y => x.concat(y))), [[]]);
@@ -225,6 +227,9 @@ function uniqueArrayMerge(left, right) {
     }
     return Array.from(result);
 }
+/**
+ * Groups the elements of the given array by the key returned by the given key function.
+ */
 function arraysGroupBy(arr, keyFn) {
     const result = new Map();
     for (const elem of arr) {

package/util/collections/defaultmap.d.ts

@@ -8,23 +8,23 @@ export declare class DefaultMap<K, V = K> {
     /** generator function to produce a default value for a given key */
     private readonly generator;
     /**
-   * @param generator - the generator to produce a default value for a given key
-   * @param map       - the initial map to start with
-   */
+     * @param generator - the generator to produce a default value for a given key
+     * @param map       - the initial map to start with
+     */
     constructor(generator: (k: K) => V, map?: Map<K, V>);
     /**
-   * Sets a value for a given key.
-   * As you provide value, this does not invoke the generator!
-   */
+     * Sets a value for a given key.
+     * As you provide value, this does not invoke the generator!
+     */
     set(k: K, v: V): this;
     /**
-   * Return a value for the given key, if the key does not exist within the default map,
-   * this will invoke the generator and assign the produced value.
-   */
+     * Return a value for the given key, if the key does not exist within the default map,
+     * this will invoke the generator and assign the produced value.
+     */
     get(k: K): V;
     /**
-   * Iterates over all entries that have been set (explicitly or by the generator)
-   */
+     * Iterates over all entries that have been set (explicitly or by the generator)
+     */
     entries(): IterableIterator<[K, V]>;
     /** returns only the keys really stored in the map */
     keys(): IterableIterator<K>;

package/util/collections/defaultmap.js

@@ -11,25 +11,25 @@ class DefaultMap {
     /** generator function to produce a default value for a given key */
     generator;
     /**
-   * @param generator - the generator to produce a default value for a given key
-   * @param map       - the initial map to start with
-   */
+     * @param generator - the generator to produce a default value for a given key
+     * @param map       - the initial map to start with
+     */
     constructor(generator, map = new Map()) {
         this.generator = generator;
         this.internal = map;
     }
     /**
-   * Sets a value for a given key.
-   * As you provide value, this does not invoke the generator!
-   */
+     * Sets a value for a given key.
+     * As you provide value, this does not invoke the generator!
+     */
     set(k, v) {
         this.internal.set(k, v);
         return this;
     }
     /**
-   * Return a value for the given key, if the key does not exist within the default map,
-   * this will invoke the generator and assign the produced value.
-   */
+     * Return a value for the given key, if the key does not exist within the default map,
+     * this will invoke the generator and assign the produced value.
+     */
     get(k) {
         const potential = this.internal.get(k);
         if (potential !== undefined) {
@@ -42,8 +42,8 @@ class DefaultMap {
         }
     }
     /**
-   * Iterates over all entries that have been set (explicitly or by the generator)
-   */
+     * Iterates over all entries that have been set (explicitly or by the generator)
+     */
     entries() {
         return this.internal.entries();
     }

package/util/containers.d.ts

@@ -1,9 +1,9 @@
 import type { REnvironmentInformation } from '../dataflow/environments/environment';
 import type { Identifier } from '../dataflow/environments/identifier';
-import type { ContainerIndices, ContainerIndicesCollection, IndexIdentifier } from '../dataflow/graph/vertex';
+import { type ContainerIndices, type ContainerIndicesCollection, type IndexIdentifier } from '../dataflow/graph/vertex';
 import type { RAccess } from '../r-bridge/lang-4.x/ast/model/nodes/r-access';
 import type { RArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-argument';
-import type { RFunctionArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 /**
  * Returns the accessed and access argument of an access operation by filtering the operation arguments.
@@ -14,7 +14,6 @@ export declare function getAccessOperands<OtherInfo>(args: readonly RFunctionArg
 };
 /**
  * Resolves the passed name within the passed environment and returns the indicesCollection of the resolved definitions.
- *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
  * @returns The indicesCollection of the resolved definitions
@@ -24,7 +23,6 @@ export declare function resolveIndicesByName(name: Identifier, environment: REnv
  * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
  *
  * If no indices could be found that match the `accessArg`, the original indices are returned as overapproximation.
- *
  * @param accessedArg        - The argument to resolve
  * @param accessArg          - The argument which is used to filter the indices
  * @param environment        - The environment in which {@link accessedArg} is resolved
@@ -38,7 +36,6 @@ export declare function resolveSingleIndex(accessedArg: {
 }, environment: REnvironmentInformation, isIndexBasedAccess: boolean): ContainerIndicesCollection;
 /**
  * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
- *
  * @param indicesCollection  - The {@link ContainerIndicesCollection} to filter
  * @param accessArg          - The argument which is used to filter {@link indicesCollection}
  * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
@@ -55,7 +52,6 @@ export declare function filterIndices(indicesCollection: ContainerIndicesCollect
  * person$credentials$username
  * ```
  * would result in a list with the index `credentials`, which has the subIndex `username`.
- *
  * @param accessedArg         - The top level argument that is accessed
  * @param leafIndices         - The index at the end of the nested access i.e. `c` in `a$b$c`.
  * @param constructIdentifier - A function that constructs the identifier for the index from the argument
@@ -64,7 +60,6 @@ export declare function filterIndices(indicesCollection: ContainerIndicesCollect
 export declare function constructNestedAccess<OtherInfo>(accessedArg: RAccess<OtherInfo & ParentInformation>, leafIndices: ContainerIndices, constructIdentifier: (arg: RArgument<OtherInfo & ParentInformation>) => IndexIdentifier): ContainerIndices[];
 /**
  * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
- *
  * @param indicesCollection - Indices where to add the sub indices.
  * @param leafSubIndices    - Indices that are added to the leaf indices.
  */

package/util/containers.js

@@ -21,7 +21,6 @@ function getAccessOperands(args) {
 }
 /**
  * Resolves the passed name within the passed environment and returns the indicesCollection of the resolved definitions.
- *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
  * @returns The indicesCollection of the resolved definitions
@@ -34,7 +33,6 @@ function resolveIndicesByName(name, environment) {
  * Resolves {@link accessedArg} in the {@link environment} and filters its indices according to {@link accessArg}.
  *
  * If no indices could be found that match the `accessArg`, the original indices are returned as overapproximation.
- *
  * @param accessedArg        - The argument to resolve
  * @param accessArg          - The argument which is used to filter the indices
  * @param environment        - The environment in which {@link accessedArg} is resolved
@@ -55,7 +53,6 @@ function resolveSingleIndex(accessedArg, accessArg, environment, isIndexBasedAcc
 }
 /**
  * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
- *
  * @param indicesCollection  - The {@link ContainerIndicesCollection} to filter
  * @param accessArg          - The argument which is used to filter {@link indicesCollection}
  * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
@@ -84,7 +81,6 @@ function filterIndices(indicesCollection, accessArg, isIndexBasedAccess) {
  * person$credentials$username
  * ```
  * would result in a list with the index `credentials`, which has the subIndex `username`.
- *
  * @param accessedArg         - The top level argument that is accessed
  * @param leafIndices         - The index at the end of the nested access i.e. `c` in `a$b$c`.
  * @param constructIdentifier - A function that constructs the identifier for the index from the argument
@@ -117,7 +113,6 @@ function constructNestedAccess(accessedArg, leafIndices, constructIdentifier) {
 }
 /**
  * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
- *
  * @param indicesCollection - Indices where to add the sub indices.
  * @param leafSubIndices    - Indices that are added to the leaf indices.
  */

package/util/diff-graph.d.ts

@@ -17,7 +17,6 @@ interface ProblematicEdge {
 export type ProblematicDiffInfo = ProblematicVertex | ProblematicEdge;
 /**
  * To be produced by a function differencing two graphs (e.g., {@link DataflowGraph|DFGs} or {@link ControlFlowGraph|CFGs}).
- *
  * @see {@link GraphDifferenceReport#isEqual|isEqual} - to check whether the graphs are equal
  * @see {@link GraphDifferenceReport#addComment|addComment} - to add comments to the report
  * @see {@link GraphDifferenceReport#comments|comments} - to get the attached comments

package/util/diff-graph.js

@@ -4,7 +4,6 @@ exports.GraphDifferenceReport = void 0;
 exports.initDiffContext = initDiffContext;
 /**
  * To be produced by a function differencing two graphs (e.g., {@link DataflowGraph|DFGs} or {@link ControlFlowGraph|CFGs}).
- *
  * @see {@link GraphDifferenceReport#isEqual|isEqual} - to check whether the graphs are equal
  * @see {@link GraphDifferenceReport#addComment|addComment} - to add comments to the report
  * @see {@link GraphDifferenceReport#comments|comments} - to get the attached comments

package/util/diff.d.ts

@@ -1,7 +1,6 @@
 /**
  * Provides utility types and functions to provide difference information if two structures
  * are not equal. Maybe. Sometime, in the far future this will be as capable as the waldo package :dream:
- *
  * @module
  */
 import type { MergeableRecord } from './objects';
@@ -52,4 +51,7 @@ export interface GenericDiffConfiguration {
      */
     readonly leftIsSubgraph?: boolean;
 }
+/**
+ * Computes the difference of two sets and adds human-readable information to the current report
+ */
 export declare function setDifference<T, Report extends WriteableDifferenceReport = WriteableDifferenceReport>(left: ReadonlySet<T>, right: ReadonlySet<T>, info: GenericDifferenceInformation<Report>): void;

package/util/diff.js

@@ -2,12 +2,14 @@
 /**
  * Provides utility types and functions to provide difference information if two structures
  * are not equal. Maybe. Sometime, in the far future this will be as capable as the waldo package :dream:
- *
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setDifference = setDifference;
 const set_1 = require("./collections/set");
+/**
+ * Computes the difference of two sets and adds human-readable information to the current report
+ */
 function setDifference(left, right, info) {
     const lWithoutR = (0, set_1.setMinus)(left, right);
     const rWithoutL = (0, set_1.setMinus)(right, left);

package/util/files.d.ts

@@ -1,4 +1,4 @@
-import type { PathLike } from 'fs';
+import { type PathLike } from 'fs';
 import type { RParseRequestFromFile } from '../r-bridge/retriever';
 import type { FlowrFileProvider } from '../project/context/flowr-file';
 /**
@@ -13,45 +13,43 @@ export interface Table {
  * @param dir    - Directory path to start the search from
  * @param suffix - Suffix of the files to be retrieved
  * Based on {@link https://stackoverflow.com/a/45130990}
- *
  * @see {@link getAllFilesSync} for a synchronous version.
  */
 export declare function getAllFiles(dir: string, suffix?: RegExp): AsyncGenerator<string>;
 /**
  * Retrieves all files in the given directory recursively (synchronously)
- *
  * @see {@link getAllFiles} - for an asynchronous version.
  */
 export declare function getAllFilesSync(dir: string, suffix?: RegExp): Generator<string>;
 /**
  * Retrieves all R files in a given directory (asynchronously)
- *
- *
  * @param input - directory-path to start the search from, can be a file as well. Will just return the file then.
  * @param limit - limit the number of files to be retrieved
- *
  * @returns Number of files processed (normally &le; `limit`, is &ge; `limit` if limit was reached).
  *          Will be `1`, if `input` is an R file (and `0` if it isn't).
- *
  * @see getAllFiles
  */
 export declare function allRFiles(input: string, limit?: number): AsyncGenerator<RParseRequestFromFile, number>;
 /**
  * Retrieves all R files in a given set of directories and files (asynchronously)
- *
  * @param inputs - Files or directories to validate for R-files
  * @param limit  - Limit the number of files to be retrieved
  * @returns Number of files processed (&le; limit)
- *
  * @see allRFiles
  */
 export declare function allRFilesFrom(inputs: string[], limit?: number): AsyncGenerator<RParseRequestFromFile, number>;
+/**
+ * Writes the given table as a CSV file.
+ * @param table   - The table to write
+ * @param file    - The file path to write the CSV to
+ * @param sep     - The separator to use (default: `,`)
+ * @param newline - The newline character to use (default: `\n`)
+ */
 export declare function writeTableAsCsv(table: Table, file: string, sep?: string, newline?: string): void;
 /**
  * Reads a file line by line and calls the given function for each line.
  * The `lineNumber` starts at `0`.
  * The `maxLines` option limits the maximum number of read lines and is `Infinity` by default.
- *
  * @returns Whether all lines have been successfully read (`false` if `maxLines` was reached)
  *
  * See {@link readLineByLineSync} for a synchronous version.
@@ -61,7 +59,6 @@ export declare function readLineByLine(filePath: string, onLine: (line: Buffer,
  * Reads a file line by line and calls the given function for each line.
  * The `lineNumber` starts at `0`.
  * The `maxLines` option limits the maximum number of read lines and is `Infinity` by default.
- *
  * @returns Whether the file exists and all lines have been successfully read (`false` if `maxLines` was reached)
  *
  * See {@link readLineByLine} for an asynchronous version.
@@ -78,5 +75,8 @@ export declare function getParentDirectory(directory: string): string;
  * @param file - The file to parse
  * @returns Map containing the keys and values of the provided file.
  */
-export declare function parseDCF(file: FlowrFileProvider<string>): Map<string, string[]>;
+export declare function parseDCF(file: FlowrFileProvider): Map<string, string[]>;
+/**
+ * Checks whether the given path-like object is a file that exists on the local filesystem.
+ */
 export declare function isFilePath(p: PathLike): boolean;