@eagleoutice/flowr 1.3.11

package/statistics/features/supported/values/post-process.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcess = void 0;
+const data_1 = require("../../../../util/summarizer/benchmark/data");
+const node_fs_1 = __importDefault(require("node:fs"));
+const path_1 = __importDefault(require("path"));
+const process_1 = require("../../../../util/summarizer/benchmark/first-phase/process");
+const files_1 = require("../../../../util/files");
+const time_1 = require("../../../../util/time");
+const arrays_1 = require("../../../../util/arrays");
+const post_processing_1 = require("../../post-processing");
+function postProcess(featureRoot, info, outputPath, config) {
+    const collected = {};
+    for (const [filepath, data] of info.entries()) {
+        const value = data.values;
+        for (const [key, val] of Object.entries(value)) {
+            let get = collected[key];
+            if (!get) {
+                get = (0, post_processing_1.emptySummarizedWithProject)();
+                collected[key] = get;
+            }
+            get.count.push(val);
+            if (val > 0) {
+                (0, post_processing_1.recordFilePath)(get, filepath, config);
+            }
+        }
+    }
+    const valuesOutStream = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, 'values.csv'));
+    valuesOutStream.write(`kind,unique-projects,unique-files,${(0, data_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [key, val] of Object.entries(collected)) {
+        const data = val;
+        const sum = (0, process_1.summarizeMeasurement)(data.count);
+        valuesOutStream.write(`${JSON.stringify(key)},${data.uniqueProjects.size},${data.uniqueFiles.size},${(0, data_1.summarizedMeasurement2Csv)(sum)}\n`);
+    }
+    valuesOutStream.close();
+    // now we read all numeric values to get the top used magic numbers (per file)
+    const valueMap = new Map();
+    (0, files_1.readLineByLineSync)(path_1.default.join(featureRoot, 'numeric.txt'), (line, lineNumber) => {
+        if (line.length === 0) {
+            return;
+        }
+        if (lineNumber % 2_500 === 0) {
+            console.log(`    [${(0, time_1.date2string)(new Date())}] Collecting numeric values ${lineNumber}`);
+        }
+        const [values, context] = JSON.parse(String(line));
+        const bag = (0, arrays_1.array2bag)(values);
+        for (const [key, val] of bag.entries()) {
+            let get = valueMap.get(key);
+            if (!get) {
+                get = { count: [], uniqueFiles: new Set(), uniqueProjects: new Set() };
+                valueMap.set(key, get);
+            }
+            get.count.push(val);
+            if (val > 0) {
+                get.uniqueFiles.add(context ?? '');
+                get.uniqueProjects.add(context?.split(path_1.default.sep)[config.projectSkip] ?? '');
+            }
+        }
+    });
+    const magicNumbersOutStream = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, 'magic-numbers.csv'));
+    magicNumbersOutStream.write(`num,unique-projects,unique-files,${(0, data_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [key, val] of valueMap.entries()) {
+        const sum = (0, process_1.summarizeMeasurement)(val.count);
+        magicNumbersOutStream.write(`${JSON.stringify(key)},${val.uniqueProjects.size},${val.uniqueFiles.size},${(0, data_1.summarizedMeasurement2Csv)(sum)}\n`);
+    }
+    magicNumbersOutStream.close();
+}
+exports.postProcess = postProcess;
+//# sourceMappingURL=post-process.js.map

package/statistics/features/supported/values/values.d.ts

@@ -0,0 +1,14 @@
+import { Feature } from '../../feature';
+import { Writable } from 'ts-essentials';
+declare const initialValueInfo: {
+    allNumerics: number;
+    imaginaryNumbers: number;
+    integers: number;
+    floatHex: number;
+    logical: number;
+    specialConstants: number;
+    strings: number;
+};
+export type ValueInfo = Writable<typeof initialValueInfo>;
+export declare const values: Feature<ValueInfo>;
+export {};

package/statistics/features/supported/values/values.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.values = void 0;
+const xpath = __importStar(require("xpath-ts2"));
+const r_bridge_1 = require("../../../../r-bridge");
+const assert_1 = require("../../../../util/assert");
+const output_1 = require("../../../output");
+const post_process_1 = require("./post-process");
+const initialValueInfo = {
+    allNumerics: 0,
+    imaginaryNumbers: 0,
+    integers: 0,
+    floatHex: 0,
+    logical: 0,
+    specialConstants: 0,
+    strings: 0
+};
+const numericConstantQuery = xpath.parse('//NUM_CONST');
+const stringConstantQuery = xpath.parse('//STR_CONST');
+const specialConstantsQuery = xpath.parse('//NULL_CONST');
+const shortLogicalSymbolQuery = xpath.parse('//SYMBOL[text() = \'T\' or text() = \'F\']');
+function classifyNumericConstants(numeric, existing) {
+    if (numeric === r_bridge_1.RTrue || numeric === r_bridge_1.RFalse) {
+        return 'logical';
+    }
+    if (numeric === r_bridge_1.RNa || numeric === 'NaN' || numeric === r_bridge_1.RNull || numeric === 'Inf' || numeric === '-Inf') {
+        return 'special-constants';
+    }
+    if (numeric.includes('i')) {
+        existing.imaginaryNumbers++;
+    }
+    else if (numeric.endsWith('L')) {
+        existing.integers++;
+    }
+    else if (r_bridge_1.RNumHexFloatRegex.test(numeric)) {
+        existing.floatHex++;
+    }
+    return 'allNumerics';
+}
+exports.values = {
+    name: 'Values',
+    description: 'All values used (as constants etc.)',
+    process(existing, input) {
+        const strings = stringConstantQuery.select({ node: input.parsedRAst });
+        const numerics = numericConstantQuery.select({ node: input.parsedRAst });
+        const specialConstants = specialConstantsQuery.select({ node: input.parsedRAst });
+        const specialLogicalSymbols = shortLogicalSymbolQuery.select({ node: input.parsedRAst });
+        const numbers = [];
+        numerics.map(n => [n, classifyNumericConstants(n.textContent ?? '<unknown>', existing)])
+            .forEach(([n, type]) => {
+            switch (type) {
+                case 'allNumerics':
+                    numbers.push(n);
+                    break;
+                case 'logical':
+                    specialLogicalSymbols.push(n);
+                    break;
+                case 'special-constants':
+                    specialConstants.push(n);
+                    break;
+                default:
+                    (0, assert_1.assertUnreachable)(type);
+            }
+        });
+        existing.strings += strings.length;
+        existing.allNumerics += numerics.length;
+        existing.specialConstants += specialConstants.length;
+        existing.logical += specialLogicalSymbols.length;
+        (0, output_1.appendStatisticsFile)(this.name, 'numeric', numbers, input.filepath);
+        (0, output_1.appendStatisticsFile)(this.name, 'string', strings, input.filepath);
+        (0, output_1.appendStatisticsFile)(this.name, 'specialConstant', specialConstants, input.filepath);
+        (0, output_1.appendStatisticsFile)(this.name, 'logical', specialLogicalSymbols, input.filepath);
+        return existing;
+    },
+    initialValue: initialValueInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=values.js.map

package/statistics/features/supported/variables/index.d.ts

@@ -0,0 +1 @@
+export { variables } from './variables';

package/statistics/features/supported/variables/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variables = void 0;
+var variables_1 = require("./variables");
+Object.defineProperty(exports, "variables", { enumerable: true, get: function () { return variables_1.variables; } });
+//# sourceMappingURL=index.js.map

package/statistics/features/supported/variables/post-process.d.ts

@@ -0,0 +1,9 @@
+import { FeatureStatisticsWithMeta } from '../../feature';
+import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+import { SummarizedWithProject } from '../../post-processing';
+export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;
+type VariableInfoMap = Map<string, SummarizedWithProject & {
+    linePercentageInFile: number[][];
+}>;
+export declare function writeVariableInfoToCsv(outputPath: string, filename: `${string}.csv`, data: VariableInfoMap): void;
+export {};

package/statistics/features/supported/variables/post-process.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeVariableInfoToCsv = exports.postProcess = void 0;
+const post_processing_1 = require("../../post-processing");
+const node_fs_1 = __importDefault(require("node:fs"));
+const path_1 = __importDefault(require("path"));
+const data_1 = require("../../../../util/summarizer/benchmark/data");
+const process_1 = require("../../../../util/summarizer/benchmark/first-phase/process");
+const files_1 = require("../../../../util/files");
+function collectUsedVariables(featureRoot, info, config, outputPath) {
+    const used = collectVariableInfoFor(path_1.default.join(featureRoot, 'usedVariables.txt'), info, config);
+    writeVariableInfoToCsv(outputPath, 'used-variables.csv', used);
+    // we manually clear these maps to save memory
+    used.clear();
+}
+function collectDefinedVariables(featureRoot, info, config, outputPath) {
+    const defined = collectVariableInfoFor(path_1.default.join(featureRoot, 'definedVariables.txt'), info, config);
+    writeVariableInfoToCsv(outputPath, 'defined-variables.csv', defined);
+    defined.clear();
+}
+function collectRedefinedVariables(featureRoot, info, config, outputPath) {
+    const redefined = collectVariableInfoFor(path_1.default.join(featureRoot, 'redefinedVariables.txt'), info, config);
+    writeVariableInfoToCsv(outputPath, 'redefined-variables.csv', redefined);
+    redefined.clear();
+}
+function writeVariableCountsToCsv(outputPath, collected) {
+    const variablesOutStream = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, 'variable-counts.csv'));
+    variablesOutStream.write(`kind,unique-projects,unique-files,${(0, data_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [key, val] of Object.entries(collected)) {
+        if (key === 'unknownVariables') {
+            // they are for function calls etc and in hindsight not a good idea
+            continue;
+        }
+        const data = val;
+        const sum = (0, process_1.summarizeMeasurement)(data.count);
+        variablesOutStream.write(`${JSON.stringify(key)},${data.uniqueProjects.size},${data.uniqueFiles.size},${(0, data_1.summarizedMeasurement2Csv)(sum)}\n`);
+    }
+    variablesOutStream.close();
+}
+function collectInformation(info, config) {
+    const collected = {};
+    for (const [filepath, data] of info.entries()) {
+        const value = data.variables;
+        for (const [key, val] of Object.entries(value)) {
+            let get = collected[key];
+            if (!get) {
+                get = (0, post_processing_1.emptySummarizedWithProject)();
+                collected[key] = get;
+            }
+            get.count.push(val);
+            if (val > 0) {
+                (0, post_processing_1.recordFilePath)(get, filepath, config);
+            }
+        }
+    }
+    return collected;
+}
+function postProcess(featureRoot, info, outputPath, config) {
+    const collected = collectInformation(info, config);
+    writeVariableCountsToCsv(outputPath, collected);
+    collectUsedVariables(featureRoot, info, config, outputPath);
+    collectDefinedVariables(featureRoot, info, config, outputPath);
+    collectRedefinedVariables(featureRoot, info, config, outputPath);
+}
+exports.postProcess = postProcess;
+function writeVariableInfoToCsv(outputPath, filename, data) {
+    const out = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, filename));
+    out.write(`variable,unique-projects,unique-files,${(0, data_1.summarizedMeasurement2CsvHeader)('count')},${(0, data_1.summarizedMeasurement2CsvHeader)('line-frac')}\n`);
+    for (const [key, val] of data.entries()) {
+        const { count, uniqueProjects, uniqueFiles, linePercentageInFile } = val;
+        const counts = (0, process_1.summarizeMeasurement)(count);
+        const lineFrac = (0, process_1.summarizeMeasurement)(linePercentageInFile.flat());
+        out.write(`${JSON.stringify(key)},${uniqueProjects.size},${uniqueFiles.size},${(0, data_1.summarizedMeasurement2Csv)(counts)},${(0, data_1.summarizedMeasurement2Csv)(lineFrac)}\n`);
+    }
+    out.close();
+}
+exports.writeVariableInfoToCsv = writeVariableInfoToCsv;
+function collectVariableInfoFor(filepath, info, config) {
+    // variable name to summary
+    const collected = new Map();
+    (0, files_1.readLineByLineSync)(filepath, (line, lineNumber) => {
+        if (line.length === 0) {
+            return;
+        }
+        if (lineNumber % 2_500 === 0) {
+            console.log(`    Processed ${lineNumber} lines of ${filepath}`);
+        }
+        const [vars, context] = JSON.parse(line.toString());
+        const numberOfLines = info.get(context ?? '')?.stats.lines[0].length;
+        // first we have to collect what this file gives us
+        const perFile = new Map();
+        for (const [name, [line]] of vars) {
+            let get = perFile.get(name);
+            if (!get) {
+                get = { ...(0, post_processing_1.emptySummarizedWithProject)(), linePercentageInFile: [] };
+                perFile.set(name, get);
+            }
+            get.count.push(1);
+            if (numberOfLines) {
+                get.linePercentageInFile.push(line / numberOfLines);
+            }
+        }
+        // now we merge it into the global map (oh gosh this is so horrible
+        for (const [name, data] of perFile.entries()) {
+            let get = collected.get(name);
+            if (!get) {
+                get = { ...(0, post_processing_1.emptySummarizedWithProject)(), linePercentageInFile: [] };
+                collected.set(name, get);
+            }
+            get.count.push(data.count.length);
+            get.linePercentageInFile.push(data.linePercentageInFile);
+            if (data.count.length > 0) {
+                (0, post_processing_1.recordFilePath)(get, context, config);
+            }
+        }
+    });
+    return collected;
+}
+//# sourceMappingURL=post-process.js.map

package/statistics/features/supported/variables/variables.d.ts

@@ -0,0 +1,15 @@
+import { Feature } from '../../feature';
+import { Writable } from 'ts-essentials';
+declare const initialVariableInfo: {
+    numberOfVariableUses: number;
+    numberOfDefinitions: number;
+    numberOfRedefinitions: number;
+    unknownVariables: number;
+};
+export type VariableInfo = Writable<typeof initialVariableInfo>;
+export type DefinedVariableInformation = [
+    name: string,
+    location: [line: number, character: number]
+];
+export declare const variables: Feature<VariableInfo>;
+export {};

package/statistics/features/supported/variables/variables.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variables = void 0;
+const r_bridge_1 = require("../../../../r-bridge");
+const output_1 = require("../../../output");
+const dataflow_1 = require("../../../../dataflow");
+const post_process_1 = require("./post-process");
+const initialVariableInfo = {
+    numberOfVariableUses: 0,
+    numberOfDefinitions: 0,
+    numberOfRedefinitions: 0,
+    // we failed to get the type/role, maybe for function call names etc.
+    unknownVariables: 0
+};
+function visitVariables(info, input) {
+    // same-def-def edges are bidirectional, we want to avoid counting them twice!
+    const redefinedBlocker = new Set();
+    (0, r_bridge_1.visitAst)(input.normalizedRAst.ast, node => {
+        if (node.type !== "RSymbol" /* RType.Symbol */ || (0, r_bridge_1.isSpecialSymbol)(node)) {
+            return;
+        }
+        // search for the node in the DF graph
+        const mayNode = input.dataflow.graph.get(node.info.id);
+        if (mayNode === undefined) {
+            info.unknownVariables++;
+            (0, output_1.appendStatisticsFile)(exports.variables.name, 'unknown', [[
+                    node.info.fullLexeme ?? node.lexeme,
+                    [node.location.start.line, node.location.start.column]
+                ]], input.filepath);
+            return;
+        }
+        const [dfNode, edges] = mayNode;
+        if (dfNode.tag === 'variable-definition') {
+            info.numberOfDefinitions++;
+            const lexeme = node.info.fullLexeme ?? node.lexeme;
+            (0, output_1.appendStatisticsFile)(exports.variables.name, 'definedVariables', [[
+                    lexeme,
+                    [node.location.start.line, node.location.start.column]
+                ]], input.filepath);
+            // check for redefinitions
+            const hasRedefinitions = [...edges.entries()].some(([target, edge]) => !redefinedBlocker.has(target) && edge.types.has(dataflow_1.EdgeType.SameDefDef));
+            if (hasRedefinitions) {
+                info.numberOfRedefinitions++;
+                redefinedBlocker.add(node.info.id);
+                (0, output_1.appendStatisticsFile)(exports.variables.name, 'redefinedVariables', [[
+                        lexeme,
+                        [node.location.start.line, node.location.start.column]
+                    ]], input.filepath);
+            }
+        }
+        else if (dfNode.tag === 'use') {
+            info.numberOfVariableUses++;
+            (0, output_1.appendStatisticsFile)(exports.variables.name, 'usedVariables', [[
+                    node.info.fullLexeme ?? node.lexeme,
+                    [node.location.start.line, node.location.start.column]
+                ]], input.filepath);
+        }
+    });
+}
+exports.variables = {
+    name: 'Variables',
+    description: 'Variable Usage, Assignments, and Redefinitions',
+    process(existing, input) {
+        visitVariables(existing, input);
+        return existing;
+    },
+    initialValue: initialVariableInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=variables.js.map

package/statistics/index.d.ts

@@ -0,0 +1,6 @@
+export * from './statistics';
+export * from './features';
+export * from './output';
+export * from '../util/summarizer/statistics/post-process';
+export { initialMetaStatistics } from './meta-statistics';
+export { MetaStatistics } from './meta-statistics';

package/statistics/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialMetaStatistics = void 0;
+__exportStar(require("./statistics"), exports);
+__exportStar(require("./features"), exports);
+__exportStar(require("./output"), exports);
+__exportStar(require("../util/summarizer/statistics/post-process"), exports);
+var meta_statistics_1 = require("./meta-statistics");
+Object.defineProperty(exports, "initialMetaStatistics", { enumerable: true, get: function () { return meta_statistics_1.initialMetaStatistics; } });
+//# sourceMappingURL=index.js.map

package/statistics/meta-statistics.d.ts

@@ -0,0 +1,33 @@
+import { RParseRequestFromFile, RParseRequestFromText } from '../r-bridge';
+/**
+ * Statistics on skipped files, the time required, and more.
+ *
+ * @see extractUsageStatistics
+ * @see initialMetaStatistics
+ */
+export interface MetaStatistics {
+    /**
+   * The number of requests that were parsed successfully
+   */
+    successfulParsed: number;
+    /**
+   * The processing time for each request
+   */
+    processingTimeMs: number[];
+    /**
+   * All failed requests (e.g., if they can not be converted to XML)
+   */
+    failedRequests: (RParseRequestFromText | RParseRequestFromFile)[];
+    /**
+   * Number of lines with each individual line length consumed for each request
+   */
+    lines: number[][];
+    /**
+     * The number of nodes in the normalized AST
+     */
+    numberOfNormalizedNodes: number[];
+}
+/**
+ * Returns an initial {@link MetaStatistics} object, using neutral defaults (like the empty list).
+ */
+export declare function initialMetaStatistics(): MetaStatistics;

package/statistics/meta-statistics.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialMetaStatistics = void 0;
+/**
+ * Returns an initial {@link MetaStatistics} object, using neutral defaults (like the empty list).
+ */
+function initialMetaStatistics() {
+    return {
+        successfulParsed: 0,
+        numberOfNormalizedNodes: [],
+        processingTimeMs: [],
+        failedRequests: [],
+        lines: []
+    };
+}
+exports.initialMetaStatistics = initialMetaStatistics;
+//# sourceMappingURL=meta-statistics.js.map

package/statistics/output/ansi.d.ts

@@ -0,0 +1,50 @@
+export declare const enum FontStyles {
+    Bold = 1,
+    Faint = 2,
+    Italic = 3,
+    Underline = 4
+}
+export declare const enum Colors {
+    Black = 0,
+    Red = 1,
+    Green = 2,
+    Yellow = 3,
+    Blue = 4,
+    Magenta = 5,
+    Cyan = 6,
+    White = 7
+}
+export declare enum ColorEffect {
+    Foreground = 30,
+    Background = 40
+}
+export type FormatOptions = ColorFormatOptions | WeightFormatOptions | ColorFormatOptions & WeightFormatOptions;
+export interface ColorFormatOptions {
+    color: Colors;
+    effect: ColorEffect;
+}
+export interface WeightFormatOptions {
+    style: FontStyles;
+}
+export interface OutputFormatter {
+    format(input: string, options?: FormatOptions): string;
+    getFormatString(options?: FormatOptions): string;
+    reset(): string;
+}
+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.
+ */
+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.
+ */
+export declare function bold(s: string, f?: OutputFormatter, options?: FormatOptions): string;
+export declare const escape = "\u001B[";
+export declare const ansiFormatter: {
+    reset(): string;
+    format(input: string, options?: FormatOptions): string;
+    getFormatString(options?: FormatOptions): string;
+};
+export declare let formatter: OutputFormatter;
+export declare function setFormatter(setFormatter: OutputFormatter): void;

package/statistics/output/ansi.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setFormatter = exports.formatter = exports.ansiFormatter = exports.escape = exports.bold = exports.italic = exports.voidFormatter = exports.ColorEffect = void 0;
+// noinspection JSUnusedGlobalSymbols
+var ColorEffect;
+(function (ColorEffect) {
+    ColorEffect[ColorEffect["Foreground"] = 30] = "Foreground";
+    ColorEffect[ColorEffect["Background"] = 40] = "Background";
+})(ColorEffect || (exports.ColorEffect = ColorEffect = {}));
+exports.voidFormatter = new class {
+    format(input) {
+        return input;
+    }
+    getFormatString(_options) {
+        return '';
+    }
+    reset() {
+        return '';
+    }
+};
+/**
+ * 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.
+ */
+function bold(s, f = exports.formatter, options) {
+    return f.format(s, { style: 1 /* FontStyles.Bold */, ...options });
+}
+exports.bold = bold;
+exports.escape = '\x1b[';
+const colorSuffix = 'm';
+exports.ansiFormatter = {
+    reset() {
+        return `${exports.escape}0${colorSuffix}`;
+    },
+    format(input, options) {
+        return `${this.getFormatString(options)}${input}${this.reset()}`;
+    },
+    getFormatString(options) {
+        if (options === undefined) {
+            return '';
+        }
+        const colorString = 'color' in options ? `${options.effect + options.color}` : '';
+        const weightString = 'style' in options ? `${options.style}` : '';
+        return `${exports.escape}${colorString}${weightString !== '' ? ';' : ''}${weightString}${colorSuffix}`;
+    }
+};
+exports.formatter = exports.ansiFormatter;
+function setFormatter(setFormatter) {
+    exports.formatter = setFormatter;
+}
+exports.setFormatter = setFormatter;
+//# sourceMappingURL=ansi.js.map

package/statistics/output/file-provider.d.ts

@@ -0,0 +1,37 @@
+export type AppendFnType = string | number | symbol;
+export interface StatisticAppendProvider {
+    append(name: string, fn: AppendFnType, content: string): void;
+}
+export type DummyAppendMemoryMap = Map<string, Map<AppendFnType, string[]>>;
+export declare class DummyAppendProvider implements StatisticAppendProvider {
+    private readonly map;
+    /**
+     * If you pass a map the dummy will log all append calls to the map, using the feature name and the appendage type as keys
+     *
+     * @param map - The map to log to
+     */
+    constructor(map?: DummyAppendMemoryMap | undefined);
+    append(name: string, fn: AppendFnType, content: string): void;
+}
+export declare const defaultStatisticsFileSuffix = ".txt";
+/**
+ * Provides cached open connections for all files to connect.
+ * allowing to append to the same file often.
+ * <p>
+ * While we could simply reopen these files, it is safer/more performant to keep the connection open.
+ */
+export declare class StatisticFileProvider implements StatisticAppendProvider {
+    readonly statisticsDirectory: string;
+    private readonly connections;
+    constructor(statisticsDirectory: string | undefined);
+    /**
+   * @param name - the name of the feature {@link Feature#name}
+   * @param fn - the name of the feature-aspect to record
+   */
+    private statisticsFile;
+    /**
+   * Append the given content to the information for a feature of the given name and function.
+   */
+    append(name: string, fn: AppendFnType, content: string): void;
+    private getHandle;
+}