@eagleoutice/flowr 1.3.11

package/r-bridge/lang-4.x/ast/model/processing/role.d.ts

@@ -0,0 +1,41 @@
+import { DecoratedAstMap, RNodeWithParent } from './decorate';
+/**
+ * Describes the role of the node in its parent. For example,
+ * if we have `if(TRUE) { ... }`, the role of the `TRUE` node is `IfCondition`.
+ *
+ * @see ParentContextInfo
+ * @see ParentInformation
+ */
+export declare const enum RoleInParent {
+    /** has no parent */
+    Root = "root",
+    IfCondition = "if-cond",
+    IfThen = "if-then",
+    IfOtherwise = "if-otherwise",
+    WhileCondition = "while-cond",
+    WhileBody = "while-body",
+    RepeatBody = "repeat-body",
+    ForVariable = "for-variable",
+    ForVector = "for-vector",
+    ForBody = "for-body",
+    FunctionCallName = "call-name",
+    FunctionCallArgument = "call-argument",
+    FunctionDefinitionBody = "function-def-body",
+    FunctionDefinitionParameter = "function-def-param",
+    ExpressionListChild = "expr-list-child",
+    BinaryOperationLhs = "binop-lhs",
+    BinaryOperationRhs = "binop-rhs",
+    PipeLhs = "pipe-lhs",
+    PipeRhs = "pipe-rhs",
+    UnaryOperand = "unary-operand",
+    ParameterName = "param-name",
+    ParameterDefaultValue = "param-value",
+    ArgumentName = "arg-name",
+    ArgumentValue = "arg-value",
+    Accessed = "accessed",
+    IndexAccess = "index-access"
+}
+/**
+ * Returns the roles of the parents of the given node, starting with the parent-role of the node itself.
+ */
+export declare function rolesOfParents(node: RNodeWithParent, idMap: DecoratedAstMap): RoleInParent[];

package/r-bridge/lang-4.x/ast/model/processing/role.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rolesOfParents = void 0;
+/**
+ * Returns the roles of the parents of the given node, starting with the parent-role of the node itself.
+ */
+function rolesOfParents(node, idMap) {
+    const roles = [];
+    let current = node;
+    while (current !== undefined) {
+        roles.push(current.info.role);
+        current = current.info.parent ? idMap.get(current.info.parent) : undefined;
+    }
+    return roles;
+}
+exports.rolesOfParents = rolesOfParents;
+//# sourceMappingURL=role.js.map

package/r-bridge/lang-4.x/ast/model/processing/stateful-fold.d.ts

@@ -0,0 +1,61 @@
+import { DeepReadonly } from 'ts-essentials';
+import { RExpressionList, RNumber, RSymbol, RLogical, RString, RArithmeticBinaryOp, RAssignmentOp, RComparisonBinaryOp, RLogicalBinaryOp, RArithmeticUnaryOp, RLogicalUnaryOp, RIfThenElse, RForLoop, RRepeatLoop, RWhileLoop, RFunctionCall, RComment, RNext, RBreak, RParameter, RArgument, RFunctionDefinition, RAccess, RModelFormulaBinaryOp, RModelFormulaUnaryOp, RLineDirective, RPipe } from '../nodes';
+import { RNode } from '../model';
+/**
+ * Called during the down-pass, will pe propagated to children and used in the up-pass (see {@link StatefulFoldFunctions}).
+ * <p>
+ * Exists for leafs as well for consistency reasons.
+ */
+export type DownFold<Info, Down> = (node: RNode<Info>, down: Down) => Down;
+/**
+ * All fold functions besides `down` are called after the down-pass in conventional fold-fashion.
+ * The `down` argument holds information obtained during the down-pass, issued by the `down` function.
+ */
+export interface StatefulFoldFunctions<Info, Down, Up> {
+    down: DownFold<Info, Down>;
+    foldNumber: (num: RNumber<Info>, down: Down) => Up;
+    foldString: (str: RString<Info>, down: Down) => Up;
+    foldLogical: (logical: RLogical<Info>, down: Down) => Up;
+    foldSymbol: (symbol: RSymbol<Info>, down: Down) => Up;
+    foldAccess: (node: RAccess<Info>, name: Up, access: string | (null | Up)[], down: Down) => Up;
+    binaryOp: {
+        foldLogicalOp: (op: RLogicalBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
+        foldArithmeticOp: (op: RArithmeticBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
+        foldComparisonOp: (op: RComparisonBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
+        foldAssignment: (op: RAssignmentOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
+        foldPipe: (op: RPipe<Info>, lhs: Up, rhs: Up, down: Down) => Up;
+        foldModelFormula: (op: RModelFormulaBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
+    };
+    unaryOp: {
+        foldLogicalOp: (op: RLogicalUnaryOp<Info>, operand: Up, down: Down) => Up;
+        foldArithmeticOp: (op: RArithmeticUnaryOp<Info>, operand: Up, down: Down) => Up;
+        foldModelFormula: (op: RModelFormulaUnaryOp<Info>, operand: Up, down: Down) => Up;
+    };
+    loop: {
+        foldFor: (loop: RForLoop<Info>, variable: Up, vector: Up, body: Up, down: Down) => Up;
+        foldWhile: (loop: RWhileLoop<Info>, condition: Up, body: Up, down: Down) => Up;
+        foldRepeat: (loop: RRepeatLoop<Info>, body: Up, down: Down) => Up;
+        foldNext: (next: RNext<Info>, down: Down) => Up;
+        foldBreak: (next: RBreak<Info>, down: Down) => Up;
+    };
+    other: {
+        foldComment: (comment: RComment<Info>, down: Down) => Up;
+        foldLineDirective: (comment: RLineDirective<Info>, down: Down) => Up;
+    };
+    /** The `otherwise` argument is `undefined` if the `else` branch is missing */
+    foldIfThenElse: (ifThenExpr: RIfThenElse<Info>, cond: Up, then: Up, otherwise: Up | undefined, down: Down) => Up;
+    foldExprList: (exprList: RExpressionList<Info>, expressions: Up[], down: Down) => Up;
+    functions: {
+        foldFunctionDefinition: (definition: RFunctionDefinition<Info>, params: Up[], body: Up, down: Down) => Up;
+        /** folds named and unnamed function calls */
+        foldFunctionCall: (call: RFunctionCall<Info>, functionNameOrExpression: Up, args: (Up | undefined)[], down: Down) => Up;
+        /** The `name` is `undefined` if the argument is unnamed, the value, if we have something like `x=,...` */
+        foldArgument: (argument: RArgument<Info>, name: Up | undefined, value: Up | undefined, down: Down) => Up;
+        /** The `defaultValue` is `undefined` if the argument was not initialized with a default value */
+        foldParameter: (parameter: RParameter<Info>, name: Up, defaultValue: Up | undefined, down: Down) => Up;
+    };
+}
+/**
+ * Folds in old functional-fashion over the AST structure but allowing for a down function which can pass context to child nodes.
+ */
+export declare function foldAstStateful<Info, Down, Up>(ast: RNode<Info>, down: Down, folds: DeepReadonly<StatefulFoldFunctions<Info, Down, Up>>): Up;

package/r-bridge/lang-4.x/ast/model/processing/stateful-fold.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foldAstStateful = void 0;
+const assert_1 = require("../../../../../util/assert");
+/**
+ * Folds in old functional-fashion over the AST structure but allowing for a down function which can pass context to child nodes.
+ */
+function foldAstStateful(ast, down, folds) {
+    const type = ast.type;
+    down = folds.down(ast, down);
+    switch (type) {
+        case "RNumber" /* RType.Number */:
+            return folds.foldNumber(ast, down);
+        case "RString" /* RType.String */:
+            return folds.foldString(ast, down);
+        case "RLogical" /* RType.Logical */:
+            return folds.foldLogical(ast, down);
+        case "RSymbol" /* RType.Symbol */:
+            return folds.foldSymbol(ast, down);
+        case "RComment" /* RType.Comment */:
+            return folds.other.foldComment(ast, down);
+        case "RLineDirective" /* RType.LineDirective */:
+            return folds.other.foldLineDirective(ast, down);
+        case "RPipe" /* RType.Pipe */:
+            return folds.binaryOp.foldPipe(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
+        case "RBinaryOp" /* RType.BinaryOp */:
+            return foldBinaryOp(ast, down, folds);
+        case "RUnaryOp" /* RType.UnaryOp */:
+            return foldUnaryOp(ast, down, folds);
+        case "RAccess" /* RType.Access */:
+            return folds.foldAccess(ast, foldAstStateful(ast.accessed, down, folds), ast.operator === '[' || ast.operator === '[[' ? ast.access.map(access => access === null ? null : foldAstStateful(access, down, folds)) : ast.access, down);
+        case "RForLoop" /* RType.ForLoop */:
+            return folds.loop.foldFor(ast, foldAstStateful(ast.variable, down, folds), foldAstStateful(ast.vector, down, folds), foldAstStateful(ast.body, down, folds), down);
+        case "RWhileLoop" /* RType.WhileLoop */:
+            return folds.loop.foldWhile(ast, foldAstStateful(ast.condition, down, folds), foldAstStateful(ast.body, down, folds), down);
+        case "RRepeatLoop" /* RType.RepeatLoop */:
+            return folds.loop.foldRepeat(ast, foldAstStateful(ast.body, down, folds), down);
+        case "RFunctionCall" /* RType.FunctionCall */:
+            return folds.functions.foldFunctionCall(ast, foldAstStateful(ast.flavor === 'named' ? ast.functionName : ast.calledFunction, down, folds), ast.arguments.map(param => param === undefined ? param : foldAstStateful(param, down, folds)), down);
+        case "RFunctionDefinition" /* RType.FunctionDefinition */:
+            return folds.functions.foldFunctionDefinition(ast, ast.parameters.map(param => foldAstStateful(param, down, folds)), foldAstStateful(ast.body, down, folds), down);
+        case "RParameter" /* RType.Parameter */:
+            return folds.functions.foldParameter(ast, foldAstStateful(ast.name, down, folds), ast.defaultValue ? foldAstStateful(ast.defaultValue, down, folds) : undefined, down);
+        case "RArgument" /* RType.Argument */:
+            return folds.functions.foldArgument(ast, ast.name ? foldAstStateful(ast.name, down, folds) : undefined, ast.value ? foldAstStateful(ast.value, down, folds) : undefined, down);
+        case "RNext" /* RType.Next */:
+            return folds.loop.foldNext(ast, down);
+        case "RBreak" /* RType.Break */:
+            return folds.loop.foldBreak(ast, down);
+        case "RIfThenElse" /* RType.IfThenElse */:
+            return folds.foldIfThenElse(ast, foldAstStateful(ast.condition, down, folds), foldAstStateful(ast.then, down, folds), ast.otherwise === undefined ? undefined : foldAstStateful(ast.otherwise, down, folds), down);
+        case "RExpressionList" /* RType.ExpressionList */:
+            return folds.foldExprList(ast, ast.children.map(expr => foldAstStateful(expr, down, folds)), down);
+        default:
+            (0, assert_1.assertUnreachable)(type);
+    }
+}
+exports.foldAstStateful = foldAstStateful;
+function foldBinaryOp(ast, down, folds) {
+    switch (ast.flavor) {
+        case 'logical':
+            return folds.binaryOp.foldLogicalOp(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
+        case 'arithmetic':
+            return folds.binaryOp.foldArithmeticOp(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
+        case 'comparison':
+            return folds.binaryOp.foldComparisonOp(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
+        case 'assignment':
+            return folds.binaryOp.foldAssignment(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
+        case 'model formula':
+            return folds.binaryOp.foldModelFormula(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
+        default:
+            (0, assert_1.assertUnreachable)(ast.flavor);
+    }
+}
+function foldUnaryOp(ast, down, folds) {
+    switch (ast.flavor) {
+        case 'logical':
+            return folds.unaryOp.foldLogicalOp(ast, foldAstStateful(ast.operand, down, folds), down);
+        case 'arithmetic':
+            return folds.unaryOp.foldArithmeticOp(ast, foldAstStateful(ast.operand, down, folds), down);
+        case 'model formula':
+            return folds.unaryOp.foldModelFormula(ast, foldAstStateful(ast.operand, down, folds), down);
+        default:
+            (0, assert_1.assertUnreachable)(ast.flavor);
+    }
+}
+//# sourceMappingURL=stateful-fold.js.map

package/r-bridge/lang-4.x/ast/model/processing/visitor.d.ts

@@ -0,0 +1,13 @@
+import { NoInfo, RNode } from '../model';
+/** Return `true` to stop visiting from this node (i.e., do not continue to visit this node *and* the children) */
+export type OnEnter<OtherInfo> = (node: RNode<OtherInfo>) => (boolean | void);
+/** Similar to {@link OnEnter} but called when leaving a node. Can't stop exploration as the subtree is already visited! */
+export type OnExit<OtherInfo> = (node: RNode<OtherInfo>) => void;
+/**
+ * Collects all node ids within a tree given by a respective root node
+ *
+ * @param nodes          - The root id nodes to start collecting from
+ * @param onVisit        - Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return `true` stop)
+ * @param onExit         - Called after the subtree of a node has been visited, called for leafs too (even though their subtree is empty)
+ */
+export declare function visitAst<OtherInfo = NoInfo>(nodes: RNode<OtherInfo> | (RNode<OtherInfo> | null | undefined)[] | undefined, onVisit?: OnEnter<OtherInfo>, onExit?: OnExit<OtherInfo>): void;

package/r-bridge/lang-4.x/ast/model/processing/visitor.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitAst = void 0;
+const assert_1 = require("../../../../../util/assert");
+// capsuled as a class to avoid passing onExit and onEnter on *each* visit call
+class NodeVisitor {
+    onEnter;
+    onExit;
+    constructor(onEnter, onExit) {
+        this.onEnter = onEnter;
+        this.onExit = onExit;
+    }
+    visitSingle(node) {
+        if (this.onEnter?.(node)) {
+            return;
+        }
+        /* let the type system know, that the type does not change */
+        const type = node.type;
+        switch (type) {
+            case "RFunctionCall" /* RType.FunctionCall */:
+                this.visitSingle(node.flavor === 'named' ? node.functionName : node.calledFunction);
+                this.visit(node.arguments);
+                break;
+            case "RFunctionDefinition" /* RType.FunctionDefinition */:
+                this.visit(node.parameters);
+                this.visitSingle(node.body);
+                break;
+            case "RExpressionList" /* RType.ExpressionList */:
+                this.visit(node.children);
+                break;
+            case "RForLoop" /* RType.ForLoop */:
+                this.visitSingle(node.variable);
+                this.visitSingle(node.vector);
+                this.visitSingle(node.body);
+                break;
+            case "RWhileLoop" /* RType.WhileLoop */:
+                this.visitSingle(node.condition);
+                this.visitSingle(node.body);
+                break;
+            case "RRepeatLoop" /* RType.RepeatLoop */:
+                this.visitSingle(node.body);
+                break;
+            case "RIfThenElse" /* RType.IfThenElse */:
+                this.visitSingle(node.condition);
+                this.visitSingle(node.then);
+                this.visit(node.otherwise);
+                break;
+            case "RBinaryOp" /* RType.BinaryOp */:
+            case "RPipe" /* RType.Pipe */:
+                this.visitSingle(node.lhs);
+                this.visitSingle(node.rhs);
+                break;
+            case "RUnaryOp" /* RType.UnaryOp */:
+                this.visitSingle(node.operand);
+                break;
+            case "RParameter" /* RType.Parameter */:
+                this.visitSingle(node.name);
+                this.visit(node.defaultValue);
+                break;
+            case "RArgument" /* RType.Argument */:
+                this.visit(node.name);
+                this.visit(node.value);
+                break;
+            case "RAccess" /* RType.Access */:
+                this.visitSingle(node.accessed);
+                if (node.operator === '[' || node.operator === '[[') {
+                    this.visit(node.access);
+                }
+                break;
+            case "RSymbol" /* RType.Symbol */:
+            case "RLogical" /* RType.Logical */:
+            case "RNumber" /* RType.Number */:
+            case "RString" /* RType.String */:
+            case "RComment" /* RType.Comment */:
+            case "RBreak" /* RType.Break */:
+            case "RNext" /* RType.Next */:
+            case "RLineDirective" /* RType.LineDirective */:
+                // leafs
+                break;
+            default:
+                (0, assert_1.assertUnreachable)(type);
+        }
+        this.onExit?.(node);
+    }
+    visit(nodes) {
+        if (Array.isArray(nodes)) {
+            for (const node of nodes) {
+                if (node) {
+                    this.visitSingle(node);
+                }
+            }
+        }
+        else if (nodes) {
+            this.visitSingle(nodes);
+        }
+    }
+}
+/**
+ * Collects all node ids within a tree given by a respective root node
+ *
+ * @param nodes          - The root id nodes to start collecting from
+ * @param onVisit        - Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return `true` stop)
+ * @param onExit         - Called after the subtree of a node has been visited, called for leafs too (even though their subtree is empty)
+ */
+function visitAst(nodes, onVisit, onExit) {
+    return new NodeVisitor(onVisit, onExit).visit(nodes);
+}
+exports.visitAst = visitAst;
+//# sourceMappingURL=visitor.js.map

package/r-bridge/lang-4.x/ast/model/type.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Token types as they are produced by the R parser.
+ * Not all of them are directly handled by the normalize step.
+ * Some of them are also listed as part of the {@link OperatorDatabase}.
+ *
+ * @see RType
+ */
+export declare const enum RawRType {
+    /** T1 */
+    NullConst = "NULL_CONST",
+    /** T2 */
+    NumericConst = "NUM_CONST",
+    /** T3 */
+    StringConst = "STR_CONST",
+    /** T4 */
+    EqualAssign = "EQ_ASSIGN",
+    /** T5 */
+    EqualFormals = "EQ_FORMALS",
+    /** T6 */
+    EqualSub = "EQ_SUB",
+    /** T7 */
+    LeftAssign = "LEFT_ASSIGN",
+    /** T8 */
+    RightAssign = "RIGHT_ASSIGN",
+    /** T9 */
+    And = "AND",
+    /** T10 */
+    And2 = "AND2",
+    /** T11 */
+    Eq = "EQ",
+    /** T12 */
+    Ge = "GE",
+    /** T13 */
+    Gt = "GT",
+    /** T14 */
+    Le = "LE",
+    /** T15 */
+    Lt = "LT",
+    /** T16 */
+    Ne = "NE",
+    /** T17 */
+    Or = "OR",
+    /** T18 */
+    Or2 = "OR2",
+    /** T19 */
+    Pipe = "PIPE",
+    /** T20 */
+    Pipebind = "PIPEBIND",
+    /** T21 */
+    Special = "SPECIAL",
+    /** T22 */
+    Plus = "+",
+    /** T23 */
+    Minus = "-",
+    /** T24 */
+    Times = "*",
+    /** T25 */
+    Div = "/",
+    /** T26 */
+    Colon = ":",
+    /** T27 */
+    Exclamation = "!",
+    /** T28 */
+    Exp = "^",
+    /** T29 */
+    Question = "?",
+    /** T30 */
+    Tilde = "~",
+    /** T31 */
+    Break = "BREAK",
+    /** T32 */
+    Else = "ELSE",
+    /** T33 */
+    For = "FOR",
+    /** T34 */
+    ForCondition = "forcond",
+    /** T35 */
+    If = "IF",
+    /** T36 */
+    ForIn = "IN",
+    /** T37 */
+    Next = "NEXT",
+    /** T38 */
+    Repeat = "REPEAT",
+    /** T39 */
+    While = "WHILE",
+    /** T40 */
+    Function = "FUNCTION",
+    /** T41 */
+    Lambda = "\\\\",
+    /** T42 */
+    DoubleBracketLeft = "LBB",
+    /** T43 */
+    Slot = "SLOT",
+    /** T44 */
+    Dollar = "$",
+    /** T45 */
+    At = "@",
+    /** T46 */
+    BracketLeft = "[",
+    /** T47 */
+    BracketRight = "]",
+    /** T48 */
+    NsGet = "::",
+    /** T49 */
+    NsGetInt = ":::",
+    /** T50 */
+    Symbol = "SYMBOL",
+    /** T51 */
+    SymbolFunctionCall = "SYMBOL_FUNCTION_CALL",
+    /** T52 */
+    SymbolPackage = "SYMBOL_PACKAGE",
+    /** T53 */
+    SymbolSub = "SYMBOL_SUB",
+    /** T54 */
+    SymbolFormals = "SYMBOL_FORMALS",
+    /** T55 */
+    Comment = "COMMENT",
+    /** T56 */
+    LineDirective = "LINE_DIRECTIVE",
+    /** T57 */
+    ParenLeft = "(",
+    /** T58 */
+    ParenRight = ")",
+    /** T59 */
+    Comma = ",",
+    /** T60 */
+    Semicolon = ";",
+    /** T61 */
+    BraceLeft = "{",
+    /** T62 */
+    BraceRight = "}",
+    /** T63 */
+    Expression = "expr",
+    /** T64
+     *
+     * https://github.com/REditorSupport/languageserver/issues/327
+     * https://github.com/REditorSupport/languageserver/pull/328
+     */
+    ExprOfAssignOrHelp = "expr_or_assign_or_help",
+    /** T65 */
+    ExpressionList = "exprlist"
+}
+/**
+ * Types as we use them for our normalized AST.
+ * See {@link RNode} for a union type of all normalized AST nodes in-use.
+ * For each enum member, the respective normalized AST node should be referenced
+ * in the corresponding comment.
+ *
+ * @see RawRType
+ */
+export declare const enum RType {
+    /** {@link RAccess} */
+    Access = "RAccess",
+    /** {@link RArgument} */
+    Argument = "RArgument",
+    /** {@link RBinaryOp} */
+    BinaryOp = "RBinaryOp",
+    /** {@link RExpressionList} */
+    ExpressionList = "RExpressionList",
+    /** {@link RForLoop} */
+    ForLoop = "RForLoop",
+    /** {@link RFunctionCall} */
+    FunctionCall = "RFunctionCall",
+    /** {@link RFunctionDefinition} */
+    FunctionDefinition = "RFunctionDefinition",
+    /** {@link RIfThenElse} */
+    IfThenElse = "RIfThenElse",
+    /** {@link RParameter} */
+    Parameter = "RParameter",
+    /** {@link RPipe} */
+    Pipe = "RPipe",
+    /** {@link RRepeatLoop} */
+    RepeatLoop = "RRepeatLoop",
+    /** {@link RUnaryOp} */
+    UnaryOp = "RUnaryOp",
+    /** {@link RWhileLoop} */
+    WhileLoop = "RWhileLoop",
+    /** {@link RBreak} */
+    Break = "RBreak",
+    /** {@link RComment} */
+    Comment = "RComment",
+    /** {@link RLineDirective} */
+    LineDirective = "RLineDirective",
+    /** {@link RLogical} */
+    Logical = "RLogical",
+    /** {@link RNext} */
+    Next = "RNext",
+    /** {@link RNumber} */
+    Number = "RNumber",
+    /** {@link RString} */
+    String = "RString",
+    /** {@link RSymbol} */
+    Symbol = "RSymbol",
+    /** {@link RDelimiter}.
+     * Is not part of the normalized AST but can be found in
+     * {@link Source#additionalTokens}.
+     */
+    Delimiter = "RDelimiter"
+}
+/**
+ * Validates, whether the given type can be used as a symbol in R
+ *
+ * @see RawRType
+ */
+export declare function isSymbol(type: string): boolean;

package/r-bridge/lang-4.x/ast/model/type.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSymbol = void 0;
+/**
+ * Validates, whether the given type can be used as a symbol in R
+ *
+ * @see RawRType
+ */
+function isSymbol(type) {
+    return (type === "SYMBOL" /* RawRType.Symbol */ ||
+        type === "SYMBOL_PACKAGE" /* RawRType.SymbolPackage */ ||
+        type === "SYMBOL_FUNCTION_CALL" /* RawRType.SymbolFunctionCall */ ||
+        type === "NULL_CONST" /* RawRType.NullConst */ ||
+        type === "STR_CONST" /* RawRType.StringConst */ ||
+        type === "SLOT" /* RawRType.Slot */);
+}
+exports.isSymbol = isSymbol;
+//# sourceMappingURL=type.js.map

package/r-bridge/lang-4.x/ast/model/versions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Link certain concepts to the version they have been introduced in R
+ *
+ * @module
+ */
+export declare const MIN_VERSION_PIPE = "4.1.0";
+export declare const MIN_VERSION_LAMBDA = "4.1.0";
+/** between 4.0.0 and (i think) 4.1.0 the parser handled them differently. We ignore that for now. */
+export declare const MIN_VERSION_RAW_STABLE = "4.1.0";

package/r-bridge/lang-4.x/ast/model/versions.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Link certain concepts to the version they have been introduced in R
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_VERSION_RAW_STABLE = exports.MIN_VERSION_LAMBDA = exports.MIN_VERSION_PIPE = void 0;
+exports.MIN_VERSION_PIPE = '4.1.0';
+exports.MIN_VERSION_LAMBDA = '4.1.0';
+/** between 4.0.0 and (i think) 4.1.0 the parser handled them differently. We ignore that for now. */
+exports.MIN_VERSION_RAW_STABLE = '4.1.0';
+//# sourceMappingURL=versions.js.map

package/r-bridge/lang-4.x/ast/parser/xml/common/config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_XML_PARSER_CONFIG = void 0;
+/**
+ * Default configuration to be used for the {@link XmlParserConfig}.
+ * <p>
+ * Note, that this does not include a sensible {@link XmlParserConfig#tokenMap}, as this must be provided by the corresponding
+ * shell environment.
+ */
+exports.DEFAULT_XML_PARSER_CONFIG = {
+    attr: '@a',
+    content: '@v',
+    children: '@c',
+    tokenMap: { /* this should not be used, but just so that we can omit null-checks */}
+};
+//# sourceMappingURL=config.js.map

package/r-bridge/lang-4.x/ast/parser/xml/common/input-format.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeysGuarded = exports.getKeyGuarded = exports.XmlParseError = void 0;
+/**
+ * Thrown if the given input xml is not valid/contains unexpected elements.
+ */
+class XmlParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'XmlParseError';
+    }
+}
+exports.XmlParseError = XmlParseError;
+function error(key, obj) {
+    throw new XmlParseError(`expected obj to have key ${key}, yet received ${JSON.stringify(obj)}`);
+}
+/**
+ * Single-key variant of {@link getKeysGuarded}. Will throw an {@link XmlParseError} if the key is not present.
+ */
+function getKeyGuarded(obj, key) {
+    const res = obj[key];
+    if (res === undefined) {
+        error(key, obj);
+    }
+    return res;
+}
+exports.getKeyGuarded = getKeyGuarded;
+/**
+ * Retrieves the given keys from the converted xml. For a single key, see {@link getKeyGuarded}.
+ * Will throw an {@link XmlParseError} if at least one of the keys is not present
+ *
+ * @typeParam T - the type of the values to retrieve. Note, that this type is not checked at runtime.
+ */
+function getKeysGuarded(obj, ...keys) {
+    const out = {};
+    for (const k of keys) {
+        out[k] = getKeyGuarded(obj, k);
+    }
+    return out;
+}
+exports.getKeysGuarded = getKeysGuarded;
+//# sourceMappingURL=input-format.js.map