@eagleoutice/flowr 2.7.6 → 2.8.1

package/r-bridge/roxygen2/roxygen-parse.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstAndRest = void 0;
+exports.parseRoxygenCommentsOfNode = parseRoxygenCommentsOfNode;
+exports.parseRoxygenComment = parseRoxygenComment;
+const roxygen_ast_1 = require("./roxygen-ast");
+const r_comment_1 = require("../lang-4.x/ast/model/nodes/r-comment");
+const assert_1 = require("../../util/assert");
+const args_1 = require("../../util/text/args");
+const range_1 = require("../../util/range");
+function prepareCommentContext(commentText) {
+    const contents = [];
+    for (const line of commentText) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        else if (!trimmed.startsWith('#')) {
+            // we are done with the roxygen comment
+            break;
+        }
+        contents.push((trimmed.startsWith('#\'') ? trimmed.slice(2) : trimmed.slice(1)).trimEnd());
+    }
+    return contents;
+}
+/**
+ * Parses the roxygen comments attached to a node into a RoxygenBlock AST node.
+ * Will return `undefined` if there are no valid roxygen comments attached to the node.
+ * @param node  - The node to parse the roxygen comments for
+ * @param idMap - An optional id map to traverse up the AST to find comments attached to parent nodes
+ */
+function parseRoxygenCommentsOfNode(node, idMap) {
+    let comments;
+    let cur = node;
+    do {
+        comments = cur?.info.additionalTokens
+            ?.filter(r_comment_1.isRComment).filter(r => (0, assert_1.isNotUndefined)(r.lexeme));
+        cur = cur?.info.parent ? idMap?.get(cur.info.parent) : undefined;
+    } while ((comments === undefined || comments.length === 0) && cur !== undefined);
+    if (comments === undefined || comments.length === 0) {
+        return undefined;
+    }
+    const commentContent = comments.map(c => c.lexeme);
+    return {
+        type: 'roxygen-block',
+        tags: parseRoxygenComment(commentContent),
+        attachedTo: cur?.info.id,
+        requestNode: node.info.id,
+        range: [
+            ...(0, range_1.mergeRanges)(...comments.map(c => c.location)),
+            comments.find(c => c.info.file)?.info.file
+        ]
+    };
+}
+/**
+ * Parses a roxygen comment into a RoxygenBlock AST node.
+ * Will return an empty array if the comment has no valid roxygen comment.
+ * @see {@link parseRoxygenCommentsOfNode} - to parse comments attached to a node
+ */
+function parseRoxygenComment(commentText) {
+    const contents = prepareCommentContext(commentText);
+    const state = {
+        lines: contents,
+        tags: [],
+        idx: 0
+    };
+    val(state, [roxygen_ast_1.KnownRoxygenTags.Text]);
+    return state.tags;
+}
+function atEnd(state) {
+    return state.idx >= state.lines.length;
+}
+function atTag(state) {
+    if (atEnd(state)) {
+        return undefined;
+    }
+    const line = state.lines[state.idx].trim();
+    if (!line.startsWith('@')) {
+        return undefined;
+    }
+    const firstSpace = line.indexOf(' ');
+    return firstSpace === -1 ? [line.slice(1), undefined] : [line.slice(1, firstSpace), line.slice(firstSpace + 1).trim()];
+}
+function advanceLine(state) {
+    return state.lines[state.idx++];
+}
+function collectUntilNextTag(state) {
+    const collected = [];
+    while (!atEnd(state)) {
+        const mayTag = atTag(state);
+        if (mayTag) {
+            advanceLine(state);
+            return [collected, mayTag];
+        }
+        collected.push(advanceLine(state));
+    }
+    return [collected, undefined];
+}
+function addTag(state, tag) {
+    state.tags.push(tag);
+}
+function val(state, tagName, lineToVal = l => l.join('\n').trim()) {
+    const [lines, nextTag] = collectUntilNextTag(state);
+    if (tagName[1]) {
+        lines.unshift(tagName[1]);
+    }
+    if (tagName[0] !== roxygen_ast_1.KnownRoxygenTags.Text || lines.length > 0) {
+        const n = tagName[0];
+        if ((0, roxygen_ast_1.isKnownRoxygenText)(n)) {
+            const val = lineToVal(lines);
+            addTag(state, (val !== undefined ? {
+                type: n,
+                value: val
+            } : { type: n }));
+        }
+        else {
+            addTag(state, {
+                type: roxygen_ast_1.KnownRoxygenTags.Unknown,
+                value: {
+                    tag: n,
+                    content: lines.join(' ')
+                }
+            });
+        }
+    }
+    parseRoxygenTag(state, nextTag);
+}
+const spaceVals = (s, t) => val(s, t, l => (0, args_1.splitAtEscapeSensitive)(l.join(' ')));
+const flagVal = (s, t) => val(s, t, () => undefined);
+const section = (s, t) => val(s, t, l => {
+    return { title: l[0].trim(), content: l.slice(1).join('\n').trim() };
+});
+const firstAndRest = (firstName, secondName) => (s, t) => val(s, t, l => {
+    const vals = (0, args_1.splitAtEscapeSensitive)(l.join('\n'));
+    return { [firstName]: vals[0], [secondName]: vals.slice(1).join(' ').trim() };
+});
+exports.firstAndRest = firstAndRest;
+const firstAndArrayRest = (firstName, secondName) => (s, t) => val(s, t, l => {
+    const vals = (0, args_1.splitAtEscapeSensitive)(l.join('\n'));
+    return { [firstName]: vals[0], [secondName]: vals.slice(1) };
+});
+const asNumber = (s, t) => val(s, t, l => {
+    const num = Number(l.join(' ').trim());
+    return Number.isNaN(num) ? undefined : num;
+});
+const TagMap = {
+    [roxygen_ast_1.KnownRoxygenTags.Aliases]: spaceVals,
+    [roxygen_ast_1.KnownRoxygenTags.Backref]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Concept]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Family]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Keywords]: spaceVals,
+    [roxygen_ast_1.KnownRoxygenTags.References]: val,
+    [roxygen_ast_1.KnownRoxygenTags.SeeAlso]: spaceVals,
+    [roxygen_ast_1.KnownRoxygenTags.EvalNamespace]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Export]: flagVal,
+    [roxygen_ast_1.KnownRoxygenTags.ExportClass]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ExportMethod]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ExportPattern]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ExportS3Method]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Import]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ImportClassesFrom]: firstAndArrayRest('package', 'classes'),
+    [roxygen_ast_1.KnownRoxygenTags.ImportMethodsFrom]: firstAndArrayRest('package', 'methods'),
+    [roxygen_ast_1.KnownRoxygenTags.ImportFrom]: firstAndArrayRest('package', 'symbols'),
+    [roxygen_ast_1.KnownRoxygenTags.RawNamespace]: val,
+    [roxygen_ast_1.KnownRoxygenTags.UseDynLib]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Md]: flagVal,
+    [roxygen_ast_1.KnownRoxygenTags.NoMd]: flagVal,
+    [roxygen_ast_1.KnownRoxygenTags.Section]: section,
+    [roxygen_ast_1.KnownRoxygenTags.Field]: (0, exports.firstAndRest)('name', 'description'),
+    [roxygen_ast_1.KnownRoxygenTags.Format]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Method]: (0, exports.firstAndRest)('generic', 'class'),
+    [roxygen_ast_1.KnownRoxygenTags.Slot]: (0, exports.firstAndRest)('name', 'description'),
+    [roxygen_ast_1.KnownRoxygenTags.Source]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Description]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Details]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Example]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Examples]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ExamplesIf]: (0, exports.firstAndRest)('condition', 'content'),
+    [roxygen_ast_1.KnownRoxygenTags.NoRd]: flagVal,
+    [roxygen_ast_1.KnownRoxygenTags.Param]: (0, exports.firstAndRest)('name', 'description'),
+    [roxygen_ast_1.KnownRoxygenTags.RawRd]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Return]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Returns]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Title]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Usage]: val,
+    [roxygen_ast_1.KnownRoxygenTags.DescribeIn]: (0, exports.firstAndRest)('dest', 'description'),
+    [roxygen_ast_1.KnownRoxygenTags.Eval]: val,
+    [roxygen_ast_1.KnownRoxygenTags.EvalRd]: val,
+    [roxygen_ast_1.KnownRoxygenTags.IncludeRmd]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Inherit]: firstAndArrayRest('source', 'components'),
+    [roxygen_ast_1.KnownRoxygenTags.InheritDotParams]: firstAndArrayRest('source', 'args'),
+    [roxygen_ast_1.KnownRoxygenTags.InheritParams]: val,
+    [roxygen_ast_1.KnownRoxygenTags.InheritSection]: (0, exports.firstAndRest)('source', 'section'),
+    [roxygen_ast_1.KnownRoxygenTags.Order]: asNumber,
+    [roxygen_ast_1.KnownRoxygenTags.RdName]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Template]: val,
+    [roxygen_ast_1.KnownRoxygenTags.TemplateVar]: (0, exports.firstAndRest)('name', 'value'),
+    [roxygen_ast_1.KnownRoxygenTags.Text]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Name]: val,
+    [roxygen_ast_1.KnownRoxygenTags.DocType]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Author]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Unknown]: (s, t) => val(s, t, l => ({
+        tag: t[0],
+        content: l.join(' ')
+    }))
+};
+function parseRoxygenTag(state, tagName) {
+    if (tagName === undefined) {
+        return;
+    }
+    const parser = TagMap[tagName[0]] ?? val;
+    parser(state, tagName);
+}
+//# sourceMappingURL=roxygen-parse.js.map

package/reconstruct/auto-select/magic-comments.js

@@ -31,7 +31,7 @@ const magicCommentIdMapper = {
         return ret;
     }
 };
-const commentTriggerRegex = / flowr@(\w+)/;
+const commentTriggerRegex = /# flowr@(\w+)/;
 /**
  * This takes an {@link NormalizedAst} and returns an auto-select predicate for {@link reconstructToCode},
  * which will automatically include lines marked by these special comments!
@@ -58,11 +58,11 @@ function makeMagicCommentHandler(and) {
                     return;
                 }
                 for (const c of comments) {
-                    if (c.type !== type_1.RType.Comment || !c.content.startsWith(' flowr@')) {
+                    if (c.type !== type_1.RType.Comment || !c.lexeme.startsWith('# flowr@')) {
                         continue;
                     }
-                    const match = commentTriggerRegex.exec(c.content);
-                    (0, assert_1.guard)(match !== null, `invalid magic comment: ${c.content}`);
+                    const match = commentTriggerRegex.exec(c.lexeme);
+                    (0, assert_1.guard)(match !== null, `invalid magic comment: ${c.lexeme}`);
                     const idMapper = magicCommentIdMapper[match[1]];
                     (0, assert_1.guard)(idMapper !== undefined, `unknown magic comment: ${match[1]}`);
                     const ls = idMapper(c, startLineStack);

package/slicing/static/slice-call.js

@@ -33,7 +33,7 @@ function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment, q
     const functionCallTargets = queue.memoizeCallTargets(functionCallDefs.join(';'), () => (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph)[0]);
     return [functionCallTargets, activeEnvironment];
 }
-function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowGraph) {
+function includeArgumentFunctionCallClosure(arg, activeEnvironment, queue, dataflowGraph) {
     const valueRoot = (0, graph_1.getReferenceOfArgument)(arg);
     if (!valueRoot) {
         return;
@@ -44,7 +44,7 @@ function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironm
 function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironment, activeEnvironmentFingerprint, queue) {
     for (const functionCallTarget of functionCallTargets) {
         for (const exitPoint of functionCallTarget.exitPoints) {
-            queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, onlyForSideEffects);
+            queue.add(exitPoint.nodeId, activeEnvironment, activeEnvironmentFingerprint, onlyForSideEffects);
         }
         // handle open reads
         for (const openIn of functionCallTarget.subflow.in) {
@@ -60,7 +60,6 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironm
 }
 /** returns the new threshold hit count */
 function sliceForCall(current, callerInfo, dataflowInformation, queue, ctx) {
-    const baseEnvironment = current.baseEnvironment;
     const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowInformation.graph, callerInfo, current.baseEnvironment, queue, ctx);
     const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
     if (functionCallTargets.size === 0) {
@@ -69,7 +68,7 @@ function sliceForCall(current, callerInfo, dataflowInformation, queue, ctx) {
          * hence, we add a new flag and add all argument values to the queue causing directly
          */
         for (const arg of callerInfo.args) {
-            includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowInformation.graph);
+            includeArgumentFunctionCallClosure(arg, activeEnvironment, queue, dataflowInformation.graph);
         }
         return;
     }

package/slicing/static/static-slicer.js

@@ -66,9 +66,9 @@ function staticSlice(ctx, info, { idMap }, criteria, direction, threshold = 75,
         }
         const [currentVertex, currentEdges] = currentInfo;
         // we only add control dependencies iff 1) we are in different function call or 2) they have, at least, the same nesting as the slicing seed
-        if (currentVertex.cds && currentVertex.cds.length > 0) {
+        if (currentVertex.controlDependencies && currentVertex.controlDependencies.length > 0) {
             const topLevel = graph.isRoot(id) || sliceSeedIds.has(id);
-            for (const cd of currentVertex.cds.filter(({ id }) => !queue.hasId(id))) {
+            for (const cd of currentVertex.controlDependencies.filter(({ id }) => !queue.hasId(id))) {
                 if (!topLevel || (idMap.get(cd.id)?.info.nesting ?? 0) >= minNesting) {
                     queue.add(cd.id, baseEnvironment, baseEnvFingerprint, false);
                 }

package/statistics/features/supported/defined-functions/defined-functions.js

@@ -57,7 +57,7 @@ function visitDefinitions(info, input) {
         }
         const [fnDefinition] = dfNode;
         (0, assert_1.guard)(fnDefinition.tag === vertex_1.VertexType.FunctionDefinition, () => `Dataflow node is not a function definition (${JSON.stringify(fnDefinition)}))})`);
-        const returnTypes = fnDefinition.exitPoints.map(ep => graph.get(ep, true)).filter(assert_1.isNotUndefined)
+        const returnTypes = fnDefinition.exitPoints.map(ep => graph.get(ep.nodeId, true)).filter(assert_1.isNotUndefined)
             .map(([vertex]) => {
             const l = graph.idMap?.get(vertex.id)?.location;
             return {

package/util/collections/defaultmap.d.ts

@@ -25,10 +25,10 @@ export declare class DefaultMap<K, V = K> {
     /**
      * Iterates over all entries that have been set (explicitly or by the generator)
      */
-    entries(): IterableIterator<[K, V]>;
+    entries(): MapIterator<[K, V]>;
     /** returns only the keys really stored in the map */
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
+    keys(): MapIterator<K>;
+    values(): MapIterator<V>;
     delete(k: K): boolean;
     size(): number;
 }

package/util/mermaid/dfg.js

@@ -33,7 +33,7 @@ function formatRange(range) {
     }
     return `${range[0]}.${range[1]}-${range[2]}.${range[3]}`;
 }
-function subflowToMermaid(nodeId, exitPoints, subflow, mermaid, idPrefix = '') {
+function subflowToMermaid(nodeId, subflow, mermaid, idPrefix = '') {
     if (subflow === undefined) {
         return;
     }
@@ -166,7 +166,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
     }
     else {
         const escapedName = (0, mermaid_1.escapeMarkdown)(node ? `[${node.type}] ${lexeme}` : '??');
-        const deps = info.cds ? ', :may:' + info.cds.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
+        const deps = info.controlDependencies ? ', :may:' + info.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
         const lnks = info.link?.origin ? ', :links:' + info.link.origin.join(',') : '';
         const n = node?.info.fullRange ?? node?.location ?? (node?.type === type_1.RType.ExpressionList ? node?.grouping?.[0].location : undefined);
         mermaid.nodeLines.push(`    ${idPrefix}${id}${open}"\`${escapedName}${escapedName.length > 10 ? '\n      ' : ' '}(${id}${deps}${lnks})\n      *${formatRange(n)}*${fCall ? displayFunctionArgMapping(info.args) : ''}\`"${close}`);
@@ -182,7 +182,7 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
         mermaid.nodeLines.push('   %% No edges found for ' + id);
         return;
     }
-    const artificialCdEdges = (info.cds ?? []).map(x => [x.id, { types: new Set([x.when ? 'CD-True' : 'CD-False']) }]);
+    const artificialCdEdges = (info.controlDependencies ?? []).map(x => [x.id, { types: new Set([x.when ? 'CD-True' : 'CD-False']) }]);
     // eslint-disable-next-line prefer-const
     for (let [target, edge] of [...edges[1], ...artificialCdEdges]) {
         if (includeOnlyIds && !includeOnlyIds.has(target)) {
@@ -207,14 +207,14 @@ function vertexToMermaid(info, mermaid, id, idPrefix, mark, includeOnlyIds) {
                 mermaid.edgeLines.push(`    linkStyle ${mermaid.presentEdges.size - 1} stroke:gray;`);
                 if (!mermaid.presentVertices.has(target)) {
                     mermaid.nodeLines.push(`    ${idPrefix}${target}["\`Built-In:\n${(0, mermaid_1.escapeMarkdown)(String(originalTarget).replace('built-in:', ''))}\`"]`);
-                    mermaid.nodeLines.push(`    style ${idPrefix}${target} stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;`);
+                    mermaid.nodeLines.push(`    style ${idPrefix}${target} stroke:gray,fill:gray,stroke-width:2px,opacity:.8;`);
                     mermaid.presentVertices.add(target);
                 }
             }
         }
     }
     if (info.tag === vertex_1.VertexType.FunctionDefinition) {
-        subflowToMermaid(id, info.exitPoints, info.subflow, mermaid, idPrefix);
+        subflowToMermaid(id, info.subflow, mermaid, idPrefix);
     }
 }
 // make the passing of root ids more performant again

package/util/objects.js

@@ -30,7 +30,7 @@ function deepMergeObject(base, addon) {
         deepMergeObjectWithResult(addon, base, result);
     }
     else if (baseIsArray && addonIsArray) {
-        return [...base, ...addon];
+        return base.concat(addon);
     }
     else {
         throw new Error('cannot merge object with array!');

package/util/r-author.d.ts

@@ -37,3 +37,8 @@ export declare function rAuthorInfoToReadable(author: RAuthorInfo): string;
  * For now, this works *without* the full dataflow engine, so complex cases may not be parsed correctly.
  */
 export declare function parseRAuthorString(authorString: string): RAuthorInfo[];
+/**
+ * In contrast to `parseRAuthorString`, this function parses simple textual author strings,
+ * like `First Middle Last <email> [roles] (comment)...`. It does not support the full R `person()` syntax.
+ */
+export declare function parseTextualAuthorString(authorString: string, addRoles?: AuthorRole[]): RAuthorInfo[];

package/util/r-author.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthorRole = void 0;
 exports.rAuthorInfoToReadable = rAuthorInfoToReadable;
 exports.parseRAuthorString = parseRAuthorString;
+exports.parseTextualAuthorString = parseTextualAuthorString;
 const args_1 = require("./text/args");
 const assert_1 = require("./assert");
 const objects_1 = require("./objects");
@@ -191,4 +192,113 @@ function parseRPersonCall(personCall) {
         orcid: comments?.orcid
     });
 }
+function collectUntil(source, anyOf) {
+    let collected = '';
+    let i = 0;
+    while (i < source.length && !anyOf.test(source[i])) {
+        collected += source[i];
+        i++;
+    }
+    return { collected, rest: source.slice(i) };
+}
+/**
+ * In contrast to `parseRAuthorString`, this function parses simple textual author strings,
+ * like `First Middle Last <email> [roles] (comment)...`. It does not support the full R `person()` syntax.
+ */
+function parseTextualAuthorString(authorString, addRoles = []) {
+    const parts = (0, args_1.splitOnNestingSensitive)(authorString, 'and', {
+        '<': '>',
+        '[': ']',
+        '(': ')',
+        '"': '"',
+        "'": "'"
+    });
+    const authors = [];
+    for (const part of parts) {
+        const name = collectUntil(part.trim(), /[<[(]/);
+        const others = parseOnRest(name.rest);
+        const c = processComment(others.comment);
+        authors.push((0, objects_1.compactRecord)({
+            name: name.collected.trim().split(/\s+/),
+            email: others.email,
+            roles: others.roles.concat(addRoles),
+            comment: c.comment,
+            orcid: c.orcid
+        }));
+    }
+    return authors;
+}
+function processComment(comment) {
+    if (!comment) {
+        return {};
+    }
+    const parts = comment.split(/\s*[,;]\s*/);
+    const comments = [];
+    let orcid = undefined;
+    for (const part of parts) {
+        const orcidExtract = /ORCID\s*[:= ]\s*(?<orcid>.+)/i;
+        const match = part.match(orcidExtract);
+        if (match && match.groups && match.groups['orcid']) {
+            orcid = match.groups['orcid'].trim();
+        }
+        else {
+            comments.push(part.trim());
+        }
+    }
+    if (orcid) {
+        return { comment: comments.length > 0 ? comments : undefined, orcid };
+    }
+    else {
+        return { comment: [comment] };
+    }
+}
+function parseOnRest(rest) {
+    let email = undefined;
+    let roles = [];
+    let comment = undefined;
+    while (rest.length > 0) {
+        rest = rest.trim();
+        switch (rest[0]) {
+            case '<': {
+                const emailEnd = rest.indexOf('>');
+                if (emailEnd !== -1) {
+                    email = rest.slice(1, emailEnd).trim();
+                    rest = rest.slice(emailEnd + 1);
+                }
+                else {
+                    rest = '';
+                }
+                break;
+            }
+            case '[': {
+                const rolesEnd = rest.indexOf(']');
+                if (rolesEnd !== -1) {
+                    const rolesStr = rest.slice(1, rolesEnd).trim();
+                    roles = rolesStr.split(/\s*,\s*/).map(r => r);
+                    rest = rest.slice(rolesEnd + 1);
+                }
+                else {
+                    rest = '';
+                }
+                break;
+            }
+            case '(': {
+                const commentEnd = rest.indexOf(')');
+                if (commentEnd !== -1) {
+                    comment = rest.slice(1, commentEnd).trim();
+                    rest = rest.slice(commentEnd + 1);
+                }
+                else {
+                    rest = '';
+                }
+                break;
+            }
+            default: {
+                rest = '';
+                break;
+            }
+        }
+    }
+    return { email, roles, comment };
+}
 //# sourceMappingURL=r-author.js.map

package/util/r-license.d.ts

@@ -1,4 +1,4 @@
-import { Range } from 'semver';
+import type { Range } from 'semver';
 export interface RLicenseInfo {
     type: 'license';
     license: string;
@@ -16,8 +16,17 @@ export interface RLicenseCombinationInfo {
 export interface NoLicenseInfo {
     type: 'no-license';
 }
+/**
+ * The structured representation of an R license element.
+ * This can be a license, an exception, a combination of licenses, or no license.
+ * @see {@link parseRLicense} and {@link stringifyRLicense} to parse and stringify R license strings.
+ */
 export type RLicenseElementInfo = RLicenseInfo | RLicenseExceptionInfo | RLicenseCombinationInfo | NoLicenseInfo;
 /**
  * Parses an R license string into its structured representation.
  */
 export declare function parseRLicense(licenseString: string): RLicenseElementInfo;
+/**
+ * Stringifies an R license element back into its string representation.
+ */
+export declare function stringifyRLicense(license: RLicenseElementInfo): string;

package/util/r-license.js

@@ -1,16 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRLicense = parseRLicense;
-const semver_1 = require("semver");
+exports.stringifyRLicense = stringifyRLicense;
 const assert_1 = require("./assert");
 const objects_1 = require("./objects");
+const r_version_1 = require("./r-version");
 /**
  * Parses an R license string into its structured representation.
  */
 function parseRLicense(licenseString) {
-    const start = skipWhitespace({ position: 0, remInput: licenseString });
-    const parsed = parseLicenseInfo(start);
-    return parsed.element;
+    return parseLicenseInfo(skipWhitespace({ position: 0, remInput: licenseString })).element;
+}
+/**
+ * Stringifies an R license element back into its string representation.
+ */
+function stringifyRLicense(license) {
+    const t = license.type;
+    switch (t) {
+        case 'no-license':
+            return 'NO LICENSE';
+        case 'license':
+            return license.versionConstraint ? `${license.license} (${license.versionConstraint.raw})` : license.license;
+        case 'exception':
+            return `with ${license.exception}`;
+        case 'combination': {
+            const left = stringifyRLicense(license.elements[0]);
+            const right = stringifyRLicense(license.elements[1]);
+            const leftStr = license.elements[0].type === 'combination' ? `(${left})` : left;
+            const rightStr = license.elements[1].type === 'combination' ? `(${right})` : right;
+            return `${leftStr} ${license.combination} ${rightStr}`;
+        }
+        default:
+            (0, assert_1.assertUnreachable)(t);
+    }
 }
 function parseLicenseInfo(info) {
     info = skipWhitespace(info);
@@ -72,8 +94,7 @@ function consumeLicenseName(info) {
 }
 function makeRange(rangeStr) {
     try {
-        rangeStr = rangeStr.trim().replaceAll('==', '=');
-        return new semver_1.Range(rangeStr);
+        return (0, r_version_1.parseRRange)(rangeStr);
     }
     catch {
         return undefined;

package/util/r-version.d.ts

@@ -0,0 +1,19 @@
+import { Range, SemVer } from 'semver';
+/**
+ * This parses an R version string and returns a SemVer object.
+ * In contrast to just using `new SemVer(version)`, this function also tries to
+ * normalize R's much free-er versioning scheme into valid SemVer versions.
+ * You can always access the original version string via the `str` property on the returned object.
+ */
+export declare function parseRVersion(version: string): SemVer & {
+    str: string;
+};
+/**
+ * This parses an R version range string and returns a SemVer Range object.
+ * In contrast to just using `new Range(range)`, this function also tries to
+ * normalize R's much free-er versioning scheme into valid SemVer ranges.
+ * You can always access the original range string via the `str` property on the returned object.
+ */
+export declare function parseRRange(range: string): Range & {
+    str: string;
+};