@eagleoutice/flowr 1.3.11

package/reconstruct/reconstruct.js

@@ -0,0 +1,448 @@
+"use strict";
+/**
+ * This module has one goal (and is to be rewritten soon to achieve that goal,
+ * as the file itself is way too long). See {@link reconstructToCode}.
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconstructToCode = exports.autoSelectLibrary = exports.doNotAutoSelect = exports.reconstructLogger = void 0;
+const r_bridge_1 = require("../r-bridge");
+const log_1 = require("../util/log");
+const assert_1 = require("../util/assert");
+function plain(text) {
+    return [{ line: text, indent: 0 }];
+}
+exports.reconstructLogger = log_1.log.getSubLogger({ name: 'reconstruct' });
+const getLexeme = (n) => n.info.fullLexeme ?? n.lexeme ?? '';
+const reconstructAsLeaf = (leaf, configuration) => {
+    const selectionHasLeaf = configuration.selection.has(leaf.info.id) || configuration.autoSelectIf(leaf);
+    if (selectionHasLeaf) {
+        return foldToConst(leaf);
+    }
+    else {
+        return [];
+    }
+    // reconstructLogger.trace(`reconstructAsLeaf: ${leaf.info.id} (${selectionHasLeaf ? 'y' : 'n'}):  ${JSON.stringify(wouldBe)}`)
+    // return selectionHasLeaf ? wouldBe : []
+};
+const foldToConst = (n) => plain(getLexeme(n));
+function indentBy(lines, indent) {
+    return lines.map(({ line, indent: i }) => ({ line, indent: i + indent }));
+}
+function reconstructExpressionList(exprList, expressions, configuration) {
+    if (isSelected(configuration, exprList)) {
+        return plain(getLexeme(exprList));
+    }
+    const subExpressions = expressions.filter(e => e.length > 0);
+    if (subExpressions.length === 0) {
+        return [];
+    }
+    else if (subExpressions.length === 1) {
+        return subExpressions[0];
+    }
+    else {
+        return [
+            { line: '{', indent: 0 },
+            ...indentBy(subExpressions.flat(), 1),
+            { line: '}', indent: 0 }
+        ];
+    }
+}
+function isSelected(configuration, n) {
+    return configuration.selection.has(n.info.id) || configuration.autoSelectIf(n);
+}
+function reconstructRawBinaryOperator(lhs, n, rhs) {
+    return [
+        ...lhs.slice(0, lhs.length - 1),
+        { line: `${lhs[lhs.length - 1].line} ${n} ${rhs[0].line}`, indent: 0 },
+        ...indentBy(rhs.slice(1, rhs.length), 1)
+    ];
+}
+function reconstructUnaryOp(leaf, operand, configuration) {
+    if (configuration.selection.has(leaf.info.id)) {
+        return foldToConst(leaf);
+    }
+    else if (operand.length === 0) {
+        return [];
+    }
+    else {
+        return foldToConst(leaf);
+    }
+}
+function reconstructBinaryOp(n, lhs, rhs, configuration) {
+    if (isSelected(configuration, n)) {
+        return plain(getLexeme(n));
+    }
+    if (lhs.length === 0 && rhs.length === 0) {
+        return [];
+    }
+    if (lhs.length === 0) { // if we have no lhs, only return rhs
+        return rhs;
+    }
+    if (rhs.length === 0) { // if we have no rhs we have to keep everything to get the rhs
+        return plain(getLexeme(n));
+    }
+    return reconstructRawBinaryOperator(lhs, n.type === "RPipe" /* RType.Pipe */ ? '|>' : n.operator, rhs);
+}
+function reconstructForLoop(loop, variable, vector, body, configuration) {
+    if (isSelected(configuration, loop)) {
+        return plain(getLexeme(loop));
+    }
+    if (body.length === 0 && variable.length === 0 && vector.length === 0) {
+        return [];
+    }
+    else {
+        if (body.length <= 1) {
+            // 'inline'
+            return [{ line: `for(${getLexeme(loop.variable)} in ${getLexeme(loop.vector)}) ${body.length === 0 ? '{}' : body[0].line}`, indent: 0 }];
+        }
+        else if (body[0].line === '{' && body[body.length - 1].line === '}') {
+            // 'block'
+            return [
+                { line: `for(${getLexeme(loop.variable)} in ${getLexeme(loop.vector)}) {`, indent: 0 },
+                ...body.slice(1, body.length - 1),
+                { line: '}', indent: 0 }
+            ];
+        }
+        else {
+            // unknown
+            return [
+                { line: `for(${getLexeme(loop.variable)} in ${getLexeme(loop.vector)})`, indent: 0 },
+                ...indentBy(body, 1)
+            ];
+        }
+    }
+}
+function reconstructRepeatLoop(loop, body, configuration) {
+    if (isSelected(configuration, loop)) {
+        return plain(getLexeme(loop));
+    }
+    else if (body.length === 0) {
+        return [];
+    }
+    else {
+        if (body.length <= 1) {
+            // 'inline'
+            return [{ line: `repeat ${body.length === 0 ? '{}' : body[0].line}`, indent: 0 }];
+        }
+        else if (body[0].line === '{' && body[body.length - 1].line === '}') {
+            // 'block'
+            return [
+                { line: 'repeat {', indent: 0 },
+                ...body.slice(1, body.length - 1),
+                { line: '}', indent: 0 }
+            ];
+        }
+        else {
+            // unknown
+            return [
+                { line: 'repeat', indent: 0 },
+                ...indentBy(body, 1)
+            ];
+        }
+    }
+}
+function removeExpressionListWrap(code) {
+    if (code.length > 0 && code[0].line === '{' && code[code.length - 1].line === '}') {
+        return indentBy(code.slice(1, code.length - 1), -1);
+    }
+    else {
+        return code;
+    }
+}
+function reconstructIfThenElse(ifThenElse, condition, when, otherwise, configuration) {
+    if (isSelected(configuration, ifThenElse)) {
+        return plain(getLexeme(ifThenElse));
+    }
+    otherwise ??= [];
+    if (condition.length === 0 && when.length === 0 && otherwise.length === 0) {
+        return [];
+    }
+    if (otherwise.length === 0 && when.length === 0) {
+        return [
+            { line: `if(${getLexeme(ifThenElse.condition)}) { }`, indent: 0 }
+        ];
+    }
+    else if (otherwise.length === 0) {
+        return [
+            { line: `if(${getLexeme(ifThenElse.condition)}) {`, indent: 0 },
+            ...indentBy(removeExpressionListWrap(when), 1),
+            { line: '}', indent: 0 }
+        ];
+    }
+    else if (when.length === 0) {
+        return [
+            { line: `if(${getLexeme(ifThenElse.condition)}) { } else {`, indent: 0 },
+            ...indentBy(removeExpressionListWrap(otherwise), 1),
+            { line: '}', indent: 0 }
+        ];
+    }
+    else {
+        return [
+            { line: `if(${getLexeme(ifThenElse.condition)}) {`, indent: 0 },
+            ...indentBy(removeExpressionListWrap(when), 1),
+            { line: '} else {', indent: 0 },
+            ...indentBy(removeExpressionListWrap(otherwise), 1),
+            { line: '}', indent: 0 }
+        ];
+    }
+}
+function reconstructWhileLoop(loop, condition, body, configuration) {
+    if (isSelected(configuration, loop)) {
+        return plain(getLexeme(loop));
+    }
+    if (body.length === 0 && condition.length === 0) {
+        return [];
+    }
+    else {
+        if (body.length <= 1) {
+            // 'inline'
+            return [{ line: `while(${getLexeme(loop.condition)}) ${body.length === 0 ? '{}' : body[0].line}`, indent: 0 }];
+        }
+        else if (body[0].line === '{' && body[body.length - 1].line === '}') {
+            // 'block'
+            return [
+                { line: `while(${getLexeme(loop.condition)}) {`, indent: 0 },
+                ...body.slice(1, body.length - 1),
+                { line: '}', indent: 0 }
+            ];
+        }
+        else {
+            // unknown
+            return [
+                { line: `while(${getLexeme(loop.condition)})`, indent: 0 },
+                ...indentBy(body, 1)
+            ];
+        }
+    }
+}
+function reconstructParameters(parameters) {
+    // const baseParameters = parameters.flatMap(p => plain(getLexeme(p)))
+    return parameters.map(p => {
+        if (p.defaultValue !== undefined) {
+            return `${getLexeme(p.name)}=${getLexeme(p.defaultValue)}`;
+        }
+        else {
+            return getLexeme(p);
+        }
+    });
+}
+function reconstructFoldAccess(node, accessed, access, configuration) {
+    if (isSelected(configuration, node)) {
+        return plain(getLexeme(node));
+    }
+    if (accessed.length === 0) {
+        if (typeof access === 'string') {
+            return [];
+        }
+        else {
+            return access.filter(assert_1.isNotNull).flat();
+        }
+    }
+    return plain(getLexeme(node));
+}
+function reconstructArgument(argument, name, value, configuration) {
+    if (isSelected(configuration, argument)) {
+        return plain(getLexeme(argument));
+    }
+    if (argument.name !== undefined && name !== undefined && name.length > 0) {
+        return plain(`${getLexeme(argument.name)}=${argument.value ? getLexeme(argument.value) : ''}`);
+    }
+    else {
+        return value ?? [];
+    }
+}
+function reconstructParameter(parameter, name, value, configuration) {
+    if (isSelected(configuration, parameter)) {
+        return plain(getLexeme(parameter));
+    }
+    if (parameter.defaultValue !== undefined && name.length > 0) {
+        return plain(`${getLexeme(parameter.name)}=${getLexeme(parameter.defaultValue)}`);
+    }
+    else if (parameter.defaultValue !== undefined && name.length === 0) {
+        return plain(getLexeme(parameter.defaultValue));
+    }
+    else {
+        return name;
+    }
+}
+function reconstructFunctionDefinition(definition, functionParameters, body, configuration) {
+    // if a definition is not selected, we only use the body - slicing will always select the definition
+    if (!isSelected(configuration, definition) && functionParameters.every(p => p.length === 0)) {
+        return body;
+    }
+    const parameters = reconstructParameters(definition.parameters).join(', ');
+    if (body.length <= 1) {
+        // 'inline'
+        const bodyStr = body.length === 0 ? '' : `${body[0].line} `; /* add suffix space */
+        // we keep the braces in every case because I do not like no-brace functions
+        return [{ line: `function(${parameters}) { ${bodyStr}}`, indent: 0 }];
+    }
+    else if (body[0].line === '{' && body[body.length - 1].line === '}') {
+        // 'block'
+        return [
+            { line: `function(${parameters}) {`, indent: 0 },
+            ...body.slice(1, body.length - 1),
+            { line: '}', indent: 0 }
+        ];
+    }
+    else {
+        // unknown -> we add the braces just to be sure
+        return [
+            { line: `function(${parameters}) {`, indent: 0 },
+            ...indentBy(body, 1),
+            { line: '}', indent: 0 }
+        ];
+    }
+}
+function reconstructSpecialInfixFunctionCall(args, call) {
+    (0, assert_1.guard)(args.length === 2, () => `infix special call must have exactly two arguments, got: ${args.length} (${JSON.stringify(args)})`);
+    (0, assert_1.guard)(call.flavor === 'named', `infix special call must be named, got: ${call.flavor}`);
+    const lhs = args[0];
+    const rhs = args[1];
+    if ((lhs === undefined || lhs.length === 0) && (rhs === undefined || rhs.length === 0)) {
+        return [];
+    }
+    // else if (rhs === undefined || rhs.length === 0) {
+    // if rhs is undefined we still  have to keep both now, but reconstruct manually :/
+    if (lhs !== undefined && lhs.length > 0) {
+        const lhsText = lhs.map(l => `${getIndentString(l.indent)}${l.line}`).join('\n');
+        if (rhs !== undefined && rhs.length > 0) {
+            const rhsText = rhs.map(l => `${getIndentString(l.indent)}${l.line}`).join('\n');
+            return plain(`${lhsText} ${call.functionName.content} ${rhsText}`);
+        }
+        else {
+            return plain(lhsText);
+        }
+    }
+    return plain(`${getLexeme(call.arguments[0])} ${call.functionName.content} ${getLexeme(call.arguments[1])}`);
+}
+function reconstructFunctionCall(call, functionName, args, configuration) {
+    if (call.infixSpecial === true) {
+        return reconstructSpecialInfixFunctionCall(args, call);
+    }
+    if (call.flavor === 'named' && isSelected(configuration, call)) {
+        return plain(getLexeme(call));
+    }
+    const filteredArgs = args.filter(a => a !== undefined && a.length > 0);
+    if (functionName.length === 0 && filteredArgs.length === 0) {
+        return [];
+    }
+    if (args.length === 0) {
+        (0, assert_1.guard)(functionName.length === 1, `without args, we need the function name to be present! got: ${JSON.stringify(functionName)}`);
+        if (call.flavor === 'unnamed' && !functionName[0].line.endsWith(')')) {
+            functionName[0].line = `(${functionName[0].line})`;
+        }
+        if (!functionName[0].line.endsWith('()')) {
+            // add empty call braces if not present
+            functionName[0].line += '()';
+        }
+        return [{ line: functionName[0].line, indent: functionName[0].indent }];
+    }
+    else {
+        return plain(getLexeme(call));
+    }
+}
+function doNotAutoSelect(_node) {
+    return false;
+}
+exports.doNotAutoSelect = doNotAutoSelect;
+const libraryFunctionCall = /^(library|require|((require|load|attach)Namespace))$/;
+function autoSelectLibrary(node) {
+    if (node.type !== "RFunctionCall" /* RType.FunctionCall */ || node.flavor !== 'named') {
+        return false;
+    }
+    return libraryFunctionCall.test(node.functionName.content);
+}
+exports.autoSelectLibrary = autoSelectLibrary;
+/**
+ * The fold functions used to reconstruct the ast in {@link reconstructToCode}.
+ */
+// escalates with undefined if all are undefined
+const reconstructAstFolds = {
+    // we just pass down the state information so everyone has them
+    down: (_n, c) => c,
+    foldNumber: reconstructAsLeaf,
+    foldString: reconstructAsLeaf,
+    foldLogical: reconstructAsLeaf,
+    foldSymbol: reconstructAsLeaf,
+    foldAccess: reconstructFoldAccess,
+    binaryOp: {
+        foldLogicalOp: reconstructBinaryOp,
+        foldArithmeticOp: reconstructBinaryOp,
+        foldComparisonOp: reconstructBinaryOp,
+        foldAssignment: reconstructBinaryOp,
+        foldPipe: reconstructBinaryOp,
+        foldModelFormula: reconstructBinaryOp
+    },
+    unaryOp: {
+        foldArithmeticOp: reconstructUnaryOp,
+        foldLogicalOp: reconstructUnaryOp,
+        foldModelFormula: reconstructUnaryOp
+    },
+    other: {
+        foldComment: reconstructAsLeaf,
+        foldLineDirective: reconstructAsLeaf
+    },
+    loop: {
+        foldFor: reconstructForLoop,
+        foldRepeat: reconstructRepeatLoop,
+        foldWhile: reconstructWhileLoop,
+        foldBreak: reconstructAsLeaf,
+        foldNext: reconstructAsLeaf
+    },
+    foldIfThenElse: reconstructIfThenElse,
+    foldExprList: reconstructExpressionList,
+    functions: {
+        foldFunctionDefinition: reconstructFunctionDefinition,
+        foldFunctionCall: reconstructFunctionCall,
+        foldParameter: reconstructParameter,
+        foldArgument: reconstructArgument
+    }
+};
+function getIndentString(indent) {
+    return ' '.repeat(indent * 4);
+}
+function prettyPrintCodeToString(code, lf = '\n') {
+    return code.map(({ line, indent }) => `${getIndentString(indent)}${line}`).join(lf);
+}
+function removeOuterExpressionListIfApplicable(result, autoSelected) {
+    if (result.length > 1 && result[0].line === '{' && result[result.length - 1].line === '}') {
+        // remove outer block
+        return { code: prettyPrintCodeToString(indentBy(result.slice(1, result.length - 1), -1)), autoSelected };
+    }
+    else {
+        return { code: prettyPrintCodeToString(result), autoSelected };
+    }
+}
+/**
+ * Reconstructs parts of a normalized R ast into R code on an expression basis.
+ *
+ * @param ast          - The {@link NormalizedAst|normalized ast} to be used as a basis for reconstruction
+ * @param selection    - The selection of nodes to be reconstructed (probably the {@link NodeId|NodeIds} identified by the slicer)
+ * @param autoSelectIf - A predicate that can be used to force the reconstruction of a node (for example to reconstruct library call statements, see {@link autoSelectLibrary}, {@link doNotAutoSelect})
+ *
+ * @returns The number of times `autoSelectIf` triggered, as well as the reconstructed code itself.
+ */
+function reconstructToCode(ast, selection, autoSelectIf = autoSelectLibrary) {
+    if (exports.reconstructLogger.settings.minLevel >= 1 /* LogLevel.Trace */) {
+        exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection])}`);
+    }
+    // we use a wrapper to count the number of times the autoSelectIf predicate triggered
+    let autoSelected = 0;
+    const autoSelectIfWrapper = (node) => {
+        const result = autoSelectIf(node);
+        if (result) {
+            autoSelected++;
+        }
+        return result;
+    };
+    // fold of the normalized ast
+    const result = (0, r_bridge_1.foldAstStateful)(ast.ast, { selection, autoSelectIf: autoSelectIfWrapper }, reconstructAstFolds);
+    if (exports.reconstructLogger.settings.minLevel >= 1 /* LogLevel.Trace */) {
+        exports.reconstructLogger.trace('reconstructed ast before string conversion: ', JSON.stringify(result));
+    }
+    return removeOuterExpressionListIfApplicable(result, autoSelected);
+}
+exports.reconstructToCode = reconstructToCode;
+//# sourceMappingURL=reconstruct.js.map

package/slicing/criterion/collect-all.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Sometimes we want to know all possible slicing criteria (obeying some filter).
+ * This module provides a function to collect all slicing criteria.
+ * @module
+ */
+import { MergeableRecord } from '../../util/objects';
+import { NodeId, RNodeWithParent } from '../../r-bridge';
+import { SlicingCriteria } from './parse';
+/**
+ * Defines the filter for collecting all possible slicing criteria.
+ * @see DefaultAllVariablesFilter
+ */
+export interface SlicingCriteriaFilter extends MergeableRecord {
+    /**
+   * Inclusive minimum size of the slicing criteria (number of included slice points).
+   * Should be at least `1` to make sense (and of course at most {@link SlicingCriteriaFilter#maximumSize | maximum size}).
+   */
+    minimumSize: number;
+    /**
+   * Inclusive maximum size of the slicing criteria (number of included slice points).
+   * Should be at least `1` to make sense (and of course at least {@link SlicingCriteriaFilter#minimumSize | minimum size}).
+   * <p>
+   * Be really careful with this one, as the number of possible slicing criteria can grow exponentially with the maximum size.
+   */
+    maximumSize: number;
+    /**
+   * Function that determines the ids of all nodes that can be used as slicing criteria.
+   */
+    collectAll: (root: RNodeWithParent) => NodeId[];
+}
+/**
+ * Will create all possible slicing criteria for the given ast, based on the {@link SlicingCriteriaFilter}.
+ * The slicing criteria will be *ordered* (i.e., it will not return `[1:2,3:4]` and `[3:4,1:2]` if `maximumSize` \> 1).
+ * If there are not enough matching nodes within the ast, this will return *no* slicing criteria!
+ */
+export declare function collectAllSlicingCriteria<OtherInfo>(ast: RNodeWithParent<OtherInfo>, filter: Readonly<SlicingCriteriaFilter>): Generator<SlicingCriteria, void, void>;

package/slicing/criterion/collect-all.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectAllSlicingCriteria = void 0;
+const assert_1 = require("../../util/assert");
+const arrays_1 = require("../../util/arrays");
+/**
+ * Will create all possible slicing criteria for the given ast, based on the {@link SlicingCriteriaFilter}.
+ * The slicing criteria will be *ordered* (i.e., it will not return `[1:2,3:4]` and `[3:4,1:2]` if `maximumSize` \> 1).
+ * If there are not enough matching nodes within the ast, this will return *no* slicing criteria!
+ */
+function* collectAllSlicingCriteria(ast, filter) {
+    (0, assert_1.guard)(filter.minimumSize >= 1, `Minimum size must be at least 1, but was ${filter.minimumSize}`);
+    (0, assert_1.guard)(filter.maximumSize >= filter.minimumSize, `Maximum size must be at least minimum size, but was ${filter.maximumSize} < ${filter.minimumSize}`);
+    const potentialSlicingNodes = filter.collectAll(ast);
+    if (potentialSlicingNodes.length < filter.minimumSize) {
+        return;
+    }
+    for (const combination of (0, arrays_1.getUniqueCombinationsOfSize)(potentialSlicingNodes, filter.minimumSize, filter.maximumSize)) {
+        yield combination.map(n => `$${n}`);
+    }
+}
+exports.collectAllSlicingCriteria = collectAllSlicingCriteria;
+//# sourceMappingURL=collect-all.js.map

package/slicing/criterion/filters/all-variables.d.ts

@@ -0,0 +1,2 @@
+import { SlicingCriteriaFilter } from '../collect-all';
+export declare const DefaultAllVariablesFilter: SlicingCriteriaFilter;

package/slicing/criterion/filters/all-variables.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultAllVariablesFilter = void 0;
+const r_bridge_1 = require("../../../r-bridge");
+const assert_1 = require("../../../util/assert");
+exports.DefaultAllVariablesFilter = {
+    minimumSize: 1,
+    maximumSize: 1,
+    collectAll: defaultAllVariablesCollector
+};
+const onLeaf = () => [];
+const onBinary = (_, lhs, rhs) => [...lhs, ...rhs];
+const defaultAllVariablesCollectorFolds = {
+    foldNumber: onLeaf,
+    foldString: onLeaf,
+    foldLogical: onLeaf,
+    foldSymbol: (symbol) => (0, r_bridge_1.isSpecialSymbol)(symbol) ? [] : [symbol.info.id],
+    foldAccess: (_, name, access) => Array.isArray(access) ? [...name, ...access.filter(assert_1.isNotNull).flat()] : name,
+    binaryOp: {
+        foldLogicalOp: onBinary,
+        foldArithmeticOp: onBinary,
+        foldComparisonOp: onBinary,
+        foldAssignment: onBinary,
+        foldPipe: onBinary,
+        foldModelFormula: onBinary
+    },
+    unaryOp: {
+        foldLogicalOp: (_, operator) => operator,
+        foldArithmeticOp: (_, operator) => operator,
+        foldModelFormula: (_, operator) => operator
+    },
+    loop: {
+        foldFor: (_, a, b, c) => [...a, ...b, ...c],
+        foldWhile: (_, a, b) => [...a, ...b],
+        foldRepeat: (_, a) => a,
+        foldNext: onLeaf,
+        foldBreak: onLeaf
+    },
+    other: {
+        foldComment: onLeaf,
+        foldLineDirective: onLeaf
+    },
+    foldIfThenElse: (_, a, b, c) => [...a, ...b, ...(c ?? [])],
+    foldExprList: (_, a) => a.flat(),
+    functions: {
+        foldFunctionDefinition: (_, a, b) => [...a.flat(), ...b],
+        foldFunctionCall: (c, a, b) => {
+            const args = b.flatMap(b => b !== undefined ? b.flat() : []);
+            if (c.flavor === 'named') {
+                return c.functionName.content === 'library' ? args.slice(1) : args;
+            }
+            else {
+                return [...a, ...args];
+            }
+        },
+        foldArgument: (_, a, b) => b ?? [],
+        foldParameter: (_, a, b) => b ?? []
+    }
+};
+function defaultAllVariablesCollector(ast) {
+    return (0, r_bridge_1.foldAst)(ast, defaultAllVariablesCollectorFolds);
+}
+//# sourceMappingURL=all-variables.js.map

package/slicing/criterion/filters/index.d.ts

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

package/slicing/criterion/filters/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("./all-variables"), exports);
+//# sourceMappingURL=index.js.map

package/slicing/criterion/index.d.ts

@@ -0,0 +1,3 @@
+export * from './parse';
+export * from './collect-all';
+export * from './filters';

package/slicing/criterion/index.js

@@ -0,0 +1,20 @@
+"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("./parse"), exports);
+__exportStar(require("./collect-all"), exports);
+__exportStar(require("./filters"), exports);
+//# sourceMappingURL=index.js.map

package/slicing/criterion/parse.d.ts

@@ -0,0 +1,20 @@
+import { NormalizedAst, NodeId, NoInfo, ParentInformation } from '../../r-bridge';
+/** Either `line:column`, `line@variable-name`, or `$id` */
+export type SingleSlicingCriterion = `${number}:${number}` | `${number}@${string}` | `$${number}`;
+export type SlicingCriteria = SingleSlicingCriterion[];
+/**
+ * Thrown if the given slicing criteria can not be found
+ */
+export declare class CriteriaParseError extends Error {
+    constructor(message: string);
+}
+/**
+ * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
+ */
+export declare function slicingCriterionToId<OtherInfo = NoInfo>(criterion: SingleSlicingCriterion, decorated: NormalizedAst<OtherInfo & ParentInformation>): NodeId;
+export interface DecodedCriterion {
+    criterion: SingleSlicingCriterion;
+    id: NodeId;
+}
+export type DecodedCriteria = DecodedCriterion[];
+export declare function convertAllSlicingCriteriaToIds(criteria: SlicingCriteria, decorated: NormalizedAst): DecodedCriteria;