@eagleoutice/flowr 2.7.4 → 2.7.6

package/project/plugins/package-version-plugins/flowr-analyzer-package-versions-namespace-file-plugin.js

@@ -13,7 +13,12 @@ class FlowrAnalyzerPackageVersionsNamespaceFilePlugin extends flowr_analyzer_pac
     version = new semver_1.SemVer('0.1.0');
     process(ctx) {
         const nmspcFiles = ctx.files.getFilesByRole(flowr_file_1.FileRole.Namespace);
-        exports.namespaceFileLog.info(`Found ${nmspcFiles.length} namespace files!`);
+        if (nmspcFiles.length === 0) {
+            exports.namespaceFileLog.warn('No namespace file found, cannot extract package versions.');
+        }
+        else if (nmspcFiles.length > 1) {
+            exports.namespaceFileLog.warn(`Found ${nmspcFiles.length} namespace files, expected exactly one.`);
+        }
         /** this will do the caching etc. for me */
         const deps = nmspcFiles[0].content();
         for (const pkg in deps) {

package/project/plugins/package-version-plugins/package.js

@@ -56,7 +56,7 @@ class Package {
             this.derivedVersion ??= versionConstraints[0];
             for (const constraint of versionConstraints) {
                 if (!this.derivedVersion?.intersects(constraint)) {
-                    throw Error('Version constraint mismatch!');
+                    throw new Error('Version constraint mismatch!');
                 }
                 this.versionConstraints.push(constraint);
                 this.derivedVersion = this.deriveVersion();

package/project/plugins/project-discovery/flowr-analyzer-project-discovery-plugin.js

@@ -5,6 +5,7 @@ const flowr_analyzer_plugin_1 = require("../flowr-analyzer-plugin");
 const semver_1 = require("semver");
 const flowr_file_1 = require("../../context/flowr-file");
 const files_1 = require("../../../util/files");
+const built_in_source_1 = require("../../../dataflow/internal/process/functions/call/built-in/built-in-source");
 /**
  * This is the base class for all plugins that discover files in a project for analysis.
  * These plugins interplay with the {@link FlowrAnalyzerFilesContext} to gather information about the files in the project.
@@ -21,6 +22,7 @@ class FlowrAnalyzerProjectDiscoveryPlugin extends flowr_analyzer_plugin_1.FlowrA
 exports.FlowrAnalyzerProjectDiscoveryPlugin = FlowrAnalyzerProjectDiscoveryPlugin;
 const discoverRSourcesRegex = /\.(r|rmd|ipynb|qmd)$/i;
 const ignorePathsWith = /(\.git|\.svn|\.hg|renv|packrat|node_modules|__pycache__|\.Rproj\.user)/i;
+const excludeRequestsForPaths = /vignettes?|tests?|revdep|inst|data/i;
 /**
  * This is the default dummy implementation of the {@link FlowrAnalyzerProjectDiscoveryPlugin}.
  * It simply collects all files in the given folder and returns them as either {@link RParseRequest} (for R and Rmd files) or {@link FlowrTextFile} (for all other files).
@@ -31,10 +33,18 @@ class DefaultFlowrAnalyzerProjectDiscoveryPlugin extends FlowrAnalyzerProjectDis
     version = new semver_1.SemVer('0.0.0');
     supportedExtensions;
     ignorePathsRegex;
-    constructor(triggerOnExtensions = discoverRSourcesRegex, ignorePathsRegex = ignorePathsWith) {
+    excludePathsRegex = excludeRequestsForPaths;
+    /**
+     * Creates a new instance of the default project discovery plugin.
+     * @param triggerOnExtensions - the regex to trigger R source file discovery on (and hence analyze them as R files)
+     * @param ignorePathsRegex    - the regex to ignore certain paths entirely
+     * @param excludePathsRegex   - the regex to exclude certain paths from being requested as R files (they are still collected as text files)
+     */
+    constructor(triggerOnExtensions = discoverRSourcesRegex, ignorePathsRegex = ignorePathsWith, excludePathsRegex = excludeRequestsForPaths) {
         super();
         this.supportedExtensions = triggerOnExtensions;
         this.ignorePathsRegex = ignorePathsRegex;
+        this.excludePathsRegex = excludePathsRegex;
     }
     process(_context, args) {
         const requests = [];
@@ -43,7 +53,7 @@ class DefaultFlowrAnalyzerProjectDiscoveryPlugin extends FlowrAnalyzerProjectDis
             if (this.ignorePathsRegex.test(file)) {
                 continue;
             }
-            if (this.supportedExtensions.test(file)) {
+            if (this.supportedExtensions.test(file) && !this.excludePathsRegex.test((0, built_in_source_1.platformDirname)(file))) {
                 requests.push({ content: file, request: 'file' });
             }
             else {

package/queries/catalog/project-query/project-query-executor.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeProjectQuery = executeProjectQuery;
 const log_1 = require("../../../util/log");
+const flowr_file_1 = require("../../../project/context/flowr-file");
 /**
  * Executes the given project queries.
  */
@@ -9,14 +10,23 @@ async function executeProjectQuery({ analyzer }, queries) {
     if (queries.length !== 1) {
         log_1.log.warn('Project query expects only up to one query, but got', queries.length);
     }
+    const withDf = queries.some(q => q.withDf);
     // we need to know what is considered by the analyzer
-    await analyzer.dataflow();
+    if (withDf) {
+        await analyzer.dataflow();
+    }
+    const descFile = analyzer.inspectContext().files.getFilesByRole(flowr_file_1.FileRole.Description);
+    const desc = descFile[0];
     return {
         '.meta': {
             /* there is no sense in measuring a get */
             timing: 0
         },
-        files: [...analyzer.inspectContext().files.consideredFilesList()]
+        files: Array.from(analyzer.inspectContext().files.consideredFilesList()),
+        authors: desc?.authors(),
+        encoding: desc?.content().get('Encoding')?.[0],
+        version: desc?.content().get('Version')?.[0],
+        licenses: desc?.license()
     };
 }
 //# sourceMappingURL=project-query-executor.js.map

package/queries/catalog/project-query/project-query-format.d.ts

@@ -1,11 +1,24 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import { executeProjectQuery } from './project-query-executor';
 import Joi from 'joi';
+import type { RAuthorInfo } from '../../../util/r-author';
+import type { RLicenseElementInfo } from '../../../util/r-license';
 export interface ProjectQuery extends BaseQueryFormat {
     readonly type: 'project';
+    /** Whether to include Dataflow information in the result. */
+    readonly withDf?: boolean;
 }
 export interface ProjectQueryResult extends BaseQueryResult {
+    /** The authors of the project. */
+    readonly authors?: RAuthorInfo[];
+    /** The files considered part of the project. */
     readonly files: (string | '<inline>')[];
+    /** The licenses of the project. */
+    readonly licenses?: RLicenseElementInfo[];
+    /** The encoding of the project files. */
+    readonly encoding?: string;
+    /** The version of the project, if available. */
+    readonly version?: string;
 }
 export declare const ProjectQueryDefinition: {
     readonly executor: typeof executeProjectQuery;

package/queries/catalog/project-query/project-query-format.js

@@ -8,19 +8,42 @@ const project_query_executor_1 = require("./project-query-executor");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
+const r_author_1 = require("../../../util/r-author");
 exports.ProjectQueryDefinition = {
     executor: project_query_executor_1.executeProjectQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('project', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push(`   ╰ Contains ${out.files.length} file${out.files.length === 1 ? '' : 's'}`);
-        for (const file of out.files) {
+        if (out.version) {
+            result.push(`   ╰ Version: ${out.version}`);
+        }
+        if (out.encoding) {
+            result.push(`   ╰ Encoding: ${out.encoding}`);
+        }
+        if (out.authors && out.authors.length > 0) {
+            result.push('   ╰ Author(s):');
+            for (const author of out.authors) {
+                result.push(`      ╰ ${(0, r_author_1.rAuthorInfoToReadable)(author)}`);
+            }
+        }
+        if (out.licenses && out.licenses.length > 0) {
+            result.push('   ╰ License(s):');
+            for (const license of out.licenses) {
+                result.push(`      ╰ ${JSON.stringify(license)}`);
+            }
+        }
+        result.push(`   ╰ Dataflow Analysis considered ${out.files.length} file${out.files.length === 1 ? '' : 's'}`);
+        for (const file of out.files.slice(0, 20)) {
             result.push(`      ╰ \`${file}\``);
         }
+        if (out.files.length > 20) {
+            result.push(`      ╰ ... and ${out.files.length - 20} more files`);
+        }
         return true;
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('project').required().description('The type of the query.'),
+        withDf: joi_1.default.boolean().optional().default(false).description('Whether to include Dataflow information in the result.')
     }).description('The project query provides information on the analyzed project.'),
     flattenInvolvedNodes: () => []
 };

package/queries/query-print.js

@@ -23,7 +23,7 @@ function nodeString(nodeId, formatter, idMap) {
 }
 function asciiCallContextSubHit(formatter, results, idMap) {
     const result = [];
-    for (const { id, calls = [], linkedIds = [], aliasRoots = [] } of results) {
+    for (const { id, calls = [], linkedIds = [], aliasRoots = [] } of results.slice(0, 20)) {
         const node = idMap.get(id);
         if (node === undefined) {
             result.push(` ${(0, ansi_1.bold)('UNKNOWN: ' + JSON.stringify({ calls, linkedIds }))}`);
@@ -41,6 +41,9 @@ function asciiCallContextSubHit(formatter, results, idMap) {
         }
         result.push(line);
     }
+    if (results.length > 20) {
+        result.push(` ... and ${results.length - 20} more hits`);
+    }
     return result.join(', ');
 }
 /**
@@ -50,9 +53,11 @@ function asciiCallContext(formatter, results, idMap) {
     /* traverse over 'kinds' and within them 'subkinds' */
     const result = [];
     for (const [kind, { subkinds }] of Object.entries(results['kinds'])) {
-        result.push(`   ╰ ${(0, ansi_1.bold)(kind, formatter)}`);
+        const amountOfHits = Object.values(subkinds).reduce((acc, cur) => acc + cur.length, 0);
+        result.push(`   ╰ ${(0, ansi_1.bold)(kind, formatter)} (${amountOfHits} hit${amountOfHits === 1 ? '' : 's'}):`);
         for (const [subkind, values] of Object.entries(subkinds)) {
-            result.push(`     ╰ ${(0, ansi_1.bold)(subkind, formatter)}: ${asciiCallContextSubHit(formatter, values, idMap)}`);
+            const amountOfSubHits = values.length;
+            result.push(`     ╰ ${(0, ansi_1.bold)(subkind, formatter)} (${amountOfSubHits} hit${amountOfSubHits === 1 ? '' : 's'}): ${asciiCallContextSubHit(formatter, values, idMap)}`);
         }
     }
     return result.join('\n');

package/util/mermaid/cfg.d.ts

@@ -7,6 +7,9 @@ import { type MermaidGraphPrinterInfo } from './info';
  * @param normalizedAst    - The normalized AST to use for the vertex content.
  * @param prefix           - The prefix to use for the mermaid string.
  * @param simplify         - Whether to simplify the control flow graph (especially in the context of basic blocks).
+ * @param markStyle        - The style to use for marked vertices and edges.
+ * @param includeOnlyIds   - If provided, only include the vertices with the given IDs.
+ * @param mark             - If provided, mark the given vertices and edges.
  */
 export declare function cfgToMermaid(cfg: ControlFlowInformation, normalizedAst: NormalizedAst, { prefix, simplify, markStyle, includeOnlyIds, mark }?: MermaidGraphPrinterInfo): string;
 /**

package/util/mermaid/cfg.js

@@ -8,6 +8,7 @@ const control_flow_graph_1 = require("../../control-flow/control-flow-graph");
 const reconstruct_1 = require("../../reconstruct/reconstruct");
 const auto_select_defaults_1 = require("../../reconstruct/auto-select/auto-select-defaults");
 const info_1 = require("./info");
+const collect_1 = require("../../r-bridge/lang-4.x/ast/model/collect");
 function getLexeme(n) {
     return n ? n.info.fullLexeme ?? n.lexeme ?? '' : undefined;
 }
@@ -30,9 +31,33 @@ const getDirRegex = /flowchart\s+([A-Za-z]+)/;
  * @param normalizedAst    - The normalized AST to use for the vertex content.
  * @param prefix           - The prefix to use for the mermaid string.
  * @param simplify         - Whether to simplify the control flow graph (especially in the context of basic blocks).
+ * @param markStyle        - The style to use for marked vertices and edges.
+ * @param includeOnlyIds   - If provided, only include the vertices with the given IDs.
+ * @param mark             - If provided, mark the given vertices and edges.
  */
 function cfgToMermaid(cfg, normalizedAst, { prefix = 'flowchart BT\n', simplify = false, markStyle = info_1.MermaidDefaultMarkStyle, includeOnlyIds, mark } = {}) {
     let output = prefix;
+    if (includeOnlyIds) {
+        const completed = new Set(includeOnlyIds);
+        // foreach nast id we add all children
+        for (const id of includeOnlyIds.values()) {
+            const nastNode = normalizedAst.idMap.get(id);
+            if (!nastNode) {
+                continue;
+            }
+            const ids = (0, collect_1.collectAllIds)(nastNode);
+            for (const childId of ids) {
+                completed.add(childId);
+            }
+        }
+        // if we have a filter, we automatically add all vertices in the cfg that are *markers* for these ids and
+        for (const [id, v] of cfg.graph.vertices()) {
+            if (v.type === control_flow_graph_1.CfgVertexType.EndMarker && completed.has(v.root)) {
+                completed.add(id);
+            }
+        }
+        includeOnlyIds = completed;
+    }
     const dirIs = getDirRegex.exec(prefix)?.at(1) ?? 'LR';
     for (const [id, vertex] of cfg.graph.vertices(false)) {
         const normalizedVertex = normalizedAst?.idMap.get(id);

package/util/r-author.d.ts

@@ -0,0 +1,39 @@
+/** https://r-pkgs.org/description.html#sec-description-authors-at-r */
+export declare enum AuthorRole {
+    /** the creator or maintainer, the person you should bother if you have problems. Despite being short for “creator”, this is the correct role to use for the current maintainer, even if they are not the initial creator of the package. */
+    Creator = "cre",
+    /** authors, those who have made significant contributions to the package. */
+    Author = "aut",
+    /** contributors, those who have made smaller contributions, like patches. */
+    Contributor = "ctb",
+    /**  copyright holder. This is used to list additional copyright holders who are not authors, typically companies, like an employer of one or more of the authors. */
+    CopyrightHolder = "cph",
+    /** funder, the people or organizations that have provided financial support for the development of the package. */
+    Funder = "fnd"
+}
+/**
+ * Information about an author.
+ * See {@link parseRAuthorString} for parsing R `Authors@R` strings, and {@link rAuthorInfoToReadable} for printing them.
+ */
+export interface RAuthorInfo {
+    /** The name (components) of the author. */
+    readonly name: string[];
+    /** The email of the author, if available. */
+    readonly email?: string;
+    /** The roles of the author in the project. */
+    readonly roles: AuthorRole[];
+    /** The ORCID of the author, if available. */
+    readonly orcid?: string;
+    /** Any additional comments about the author. */
+    readonly comment?: string[];
+}
+/**
+ * Convert structured R author information into an R `Authors@R` string.
+ */
+export declare function rAuthorInfoToReadable(author: RAuthorInfo): string;
+/**
+ * Parse an R `Authors@R` string into structured author information.
+ * These are mostly found in `R` DESCRIPTION files and are a vector of `person()` calls.
+ * For now, this works *without* the full dataflow engine, so complex cases may not be parsed correctly.
+ */
+export declare function parseRAuthorString(authorString: string): RAuthorInfo[];

package/util/r-author.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorRole = void 0;
+exports.rAuthorInfoToReadable = rAuthorInfoToReadable;
+exports.parseRAuthorString = parseRAuthorString;
+const args_1 = require("./text/args");
+const assert_1 = require("./assert");
+const objects_1 = require("./objects");
+const retriever_1 = require("../r-bridge/retriever");
+/** https://r-pkgs.org/description.html#sec-description-authors-at-r */
+var AuthorRole;
+(function (AuthorRole) {
+    /** the creator or maintainer, the person you should bother if you have problems. Despite being short for “creator”, this is the correct role to use for the current maintainer, even if they are not the initial creator of the package. */
+    AuthorRole["Creator"] = "cre";
+    /** authors, those who have made significant contributions to the package. */
+    AuthorRole["Author"] = "aut";
+    /** contributors, those who have made smaller contributions, like patches. */
+    AuthorRole["Contributor"] = "ctb";
+    /**  copyright holder. This is used to list additional copyright holders who are not authors, typically companies, like an employer of one or more of the authors. */
+    AuthorRole["CopyrightHolder"] = "cph";
+    /** funder, the people or organizations that have provided financial support for the development of the package. */
+    AuthorRole["Funder"] = "fnd";
+})(AuthorRole || (exports.AuthorRole = AuthorRole = {}));
+/**
+ * Convert structured R author information into an R `Authors@R` string.
+ */
+function rAuthorInfoToReadable(author) {
+    const nameStr = author.name.join(' ');
+    const emailStr = author.email ? ` <${author.email}>` : '';
+    const rolesStr = author.roles.length > 0 ? ` [${author.roles.join(', ')}]` : '';
+    const orcidStr = author.orcid ? ` (ORCID: ${author.orcid})` : '';
+    const commentStr = author.comment && author.comment.length > 0 ? ` {${author.comment.join('; ')}}` : '';
+    return `${nameStr}${emailStr}${rolesStr}${orcidStr}${commentStr}`;
+}
+/**
+ * Parse an R `Authors@R` string into structured author information.
+ * These are mostly found in `R` DESCRIPTION files and are a vector of `person()` calls.
+ * For now, this works *without* the full dataflow engine, so complex cases may not be parsed correctly.
+ */
+function parseRAuthorString(authorString) {
+    const str = authorString.trim();
+    if (str.startsWith('c(') && str.endsWith(')')) {
+        const inner = str.slice(2, -1).trim();
+        const parts = joinPartsWithVectors((0, args_1.splitAtEscapeSensitive)(inner, false, ','));
+        const authors = [];
+        for (const part of parts) {
+            const author = parseRPersonCall(part);
+            if (author) {
+                authors.push(author);
+            }
+        }
+        return authors;
+    }
+    else if (str.startsWith('person(') && str.endsWith(')')) {
+        const author = parseRPersonCall(str);
+        return author ? [author] : [];
+    }
+    return [];
+}
+function splitArgNameValue(arg) {
+    const eqIndex = arg.indexOf('=');
+    if (eqIndex === -1) {
+        const trimmedArg = arg.trim();
+        return { value: trimmedArg.length === 0 ? undefined : trimmedArg };
+    }
+    else {
+        const name = arg.slice(0, eqIndex).trim();
+        const value = arg.slice(eqIndex + 1).trim();
+        return { name, value };
+    }
+}
+// Joins parts that may be split by c(...) vectors back together, ...
+function joinPartsWithVectors(parts) {
+    const result = [];
+    let buffer = [];
+    let parenthesisLevel = 0;
+    for (const part of parts) {
+        const trimmed = part.trim();
+        // check whether parenthesis are balanced
+        for (const char of trimmed) {
+            if (char === '(') {
+                parenthesisLevel++;
+            }
+            else if (char === ')') {
+                parenthesisLevel--;
+            }
+        }
+        if (parenthesisLevel === 0) {
+            buffer.push(trimmed);
+            result.push(buffer.join(', '));
+            buffer = [];
+        }
+        else {
+            buffer.push(trimmed);
+        }
+    }
+    if (buffer.length > 0) {
+        result.push(buffer.join(', '));
+    }
+    return result;
+}
+const defaultPosArgNames = ['given', 'family', 'middle', 'email', 'role', 'comment', 'first', 'last'];
+function splitVector(roleStr) {
+    if (roleStr.startsWith('c(') && roleStr.endsWith(')')) {
+        const inner = roleStr.slice(2, -1).trim();
+        return joinPartsWithVectors((0, args_1.splitAtEscapeSensitive)(inner, false, ','));
+    }
+    else {
+        return [roleStr.trim()];
+    }
+}
+function parseRoles(roleStr) {
+    if (!roleStr) {
+        return [];
+    }
+    const roles = [];
+    const parts = splitVector(roleStr);
+    for (const part of parts) {
+        const trimmed = part.trim();
+        const roleValue = (0, retriever_1.removeRQuotes)(trimmed);
+        if (Object.values(AuthorRole).includes(roleValue)) {
+            roles.push(roleValue);
+        }
+    }
+    return roles;
+}
+function parseComments(commentStr) {
+    if (!commentStr) {
+        return undefined;
+    }
+    const comments = [];
+    const parts = splitVector(commentStr);
+    let orcid = undefined;
+    for (const part of parts) {
+        const trimmed = part.trim();
+        const commentValue = (0, retriever_1.removeRQuotes)(trimmed);
+        if (/ORCID\s*=/ig.test(commentValue)) {
+            const orcidIndex = commentValue.indexOf('=');
+            if (orcidIndex !== -1) {
+                orcid = (0, retriever_1.removeRQuotes)(commentValue.slice(orcidIndex + 1).trim());
+            }
+            continue;
+        }
+        comments.push(commentValue);
+    }
+    return comments.length > 0 || orcid ? { contents: comments, orcid: orcid } : undefined;
+}
+function assignArg(argMap, split) {
+    argMap.set(split.name, split.value === undefined || split.value?.length === 0 ? undefined : (0, retriever_1.removeRQuotes)(split.value));
+}
+function parseRPersonCall(personCall) {
+    /* function(given = NULL, family = NULL, middle = NULL,
+         email = NULL, role = NULL, comment = NULL,
+         first = NULL, last = NULL), but we neither use nor support full R semantics here for now */
+    personCall = personCall.trim();
+    if (!personCall.startsWith('person(') || !personCall.endsWith(')')) {
+        return undefined;
+    }
+    const inner = personCall.slice(7, -1).trim();
+    // these may also split unescaped commas inside c(...)
+    const parArgs = joinPartsWithVectors((0, args_1.splitAtEscapeSensitive)(inner, false, ','));
+    const argMap = new Map();
+    const unnamed = [];
+    for (const arg of parArgs) {
+        const split = splitArgNameValue(arg.trim());
+        if (!split.name) {
+            unnamed.push(arg.trim());
+            continue;
+        }
+        assignArg(argMap, split);
+    }
+    // assign unnamed args in order
+    for (let i = 0; i < unnamed.length; i++) {
+        if (i >= defaultPosArgNames.length) {
+            break;
+        }
+        const argIdx = defaultPosArgNames.findIndex(x => !argMap.has(x));
+        if (argIdx === -1) {
+            break;
+        }
+        const argName = defaultPosArgNames[argIdx];
+        const value = unnamed[i];
+        assignArg(argMap, { name: argName, value });
+    }
+    const comments = parseComments(argMap.get('comment'));
+    return (0, objects_1.compactRecord)({
+        name: [argMap.get('given') ?? argMap.get('first'), argMap.get('middle'), argMap.get('family') ?? argMap.get('last')].filter(assert_1.isNotUndefined),
+        email: argMap.get('email'),
+        roles: parseRoles(argMap.get('role')),
+        comment: comments?.contents,
+        orcid: comments?.orcid
+    });
+}
+//# sourceMappingURL=r-author.js.map

package/util/r-license.d.ts

@@ -0,0 +1,23 @@
+import { Range } from 'semver';
+export interface RLicenseInfo {
+    type: 'license';
+    license: string;
+    versionConstraint?: Range;
+}
+export interface RLicenseExceptionInfo {
+    type: 'exception';
+    exception: string;
+}
+export interface RLicenseCombinationInfo {
+    type: 'combination';
+    combination: 'and' | 'or' | 'with';
+    elements: [left: RLicenseElementInfo, right: RLicenseElementInfo];
+}
+export interface NoLicenseInfo {
+    type: 'no-license';
+}
+export type RLicenseElementInfo = RLicenseInfo | RLicenseExceptionInfo | RLicenseCombinationInfo | NoLicenseInfo;
+/**
+ * Parses an R license string into its structured representation.
+ */
+export declare function parseRLicense(licenseString: string): RLicenseElementInfo;