@eagleoutice/flowr 2.6.1 → 2.6.2

package/statistics/summarizer/post-process/file-based-count.d.ts

@@ -7,7 +7,6 @@ export interface FileBasedTable {
  * The purpose of this function is to reformat {@link ClusterReport} in way that lists file-based contributions.
  * E.g., "the file with id 12 contained the assignment with `<-` 3 times".
  * Feature Values are listed in the header.
- *
  * @param report - the report to reformat
  */
 export declare function fileBasedCount(report: ClusterReport): FileBasedTable;

package/statistics/summarizer/post-process/file-based-count.js

@@ -10,7 +10,6 @@ const fs_1 = __importDefault(require("fs"));
  * The purpose of this function is to reformat {@link ClusterReport} in way that lists file-based contributions.
  * E.g., "the file with id 12 contained the assignment with `<-` 3 times".
  * Feature Values are listed in the header.
- *
  * @param report - the report to reformat
  */
 function fileBasedCount(report) {

package/statistics/summarizer/post-process/histogram.d.ts

@@ -28,7 +28,6 @@ export interface Histogram {
  *
  * Let's suppose you want histograms for the Assignments feature.
  * By default, for each clustered value, a histogram is produced (can be configured by `filter`).
- *
  * @param report  - The report to collect histogram information from
  * @param binSize - Size of each bin (see {@link histogramFromNumbers} for details on why we do not specify the bin-count)
  * @param relateValuesToNumberOfLines - If true, each value (like `<-` appeared in file 'x' exactly `N` times) will be divided by the number of lines in the file 'x'.
@@ -52,7 +51,6 @@ export declare function histogramFromNumbers(name: string, binSize: number, valu
  * - `from` - The exclusive lower bound of the bin
  * - `to`   - The inclusive upper bound of the bin
  * - a column with the name of each histogram, containing its count of values in the corresponding bin
- *
  * @param histograms     - The histogram to convert (assumed to have the same ranges and bins)
  * @param countAsDensity - If true, the count is divided by the total number of values (individually for each histogram, similar to pgfplots `hist/density` option)
  */

package/statistics/summarizer/post-process/histogram.js

@@ -17,7 +17,6 @@ const arrays_1 = require("../../../util/collections/arrays");
  *
  * Let's suppose you want histograms for the Assignments feature.
  * By default, for each clustered value, a histogram is produced (can be configured by `filter`).
- *
  * @param report  - The report to collect histogram information from
  * @param binSize - Size of each bin (see {@link histogramFromNumbers} for details on why we do not specify the bin-count)
  * @param relateValuesToNumberOfLines - If true, each value (like `<-` appeared in file 'x' exactly `N` times) will be divided by the number of lines in the file 'x'.
@@ -72,7 +71,6 @@ function histogramFromNumbers(name, binSize, values) {
  * - `from` - The exclusive lower bound of the bin
  * - `to`   - The inclusive upper bound of the bin
  * - a column with the name of each histogram, containing its count of values in the corresponding bin
- *
  * @param histograms     - The histogram to convert (assumed to have the same ranges and bins)
  * @param countAsDensity - If true, the count is divided by the total number of values (individually for each histogram, similar to pgfplots `hist/density` option)
  */

package/statistics/summarizer/post-process/post-process-output.d.ts

@@ -1,11 +1,9 @@
-import type { ClusterReport } from './clusterer';
-import type { FeatureSelection } from '../../features/feature';
+import { type ClusterReport } from './clusterer';
+import { type FeatureSelection } from '../../features/feature';
 /**
  * Post process the collections in a given folder, reducing them in a memory preserving way.
- *
  * @param filepath - Path to the root file of the data collection like `statistics-out/top-2023-01-01-00-00-00/`
  * @param features - Collection of features to post process, expects corresponding folders to exist
- *
  * @returns non-aggregated reports for each sub-key of each feature
  */
 export declare function postProcessFeatureFolder(filepath: string, features: FeatureSelection): ClusterReport[];

package/statistics/summarizer/post-process/post-process-output.js

@@ -17,10 +17,8 @@ const file_provider_1 = require("../../output/file-provider");
 const arrays_1 = require("../../../util/collections/arrays");
 /**
  * Post process the collections in a given folder, reducing them in a memory preserving way.
- *
  * @param filepath - Path to the root file of the data collection like `statistics-out/top-2023-01-01-00-00-00/`
  * @param features - Collection of features to post process, expects corresponding folders to exist
- *
  * @returns non-aggregated reports for each sub-key of each feature
  */
 function postProcessFeatureFolder(filepath, features) {
@@ -39,7 +37,6 @@ function postProcessFeatureFolder(filepath, features) {
 }
 /**
  * Process a single feature folder like `Assignments/`
- *
  * @param filepath - Same as the input to {@link postProcessFeatureFolder}
  * @param feature  - The (single) feature to process
  */

package/statistics/summarizer/second-phase/process.d.ts

@@ -1,10 +1,12 @@
 import type { StatisticsSummarizerConfiguration } from '../summarizer';
-import type { CommonSummarizerConfiguration } from '../../../util/summarizer';
-import type { FeatureStatisticsWithMeta } from '../../features/feature';
+import { type CommonSummarizerConfiguration } from '../../../util/summarizer';
+import { type FeatureStatisticsWithMeta } from '../../features/feature';
+/**
+ *
+ */
 export declare function postProcessFeatures(config: StatisticsSummarizerConfiguration, filepath: string, outputPath: string, logger: (message: string) => void, metaFeatureInformation: Map<string, FeatureStatisticsWithMeta>): void;
 /**
  * Post process the collections in a given folder, retrieving the final summaries.
- *
  * @param logger       - The logger to use for outputs
  * @param filepath     - Path to the root file of the data collection (contains all the archives)
  * @param config       - Configuration of the summarizer

package/statistics/summarizer/second-phase/process.js

@@ -13,6 +13,9 @@ const arrays_1 = require("../../../util/collections/arrays");
 const files_1 = require("../../../util/files");
 const assert_1 = require("../../../util/assert");
 const feature_1 = require("../../features/feature");
+/**
+ *
+ */
 function postProcessFeatures(config, filepath, outputPath, logger, metaFeatureInformation) {
     for (const featureName of config.featuresToUse) {
         const featureInfo = feature_1.ALL_FEATURES[featureName];
@@ -66,7 +69,6 @@ function postProcessMeta(config, filepath, outputPath, logger, metaFeatureInform
 }
 /**
  * Post process the collections in a given folder, retrieving the final summaries.
- *
  * @param logger       - The logger to use for outputs
  * @param filepath     - Path to the root file of the data collection (contains all the archives)
  * @param config       - Configuration of the summarizer

package/statistics/summarizer/summarizer.d.ts

@@ -1,5 +1,4 @@
-import type { CommonSummarizerConfiguration } from '../../util/summarizer';
-import { Summarizer } from '../../util/summarizer';
+import { type CommonSummarizerConfiguration, Summarizer } from '../../util/summarizer';
 import type { FeatureSelection } from '../features/feature';
 export interface StatisticsSummarizerConfiguration extends CommonSummarizerConfiguration {
     /**

package/util/assert.d.ts

@@ -1,12 +1,62 @@
 /** 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;
 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

@@ -8,15 +8,65 @@ exports.isNotNull = isNotNull;
 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;
 }
@@ -61,8 +111,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);