@eagleoutice/flowr 1.3.11

package/statistics/features/feature.d.ts

@@ -0,0 +1,175 @@
+import { EvalOptions } from 'xpath-ts2/src/parse-api';
+import { MergeableRecord } from '../../util/objects';
+import { NormalizedAst } from '../../r-bridge';
+import { DataflowInformation } from '../../dataflow/internal/info';
+import { MetaStatistics } from '../meta-statistics';
+import { StatisticsSummarizerConfiguration } from '../../util/summarizer/statistics/summarizer';
+/**
+ * Maps each sub-feature name to the number of occurrences of that sub-feature.
+ * Allows for one nesting level to denote hierarchical features.
+ * <p>
+ * Since we are writing to files {@link process}, we only count feature occurrences (some feature/parts are not written to file)
+ */
+export type FeatureInfo = Record<string, unknown> & MergeableRecord;
+/**
+ * The information and context that a {@link FeatureProcessor} may operate in.
+ */
+export interface FeatureProcessorInput extends MergeableRecord {
+    /** The XML Document representing the parsed (non-normalized) R AST */
+    readonly parsedRAst: Document;
+    /** The R AST, after the normalization step */
+    readonly normalizedRAst: NormalizedAst;
+    /** The dataflow information for the given input */
+    readonly dataflow: DataflowInformation;
+    /** The filepath that the document originated from (if present, may be undefined if the input was provided as text). This can be relative to the common root directory of requests. */
+    readonly filepath: string | undefined;
+}
+/**
+ * A function that processes the analysis results of a document and returns the feature information.
+ */
+export type FeatureProcessor<T extends FeatureInfo> = (existing: T, input: FeatureProcessorInput) => T;
+/**
+ * A feature is something to be retrieved by the statistics.
+ *
+ * @typeParam T - The type of what should be collected for the feature
+ *
+ * @see ALL_FEATURES
+ */
+export interface Feature<T extends FeatureInfo> {
+    /** A descriptive, yet unique name of the feature */
+    readonly name: string;
+    /** A description of the feature */
+    readonly description: string;
+    /** A function that retrieves the feature in the document appends it to the existing feature set (we could use a monoid :D), the filepath corresponds to the active file (if any) */
+    process: FeatureProcessor<T>;
+    /**
+     * If present, this feature allows to post-process the results of the feature extraction (for the summarizer).
+     * <p>
+     * The extraction can use the output path to write files to, and should return the final output.
+     *
+     * @param featureRoot - The root path to the feature directory which should contain all the files the feature can write to (already merged for every file processed)
+     * @param info        - The feature statistic maps each file name/context encountered to the feature information as well as the meta statistics for the file
+     * @param outputPath  - The path to write the output to (besides what is collected in the output and meta information)
+     * @param config      - The configuration for the summarizer (e.g., to obtain the number of folders to skip for the feature root)
+     */
+    postProcess?: (featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration) => void;
+    /** Values to start the existing track from */
+    initialValue: T;
+}
+/**
+ * The source of truth for all features that are supported by the statistics.
+ */
+export declare const ALL_FEATURES: {
+    readonly usedPackages: Feature<import("ts-essentials").Writable<{
+        library: number;
+        require: number;
+        loadNamespace: number;
+        requireNamespace: number;
+        attachNamespace: number;
+        withinApply: number;
+        '::': number;
+        ':::': number;
+        '<loadedByVariable>': number;
+    }>>;
+    readonly comments: Feature<import("ts-essentials").Writable<{
+        totalAmount: number;
+        roxygenComments: number;
+        import: number;
+        importFrom: number;
+        importMethodsFrom: number;
+        importClassesFrom: number;
+        useDynLib: number;
+        export: number;
+        exportClass: number;
+        exportMethod: number;
+        exportS3Method: number;
+        exportPattern: number;
+    }>>;
+    readonly definedFunctions: Feature<import("ts-essentials").Writable<{
+        total: number;
+        lambdasOnly: number;
+        assignedFunctions: number;
+        nestedFunctions: number;
+        recursive: number;
+        deepestNesting: number;
+    }>>;
+    readonly usedFunctions: Feature<import("ts-essentials").Writable<{
+        allFunctionCalls: number;
+        args: Record<number, bigint | import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>>;
+        nestedFunctionCalls: number;
+        deepestNesting: number;
+        unnamedCalls: number;
+    }>>;
+    readonly values: Feature<import("ts-essentials").Writable<{
+        allNumerics: number;
+        imaginaryNumbers: number;
+        integers: number;
+        floatHex: number;
+        logical: number;
+        specialConstants: number;
+        strings: number;
+    }>>;
+    readonly assignments: Feature<import("ts-essentials").Writable<{
+        assignmentOperator: Record<string, bigint>;
+        assigned: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        deepestNesting: number;
+        nestedOperatorAssignment: number;
+    }>>;
+    readonly loops: Feature<import("ts-essentials").Writable<{
+        forLoops: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        forLoopVar: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        forBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        whileLoops: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        whileBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        repeatLoops: bigint;
+        repeatBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        breakStatements: number;
+        nextStatements: number;
+        implicitLoops: number;
+        nestedExplicitLoops: number;
+        deepestExplicitNesting: number;
+    }>>;
+    readonly controlflow: Feature<import("ts-essentials").Writable<{
+        ifThen: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        thenBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        ifThenElse: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        elseBody: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+        nestedIfThen: number;
+        nestedIfThenElse: number;
+        deepestNesting: number;
+        switchCase: import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+    }>>;
+    readonly dataAccess: Feature<import("ts-essentials").Writable<{
+        singleBracket: Record<number, bigint | import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>>;
+        doubleBracket: Record<number, bigint | import("./common-syntax-probability").CommonSyntaxTypeCounts<bigint>>;
+        chainedOrNestedAccess: number;
+        longestChain: number;
+        deepestNesting: number;
+        byName: number;
+        bySlot: number;
+    }>>;
+    readonly expressionList: Feature<import("ts-essentials").Writable<{
+        allExpressionLists: number;
+        deepestNesting: number;
+    }>>;
+    readonly variables: Feature<import("ts-essentials").Writable<{
+        numberOfVariableUses: number;
+        numberOfDefinitions: number;
+        numberOfRedefinitions: number;
+        unknownVariables: number;
+    }>>;
+};
+export type FeatureKey = keyof typeof ALL_FEATURES;
+export type FeatureValue<K extends FeatureKey> = ReturnType<typeof ALL_FEATURES[K]['process']>;
+/** If the user passes `all`, this should be every feature present in {@link ALL_FEATURES} (see {@link allFeatureNames})*/
+export type FeatureSelection = Set<FeatureKey>;
+export declare const allFeatureNames: Set<FeatureKey>;
+export type FeatureStatistics = {
+    [K in FeatureKey]: FeatureInfo;
+};
+export type FeatureStatisticsWithMeta = FeatureStatistics & {
+    stats: MetaStatistics;
+};
+export interface Query {
+    select(options?: EvalOptions): Node[];
+}

package/statistics/features/feature.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allFeatureNames = exports.ALL_FEATURES = void 0;
+/**
+ * This module holds the definition of what a {@link Feature} that can be extracted from an R AST is.
+ *
+ * Furthermore, it contains the definition of all features that are known in {@link ALL_FEATURES}.
+ *
+ * @module
+ */
+const supported_1 = require("./supported");
+const variables_1 = require("./supported/variables/variables");
+/**
+ * The source of truth for all features that are supported by the statistics.
+ */
+exports.ALL_FEATURES = {
+    usedPackages: supported_1.usedPackages,
+    comments: supported_1.comments,
+    definedFunctions: supported_1.definedFunctions,
+    usedFunctions: supported_1.usedFunctions,
+    values: supported_1.values,
+    assignments: supported_1.assignments,
+    loops: supported_1.loops,
+    controlflow: supported_1.controlflow,
+    dataAccess: supported_1.dataAccess,
+    expressionList: supported_1.expressionList,
+    variables: variables_1.variables
+};
+exports.allFeatureNames = new Set(Object.keys(exports.ALL_FEATURES));
+//# sourceMappingURL=feature.js.map

package/statistics/features/index.d.ts

@@ -0,0 +1 @@
+export * from './feature';

package/statistics/features/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./feature"), exports);
+//# sourceMappingURL=index.js.map

package/statistics/features/post-processing.d.ts

@@ -0,0 +1,12 @@
+import { MergeableRecord } from '../../util/objects';
+import { StatisticsSummarizerConfiguration } from '../../util/summarizer/statistics/summarizer';
+export interface SummarizedWithProject<Uniques = Set<string>, Count = number[]> {
+    uniqueProjects: Uniques;
+    uniqueFiles: Uniques;
+    count: Count;
+}
+export declare function emptySummarizedWithProject(): SummarizedWithProject;
+export type ReplaceKeysForSummary<Source, Target> = MergeableRecord & {
+    [K in keyof Source]: Target;
+};
+export declare function recordFilePath(summarize: SummarizedWithProject, filepath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/post-processing.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordFilePath = exports.emptySummarizedWithProject = void 0;
+const path_1 = __importDefault(require("path"));
+function emptySummarizedWithProject() {
+    return {
+        uniqueProjects: new Set(),
+        uniqueFiles: new Set(),
+        count: []
+    };
+}
+exports.emptySummarizedWithProject = emptySummarizedWithProject;
+function recordFilePath(summarize, filepath, config) {
+    summarize.uniqueFiles.add(filepath);
+    summarize.uniqueProjects.add(filepath.split(path_1.default.sep)[config.projectSkip] ?? '');
+}
+exports.recordFilePath = recordFilePath;
+//# sourceMappingURL=post-processing.js.map

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

@@ -0,0 +1,11 @@
+import { Feature } from '../../feature';
+import { Writable } from 'ts-essentials';
+declare const initialAssignmentInfo: {
+    assignmentOperator: Record<string, bigint>;
+    assigned: import("../../common-syntax-probability").CommonSyntaxTypeCounts<bigint>;
+    deepestNesting: number;
+    nestedOperatorAssignment: number;
+};
+export type AssignmentInfo = Writable<typeof initialAssignmentInfo>;
+export declare const assignments: Feature<AssignmentInfo>;
+export {};

package/statistics/features/supported/assignments/assignments.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignments = void 0;
+const common_syntax_probability_1 = require("../../common-syntax-probability");
+const r_bridge_1 = require("../../../../r-bridge");
+const post_process_1 = require("./post-process");
+const initialAssignmentInfo = {
+    // operator to occurrence count
+    assignmentOperator: {},
+    assigned: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(),
+    // find combinations like `` is most often used for functions?
+    deepestNesting: 0,
+    nestedOperatorAssignment: 0
+};
+function visitAssignment(info, input) {
+    const assignmentStack = [];
+    (0, r_bridge_1.visitAst)(input.normalizedRAst.ast, node => {
+        if (node.type !== "RBinaryOp" /* RType.BinaryOp */ || node.flavor !== 'assignment') {
+            return;
+        }
+        if (assignmentStack.length > 0) {
+            info.nestedOperatorAssignment++;
+            info.deepestNesting = Math.max(info.deepestNesting, assignmentStack.length);
+        }
+        assignmentStack.push(node);
+        info.assignmentOperator[node.operator] = (info.assignmentOperator[node.operator] ?? 0n) + 1n;
+        switch (node.operator) {
+            case '->':
+            case '->>':
+                info.assigned = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.assigned, node.lhs);
+                break;
+            default:
+                info.assigned = (0, common_syntax_probability_1.updateCommonSyntaxTypeCounts)(info.assigned, node.rhs);
+                break;
+        }
+    }, node => {
+        // drop again :D
+        if (node.type === "RBinaryOp" /* RType.BinaryOp */ && node.flavor === 'assignment') {
+            assignmentStack.pop();
+        }
+    });
+}
+exports.assignments = {
+    name: 'Assignments',
+    description: 'all ways to assign something in R',
+    process(existing, input) {
+        visitAssignment(existing, input);
+        return existing;
+    },
+    initialValue: initialAssignmentInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=assignments.js.map

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { FeatureStatisticsWithMeta } from '../../feature';
+import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

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

@@ -0,0 +1,125 @@
+"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 common_syntax_probability_1 = require("../../common-syntax-probability");
+const numbers_1 = require("../../../../util/numbers");
+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 arrays_1 = require("../../../../util/arrays");
+const assert_1 = require("../../../../util/assert");
+function appendOperators(base, b, filepath, config) {
+    for (const [key, val] of Object.entries(b)) {
+        let get = base.assignmentOperator[key];
+        if (!get) {
+            get = { uniqueFiles: new Set(), uniqueProjects: new Set(), counts: [] };
+            base.assignmentOperator[key] = get;
+        }
+        const num = (0, numbers_1.bigint2number)(val);
+        get.counts.push([num]);
+        if (num > 0) {
+            get.uniqueFiles.add(filepath);
+            get.uniqueProjects.add(filepath.split(path_1.default.sep)[config.projectSkip] ?? '');
+        }
+    }
+}
+// returns a map that for each combination of operators found (like `<-,=`) returns the number of projects and files
+// that use both of them
+function retrieveUsageCombinationCounts(collected) {
+    const ops = Object.keys(collected.assignmentOperator);
+    if (ops.length < 1) {
+        return new Map();
+    }
+    const allCombinations = [...(0, arrays_1.getUniqueCombinationsOfSize)(ops, 1)];
+    const store = new Map;
+    for (const combs of allCombinations) {
+        if (combs.length === 1) {
+            // we can just copy the information
+            const { uniqueProjects, uniqueFiles } = collected.assignmentOperator[combs[0]];
+            store.set(combs[0], { uniqueProjects, uniqueFiles });
+            continue;
+        }
+        const existingKey = combs.slice(0, -1).join(',');
+        const existing = store.get(existingKey);
+        (0, assert_1.guard)(existing !== undefined, `Unable to retrieve cache for ${existingKey}`);
+        const newKey = combs.join(',');
+        const { uniqueProjects, uniqueFiles } = collected.assignmentOperator[combs[combs.length - 1]];
+        const newUniqueProjects = new Set([...existing.uniqueProjects].filter(x => uniqueProjects.has(x)));
+        const newUniqueFiles = new Set([...existing.uniqueFiles].filter(x => uniqueFiles.has(x)));
+        store.set(newKey, { uniqueProjects: newUniqueProjects, uniqueFiles: newUniqueFiles });
+    }
+    const result = new Map();
+    for (const [key, val] of store.entries()) {
+        result.set(key, { uniqueProjects: val.uniqueProjects.size, uniqueFiles: val.uniqueFiles.size });
+    }
+    return result;
+}
+function writeOperatorCombinationsUsageToCsv(collected, outputPath) {
+    // now to get all projects exhausted with _only_ a given subset (e.g., all projects only using '=')
+    const operators = retrieveUsageCombinationCounts(collected);
+    const out = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-assigned-combinations.csv'));
+    out.write('assignment,unique-projects,unique-files\n');
+    for (const [key, val] of operators.entries()) {
+        out.write(`${JSON.stringify(key)},${val.uniqueProjects},${val.uniqueFiles}\n`);
+    }
+    out.close();
+}
+function writeAssignmentMetadataToCsv(outputPath, collected) {
+    const out = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-meta.csv'));
+    out.write(`kind,${(0, data_1.summarizedMeasurement2CsvHeader)()}\n`);
+    const summarizedDeepestNesting = (0, process_1.summarizeMeasurement)(collected.deepestNesting.flat());
+    out.write(`deepest-nesting,${(0, data_1.summarizedMeasurement2Csv)(summarizedDeepestNesting)}\n`);
+    const summarizedNestedOperatorAssignment = (0, process_1.summarizeMeasurement)(collected.nestedOperatorAssignment.flat());
+    out.write(`nested-operator-assignment,${(0, data_1.summarizedMeasurement2Csv)(summarizedNestedOperatorAssignment)}\n`);
+    out.close();
+}
+function writeAssignedTypesToCsv(outputPath, collected) {
+    const out = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-assigned.csv'));
+    out.write(`kind,name,${(0, data_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [entryName, values] of Object.entries(collected.assigned)) {
+        if (Array.isArray(values)) {
+            out.write(`${JSON.stringify(entryName)},"",${(0, data_1.summarizedMeasurement2Csv)((0, process_1.summarizeMeasurement)(values.flat()))}\n`);
+        }
+        else {
+            for (const [keyName, keyValue] of Object.entries(values)) {
+                out.write(`${JSON.stringify(entryName)},${JSON.stringify(keyName)},${(0, data_1.summarizedMeasurement2Csv)((0, process_1.summarizeMeasurement)(keyValue.flat()))}\n`);
+            }
+        }
+    }
+    out.close();
+}
+function writeAssignmentOperatorsToCsv(outputPath, collected) {
+    const fnOutStream = node_fs_1.default.createWriteStream(path_1.default.join(outputPath, 'assignments-assignment-operators.csv'));
+    fnOutStream.write(`assignment,unique-projects,unique-files,${(0, data_1.summarizedMeasurement2CsvHeader)()}\n`);
+    for (const [key, val] of Object.entries(collected.assignmentOperator)) {
+        const { uniqueProjects, uniqueFiles, counts } = val;
+        const summarized = (0, data_1.summarizedMeasurement2Csv)((0, process_1.summarizeMeasurement)(counts.flat()));
+        fnOutStream.write(`${JSON.stringify(key)},${uniqueProjects.size},${uniqueFiles.size},${summarized}\n`);
+    }
+    fnOutStream.close();
+}
+function postProcess(featureRoot, info, outputPath, config) {
+    const collected = {
+        assignmentOperator: {},
+        assigned: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => []),
+        deepestNesting: [],
+        nestedOperatorAssignment: []
+    };
+    for (const [filepath, data] of info.entries()) {
+        const assignmentInfo = data.assignments;
+        collected.deepestNesting.push([assignmentInfo.deepestNesting]);
+        collected.nestedOperatorAssignment.push([assignmentInfo.nestedOperatorAssignment]);
+        (0, common_syntax_probability_1.appendCommonSyntaxTypeCounter)(collected.assigned, assignmentInfo.assigned);
+        appendOperators(collected, assignmentInfo.assignmentOperator, filepath, config);
+    }
+    writeAssignmentOperatorsToCsv(outputPath, collected);
+    writeOperatorCombinationsUsageToCsv(collected, outputPath);
+    writeAssignmentMetadataToCsv(outputPath, collected);
+    writeAssignedTypesToCsv(outputPath, collected);
+}
+exports.postProcess = postProcess;
+//# sourceMappingURL=post-process.js.map

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

@@ -0,0 +1,18 @@
+import { Feature } from '../../feature';
+import { Writable } from 'ts-essentials';
+export declare const initialCommentInfo: {
+    totalAmount: number;
+    roxygenComments: number;
+    import: number;
+    importFrom: number;
+    importMethodsFrom: number;
+    importClassesFrom: number;
+    useDynLib: number;
+    export: number;
+    exportClass: number;
+    exportMethod: number;
+    exportS3Method: number;
+    exportPattern: number;
+};
+export type CommentInfo = Writable<typeof initialCommentInfo>;
+export declare const comments: Feature<CommentInfo>;

package/statistics/features/supported/comments/comments.js

@@ -0,0 +1,133 @@
+"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.comments = exports.initialCommentInfo = void 0;
+const xpath = __importStar(require("xpath-ts2"));
+const assert_1 = require("../../../../util/assert");
+const output_1 = require("../../../output");
+const post_process_1 = require("./post-process");
+exports.initialCommentInfo = {
+    totalAmount: 0,
+    roxygenComments: 0,
+    import: 0,
+    importFrom: 0,
+    importMethodsFrom: 0,
+    importClassesFrom: 0,
+    useDynLib: 0,
+    export: 0,
+    exportClass: 0,
+    exportMethod: 0,
+    exportS3Method: 0,
+    exportPattern: 0
+};
+const commentQuery = xpath.parse('//COMMENT');
+const importRegex = /^'\s*@import\s+(?<package>\S+)/;
+const importFromRegex = /^'\s*@importFrom\s+(?<package>\S+)(?<fn>( +\S+)+)$/;
+const useDynLibRegex = /^'\s*@useDynLib\s+(?<package>\S+)(?<fn>( +\S+)+)?$/;
+/** we still name the classes fn, so we can reuse processing code */
+const importClassesFromRegex = /^'\s*@importClassesFrom\s+(?<package>\S+)(?<fn>( +\S+)+)$/;
+const importMethodsFrom = /^'\s*@importMethodsFrom\s+(?<package>\S+)(?<fn>( +\S+)+)$/;
+/** deliberately includes the others to get a "total" overview */
+const exportRegex = /^'\s*@export/;
+const exportS3MethodRegex = /^'\s*@exportS3Method/;
+const exportClassRegex = /^'\s*@exportClass/;
+const exportMethodRegex = /^'\s*@exportMethod/;
+const exportPatternRegex = /^'\s*@exportPattern/;
+function processRoxygenImport(existing, commentsText, filepath) {
+    const packages = commentsText.map(text => importRegex.exec(text)?.groups?.package).filter(assert_1.isNotUndefined);
+    existing.import += packages.length;
+    (0, output_1.appendStatisticsFile)(exports.comments.name, 'import', packages, filepath, true);
+}
+function processWithRegex(commentsText, existing, regex) {
+    return commentsText.map(text => regex.exec(text)).filter(assert_1.isNotNull)
+        .flatMap(match => {
+        const packageName = match.groups?.package ?? '<unknown>';
+        return (match.groups?.fn.trim().split(/\s+/) ?? []).map(fn => `${JSON.stringify(packageName)},${fn}`);
+    });
+}
+function processRoxygenImportFrom(existing, commentsText, filepath) {
+    const result = processWithRegex(commentsText, existing, importFromRegex);
+    existing.importFrom += result.length;
+    (0, output_1.appendStatisticsFile)(exports.comments.name, 'importFrom', result, filepath, true);
+}
+function processRoxygenImportClassesFrom(existing, commentsText, filepath) {
+    const result = processWithRegex(commentsText, existing, importClassesFromRegex);
+    existing.importClassesFrom += result.length;
+    (0, output_1.appendStatisticsFile)(exports.comments.name, 'importClassesFrom', result, filepath, true);
+}
+function processRoxygenImportMethodsFrom(existing, commentsText, filepath) {
+    const result = processWithRegex(commentsText, existing, importMethodsFrom);
+    existing.importMethodsFrom += result.length;
+    (0, output_1.appendStatisticsFile)(exports.comments.name, 'importMethodsFrom', result, filepath, true);
+}
+function processExports(existing, comments) {
+    existing.export += comments.filter(text => exportRegex.test(text)).length;
+    existing.exportClass += comments.filter(text => exportClassRegex.test(text)).length;
+    existing.exportMethod += comments.filter(text => exportMethodRegex.test(text)).length;
+    existing.exportS3Method += comments.filter(text => exportS3MethodRegex.test(text)).length;
+    existing.exportPattern += comments.filter(text => exportPatternRegex.test(text)).length;
+}
+function processMatchForDynLib(match) {
+    const packageName = match.groups?.package ?? '<unknown>';
+    const functions = match.groups?.fn?.trim().split(/\s+/) ?? [];
+    if (functions.length === 0) {
+        return [packageName];
+    }
+    else {
+        return functions.map(fn => `${JSON.stringify(packageName)},${fn}`);
+    }
+}
+function processRoxygenUseDynLib(existing, commentsText, filepath) {
+    const result = commentsText.map(text => useDynLibRegex.exec(text))
+        .filter(assert_1.isNotNull)
+        .flatMap(processMatchForDynLib);
+    existing.useDynLib += result.length;
+    (0, output_1.appendStatisticsFile)(exports.comments.name, 'useDynLib', result, filepath, true);
+}
+exports.comments = {
+    name: 'Comments',
+    description: 'All comments that appear within the document',
+    process(existing, input) {
+        const comments = commentQuery.select({ node: input.parsedRAst }).map(node => node.textContent ?? '#')
+            .map(text => {
+            (0, assert_1.guard)(text.startsWith('#'), `unexpected comment ${text}`);
+            return text.slice(1);
+        })
+            .map(text => text.trim());
+        existing.totalAmount += comments.length;
+        const roxygenComments = comments.filter(text => text.startsWith("'"));
+        existing.roxygenComments += roxygenComments.length;
+        processRoxygenImport(existing, roxygenComments, input.filepath);
+        processRoxygenImportFrom(existing, roxygenComments, input.filepath);
+        processRoxygenUseDynLib(existing, roxygenComments, input.filepath);
+        processRoxygenImportClassesFrom(existing, roxygenComments, input.filepath);
+        processRoxygenImportMethodsFrom(existing, roxygenComments, input.filepath);
+        processExports(existing, roxygenComments);
+        return existing;
+    },
+    initialValue: exports.initialCommentInfo,
+    postProcess: post_process_1.postProcess
+};
+//# sourceMappingURL=comments.js.map

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { FeatureStatisticsWithMeta } from '../../feature';
+import { StatisticsSummarizerConfiguration } from '../../../../util/summarizer/statistics/summarizer';
+export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;