@eagleoutice/flowr 1.5.2 → 2.0.0

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

@@ -1,42 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeRepeat = void 0;
-const meta_1 = require("../meta");
-const structure_1 = require("../structure");
-const assert_1 = require("../../../../../../../util/assert");
-const hooks_1 = require("../../hooks");
 const parser_1 = require("../../../json/parser");
+const assert_1 = require("../../../../../../../util/assert");
+const normalize_meta_1 = require("../../normalize-meta");
+const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * Try to parse the construct as a {@link RRepeatLoop}.
  *
- * @param data - The data used by the parser (see {@link ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @param repeatToken - Token which represents the `repeat` keyword
- * @param body - The `body` of the repeat-loop
+ * @param bodyToken - The `body` of the repeat-loop
  *
  * @returns The parsed {@link RRepeatLoop} or `undefined` if the given construct is not a repeat-loop
  */
-function tryNormalizeRepeat(data, repeatToken, body) {
+function tryNormalizeRepeat(data, [repeatToken, bodyToken]) {
     if (repeatToken.name !== "REPEAT" /* RawRType.Repeat */) {
         parser_1.parseLog.debug('encountered non-repeat token for supposed repeat-loop structure');
-        return (0, hooks_1.executeUnknownHook)(data.hooks.loops.onRepeatLoop.unknown, data, { repeatToken, body });
+        return undefined;
     }
     parser_1.parseLog.debug('trying to parse repeat-loop');
-    ({ repeatToken, body } = (0, hooks_1.executeHook)(data.hooks.loops.onRepeatLoop.before, data, { repeatToken, body }));
-    const parseBody = (0, structure_1.tryNormalizeSingleNode)(data, body);
-    (0, assert_1.guard)(parseBody.type !== "RDelimiter" /* RType.Delimiter */, () => `no body for repeat-loop ${JSON.stringify(repeatToken)} (${JSON.stringify(body)})`);
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(repeatToken.content);
-    const result = {
+    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)})`);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(repeatToken.content);
+    return {
         type: "RRepeatLoop" /* RType.RepeatLoop */,
         location,
         lexeme: content,
-        body: (0, meta_1.ensureExpressionList)(parseBody),
+        body: (0, normalize_meta_1.ensureExpressionList)(parseBody),
         info: {
             fullRange: data.currentRange,
             additionalTokens: [],
             fullLexeme: data.currentLexeme
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.loops.onRepeatLoop.after, data, result);
 }
 exports.tryNormalizeRepeat = tryNormalizeRepeat;
-//# sourceMappingURL=repeat.js.map
+//# sourceMappingURL=normalize-repeat.js.map

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

@@ -0,0 +1,4 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { NamedXmlBasedJson } from '../../input-format';
+import type { RWhileLoop } from '../../../../model/nodes/r-while-loop';
+export declare function tryNormalizeWhile(data: NormalizerData, [whileToken, leftParen, condition, rightParen, body]: [NamedXmlBasedJson, NamedXmlBasedJson, NamedXmlBasedJson, NamedXmlBasedJson, NamedXmlBasedJson]): RWhileLoop | undefined;

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

@@ -2,14 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeWhile = void 0;
 const input_format_1 = require("../../input-format");
-const meta_1 = require("../meta");
-const structure_1 = require("../structure");
-const hooks_1 = require("../../hooks");
 const parser_1 = require("../../../json/parser");
-function tryNormalizeWhile(data, whileToken, leftParen, condition, rightParen, body) {
+const normalize_meta_1 = require("../../normalize-meta");
+const normalize_single_node_1 = require("../structure/normalize-single-node");
+function tryNormalizeWhile(data, [whileToken, leftParen, condition, rightParen, body]) {
     if (whileToken.name !== "WHILE" /* RawRType.While */) {
         parser_1.parseLog.debug('encountered non-while token for supposed while-loop structure');
-        return (0, hooks_1.executeUnknownHook)(data.hooks.loops.onWhileLoop.unknown, data, { whileToken, leftParen, condition, rightParen, body });
+        return undefined;
     }
     else if (leftParen.name !== "(" /* RawRType.ParenLeft */) {
         throw new input_format_1.XmlParseError(`expected left-parenthesis for while but found ${JSON.stringify(leftParen)}`);
@@ -18,19 +17,19 @@ function tryNormalizeWhile(data, whileToken, leftParen, condition, rightParen, b
         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, structure_1.tryNormalizeSingleNode)(data, condition);
-    const parseBody = (0, structure_1.tryNormalizeSingleNode)(data, body);
+    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 */) {
         throw new input_format_1.XmlParseError(`unexpected under-sided while-loop, received ${JSON.stringify([
             parsedCondition,
             parseBody,
         ])} for ${JSON.stringify([whileToken, condition, body])}`);
     }
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(whileToken.content);
-    const result = {
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(whileToken.content);
+    return {
         type: "RWhileLoop" /* RType.WhileLoop */,
         condition: parsedCondition,
-        body: (0, meta_1.ensureExpressionList)(parseBody),
+        body: (0, normalize_meta_1.ensureExpressionList)(parseBody),
         lexeme: content,
         location,
         info: {
@@ -39,7 +38,6 @@ function tryNormalizeWhile(data, whileToken, leftParen, condition, rightParen, b
             fullLexeme: data.currentLexeme
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.loops.onWhileLoop.after, data, result);
 }
 exports.tryNormalizeWhile = tryNormalizeWhile;
-//# sourceMappingURL=while.js.map
+//# sourceMappingURL=normalize-while.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/{access.d.ts → normalize-access.d.ts}

@@ -1,12 +1,12 @@
 import type { NamedXmlBasedJson } from '../input-format';
-import type { ParserData } from '../data';
-import type { RAccess } from '../../../model';
+import type { NormalizerData } from '../normalizer-data';
+import type { RAccess } from '../../../model/nodes/r-access';
 /**
  * Tries to normalize the given data as access (e.g., indexing).
  *
- * @param data           - The data used by the parser (see {@link ParserData})
+ * @param data           - The data used by the parser (see {@link NormalizerData})
  * @param mappedWithName - The json object to extract the meta-information from
  *
  * @returns The parsed {@link RAccess} or `undefined` if the given construct is not accessing a value
  */
-export declare function tryNormalizeAccess(data: ParserData, mappedWithName: NamedXmlBasedJson[]): RAccess | undefined;
+export declare function tryNormalizeAccess(data: NormalizerData, mappedWithName: NamedXmlBasedJson[]): RAccess | undefined;

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

@@ -1,27 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeAccess = void 0;
-const meta_1 = require("./meta");
-const hooks_1 = require("../hooks");
-const structure_1 = require("./structure");
-const assert_1 = require("../../../../../../util/assert");
-const arrays_1 = require("../../../../../../util/arrays");
-const argument_1 = require("./functions/argument");
+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 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");
+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 */) {
+        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)}`);
+        return {
+            type: "RArgument" /* RType.Argument */,
+            location: node.location,
+            lexeme: node.lexeme,
+            name: undefined,
+            value: node,
+            info: {
+                fullRange: node.location,
+                fullLexeme: node.lexeme,
+                additionalTokens: []
+            }
+        };
+    }
+}
 /**
  * Tries to normalize the given data as access (e.g., indexing).
  *
- * @param data           - The data used by the parser (see {@link ParserData})
+ * @param data           - The data used by the parser (see {@link NormalizerData})
  * @param mappedWithName - The json object to extract the meta-information from
  *
  * @returns The parsed {@link RAccess} or `undefined` if the given construct is not accessing a value
  */
 function tryNormalizeAccess(data, mappedWithName) {
     parser_1.parseLog.trace('trying to parse access');
-    mappedWithName = (0, hooks_1.executeHook)(data.hooks.onAccess.before, data, mappedWithName);
     if (mappedWithName.length < 3) {
         parser_1.parseLog.trace('expected at least three elements are required to parse an access');
-        return (0, hooks_1.executeUnknownHook)(data.hooks.onAccess.unknown, data, mappedWithName);
+        return undefined;
     }
     const accessOp = mappedWithName[1];
     let operator;
@@ -43,65 +69,38 @@ function tryNormalizeAccess(data, mappedWithName) {
             break;
         default:
             parser_1.parseLog.trace(`expected second element to be an access operator, yet received ${accessOp.name}`);
-            return (0, hooks_1.executeUnknownHook)(data.hooks.onAccess.unknown, data, mappedWithName);
+            return undefined;
     }
     const accessed = mappedWithName[0];
     if (accessed.name !== "expr" /* RawRType.Expression */ && accessed.name !== "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */) {
         parser_1.parseLog.trace(`expected accessed element to be wrapped an expression, yet received ${accessed.name}`);
-        return (0, hooks_1.executeUnknownHook)(data.hooks.onAccess.unknown, data, mappedWithName);
+        return undefined;
     }
-    const parsedAccessed = (0, structure_1.normalizeBasedOnType)(data, [accessed]);
+    const parsedAccessed = (0, normalize_expressions_1.normalizeExpressions)(data, [accessed]);
     if (parsedAccessed.length !== 1) {
         parser_1.parseLog.trace(`expected accessed element to be wrapped an expression, yet received ${accessed.name}`);
-        return (0, hooks_1.executeUnknownHook)(data.hooks.onAccess.unknown, data, mappedWithName);
+        return undefined;
     }
     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 parsedAccess = splitAccessOnComma.map(x => {
-        if (x.length === 0) {
-            parser_1.parseLog.trace('record empty access');
-            return null;
-        }
-        parser_1.parseLog.trace('trying to parse access');
-        const gotAccess = parseAccessArgument(operator, 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;
+        return normalizeAbstractArgument(x, data, operator);
     });
-    let resultingAccess = parsedAccess;
-    if (operator === '@' || operator === '$') {
-        (0, assert_1.guard)(parsedAccess.length === 1, () => `expected one access result in access with ${JSON.stringify(operator)}, yet received ${JSON.stringify(parsedAccess)}`);
-        const first = parsedAccess[0];
-        (0, assert_1.guard)(first !== null && (first.type === "RSymbol" /* RType.Symbol */ || first.type === "RString" /* RType.String */ || first.type === "RLogical" /* RType.Logical */), () => `${JSON.stringify(operator)} requires one symbol, yet received ${JSON.stringify(parsedAccess)}`);
-        resultingAccess = first.type === "RString" /* RType.String */ ? first.content.str : first.lexeme;
-    }
-    const { content, location } = (0, meta_1.retrieveMetaStructure)(accessOp.content);
-    const result = {
+    const { content, location } = (0, normalize_meta_1.retrieveMetaStructure)(accessOp.content);
+    return {
         type: "RAccess" /* RType.Access */,
         location,
         lexeme: content,
         accessed: parsedAccessed[0],
         operator,
-        access: resultingAccess,
+        access: parsedAccess,
         info: {
             fullRange: data.currentRange,
             additionalTokens: [],
             fullLexeme: data.currentLexeme
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.onAccess.after, data, result);
 }
 exports.tryNormalizeAccess = tryNormalizeAccess;
-function parseAccessArgument(operator, data, elements) {
-    // within access the content is *not* wrapped within another expression, that means if we have a SYMBOL_SUB we can directly parse the argument,
-    // otherwise we have to add the expression layer
-    // console.log('parseAccessArgument', elements.map(x => x.name))
-    if (operator === '@' || operator === '$') {
-        const parse = (0, structure_1.normalizeBasedOnType)(data, elements);
-        return parse.length !== 1 ? undefined : parse[0];
-    }
-    else {
-        return (0, argument_1.tryToNormalizeArgument)(data, elements);
-    }
-}
-//# sourceMappingURL=access.js.map
+//# sourceMappingURL=normalize-access.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/operators/{binary.d.ts → normalize-binary.d.ts}

@@ -1,8 +1,8 @@
+import type { NormalizerData } from '../../normalizer-data';
 import type { NamedXmlBasedJson } from '../../input-format';
-import type { ParserData } from '../../data';
-import type { RNode } from '../../../../model';
+import type { RNode } from '../../../../model/model';
 /**
  * Parsing binary operations includes the pipe, even though the produced PIPE construct is not a binary operation,
  * to ensure it is handled separately from the others (especially in the combination of a pipe bind)
  */
-export declare function tryNormalizeBinary(data: ParserData, lhs: NamedXmlBasedJson, operator: NamedXmlBasedJson, rhs: NamedXmlBasedJson): RNode | undefined;
+export declare function tryNormalizeBinary(data: NormalizerData, [lhs, operator, rhs]: [NamedXmlBasedJson, NamedXmlBasedJson, NamedXmlBasedJson]): RNode | undefined;

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

@@ -2,69 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeBinary = void 0;
 const input_format_1 = require("../../input-format");
-const meta_1 = require("../meta");
-const special_1 = require("./special");
-const structure_1 = require("../structure");
-const model_1 = require("../../../../model");
-const hooks_1 = require("../../hooks");
-const assert_1 = require("../../../../../../../util/assert");
 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 operators_1 = require("../../../../model/operators");
+const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * Parsing binary operations includes the pipe, even though the produced PIPE construct is not a binary operation,
  * to ensure it is handled separately from the others (especially in the combination of a pipe bind)
  */
-function tryNormalizeBinary(data, lhs, operator, rhs) {
-    parser_1.parseLog.trace(`binary op for ${lhs.name} [${operator.name}] ${rhs.name}`);
-    let flavor;
-    if ("SPECIAL" /* RawRType.Special */ === operator.name) {
-        flavor = 'special';
-    }
-    else if (model_1.ArithmeticOperatorsRAst.has(operator.name)) {
-        flavor = 'arithmetic';
-    }
-    else if (model_1.ComparisonOperatorsRAst.has(operator.name)) {
-        flavor = 'comparison';
-    }
-    else if (model_1.LogicalOperatorsRAst.has(operator.name)) {
-        flavor = 'logical';
-    }
-    else if (model_1.ModelFormulaOperatorsRAst.has(operator.name)) {
-        flavor = 'model formula';
-    }
-    else if (model_1.AssignmentsRAst.has(operator.name)) {
-        flavor = 'assignment';
-    }
-    else if (operator.name === "PIPE" /* RawRType.Pipe */) {
-        flavor = 'pipe';
+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 */) {
+        return parseBinaryOp(data, lhs, operator, rhs);
     }
     else {
-        return (0, hooks_1.executeUnknownHook)(data.hooks.operators.onBinary.unknown, data, { lhs, operator, rhs });
+        return undefined;
     }
-    return parseBinaryOp(data, flavor, lhs, operator, rhs);
 }
 exports.tryNormalizeBinary = tryNormalizeBinary;
-function parseBinaryOp(data, flavor, lhs, operator, rhs) {
-    parser_1.parseLog.debug(`[binary op] trying to parse ${flavor}`);
-    ({ flavor, lhs, rhs, operator } = (0, hooks_1.executeHook)(data.hooks.operators.onBinary.before, data, { flavor, lhs, operator, rhs }));
-    (0, meta_1.ensureChildrenAreLhsAndRhsOrdered)(lhs.content, rhs.content);
-    let parsedLhs = (0, structure_1.tryNormalizeSingleNode)(data, lhs);
-    let parsedRhs = (0, structure_1.tryNormalizeSingleNode)(data, rhs);
+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 */) {
         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, meta_1.retrieveOpName)(operator);
-    // special support for strings in assignments
-    if (flavor === 'assignment') {
-        [parsedLhs, parsedRhs] = processLhsAndRhsForAssignment(operationName, parsedLhs, parsedRhs);
-    }
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(operator.content);
-    if (flavor === 'special') {
-        flavor = (0, special_1.identifySpecialOp)(content);
-    }
-    if (flavor === 'special') {
+    const operationName = (0, normalize_meta_1.retrieveOpName)(operator);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(operator.content);
+    if ((0, strings_1.startAndEndsWith)(operationName, '%')) {
         (0, assert_1.guard)(parsedLhs.location !== undefined && parsedLhs.lexeme !== undefined && parsedRhs.location !== undefined && parsedRhs.lexeme !== undefined, () => `special op lhs and rhs must have a locations and lexemes, but ${JSON.stringify(parsedLhs)} and ${JSON.stringify(parsedRhs)})`);
         // parse as infix function call!
-        const result = {
+        return {
             type: "RFunctionCall" /* RType.FunctionCall */,
             flavor: 'named',
             infixSpecial: true,
@@ -98,13 +69,11 @@ function parseBinaryOp(data, flavor, lhs, operator, rhs) {
             ],
             info: {}
         };
-        return (0, hooks_1.executeHook)(data.hooks.operators.onBinary.after, data, result);
     }
-    let result;
-    if (flavor === 'pipe') {
+    else if (operator.name === "PIPE" /* 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)})`);
-        result = {
+        return {
             type: "RPipe" /* RType.Pipe */,
             location,
             lhs: {
@@ -125,9 +94,8 @@ function parseBinaryOp(data, flavor, lhs, operator, rhs) {
         };
     }
     else {
-        result = {
+        return {
             type: "RBinaryOp" /* RType.BinaryOp */,
-            flavor,
             location,
             lhs: parsedLhs,
             rhs: parsedRhs,
@@ -140,23 +108,5 @@ function parseBinaryOp(data, flavor, lhs, operator, rhs) {
             }
         };
     }
-    return (0, hooks_1.executeHook)(data.hooks.operators.onBinary.after, data, result);
-}
-function processLhsAndRhsForAssignment(opName, parsedLhs, parsedRhs) {
-    const isRhs = opName === '->' || opName === '->>';
-    const assigned = isRhs ? parsedRhs : parsedLhs;
-    if (assigned.type !== "RString" /* RType.String */) {
-        return [parsedLhs, parsedRhs];
-    }
-    // update the assigned value to be parsed as a symbol
-    const result = {
-        type: "RSymbol" /* RType.Symbol */,
-        lexeme: assigned.lexeme,
-        location: assigned.location,
-        content: assigned.content.str,
-        namespace: undefined,
-        info: assigned.info
-    };
-    return isRhs ? [parsedLhs, result] : [result, parsedRhs];
 }
-//# sourceMappingURL=binary.js.map
+//# sourceMappingURL=normalize-binary.js.map

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

@@ -0,0 +1,13 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { NamedXmlBasedJson } from '../../input-format';
+import type { RNode } from '../../../../model/model';
+/**
+ * Parses the construct as a {@link RUnaryOp}.
+ *
+ * @param data     - The data used by the parser (see {@link NormalizerData})
+ * @param operator - The operator token
+ * @param operand  - The operand of the unary operator
+ *
+ * @returns The parsed {@link RUnaryOp} or `undefined` if the given construct is not a unary operator
+ */
+export declare function tryNormalizeUnary(data: NormalizerData, [operator, operand]: [NamedXmlBasedJson, NamedXmlBasedJson]): RNode | undefined;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeUnary = void 0;
+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");
+/**
+ * Parses the construct as a {@link RUnaryOp}.
+ *
+ * @param data     - The data used by the parser (see {@link NormalizerData})
+ * @param operator - The operator token
+ * @param operand  - The operand of the unary operator
+ *
+ * @returns The parsed {@link RUnaryOp} or `undefined` if the given construct is not a unary operator
+ */
+function tryNormalizeUnary(data, [operator, operand]) {
+    (0, log_1.expensiveTrace)(parser_1.parseLog, () => `unary op for ${operator.name} ${operand.name}`);
+    if (operators_1.UnaryOperatorsInRAst.has(operator.name)) {
+        return parseUnaryOp(data, operator, operand);
+    }
+    else {
+        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');
+    const operationName = (0, normalize_meta_1.retrieveOpName)(operator);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(operator.content);
+    return {
+        type: "RUnaryOp" /* RType.UnaryOp */,
+        location,
+        operator: operationName,
+        lexeme: content,
+        operand: parsedOperand,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+}
+//# sourceMappingURL=normalize-unary.js.map

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

@@ -0,0 +1,11 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { XmlBasedJson } from '../../input-format';
+import type { RComment } from '../../../../model/nodes/r-comment';
+/**
+ * Normalize the given object as an R comment.
+ * This requires you to check the corresponding name beforehand.
+ *
+ * @param data - The data used by the parser (see {@link NormalizerData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+export declare function normalizeComment(data: NormalizerData, obj: XmlBasedJson): RComment;

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

@@ -1,23 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeComment = void 0;
-const meta_1 = require("../meta");
+const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
-const hooks_1 = require("../../hooks");
-const parser_1 = require("../../../json/parser");
 /**
  * Normalize the given object as an R comment.
  * This requires you to check the corresponding name beforehand.
  *
- * @param data - The data used by the parser (see {@link ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @param obj  - The json object to extract the meta-information from
  */
 function normalizeComment(data, obj) {
-    parser_1.parseLog.debug('[comment]');
-    obj = (0, hooks_1.executeHook)(data.hooks.other.onComment.before, data, obj);
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(obj);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
     (0, assert_1.guard)(content.startsWith('#'), 'comment must start with #');
-    const result = {
+    return {
         type: "RComment" /* RType.Comment */,
         location,
         content: content.slice(1),
@@ -28,7 +24,6 @@ function normalizeComment(data, obj) {
             fullLexeme: content
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.other.onComment.after, data, result);
 }
 exports.normalizeComment = normalizeComment;
-//# sourceMappingURL=comment.js.map
+//# sourceMappingURL=normalize-comment.js.map

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

@@ -0,0 +1,13 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { XmlBasedJson } from '../../input-format';
+import type { RLineDirective } from '../../../../model/nodes/r-line-directive';
+import type { RComment } from '../../../../model/nodes/r-comment';
+/**
+ * Normalize the given object as an R line directive (`#line <number> "<file>"`).
+ * This requires you to check the corresponding name beforehand.
+ * If the given object turns out to be no line directive, this returns a normal comment instead.
+ *
+ * @param data - The data used by the parser (see {@link NormalizerData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+export declare function normalizeLineDirective(data: NormalizerData, obj: XmlBasedJson): RLineDirective | RComment;

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

@@ -1,29 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeLineDirective = void 0;
-const meta_1 = require("../meta");
-const assert_1 = require("../../../../../../../util/assert");
-const hooks_1 = require("../../hooks");
 const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-meta");
+const assert_1 = require("../../../../../../../util/assert");
 const LineDirectiveRegex = /^#line\s+(\d+)\s+"([^"]+)"\s*$/;
 /**
  * Normalize the given object as an R line directive (`#line <number> "<file>"`).
  * This requires you to check the corresponding name beforehand.
  * If the given object turns out to be no line directive, this returns a normal comment instead.
  *
- * @param data - The data used by the parser (see {@link ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @param obj  - The json object to extract the meta-information from
  */
 function normalizeLineDirective(data, obj) {
-    parser_1.parseLog.debug('[line-directive]');
-    obj = (0, hooks_1.executeHook)(data.hooks.other.onLineDirective.before, data, obj);
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(obj);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
     (0, assert_1.guard)(content.startsWith('#line'), 'line directive must start with #line');
     const match = LineDirectiveRegex.exec(content);
-    let result;
     if (match === null) {
         parser_1.parseLog.debug(`[line-directive] does not match the regex ${LineDirectiveRegex.source} given ${JSON.stringify(content)}`);
-        result = {
+        return {
             type: "RComment" /* RType.Comment */,
             location,
             lexeme: content,
@@ -36,7 +32,7 @@ function normalizeLineDirective(data, obj) {
         };
     }
     else {
-        result = {
+        return {
             type: "RLineDirective" /* RType.LineDirective */,
             location,
             line: parseInt(match[1]),
@@ -49,7 +45,6 @@ function normalizeLineDirective(data, obj) {
             }
         };
     }
-    return (0, hooks_1.executeHook)(data.hooks.other.onLineDirective.after, data, result);
 }
 exports.normalizeLineDirective = normalizeLineDirective;
-//# sourceMappingURL=line-directive.js.map
+//# sourceMappingURL=normalize-line-directive.js.map

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

@@ -0,0 +1,3 @@
+import type { NamedXmlBasedJson } from '../../input-format';
+import type { RDelimiter } from '../../../../model/nodes/info/r-delimiter';
+export declare function normalizeDelimiter(elem: NamedXmlBasedJson): RDelimiter;

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

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

package/r-bridge/lang-4.x/ast/parser/xml/internal/structure/normalize-expressions.d.ts

@@ -0,0 +1,10 @@
+import type { NamedXmlBasedJson, XmlBasedJson } from '../../input-format';
+import type { NormalizerData } from '../../normalizer-data';
+import type { RDelimiter } from '../../../../model/nodes/info/r-delimiter';
+import type { RNode } from '../../../../model/model';
+export declare function splitComments(tokens: readonly NamedXmlBasedJson[]): {
+    comments: NamedXmlBasedJson[];
+    others: NamedXmlBasedJson[];
+};
+export declare function normalizeExpressions(data: NormalizerData, tokens: readonly XmlBasedJson[] | readonly NamedXmlBasedJson[]): (RNode | RDelimiter)[];
+export declare function parseNodesWithUnknownType(data: NormalizerData, mappedWithName: readonly NamedXmlBasedJson[]): (RNode | RDelimiter)[];