@eagleoutice/flowr 1.5.2 → 2.0.1

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

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNodesWithUnknownType = exports.normalizeExpressions = exports.splitComments = void 0;
+const normalize_single_node_1 = require("./normalize-single-node");
+const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-meta");
+const log_1 = require("../../../../../../../util/log");
+const assert_1 = require("../../../../../../../util/assert");
+const json_1 = require("../../../../../../../util/json");
+const normalize_unary_1 = require("../operators/normalize-unary");
+const normalize_repeat_1 = require("../loops/normalize-repeat");
+const normalize_binary_1 = require("../operators/normalize-binary");
+const normalize_for_1 = require("../loops/normalize-for");
+const normalize_symbol_1 = require("../values/normalize-symbol");
+const normalize_if_then_1 = require("../control/normalize-if-then");
+const normalize_while_1 = require("../loops/normalize-while");
+const normalize_if_then_else_1 = require("../control/normalize-if-then-else");
+const normalize_comment_1 = require("../other/normalize-comment");
+function normalizeMappedWithoutSemicolonBasedOnType(mappedWithName, data) {
+    let result = undefined;
+    switch (mappedWithName.length) {
+        case 1:
+            result = (0, normalize_single_node_1.normalizeSingleNode)(data, mappedWithName[0]);
+            break;
+        case 2:
+            result = (0, normalize_unary_1.tryNormalizeUnary)(data, mappedWithName)
+                ?? (0, normalize_repeat_1.tryNormalizeRepeat)(data, mappedWithName);
+            break;
+        case 3:
+            result = (0, normalize_binary_1.tryNormalizeBinary)(data, mappedWithName)
+                ?? (0, normalize_for_1.tryNormalizeFor)(data, mappedWithName)
+                ?? (0, normalize_symbol_1.tryNormalizeSymbol)(data, mappedWithName);
+            break;
+        case 5:
+            result = (0, normalize_if_then_1.tryNormalizeIfThen)(data, mappedWithName)
+                ?? (0, normalize_while_1.tryNormalizeWhile)(data, mappedWithName);
+            break;
+        case 7:
+            result = (0, normalize_if_then_else_1.tryNormalizeIfThenElse)(data, mappedWithName);
+            break;
+    }
+    // otherwise perform default parsing
+    return result !== undefined ? [result] : parseNodesWithUnknownType(data, mappedWithName);
+}
+function splitComments(tokens) {
+    const comments = [];
+    const others = [];
+    for (const elem of tokens) {
+        if (elem.name === "COMMENT" /* RawRType.Comment */) {
+            comments.push(elem);
+        }
+        else {
+            others.push(elem);
+        }
+    }
+    return { comments, others };
+}
+exports.splitComments = splitComments;
+function splitExprs(tokens) {
+    let last = 0, i = 0;
+    let lastExpr = false;
+    const segments = [];
+    for (const token of tokens) {
+        if (token.name === ";" /* RawRType.Semicolon */) {
+            segments.push(tokens.slice(last, i));
+            lastExpr = false;
+            last = i + 1;
+        }
+        else {
+            const thisExpr = token.name === "expr" /* RawRType.Expression */ || token.name === "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */;
+            if (thisExpr && lastExpr) {
+                if (i > last) {
+                    segments.push(tokens.slice(last, i));
+                }
+                segments.push([tokens[i]]);
+                last = i + 1;
+            }
+            lastExpr = thisExpr;
+        }
+        i++;
+    }
+    if (last < tokens.length) {
+        segments.push(tokens.slice(last, tokens.length));
+    }
+    return segments;
+}
+/**
+ * Handles semicolons within _and_ braces at the start and end of the expression
+ * @param raw - The tokens to split
+ */
+function handleExpressionList(raw) {
+    if (raw.length === 0) {
+        return { segments: [], comments: [], braces: undefined };
+    }
+    const { comments, others: tokens } = splitComments(raw);
+    const first = tokens[0].name;
+    if (first === "{" /* RawRType.BraceLeft */) {
+        const endType = tokens[tokens.length - 1].name;
+        (0, assert_1.guard)(endType === "}" /* RawRType.BraceRight */, () => `expected a brace at the end of the expression list as well, but ${endType} :: ${JSON.stringify(tokens[tokens.length - 1], json_1.jsonReplacer)}`);
+        return {
+            segments: [tokens.slice(1, tokens.length - 1)],
+            comments,
+            braces: [tokens[0], tokens[tokens.length - 1]]
+        };
+    }
+    else if (first === "(" /* RawRType.ParenLeft */) {
+        const endType = tokens[tokens.length - 1].name;
+        (0, assert_1.guard)(endType === ")" /* RawRType.ParenRight */, () => `expected a parenthesis at the end of the expression list as well, but ${endType} :: ${JSON.stringify(tokens[tokens.length - 1], json_1.jsonReplacer)}`);
+        return {
+            segments: [tokens.slice(1, tokens.length - 1)],
+            comments,
+            braces: [tokens[0], tokens[tokens.length - 1]]
+        };
+    }
+    else {
+        return { segments: splitExprs(tokens), comments, braces: undefined };
+    }
+}
+function processBraces([start, end], processed, comments, data) {
+    const [newStart, newEnd] = [(0, normalize_symbol_1.tryNormalizeSymbol)(data, [start]), (0, normalize_symbol_1.tryNormalizeSymbol)(data, [end])];
+    (0, assert_1.guard)(newStart !== undefined && newEnd !== undefined, () => `expected both start and end to be symbols, but ${JSON.stringify(start, json_1.jsonReplacer)} :: ${JSON.stringify(end, json_1.jsonReplacer)}`);
+    return {
+        type: "RExpressionList" /* RType.ExpressionList */,
+        children: processed,
+        grouping: [newStart, newEnd],
+        lexeme: undefined,
+        location: undefined,
+        info: {
+            additionalTokens: comments,
+        }
+    };
+}
+function normalizeExpressions(data, tokens) {
+    if (tokens.length === 0) {
+        parser_1.parseLog.warn('no children received, skipping');
+        return [];
+    }
+    let mappedWithName = tokens[0].name ? tokens : (0, normalize_meta_1.getWithTokenType)(tokens);
+    (0, log_1.expensiveTrace)(log_1.log, () => `[parseBasedOnType] names: [${mappedWithName.map(({ name }) => name).join(', ')}]`);
+    let parsedComments = [];
+    if (mappedWithName.length > 1) {
+        // iterate over types, find all semicolons, and segment the tokens based on them.
+        // we could potentially optimize as not all expr may have semicolons but not for now
+        const { segments, braces, comments } = handleExpressionList(mappedWithName);
+        parsedComments = comments.map(c => (0, normalize_comment_1.normalizeComment)(data, c.content));
+        if (segments.length > 1 || braces) {
+            const processed = segments.flatMap(s => normalizeExpressions(data, s));
+            (0, assert_1.guard)(!processed.some(x => x.type === "RDelimiter" /* RType.Delimiter */), () => `expected no delimiter tokens in ${JSON.stringify(processed)}`);
+            if (braces) {
+                return [processBraces(braces, processed, parsedComments, data)];
+            }
+            else if (processed.length > 0) {
+                if (parsedComments) {
+                    processed[0].info.additionalTokens ??= [];
+                    processed[0].info.additionalTokens.push(...parsedComments);
+                }
+                return processed;
+            }
+            else {
+                return parsedComments;
+            }
+        }
+        /*
+         * if splitOnSemicolon.length === 1, we can continue with the normal parsing, but we may have had a trailing semicolon, with this, it is removed as well.
+         * splitOnSemicolon.length === 0 is not possible, as we would have had an empty array before, split does not add elements.
+         */
+        mappedWithName = segments[0];
+    }
+    return [...parsedComments, ...normalizeMappedWithoutSemicolonBasedOnType(mappedWithName, data)];
+}
+exports.normalizeExpressions = normalizeExpressions;
+function parseNodesWithUnknownType(data, mappedWithName) {
+    const parsedNodes = [];
+    // used to indicate the new root node of this set of nodes
+    for (const elem of mappedWithName) {
+        const retrieved = (0, normalize_single_node_1.normalizeSingleNode)(data, elem);
+        parsedNodes.push(retrieved);
+    }
+    return parsedNodes;
+}
+exports.parseNodesWithUnknownType = parseNodesWithUnknownType;
+//# sourceMappingURL=normalize-expressions.js.map

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

@@ -0,0 +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;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRootObjToAst = void 0;
+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");
+function normalizeRootObjToAst(data, obj) {
+    const exprContent = (0, input_format_1.getKeyGuarded)(obj, "exprlist" /* RawRType.ExpressionList */);
+    (0, normalize_meta_1.assureTokenType)(exprContent, "exprlist" /* RawRType.ExpressionList */);
+    let parsedChildren = [];
+    if (input_format_1.childrenKey in exprContent) {
+        const children = (0, input_format_1.getKeyGuarded)(exprContent, input_format_1.childrenKey);
+        parsedChildren = (0, normalize_expressions_1.normalizeExpressions)(data, children);
+    }
+    else {
+        log_1.log.debug('no children found, assume empty input');
+    }
+    const [delimiters, nodes] = (0, arrays_1.partition)(parsedChildren, x => x.type === "RDelimiter" /* RType.Delimiter */ || x.type === "RComment" /* RType.Comment */);
+    return {
+        type: "RExpressionList" /* RType.ExpressionList */,
+        children: nodes,
+        grouping: undefined,
+        lexeme: undefined,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: delimiters,
+            fullLexeme: data.currentLexeme
+        }
+    };
+}
+exports.normalizeRootObjToAst = normalizeRootObjToAst;
+//# sourceMappingURL=normalize-root.js.map

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

@@ -0,0 +1,13 @@
+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';
+/**
+ * Parses a single structure in the ast based on its type (e.g., a string, a number, a symbol, ...)
+ *
+ * @param data - The data used by the parser (see {@link NormalizerData})
+ * @param elem - The element to parse
+ *
+ * @returns The parsed element as an `RNode` or an `RDelimiter` if it is such.
+ */
+export declare function normalizeSingleNode(data: NormalizerData, elem: NamedXmlBasedJson): RNode | RDelimiter;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSingleNode = void 0;
+const normalize_meta_1 = require("../../normalize-meta");
+const input_format_1 = require("../../input-format");
+const normalize_line_directive_1 = require("../other/normalize-line-directive");
+const assert_1 = require("../../../../../../../util/assert");
+const normalize_delimiter_1 = require("./normalize-delimiter");
+const normalize_comment_1 = require("../other/normalize-comment");
+const normalize_expression_1 = require("../expression/normalize-expression");
+const normalize_number_1 = require("../values/normalize-number");
+const normalize_string_1 = require("../values/normalize-string");
+const normalize_break_1 = require("../loops/normalize-break");
+const normalize_next_1 = require("../loops/normalize-next");
+const normalize_symbol_1 = require("../values/normalize-symbol");
+/**
+ * Parses a single structure in the ast based on its type (e.g., a string, a number, a symbol, ...)
+ *
+ * @param data - The data used by the parser (see {@link NormalizerData})
+ * @param elem - The element to parse
+ *
+ * @returns The parsed element as an `RNode` or an `RDelimiter` if it is such.
+ */
+function normalizeSingleNode(data, elem) {
+    switch (elem.name) {
+        case "(" /* RawRType.ParenLeft */:
+        case ")" /* RawRType.ParenRight */:
+        case "{" /* RawRType.BraceLeft */:
+        case "}" /* RawRType.BraceRight */:
+            return (0, normalize_delimiter_1.normalizeDelimiter)(elem);
+        case "COMMENT" /* RawRType.Comment */:
+            return (0, normalize_comment_1.normalizeComment)(data, elem.content);
+        case "LINE_DIRECTIVE" /* RawRType.LineDirective */:
+            return (0, normalize_line_directive_1.normalizeLineDirective)(data, elem.content);
+        case "exprlist" /* RawRType.ExpressionList */:
+        case "expr" /* RawRType.Expression */:
+        case "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */:
+            return (0, normalize_expression_1.normalizeExpression)(data, elem.content);
+        case "NUM_CONST" /* RawRType.NumericConst */:
+            return (0, normalize_number_1.normalizeNumber)(data, elem.content);
+        case "STR_CONST" /* RawRType.StringConst */:
+            return (0, normalize_string_1.normalizeString)(data, elem.content);
+        case "BREAK" /* RawRType.Break */:
+            return (0, normalize_break_1.normalizeBreak)(data, elem.content);
+        case "NEXT" /* RawRType.Next */:
+            return (0, normalize_next_1.normalizeNext)(data, elem.content);
+        case "SYMBOL" /* RawRType.Symbol */:
+        case "SLOT" /* RawRType.Slot */:
+        case "NULL_CONST" /* RawRType.NullConst */: {
+            const symbol = (0, normalize_symbol_1.tryNormalizeSymbol)(data, (0, normalize_meta_1.getWithTokenType)([elem.content]));
+            (0, assert_1.guard)(symbol !== undefined, () => `should have been parsed to a symbol but was ${JSON.stringify(symbol)}`);
+            return symbol;
+        }
+        default:
+            throw new input_format_1.XmlParseError(`unknown type ${elem.name} for ${JSON.stringify(elem)} in ${JSON.stringify(data)}`);
+    }
+}
+exports.normalizeSingleNode = normalizeSingleNode;
+//# sourceMappingURL=normalize-single-node.js.map

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

@@ -0,0 +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';
+/**
+ * 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
+ */
+export declare function normalizeNumber(data: NormalizerData, obj: XmlBasedJson): RNumber | RLogical | RSymbol<NoInfo, typeof RNa>;

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

@@ -1,22 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeNumber = void 0;
-const values_1 = require("../../../../../values");
-const meta_1 = require("../meta");
-const hooks_1 = require("../../hooks");
-const parser_1 = require("../../../json/parser");
+const convert_values_1 = require("../../../../../convert-values");
+const normalize_meta_1 = require("../../normalize-meta");
 /**
  * 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 ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @param obj  - The json object to extract the meta-information from
  */
 function normalizeNumber(data, obj) {
-    parser_1.parseLog.debug('[number]');
-    obj = (0, hooks_1.executeHook)(data.hooks.values.onNumber.before, data, obj);
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(obj);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
     const common = {
         location,
         lexeme: content,
@@ -26,31 +22,29 @@ function normalizeNumber(data, obj) {
             fullLexeme: data.currentLexeme
         }
     };
-    let result;
     /* the special symbol */
-    if ((0, values_1.isNA)(content)) {
-        result = {
+    if ((0, convert_values_1.isNA)(content)) {
+        return {
             ...common,
             namespace: undefined,
             type: "RSymbol" /* RType.Symbol */,
             content
         };
     }
-    else if ((0, values_1.isBoolean)(content)) {
-        result = {
+    else if ((0, convert_values_1.isBoolean)(content)) {
+        return {
             ...common,
             type: "RLogical" /* RType.Logical */,
-            content: (0, values_1.boolean2ts)(content)
+            content: (0, convert_values_1.boolean2ts)(content)
         };
     }
     else {
-        result = {
+        return {
             ...common,
             type: "RNumber" /* RType.Number */,
-            content: (0, values_1.number2ts)(content)
+            content: (0, convert_values_1.number2ts)(content)
         };
     }
-    return (0, hooks_1.executeHook)(data.hooks.values.onNumber.after, data, result);
 }
 exports.normalizeNumber = normalizeNumber;
-//# sourceMappingURL=number.js.map
+//# sourceMappingURL=normalize-number.js.map

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

@@ -0,0 +1,11 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { XmlBasedJson } from '../../input-format';
+import type { RString } from '../../../../model/nodes/r-string';
+/**
+ * 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
+ */
+export declare function normalizeString(data: NormalizerData, obj: XmlBasedJson): RString;

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

@@ -1,22 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeString = void 0;
-const meta_1 = require("../meta");
-const values_1 = require("../../../../../values");
-const hooks_1 = require("../../hooks");
+const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
-const parser_1 = require("../../../json/parser");
+const convert_values_1 = require("../../../../../convert-values");
 /**
  * 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 ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @param obj  - The json object to extract the meta-information from
  */
 function normalizeString(data, obj) {
-    parser_1.parseLog.debug('[string]');
-    obj = (0, hooks_1.executeHook)(data.hooks.values.onString.before, data, obj);
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(obj);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
     // based on https://www.rdocumentation.org/packages/utils/versions/3.6.2/topics/getParseData we do not get strings with 1000 characters or more within the text field.
     // therefore, we recover the full string from the surrounding expr lexeme field
     let stringContent = content;
@@ -24,10 +20,10 @@ function normalizeString(data, obj) {
         (0, assert_1.guard)(data.currentLexeme !== undefined, 'need current lexeme wrapper for too long strings as they are not stored by the R parser post-processor');
         stringContent = data.currentLexeme;
     }
-    const result = {
+    return {
         type: "RString" /* RType.String */,
         location,
-        content: (0, values_1.string2ts)(stringContent),
+        content: (0, convert_values_1.string2ts)(stringContent),
         lexeme: stringContent,
         info: {
             fullRange: data.currentRange,
@@ -35,7 +31,6 @@ function normalizeString(data, obj) {
             fullLexeme: data.currentLexeme
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.values.onString.after, data, result);
 }
 exports.normalizeString = normalizeString;
-//# sourceMappingURL=string.js.map
+//# sourceMappingURL=normalize-string.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/values/{symbol.d.ts → 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';
-import type { ParserData } from '../../data';
+import type { RSymbol } from '../../../../model/nodes/r-symbol';
 /**
  * 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 ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @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: ParserData, objs: NamedXmlBasedJson[]): RSymbol | undefined;
+export declare function tryNormalizeSymbol(data: NormalizerData, objs: readonly NamedXmlBasedJson[]): RSymbol | undefined;

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

@@ -2,17 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeSymbol = void 0;
 const assert_1 = require("../../../../../../../util/assert");
-const meta_1 = require("../meta");
-const model_1 = require("../../../../model");
-const hooks_1 = require("../../hooks");
-const strings_1 = require("../../../../../../../util/strings");
 const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-meta");
+const strings_1 = require("../../../../../../../util/strings");
+const type_1 = require("../../../../model/type");
 /**
  * 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 ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @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.
@@ -20,24 +19,23 @@ const parser_1 = require("../../../json/parser");
 function tryNormalizeSymbol(data, objs) {
     (0, assert_1.guard)(objs.length > 0, 'to parse symbols we need at least one object to work on!');
     parser_1.parseLog.debug('trying to parse symbol');
-    objs = (0, hooks_1.executeHook)(data.hooks.values.onSymbol.before, data, objs);
     let location, content, namespace;
-    if (objs.length === 1 && (0, model_1.isSymbol)(objs[0].name)) {
-        const meta = (0, meta_1.retrieveMetaStructure)(objs[0].content);
+    if (objs.length === 1 && (0, type_1.isSymbol)(objs[0].name)) {
+        const meta = (0, normalize_meta_1.retrieveMetaStructure)(objs[0].content);
         location = meta.location;
         content = meta.content;
         namespace = undefined;
     }
-    else if (objs.length === 3 && (0, model_1.isSymbol)(objs[2].name)) {
-        const meta = (0, meta_1.retrieveMetaStructure)(objs[2].content);
+    else if (objs.length === 3 && (0, type_1.isSymbol)(objs[2].name)) {
+        const meta = (0, normalize_meta_1.retrieveMetaStructure)(objs[2].content);
         location = meta.location;
         content = meta.content;
-        namespace = (0, meta_1.retrieveMetaStructure)(objs[0].content).content;
+        namespace = (0, normalize_meta_1.retrieveMetaStructure)(objs[0].content).content;
     }
     else {
-        return (0, hooks_1.executeUnknownHook)(data.hooks.values.onSymbol.unknown, data, objs);
+        return undefined;
     }
-    const result = {
+    return {
         type: "RSymbol" /* RType.Symbol */,
         namespace,
         location,
@@ -50,7 +48,6 @@ function tryNormalizeSymbol(data, objs) {
             fullLexeme: data.currentLexeme
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.values.onSymbol.after, data, result);
 }
 exports.tryNormalizeSymbol = tryNormalizeSymbol;
-//# sourceMappingURL=symbol.js.map
+//# sourceMappingURL=normalize-symbol.js.map

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

@@ -1,6 +1,8 @@
-import type { NamedXmlBasedJson, XmlBasedJson } from '../input-format';
-import type { SourceRange } from '../../../../../../util/range';
-import type { RawRType, RExpressionList, RNode } from '../../../model';
+import type { SourceRange } from '../../../../../util/range';
+import type { NamedXmlBasedJson, XmlBasedJson } from './input-format';
+import type { RawRType } from '../../model/type';
+import type { RExpressionList } from '../../model/nodes/r-expression-list';
+import type { RNode } from '../../model/model';
 /**
  * if the passed object is an array with only one element, remove the array wrapper
  */

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureExpressionList = exports.ensureChildrenAreLhsAndRhsOrdered = exports.retrieveOpName = exports.getWithTokenType = exports.getTokenType = exports.assureTokenType = exports.retrieveMetaStructure = exports.extractLocation = exports.objectWithArrUnwrap = void 0;
-const input_format_1 = require("../input-format");
-const range_1 = require("../../../../../../util/range");
-const assert_1 = require("../../../../../../util/assert");
+const range_1 = require("../../../../../util/range");
+const assert_1 = require("../../../../../util/assert");
+const input_format_1 = require("./input-format");
 /**
  * if the passed object is an array with only one element, remove the array wrapper
  */
@@ -26,8 +26,7 @@ exports.objectWithArrUnwrap = objectWithArrUnwrap;
  * given a xml element, extract the source location of the corresponding element in the R-ast
  */
 function extractLocation(ast) {
-    const { line1, col1, line2, col2 } = (0, input_format_1.getKeysGuarded)(ast, 'line1', 'col1', 'line2', 'col2');
-    return (0, range_1.rangeFrom)(line1, col1, line2, col2);
+    return (0, range_1.rangeFrom)(ast['line1'], ast['col1'], ast['line2'], ast['col2']);
 }
 exports.extractLocation = extractLocation;
 /**
@@ -39,8 +38,8 @@ exports.extractLocation = extractLocation;
 function retrieveMetaStructure(obj) {
     const unwrappedObj = objectWithArrUnwrap(obj);
     const attributes = obj[input_format_1.attributesKey];
-    const content = obj[input_format_1.contentKey] ?? '';
     (0, assert_1.guard)(attributes !== undefined, () => `expected attributes to be defined for ${JSON.stringify(obj)}`);
+    const content = obj[input_format_1.contentKey] ?? '';
     const location = extractLocation(attributes);
     return {
         unwrappedObj,
@@ -63,7 +62,7 @@ exports.assureTokenType = assureTokenType;
  * @param content  - the json object to extract the token-type from
  */
 function getTokenType(content) {
-    return (0, input_format_1.getKeysGuarded)(content, input_format_1.nameKey);
+    return content[input_format_1.nameKey];
 }
 exports.getTokenType = getTokenType;
 function getWithTokenType(obj) {
@@ -98,6 +97,7 @@ function ensureExpressionList(node) {
     if (node.type !== "RExpressionList" /* RType.ExpressionList */) {
         return {
             type: "RExpressionList" /* RType.ExpressionList */,
+            grouping: undefined,
             location: node.location,
             info: node.info,
             lexeme: undefined,
@@ -107,4 +107,4 @@ function ensureExpressionList(node) {
     return node;
 }
 exports.ensureExpressionList = ensureExpressionList;
-//# sourceMappingURL=meta.js.map
+//# sourceMappingURL=normalize-meta.js.map

package/r-bridge/lang-4.x/ast/parser/xml/{data.d.ts → normalizer-data.d.ts}

@@ -1,13 +1,9 @@
 import type { MergeableRecord } from '../../../../../util/objects';
-import type { DeepReadonly } from 'ts-essentials';
-import type { XmlParserHooks } from './hooks';
 import type { SourceRange } from '../../../../../util/range';
 /**
  * Contains all information populated and present during parsing and normalization of the R AST.
  */
-export interface ParserData extends MergeableRecord {
-    /** @see XmlParserHooks */
-    readonly hooks: DeepReadonly<XmlParserHooks>;
+export interface NormalizerData extends MergeableRecord {
     /**
    * The currently active source range during parsing, i.e. the full range of the current element.
    */

package/r-bridge/lang-4.x/ast/parser/xml/normalizer-data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=normalizer-data.js.map

package/r-bridge/lang-4.x/{values.d.ts → convert-values.d.ts}

@@ -22,8 +22,8 @@ export interface RNumberValue {
 export declare function number2ts(value: string): RNumberValue;
 export interface RStringValue {
     str: string;
-    /** from the R-language definition a string is either delimited by a pair of single or double quotes */
-    quotes: '"' | '\'';
+    /** from the R-language definition a string is either delimited by a pair of single or double quotes, 'none' strings are syntactically unquoted but treated as strings  */
+    quotes: '"' | '\'' | 'none';
     /** a string is raw if prefixed with r */
     flag?: 'raw';
 }