@eagleoutice/flowr 2.1.1 → 2.1.3

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

@@ -16,7 +16,6 @@ const normalize_single_node_1 = require("../structure/normalize-single-node");
  * @returns The parsed argument or `undefined` if the given object is not an argument.
  */
 function tryToNormalizeArgument(data, objs) {
-    parser_1.parseLog.debug('[argument]');
     if (objs.length < 1 || objs.length > 3) {
         parser_1.parseLog.warn(`Either [expr|value], [SYMBOL_SUB, EQ_SUB], or [SYMBOL_SUB, EQ_SUB, expr], but got: ${objs.map(o => o.name).join(', ')}`);
         return undefined;
@@ -64,7 +63,8 @@ function tryToNormalizeArgument(data, objs) {
 }
 function parseWithValue(data, objs) {
     (0, assert_1.guard)(objs[1].name === type_1.RawRType.EqualSub, () => `[arg-default] second element of parameter must be ${type_1.RawRType.EqualFormals}, but: ${JSON.stringify(objs)}`);
-    (0, assert_1.guard)(objs.length === 2 || objs[2].name === type_1.RawRType.Expression, () => `[arg-default] third element of parameter must be an Expression or undefined (for 'x=') but: ${JSON.stringify(objs)}`);
-    return objs[2] ? (0, normalize_single_node_1.normalizeSingleNode)(data, objs[2]) : null;
+    const snd = objs[2];
+    (0, assert_1.guard)(objs.length === 2 || snd.name === type_1.RawRType.Expression, () => `[arg-default] third element of parameter must be an Expression or undefined (for 'x=') but: ${JSON.stringify(objs)}`);
+    return snd ? (0, normalize_single_node_1.normalizeSingleNode)(data, snd) : null;
 }
 //# sourceMappingURL=normalize-argument.js.map

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

@@ -1,15 +1,15 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RFunctionCall } from '../../../../model/nodes/r-function-call';
 import type { RNext } from '../../../../model/nodes/r-next';
 import type { RBreak } from '../../../../model/nodes/r-break';
+import type { NamedJsonEntry } from '../../../json/format';
 /**
  * Tries to parse the given data as a function call.
  *
  * @param data           - The data used by the parser (see {@link NormalizerData})
- * @param mappedWithName - The json object to extract the meta-information from
+ * @param mappedWithName - The JSON object to extract the meta-information from
  *
  * @returns The parsed {@link RFunctionCall} (either named or unnamed) or `undefined` if the given construct is not a function call
  * May return a {@link RNext} or {@link RBreak} as `next()` and `break()` work as such.
  */
-export declare function tryNormalizeFunctionCall(data: NormalizerData, mappedWithName: NamedXmlBasedJson[]): RFunctionCall | RNext | RBreak | undefined;
+export declare function tryNormalizeFunctionCall(data: NormalizerData, mappedWithName: readonly NamedJsonEntry[]): RFunctionCall | RNext | RBreak | undefined;

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeFunctionCall = tryNormalizeFunctionCall;
-const input_format_1 = require("../../input-format");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const arrays_1 = require("../../../../../../../util/arrays");
@@ -16,7 +15,7 @@ const normalize_symbol_1 = require("../values/normalize-symbol");
  * Tries to parse the given data as a function call.
  *
  * @param data           - The data used by the parser (see {@link NormalizerData})
- * @param mappedWithName - The json object to extract the meta-information from
+ * @param mappedWithName - The JSON object to extract the meta-information from
  *
  * @returns The parsed {@link RFunctionCall} (either named or unnamed) or `undefined` if the given construct is not a function call
  * May return a {@link RNext} or {@link RBreak} as `next()` and `break()` work as such.
@@ -31,9 +30,8 @@ function tryNormalizeFunctionCall(data, mappedWithName) {
         parser_1.parseLog.trace('expected function call to have parenthesis for a call, but was not');
         return undefined;
     }
-    parser_1.parseLog.trace('trying to parse function call');
-    const { unwrappedObj, content, location } = (0, normalize_meta_1.retrieveMetaStructure)(fnBase.content);
-    const symbolContent = (0, input_format_1.getKeyGuarded)(unwrappedObj, input_format_1.childrenKey);
+    const { content, location } = (0, normalize_meta_1.retrieveMetaStructure)(fnBase.content);
+    const symbolContent = fnBase.content.children;
     const namedSymbolContent = (0, normalize_meta_1.getWithTokenType)(symbolContent);
     if (namedSymbolContent.length === 1 && namedSymbolContent[0].name === type_1.RawRType.StringConst) {
         // special handling when someone calls a function by string
@@ -41,8 +39,7 @@ function tryNormalizeFunctionCall(data, mappedWithName) {
     }
     else if (namedSymbolContent.findIndex(x => x.name === type_1.RawRType.SymbolFunctionCall) < 0) {
         parser_1.parseLog.trace(`is not named function call, as the name is not of type ${type_1.RType.FunctionCall}, but: ${namedSymbolContent.map(n => n.name).join(',')}`);
-        const mayResult = tryParseUnnamedFunctionCall(data, mappedWithName, location, content);
-        return mayResult;
+        return tryParseUnnamedFunctionCall(data, mappedWithName, location, content);
     }
     else {
         return parseNamedFunctionCall(data, namedSymbolContent, mappedWithName, location, content);
@@ -68,7 +65,7 @@ function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
     const calledFunction = (0, normalize_expression_1.normalizeExpression)(data, mappedWithName[0].content);
     const parsedArguments = parseArguments(mappedWithName, data);
     if (parsedArguments.length === 0) {
-        // sadly, next() and break() work
+        // interestingly, next() and break() work
         if (calledFunction.type === type_1.RType.Next) {
             return {
                 type: type_1.RType.Next,
@@ -125,7 +122,7 @@ function parseNamedFunctionCall(data, symbolContent, mappedWithName, location, c
         functionName = (0, normalize_symbol_1.tryNormalizeSymbol)(data, symbolContent);
     }
     (0, assert_1.guard)(functionName !== undefined, 'expected function name to be a symbol, yet received none');
-    (0, assert_1.guard)((functionName).type === type_1.RType.Symbol, () => `expected function name to be a symbol, yet received ${JSON.stringify(functionName)}`);
+    (0, assert_1.guard)(functionName.type === type_1.RType.Symbol, () => `expected function name to be a symbol, yet received ${JSON.stringify(functionName)}`);
     const parsedArguments = parseArguments(mappedWithName, data);
     return {
         type: type_1.RType.FunctionCall,

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

@@ -1,12 +1,12 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RFunctionDefinition } from '../../../../model/nodes/r-function-definition';
+import type { NamedJsonEntry } from '../../../json/format';
 /**
  * Tries to parse the given data as a function definition.
  *
  * @param data - The data used by the parser (see {@link NormalizerData})
- * @param mappedWithName - The json object to extract the meta-information from
+ * @param mappedWithName - The JSON object to extract the meta-information from
  *
  * @returns The parsed {@link RFunctionDefinition} or `undefined` if the given construct is not a function definition
  */
-export declare function tryNormalizeFunctionDefinition(data: NormalizerData, mappedWithName: readonly NamedXmlBasedJson[]): RFunctionDefinition | undefined;
+export declare function tryNormalizeFunctionDefinition(data: NormalizerData, mappedWithName: readonly NamedJsonEntry[]): RFunctionDefinition | undefined;

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

@@ -12,7 +12,7 @@ const normalize_expressions_1 = require("../structure/normalize-expressions");
  * Tries to parse the given data as a function definition.
  *
  * @param data - The data used by the parser (see {@link NormalizerData})
- * @param mappedWithName - The json object to extract the meta-information from
+ * @param mappedWithName - The JSON object to extract the meta-information from
  *
  * @returns The parsed {@link RFunctionDefinition} or `undefined` if the given construct is not a function definition
  */
@@ -28,13 +28,11 @@ function tryNormalizeFunctionDefinition(data, mappedWithName) {
     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 === 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)) {
         parser_1.parseLog.error(`function had unexpected unknown parameters: ${JSON.stringify(parameters.filter(assert_1.isNotUndefined))}, aborting.`);
         return undefined;
     }
-    parser_1.parseLog.trace(`function definition retained ${parameters.length} parameters after parsing, moving to body.`);
     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);

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

@@ -1,6 +1,6 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RParameter } from '../../../../model/nodes/r-parameter';
+import type { NamedJsonEntry } from '../../../json/format';
 /**
  * Either parses `[SYMBOL_FORMALS]` or `[SYMBOL_FORMALS, EQ_FORMALS, expr]` as a parameter of a function definition in R.
  * Probably directly called by the function definition parser as otherwise, we do not expect to find parameters.
@@ -10,4 +10,4 @@ import type { RParameter } from '../../../../model/nodes/r-parameter';
  *
  * @returns The parsed parameter or `undefined` if the given object is not a parameter.
  */
-export declare function tryNormalizeParameter(data: NormalizerData, objs: readonly NamedXmlBasedJson[]): RParameter | undefined;
+export declare function tryNormalizeParameter(data: NormalizerData, objs: readonly NamedJsonEntry[]): RParameter | undefined;

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

@@ -16,7 +16,6 @@ const normalize_single_node_1 = require("../structure/normalize-single-node");
  * @returns The parsed parameter or `undefined` if the given object is not a parameter.
  */
 function tryNormalizeParameter(data, objs) {
-    parser_1.parseLog.debug('[parameter]');
     if (objs.length !== 1 && objs.length !== 3) {
         parser_1.parseLog.warn(`Either [SYMBOL_FORMALS] or [SYMBOL_FORMALS, EQ_FORMALS, expr], but got: ${JSON.stringify(objs)}`);
         return undefined;
@@ -28,6 +27,7 @@ function tryNormalizeParameter(data, objs) {
     }
     const defaultValue = objs.length === 3 ? parseWithDefaultValue(data, objs) : undefined;
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(symbol.content);
+    const delim = defaultValue?.type === type_1.RType.Delimiter;
     return {
         type: type_1.RType.Parameter,
         location,
@@ -44,17 +44,18 @@ function tryNormalizeParameter(data, objs) {
                 fullLexeme: content
             }
         },
-        defaultValue: defaultValue?.type === type_1.RType.Delimiter ? undefined : defaultValue,
+        defaultValue: delim ? undefined : defaultValue,
         info: {
             fullRange: location,
             fullLexeme: content,
-            additionalTokens: defaultValue?.type === type_1.RType.Delimiter ? [defaultValue] : []
+            additionalTokens: delim ? [defaultValue] : []
         }
     };
 }
 function parseWithDefaultValue(data, 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]);
+    const snd = objs[2];
+    (0, assert_1.guard)(snd.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, snd);
 }
 //# sourceMappingURL=normalize-parameter.js.map

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

@@ -1,4 +1,4 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { XmlBasedJson } from '../../input-format';
 import type { RBreak } from '../../../../model/nodes/r-break';
-export declare function normalizeBreak(data: NormalizerData, obj: XmlBasedJson): RBreak;
+import type { JsonEntry } from '../../../json/format';
+export declare function normalizeBreak(data: NormalizerData, obj: JsonEntry): RBreak;

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

@@ -1,4 +1,4 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RForLoop } from '../../../../model/nodes/r-for-loop';
-export declare function tryNormalizeFor(data: NormalizerData, [forToken, head, body]: [NamedXmlBasedJson, NamedXmlBasedJson, NamedXmlBasedJson]): RForLoop | undefined;
+import type { NamedJsonEntry } from '../../../json/format';
+export declare function tryNormalizeFor(data: NormalizerData, [forToken, head, body]: [NamedJsonEntry, NamedJsonEntry, NamedJsonEntry]): RForLoop | undefined;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeFor = tryNormalizeFor;
-const input_format_1 = require("../../input-format");
+const normalizer_data_1 = require("../../normalizer-data");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
@@ -17,19 +17,18 @@ function tryNormalizeFor(data, [forToken, head, body]) {
         return undefined;
     }
     else if (head.name !== type_1.RawRType.ForCondition) {
-        throw new input_format_1.XmlParseError(`expected condition for for-loop but found ${JSON.stringify(head)}`);
+        throw new normalizer_data_1.ParseError(`expected condition for for-loop but found ${JSON.stringify(head)}`);
     }
     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)}`);
+        throw new normalizer_data_1.ParseError(`expected expr body for for-loop but found ${JSON.stringify(body)}`);
     }
-    parser_1.parseLog.debug('trying to parse for-loop');
     const newParseData = { ...data, data, currentRange: undefined, currentLexeme: undefined };
     const { variable: parsedVariable, vector: parsedVector, comments } = normalizeForHead(newParseData, head.content);
     const parseBody = (0, normalize_single_node_1.normalizeSingleNode)(newParseData, body);
     if (parsedVariable === undefined ||
         parsedVector === undefined ||
         parseBody.type === type_1.RType.Delimiter) {
-        throw new input_format_1.XmlParseError(`unexpected under-sided for-loop, received ${JSON.stringify([
+        throw new normalizer_data_1.ParseError(`unexpected under-sided for-loop, received ${JSON.stringify([
             parsedVariable,
             parsedVariable,
             parseBody,
@@ -52,7 +51,7 @@ function tryNormalizeFor(data, [forToken, head, body]) {
 }
 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 children = (0, normalize_meta_1.getWithTokenType)(forCondition.children);
     const { comments, others } = (0, normalize_expressions_1.splitComments)(children);
     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)}`);

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

@@ -1,4 +1,4 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { XmlBasedJson } from '../../input-format';
 import type { RNext } from '../../../../model/nodes/r-next';
-export declare function normalizeNext(data: NormalizerData, obj: XmlBasedJson): RNext;
+import type { JsonEntry } from '../../../json/format';
+export declare function normalizeNext(data: NormalizerData, obj: JsonEntry): RNext;

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

@@ -1,6 +1,6 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RRepeatLoop } from '../../../../model/nodes/r-repeat-loop';
+import type { NamedJsonEntry } from '../../../json/format';
 /**
  * Try to parse the construct as a {@link RRepeatLoop}.
  *
@@ -10,4 +10,4 @@ import type { RRepeatLoop } from '../../../../model/nodes/r-repeat-loop';
  *
  * @returns The parsed {@link RRepeatLoop} or `undefined` if the given construct is not a repeat-loop
  */
-export declare function tryNormalizeRepeat(data: NormalizerData, [repeatToken, bodyToken]: [NamedXmlBasedJson, NamedXmlBasedJson]): RRepeatLoop | undefined;
+export declare function tryNormalizeRepeat(data: NormalizerData, [repeatToken, bodyToken]: [NamedJsonEntry, NamedJsonEntry]): RRepeatLoop | undefined;

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

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

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeWhile = tryNormalizeWhile;
-const input_format_1 = require("../../input-format");
+const normalizer_data_1 = require("../../normalizer-data");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const type_1 = require("../../../../model/type");
@@ -12,16 +12,16 @@ function tryNormalizeWhile(data, [whileToken, leftParen, condition, rightParen,
         return undefined;
     }
     else if (leftParen.name !== type_1.RawRType.ParenLeft) {
-        throw new input_format_1.XmlParseError(`expected left-parenthesis for while but found ${JSON.stringify(leftParen)}`);
+        throw new normalizer_data_1.ParseError(`expected left-parenthesis for while but found ${JSON.stringify(leftParen)}`);
     }
     else if (rightParen.name !== type_1.RawRType.ParenRight) {
-        throw new input_format_1.XmlParseError(`expected right-parenthesis for while but found ${JSON.stringify(rightParen)}`);
+        throw new normalizer_data_1.ParseError(`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 === type_1.RType.Delimiter || parseBody.type === type_1.RType.Delimiter) {
-        throw new input_format_1.XmlParseError(`unexpected under-sided while-loop, received ${JSON.stringify([
+        throw new normalizer_data_1.ParseError(`unexpected under-sided while-loop, received ${JSON.stringify([
             parsedCondition,
             parseBody,
         ])} for ${JSON.stringify([whileToken, condition, body])}`);

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

@@ -1,12 +1,12 @@
-import type { NamedXmlBasedJson } from '../input-format';
 import type { NormalizerData } from '../normalizer-data';
 import type { RAccess } from '../../../model/nodes/r-access';
+import type { NamedJsonEntry } from '../../json/format';
 /**
  * Tries to normalize the given data as access (e.g., indexing).
  *
  * @param data           - The data used by the parser (see {@link NormalizerData})
- * @param mappedWithName - The json object to extract the meta-information from
+ * @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: NormalizerData, mappedWithName: NamedXmlBasedJson[]): RAccess | undefined;
+export declare function tryNormalizeAccess(data: NormalizerData, mappedWithName: NamedJsonEntry[]): RAccess | undefined;

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

@@ -40,12 +40,11 @@ function normalizeAbstractArgument(x, data, operator) {
  * Tries to normalize the given data as access (e.g., indexing).
  *
  * @param data           - The data used by the parser (see {@link NormalizerData})
- * @param mappedWithName - The json object to extract the meta-information from
+ * @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');
     if (mappedWithName.length < 3) {
         parser_1.parseLog.trace('expected at least three elements are required to parse an access');
         return undefined;

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

@@ -1,8 +1,8 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RNode } from '../../../../model/model';
+import type { NamedJsonEntry } from '../../../json/format';
 /**
  * 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: NormalizerData, [lhs, operator, rhs]: [NamedXmlBasedJson, NamedXmlBasedJson, NamedXmlBasedJson]): RNode | undefined;
+export declare function tryNormalizeBinary(data: NormalizerData, [lhs, operator, rhs]: [NamedJsonEntry, NamedJsonEntry, NamedJsonEntry]): RNode | undefined;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeBinary = tryNormalizeBinary;
-const input_format_1 = require("../../input-format");
+const normalizer_data_1 = require("../../normalizer-data");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
@@ -28,7 +28,7 @@ function parseBinaryOp(data, lhs, operator, rhs) {
     const parsedLhs = (0, normalize_single_node_1.normalizeSingleNode)(data, lhs);
     const parsedRhs = (0, normalize_single_node_1.normalizeSingleNode)(data, rhs);
     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])}`);
+        throw new normalizer_data_1.ParseError(`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);

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

@@ -1,6 +1,6 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RNode } from '../../../../model/model';
+import type { NamedJsonEntry } from '../../../json/format';
 /**
  * Parses the construct as a {@link RUnaryOp}.
  *
@@ -10,4 +10,4 @@ import type { RNode } from '../../../../model/model';
  *
  * @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;
+export declare function tryNormalizeUnary(data: NormalizerData, [operator, operand]: [NamedJsonEntry, NamedJsonEntry]): RNode | undefined;

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

@@ -1,11 +1,11 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { XmlBasedJson } from '../../input-format';
 import type { RComment } from '../../../../model/nodes/r-comment';
+import type { JsonEntry } from '../../../json/format';
 /**
  * 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
+ * @param obj  - The JSON object to extract the meta-information from
  */
-export declare function normalizeComment(data: NormalizerData, obj: XmlBasedJson): RComment;
+export declare function normalizeComment(data: NormalizerData, obj: JsonEntry): RComment;

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

@@ -9,7 +9,7 @@ const type_1 = require("../../../../model/type");
  * 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
+ * @param obj  - The JSON object to extract the meta-information from
  */
 function normalizeComment(data, obj) {
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);

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

@@ -1,13 +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';
+import type { JsonEntry } from '../../../json/format';
 /**
  * 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
+ * @param obj  - The JSON object to extract the meta-information from
  */
-export declare function normalizeLineDirective(data: NormalizerData, obj: XmlBasedJson): RLineDirective | RComment;
+export declare function normalizeLineDirective(data: NormalizerData, obj: JsonEntry): RLineDirective | RComment;

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

@@ -12,7 +12,7 @@ const LineDirectiveRegex = /^#line\s+(\d+)\s+"([^"]+)"\s*$/;
  * 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
+ * @param obj  - The JSON object to extract the meta-information from
  */
 function normalizeLineDirective(data, obj) {
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);

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

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

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

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

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

@@ -1,4 +1,4 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { XmlBasedJson } from '../../input-format';
 import type { RExpressionList } from '../../../../model/nodes/r-expression-list';
-export declare function normalizeRootObjToAst(data: NormalizerData, obj: XmlBasedJson): RExpressionList;
+import type { JsonEntry } from '../../../json/format';
+export declare function normalizeRootObjToAst(data: NormalizerData, obj: JsonEntry): RExpressionList;

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

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeRootObjToAst = normalizeRootObjToAst;
-const input_format_1 = require("../../input-format");
 const normalize_meta_1 = require("../../normalize-meta");
 const normalize_expressions_1 = require("./normalize-expressions");
 const log_1 = require("../../../../../../../util/log");
 const arrays_1 = require("../../../../../../../util/arrays");
 const type_1 = require("../../../../model/type");
 function normalizeRootObjToAst(data, obj) {
-    const exprContent = (0, input_format_1.getKeyGuarded)(obj, type_1.RawRType.ExpressionList);
+    const exprContent = obj.token;
     (0, normalize_meta_1.assureTokenType)(exprContent, type_1.RawRType.ExpressionList);
     let parsedChildren = [];
-    if (input_format_1.childrenKey in exprContent) {
-        const children = (0, input_format_1.getKeyGuarded)(exprContent, input_format_1.childrenKey);
+    if (obj.children.length > 0) {
+        const children = obj.children;
         parsedChildren = (0, normalize_expressions_1.normalizeExpressions)(data, children);
     }
     else {

package/r-bridge/lang-4.x/ast/parser/{xml → main}/internal/structure/normalize-single-node.d.ts

@@ -1,7 +1,7 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RNode } from '../../../../model/model';
 import type { RDelimiter } from '../../../../model/nodes/info/r-delimiter';
+import type { NamedJsonEntry } from '../../../json/format';
 /**
  * Parses a single structure in the ast based on its type (e.g., a string, a number, a symbol, ...)
  *
@@ -10,4 +10,4 @@ import type { RDelimiter } from '../../../../model/nodes/info/r-delimiter';
  *
  * @returns The parsed element as an `RNode` or an `RDelimiter` if it is such.
  */
-export declare function normalizeSingleNode(data: NormalizerData, elem: NamedXmlBasedJson): RNode | RDelimiter;
+export declare function normalizeSingleNode(data: NormalizerData, elem: NamedJsonEntry): RNode | RDelimiter;

package/r-bridge/lang-4.x/ast/parser/{xml → main}/internal/structure/normalize-single-node.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeSingleNode = normalizeSingleNode;
 const normalize_meta_1 = require("../../normalize-meta");
-const input_format_1 = require("../../input-format");
+const normalizer_data_1 = require("../../normalizer-data");
 const normalize_line_directive_1 = require("../other/normalize-line-directive");
 const assert_1 = require("../../../../../../../util/assert");
 const normalize_delimiter_1 = require("./normalize-delimiter");
@@ -54,7 +54,7 @@ function normalizeSingleNode(data, elem) {
             return symbol;
         }
         default:
-            throw new input_format_1.XmlParseError(`unknown type ${elem.name} for ${JSON.stringify(elem)} in ${JSON.stringify(data)}`);
+            throw new normalizer_data_1.ParseError(`unknown type ${elem.name} for ${JSON.stringify(elem)} in ${JSON.stringify(data)}`);
     }
 }
 //# sourceMappingURL=normalize-single-node.js.map

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

@@ -1,16 +1,16 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { XmlBasedJson } from '../../input-format';
 import type { RNa } from '../../../../../convert-values';
 import type { RNumber } from '../../../../model/nodes/r-number';
 import type { RLogical } from '../../../../model/nodes/r-logical';
 import type { RSymbol } from '../../../../model/nodes/r-symbol';
 import type { NoInfo } from '../../../../model/model';
+import type { JsonEntry } from '../../../json/format';
 /**
  * Normalize the given object as a R number (see {@link number2ts}), supporting booleans (see {@link boolean2ts}),
  * and special values.
  * 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
+ * @param obj  - The JSON object to extract the meta-information from
  */
-export declare function normalizeNumber(data: NormalizerData, obj: XmlBasedJson): RNumber | RLogical | RSymbol<NoInfo, typeof RNa>;
+export declare function normalizeNumber(data: NormalizerData, obj: JsonEntry): RNumber | RLogical | RSymbol<NoInfo, typeof RNa>;

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

@@ -10,7 +10,7 @@ const type_1 = require("../../../../model/type");
  * 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
+ * @param obj  - The JSON object to extract the meta-information from
  */
 function normalizeNumber(data, obj) {
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);

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

@@ -1,11 +1,11 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { XmlBasedJson } from '../../input-format';
 import type { RString } from '../../../../model/nodes/r-string';
+import type { JsonEntry } from '../../../json/format';
 /**
  * Normalize the given object as a R string (see {@link string2ts}).
  * 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
+ * @param obj  - The JSON object to extract the meta-information from
  */
-export declare function normalizeString(data: NormalizerData, obj: XmlBasedJson): RString;
+export declare function normalizeString(data: NormalizerData, obj: JsonEntry): RString;

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

@@ -10,7 +10,7 @@ const type_1 = require("../../../../model/type");
  * 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
+ * @param obj  - The JSON object to extract the meta-information from
  */
 function normalizeString(data, obj) {
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);

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

@@ -1,14 +1,14 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RSymbol } from '../../../../model/nodes/r-symbol';
+import type { NamedJsonEntry } from '../../../json/format';
 /**
  * Normalize the given object as an R symbol (incorporating namespace information).
  * <p>
  * The special symbols `T` and `F` are parsed as logic values.
  *
  * @param data - The data used by the parser (see {@link NormalizerData})
- * @param objs - The json object to extract the meta-information from
+ * @param objs - The JSON object to extract the meta-information from
  *
  * @returns The parsed symbol (with populated namespace information) or `undefined` if the given object is not a symbol.
  */
-export declare function tryNormalizeSymbol(data: NormalizerData, objs: readonly NamedXmlBasedJson[]): RSymbol | undefined;
+export declare function tryNormalizeSymbol(data: NormalizerData, objs: readonly NamedJsonEntry[]): RSymbol | undefined;