@eagleoutice/flowr 2.1.11 → 2.2.0

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

@@ -0,0 +1,74 @@
+import { RType } from '../r-bridge/lang-4.x/ast/model/type';
+import type { VertexType } from '../dataflow/graph/vertex';
+import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowInformation } from '../dataflow/info';
+import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
+export type FlowrFilterName = keyof typeof FlowrFilters;
+export declare enum FlowrFilter {
+    DropEmptyArguments = "drop-empty-arguments"
+}
+export declare const ValidFlowrFilters: Set<string>;
+export declare const ValidFlowrFiltersReverse: {
+    [k: string]: string;
+};
+export declare const FlowrFilters: {
+    readonly "drop-empty-arguments": (n: RNode<ParentInformation>) => boolean;
+};
+type ValidFilterTypes = FlowrFilterName | RType | VertexType;
+/**
+ * By default, we provide filter for every {@link RType} and {@link VertexType}.
+ */
+export type FlowrFilterExpression = FlowrFilterCombinator | ValidFilterTypes;
+interface BooleanBinaryNode<Composite> {
+    readonly type: 'and' | 'or' | 'xor';
+    readonly left: Composite;
+    readonly right: Composite;
+}
+interface BooleanUnaryNode<Composite> {
+    readonly type: 'not';
+    readonly operand: Composite;
+}
+type LeafRType = {
+    readonly type: 'r-type';
+    readonly value: RType;
+};
+type LeafVertexType = {
+    readonly type: 'vertex-type';
+    readonly value: VertexType;
+};
+type LeafSpecial = {
+    readonly type: 'special';
+    readonly value: string;
+};
+type Leaf = LeafRType | LeafVertexType | LeafSpecial;
+type BooleanNode = BooleanBinaryNode<BooleanNode> | BooleanUnaryNode<BooleanNode> | Leaf;
+type BooleanNodeOrCombinator = BooleanNode | FlowrFilterCombinator;
+/**
+ * @see {@link FlowrFilterCombinator.is}
+ * @see {@link evalFilter}
+ * @see {@link binaryTreeToString}
+ */
+export declare class FlowrFilterCombinator {
+    private tree;
+    protected constructor(init: BooleanNodeOrCombinator);
+    static is(value: BooleanNodeOrCombinator | ValidFilterTypes): FlowrFilterCombinator;
+    and(right: BooleanNodeOrCombinator | ValidFilterTypes): this;
+    or(right: BooleanNodeOrCombinator | ValidFilterTypes): this;
+    xor(right: BooleanNodeOrCombinator | ValidFilterTypes): this;
+    private binaryRight;
+    not(): this;
+    private unary;
+    private unpack;
+    get(): BooleanNode;
+}
+export declare function binaryTreeToString(tree: BooleanNode): string;
+export declare function isBinaryTree(tree: unknown): tree is {
+    tree: BooleanNode;
+};
+interface FilterData {
+    readonly node: RNode<ParentInformation>;
+    readonly normalize: NormalizedAst;
+    readonly dataflow: DataflowInformation;
+}
+export declare function evalFilter(filter: FlowrFilterExpression, data: FilterData): boolean;
+export {};

package/search/flowr-search-filters.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowrFilterCombinator = exports.FlowrFilters = exports.ValidFlowrFiltersReverse = exports.ValidFlowrFilters = exports.FlowrFilter = void 0;
+exports.binaryTreeToString = binaryTreeToString;
+exports.isBinaryTree = isBinaryTree;
+exports.evalFilter = evalFilter;
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
+const vertex_1 = require("../dataflow/graph/vertex");
+var FlowrFilter;
+(function (FlowrFilter) {
+    FlowrFilter["DropEmptyArguments"] = "drop-empty-arguments";
+})(FlowrFilter || (exports.FlowrFilter = FlowrFilter = {}));
+exports.ValidFlowrFilters = new Set(Object.values(FlowrFilter));
+exports.ValidFlowrFiltersReverse = Object.fromEntries(Object.entries(FlowrFilter).map(([k, v]) => [v, k]));
+exports.FlowrFilters = {
+    [FlowrFilter.DropEmptyArguments]: (n) => {
+        return n.type !== type_1.RType.Argument || n.name !== undefined;
+    }
+};
+/**
+ * @see {@link FlowrFilterCombinator.is}
+ * @see {@link evalFilter}
+ * @see {@link binaryTreeToString}
+ */
+class FlowrFilterCombinator {
+    tree;
+    constructor(init) {
+        this.tree = this.unpack(init);
+    }
+    static is(value) {
+        if (typeof value === 'object') {
+            return new this(value);
+        }
+        else if (type_1.ValidRTypes.has(value)) {
+            return new this({ type: 'r-type', value: value });
+        }
+        else if (vertex_1.ValidVertexTypes.has(value)) {
+            return new this({ type: 'vertex-type', value: value });
+        }
+        else if (exports.ValidFlowrFilters.has(value)) {
+            return new this({ type: 'special', value: value });
+        }
+        else {
+            throw new Error(`Invalid filter value: ${value}`);
+        }
+    }
+    and(right) {
+        return this.binaryRight('and', right);
+    }
+    or(right) {
+        return this.binaryRight('or', right);
+    }
+    xor(right) {
+        return this.binaryRight('xor', right);
+    }
+    binaryRight(op, right) {
+        this.tree = {
+            type: op,
+            left: this.tree,
+            right: this.unpack(FlowrFilterCombinator.is(right))
+        };
+        return this;
+    }
+    not() {
+        return this.unary('not');
+    }
+    unary(op) {
+        this.tree = {
+            type: op,
+            operand: this.tree
+        };
+        return this;
+    }
+    unpack(val) {
+        return val instanceof FlowrFilterCombinator ? val.tree : val;
+    }
+    get() {
+        return this.tree;
+    }
+}
+exports.FlowrFilterCombinator = FlowrFilterCombinator;
+function binaryTreeToString(tree) {
+    const res = treeToStringImpl(tree, 0);
+    // drop outer parens
+    if (res.startsWith('(') && res.endsWith(')')) {
+        return res.slice(1, -1);
+    }
+    else {
+        return res;
+    }
+}
+const typeToSymbol = {
+    'and': '∧',
+    'or': '∨',
+    'xor': '⊕',
+    'not': '¬'
+};
+function treeToStringImpl(tree, depth) {
+    if (tree.type === 'r-type' || tree.type === 'vertex-type' || tree.type === 'special') {
+        return tree.value;
+    }
+    if (tree.type === 'not') {
+        return `${typeToSymbol[tree.type]}${treeToStringImpl(tree.operand, depth)}`;
+    }
+    const left = treeToStringImpl(tree.left, depth + 1);
+    const right = treeToStringImpl(tree.right, depth + 1);
+    return `(${left} ${typeToSymbol[tree.type]} ${right})`;
+}
+function isBinaryTree(tree) {
+    return typeof tree === 'object' && tree !== null && 'tree' in tree;
+}
+const evalVisit = {
+    and: ({ left, right }, data) => evalTree(left, data) && evalTree(right, data),
+    or: ({ left, right }, data) => evalTree(left, data) || evalTree(right, data),
+    xor: ({ left, right }, data) => evalTree(left, data) !== evalTree(right, data),
+    not: ({ operand }, data) => !evalTree(operand, data),
+    'r-type': ({ value }, { node }) => node.type === value,
+    'vertex-type': ({ value }, { dataflow: { graph }, node }) => graph.getVertex(node.info.id)?.tag === value,
+    'special': ({ value }, { node }) => {
+        const getHandler = exports.FlowrFilters[value];
+        if (getHandler) {
+            return getHandler(node);
+        }
+        throw new Error(`Special filter not implemented: ${value}`);
+    }
+};
+function evalTree(tree, data) {
+    /* we ensure that the types fit */
+    return evalVisit[tree.type](tree, data);
+}
+function evalFilter(filter, data) {
+    /* common lift, this can be improved easily :D */
+    const tree = FlowrFilterCombinator.is(filter);
+    return evalTree(tree.get(), data);
+}
+//# sourceMappingURL=flowr-search-filters.js.map

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

@@ -0,0 +1,10 @@
+import type { FlowrSearchLike } from './flowr-search-builder';
+export interface FlowrSearchMermaidBuilderOptions {
+    header?: string;
+}
+/**
+ * Converts a {@link FlowrSearchLike} object to a mermaid flowchart.
+ */
+export declare function flowrSearchToMermaid(search: FlowrSearchLike, conf?: FlowrSearchMermaidBuilderOptions): string;
+export declare function flowrSearchToAscii(search: FlowrSearchLike): string;
+export declare function flowrSearchToCode(search: FlowrSearchLike): string;

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 {};