jvm-upgrade 0.1.0

package/dist/repos.js

@@ -0,0 +1,121 @@
+const GRADLE_VERSIONS_URL = 'https://services.gradle.org/versions/all';
+const gradleBuildTimes = new WeakMap();
+const publishedMemo = new WeakMap();
+export function artifactPath(group, artifact) {
+    return `${group.replaceAll('.', '/')}/${artifact}`;
+}
+export function parseMetadata(xml) {
+    const found = new Set();
+    const block = /<versions>([\s\S]*?)<\/versions>/.exec(xml)?.[1] ?? '';
+    for (const m of block.matchAll(/<version>\s*([^<\s]+)\s*<\/version>/g))
+        found.add(m[1]);
+    for (const tag of ['latest', 'release']) {
+        const m = new RegExp(`<${tag}>\\s*([^<\\s]+)\\s*</${tag}>`).exec(xml);
+        if (m)
+            found.add(m[1]);
+    }
+    return [...found];
+}
+export function parseGradleBuildTime(value) {
+    const m = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})([+-]\d{4})?$/.exec(value);
+    if (!m)
+        return undefined;
+    const [, y, mo, d, h, mi, s, tz = '+0000'] = m;
+    const date = new Date(`${y}-${mo}-${d}T${h}:${mi}:${s}${tz.slice(0, 3)}:${tz.slice(3)}`);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+function loadGradle(http) {
+    let p = gradleBuildTimes.get(http);
+    if (!p) {
+        p = (async () => {
+            const res = await http.get(GRADLE_VERSIONS_URL);
+            if (res.status !== 200)
+                throw new Error(`${GRADLE_VERSIONS_URL}: HTTP ${res.status}`);
+            const list = JSON.parse(res.body);
+            const usable = list.filter((v) => !v.snapshot && !v.nightly && !v.broken && !v.releaseNightly);
+            return new Map(usable.map((v) => [v.version, v.buildTime ?? '']));
+        })();
+        p.catch(() => gradleBuildTimes.delete(http));
+        gradleBuildTimes.set(http, p);
+    }
+    return p;
+}
+async function fetchGithubTags(http, owner, repo) {
+    const res = await http.get(`https://api.github.com/repos/${owner}/${repo}/tags?per_page=100`);
+    if (res.status !== 200)
+        return undefined;
+    const tags = JSON.parse(res.body);
+    return tags.map((t) => t.name.replace(/^v(?=\d)/i, ''));
+}
+async function versionsFromRepo(http, dep, repo) {
+    const url = `${repo}${artifactPath(dep.group, dep.artifact)}/maven-metadata.xml`;
+    const res = await http.get(url);
+    if (res.status === 200)
+        return parseMetadata(res.body);
+    if (res.status === 404) {
+        const owner = dep.group.startsWith('com.github.') ? dep.group.split('.')[2] : undefined;
+        if (repo.includes('jitpack.io') && owner) {
+            return (await fetchGithubTags(http, owner, dep.artifact)) ?? [];
+        }
+        return [];
+    }
+    throw new Error(`${url}: HTTP ${res.status}`);
+}
+export async function fetchVersions(http, dep) {
+    const repoOf = new Map();
+    if (dep.kind === 'gradle') {
+        try {
+            return { versions: [...(await loadGradle(http)).keys()], repoOf, errors: [] };
+        }
+        catch (err) {
+            return { versions: [], repoOf, errors: [errorText(err)] };
+        }
+    }
+    const results = await Promise.allSettled(dep.repositories.map((r) => versionsFromRepo(http, dep, r)));
+    const errors = [];
+    results.forEach((result, i) => {
+        const repo = dep.repositories[i];
+        if (result.status === 'rejected') {
+            errors.push(`${repo}: ${errorText(result.reason)}`);
+            return;
+        }
+        for (const v of result.value)
+            if (!repoOf.has(v))
+                repoOf.set(v, repo);
+    });
+    return { versions: [...repoOf.keys()], repoOf, errors };
+}
+function errorText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+async function publishedAt(http, dep, version, repo) {
+    if (dep.kind === 'gradle') {
+        const time = (await loadGradle(http).catch(() => undefined))?.get(version);
+        return time ? parseGradleBuildTime(time) : undefined;
+    }
+    const base = repo ?? dep.repositories[0];
+    if (!base)
+        return undefined;
+    const url = `${base}${artifactPath(dep.group, dep.artifact)}/${version}/${dep.artifact}-${version}.pom`;
+    const res = await http.head(url).catch(() => undefined);
+    const header = res?.status === 200 ? res.headers['last-modified'] : undefined;
+    if (!header)
+        return undefined;
+    const date = new Date(header);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+export function fetchPublishedAt(http, dep, version, repo) {
+    let memo = publishedMemo.get(http);
+    if (!memo)
+        publishedMemo.set(http, (memo = new Map()));
+    const key = `${dep.kind}|${dep.group}:${dep.artifact}:${version}|${repo ?? dep.repositories[0] ?? ''}`;
+    let p = memo.get(key);
+    if (!p)
+        memo.set(key, (p = publishedAt(http, dep, version, repo)));
+    return p;
+}
+export async function fetchPom(http, group, artifact, version, repo) {
+    const url = `${repo}${artifactPath(group, artifact)}/${version}/${artifact}-${version}.pom`;
+    const res = await http.get(url).catch(() => undefined);
+    return res?.status === 200 ? res.body : undefined;
+}

package/dist/rows.js

@@ -0,0 +1,81 @@
+import { matchesAny } from './config.js';
+import { intersectVersions, pick, selectCandidates } from './policy.js';
+import { fetchPublishedAt, fetchVersions } from './repos.js';
+import { compareVersions, preferStyle, upgradeLevel } from './version.js';
+export function displayName(dep) {
+    if (dep.kind === 'plugin' && dep.artifact.endsWith('.gradle.plugin'))
+        return dep.group;
+    if (dep.kind === 'gradle')
+        return 'gradle (wrapper)';
+    return `${dep.group}:${dep.artifact}`;
+}
+export function levelColor(level) {
+    return level === 'major' ? 'red' : level === 'minor' ? 'yellow' : level === 'patch' ? 'green' : 'magenta';
+}
+/** Dependencies sharing one version literal (catalog ref, property) become one row. */
+function groupByLocation(deps) {
+    const groups = new Map();
+    for (const dep of deps) {
+        const key = dep.location
+            ? `${dep.location.file}:${dep.location.start}`
+            : `${dep.group}:${dep.artifact}:${dep.version}:${dep.file}`;
+        const list = groups.get(key) ?? [];
+        list.push(dep);
+        groups.set(key, list);
+    }
+    return [...groups.values()];
+}
+export async function buildRows(deps, opts) {
+    const filtered = [];
+    for (const dep of deps) {
+        const options = await opts.optionsFor(dep.file);
+        if (options.include.length && !matchesAny(options.include, dep.group, dep.artifact))
+            continue;
+        if (matchesAny(options.exclude, dep.group, dep.artifact))
+            continue;
+        filtered.push({ dep, options });
+    }
+    const optionsOf = new Map(filtered.map((f) => [f.dep, f.options]));
+    const groups = groupByLocation(filtered.map((f) => f.dep));
+    opts.progress.total(groups.length);
+    return Promise.all(groups.map(async (group) => {
+        try {
+            return await buildRow(group, optionsOf.get(group[0]), opts);
+        }
+        finally {
+            opts.progress.tick();
+        }
+    }));
+}
+async function buildRow(group, options, opts) {
+    const first = group[0];
+    const extra = first.kind === 'gradle' ? [] : [...opts.extraRepositories, ...options.repositories].map((r) => (r.endsWith('/') ? r : `${r}/`));
+    const results = await Promise.all(group.map((dep) => fetchVersions(opts.http, { ...dep, repositories: [...new Set([...dep.repositories, ...extra])] })));
+    const errors = [...new Set(results.flatMap((r) => r.errors))];
+    const repoOf = results[0].repoOf;
+    const versions = preferStyle(first.version, intersectVersions(results.map((r) => r.versions)));
+    const name = group.length > 1 ? `${displayName(first)} (+${group.length - 1})` : displayName(first);
+    const candidates = await selectCandidates(first.version, versions, { target: options.target, pre: options.pre, cooldownDays: options.cooldown, allowDowngrade: options.allowDowngrade, now: opts.now }, (v) => fetchPublishedAt(opts.http, first, v, repoOf.get(v)));
+    const choices = toChoices(first.version, candidates);
+    const wanted = candidates.downgrade ?? pick(candidates, options.target);
+    const selected = wanted === undefined ? undefined : choices.findIndex((c) => c.version === wanted);
+    return { name, deps: group, current: first.version, location: first.location, choices, selected: selected === -1 ? undefined : selected, repoOf, errors };
+}
+export function toChoices(current, c) {
+    const seen = new Set();
+    const choices = [];
+    if (c.downgrade) {
+        choices.push({ level: 'downgrade', version: c.downgrade });
+        seen.add(c.downgrade);
+    }
+    for (const v of [c.patch, c.minor, c.major]) {
+        if (!v || seen.has(v))
+            continue;
+        const level = upgradeLevel(current, v);
+        if (!level)
+            continue;
+        seen.add(v);
+        choices.push({ level, version: v });
+    }
+    return choices.sort((a, b) => compareVersions(a.version, b.version));
+}

package/dist/scan/gradle.js

@@ -0,0 +1,454 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { dedupeRepos, GOOGLE, GRADLE_PLUGIN_PORTAL, MAVEN_CENTRAL, NAMED_REPOS } from './repos.js';
+const COORD_RE = /(["'])([\w.\-]+):([\w.\-]+):([^"'\s@:]+)(?::[\w.\-]+)?(?:@\w+)?\1/dg;
+const MAP_RE = /\bgroup\s*[:=]\s*(["'])([^"']+)\1\s*,\s*name\s*[:=]\s*(["'])([^"']+)\3\s*,\s*version\s*[:=]\s*(?:(["'])([^"']*)\5|([A-Za-z_][\w.]*))/dg;
+const KOTLIN_DEP_RE = /\bkotlin\s*\(\s*"([\w\-]+)"\s*,\s*(?:version\s*=\s*)?"([^"]*)"\s*\)/dg;
+const PLUGIN_RE = /\b(id|kotlin)\s*\(?\s*(["'])([\w.\-]+)\2\s*\)?\s*\.?\s*version\s*\(?\s*(?:(["'])([^"']*)\4|([A-Za-z_][\w.]*(?:\(\))?))/dg;
+const REPO_RE = /\b(mavenCentral|google|gradlePluginPortal|jcenter|mavenLocal)\s*[({]|\bmaven\s*\(\s*(?:url\s*=\s*)?(?:uri\s*\(\s*)?["']([^"'$]+)["']|\b(?:url|setUrl)\s*(?:=\s*)?\(?\s*(?:uri\s*\(\s*)?["']([^"'$]+)["']/g;
+const CATALOG_RE = /(?:create\s*\(\s*["'](\w+)["']\s*\)|(\w+))\s*\{[^{}]*?\bfrom\s*\(\s*files\s*\(\s*["']([^"']+)["']/g;
+const VAR_RES = [
+    /\b(?:ext|extra)\.(\w+)\s*=\s*(["'])([^"'$\n]*)\2/dg,
+    /\b(?:ext|extra)\.set\s*\(\s*["'](\w+)["']\s*,\s*(["'])([^"'$\n]*)\2/dg,
+    /\bextra\s*\[\s*["'](\w+)["']\s*\]\s*=\s*(["'])([^"'$\n]*)\2/dg,
+    /\b(?:val|var|def|String)\s+(\w+)\s*(?::\s*String\s*)?(?:=|by\s+extra\s*\()\s*(["'])([^"'$\n]*)\2/dg,
+];
+const EXT_BLOCK_RES = [
+    /(?<![\w.])(\w+)\s*=\s*(["'])([^"'$\n]*)\2/dg,
+    /\bset\s*\(\s*["'](\w+)["']\s*,\s*(["'])([^"'$\n]*)\2/dg,
+];
+const PROPERTY_RE = /^[ \t]*([\w.\-]+)[ \t]*[=:][ \t]*(.*?)[ \t]*\r?$/dgm;
+const WRAPPER_RE = /distributionUrl\s*[=:].*?gradle-([\w.\-]+?)-(?:bin|all)\.zip/d;
+export function isDynamic(version) {
+    return version === '' || /[+\[\]()*,]|^latest\./.test(version);
+}
+export function stripCode(src) {
+    const out = src.split('');
+    const blank = (from, to) => {
+        for (let k = from; k < to; k++)
+            if (src[k] !== '\n')
+                out[k] = ' ';
+    };
+    let i = 0;
+    while (i < src.length) {
+        if (src.startsWith('//', i)) {
+            const end = src.indexOf('\n', i);
+            blank(i, (i = end < 0 ? src.length : end));
+        }
+        else if (src.startsWith('/*', i)) {
+            const close = src.indexOf('*/', i + 2);
+            blank(i, (i = close < 0 ? src.length : close + 2));
+        }
+        else if (src[i] === '"' || src[i] === "'") {
+            i = skipString(src, i);
+        }
+        else {
+            i++;
+        }
+    }
+    return out.join('');
+}
+function skipString(src, i) {
+    const quote = src[i];
+    const delim = src.startsWith(quote.repeat(3), i) ? quote.repeat(3) : quote;
+    let j = i + delim.length;
+    while (j < src.length) {
+        if (src[j] === '\\')
+            j += 2;
+        else if (src.startsWith(delim, j))
+            return j + delim.length;
+        else if (delim.length === 1 && src[j] === '\n')
+            return j;
+        else
+            j++;
+    }
+    return j;
+}
+export function stripToml(src) {
+    const out = src.split('');
+    let quote;
+    for (let i = 0; i < src.length; i++) {
+        const c = src[i];
+        if (quote) {
+            if (c === '\\' && quote === '"')
+                i++;
+            else if (c === quote || c === '\n')
+                quote = undefined;
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+        }
+        else if (c === '#') {
+            for (; i < src.length && src[i] !== '\n'; i++)
+                out[i] = ' ';
+        }
+    }
+    return out.join('');
+}
+export function stripProperties(src) {
+    return src.replace(/^[ \t]*[#!].*$/gm, (line) => ' '.repeat(line.length));
+}
+async function readSource(file, strip) {
+    try {
+        const content = await readFile(file, 'utf8');
+        return { file, content, code: strip(content) };
+    }
+    catch {
+        return undefined;
+    }
+}
+function findBlocks(code, name) {
+    const re = new RegExp(`\\b${name}\\s*(?:\\([^()]*\\))?\\s*\\{`, 'g');
+    return [...code.matchAll(re)].map((m) => {
+        const open = m.index + m[0].length - 1;
+        return { start: open + 1, end: matchBrace(code, open) };
+    });
+}
+function matchBrace(code, open) {
+    let depth = 0;
+    for (let i = open; i < code.length; i++) {
+        if (code[i] === '{')
+            depth++;
+        else if (code[i] === '}' && --depth === 0)
+            return i;
+    }
+    return code.length;
+}
+function within(pos, spans) {
+    return spans.some((s) => pos >= s.start && pos < s.end);
+}
+function matchesIn(code, re, spans) {
+    return [...code.matchAll(re)].filter((m) => !spans || within(m.index, spans));
+}
+function locOf(src, m, group) {
+    const [start, end] = m.indices[group];
+    return { file: src.file, start, end };
+}
+function reposIn(code, spans) {
+    const urls = [];
+    for (const span of spans) {
+        for (const m of code.slice(span.start, span.end).matchAll(REPO_RE)) {
+            urls.push(m[1] ? NAMED_REPOS[m[1]]() : (m[2] ?? m[3]));
+        }
+    }
+    return dedupeRepos(urls);
+}
+function reposWithin(src, outer) {
+    const outerSpans = findBlocks(src.code, outer);
+    return reposIn(src.code, findBlocks(src.code, 'repositories').filter((s) => within(s.start, outerSpans)));
+}
+function buildFileRepos(src) {
+    const publishing = findBlocks(src.code, 'publishing');
+    return reposIn(src.code, findBlocks(src.code, 'repositories').filter((s) => !within(s.start, publishing)));
+}
+function collectVars(src) {
+    const vars = new Map();
+    const extBlocks = findBlocks(src.code, 'ext');
+    const matches = [
+        ...EXT_BLOCK_RES.flatMap((re) => matchesIn(src.code, re, extBlocks)),
+        ...VAR_RES.flatMap((re) => matchesIn(src.code, re)),
+    ].sort((a, b) => a.index - b.index);
+    for (const m of matches)
+        vars.set(m[1], { value: m[3], loc: locOf(src, m, 3) });
+    return vars;
+}
+function propertyVars(src) {
+    const vars = new Map();
+    for (const m of src?.code.matchAll(PROPERTY_RE) ?? []) {
+        if (m[2])
+            vars.set(m[1], { value: m[2], loc: locOf(src, m, 2) });
+    }
+    return vars;
+}
+function normKey(key) {
+    return key.replace(/[-_]/g, '.');
+}
+function lookup(scope, expr) {
+    const e = expr.trim().replace(/\.get(?:\(\))?$/, '');
+    const catalog = /^(\w+)\.versions\.([\w.]+)$/.exec(e);
+    if (catalog)
+        return scope.catalogs.get(catalog[1])?.get(normKey(catalog[2]));
+    const key = /(?:extra|properties)\s*\[\s*["']([\w.\-]+)["']\s*\]$/.exec(e)?.[1] ??
+        /property\s*\(\s*["']([\w.\-]+)["']\s*\)$/.exec(e)?.[1] ??
+        e.replace(/^(?:(?:rootProject|project|ext|extra|properties)\.)+/, '');
+    for (const vars of scope.vars) {
+        const value = vars.get(key);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+const REF_RE = /\$\{([^}]+)\}|\$([A-Za-z_][\w.]*(?:\(\))?)/g;
+function resolveVersion(raw, loc, scope) {
+    const whole = /^(?:\$\{([^}]+)\}|\$([A-Za-z_][\w.]*(?:\(\))?))$/.exec(raw);
+    let result;
+    if (whole) {
+        result = lookup(scope, (whole[1] ?? whole[2]));
+    }
+    else if (!raw.includes('$')) {
+        result = { value: raw, loc };
+    }
+    else {
+        let ok = true;
+        const value = raw.replace(REF_RE, (_, braced, bare) => {
+            const found = lookup(scope, (braced ?? bare));
+            if (!found)
+                ok = false;
+            return found?.value ?? '';
+        });
+        result = ok ? { value } : undefined;
+    }
+    return result && (isDynamic(result.value) || !result.loc) ? { value: result.value } : result;
+}
+function makeDep(kind, group, artifact, version, file, repositories) {
+    return { group, artifact, kind, version: version.value, file, repositories, ...(version.loc && { location: version.loc }) };
+}
+function addResolved(ctx, src, kind, group, artifact, raw, loc) {
+    const version = resolveVersion(raw, loc, ctx.scope);
+    if (!version) {
+        ctx.warnings.push(`${src.file}: cannot resolve version "${raw}" of ${group}:${artifact}`);
+        return;
+    }
+    ctx.out.push(makeDep(kind, group, artifact, version, src.file, ctx.repositories));
+}
+function libraryDeps(src, ctx) {
+    for (const m of src.code.matchAll(COORD_RE)) {
+        addResolved(ctx, src, 'library', m[2], m[3], m[4], locOf(src, m, 4));
+    }
+    for (const m of src.code.matchAll(MAP_RE)) {
+        if (m[6] !== undefined)
+            addResolved(ctx, src, 'library', m[2], m[4], m[6], locOf(src, m, 6));
+        else
+            addResolved(ctx, src, 'library', m[2], m[4], `\${${m[7]}}`);
+    }
+    const plugins = findBlocks(src.code, 'plugins');
+    for (const m of src.code.matchAll(KOTLIN_DEP_RE)) {
+        if (!within(m.index, plugins)) {
+            addResolved(ctx, src, 'library', 'org.jetbrains.kotlin', `kotlin-${m[1]}`, m[2], locOf(src, m, 2));
+        }
+    }
+}
+function pluginDeps(src, ctx) {
+    for (const m of matchesIn(src.code, PLUGIN_RE, findBlocks(src.code, 'plugins'))) {
+        const id = m[1] === 'kotlin' ? `org.jetbrains.kotlin.${m[3]}` : m[3];
+        if (m[5] !== undefined)
+            addResolved(ctx, src, 'plugin', id, `${id}.gradle.plugin`, m[5], locOf(src, m, 5));
+        else
+            addResolved(ctx, src, 'plugin', id, `${id}.gradle.plugin`, `\${${m[6]}}`);
+    }
+}
+export function parseToml(code) {
+    const entries = [];
+    let table = '';
+    let i = 0;
+    const skipWs = (newlines) => {
+        while (i < code.length && (code[i] === ' ' || code[i] === '\t' || code[i] === '\r' || (newlines && code[i] === '\n')))
+            i++;
+    };
+    const skipLine = () => {
+        const nl = code.indexOf('\n', i);
+        i = nl < 0 ? code.length : nl + 1;
+    };
+    const readKey = () => {
+        const key = /^(?:[\w.\-]+|"[^"\n]*"|'[^'\n]*')+/.exec(code.slice(i, i + 256))?.[0] ?? '';
+        i += key.length;
+        return key.replace(/["']/g, '');
+    };
+    const readValue = (path, fields) => {
+        const c = code[i];
+        if (c === '"' || c === "'") {
+            const start = i + 1;
+            let j = start;
+            while (j < code.length && code[j] !== c && code[j] !== '\n')
+                j += c === '"' && code[j] === '\\' ? 2 : 1;
+            fields.set(path, { value: code.slice(start, j), start, end: j });
+            i = j + 1;
+        }
+        else if (c === '{') {
+            i++;
+            for (;;) {
+                skipWs(true);
+                if (i >= code.length || code[i] === '}')
+                    break;
+                if (code[i] === ',') {
+                    i++;
+                    continue;
+                }
+                const key = readKey();
+                skipWs(false);
+                if (!key || code[i] !== '=')
+                    break;
+                i++;
+                skipWs(true);
+                readValue(path ? `${path}.${key}` : key, fields);
+            }
+            i++;
+        }
+        else if (c === '[') {
+            let depth = 0;
+            for (; i < code.length; i++) {
+                if (code[i] === '[')
+                    depth++;
+                else if (code[i] === ']' && --depth === 0)
+                    break;
+            }
+            i++;
+        }
+        else {
+            while (i < code.length && !/[\n,}]/.test(code[i]))
+                i++;
+        }
+    };
+    while (i < code.length) {
+        skipWs(true);
+        if (i >= code.length)
+            break;
+        if (code[i] === '[') {
+            const end = code.indexOf(']', i);
+            table = code.slice(i + 1, end).trim();
+            i = end + 1;
+            skipLine();
+            continue;
+        }
+        const key = readKey();
+        skipWs(false);
+        if (!key || code[i] !== '=') {
+            skipLine();
+            continue;
+        }
+        i++;
+        skipWs(false);
+        const fields = new Map();
+        readValue('', fields);
+        entries.push({ table, key, fields });
+        skipLine();
+    }
+    return entries;
+}
+async function catalogDeclarations(root, settings) {
+    const declared = [];
+    if (settings) {
+        const blocks = findBlocks(settings.code, 'versionCatalogs');
+        for (const m of matchesIn(settings.code, CATALOG_RE, blocks)) {
+            declared.push({ name: (m[1] ?? m[2]), file: resolve(dirname(settings.file), m[3]) });
+        }
+    }
+    const defaultFile = join(root, 'gradle', 'libs.versions.toml');
+    if (!declared.some((c) => c.file === defaultFile))
+        declared.push({ name: 'libs', file: defaultFile });
+    return declared;
+}
+function tomlValue(src, s) {
+    return isDynamic(s.value) ? { value: s.value } : { value: s.value, loc: { file: src.file, start: s.start, end: s.end } };
+}
+function pickVersion(src, fields, path) {
+    const plain = fields.get(path);
+    if (plain)
+        return tomlValue(src, plain);
+    const rich = ['require', 'strictly', 'prefer']
+        .map((k) => fields.get(path ? `${path}.${k}` : k))
+        .filter((s) => s !== undefined);
+    const best = rich.find((s) => !isDynamic(s.value)) ?? rich[0];
+    return best && tomlValue(src, best);
+}
+function splitNotation(src, s) {
+    const parts = s.value.split(':');
+    const last = parts[parts.length - 1];
+    const start = s.end - last.length;
+    return { parts, version: tomlValue(src, { value: last, start, end: s.end }) };
+}
+function parseCatalog(src, libraryRepos, pluginRepos, warnings) {
+    const entries = parseToml(src.code);
+    const versions = new Map();
+    for (const e of entries.filter((e) => e.table === 'versions')) {
+        const v = pickVersion(src, e.fields, '');
+        if (v)
+            versions.set(e.key, v);
+    }
+    const versionOf = (e) => {
+        const ref = e.fields.get('version.ref');
+        if (!ref)
+            return pickVersion(src, e.fields, 'version');
+        const found = versions.get(ref.value);
+        if (!found)
+            warnings.push(`${src.file}: unknown version.ref "${ref.value}" in ${e.key}`);
+        return found;
+    };
+    const deps = [];
+    for (const e of entries.filter((e) => e.table === 'libraries')) {
+        const str = e.fields.get('');
+        if (str) {
+            const { parts, version } = splitNotation(src, str);
+            if (parts.length >= 3 && version)
+                deps.push(makeDep('library', parts[0], parts[1], version, src.file, libraryRepos));
+            continue;
+        }
+        const [group, artifact] = e.fields.get('module')?.value.split(':') ?? [e.fields.get('group')?.value, e.fields.get('name')?.value];
+        const version = versionOf(e);
+        if (group && artifact && version)
+            deps.push(makeDep('library', group, artifact, version, src.file, libraryRepos));
+    }
+    for (const e of entries.filter((e) => e.table === 'plugins')) {
+        const str = e.fields.get('');
+        const id = str ? str.value.split(':')[0] : e.fields.get('id')?.value;
+        const version = str ? (str.value.includes(':') ? splitNotation(src, str).version : undefined) : versionOf(e);
+        if (id && version)
+            deps.push(makeDep('plugin', id, `${id}.gradle.plugin`, version, src.file, pluginRepos));
+    }
+    const normalized = new Map([...versions].map(([k, v]) => [normKey(k), v]));
+    return { versions: normalized, deps };
+}
+async function wrapperDep(root) {
+    const src = await readSource(join(root, 'gradle', 'wrapper', 'gradle-wrapper.properties'), stripProperties);
+    const m = src && WRAPPER_RE.exec(src.code);
+    if (!src || !m)
+        return undefined;
+    return makeDep('gradle', 'org.gradle', 'gradle', { value: m[1], loc: locOf(src, m, 1) }, src.file, []);
+}
+export async function scanGradle(build) {
+    const warnings = [];
+    const out = [];
+    const settings = build.settings ? await readSource(build.settings, stripCode) : undefined;
+    const rootProps = propertyVars(await readSource(join(build.root, 'gradle.properties'), stripProperties));
+    const rootBuildFile = build.buildFiles.find((f) => dirname(f) === build.root);
+    const rootBuild = rootBuildFile ? await readSource(rootBuildFile, stripCode) : undefined;
+    const rootVars = rootBuild ? collectVars(rootBuild) : new Map();
+    const pluginManagementRepos = settings ? reposWithin(settings, 'pluginManagement') : [];
+    const resolutionRepos = settings ? reposWithin(settings, 'dependencyResolutionManagement') : [];
+    const sharedLibraryRepos = [...resolutionRepos, ...(rootBuild ? buildFileRepos(rootBuild) : [])];
+    const libraryRepos = (extra) => {
+        const repos = dedupeRepos([...sharedLibraryRepos, ...extra]);
+        return repos.length ? repos : [MAVEN_CENTRAL, GOOGLE];
+    };
+    const pluginRepos = dedupeRepos([
+        ...(pluginManagementRepos.length ? pluginManagementRepos : [GRADLE_PLUGIN_PORTAL]),
+        ...resolutionRepos.filter((url) => url === GOOGLE || url === MAVEN_CENTRAL),
+    ]);
+    const catalogs = new Map();
+    for (const decl of await catalogDeclarations(build.root, settings)) {
+        const src = await readSource(decl.file, stripToml);
+        if (!src)
+            continue;
+        const parsed = parseCatalog(src, libraryRepos([]), pluginRepos, warnings);
+        catalogs.set(decl.name, parsed.versions);
+        out.push(...parsed.deps);
+    }
+    if (settings) {
+        const scope = { vars: [collectVars(settings), rootProps], catalogs };
+        pluginDeps(settings, { scope, repositories: pluginRepos, warnings, out });
+    }
+    for (const file of build.buildFiles) {
+        const src = file === rootBuildFile ? rootBuild : await readSource(file, stripCode);
+        if (!src)
+            continue;
+        const dir = dirname(file);
+        const moduleProps = dir === build.root ? new Map() : propertyVars(await readSource(join(dir, 'gradle.properties'), stripProperties));
+        const scope = { vars: [collectVars(src), rootVars, moduleProps, rootProps], catalogs };
+        libraryDeps(src, { scope, repositories: libraryRepos(buildFileRepos(src)), warnings, out });
+        pluginDeps(src, { scope, repositories: pluginRepos, warnings, out });
+    }
+    const wrapper = await wrapperDep(build.root);
+    if (wrapper)
+        out.push(wrapper);
+    return { dependencies: out, warnings };
+}