@eagleoutice/flowr 1.3.11

package/r-bridge/lang-4.x/ast/parser/xml/v1/hooks.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PARSER_HOOKS = exports.executeUnknownHook = exports.executeHook = void 0;
+/* eslint-disable -- hooks are unsafe */
+/**
+ * simple (rather type-wise unsafe ^^) function you can use to execute hooks and deal with {@link AutoIfOmit}
+ *
+ * @see executeUnknownHook
+ */
+function executeHook(hook, data, input) {
+    const result = hook(data, input);
+    if (result === undefined) {
+        return input;
+    }
+    return result;
+}
+exports.executeHook = executeHook;
+/**
+ * @see executeHook
+ */
+function executeUnknownHook(hook, data, input) {
+    return hook(data, input);
+}
+exports.executeUnknownHook = executeUnknownHook;
+/* eslint-enable */
+const doNothing = () => undefined;
+exports.DEFAULT_PARSER_HOOKS = {
+    values: {
+        onNumber: {
+            before: doNothing,
+            after: doNothing
+        },
+        onString: {
+            before: doNothing,
+            after: doNothing
+        },
+        onSymbol: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    onAccess: {
+        unknown: doNothing,
+        before: doNothing,
+        after: doNothing
+    },
+    other: {
+        onComment: {
+            before: doNothing,
+            after: doNothing
+        },
+        onLineDirective: {
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    control: {
+        onIfThen: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onIfThenElse: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    loops: {
+        onForLoop: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onRepeatLoop: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onWhileLoop: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onBreak: {
+            before: doNothing,
+            after: doNothing
+        },
+        onNext: {
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    operators: {
+        onBinary: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onUnary: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    functions: {
+        onFunctionDefinition: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onParameter: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onFunctionCall: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onArgument: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+    },
+    expression: {
+        onExpression: {
+            before: doNothing,
+            after: doNothing
+        }
+    }
+};
+//# sourceMappingURL=hooks.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./data"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("../common/config"), exports);
+__exportStar(require("./normalize"), exports);
+__exportStar(require("../common/input-format"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeAccess = void 0;
+const meta_1 = require("../../common/meta");
+const normalize_1 = require("../normalize");
+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");
+/**
+ * Tries to normalize the given data as access (e.g., indexing).
+ *
+ * @param data           - The data used by the parser (see {@link ParserData})
+ * @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) {
+    normalize_1.parseLog.trace('trying to parse access');
+    mappedWithName = (0, hooks_1.executeHook)(data.hooks.onAccess.before, data, mappedWithName);
+    if (mappedWithName.length < 3) {
+        normalize_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);
+    }
+    const accessOp = mappedWithName[1];
+    let operator;
+    let closingLength = 0;
+    switch (accessOp.name) {
+        case "[" /* RawRType.BracketLeft */:
+            operator = '[';
+            closingLength = 1;
+            break;
+        case "$" /* RawRType.Dollar */:
+            operator = '$';
+            break;
+        case "@" /* RawRType.At */:
+            operator = '@';
+            break;
+        case "LBB" /* RawRType.DoubleBracketLeft */:
+            operator = '[[';
+            closingLength = 2;
+            break;
+        default:
+            normalize_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);
+    }
+    const accessed = mappedWithName[0];
+    if (accessed.name !== "expr" /* RawRType.Expression */ && accessed.name !== "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */) {
+        normalize_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);
+    }
+    const parsedAccessed = (0, structure_1.normalizeBasedOnType)(data, [accessed]);
+    if (parsedAccessed.length !== 1) {
+        normalize_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);
+    }
+    const remaining = mappedWithName.slice(2, mappedWithName.length - closingLength);
+    normalize_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) {
+            normalize_1.parseLog.trace('record empty access');
+            return null;
+        }
+        normalize_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;
+    });
+    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)(data.config, accessOp.content);
+    const result = {
+        type: "RAccess" /* RType.Access */,
+        location,
+        lexeme: content,
+        accessed: parsedAccessed[0],
+        operator,
+        access: resultingAccess,
+        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

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/control/if-then-else.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeIfThenElse = void 0;
+const structure_1 = require("../structure");
+const normalize_1 = require("../../normalize");
+const if_then_1 = require("./if-then");
+const assert_1 = require("../../../../../../../../util/assert");
+const hooks_1 = require("../../hooks");
+const meta_1 = require("../../../common/meta");
+/**
+ * Try to parse the construct as a {@link RIfThenElse}.
+ */
+function tryNormalizeIfThenElse(data, tokens) {
+    // we start by parsing a regular if-then structure
+    normalize_1.parseLog.trace('trying to parse if-then-else structure');
+    tokens = (0, hooks_1.executeHook)(data.hooks.control.onIfThenElse.before, data, tokens);
+    const parsedIfThen = (0, if_then_1.tryNormalizeIfThen)(data, [tokens[0], tokens[1], tokens[2], tokens[3], tokens[4]]);
+    if (parsedIfThen === undefined) {
+        return (0, hooks_1.executeUnknownHook)(data.hooks.control.onIfThenElse.unknown, data, tokens);
+    }
+    normalize_1.parseLog.trace('if-then part successful, now parsing else part');
+    (0, assert_1.guard)(tokens[5].name === "ELSE" /* RawRType.Else */, () => `expected else token for if-then-else but found ${JSON.stringify(tokens[5])}`);
+    const parsedElse = (0, structure_1.tryNormalizeSingleNode)(data, tokens[6]);
+    (0, assert_1.guard)(parsedElse.type !== "RDelimiter" /* RType.Delimiter */, () => `unexpected missing else-part of if-then-else, received ${JSON.stringify([parsedIfThen, parsedElse])} for ${JSON.stringify(tokens)}`);
+    const result = {
+        ...parsedIfThen,
+        otherwise: (0, meta_1.ensureExpressionList)(parsedElse)
+    };
+    return (0, hooks_1.executeHook)(data.hooks.control.onIfThenElse.after, data, result);
+}
+exports.tryNormalizeIfThenElse = tryNormalizeIfThenElse;
+//# sourceMappingURL=if-then-else.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/control/if-then.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeIfThen = void 0;
+const input_format_1 = require("../../../common/input-format");
+const structure_1 = require("../structure");
+const meta_1 = require("../../../common/meta");
+const normalize_1 = require("../../normalize");
+const hooks_1 = require("../../hooks");
+/**
+ * Try to parse the construct as a {@link RIfThenElse}.
+ */
+function tryNormalizeIfThen(data, tokens) {
+    normalize_1.parseLog.trace('trying to parse if-then structure');
+    if (tokens[0].name !== "IF" /* RawRType.If */) {
+        normalize_1.parseLog.debug('encountered non-if token for supposed if-then structure');
+        return (0, hooks_1.executeUnknownHook)(data.hooks.control.onIfThen.unknown, data, tokens);
+    }
+    else if (tokens[1].name !== "(" /* RawRType.ParenLeft */) {
+        throw new input_format_1.XmlParseError(`expected left-parenthesis for if but found ${JSON.stringify(tokens[1])}`);
+    }
+    else if (tokens[3].name !== ")" /* RawRType.ParenRight */) {
+        throw new input_format_1.XmlParseError(`expected right-parenthesis for if but found ${JSON.stringify(tokens[3])}`);
+    }
+    tokens = (0, hooks_1.executeHook)(data.hooks.control.onIfThen.before, data, tokens);
+    const parsedCondition = (0, structure_1.tryNormalizeSingleNode)(data, tokens[2]);
+    const parsedThen = (0, structure_1.tryNormalizeSingleNode)(data, tokens[4]);
+    if (parsedCondition.type === "RDelimiter" /* RType.Delimiter */ || parsedThen.type === "RDelimiter" /* RType.Delimiter */) {
+        throw new input_format_1.XmlParseError(`unexpected missing parts of if, received ${JSON.stringify([parsedCondition, parsedThen])} for ${JSON.stringify(tokens)}`);
+    }
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, tokens[0].content);
+    const result = {
+        type: "RIfThenElse" /* RType.IfThenElse */,
+        condition: parsedCondition,
+        then: (0, meta_1.ensureExpressionList)(parsedThen),
+        location,
+        lexeme: content,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.control.onIfThen.after, data, result);
+}
+exports.tryNormalizeIfThen = tryNormalizeIfThen;
+//# sourceMappingURL=if-then.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/control/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./if-then"), exports);
+__exportStar(require("./if-then-else"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/expression/expression.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExpression = void 0;
+const input_format_1 = require("../../../common/input-format");
+const meta_1 = require("../../../common/meta");
+const normalize_1 = require("../../normalize");
+const structure_1 = require("../structure");
+const functions_1 = require("../functions");
+const hooks_1 = require("../../hooks");
+const access_1 = require("../access");
+const other_1 = require("../other");
+const arrays_1 = require("../../../../../../../../util/arrays");
+/**
+ * Returns an expression list if there are multiple children, otherwise returns the single child directly with no expr wrapper
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeExpression(data, obj) {
+    normalize_1.parseLog.debug('Parsing expr');
+    obj = (0, hooks_1.executeHook)(data.hooks.expression.onExpression.before, data, obj);
+    const { unwrappedObj, content, location } = (0, meta_1.retrieveMetaStructure)(data.config, obj);
+    const childrenSource = (0, input_format_1.getKeyGuarded)(unwrappedObj, data.config.children);
+    const typed = (0, meta_1.getWithTokenType)(data.config.tokenMap, childrenSource);
+    const { others, comments } = (0, structure_1.splitComments)(typed);
+    const childData = { ...data, currentRange: location, currentLexeme: content };
+    const maybeFunctionCall = (0, functions_1.tryNormalizeFunctionCall)(childData, others);
+    if (maybeFunctionCall !== undefined) {
+        maybeFunctionCall.info.additionalTokens = [...maybeFunctionCall.info.additionalTokens ?? [], ...comments.map(x => (0, other_1.normalizeComment)(data, x.content))];
+        return maybeFunctionCall;
+    }
+    const maybeAccess = (0, access_1.tryNormalizeAccess)(childData, others);
+    if (maybeAccess !== undefined) {
+        maybeAccess.info.additionalTokens = [...maybeAccess.info.additionalTokens ?? [], ...comments.map(x => (0, other_1.normalizeComment)(data, x.content))];
+        return maybeAccess;
+    }
+    const maybeFunctionDefinition = (0, functions_1.tryNormalizeFunctionDefinition)(childData, others);
+    if (maybeFunctionDefinition !== undefined) {
+        maybeFunctionDefinition.info.additionalTokens = [...maybeFunctionDefinition.info.additionalTokens ?? [], ...comments.map(x => (0, other_1.normalizeComment)(data, x.content))];
+        return maybeFunctionDefinition;
+    }
+    const children = (0, structure_1.normalizeBasedOnType)(childData, childrenSource);
+    const [delimiters, nodes] = (0, arrays_1.partition)(children, x => x.type === "RDelimiter" /* RType.Delimiter */);
+    let result;
+    if (nodes.length === 1) {
+        result = nodes[0];
+        result.info.additionalTokens = [...result.info.additionalTokens ?? [], ...delimiters];
+    }
+    else {
+        result = {
+            type: "RExpressionList" /* RType.ExpressionList */,
+            location,
+            children: nodes,
+            lexeme: content,
+            info: {
+                fullRange: childData.currentRange,
+                additionalTokens: delimiters,
+                fullLexeme: childData.currentLexeme
+            }
+        };
+    }
+    return (0, hooks_1.executeHook)(data.hooks.expression.onExpression.after, data, result);
+}
+exports.normalizeExpression = normalizeExpression;
+//# sourceMappingURL=expression.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/expression/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./expression"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/functions/argument.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryToNormalizeArgument = void 0;
+const normalize_1 = require("../../normalize");
+const meta_1 = require("../../../common/meta");
+const hooks_1 = require("../../hooks");
+const log_1 = require("../../../../../../../../util/log");
+const assert_1 = require("../../../../../../../../util/assert");
+const structure_1 = require("../structure");
+/**
+ * Either parses `[expr]` or `[SYMBOL_SUB, EQ_SUB, expr]` as an argument of a function call in R.
+ * Probably directly called by the function call parser as otherwise, we do not expect to find arguments.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param objs - Either `[expr]` or `[SYMBOL_FORMALS, EQ_FORMALS, expr]`
+ *
+ * @returns The parsed argument or `undefined` if the given object is not an argument.
+ */
+function tryToNormalizeArgument(data, objs) {
+    normalize_1.parseLog.debug('[argument]');
+    objs = (0, hooks_1.executeHook)(data.hooks.functions.onArgument.before, data, objs);
+    if (objs.length < 1 || objs.length > 3) {
+        log_1.log.warn(`Either [expr|value], [SYMBOL_SUB, EQ_SUB], or [SYMBOL_SUB, EQ_SUB, expr], but got: ${objs.map(o => o.name).join(', ')}`);
+        return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onArgument.unknown, data, objs);
+    }
+    const symbolOrExpr = objs[0];
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, symbolOrExpr.content);
+    let parsedValue;
+    let name;
+    if (symbolOrExpr.name === "expr" /* RawRType.Expression */) {
+        name = undefined;
+        parsedValue = (0, structure_1.tryNormalizeSingleNode)(data, symbolOrExpr);
+    }
+    else if (symbolOrExpr.name === "SYMBOL_SUB" /* RawRType.SymbolSub */ || symbolOrExpr.name === "STR_CONST" /* RawRType.StringConst */) {
+        name = {
+            type: "RSymbol" /* RType.Symbol */,
+            location,
+            content: symbolOrExpr.name === "STR_CONST" /* RawRType.StringConst */ ? content.slice(1, -1) : content,
+            namespace: undefined,
+            lexeme: content,
+            info: {
+                fullRange: location,
+                additionalTokens: [],
+                fullLexeme: content
+            }
+        };
+        parsedValue = parseWithValue(data, objs);
+    }
+    else {
+        log_1.log.warn(`expected symbol or expr for argument, yet received ${objs.map(o => o.name).join(',')}`);
+        return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onArgument.unknown, data, objs);
+    }
+    (0, assert_1.guard)(parsedValue !== undefined && parsedValue?.type !== "RDelimiter" /* RType.Delimiter */, () => `[argument] parsed value must not be undefined, yet: ${JSON.stringify(objs)}`);
+    const result = {
+        type: "RArgument" /* RType.Argument */,
+        location,
+        lexeme: content,
+        name,
+        value: parsedValue ?? undefined,
+        info: {
+            fullRange: location,
+            fullLexeme: content,
+            additionalTokens: []
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.functions.onArgument.after, data, result);
+}
+exports.tryToNormalizeArgument = tryToNormalizeArgument;
+function parseWithValue(data, objs) {
+    (0, assert_1.guard)(objs[1].name === "EQ_SUB" /* RawRType.EqualSub */, () => `[arg-default] second element of parameter must be ${"EQ_FORMALS" /* RawRType.EqualFormals */}, but: ${JSON.stringify(objs)}`);
+    (0, assert_1.guard)(objs.length === 2 || objs[2].name === "expr" /* RawRType.Expression */, () => `[arg-default] third element of parameter must be an Expression or undefined (for 'x=') but: ${JSON.stringify(objs)}`);
+    return objs[2] ? (0, structure_1.tryNormalizeSingleNode)(data, objs[2]) : null;
+}
+//# sourceMappingURL=argument.js.map