@eagleoutice/flowr 2.7.5 → 2.8.0

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

@@ -0,0 +1,32 @@
+import type { 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';
+}
+/**
+ * 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

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRLicense = parseRLicense;
+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) {
+    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);
+    if (info.remInput.length === 0) {
+        return { ...info, element: { type: 'no-license' } };
+    }
+    else if (info.remInput.startsWith('(')) {
+        return parseParenthesizedExpression(info);
+    }
+    else {
+        return parseBinaryOperator(info);
+    }
+}
+function parseParenthesizedExpression(info) {
+    const openParen = consumeString(info, '(');
+    (0, assert_1.guard)(openParen.element, `Expected (, but found ${info.remInput[0]} at position ${info.position}`);
+    const innerInfo = parseLicenseInfo(openParen);
+    const closeParen = consumeString(innerInfo, ')');
+    (0, assert_1.guard)(closeParen.element, `Expected ), but found ${innerInfo.remInput[0]} at position ${innerInfo.position}`);
+    return { ...closeParen, element: innerInfo.element };
+}
+function skipWhitespace({ remInput, position }) {
+    let idx = remInput.search(/\S/);
+    if (idx === -1) {
+        idx = remInput.length;
+    }
+    position += idx;
+    remInput = remInput.slice(idx);
+    return { position, remInput };
+}
+function consumeLicenseName(info) {
+    info = skipWhitespace(info);
+    let licenseName = '';
+    let isAtWhitespace = false;
+    for (let i = 0; i < info.remInput.length; i++) {
+        const char = info.remInput[i];
+        if (/[()<>~!=,&|+]/.test(char)) {
+            break;
+        }
+        else {
+            isAtWhitespace = /\s/.test(char);
+        }
+        if (isAtWhitespace) {
+            if (/^\s*(with|and|or)\s+/i.test(info.remInput.slice(i))) {
+                break;
+            }
+        }
+        licenseName += char;
+    }
+    const newInfo = {
+        position: info.position + licenseName.length,
+        remInput: info.remInput.slice(licenseName.length)
+    };
+    // file licenses are a special case!
+    if (licenseName && /^file[\s-]+license$/i.test(licenseName.trim())) {
+        return { ...newInfo, element: 'file LICENSE' };
+    }
+    return { ...newInfo, element: licenseName?.trim() ?? '' };
+}
+function makeRange(rangeStr) {
+    try {
+        return (0, r_version_1.parseRRange)(rangeStr);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseLicenseElement(info) {
+    const licenseName = consumeLicenseName(info);
+    info = skipWhitespace(licenseName);
+    // may be followed by version constraint in parentheses or directly
+    let versionConstraint;
+    if (/^\(\s*?[\d<>=!~]/.test(info.remInput)) {
+        // version constraint
+        if (info.remInput.startsWith('(')) {
+            const openParen = consumeString(info, '(');
+            (0, assert_1.guard)(openParen.element, `Expected (, but found ${info.remInput[0]} at position ${info.position}`);
+            info = skipWhitespace(openParen);
+            // consume until closing parenthesis
+            const versionStr = consumeUntilString(info, ')');
+            versionConstraint = makeRange(versionStr.element);
+            const closeParen = consumeString(versionStr, ')');
+            (0, assert_1.guard)(closeParen.element, `Expected ), but found ${versionStr.remInput[0]} at position ${versionStr.position}`);
+            info = skipWhitespace(closeParen);
+        }
+        else {
+            // consume until whitespace or special character
+            const versionStr = consumeRegexp(info, /^[\d<>=!~.\s]+/);
+            versionConstraint = versionStr.element ? makeRange(versionStr.element) : undefined;
+            info = skipWhitespace(versionStr);
+        }
+    }
+    const licenseInfo = (0, objects_1.compactRecord)({
+        type: 'license',
+        license: licenseName.element,
+        versionConstraint
+    });
+    return { ...info, element: licenseInfo };
+}
+const operators = {
+    'and': ['and', '+', '&'],
+    'or': ['or', '|'],
+    'with': ['with']
+};
+function parseBinaryOperator(info) {
+    const license = parseLicenseElement(info);
+    info = skipWhitespace(license);
+    const operator = tryConsumeOperator(info);
+    if (operator.element) {
+        info = skipWhitespace(operator);
+        let rightLicense = parseLicenseInfo(info);
+        if (operator.element === 'with' && rightLicense.element.type === 'license') {
+            rightLicense = {
+                ...rightLicense,
+                element: {
+                    type: 'exception',
+                    exception: rightLicense.element.license
+                }
+            };
+        }
+        const combination = {
+            type: 'combination',
+            combination: operator.element,
+            elements: [license.element, rightLicense.element]
+        };
+        return { ...rightLicense, element: combination };
+    }
+    return { ...info, element: license.element };
+}
+function tryConsumeOperator(info) {
+    for (const [opName, opSymbols] of Object.entries(operators)) {
+        for (const symbol of opSymbols) {
+            if (info.remInput.toLowerCase().startsWith(symbol)) {
+                const newInfo = {
+                    position: info.position + symbol.length,
+                    remInput: info.remInput.slice(symbol.length)
+                };
+                return { ...newInfo, element: opName };
+            }
+        }
+    }
+    return { ...info, element: undefined };
+}
+function consumeString(info, str) {
+    info = skipWhitespace(info);
+    if (info.remInput.startsWith(str)) {
+        const newInfo = {
+            position: info.position + str.length,
+            remInput: info.remInput.slice(str.length)
+        };
+        return { ...newInfo, element: true };
+    }
+    else {
+        return { ...info, element: false };
+    }
+}
+function consumeUntilString(info, str) {
+    let idx = info.remInput.indexOf(str);
+    if (idx === -1) {
+        idx = info.remInput.length;
+    }
+    const consumed = info.remInput.slice(0, idx);
+    const newInfo = {
+        position: info.position + idx,
+        remInput: info.remInput.slice(idx)
+    };
+    return { ...newInfo, element: consumed };
+}
+function consumeRegexp(info, regex) {
+    info = skipWhitespace(info);
+    const match = info.remInput.match(regex);
+    if (match && match.index === 0) {
+        const matchedStr = match[0];
+        const newInfo = {
+            position: info.position + matchedStr.length,
+            remInput: info.remInput.slice(matchedStr.length)
+        };
+        return { ...newInfo, element: matchedStr };
+    }
+    return { ...info, element: null };
+}
+//# sourceMappingURL=r-license.js.map

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;
+};

package/util/r-version.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRVersion = parseRVersion;
+exports.parseRRange = parseRRange;
+const semver_1 = require("semver");
+const assert_1 = require("./assert");
+function makeVersion(version, original) {
+    const semver = new semver_1.SemVer(version);
+    semver.str = original;
+    return semver;
+}
+/**
+ * Additionally, this transforms `a-b.c` into `a.0.0-b.c` and `a.b-c.d` into `a.b.0-c.d` to
+ * ensure valid SemVer format.
+ */
+function normalizeTooShortVersions(versions) {
+    const TooShortVersionRegex = /(^|(?<=[^\d.-]))(?<major>\d+)(\.(?<minor>\d+))?\.?-(?<prerelease>[0-9A-Za-z-.]+)(\s|$)/g;
+    let newVersions = '';
+    let match;
+    while ((match = TooShortVersionRegex.exec(versions)) !== null) {
+        const { major, minor, prerelease } = match.groups;
+        const prefix = versions.slice(0, match.index);
+        let newVersion = '';
+        if (minor === undefined) {
+            // only major version present
+            newVersion = `${major}.0.0-${prerelease}`;
+        }
+        else {
+            // major and minor version present, but dot before prerelease
+            newVersion = `${major}.${minor}.0-${prerelease}`;
+        }
+        newVersions += `${prefix}${newVersion}`;
+        versions = versions.slice(match.index + match[0].length);
+    }
+    newVersions += versions; // append any remaining part
+    return newVersions;
+}
+/**
+ * For every version `a.b.c.d.e...` converts it to `a.b.c-d.e...`
+ * If the version already contains a prerelease part, it is appended:
+ * `a.b.c.d.e-prerelease...` becomes `a.b.c-d.e-prerelease...`
+ */
+function normalizeAdditionalVersionsToPrerelease(version) {
+    version = normalizeTooShortVersions(version);
+    const AdditionalVersionRegex = /(\d+\.\d+\.\d+)(?<additional>(\.\d+)+)(-(?<prerelease>[0-9A-Za-z-.]+))?/g;
+    let match;
+    let newVersion = '';
+    // repeat until no more matches
+    while ((match = AdditionalVersionRegex.exec(version)) !== null) {
+        // append to new version, first take over anything before the match
+        const prefix = version.slice(0, match.index);
+        const { additional, prerelease } = match.groups;
+        const additionalParts = additional.slice(1).split('.'); // remove leading dot and split
+        if (additionalParts.length === 0) {
+            continue; // nothing to do
+        }
+        let newPrerelease = additionalParts.join('.');
+        if (prerelease) {
+            newPrerelease = `${newPrerelease}-${prerelease}`;
+        }
+        newVersion = `${prefix}${match[1]}-${newPrerelease}`;
+        version = version.slice(match.index + match[0].length);
+    }
+    newVersion += version; // append any remaining part
+    return newVersion;
+}
+/**
+ * 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.
+ */
+function parseRVersion(version) {
+    try {
+        return makeVersion(version, version);
+    }
+    catch { /* do nothing */ }
+    try {
+        const normalized = normalizeAdditionalVersionsToPrerelease(version);
+        return makeVersion(normalized, version);
+    }
+    catch { /* do nothing */ }
+    const coerced = (0, semver_1.coerce)(version, { loose: true, includePrerelease: true });
+    (0, assert_1.guard)(coerced !== null, `Could not coerce R version "${version}" to SemVer`);
+    return makeVersion(coerced.version, version);
+}
+function makeRange(range, original) {
+    const semverRange = new semver_1.Range(range);
+    semverRange.str = original;
+    return semverRange;
+}
+/**
+ * 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.
+ */
+function parseRRange(range) {
+    try {
+        return makeRange(range, range);
+    }
+    catch { /* try to normalize R range to SemVer */ }
+    const normalized = normalizeAdditionalVersionsToPrerelease(range);
+    return makeRange(normalized.replace(/==/g, '='), range);
+}
+//# sourceMappingURL=r-version.js.map

package/util/range.d.ts

@@ -43,6 +43,10 @@ export declare function getRangeEnd(p: SourceRange | undefined): SourcePosition
  * @param ec - end column
  */
 export declare function rangeFrom(sl: number | string, sc: number | string, el: number | string, ec: number | string): SourceRange;
+/**
+ * @returns an invalid source range
+ */
+export declare function invalidRange(): SourceRange;
 /**
  * Merges multiple source ranges into a single source range that spans from the earliest start to the latest end.
  * If you are interested in combining overlapping ranges into a minimal set of ranges, see {@link combineRanges}.
@@ -75,3 +79,5 @@ export declare function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec]: SourceRange, [
  * If you are interested in merging overlapping ranges, see {@link mergeRanges}.
  */
 export declare function combineRanges(...ranges: SourceRange[]): SourceRange[];
+/** A source location consisting of a source range and an optional file name. */
+export type SourceLocation = [...r: SourceRange, f?: string];

package/util/range.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRangeStart = getRangeStart;
 exports.getRangeEnd = getRangeEnd;
 exports.rangeFrom = rangeFrom;
+exports.invalidRange = invalidRange;
 exports.mergeRanges = mergeRanges;
 exports.rangeStartsCompletelyBefore = rangeStartsCompletelyBefore;
 exports.rangesOverlap = rangesOverlap;
@@ -33,6 +34,12 @@ function getRangeEnd(p) {
 function rangeFrom(sl, sc, el, ec) {
     return [Number(sl), Number(sc), Number(el), Number(ec)];
 }
+/**
+ * @returns an invalid source range
+ */
+function invalidRange() {
+    return [-1, -1, -1, -1];
+}
 /**
  * Merges multiple source ranges into a single source range that spans from the earliest start to the latest end.
  * If you are interested in combining overlapping ranges into a minimal set of ranges, see {@link combineRanges}.

package/util/simple-df/dfg-ascii.js

@@ -88,8 +88,8 @@ function dfgToAscii(dfg) {
         }
         g.setNode(String(id), {
             label,
-            width: Math.max(3, label.length * 2),
-            height: 3,
+            width: Math.max(3, label.length * 1.2),
+            height: 4,
             shape: 'rectangle'
         });
     }

package/util/text/args.d.ts

@@ -14,3 +14,12 @@
  * @param split       - The character or character sequence to split on (can not be backslash or quote!)
  */
 export declare function splitAtEscapeSensitive(inputString: string, escapeQuote?: boolean, split?: RegExp | string): string[];
+/**
+ * Splits the given string on 'and', but only if not nested inside `<>`, `[]`, `()`, or quotes.
+ * This also handles escaped quotes.
+ * @param str - The string to split
+ * @param splitOn - The string to split on (default: 'and')
+ * @param closes - The matching of closing characters for nesting, structures with different open and close characters only can be nested
+ *                 of each other, while those with the same open and close character (like quotes) can not be nested inside themselves.
+ */
+export declare function splitOnNestingSensitive(str: string, splitOn?: string, closes?: Record<string, string>): string[];