Variable TREE_SITTER_SLICING_PIPELINEConst

TREE_SITTER_SLICING_PIPELINE: Pipeline<
    | {
        dependencies: readonly ["normalize"];
        description: "Construct the dataflow graph";
        executed: OncePerFile;
        humanReadableName: "dataflow";
        name: "dataflow";
        printer: {
            "0": <Input>(input: Input) => Input;
            "2": (df: DataflowInformation) => string;
            "3": (df: DataflowInformation) => string;
            "4": (df: DataflowInformation) => string;
            "5": (
                df: DataflowInformation,
                config: QuadSerializationConfiguration,
            ) => string;
        };
        processor: (
            results: {
                normalize?: NormalizedAst<
                    ParentInformation,
                    RNode<ParentInformation>,
                >;
            },
            input: { parser?: Parser<KnownParserType>; request?: RParseRequests },
        ) => DataflowInformation;
        requiredInput: {};
    }
    | {
        dependencies: readonly ["dataflow"];
        description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
        executed: OncePerRequest;
        humanReadableName: "static slice";
        name: "slice";
        printer: { "0": <Input>(input: Input) => Input };
        processor: (
            results: {
                dataflow?: DataflowInformation;
                normalize?: NormalizedAst<ParentInformation, RNode<ParentInformation>>;
            },
            input: Partial<SliceRequiredInput>,
        ) => Readonly<SliceResult>;
        requiredInput: SliceRequiredInput;
    }
    | {
        dependencies: readonly ["slice"];
        description: "Reconstruct R code from the static slice";
        executed: OncePerRequest;
        humanReadableName: "static code reconstruction";
        name: "reconstruct";
        printer: { "0": <Input>(input: Input) => Input };
        processor: (
            results: {
                normalize?: NormalizedAst<
                    ParentInformation,
                    RNode<ParentInformation>,
                >;
                slice?: SliceResult;
            },
            input: Partial<ReconstructRequiredInput>,
        ) => ReconstructionResult;
        requiredInput: ReconstructRequiredInput;
    }
    | {
        dependencies: readonly [];
        description: "Parse the given R code into an AST using tree-sitter";
        executed: OncePerFile;
        humanReadableName: "parse with tree-sitter";
        name: "parse";
        printer: {
            "0": <Input>(input: Input) => Input;
            "2": {
                (
                    value: any,
                    replacer?: (this: any, key: string, value: any) => any,
                    space?: string | number,
                ): string;
                (
                    value: any,
                    replacer?: null | (string | number)[],
                    space?: string | number,
                ): string;
            };
        };
        processor: (
            _results: unknown,
            input: Partial<ParseRequiredInput<Tree>>,
        ) => Promise<ParseStepOutput<Tree>>;
        requiredInput: ParseRequiredInput<Tree>;
    }
    | {
        dependencies: readonly ["parse"];
        description: "Normalize the AST to flowR's AST";
        executed: OncePerFile;
        humanReadableName: "normalize tree-sitter tree";
        name: "normalize";
        printer: {
            "0": <Input>(input: Input) => Input;
            "2": (ast: NormalizedAst) => string;
            "3": (ast: NormalizedAst) => string;
            "4": (ast: NormalizedAst) => string;
            "5": (
                ast: NormalizedAst,
                config: QuadSerializationConfiguration,
            ) => string;
        };
        processor: (
            results: { parse?: ParseStepOutputTS },
            input: Partial<NormalizeRequiredInput>,
        ) => NormalizedAst<ParentInformation, RNode<ParentInformation>>;
        requiredInput: NormalizeRequiredInput;
    },
> = ...