@eagleoutice/flowr 2.1.11 → 2.1.12

package/search/flowr-search-printer.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flowrSearchToMermaid = flowrSearchToMermaid;
+exports.flowrSearchToAscii = flowrSearchToAscii;
+exports.flowrSearchToCode = flowrSearchToCode;
+const flowr_search_traverse_1 = require("./flowr-search-traverse");
+const mermaid_1 = require("../util/mermaid/mermaid");
+const flowr_search_filters_1 = require("./flowr-search-filters");
+const vertex_1 = require("../dataflow/graph/vertex");
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
+/**
+ * Converts a {@link FlowrSearchLike} object to a mermaid flowchart.
+ */
+function flowrSearchToMermaid(search, conf) {
+    const out = [conf?.header ?? 'flowchart LR'];
+    let count = 0;
+    out.push((0, flowr_search_traverse_1.traverseFlowrSearchBuilderType)(search, ({ type, name, args }) => `${count}("<b>${name}</b>(${argsToMermaidString(args)})<br/>_${type}_")`, (acc, { name, args, type }) => `${acc} --> ${++count}["<b>${name}</b>(${argsToMermaidString(args)})<br/>_${type}_"]`));
+    return out.join('\n');
+}
+function argsToMermaidString(args) {
+    if (args === undefined) {
+        return '';
+    }
+    return Object.entries(args).map(([key, value]) => `${key}: ${(0, flowr_search_filters_1.isBinaryTree)(value) ? '_' + (0, mermaid_1.escapeMarkdown)((0, flowr_search_filters_1.binaryTreeToString)(value.tree)) + '_'
+        : (0, mermaid_1.escapeMarkdown)(JSON.stringify(value))}`)
+        .join(', ');
+}
+function argsToAsciiString(args) {
+    if (args === undefined) {
+        return '';
+    }
+    else if (Object.keys(args).length === 1) {
+        const key = Object.keys(args)[0];
+        const value = args[key];
+        return `${key}: ${(0, flowr_search_filters_1.isBinaryTree)(value) ? '_' + (0, flowr_search_filters_1.binaryTreeToString)(value.tree) + '_' : JSON.stringify(value)}`;
+    }
+    return Object.entries(args).map(([key, value]) => `${key}: ${(0, flowr_search_filters_1.isBinaryTree)(value) ? '_' + (0, flowr_search_filters_1.binaryTreeToString)(value.tree) + '_' : JSON.stringify(value)}`)
+        .join(', ');
+}
+function flowrSearchToAscii(search) {
+    return (0, flowr_search_traverse_1.traverseFlowrSearchBuilderType)(search, ({ name, args }) => `${name}(${argsToAsciiString(args)})`, (acc, { name, args }) => `${acc} --> ${name}(${argsToAsciiString(args)})`);
+}
+function argsToCodeString(args) {
+    if (args === undefined) {
+        return '';
+    }
+    return Object.entries(args).map(([, value]) => `${JSON.stringify(value)}`)
+        .join(', ');
+}
+function flowrSearchToCode(search) {
+    return (0, flowr_search_traverse_1.traverseFlowrSearchBuilderType)(search, (node) => `Q.${flowrGeneratorToCode(node)}`, (acc, node) => `${acc}.${flowrTransformerToCode(node)}`);
+}
+function flowrTransformerToCode(node) {
+    if (node.name === 'filter') {
+        const a = node.args.filter;
+        if (vertex_1.ValidVertexTypes.has(String(a))) {
+            return `${node.name}(VertexType.${vertex_1.ValidVertexTypeReverse[String(a)]})`;
+        }
+        else if (type_1.ValidRTypes.has(String(a))) {
+            return `${node.name}(RType.${type_1.ValidRTypesReverse[String(a)]})`;
+        }
+        else if (flowr_search_filters_1.ValidFlowrFilters.has(String(a))) {
+            return `${node.name}(FlowrFilter.${flowr_search_filters_1.ValidFlowrFiltersReverse[String(a)]})`;
+        }
+    }
+    return `${node.name}(${argsToCodeString(node.args)})`;
+}
+function flowrGeneratorToCode(node) {
+    if (node.name !== 'get') {
+        return `${node.name}(${argsToCodeString(node.args)})`;
+    }
+    const a = node.args.filter;
+    if (Object.keys(a).length === 1) {
+        if (a.name) {
+            return `var(${JSON.stringify(a.name)})`;
+        }
+    }
+    else if (Object.keys(a).length === 2) {
+        if (a.name && a.line) {
+            return `varInLine(${JSON.stringify(a.name)}, ${JSON.stringify(a.line)})`;
+        }
+    }
+    return `${node.name}(${argsToCodeString(node.args)})`;
+}
+//# sourceMappingURL=flowr-search-printer.js.map

package/search/flowr-search-traverse.d.ts

@@ -0,0 +1,7 @@
+import type { FlowrSearchLike } from './flowr-search-builder';
+import type { FlowrSearchGeneratorNode } from './search-executor/search-generators';
+import type { FlowrSearchTransformerNode } from './search-executor/search-transformer';
+/**
+ * Allows you to traverse a {@link FlowrSearchLike} object.
+ */
+export declare function traverseFlowrSearchBuilderType<Accumulate, GeneratorVisit extends (generator: FlowrSearchGeneratorNode) => Accumulate, TransformerVisit extends (acc: Accumulate, transformer: FlowrSearchTransformerNode) => Accumulate>(search: FlowrSearchLike, gen: GeneratorVisit, trans: TransformerVisit): Accumulate;

package/search/flowr-search-traverse.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseFlowrSearchBuilderType = traverseFlowrSearchBuilderType;
+const flowr_search_builder_1 = require("./flowr-search-builder");
+/**
+ * Allows you to traverse a {@link FlowrSearchLike} object.
+ */
+function traverseFlowrSearchBuilderType(search, gen, trans) {
+    const s = (0, flowr_search_builder_1.getFlowrSearch)(search);
+    return s.search.reduce(trans, gen(s.generator));
+}
+//# sourceMappingURL=flowr-search-traverse.js.map

package/search/flowr-search.d.ts

@@ -0,0 +1,58 @@
+import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
+import type { Pipeline, PipelineOutput, PipelineStepOutputWithName } from '../core/steps/pipeline/pipeline';
+import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowInformation } from '../dataflow/info';
+/**
+ * Yes, for now we do technically not need a wrapper around the RNode, but this allows us to attach caches etc.
+ * just for the respective search.
+ */
+export interface FlowrSearchElement<Info> {
+    readonly node: RNode<Info>;
+}
+export interface FlowrSearchNodeBase<Type extends string, Name extends string, Args extends Record<string, unknown> | undefined> {
+    readonly type: Type;
+    readonly name: Name;
+    readonly args: Args;
+}
+export type FlowrSearchGeneratorNodeBase<Name extends string, Args extends Record<string, unknown> | undefined> = FlowrSearchNodeBase<'generator', Name, Args>;
+export type FlowrSearchTransformerNodeBase<Name extends string, Args extends Record<string, unknown> | undefined> = FlowrSearchNodeBase<'transformer', Name, Args>;
+export interface FlowrSearchGetFilter extends Record<string, unknown> {
+    /**
+     * The node must be in the given line.
+     */
+    readonly line?: number;
+    /**
+     * The node must be in the given column.
+     */
+    readonly column?: number;
+    /**
+     * The node must have the given name.
+     * To treat this name as a regular expression, set {@link FlowrSearchGetFilter#nameIsRegex} to true.
+     */
+    readonly name?: string;
+    /**
+     * Only useful in combination with `name`. If true, the name is treated as a regular expression.
+     */
+    readonly nameIsRegex?: boolean;
+    /**
+     * The node must have the given id.
+     */
+    readonly id?: NodeId;
+}
+type MinimumInputForFlowrSearch<P extends Pipeline> = PipelineStepOutputWithName<P, 'normalize'> extends NormalizedAst ? (PipelineStepOutputWithName<P, 'dataflow'> extends DataflowInformation ? PipelineOutput<P> & {
+    normalize: NormalizedAst;
+    dataflow: DataflowInformation;
+} : never) : never;
+/** we allow any pipeline, which provides us with a 'normalize' and 'dataflow' step */
+export type FlowrSearchInput<P extends Pipeline> = MinimumInputForFlowrSearch<P>;
+/** Intentionally, we abstract away from an array to avoid the use of conventional typescript operations */
+export declare class FlowrSearchElements<Info = NoInfo, Elements extends FlowrSearchElement<Info>[] = FlowrSearchElement<Info>[]> {
+    private elements;
+    constructor(elements?: Elements);
+    add(element: FlowrSearchElement<Info>): this;
+    addAll(elements: FlowrSearchElement<Info>[]): this;
+    getElements(): readonly FlowrSearchElement<Info>[];
+    mutate<OutElements extends Elements>(mutator: (elements: Elements) => OutElements): this;
+}
+export {};

package/search/flowr-search.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrSearchElements = void 0;
+/** Intentionally, we abstract away from an array to avoid the use of conventional typescript operations */
+class FlowrSearchElements {
+    elements = [];
+    constructor(elements) {
+        if (elements) {
+            this.elements = elements;
+        }
+    }
+    add(element) {
+        this.elements.push(element);
+        return this;
+    }
+    addAll(elements) {
+        this.elements.push(...elements);
+        return this;
+    }
+    getElements() {
+        return this.elements;
+    }
+    mutate(mutator) {
+        this.elements = mutator(this.elements);
+        return this;
+    }
+}
+exports.FlowrSearchElements = FlowrSearchElements;
+//# sourceMappingURL=flowr-search.js.map

package/search/search-executor/search-generators.d.ts

@@ -0,0 +1,37 @@
+import type { FlowrSearchElement, FlowrSearchGeneratorNodeBase, FlowrSearchGetFilter, FlowrSearchInput } from '../flowr-search';
+import { FlowrSearchElements } from '../flowr-search';
+import type { Pipeline } from '../../core/steps/pipeline/pipeline';
+import type { TailTypesOrUndefined } from '../../util/arrays';
+import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { SlicingCriteria } from '../../slicing/criterion/parse';
+/**
+ * This is a union of all possible generator node types
+ */
+export type FlowrSearchGeneratorNode = {
+    [K in GeneratorNames]: FlowrSearchGeneratorNodeBase<K, TailTypesOrUndefined<Parameters<typeof generators[K]>>>;
+}[GeneratorNames];
+export type GeneratorNames = keyof typeof generators;
+export type GetGenerator<Name extends GeneratorNames> = FlowrSearchGeneratorNode & {
+    name: Name;
+};
+/**
+ * All supported generators!
+ */
+export declare const generators: {
+    readonly all: typeof generateAll;
+    readonly get: typeof generateGet;
+    readonly criterion: typeof generateCriterion;
+    readonly from: typeof generateFrom;
+};
+declare function generateAll(data: FlowrSearchInput<Pipeline>): FlowrSearchElements<ParentInformation>;
+declare function generateGet(data: FlowrSearchInput<Pipeline>, { filter: { line, column, id, name, nameIsRegex } }: {
+    filter: FlowrSearchGetFilter;
+}): FlowrSearchElements<ParentInformation>;
+declare function generateFrom(data: FlowrSearchInput<Pipeline>, args: {
+    from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[];
+}): FlowrSearchElements<ParentInformation>;
+declare function generateCriterion(data: FlowrSearchInput<Pipeline>, args: {
+    criterion: SlicingCriteria;
+}): FlowrSearchElements<ParentInformation>;
+export declare function getGenerator<Name extends GeneratorNames>(name: Name): typeof generators[Name];
+export {};

package/search/search-executor/search-generators.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generators = void 0;
+exports.getGenerator = getGenerator;
+const flowr_search_1 = require("../flowr-search");
+const parse_1 = require("../../slicing/criterion/parse");
+const assert_1 = require("../../util/assert");
+/**
+ * All supported generators!
+ */
+exports.generators = {
+    all: generateAll,
+    get: generateGet,
+    criterion: generateCriterion,
+    from: generateFrom
+};
+function generateAll(data) {
+    return new flowr_search_1.FlowrSearchElements(getAllNodes(data)
+        .map(node => ({ node })));
+}
+function getAllNodes(data) {
+    return [...new Map([...data.normalize.idMap.values()].map(n => [n.info.id, n]))
+            .values()];
+}
+function generateGet(data, { filter: { line, column, id, name, nameIsRegex } }) {
+    let potentials = (id ?
+        [data.normalize.idMap.get(id)].filter(assert_1.isNotUndefined) :
+        getAllNodes(data));
+    if (line && line < 0) {
+        const maxLines = data.normalize.ast.info.fullRange?.[2] ??
+            (id ? getAllNodes(data) : potentials).reduce((maxLine, { location }) => location && location[2] > maxLine ? location[2] : maxLine, 0);
+        line = maxLines + line + 1;
+    }
+    if (line && column) {
+        potentials = potentials.filter(({ location }) => location?.[0] === line && location?.[1] === column);
+    }
+    else if (line) {
+        potentials = potentials.filter(({ location }) => location?.[0] === line);
+    }
+    else if (column) {
+        potentials = potentials.filter(({ location }) => location?.[1] === column);
+    }
+    if (nameIsRegex && name) {
+        const nameFilter = new RegExp(name);
+        potentials = potentials.filter(({ lexeme }) => lexeme && nameFilter.test(lexeme));
+    }
+    else if (name) {
+        potentials = potentials.filter(({ lexeme }) => lexeme === name);
+    }
+    return new flowr_search_1.FlowrSearchElements(potentials.map(node => ({ node })));
+}
+function generateFrom(data, args) {
+    return new flowr_search_1.FlowrSearchElements(Array.isArray(args.from) ? args.from : [args.from]);
+}
+function generateCriterion(data, args) {
+    return new flowr_search_1.FlowrSearchElements(args.criterion.map(c => ({ node: data.normalize.idMap.get((0, parse_1.slicingCriterionToId)(c, data.normalize.idMap)) })));
+}
+function getGenerator(name) {
+    if (!exports.generators[name]) {
+        throw new Error(`Unknown generator: ${name}`);
+    }
+    return exports.generators[name];
+}
+//# sourceMappingURL=search-generators.js.map

package/search/search-executor/search-transformer.d.ts

@@ -0,0 +1,57 @@
+import type { FlowrSearchElement, FlowrSearchElements, FlowrSearchInput, FlowrSearchTransformerNodeBase } from '../flowr-search';
+import type { Pipeline } from '../../core/steps/pipeline/pipeline';
+import type { LastOfArray, Tail2TypesOrUndefined, TailOfArray } from '../../util/arrays';
+import type { FlowrFilterExpression } from '../flowr-search-filters';
+import type { FlowrSearchGeneratorNode } from './search-generators';
+import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * This is a union of all possible transformer node types
+ */
+export type FlowrSearchTransformerNode = {
+    [K in TransformerNames]: FlowrSearchTransformerNodeBase<K, Tail2TypesOrUndefined<Parameters<typeof transformers[K]>>>;
+}[TransformerNames];
+export type TransformerNames = keyof typeof transformers;
+export type GetTransformer<Name extends TransformerNames> = FlowrSearchTransformerNode & {
+    name: Name;
+};
+export type GetOutputOfTransformer<Name extends TransformerNames> = ReturnType<typeof transformers[Name]>;
+/**
+ * All supported generators!
+ */
+export declare const transformers: {
+    readonly first: typeof getFirst;
+    readonly last: typeof getLast;
+    readonly index: typeof getIndex;
+    readonly tail: typeof getTail;
+    readonly take: typeof getTake;
+    readonly skip: typeof getSkip;
+    readonly filter: typeof getFilter;
+    readonly merge: typeof getMerge;
+    readonly select: typeof getSelect;
+};
+export declare function getTransformer<Name extends TransformerNames>(name: Name): typeof transformers[Name];
+/** If we already have no more elements, cascade will not add any but keep the empty elements, otherwise it will now be NewElements */
+type CascadeEmpty<Elements extends FlowrSearchElement<ParentInformation>[], NewElements extends FlowrSearchElement<ParentInformation>[]> = Elements extends [] ? FlowrSearchElements<ParentInformation, []> : FlowrSearchElements<ParentInformation, NewElements>;
+declare function getFirst<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, [Elements[0]]>;
+declare function getLast<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, [LastOfArray<Elements>]>;
+declare function getIndex<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { index }: {
+    index: number;
+}): CascadeEmpty<Elements, [Elements[number]]>;
+declare function getSelect<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { select }: {
+    select: number[];
+}): CascadeEmpty<Elements, Elements>;
+declare function getTail<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, TailOfArray<Elements>>;
+declare function getTake<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { count }: {
+    count: number;
+}): CascadeEmpty<Elements, TailOfArray<Elements>>;
+declare function getSkip<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { count }: {
+    count: number;
+}): CascadeEmpty<Elements, TailOfArray<Elements>>;
+declare function getFilter<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { filter }: {
+    filter: FlowrFilterExpression;
+}): CascadeEmpty<Elements, Elements | []>;
+declare function getMerge<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, other: {
+    search: unknown[];
+    generator: FlowrSearchGeneratorNode;
+}): FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>;
+export {};

package/search/search-executor/search-transformer.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformers = void 0;
+exports.getTransformer = getTransformer;
+const flowr_search_filters_1 = require("../flowr-search-filters");
+const flowr_search_executor_1 = require("../flowr-search-executor");
+const assert_1 = require("../../util/assert");
+/**
+ * All supported generators!
+ */
+exports.transformers = {
+    first: getFirst,
+    last: getLast,
+    index: getIndex,
+    tail: getTail,
+    take: getTake,
+    skip: getSkip,
+    filter: getFilter,
+    merge: getMerge,
+    select: getSelect
+};
+function getTransformer(name) {
+    if (!exports.transformers[name]) {
+        throw new Error(`Unknown transformer: ${name}`);
+    }
+    return exports.transformers[name];
+}
+function compareByLocation({ node: a }, { node: b }) {
+    if (a.location && b.location) {
+        return a.location[0] - b.location[0] || a.location[1] - b.location[1];
+    }
+    else if (a.location) {
+        return -1;
+    }
+    return b.location ? 1 : 0;
+}
+function getFirstByLocation(elements) {
+    if (elements.length === 0) {
+        return undefined;
+    }
+    return elements.reduce((acc, cur) => {
+        if (acc === undefined) {
+            return cur;
+        }
+        return compareByLocation(acc, cur) < 0 ? acc : cur;
+    }, undefined);
+}
+/* later we can add something like sort partially to get the first k elements */
+function sortFully(elements) {
+    return elements.sort(compareByLocation);
+}
+function getLastByLocation(elements) {
+    if (elements.length === 0) {
+        return undefined;
+    }
+    return elements.reduce((acc, cur) => {
+        if (acc === undefined) {
+            return cur;
+        }
+        return compareByLocation(acc, cur) > 0 ? acc : cur;
+    }, undefined);
+}
+function getFirst(data, elements) {
+    return elements.mutate(e => [getFirstByLocation(e)]);
+}
+function getLast(data, elements) {
+    return elements.mutate(e => [getLastByLocation(e)]);
+}
+function getIndex(data, elements, { index }) {
+    return elements.mutate(e => [sortFully(e)[index]]);
+}
+function getSelect(data, elements, { select }) {
+    return elements.mutate(e => {
+        sortFully(e);
+        return select.map(i => e[i]).filter(assert_1.isNotUndefined);
+    });
+}
+function getTail(data, elements) {
+    return elements.mutate(e => {
+        const first = getFirstByLocation(e);
+        return e.filter(el => el !== first);
+    });
+}
+function getTake(data, elements, { count }) {
+    return elements.mutate(e => sortFully(e).slice(0, count));
+}
+function getSkip(data, elements, { count }) {
+    return elements.mutate(e => sortFully(e).slice(count));
+}
+function getFilter(data, elements, { filter }) {
+    return elements.mutate(e => e.filter(({ node }) => (0, flowr_search_filters_1.evalFilter)(filter, { node, normalize: data.normalize, dataflow: data.dataflow })));
+}
+function getMerge(
+/* search has to be unknown because it is a recursive type */
+data, elements, other) {
+    const resultOther = (0, flowr_search_executor_1.runSearch)(other, data);
+    return elements.addAll(resultOther);
+}
+//# sourceMappingURL=search-transformer.js.map

package/search/search-optimizer/search-optimizer.d.ts

@@ -0,0 +1,9 @@
+import type { FlowrSearchGeneratorNode, GeneratorNames } from '../search-executor/search-generators';
+import type { FlowrSearchTransformerNode, TransformerNames } from '../search-executor/search-transformer';
+import type { FlowrSearch } from '../flowr-search-builder';
+import type { FlowrSearchElement, FlowrSearchElements } from '../flowr-search';
+/**
+ * Optimizations are currently not reflected
+ * in an update of the search object.
+ */
+export declare function optimize<Info, Generator extends GeneratorNames, Transformers extends TransformerNames[], ElementType extends FlowrSearchElements<Info, FlowrSearchElement<Info>[]>>(generator: FlowrSearchGeneratorNode, search: readonly FlowrSearchTransformerNode[]): FlowrSearch<Info, Generator, Transformers, ElementType>;

package/search/search-optimizer/search-optimizer.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimize = optimize;
+function fingerPrintTransformer(transformer) {
+    return JSON.stringify(transformer);
+}
+/**
+ * Optimizations are currently not reflected
+ * in an update of the search object.
+ */
+function optimize(generator, search) {
+    let searchToOptimize = search.slice();
+    let fingerprint = fingerPrintTransformer(searchToOptimize);
+    generator = optimizeGenerator(generator);
+    let lastFingerprint = '{}';
+    /* maybe we want shared optimizers in the future, but for now we let it be :sparkles: */
+    while (fingerprint !== lastFingerprint) {
+        lastFingerprint = fingerprint;
+        searchToOptimize = optimizeSearch(searchToOptimize, generator);
+        fingerprint = fingerPrintTransformer(searchToOptimize);
+    }
+    return {
+        generator,
+        search: searchToOptimize
+    };
+}
+function optimizeGenerator(generator) {
+    return dropAnyNameRegex(generator);
+}
+/*
+ * Ideas:
+ * Replace .tail().last() with .last()
+ * Replace .take(1) with '.first()'
+ * Remove duplicate indices in a .select
+ * Provide unification step after merge (id based)
+ * Install caches if sorting is required multiple times (especially for repeated use of generators)
+ */
+function optimizeSearch(search, _generator) {
+    search = dropDuplicateNoops(search);
+    search = selectWithSingleCanBeIndex(search);
+    return search;
+}
+const noopTransformers = new Set(['first', 'last']);
+/* yes we could optimize something like first, last, first too, but why bother :D*/
+function dropDuplicateNoops(transformers) {
+    const newTransformers = [];
+    let lastTransformer;
+    for (const transformer of transformers) {
+        if (lastTransformer === undefined || lastTransformer.name !== transformer.name || !noopTransformers.has(transformer.name)) {
+            newTransformers.push(transformer);
+        }
+        lastTransformer = transformer;
+    }
+    return newTransformers;
+}
+function selectWithSingleCanBeIndex(transformers) {
+    return transformers.map(transformer => {
+        if (transformer.name === 'select' && transformer.args.select.length === 1) {
+            return {
+                ...transformer,
+                name: 'index',
+                args: {
+                    index: transformer.args.select[0]
+                }
+            };
+        }
+        return transformer;
+    });
+}
+function dropAnyNameRegex(generator) {
+    if (generator.name !== 'get' || !generator.args.filter.nameIsRegex) {
+        return generator;
+    }
+    if (generator.args.filter.name === '.') {
+        return {
+            ...generator,
+            args: {
+                ...generator.args,
+                filter: {
+                    ...generator.args.filter,
+                    name: undefined,
+                    nameIsRegex: undefined
+                }
+            }
+        };
+    }
+    return generator;
+}
+//# sourceMappingURL=search-optimizer.js.map

package/util/arrays.d.ts

@@ -1,7 +1,20 @@
+import type { AnyArray, Tail } from 'ts-essentials';
 /**
  * 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;
+/**
+ * Returns the union of types in an array, but the first one, uses U as a fallback if the array is empty.
+ */
+export type TailTypesOrUndefined<T extends AnyArray, U = undefined> = T extends [] ? U : T extends [unknown] ? U : Tail<T>[number];
+/**
+ * Returns the union of types in an array, but the first and the second one, uses U as a fallback if the array is empty.
+ */
+export type Tail2TypesOrUndefined<T extends AnyArray, U = undefined> = T extends [] ? U : T extends [unknown] ? U : T extends [unknown, unknown] ? U : Tail<Tail<T>>[number];
+/**
+ * Returns the last element of an array
+ */
+export type LastOfArray<T extends AnyArray> = T extends [...infer _, infer L] ? L : never;
 /**
  * Splits the array every time the given predicate fires.
  * The element the split appears on will not be included!

package/util/assert.d.ts

@@ -9,4 +9,4 @@ export type GuardMessage = string | (() => string);
  * @param message - if a string, we will use it as the error message, if it is a function, we will call it to produce the error message (can be used to avoid costly message generations)
  * @throws GuardError - if the assertion fails
  */
-export declare function guard(assertion: boolean | undefined, message?: GuardMessage): asserts assertion;
+export declare function guard(assertion: unknown | undefined, message?: GuardMessage): asserts assertion;

package/util/mermaid/mermaid.js

@@ -21,6 +21,23 @@ const replacements = {
     '&': '#38;',
     '\'': '#39;',
     ':': '#58;',
+    '∨': '#8744;',
+    '∧': '#8743;',
+    '¬': '#172;',
+    '→': '#8594;',
+    '↔': '#8596;',
+    '⇒': '#8658;',
+    '⇔': '#8660;',
+    '∀': '#8704;',
+    '∃': '#8707;',
+    '∈': '#8712;',
+    '∉': '#8713;',
+    '∋': '#8715;',
+    '∌': '#8716;',
+    '∩': '#8745;',
+    '∪': '#8746;',
+    '∫': '#8747;',
+    '⊕': '#8853;',
 };
 function escapeMarkdown(text) {
     for (const [key, value] of Object.entries(replacements)) {

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.1.11';
+const version = '2.1.12';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }