@eagleoutice/flowr 2.0.25 → 2.1.0

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/normalize-definition.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeFunctionDefinition = void 0;
+exports.tryNormalizeFunctionDefinition = tryNormalizeFunctionDefinition;
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
 const arrays_1 = require("../../../../../../../util/arrays");
 const normalize_parameter_1 = require("./normalize-parameter");
+const type_1 = require("../../../../model/type");
 const normalize_expressions_1 = require("../structure/normalize-expressions");
 /**
  * Tries to parse the given data as a function definition.
@@ -17,16 +18,16 @@ const normalize_expressions_1 = require("../structure/normalize-expressions");
  */
 function tryNormalizeFunctionDefinition(data, mappedWithName) {
     const fnBase = mappedWithName[0];
-    if (fnBase.name !== "FUNCTION" /* RawRType.Function */ && fnBase.name !== "\\\\" /* RawRType.Lambda */) {
+    if (fnBase.name !== type_1.RawRType.Function && fnBase.name !== type_1.RawRType.Lambda) {
         parser_1.parseLog.trace(`expected function definition to be identified by keyword, yet received ${fnBase.name}`);
         return undefined;
     }
     const { content, location } = (0, normalize_meta_1.retrieveMetaStructure)(fnBase.content);
     const openParen = mappedWithName[1];
-    (0, assert_1.guard)(openParen.name === "(" /* RawRType.ParenLeft */, () => `expected opening parenthesis, yet received ${openParen.name}`);
-    const closingParenIndex = mappedWithName.findIndex(x => x.name === ")" /* RawRType.ParenRight */);
+    (0, assert_1.guard)(openParen.name === type_1.RawRType.ParenLeft, () => `expected opening parenthesis, yet received ${openParen.name}`);
+    const closingParenIndex = mappedWithName.findIndex(x => x.name === type_1.RawRType.ParenRight);
     (0, assert_1.guard)(closingParenIndex !== -1, () => `expected closing parenthesis, yet received ${JSON.stringify(mappedWithName)}`);
-    const splitParameters = (0, arrays_1.splitArrayOn)(mappedWithName.slice(2, closingParenIndex), x => x.name === "," /* RawRType.Comma */);
+    const splitParameters = (0, arrays_1.splitArrayOn)(mappedWithName.slice(2, closingParenIndex), x => x.name === type_1.RawRType.Comma);
     parser_1.parseLog.trace(`function definition has ${splitParameters.length} parameters (by comma split)`);
     const parameters = splitParameters.map(x => (0, normalize_parameter_1.tryNormalizeParameter)(data, x));
     if (parameters.some(p => p === undefined)) {
@@ -37,9 +38,9 @@ function tryNormalizeFunctionDefinition(data, mappedWithName) {
     const bodyStructure = mappedWithName.slice(closingParenIndex + 1);
     (0, assert_1.guard)(bodyStructure.length === 1, () => `expected function body to be unique, yet received ${bodyStructure.length}`);
     const body = (0, normalize_expressions_1.normalizeExpressions)(data, bodyStructure);
-    (0, assert_1.guard)(body.length === 1 && body[0].type !== "RDelimiter" /* RType.Delimiter */, () => `expected function body to yield one normalized expression, but ${body.length}`);
+    (0, assert_1.guard)(body.length === 1 && body[0].type !== type_1.RType.Delimiter, () => `expected function body to yield one normalized expression, but ${body.length}`);
     return {
-        type: "RFunctionDefinition" /* RType.FunctionDefinition */,
+        type: type_1.RType.FunctionDefinition,
         location,
         lexeme: content,
         parameters: parameters,
@@ -51,5 +52,4 @@ function tryNormalizeFunctionDefinition(data, mappedWithName) {
         }
     };
 }
-exports.tryNormalizeFunctionDefinition = tryNormalizeFunctionDefinition;
 //# sourceMappingURL=normalize-definition.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/normalize-parameter.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeParameter = void 0;
+exports.tryNormalizeParameter = tryNormalizeParameter;
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
+const type_1 = require("../../../../model/type");
 const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * Either parses `[SYMBOL_FORMALS]` or `[SYMBOL_FORMALS, EQ_FORMALS, expr]` as a parameter of a function definition in R.
@@ -21,19 +22,19 @@ function tryNormalizeParameter(data, objs) {
         return undefined;
     }
     const symbol = objs[0];
-    if (symbol.name !== "SYMBOL_FORMALS" /* RawRType.SymbolFormals */) {
+    if (symbol.name !== type_1.RawRType.SymbolFormals) {
         parser_1.parseLog.warn(`expected symbol for parameter, yet received ${JSON.stringify(objs)}`);
         return undefined;
     }
     const defaultValue = objs.length === 3 ? parseWithDefaultValue(data, objs) : undefined;
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(symbol.content);
     return {
-        type: "RParameter" /* RType.Parameter */,
+        type: type_1.RType.Parameter,
         location,
         special: content === '...',
         lexeme: content,
         name: {
-            type: "RSymbol" /* RType.Symbol */,
+            type: type_1.RType.Symbol,
             location, content,
             namespace: undefined,
             lexeme: content,
@@ -43,18 +44,17 @@ function tryNormalizeParameter(data, objs) {
                 fullLexeme: content
             }
         },
-        defaultValue: defaultValue?.type === "RDelimiter" /* RType.Delimiter */ ? undefined : defaultValue,
+        defaultValue: defaultValue?.type === type_1.RType.Delimiter ? undefined : defaultValue,
         info: {
             fullRange: location,
             fullLexeme: content,
-            additionalTokens: defaultValue?.type === "RDelimiter" /* RType.Delimiter */ ? [defaultValue] : []
+            additionalTokens: defaultValue?.type === type_1.RType.Delimiter ? [defaultValue] : []
         }
     };
 }
-exports.tryNormalizeParameter = tryNormalizeParameter;
 function parseWithDefaultValue(data, objs) {
-    (0, assert_1.guard)(objs[1].name === "EQ_FORMALS" /* RawRType.EqualFormals */, () => `[arg-default] second element of parameter must be ${"EQ_FORMALS" /* RawRType.EqualFormals */}, but: ${JSON.stringify(objs)}`);
-    (0, assert_1.guard)(objs[2].name === "expr" /* RawRType.Expression */, () => `[arg-default] third element of parameter must be an Expression but: ${JSON.stringify(objs)}`);
+    (0, assert_1.guard)(objs[1].name === type_1.RawRType.EqualFormals, () => `[arg-default] second element of parameter must be ${type_1.RawRType.EqualFormals}, but: ${JSON.stringify(objs)}`);
+    (0, assert_1.guard)(objs[2].name === type_1.RawRType.Expression, () => `[arg-default] third element of parameter must be an Expression but: ${JSON.stringify(objs)}`);
     return (0, normalize_single_node_1.normalizeSingleNode)(data, objs[2]);
 }
 //# sourceMappingURL=normalize-parameter.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/normalize-break.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeBreak = void 0;
+exports.normalizeBreak = normalizeBreak;
 const parser_1 = require("../../../json/parser");
 const log_1 = require("../../../../../../../util/log");
 const normalize_meta_1 = require("../../normalize-meta");
+const type_1 = require("../../../../model/type");
 function normalizeBreak(data, obj) {
     (0, log_1.expensiveTrace)(parser_1.parseLog, () => `[break] ${JSON.stringify(obj)}`);
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
     return {
-        type: "RBreak" /* RType.Break */,
+        type: type_1.RType.Break,
         location,
         lexeme: content,
         info: {
@@ -18,5 +19,4 @@ function normalizeBreak(data, obj) {
         }
     };
 }
-exports.normalizeBreak = normalizeBreak;
 //# sourceMappingURL=normalize-break.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/normalize-for.js

@@ -1,24 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeFor = void 0;
+exports.tryNormalizeFor = tryNormalizeFor;
 const input_format_1 = require("../../input-format");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
+const type_1 = require("../../../../model/type");
 const normalize_single_node_1 = require("../structure/normalize-single-node");
 const normalize_expressions_1 = require("../structure/normalize-expressions");
 const normalize_symbol_1 = require("../values/normalize-symbol");
 const normalize_comment_1 = require("../other/normalize-comment");
 function tryNormalizeFor(data, [forToken, head, body]) {
     // funny, for does not use top-level parenthesis
-    if (forToken.name !== "FOR" /* RawRType.For */) {
+    if (forToken.name !== type_1.RawRType.For) {
         parser_1.parseLog.debug('encountered non-for token for supposed for-loop structure');
         return undefined;
     }
-    else if (head.name !== "forcond" /* RawRType.ForCondition */) {
+    else if (head.name !== type_1.RawRType.ForCondition) {
         throw new input_format_1.XmlParseError(`expected condition for for-loop but found ${JSON.stringify(head)}`);
     }
-    else if (body.name !== "expr" /* RawRType.Expression */ && body.name !== "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */ && body.name !== "equal_assign" /* RawRType.LegacyEqualAssign */) {
+    else if (body.name !== type_1.RawRType.Expression && body.name !== type_1.RawRType.ExprOfAssignOrHelp && body.name !== type_1.RawRType.LegacyEqualAssign) {
         throw new input_format_1.XmlParseError(`expected expr body for for-loop but found ${JSON.stringify(body)}`);
     }
     parser_1.parseLog.debug('trying to parse for-loop');
@@ -27,7 +28,7 @@ function tryNormalizeFor(data, [forToken, head, body]) {
     const parseBody = (0, normalize_single_node_1.normalizeSingleNode)(newParseData, body);
     if (parsedVariable === undefined ||
         parsedVector === undefined ||
-        parseBody.type === "RDelimiter" /* RType.Delimiter */) {
+        parseBody.type === type_1.RType.Delimiter) {
         throw new input_format_1.XmlParseError(`unexpected under-sided for-loop, received ${JSON.stringify([
             parsedVariable,
             parsedVariable,
@@ -36,7 +37,7 @@ function tryNormalizeFor(data, [forToken, head, body]) {
     }
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(forToken.content);
     return {
-        type: "RForLoop" /* RType.ForLoop */,
+        type: type_1.RType.ForLoop,
         variable: parsedVariable,
         vector: parsedVector,
         body: (0, normalize_meta_1.ensureExpressionList)(parseBody),
@@ -49,18 +50,17 @@ function tryNormalizeFor(data, [forToken, head, body]) {
         location
     };
 }
-exports.tryNormalizeFor = tryNormalizeFor;
 function normalizeForHead(data, forCondition) {
     // must have a child which is `in`, a variable on the left, and a vector on the right
     const children = (0, input_format_1.getKeyGuarded)(forCondition, input_format_1.childrenKey).map(content => ({ name: (0, normalize_meta_1.getTokenType)(content), content }));
     const { comments, others } = (0, normalize_expressions_1.splitComments)(children);
-    const inPosition = others.findIndex(elem => elem.name === "IN" /* RawRType.ForIn */);
+    const inPosition = others.findIndex(elem => elem.name === type_1.RawRType.ForIn);
     (0, assert_1.guard)(inPosition > 0 && inPosition < others.length - 1, () => `for loop searched in and found at ${inPosition}, but this is not in legal bounds for ${JSON.stringify(children)}`);
     const variable = (0, normalize_symbol_1.tryNormalizeSymbol)(data, [others[inPosition - 1]]);
     (0, assert_1.guard)(variable !== undefined, () => `for loop variable should have been parsed to a symbol but was ${JSON.stringify(variable)}`);
-    (0, assert_1.guard)(variable.type === "RSymbol" /* RType.Symbol */, () => `for loop variable should have been parsed to a symbol but was ${JSON.stringify(variable)}`);
+    (0, assert_1.guard)(variable.type === type_1.RType.Symbol, () => `for loop variable should have been parsed to a symbol but was ${JSON.stringify(variable)}`);
     const vector = (0, normalize_expressions_1.normalizeExpressions)(data, [others[inPosition + 1]]);
-    (0, assert_1.guard)(vector.length === 1 && vector[0].type !== "RDelimiter" /* RType.Delimiter */, () => `for loop vector should have been parsed to a single element but was ${JSON.stringify(vector)}`);
+    (0, assert_1.guard)(vector.length === 1 && vector[0].type !== type_1.RType.Delimiter, () => `for loop vector should have been parsed to a single element but was ${JSON.stringify(vector)}`);
     const parsedComments = comments.map(c => (0, normalize_comment_1.normalizeComment)(data, c.content));
     return { variable, vector: vector[0], comments: parsedComments };
 }

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/normalize-next.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeNext = void 0;
+exports.normalizeNext = normalizeNext;
 const log_1 = require("../../../../../../../util/log");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
+const type_1 = require("../../../../model/type");
 function normalizeNext(data, obj) {
     (0, log_1.expensiveTrace)(parser_1.parseLog, () => `[next] ${JSON.stringify(obj)}`);
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
     return {
-        type: "RNext" /* RType.Next */,
+        type: type_1.RType.Next,
         location,
         lexeme: content,
         info: {
@@ -18,5 +19,4 @@ function normalizeNext(data, obj) {
         }
     };
 }
-exports.normalizeNext = normalizeNext;
 //# sourceMappingURL=normalize-next.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/normalize-repeat.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeRepeat = void 0;
+exports.tryNormalizeRepeat = tryNormalizeRepeat;
 const parser_1 = require("../../../json/parser");
 const assert_1 = require("../../../../../../../util/assert");
 const normalize_meta_1 = require("../../normalize-meta");
+const type_1 = require("../../../../model/type");
 const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * Try to parse the construct as a {@link RRepeatLoop}.
@@ -15,16 +16,16 @@ const normalize_single_node_1 = require("../structure/normalize-single-node");
  * @returns The parsed {@link RRepeatLoop} or `undefined` if the given construct is not a repeat-loop
  */
 function tryNormalizeRepeat(data, [repeatToken, bodyToken]) {
-    if (repeatToken.name !== "REPEAT" /* RawRType.Repeat */) {
+    if (repeatToken.name !== type_1.RawRType.Repeat) {
         parser_1.parseLog.debug('encountered non-repeat token for supposed repeat-loop structure');
         return undefined;
     }
     parser_1.parseLog.debug('trying to parse repeat-loop');
     const parseBody = (0, normalize_single_node_1.normalizeSingleNode)(data, bodyToken);
-    (0, assert_1.guard)(parseBody.type !== "RDelimiter" /* RType.Delimiter */, () => `no body for repeat-loop ${JSON.stringify(repeatToken)} (${JSON.stringify(bodyToken)})`);
+    (0, assert_1.guard)(parseBody.type !== type_1.RType.Delimiter, () => `no body for repeat-loop ${JSON.stringify(repeatToken)} (${JSON.stringify(bodyToken)})`);
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(repeatToken.content);
     return {
-        type: "RRepeatLoop" /* RType.RepeatLoop */,
+        type: type_1.RType.RepeatLoop,
         location,
         lexeme: content,
         body: (0, normalize_meta_1.ensureExpressionList)(parseBody),
@@ -35,5 +36,4 @@ function tryNormalizeRepeat(data, [repeatToken, bodyToken]) {
         }
     };
 }
-exports.tryNormalizeRepeat = tryNormalizeRepeat;
 //# sourceMappingURL=normalize-repeat.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/normalize-while.js

@@ -1,25 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeWhile = void 0;
+exports.tryNormalizeWhile = tryNormalizeWhile;
 const input_format_1 = require("../../input-format");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
+const type_1 = require("../../../../model/type");
 const normalize_single_node_1 = require("../structure/normalize-single-node");
 function tryNormalizeWhile(data, [whileToken, leftParen, condition, rightParen, body]) {
-    if (whileToken.name !== "WHILE" /* RawRType.While */) {
+    if (whileToken.name !== type_1.RawRType.While) {
         parser_1.parseLog.debug('encountered non-while token for supposed while-loop structure');
         return undefined;
     }
-    else if (leftParen.name !== "(" /* RawRType.ParenLeft */) {
+    else if (leftParen.name !== type_1.RawRType.ParenLeft) {
         throw new input_format_1.XmlParseError(`expected left-parenthesis for while but found ${JSON.stringify(leftParen)}`);
     }
-    else if (rightParen.name !== ")" /* RawRType.ParenRight */) {
+    else if (rightParen.name !== type_1.RawRType.ParenRight) {
         throw new input_format_1.XmlParseError(`expected right-parenthesis for while but found ${JSON.stringify(rightParen)}`);
     }
     parser_1.parseLog.debug('trying to parse while-loop');
     const parsedCondition = (0, normalize_single_node_1.normalizeSingleNode)(data, condition);
     const parseBody = (0, normalize_single_node_1.normalizeSingleNode)(data, body);
-    if (parsedCondition.type === "RDelimiter" /* RType.Delimiter */ || parseBody.type === "RDelimiter" /* RType.Delimiter */) {
+    if (parsedCondition.type === type_1.RType.Delimiter || parseBody.type === type_1.RType.Delimiter) {
         throw new input_format_1.XmlParseError(`unexpected under-sided while-loop, received ${JSON.stringify([
             parsedCondition,
             parseBody,
@@ -27,7 +28,7 @@ function tryNormalizeWhile(data, [whileToken, leftParen, condition, rightParen,
     }
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(whileToken.content);
     return {
-        type: "RWhileLoop" /* RType.WhileLoop */,
+        type: type_1.RType.WhileLoop,
         condition: parsedCondition,
         body: (0, normalize_meta_1.ensureExpressionList)(parseBody),
         lexeme: content,
@@ -39,5 +40,4 @@ function tryNormalizeWhile(data, [whileToken, leftParen, condition, rightParen,
         }
     };
 }
-exports.tryNormalizeWhile = tryNormalizeWhile;
 //# sourceMappingURL=normalize-while.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/normalize-access.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeAccess = void 0;
+exports.tryNormalizeAccess = tryNormalizeAccess;
 const normalize_argument_1 = require("./functions/normalize-argument");
 const parser_1 = require("../../json/parser");
 const arrays_1 = require("../../../../../../util/arrays");
 const assert_1 = require("../../../../../../util/assert");
 const normalize_meta_1 = require("../normalize-meta");
+const type_1 = require("../../../model/type");
 const normalize_single_node_1 = require("./structure/normalize-single-node");
 const r_function_call_1 = require("../../../model/nodes/r-function-call");
 const normalize_expressions_1 = require("./structure/normalize-expressions");
@@ -13,16 +14,16 @@ function normalizeAbstractArgument(x, data, operator) {
     if (x.length === 0) {
         return r_function_call_1.EmptyArgument;
     }
-    else if (x.length !== 1 || x[0].name === "expr" /* RawRType.Expression */) {
+    else if (x.length !== 1 || x[0].name === type_1.RawRType.Expression) {
         const gotAccess = (0, normalize_argument_1.tryToNormalizeArgument)(data, x);
         (0, assert_1.guard)(gotAccess !== undefined, () => `expected one access result in access as argument, yet received ${JSON.stringify(gotAccess)} for ${JSON.stringify([operator, x])}`);
         return gotAccess;
     }
     else {
         const node = (0, normalize_single_node_1.normalizeSingleNode)(data, x[0]);
-        (0, assert_1.guard)(node.type !== "RExpressionList" /* RType.ExpressionList */, () => `expected expression list to be parsed as argument, yet received ${JSON.stringify(node)} for ${JSON.stringify(x)}`);
+        (0, assert_1.guard)(node.type !== type_1.RType.ExpressionList, () => `expected expression list to be parsed as argument, yet received ${JSON.stringify(node)} for ${JSON.stringify(x)}`);
         return {
-            type: "RArgument" /* RType.Argument */,
+            type: type_1.RType.Argument,
             location: node.location,
             lexeme: node.lexeme,
             name: undefined,
@@ -53,17 +54,17 @@ function tryNormalizeAccess(data, mappedWithName) {
     let operator;
     let closingLength = 0;
     switch (accessOp.name) {
-        case "[" /* RawRType.BracketLeft */:
+        case type_1.RawRType.BracketLeft:
             operator = '[';
             closingLength = 1;
             break;
-        case "$" /* RawRType.Dollar */:
+        case type_1.RawRType.Dollar:
             operator = '$';
             break;
-        case "@" /* RawRType.At */:
+        case type_1.RawRType.At:
             operator = '@';
             break;
-        case "LBB" /* RawRType.DoubleBracketLeft */:
+        case type_1.RawRType.DoubleBracketLeft:
             operator = '[[';
             closingLength = 2;
             break;
@@ -72,7 +73,7 @@ function tryNormalizeAccess(data, mappedWithName) {
             return undefined;
     }
     const accessed = mappedWithName[0];
-    if (accessed.name !== "expr" /* RawRType.Expression */ && accessed.name !== "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */ && accessed.name !== "equal_assign" /* RawRType.LegacyEqualAssign */) {
+    if (accessed.name !== type_1.RawRType.Expression && accessed.name !== type_1.RawRType.ExprOfAssignOrHelp && accessed.name !== type_1.RawRType.LegacyEqualAssign) {
         parser_1.parseLog.trace(`expected accessed element to be wrapped an expression, yet received ${accessed.name}`);
         return undefined;
     }
@@ -83,13 +84,13 @@ function tryNormalizeAccess(data, mappedWithName) {
     }
     const remaining = mappedWithName.slice(2, mappedWithName.length - closingLength);
     parser_1.parseLog.trace(`${remaining.length} remaining arguments for access`);
-    const splitAccessOnComma = (0, arrays_1.splitArrayOn)(remaining, x => x.name === "," /* RawRType.Comma */);
+    const splitAccessOnComma = (0, arrays_1.splitArrayOn)(remaining, x => x.name === type_1.RawRType.Comma);
     const parsedAccess = splitAccessOnComma.map(x => {
         return normalizeAbstractArgument(x, data, operator);
     });
     const { content, location } = (0, normalize_meta_1.retrieveMetaStructure)(accessOp.content);
     return {
-        type: "RAccess" /* RType.Access */,
+        type: type_1.RType.Access,
         location,
         lexeme: content,
         accessed: parsedAccessed[0],
@@ -102,5 +103,4 @@ function tryNormalizeAccess(data, mappedWithName) {
         }
     };
 }
-exports.tryNormalizeAccess = tryNormalizeAccess;
 //# sourceMappingURL=normalize-access.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/operators/normalize-binary.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeBinary = void 0;
+exports.tryNormalizeBinary = tryNormalizeBinary;
 const input_format_1 = require("../../input-format");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
 const log_1 = require("../../../../../../../util/log");
 const strings_1 = require("../../../../../../../util/strings");
+const type_1 = require("../../../../model/type");
 const operators_1 = require("../../../../model/operators");
 const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
@@ -15,36 +16,35 @@ const normalize_single_node_1 = require("../structure/normalize-single-node");
  */
 function tryNormalizeBinary(data, [lhs, operator, rhs]) {
     (0, log_1.expensiveTrace)(parser_1.parseLog, () => `binary op for ${lhs.name} [${operator.name}] ${rhs.name}`);
-    if (operator.name === "SPECIAL" /* RawRType.Special */ || operators_1.OperatorsInRAst.has(operator.name) || operator.name === "PIPE" /* RawRType.Pipe */) {
+    if (operator.name === type_1.RawRType.Special || operators_1.OperatorsInRAst.has(operator.name) || operator.name === type_1.RawRType.Pipe) {
         return parseBinaryOp(data, lhs, operator, rhs);
     }
     else {
         return undefined;
     }
 }
-exports.tryNormalizeBinary = tryNormalizeBinary;
 function parseBinaryOp(data, lhs, operator, rhs) {
     (0, normalize_meta_1.ensureChildrenAreLhsAndRhsOrdered)(lhs.content, rhs.content);
     const parsedLhs = (0, normalize_single_node_1.normalizeSingleNode)(data, lhs);
     const parsedRhs = (0, normalize_single_node_1.normalizeSingleNode)(data, rhs);
-    if (parsedLhs.type === "RDelimiter" /* RType.Delimiter */ || parsedRhs.type === "RDelimiter" /* RType.Delimiter */) {
+    if (parsedLhs.type === type_1.RType.Delimiter || parsedRhs.type === type_1.RType.Delimiter) {
         throw new input_format_1.XmlParseError(`unexpected under-sided binary op, received ${JSON.stringify([parsedLhs, parsedRhs])} for ${JSON.stringify([lhs, operator, rhs])}`);
     }
     const operationName = (0, normalize_meta_1.retrieveOpName)(operator);
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(operator.content);
     if ((0, strings_1.startAndEndsWith)(operationName, '%')) {
-        const lhsLoc = parsedLhs.type === "RExpressionList" /* RType.ExpressionList */ ? parsedLhs.grouping?.[0].location : parsedLhs.location;
-        const rhsLoc = parsedRhs.type === "RExpressionList" /* RType.ExpressionList */ ? parsedRhs.grouping?.[0].location : parsedRhs.location;
+        const lhsLoc = parsedLhs.type === type_1.RType.ExpressionList ? parsedLhs.grouping?.[0].location : parsedLhs.location;
+        const rhsLoc = parsedRhs.type === type_1.RType.ExpressionList ? parsedRhs.grouping?.[0].location : parsedRhs.location;
         (0, assert_1.guard)(lhsLoc !== undefined && rhsLoc !== undefined, () => `special op lhs and rhs must have a locations, but ${JSON.stringify(parsedLhs)} || ${JSON.stringify(lhsLoc)} and ${JSON.stringify(parsedRhs)} ||  || ${JSON.stringify(rhsLoc)})`);
         // parse as infix function call!
         return {
-            type: "RFunctionCall" /* RType.FunctionCall */,
+            type: type_1.RType.FunctionCall,
             named: true,
             infixSpecial: true,
             lexeme: data.currentLexeme ?? content,
             location,
             functionName: {
-                type: "RSymbol" /* RType.Symbol */,
+                type: type_1.RType.Symbol,
                 location,
                 lexeme: content,
                 content,
@@ -53,7 +53,7 @@ function parseBinaryOp(data, lhs, operator, rhs) {
             },
             arguments: [
                 {
-                    type: "RArgument" /* RType.Argument */,
+                    type: type_1.RType.Argument,
                     location: lhsLoc,
                     value: parsedLhs,
                     name: undefined,
@@ -61,7 +61,7 @@ function parseBinaryOp(data, lhs, operator, rhs) {
                     info: {}
                 },
                 {
-                    type: "RArgument" /* RType.Argument */,
+                    type: type_1.RType.Argument,
                     location: rhsLoc,
                     value: parsedRhs,
                     name: undefined,
@@ -72,14 +72,14 @@ function parseBinaryOp(data, lhs, operator, rhs) {
             info: {}
         };
     }
-    else if (operator.name === "PIPE" /* RawRType.Pipe */) {
+    else if (operator.name === type_1.RawRType.Pipe) {
         (0, assert_1.guard)(parsedLhs.location !== undefined, () => `pipe lhs must have a location, but ${JSON.stringify(parsedLhs)})`);
         (0, assert_1.guard)(parsedLhs.lexeme !== undefined, () => `pipe lhs must have a full lexeme, but ${JSON.stringify(parsedLhs)})`);
         return {
-            type: "RPipe" /* RType.Pipe */,
+            type: type_1.RType.Pipe,
             location,
             lhs: {
-                type: "RArgument" /* RType.Argument */,
+                type: type_1.RType.Argument,
                 location: parsedLhs.location,
                 value: parsedLhs,
                 name: undefined,
@@ -97,7 +97,7 @@ function parseBinaryOp(data, lhs, operator, rhs) {
     }
     else {
         return {
-            type: "RBinaryOp" /* RType.BinaryOp */,
+            type: type_1.RType.BinaryOp,
             location,
             lhs: parsedLhs,
             rhs: parsedRhs,

package/r-bridge/lang-4.x/ast/parser/xml/internal/operators/normalize-unary.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeUnary = void 0;
+exports.tryNormalizeUnary = tryNormalizeUnary;
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
 const log_1 = require("../../../../../../../util/log");
 const operators_1 = require("../../../../model/operators");
 const normalize_single_node_1 = require("../structure/normalize-single-node");
+const type_1 = require("../../../../model/type");
 /**
  * Parses the construct as a {@link RUnaryOp}.
  *
@@ -25,14 +26,13 @@ function tryNormalizeUnary(data, [operator, operand]) {
         return undefined;
     }
 }
-exports.tryNormalizeUnary = tryNormalizeUnary;
 function parseUnaryOp(data, operator, operand) {
     const parsedOperand = (0, normalize_single_node_1.normalizeSingleNode)(data, operand);
-    (0, assert_1.guard)(parsedOperand.type !== "RDelimiter" /* RType.Delimiter */, 'unexpected under-sided unary op');
+    (0, assert_1.guard)(parsedOperand.type !== type_1.RType.Delimiter, 'unexpected under-sided unary op');
     const operationName = (0, normalize_meta_1.retrieveOpName)(operator);
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(operator.content);
     return {
-        type: "RUnaryOp" /* RType.UnaryOp */,
+        type: type_1.RType.UnaryOp,
         location,
         operator: operationName,
         lexeme: content,

package/r-bridge/lang-4.x/ast/parser/xml/internal/other/normalize-comment.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeComment = void 0;
+exports.normalizeComment = normalizeComment;
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
+const type_1 = require("../../../../model/type");
 /**
  * Normalize the given object as an R comment.
  * This requires you to check the corresponding name beforehand.
@@ -14,7 +15,7 @@ function normalizeComment(data, obj) {
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
     (0, assert_1.guard)(content.startsWith('#'), 'comment must start with #');
     return {
-        type: "RComment" /* RType.Comment */,
+        type: type_1.RType.Comment,
         location,
         content: content.slice(1),
         lexeme: content,
@@ -25,5 +26,4 @@ function normalizeComment(data, obj) {
         }
     };
 }
-exports.normalizeComment = normalizeComment;
 //# sourceMappingURL=normalize-comment.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/other/normalize-line-directive.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeLineDirective = void 0;
+exports.normalizeLineDirective = normalizeLineDirective;
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
+const type_1 = require("../../../../model/type");
 const LineDirectiveRegex = /^#line\s+(\d+)\s+"([^"]+)"\s*$/;
 /**
  * Normalize the given object as an R line directive (`#line <number> "<file>"`).
@@ -20,7 +21,7 @@ function normalizeLineDirective(data, obj) {
     if (match === null) {
         parser_1.parseLog.debug(`[line-directive] does not match the regex ${LineDirectiveRegex.source} given ${JSON.stringify(content)}`);
         return {
-            type: "RComment" /* RType.Comment */,
+            type: type_1.RType.Comment,
             location,
             lexeme: content,
             info: {
@@ -33,7 +34,7 @@ function normalizeLineDirective(data, obj) {
     }
     else {
         return {
-            type: "RLineDirective" /* RType.LineDirective */,
+            type: type_1.RType.LineDirective,
             location,
             line: parseInt(match[1]),
             file: match[2],
@@ -46,5 +47,4 @@ function normalizeLineDirective(data, obj) {
         };
     }
 }
-exports.normalizeLineDirective = normalizeLineDirective;
 //# sourceMappingURL=normalize-line-directive.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/structure/normalize-delimiter.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeDelimiter = void 0;
+exports.normalizeDelimiter = normalizeDelimiter;
 const normalize_meta_1 = require("../../normalize-meta");
+const type_1 = require("../../../../model/type");
 function normalizeDelimiter(elem) {
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(elem.content);
     return {
-        type: "RDelimiter" /* RType.Delimiter */,
+        type: type_1.RType.Delimiter,
         location,
         lexeme: content,
         subtype: elem.name
     };
 }
-exports.normalizeDelimiter = normalizeDelimiter;
 //# sourceMappingURL=normalize-delimiter.js.map