@eagleoutice/flowr 2.1.3 → 2.1.4

package/queries/catalog/location-map-query/location-map-query-executor.d.ts

@@ -0,0 +1,3 @@
+import type { LocationMapQuery, LocationMapQueryResult } from './location-map-query-format';
+import type { BasicQueryData } from '../../base-query-format';
+export declare function executeLocationMapQuery({ ast }: BasicQueryData, queries: readonly LocationMapQuery[]): LocationMapQueryResult;

package/queries/catalog/location-map-query/location-map-query-executor.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeLocationMapQuery = executeLocationMapQuery;
+const log_1 = require("../../../util/log");
+function executeLocationMapQuery({ ast }, queries) {
+    if (queries.length !== 1) {
+        log_1.log.warn('Id-Map query expects only up to one query, but got', queries.length);
+    }
+    const start = Date.now();
+    const locationMap = {};
+    for (const [id, node] of ast.idMap.entries()) {
+        locationMap[id] = node.location;
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        map: locationMap
+    };
+}
+//# sourceMappingURL=location-map-query-executor.js.map

package/queries/catalog/location-map-query/location-map-query-format.d.ts

@@ -0,0 +1,17 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import { executeLocationMapQuery } from './location-map-query-executor';
+import { type OutputFormatter } from '../../../util/ansi';
+import Joi from 'joi';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { SourceRange } from '../../../util/range';
+export interface LocationMapQuery extends BaseQueryFormat {
+    readonly type: 'location-map';
+}
+export interface LocationMapQueryResult extends BaseQueryResult {
+    readonly map: Record<NodeId, SourceRange | undefined>;
+}
+export declare const LocationMapQueryDefinition: {
+    readonly executor: typeof executeLocationMapQuery;
+    readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+    readonly schema: Joi.ObjectSchema<any>;
+};

package/queries/catalog/location-map-query/location-map-query-format.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocationMapQueryDefinition = void 0;
+const location_map_query_executor_1 = require("./location-map-query-executor");
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+const query_print_1 = require("../../query-print");
+exports.LocationMapQueryDefinition = {
+    executor: location_map_query_executor_1.executeLocationMapQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('location-map', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(`   ╰ Id List: {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, [...Object.keys(out.map)])}}`);
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('location-map').required().description('The type of the query.'),
+    }).description('The id map query retrieves the location of every id in the ast.')
+};
+//# sourceMappingURL=location-map-query-format.js.map

package/queries/catalog/normalized-ast-query/normalized-ast-query-executor.d.ts

@@ -1,3 +1,3 @@
-import type { BasicQueryData } from '../../query';
 import type { NormalizedAstQuery, NormalizedAstQueryResult } from './normalized-ast-query-format';
+import type { BasicQueryData } from '../../base-query-format';
 export declare function executeNormalizedAstQuery({ ast }: BasicQueryData, queries: readonly NormalizedAstQuery[]): NormalizedAstQueryResult;

package/queries/catalog/normalized-ast-query/normalized-ast-query-format.d.ts

@@ -1,5 +1,7 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { NormalizedAst } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { executeNormalizedAstQuery } from './normalized-ast-query-executor';
+import Joi from 'joi';
 /**
  * Simple re-returns the normalized AST of the analysis.
  */
@@ -9,3 +11,60 @@ export interface NormalizedAstQuery extends BaseQueryFormat {
 export interface NormalizedAstQueryResult extends BaseQueryResult {
     readonly normalized: NormalizedAst;
 }
+export declare const NormalizedAstQueryDefinition: {
+    readonly executor: typeof executeNormalizedAstQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/ansi").OutputFormatter, _processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
+        readonly name: "parse";
+        readonly humanReadableName: "parse with R shell";
+        readonly description: "Parse the given R code into an AST";
+        readonly processor: (_results: unknown, input: Partial<import("../../../core/steps/all/core/00-parse").ParseRequiredInput>) => Promise<import("../../../core/steps/all/core/00-parse").ParseStepOutput>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: {
+                (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+            };
+            readonly 5: ({ parsed }: import("../../../core/steps/all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
+        };
+        readonly dependencies: readonly [];
+        readonly requiredInput: import("../../../core/steps/all/core/00-parse").ParseRequiredInput;
+    } | {
+        readonly name: "normalize";
+        readonly humanReadableName: "normalize";
+        readonly description: "Normalize the AST to flowR's AST";
+        readonly processor: (results: {
+            parse?: import("../../../core/steps/all/core/00-parse").ParseStepOutput;
+        }, input: Partial<import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/normalize-printer").normalizedAstToJson;
+            readonly 5: typeof import("../../../core/print/normalize-printer").normalizedAstToQuads;
+            readonly 3: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaid;
+            readonly 4: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+        };
+        readonly dependencies: readonly ["parse"];
+        readonly requiredInput: import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+    } | {
+        readonly humanReadableName: "dataflow";
+        readonly processor: (results: {
+            normalize?: NormalizedAst;
+        }, input: {
+            request?: import("../../../r-bridge/retriever").RParseRequests;
+        }) => import("../../../dataflow/info").DataflowInformation;
+        readonly requiredInput: {};
+        readonly name: "dataflow";
+        readonly description: "Construct the dataflow graph";
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/dataflow-printer").dataflowGraphToJson;
+            readonly 5: typeof import("../../../core/print/dataflow-printer").dataflowGraphToQuads;
+            readonly 3: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaid;
+            readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+        };
+        readonly dependencies: readonly ["normalize"];
+    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly schema: Joi.ObjectSchema<any>;
+};

package/queries/catalog/normalized-ast-query/normalized-ast-query-format.js

@@ -1,3 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NormalizedAstQueryDefinition = void 0;
+const normalized_ast_query_executor_1 = require("./normalized-ast-query-executor");
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const ast_1 = require("../../../util/mermaid/ast");
+const joi_1 = __importDefault(require("joi"));
+exports.NormalizedAstQueryDefinition = {
+    executor: normalized_ast_query_executor_1.executeNormalizedAstQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('normalized-ast', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        result.push(`   ╰ [Normalized AST](${(0, ast_1.normalizedAstToMermaidUrl)(out.normalized.ast)})`);
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('normalized-ast').required().description('The type of the query.'),
+    }).description('The normalized AST query simply returns the normalized AST, there is no need to pass it multiple times!')
+};
 //# sourceMappingURL=normalized-ast-query-format.js.map

package/queries/catalog/static-slice-query/static-slice-query-executor.d.ts

@@ -1,4 +1,4 @@
-import type { BasicQueryData } from '../../query';
 import type { StaticSliceQuery, StaticSliceQueryResult } from './static-slice-query-format';
+import type { BasicQueryData } from '../../base-query-format';
 export declare function fingerPrintOfQuery(query: StaticSliceQuery): string;
 export declare function executeStaticSliceClusterQuery({ graph, ast }: BasicQueryData, queries: readonly StaticSliceQuery[]): StaticSliceQueryResult;

package/queries/catalog/static-slice-query/static-slice-query-executor.js

@@ -19,14 +19,19 @@ function executeStaticSliceClusterQuery({ graph, ast }, queries) {
             log_1.log.warn(`Duplicate Key for slicing-query: ${key}, skipping...`);
         }
         const { criteria, noReconstruction, noMagicComments } = query;
+        const sliceStart = Date.now();
         const slice = (0, static_slicer_1.staticSlicing)(graph, ast, criteria);
+        const sliceEnd = Date.now();
         if (noReconstruction) {
-            results[key] = { slice };
+            results[key] = { slice: { ...slice, '.meta': { timing: sliceEnd - sliceStart } } };
         }
         else {
+            const reconstructStart = Date.now();
+            const reconstruct = (0, reconstruct_1.reconstructToCode)(ast, slice.result, noMagicComments ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect));
+            const reconstructEnd = Date.now();
             results[key] = {
-                slice,
-                reconstruct: (0, reconstruct_1.reconstructToCode)(ast, slice.result, noMagicComments ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect))
+                slice: { ...slice, '.meta': { timing: sliceEnd - sliceStart } },
+                reconstruct: { ...reconstruct, '.meta': { timing: reconstructEnd - reconstructStart } }
             };
         }
     }

package/queries/catalog/static-slice-query/static-slice-query-format.d.ts

@@ -2,6 +2,8 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DEFAULT_DATAFLOW_PIPELINE, DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE, DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
 import type { SlicingCriteria } from '../../../slicing/criterion/parse';
+import Joi from 'joi';
+import { executeStaticSliceClusterQuery } from './static-slice-query-executor';
 /** Calculates and returns all clusters encountered in the dataflow graph. */
 export interface StaticSliceQuery extends BaseQueryFormat {
     readonly type: 'static-slice';
@@ -22,3 +24,60 @@ export interface StaticSliceQueryResult extends BaseQueryResult {
      */
     results: Record<string, Omit<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>, keyof PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>> | Omit<PipelineOutput<typeof DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE>, keyof PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>>>;
 }
+export declare const StaticSliceQueryDefinition: {
+    readonly executor: typeof executeStaticSliceClusterQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/ansi").OutputFormatter, _processed: PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
+        readonly name: "parse";
+        readonly humanReadableName: "parse with R shell";
+        readonly description: "Parse the given R code into an AST";
+        readonly processor: (_results: unknown, input: Partial<import("../../../core/steps/all/core/00-parse").ParseRequiredInput>) => Promise<import("../../../core/steps/all/core/00-parse").ParseStepOutput>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: {
+                (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+            };
+            readonly 5: ({ parsed }: import("../../../core/steps/all/core/00-parse").ParseStepOutput, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
+        };
+        readonly dependencies: readonly [];
+        readonly requiredInput: import("../../../core/steps/all/core/00-parse").ParseRequiredInput;
+    } | {
+        readonly name: "normalize";
+        readonly humanReadableName: "normalize";
+        readonly description: "Normalize the AST to flowR's AST";
+        readonly processor: (results: {
+            parse?: import("../../../core/steps/all/core/00-parse").ParseStepOutput;
+        }, input: Partial<import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/normalize-printer").normalizedAstToJson;
+            readonly 5: typeof import("../../../core/print/normalize-printer").normalizedAstToQuads;
+            readonly 3: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaid;
+            readonly 4: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+        };
+        readonly dependencies: readonly ["parse"];
+        readonly requiredInput: import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+    } | {
+        readonly humanReadableName: "dataflow";
+        readonly processor: (results: {
+            normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        }, input: {
+            request?: import("../../../r-bridge/retriever").RParseRequests;
+        }) => import("../../../dataflow/info").DataflowInformation;
+        readonly requiredInput: {};
+        readonly name: "dataflow";
+        readonly description: "Construct the dataflow graph";
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/dataflow-printer").dataflowGraphToJson;
+            readonly 5: typeof import("../../../core/print/dataflow-printer").dataflowGraphToQuads;
+            readonly 3: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaid;
+            readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+        };
+        readonly dependencies: readonly ["normalize"];
+    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly schema: Joi.ObjectSchema<any>;
+};

package/queries/catalog/static-slice-query/static-slice-query-format.js

@@ -1,3 +1,43 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticSliceQueryDefinition = void 0;
+const ansi_1 = require("../../../util/ansi");
+const time_1 = require("../../../util/time");
+const joi_1 = __importDefault(require("joi"));
+const static_slice_query_executor_1 = require("./static-slice-query-executor");
+const query_print_1 = require("../../query-print");
+exports.StaticSliceQueryDefinition = {
+    executor: static_slice_query_executor_1.executeStaticSliceClusterQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('static-slice', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        for (const [fingerprint, obj] of Object.entries(out.results)) {
+            const { criteria, noMagicComments, noReconstruction } = JSON.parse(fingerprint);
+            const addons = [];
+            if (noReconstruction) {
+                addons.push('no reconstruction');
+            }
+            if (noMagicComments) {
+                addons.push('no magic comments');
+            }
+            result.push(`   ╰ Slice for {${criteria.join(', ')}} ${addons.join(', ')}`);
+            if ('reconstruct' in obj) {
+                result.push('     ╰ Code (newline as <code>&#92;n</code>): <code>' + obj.reconstruct.code.split('\n').join('\\n') + '</code>');
+            }
+            else {
+                result.push(`     ╰ Id List: {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, [...obj.slice.result])}}`);
+            }
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('static-slice').required().description('The type of the query.'),
+        criteria: joi_1.default.array().items(joi_1.default.string()).min(0).required().description('The slicing criteria to use.'),
+        noReconstruction: joi_1.default.boolean().optional().description('Do not reconstruct the slice into readable code.'),
+        noMagicComments: joi_1.default.boolean().optional().description('Should the magic comments (force-including lines within the slice) be ignored?')
+    }).description('Slice query used to slice the dataflow graph')
+};
 //# sourceMappingURL=static-slice-query-format.js.map

package/queries/query-print.d.ts

@@ -0,0 +1,8 @@
+import type { OutputFormatter } from '../util/ansi';
+import type { QueryResults, SupportedQueryTypes } from './query';
+import type { PipelineOutput } from '../core/steps/pipeline/pipeline';
+import type { DEFAULT_DATAFLOW_PIPELINE } from '../core/steps/pipeline/default-pipelines';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare function asciiCallContext(formatter: OutputFormatter, results: QueryResults<'call-context'>['call-context'], processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string;
+export declare function summarizeIdsIfTooLong(formatter: OutputFormatter, ids: readonly NodeId[]): string;
+export declare function asciiSummaryOfQueryResult(formatter: OutputFormatter, totalInMs: number, results: QueryResults<SupportedQueryTypes>, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string;

package/queries/query-print.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asciiCallContext = asciiCallContext;
+exports.summarizeIdsIfTooLong = summarizeIdsIfTooLong;
+exports.asciiSummaryOfQueryResult = asciiSummaryOfQueryResult;
+const ansi_1 = require("../util/ansi");
+const query_1 = require("./query");
+const html_hover_over_1 = require("../util/html-hover-over");
+const time_1 = require("../util/time");
+const built_in_1 = require("../dataflow/environments/built-in");
+function nodeString(id, formatter, processed) {
+    if (id === built_in_1.BuiltIn) {
+        return (0, ansi_1.italic)('built-in', formatter);
+    }
+    const node = processed.normalize.idMap.get(id);
+    if (node === undefined) {
+        return `UNKNOWN: ${id}`;
+    }
+    return `${(0, ansi_1.italic)('`' + (node.lexeme ?? node.info.fullLexeme ?? 'UNKNOWN') + '`', formatter)} (L.${node.location?.[0]})`;
+}
+function asciiCallContextSubHit(formatter, results, processed) {
+    const result = [];
+    for (const { id, calls = [], linkedIds = [], aliasRoots = [] } of results) {
+        const node = processed.normalize.idMap.get(id);
+        if (node === undefined) {
+            result.push(` ${(0, ansi_1.bold)('UNKNOWN: ' + JSON.stringify({ calls, linkedIds }))}`);
+            continue;
+        }
+        let line = nodeString(id, formatter, processed);
+        if (calls.length > 0) {
+            line += ` with ${calls.length} call${calls.length > 1 ? 's' : ''} (${calls.map(c => nodeString(c, formatter, processed)).join(', ')})`;
+        }
+        if (linkedIds.length > 0) {
+            line += ` with ${linkedIds.length} link${linkedIds.length > 1 ? 's' : ''} (${linkedIds.map(c => nodeString(c, formatter, processed)).join(', ')})`;
+        }
+        if (aliasRoots.length > 0) {
+            line += ` with ${aliasRoots.length} alias root${aliasRoots.length > 1 ? 's' : ''} (${aliasRoots.map(c => nodeString(c, formatter, processed)).join(', ')})`;
+        }
+        result.push(line);
+    }
+    return result.join(', ');
+}
+function asciiCallContext(formatter, results, processed) {
+    /* traverse over 'kinds' and within them 'subkinds' */
+    const result = [];
+    for (const [kind, { subkinds }] of Object.entries(results['kinds'])) {
+        result.push(`   ╰ ${(0, ansi_1.bold)(kind, formatter)}`);
+        for (const [subkind, values] of Object.entries(subkinds)) {
+            result.push(`     ╰ ${(0, ansi_1.bold)(subkind, formatter)}: ${asciiCallContextSubHit(formatter, values, processed)}`);
+        }
+    }
+    return result.join('\n');
+}
+function summarizeIdsIfTooLong(formatter, ids) {
+    const naive = ids.join(', ');
+    if (naive.length <= 20) {
+        return naive;
+    }
+    let acc = '';
+    let i = 0;
+    while (acc.length <= 20) {
+        acc += ids[i++] + ', ';
+    }
+    if (i < ids.length) {
+        acc += '... (see JSON)';
+    }
+    return formatter === ansi_1.markdownFormatter ? (0, html_hover_over_1.textWithTooltip)(acc, JSON.stringify(ids)) : acc;
+}
+function asciiSummaryOfQueryResult(formatter, totalInMs, results, processed) {
+    const result = [];
+    for (const [query, queryResults] of Object.entries(results)) {
+        if (query === '.meta') {
+            continue;
+        }
+        const queryType = query_1.SupportedQueries[query];
+        if (queryType.asciiSummarizer(formatter, processed, queryResults, result)) {
+            continue;
+        }
+        result.push(`Query: ${(0, ansi_1.bold)(query, formatter)}`);
+        let timing = -1;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        for (const [key, value] of Object.entries(queryResults)) {
+            if (key === '.meta') {
+                timing = value.timing;
+                continue;
+            }
+            result.push(` ╰ ${key}: ${JSON.stringify(value)}`);
+        }
+        result.push(`  - Took ${(0, time_1.printAsMs)(timing, 0)}`);
+    }
+    result.push((0, ansi_1.italic)(`All queries together required ≈${(0, time_1.printAsMs)(results['.meta'].timing, 0)} (1ms accuracy, total ${(0, time_1.printAsMs)(totalInMs, 0)})`, formatter));
+    return formatter.format(result.join('\n'));
+}
+//# sourceMappingURL=query-print.js.map