@eagleoutice/flowr 1.5.2 → 2.0.1

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

@@ -0,0 +1,16 @@
+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[];
+/**
+ * Prints the report to the console, but limits the output to the `limit` entries with the highest counts.
+ * The names of these entries (like `->`) are returned, so they can be used to filter the following histograms.
+ */
+export declare function printClusterReport(report: ClusterReport, limit?: number): string[];

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

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printClusterReport = exports.postProcessFeatureFolder = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const clusterer_1 = require("./clusterer");
+const log_1 = require("../../../util/log");
+const defaultmap_1 = require("../../../util/defaultmap");
+const ansi_1 = require("../../../util/ansi");
+const feature_1 = require("../../features/feature");
+const decorate_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/decorate");
+const file_provider_1 = require("../../output/file-provider");
+/**
+ * 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) {
+    if (!fs_1.default.existsSync(filepath)) {
+        log_1.log.warn(`Folder for ${filepath} does not exist, skipping post processing`);
+        return [];
+    }
+    const results = [];
+    for (const feature of features) {
+        const result = processFeatureFolder(filepath, feature);
+        if (result.length > 0) {
+            results.push(...result);
+        }
+    }
+    return results;
+}
+exports.postProcessFeatureFolder = postProcessFeatureFolder;
+/**
+ * Process a single feature folder like `Assignments/`
+ *
+ * @param filepath - Same as the input to {@link postProcessFeatureFolder}
+ * @param feature  - The (single) feature to process
+ */
+function processFeatureFolder(filepath, feature) {
+    const featureInfo = feature_1.ALL_FEATURES[feature];
+    const targetPath = path_1.default.join(filepath, featureInfo.name);
+    if (!fs_1.default.existsSync(targetPath)) {
+        log_1.log.warn(`Folder for ${feature} does not exist at ${targetPath} skipping post processing of this feature`);
+        return [];
+    }
+    log_1.log.info(`Processing ${feature} at ${targetPath}`);
+    const contextIdMap = new defaultmap_1.DefaultMap((0, decorate_1.deterministicCountingIdGenerator)());
+    const featureSubKeys = Object.keys(featureInfo.initialValue);
+    const reports = [];
+    for (const subKey of featureSubKeys) {
+        const value = processFeatureSubKey(targetPath, subKey, contextIdMap);
+        if (value !== undefined) {
+            reports.push(value);
+        }
+    }
+    return reports;
+}
+function processFeatureSubKey(featurePath, subKey, contextIdMap) {
+    const targetPath = path_1.default.join(featurePath, `${subKey}${file_provider_1.defaultStatisticsFileSuffix}`);
+    if (!fs_1.default.existsSync(targetPath)) {
+        log_1.log.warn(`Folder for ${subKey} does not exist at ${targetPath} skipping post processing of this key`);
+        return undefined;
+    }
+    return (0, clusterer_1.clusterStatisticsOutput)(targetPath, contextIdMap);
+}
+/**
+ * Prints the report to the console, but limits the output to the `limit` entries with the highest counts.
+ * The names of these entries (like `->`) are returned, so they can be used to filter the following histograms.
+ */
+function printClusterReport(report, limit = 1000) {
+    console.log('\n\n\n');
+    console.log(report.filepath);
+    const shortStats = [...report.valueInfoMap.entries()].map(([name, values]) => {
+        return {
+            name,
+            count: [...values.values()].reduce((a, b) => a + b, 0),
+            unique: values.size()
+        };
+    }).sort((a, b) => b.count - a.count).slice(0, limit);
+    const { longestName, longestCount, longestUnique } = shortStats.reduce((acc, { name, count, unique }) => {
+        return {
+            longestName: Math.max(acc.longestName, name.length),
+            longestCount: Math.max(acc.longestCount, count.toLocaleString().length),
+            longestUnique: Math.max(acc.longestUnique, unique.toLocaleString().length),
+        };
+    }, { longestName: 0, longestCount: 0, longestUnique: 0 });
+    for (const { name, count, unique } of shortStats) {
+        const strId = `${name}`.padEnd(longestName, ' ');
+        const strCount = count.toLocaleString().padStart(longestCount, ' ');
+        const strUnique = unique.toLocaleString().padStart(longestUnique, ' ');
+        const uniqueSuffix = `\t (${strUnique} ${ansi_1.formatter.format('unique', { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground })})`;
+        console.log(`\t${ansi_1.formatter.format(strId, { style: 1 /* FontStyles.Bold */ })}\t ${strCount} ` +
+            `${ansi_1.formatter.format('total', { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground })}`
+            + (count !== unique ? uniqueSuffix : ''));
+    }
+    return shortStats.map(({ name }) => name);
+}
+exports.printClusterReport = printClusterReport;
+//# sourceMappingURL=post-process-output.js.map

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

@@ -0,0 +1,11 @@
+import type { StatisticsSummarizerConfiguration } from '../summarizer';
+import type { CommonSummarizerConfiguration } from '../../../util/summarizer';
+/**
+ * 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
+ * @param outputPath   - The final outputPath to write the result to (may differ from the configured root folder)
+ */
+export declare function postProcessFeatureFolder(logger: CommonSummarizerConfiguration['logger'], filepath: string, config: StatisticsSummarizerConfiguration, outputPath: string): void;

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

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcessFeatureFolder = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const time_1 = require("../../../util/time");
+const summarizer_1 = require("../../../util/summarizer");
+const arrays_1 = require("../../../util/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];
+        const targetPath = path_1.default.join(filepath, featureInfo.name);
+        const targetFeature = path_1.default.join(outputPath, featureInfo.name);
+        if (!featureInfo.postProcess) {
+            logger(`    Skipping post processing of ${featureName} as no post processing behavior is defined`);
+            continue;
+        }
+        logger(`    Post processing of ${featureName}...`);
+        if (!fs_1.default.existsSync(targetFeature)) {
+            fs_1.default.mkdirSync(targetFeature, { recursive: true });
+        }
+        if (global.gc) {
+            logger(`    [${(0, time_1.date2string)(new Date())}] Running garbage collection (--expose-gc)`);
+            global.gc();
+        }
+        featureInfo.postProcess(targetPath, metaFeatureInformation, targetFeature, config);
+    }
+}
+function postProcessMeta(config, filepath, outputPath, logger, metaFeatureInformation) {
+    const fileStatisticsSummary = {
+        successfulParsed: [],
+        processingTimeMs: [],
+        failedRequests: [],
+        // min lengths of 1 etc. could come from different line endings
+        lines: [],
+        characters: [],
+        numberOfNormalizedNodes: []
+    };
+    if (!fs_1.default.existsSync(path_1.default.join(outputPath, 'meta'))) {
+        fs_1.default.mkdirSync(path_1.default.join(outputPath, 'meta'), { recursive: true });
+    }
+    const out = fs_1.default.createWriteStream(path_1.default.join(outputPath, 'meta', 'stats.csv'));
+    out.write(`file,successfulParsed,${(0, summarizer_1.summarizedMeasurement2CsvHeader)('processing')},failedRequests,${(0, summarizer_1.summarizedMeasurement2CsvHeader)('line-length')},${(0, summarizer_1.summarizedMeasurement2CsvHeader)('lines')},${(0, summarizer_1.summarizedMeasurement2CsvHeader)('characters')},numberOfNormalizedNodes\n`);
+    for (const [file, info] of metaFeatureInformation) {
+        // we could retrieve these by summing later as well :thinking: however, this makes it more explicit
+        const characters = (0, arrays_1.sum)(info.stats.lines[0]);
+        out.write(`${JSON.stringify(file)},${info.stats.successfulParsed},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(info.stats.processingTimeMs))},`
+            + `${info.stats.failedRequests.length},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(info.stats.lines[0]))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)([info.stats.lines[0].length]))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)([characters]))},${info.stats.numberOfNormalizedNodes[0]}\n`);
+        fileStatisticsSummary.successfulParsed.push(info.stats.successfulParsed);
+        fileStatisticsSummary.processingTimeMs.push(...info.stats.processingTimeMs);
+        fileStatisticsSummary.failedRequests.push(info.stats.failedRequests.length);
+        fileStatisticsSummary.lines.push(info.stats.lines[0]);
+        fileStatisticsSummary.characters.push(characters);
+        fileStatisticsSummary.numberOfNormalizedNodes.push(info.stats.numberOfNormalizedNodes[0]);
+    }
+    out.write(`all,${(0, arrays_1.sum)(fileStatisticsSummary.successfulParsed)},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.processingTimeMs))},`
+        + `${(0, arrays_1.sum)(fileStatisticsSummary.failedRequests)},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.lines.flat()))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.lines.map(l => l.length)))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.characters))},${(0, arrays_1.sum)(fileStatisticsSummary.numberOfNormalizedNodes)}\n`);
+    out.close();
+}
+/**
+ * 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
+ * @param outputPath   - The final outputPath to write the result to (may differ from the configured root folder)
+ */
+function postProcessFeatureFolder(logger, filepath, config, outputPath) {
+    if (!fs_1.default.existsSync(filepath)) {
+        logger(`    Folder for ${filepath} does not exist, skipping post processing`);
+        return;
+    }
+    if (!fs_1.default.existsSync(outputPath)) {
+        fs_1.default.mkdirSync(outputPath, { recursive: true });
+    }
+    const metaFeatureInformation = extractMetaInformationFrom(logger, path_1.default.join(filepath, 'meta', 'features.txt'), path_1.default.join(filepath, 'meta', 'stats.txt'));
+    postProcessFeatures(config, filepath, outputPath, logger, metaFeatureInformation);
+    postProcessMeta(config, filepath, outputPath, logger, metaFeatureInformation);
+}
+exports.postProcessFeatureFolder = postProcessFeatureFolder;
+function extractMetaInformationFrom(logger, metaFeaturesPath, metaStatsPath) {
+    const storage = new Map();
+    logger(`    [${(0, time_1.date2string)(new Date())}] Collect feature statistics`);
+    (0, files_1.readLineByLineSync)(metaFeaturesPath, (line, lineNumber) => {
+        if (line.length === 0) {
+            return;
+        }
+        if (lineNumber % 2_500 === 0) {
+            logger(`    [${(0, time_1.date2string)(new Date())}] ${lineNumber} meta feature lines processed`);
+        }
+        const meta = JSON.parse(line.toString());
+        storage.set(meta.file, meta.content);
+    });
+    logger(`    [${(0, time_1.date2string)(new Date())}] Collect meta statistics`);
+    (0, files_1.readLineByLineSync)(metaStatsPath, (line, lineNumber) => {
+        if (line.length === 0) {
+            return;
+        }
+        if (lineNumber % 2_500 === 0) {
+            logger(`    [${(0, time_1.date2string)(new Date())}] ${lineNumber} meta statistics lines processed`);
+        }
+        const meta = JSON.parse(line.toString());
+        const existing = storage.get(meta.file);
+        (0, assert_1.guard)(existing !== undefined, () => `Expected to find meta information for ${meta.file} in line ${lineNumber + 1} of ${metaFeaturesPath}`);
+        existing.stats = meta.content;
+    });
+    logger(`    [${(0, time_1.date2string)(new Date())}] Done collecting meta information`);
+    return storage;
+}
+//# sourceMappingURL=process.js.map

package/statistics/summarizer/summarizer.d.ts

@@ -0,0 +1,35 @@
+import type { CommonSummarizerConfiguration } from '../../util/summarizer';
+import { Summarizer } from '../../util/summarizer';
+import type { FeatureSelection } from '../features/feature';
+export interface StatisticsSummarizerConfiguration extends CommonSummarizerConfiguration {
+    /**
+     * The input path to read all zips from
+     */
+    inputPath: string;
+    /**
+     * Features to extract the summaries for
+     */
+    featuresToUse: FeatureSelection;
+    /**
+     * Path for the intermediate results of the preparation phase
+     */
+    intermediateOutputPath: string;
+    /**
+     * Path for the final results of the summarization phase
+     */
+    outputPath: string;
+    /**
+     * How many folders to skip to find the project root
+     */
+    projectSkip: number;
+}
+export declare const statisticsFileNameRegex: RegExp;
+export declare class StatisticsSummarizer extends Summarizer<unknown, StatisticsSummarizerConfiguration> {
+    constructor(config: StatisticsSummarizerConfiguration);
+    private removeIfExists;
+    /**
+     * The preparation phase essentially merges all files into one by just attaching lines together!
+     */
+    preparationPhase(useTypeClassification: boolean): Promise<void>;
+    summarizePhase(): Promise<unknown>;
+}

package/statistics/summarizer/summarizer.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatisticsSummarizer = exports.statisticsFileNameRegex = void 0;
+const tar_1 = require("tar");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const process_1 = require("./first-phase/process");
+const process_2 = require("./second-phase/process");
+const summarizer_1 = require("../../util/summarizer");
+const strings_1 = require("../../util/strings");
+const files_1 = require("../../util/files");
+const time_1 = require("../../util/time");
+exports.statisticsFileNameRegex = /.*--.*\.tar\.gz$/;
+/**
+ * The returned map contains the full path as key, mapping it to the complete contents.
+ */
+async function retrieveAllFilesInArchive(f) {
+    const filenames = new Map();
+    const promises = [];
+    (0, tar_1.list)({
+        file: f,
+        onentry: entry => {
+            if (entry.type === 'File') {
+                promises.push(entry.concat().then(content => {
+                    filenames.set(entry.path, content.toString());
+                }));
+            }
+        },
+        sync: true
+    });
+    await Promise.all(promises);
+    return filenames;
+}
+function identifyCommonPrefix(files) {
+    return (0, strings_1.longestCommonPrefix)([...files.keys()]);
+}
+/** returns the target path */
+async function extractArchive(f) {
+    const files = await retrieveAllFilesInArchive(f);
+    const commonRoot = identifyCommonPrefix(files);
+    // post process until we find the '<filename>.(r|R)' suffix. otherwise, if there are no features and only the meta folder, the meta folder will be removed, resulting in a write
+    // to the toplevel!
+    const fname = path_1.default.basename(f).replace(/\.tar\.gz$/, '');
+    const findIndex = commonRoot.indexOf(fname);
+    const commonPart = findIndex < 0 ? commonRoot.length : findIndex + fname.length;
+    // transform all map keys by removing the common root
+    const transformed = new Map();
+    for (const [key, value] of files.entries()) {
+        transformed.set(key.slice(commonPart), value);
+    }
+    return transformed;
+}
+// due to a redefinition after the initial statistic extraction, we extract the type from the remaining path :D
+// original: /^([^-]*)---?(.+)\.tar.gz/
+const filePrefixRegex = /^[^-]*---?(?<fullname>([^/]+)\/(?<pathtest>.+))\.tar\.gz$/;
+const testRegex = /.*test[-_]?(s|that|)\//i;
+/** if it starts with example-, this will return `'example'`, etc. if it starts with '--' this will return `undefined` */
+function identifyExtractionType(path) {
+    const match = filePrefixRegex.exec(path.replace(/／/g, '/'));
+    if (match === null || match?.groups === undefined) {
+        return undefined;
+    }
+    // recover
+    const originalFile = match.groups.fullname;
+    let folder;
+    if (testRegex.test(match.groups.pathtest)) {
+        folder = 'test';
+    }
+    else if (match.groups.pathtest.includes('example')) {
+        folder = 'example';
+    }
+    else {
+        folder = 'default';
+    }
+    return { folder, originalFile };
+}
+class StatisticsSummarizer extends summarizer_1.Summarizer {
+    constructor(config) {
+        super(config);
+    }
+    removeIfExists(path) {
+        if (path && fs_1.default.existsSync(path)) {
+            this.log(`Removing existing ${path}`);
+            fs_1.default.rmSync(path, { recursive: true, force: true });
+        }
+    }
+    /**
+     * The preparation phase essentially merges all files into one by just attaching lines together!
+     */
+    async preparationPhase(useTypeClassification) {
+        this.removeIfExists(this.config.intermediateOutputPath);
+        fs_1.default.mkdirSync(this.config.intermediateOutputPath, { recursive: true });
+        let count = 0;
+        const migrator = new process_1.FileMigrator();
+        for await (const f of (0, files_1.getAllFiles)(this.config.inputPath, /\.tar.gz$/)) {
+            this.log(`[${count++}, ${(0, time_1.date2string)()}] processing file ${f} (to ${this.config.intermediateOutputPath})`);
+            let target;
+            try {
+                target = await extractArchive(f);
+                this.log('    Collected!');
+            }
+            catch (e) {
+                this.log(`    Failed to extract ${f}, skipping...`);
+                continue;
+            }
+            this.log('    Migrating files...');
+            const extracted = identifyExtractionType(path_1.default.basename(f));
+            await migrator.migrate(target, path_1.default.join(this.config.intermediateOutputPath, useTypeClassification ? extracted?.folder ?? 'default' : 'uncategorized'), extracted?.originalFile);
+            this.log('    Done! (Cleanup...)');
+        }
+        migrator.finish();
+        this.log(`Found ${count} files to summarize`);
+        return Promise.resolve();
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await -- just to obey the structure
+    async summarizePhase() {
+        // detect all subfolders in the current folder (default, test...) for each: concat.
+        this.removeIfExists(this.config.outputPath);
+        fs_1.default.mkdirSync(this.config.outputPath, { recursive: true });
+        const folders = fs_1.default.readdirSync(this.config.intermediateOutputPath, { recursive: false });
+        for (const folder of folders) {
+            const folderStr = String(folder);
+            const output = path_1.default.join(this.config.outputPath, folderStr);
+            const input = path_1.default.join(this.config.intermediateOutputPath, folderStr);
+            this.log(`Summarizing for ${input} (target: ${output})`);
+            (0, process_2.postProcessFeatureFolder)(this.log, input, this.config, output);
+        }
+        return Promise.resolve(undefined);
+    }
+}
+exports.StatisticsSummarizer = StatisticsSummarizer;
+//# sourceMappingURL=summarizer.js.map

package/util/ansi.d.ts

@@ -33,11 +33,11 @@ export interface OutputFormatter {
 }
 export declare const voidFormatter: OutputFormatter;
 /**
- * This does not work if the {@link setFormatter | formatter} is void. Tries to format the text with a bold font weight.
+ * This does not work if the {@link setFormatter|formatter} is void. Tries to format the text with a bold font weight.
  */
 export declare function italic(s: string, f?: OutputFormatter, options?: FormatOptions): string;
 /**
- * This does not work if the {@link setFormatter | formatter} is void. Tries to format the text with an italic font shape.
+ * This does not work if the {@link setFormatter|formatter} is void. Tries to format the text with an italic font shape.
  */
 export declare function bold(s: string, f?: OutputFormatter, options?: FormatOptions): string;
 export declare const escape = "\u001B[";

package/util/ansi.js

@@ -19,14 +19,14 @@ exports.voidFormatter = new class {
     }
 }();
 /**
- * This does not work if the {@link setFormatter | formatter} is void. Tries to format the text with a bold font weight.
+ * This does not work if the {@link setFormatter|formatter} is void. Tries to format the text with a bold font weight.
  */
 function italic(s, f = exports.formatter, options) {
     return f.format(s, { style: 3 /* FontStyles.Italic */, ...options });
 }
 exports.italic = italic;
 /**
- * This does not work if the {@link setFormatter | formatter} is void. Tries to format the text with an italic font shape.
+ * This does not work if the {@link setFormatter|formatter} is void. Tries to format the text with an italic font shape.
  */
 function bold(s, f = exports.formatter, options) {
     return f.format(s, { style: 1 /* FontStyles.Bold */, ...options });

package/util/arrays.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Returns the tail of an array (all elements except the first one).
+ */
+export type TailOfArray<T extends unknown[]> = T extends [infer _, ...infer Rest] ? Rest : never;
 /**
  * Splits the array every time the given predicate fires.
  * The element the split appears on will not be included!
@@ -13,7 +17,12 @@
  * // => [[], [], [], []]
  * ```
  */
-export declare function splitArrayOn<T>(arr: T[], predicate: (elem: T) => boolean): T[][];
+export declare function splitArrayOn<T>(arr: readonly T[], predicate: (elem: T) => boolean): T[][];
+/**
+ * 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 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).
  *
@@ -42,3 +51,4 @@ export declare function sum(arr: 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>;
+export declare function arrayEqual<T>(a: readonly T[] | undefined, b: readonly T[] | undefined): boolean;

package/util/arrays.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.array2bag = exports.sum = exports.getUniqueCombinationsOfSize = exports.partition = exports.allPermutations = exports.splitArrayOn = void 0;
+exports.arrayEqual = exports.array2bag = exports.sum = exports.getUniqueCombinationsOfSize = exports.partition = exports.allPermutations = exports.partitionArray = exports.splitArrayOn = void 0;
 const assert_1 = require("./assert");
 /**
  * Splits the array every time the given predicate fires.
@@ -37,6 +37,24 @@ function splitArrayOn(arr, predicate) {
     return result;
 }
 exports.splitArrayOn = splitArrayOn;
+/**
+ * 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 partitionArray(arr, predicate) {
+    const left = [];
+    const right = [];
+    for (const elem of arr) {
+        if (predicate(elem)) {
+            left.push(elem);
+        }
+        else {
+            right.push(elem);
+        }
+    }
+    return [left, right];
+}
+exports.partitionArray = partitionArray;
 /**
  * Generate all permutations of the given array using Heap's algorithm (with its non-recursive variant).
  *
@@ -142,4 +160,19 @@ function array2bag(arr) {
     return result;
 }
 exports.array2bag = array2bag;
+function arrayEqual(a, b) {
+    if (a === undefined || b === undefined) {
+        return a === b;
+    }
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.arrayEqual = arrayEqual;
 //# sourceMappingURL=arrays.js.map

package/util/assert.d.ts

@@ -1,6 +1,7 @@
 /** use this to ensure that all cases are covered in case of a selection */
 export declare function assertUnreachable(x: never): never;
 export declare function isNotUndefined<T>(x: T | undefined): x is T;
+export declare function isUndefined<T>(x: T | undefined): x is undefined;
 export declare function isNotNull<T>(x: T | null): x is T;
 export type GuardMessage = string | (() => string);
 /**

package/util/assert.js

@@ -1,7 +1,7 @@
 "use strict";
 /** use this to ensure that all cases are covered in case of a selection */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.guard = exports.isNotNull = exports.isNotUndefined = exports.assertUnreachable = void 0;
+exports.guard = exports.isNotNull = exports.isUndefined = exports.isNotUndefined = exports.assertUnreachable = void 0;
 /* istanbul ignore next */
 function assertUnreachable(x) {
     throw new Error(`Unexpected object: ${JSON.stringify(x)}`);
@@ -11,6 +11,10 @@ function isNotUndefined(x) {
     return x !== undefined;
 }
 exports.isNotUndefined = isNotUndefined;
+function isUndefined(x) {
+    return x === undefined;
+}
+exports.isUndefined = isUndefined;
 function isNotNull(x) {
     return x !== null;
 }

package/util/cfg/cfg.d.ts

@@ -1,7 +1,8 @@
-import type { NodeId, NormalizedAst, ParentInformation } from '../../r-bridge';
-import { RFalse, RTrue } from '../../r-bridge';
 import type { MergeableRecord } from '../objects';
 import type { QuadSerializationConfiguration } from '../quads';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 export declare const enum CfgVertexType {
     /** Marks a break point in a construct (e.g., between the name and the value of an argument, or the formals and the body of a function)  */
     MidMarker = "mid-marker",