mergestory 0.0.0-stage → 1.0.0

package/dist/analyzer/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The PR analyzer: classifies files, groups components, finds changed symbols, ranks hunks,
+ * flags review risks and builds the evidence index every storyboard claim must cite.
+ * It only reports what the diff and the repository show.
+ */
+import { type Config } from '../core/config.ts';
+import type { Analysis } from '../core/types.ts';
+export { analyze } from './analyze.ts';
+export { hunkRange } from './hunks.ts';
+export type { EvidencePack, EvidencePackOptions } from './pack.ts';
+export { buildEvidencePack } from './pack.ts';
+export { detectRole } from './roles.ts';
+/** Target video length: the configured target, else the analysis suggestion, capped by maxDurationSec. */
+export declare function targetDuration(analysis: Analysis, config: Pick<Config, 'targetDurationSec' | 'maxDurationSec'>): number;

package/dist/analyzer/index.js

@@ -0,0 +1,16 @@
+/**
+ * The PR analyzer: classifies files, groups components, finds changed symbols, ranks hunks,
+ * flags review risks and builds the evidence index every storyboard claim must cite.
+ * It only reports what the diff and the repository show.
+ */
+import { DURATION_LIMITS } from '../core/config.js';
+export { analyze } from './analyze.js';
+export { hunkRange } from './hunks.js';
+export { buildEvidencePack } from './pack.js';
+export { detectRole } from './roles.js';
+/** Target video length: the configured target, else the analysis suggestion, capped by maxDurationSec. */
+export function targetDuration(analysis, config) {
+    const wanted = config.targetDurationSec ?? analysis.suggestedDurationSec;
+    return Math.max(DURATION_LIMITS.targetDurationSec.min, Math.min(config.maxDurationSec, wanted));
+}
+//# sourceMappingURL=index.js.map

package/dist/analyzer/languages/go.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageSupport } from './types.ts';
+export declare const GO: readonly LanguageSupport[];

package/dist/analyzer/languages/go.js

@@ -0,0 +1,76 @@
+// biome-ignore-all lint/suspicious/noAssignInExpressions: regex matches are assigned in the condition so the else-if chain stays flat
+/** Go, with the routes of calls such as `r.GET("/users", handler)`. */
+import { joinPosix } from '../../core/posix.js';
+import { nestingDepths } from '../scan.js';
+import { C_COMMENTS, matchAll, symbolEmitter } from './shared.js';
+const PROFILE = { lineComments: ['//'], blockComments: true, backtick: true };
+const GO_FUNC = /^func\s+(?:\(\s*(?:\w+\s+)?\*?([\w.]+)(?:\[[^\]]*\])?\s*\)\s*)?([A-Za-z_]\w*)\s*[[(]/;
+const GO_TYPE = /^type\s+(\w+)(?:\[[^\]]*\])?\s+(struct|interface)?/;
+const GO_VAR = /^(const|var)\s+(\w+)\b/;
+const GO_ROUTE = /\b\w+\.(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|Get|Post|Put|Patch|Delete|Handle|HandleFunc)\(\s*"([^"]*)"/;
+const GO_SPACED_ROUTE = /^([A-Z]+)\s+(\/.*)$/;
+function detectGo(lines) {
+    const depths = nestingDepths(lines, PROFILE);
+    const { symbols, emit } = symbolEmitter(lines, depths);
+    for (const [i, line] of lines.entries()) {
+        const t = line.trim();
+        if (!t || t.startsWith('//'))
+            continue;
+        const route = GO_ROUTE.exec(t);
+        if (route) {
+            const [, verb = '', target = ''] = route;
+            const [, spacedMethod, spacedPath] = GO_SPACED_ROUTE.exec(target) ?? [];
+            const method = spacedMethod ?? (/^(Handle|HandleFunc)$/.test(verb) ? 'ALL' : verb.toUpperCase());
+            const path = spacedPath ?? target;
+            if (path.startsWith('/'))
+                emit(`${method} ${path}`, 'route', i);
+        }
+        if (depths[i] !== 0)
+            continue;
+        let m;
+        if ((m = GO_FUNC.exec(line))) {
+            const [, receiver, name = ''] = m;
+            const exported = /^[A-Z]/.test(name) && (!receiver || /^[A-Z]/.test(receiver.split('.').pop() ?? ''));
+            emit(receiver ? `${receiver}.${name}` : name, receiver ? 'method' : 'function', i, { exported });
+        }
+        else if ((m = GO_TYPE.exec(line))) {
+            const [, name = '', shape] = m;
+            const kind = shape === 'struct' ? 'class' : shape === 'interface' ? 'interface' : 'type';
+            emit(name, kind, i, { exported: /^[A-Z]/.test(name) });
+        }
+        else if ((m = GO_VAR.exec(line))) {
+            const [, , name = ''] = m;
+            emit(name, 'constant', i, { exported: /^[A-Z]/.test(name) });
+        }
+    }
+    return symbols;
+}
+function extractImports(text) {
+    const refs = [];
+    for (const block of matchAll(text, /^\s*import\s*\(([\s\S]*?)\)/gm)) {
+        const [, body = ''] = block;
+        for (const [, spec = ''] of matchAll(body, /"([^"\n]+)"/g))
+            refs.push({ lang: 'go', spec });
+    }
+    for (const [, spec = ''] of matchAll(text, /^\s*import\s+(?:[\w.]+\s+)?"([^"\n]+)"/gm)) {
+        refs.push({ lang: 'go', spec });
+    }
+    return refs;
+}
+const IMPORTS = {
+    lang: 'go',
+    extract: extractImports,
+    resolve(_importer, { spec }, index) {
+        for (const { module, dir } of index.goModules) {
+            if (spec === module || spec.startsWith(`${module}/`)) {
+                const rest = spec.slice(module.length).replace(/^\//, '');
+                return [joinPosix(dir, rest, '_package.go')];
+            }
+        }
+        return [];
+    },
+};
+export const GO = [
+    { extensions: ['.go'], symbols: detectGo, imports: IMPORTS, comments: C_COMMENTS },
+];
+//# sourceMappingURL=go.js.map

package/dist/analyzer/languages/index.d.ts

@@ -0,0 +1,18 @@
+import type { ImportLang, ImportSupport, LanguageSupport } from './types.ts';
+/**
+ * The entries by extension and by name. A mistake in an entry would leave a file silently skipped, so
+ * it is refused when the module loads: an extension without its dot, a key in upper case (the lookup
+ * is in lower case), or one that two entries list.
+ */
+export declare function indexLanguages(languages: readonly LanguageSupport[]): {
+    byExtension: Map<string, LanguageSupport>;
+    byName: Map<string, LanguageSupport>;
+};
+/** The support the analyzer has for a file, from its name or extension; null for a kind it does not know. */
+export declare function languageSupport(path: string): LanguageSupport | null;
+/** True when the analyzer finds declarations in files like this one. */
+export declare function hasSymbols(path: string): boolean;
+/** True when the analyzer reads the imports of files like this one. */
+export declare function hasImports(path: string): boolean;
+/** The import support that makes and resolves the imports of a language. */
+export declare function importSupport(lang: ImportLang): ImportSupport | undefined;

package/dist/analyzer/languages/index.js

@@ -0,0 +1,72 @@
+/**
+ * The languages the analyzer reads, and what it knows about each: how to find declarations, how to
+ * read and resolve imports, how a comment starts and whether indentation carries meaning. A file
+ * gets the support of the language that lists its name or extension.
+ */
+import { basename, extname } from '../../core/posix.js';
+import { GO } from './go.js';
+import { JAVASCRIPT } from './javascript.js';
+import { JVM } from './jvm.js';
+import { OTHERS } from './others.js';
+import { PHP } from './php.js';
+import { PYTHON } from './python.js';
+import { RUBY } from './ruby.js';
+import { RUST } from './rust.js';
+const LANGUAGES = [
+    ...JAVASCRIPT,
+    ...PYTHON,
+    ...GO,
+    ...RUST,
+    ...JVM,
+    ...RUBY,
+    ...PHP,
+    ...OTHERS,
+];
+/**
+ * The entries by extension and by name. A mistake in an entry would leave a file silently skipped, so
+ * it is refused when the module loads: an extension without its dot, a key in upper case (the lookup
+ * is in lower case), or one that two entries list.
+ */
+export function indexLanguages(languages) {
+    const byExtension = new Map();
+    const byName = new Map();
+    const add = (map, key, language) => {
+        if (key !== key.toLowerCase())
+            throw new Error(`"${key}" must be lower case.`);
+        if (map === byExtension && !key.startsWith('.'))
+            throw new Error(`The extension "${key}" needs its dot.`);
+        if (map.has(key))
+            throw new Error(`Two languages list "${key}".`);
+        map.set(key, language);
+    };
+    for (const language of languages) {
+        for (const extension of language.extensions)
+            add(byExtension, extension, language);
+        for (const name of language.names ?? [])
+            add(byName, name, language);
+    }
+    return { byExtension, byName };
+}
+const { byExtension, byName } = indexLanguages(LANGUAGES);
+/** The support the analyzer has for a file, from its name or extension; null for a kind it does not know. */
+export function languageSupport(path) {
+    return byName.get(basename(path).toLowerCase()) ?? byExtension.get(extname(path)) ?? null;
+}
+/** True when the analyzer finds declarations in files like this one. */
+export function hasSymbols(path) {
+    return languageSupport(path)?.symbols !== undefined;
+}
+/** True when the analyzer reads the imports of files like this one. */
+export function hasImports(path) {
+    return languageSupport(path)?.imports !== undefined;
+}
+const importsByLang = new Map();
+for (const language of LANGUAGES) {
+    if (language.imports)
+        importsByLang.set(language.imports.lang, language.imports);
+}
+/** The import support that makes and resolves the imports of a language. */
+export function importSupport(lang) {
+    return importsByLang.get(lang);
+}
+//# sourceMappingURL=index.js.map

package/dist/analyzer/languages/javascript.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageSupport } from './types.ts';
+export declare const JAVASCRIPT: readonly LanguageSupport[];

package/dist/analyzer/languages/javascript.js

@@ -0,0 +1,336 @@
+// biome-ignore-all lint/suspicious/noAssignInExpressions: regex matches are assigned in the condition so the else-if chain stays flat
+/** JavaScript and TypeScript, and Vue and Svelte components, of which only the imports are read. */
+import { dirname, joinPosix, normalizePosix } from '../../core/posix.js';
+import { blockEnd, nestingDepths } from '../scan.js';
+import { collapse } from '../symbol-types.js';
+import { C_COMMENTS, matchAll, packageRootOf, symbolEmitter } from './shared.js';
+const PROFILE = {
+    lineComments: ['//'],
+    blockComments: true,
+    backtick: true,
+    templateLiterals: true,
+    regexLiterals: true,
+};
+const JS_FN = /^(export\s+)?(default\s+)?(?:declare\s+)?(async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)?\s*[<(]/;
+const JS_CLASS = /^(export\s+)?(default\s+)?(?:declare\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/;
+const JS_IFACE = /^(export\s+)?(?:declare\s+)?interface\s+([A-Za-z_$][\w$]*)/;
+const JS_TYPE = /^(export\s+)?(?:declare\s+)?type\s+([A-Za-z_$][\w$]*)\s*[<=]/;
+const JS_ENUM = /^(export\s+)?(?:declare\s+)?(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/;
+const JS_VAR = /^(export\s+)?(?:declare\s+)?(const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::(?:[^=]|=>)+?)?=(?!=)\s*(.*)$/;
+const JS_CJS = /^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(.*)$/;
+const JS_DEFAULT_EXPR = /^export\s+default\s+(?:async\s+)?(?:\(|[\w$]+\s*=>)/;
+const ARROW = /^(?:async\s+)?(?:<[^>]*>\s*)?(?:function\b|[\w$]+\s*=>|\((?:[^()]|\([^()]*\))*\)\s*(?::\s*[^=;{]+?)?\s*=>)/;
+const WRAPPED = /^(?:React\.)?(?:memo|forwardRef)\s*\(/;
+const JS_METHOD = /^((?:(?:public|private|protected|static|readonly|abstract|override|async|get|set|declare)\s+)*)(\*\s*)?(#?[A-Za-z_$][\w$]*)\s*(?:<[^>()]*>)?\s*\(/;
+const JS_PROP_FN = /^((?:(?:public|private|protected|static|readonly|override|declare)\s+)*)(#?[A-Za-z_$][\w$]*)\s*[?!]?\s*(?::(?:[^=]|=>)+?)?=(?!=)\s*(?:async\s+)?(?:\(|[\w$]+\s*=>|function)/;
+const JS_ROUTE = /\b([A-Za-z_$][\w$]*)\.(get|post|put|patch|delete|options|head|all)\(\s*(['"`])(\/[^'"`]*|\*)\3/;
+const ROUTER_NAME = /^(app|router|server|fastify|api|route|routes|r|[\w$]*Router|[\w$]*App|[\w$]*Server|[\w$]*Api)$/;
+const NOT_METHODS = new Set([
+    'if',
+    'for',
+    'while',
+    'switch',
+    'catch',
+    'function',
+    'return',
+    'with',
+    'else',
+    'do',
+    'try',
+]);
+const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']);
+const NEST_ROUTE = /^@(Get|Post|Put|Patch|Delete|All|Head|Options)\(\s*(?:['"`]([^'"`]*)['"`])?/;
+const NEST_CONTROLLER = /^@Controller\(\s*(?:['"`]([^'"`]*)['"`])?/;
+const NEXT_APP_ROUTE = /(^|\/)app\/((?:.*\/)?)route\.[mc]?[jt]sx?$/;
+const NEXT_PAGES_ROUTE = /(^|\/)pages\/(api\/.*)\.[mc]?[jt]sx?$/;
+function joinRoute(...parts) {
+    const joined = parts
+        .filter((p) => !!p)
+        .map((p) => p.replace(/^\/+|\/+$/g, ''))
+        .filter(Boolean)
+        .join('/');
+    return `/${joined}`;
+}
+/** Route path of a Next.js route file, or null when the path is not one. */
+function nextRoutePath(path) {
+    const app = NEXT_APP_ROUTE.exec(path);
+    if (app) {
+        const [, , dirs = ''] = app;
+        return { path: joinRoute(...dirs.split('/').filter((d) => d && !/^\(.*\)$/.test(d))), app: true };
+    }
+    const pages = NEXT_PAGES_ROUTE.exec(path);
+    if (pages) {
+        const [, , api = ''] = pages;
+        return { path: joinRoute(api.replace(/\/index$/, '')), app: false };
+    }
+    return null;
+}
+/**
+ * Text that stands for a symbol's signature: the declaration without its body. Interfaces and types
+ * use their whole text, because any change to their shape changes what callers can rely on.
+ */
+function jsDecl(lines, kind, name, from, to) {
+    if (kind === 'route')
+        return name;
+    if (kind === 'interface' || kind === 'type')
+        return collapse(lines.slice(from, to + 1).join(' '), 2000);
+    const text = lines
+        .slice(from, Math.min(to, from + 6) + 1)
+        .map((l) => l.trim())
+        .join(' ');
+    if (kind === 'constant')
+        return collapse(text.split(/=(?!>)/)[0] ?? '');
+    return collapse(cutSignature(text));
+}
+/** Cut at the first body brace, arrow or semicolon that is not inside parentheses or brackets. */
+function cutSignature(text) {
+    let depth = 0;
+    for (let k = 0; k < text.length; k++) {
+        const ch = text.charAt(k);
+        if (ch === '(' || ch === '[')
+            depth++;
+        else if (ch === ')' || ch === ']')
+            depth--;
+        else if (depth <= 0) {
+            if (ch === '{' || ch === ';')
+                return text.slice(0, k);
+            if (ch === '=' && text.charAt(k + 1) === '>')
+                return text.slice(0, k + 2);
+        }
+    }
+    return text;
+}
+const CONTINUES_AT_START = /^(?:\?\.|\.(?!\.)|\?|:|&&|\|\||\?\?|\+|-|\||&|,)/;
+const CONTINUES_AT_END = /(?:=>|=|&&|\|\||\?\?|\+|-|\?|:|\||&|,|\.)$/;
+/**
+ * A top-level statement can continue on the next line without opening a bracket: a chained call
+ * (".object({"), a leading operator, or an assignment that ends the line with "=".
+ */
+function extendStatement(lines, depths, end) {
+    let e = end;
+    for (let guard = 0; guard < 400; guard++) {
+        const code = (lines[e] ?? '').replace(/\s\/\/.*$/, '').trimEnd();
+        let n = e + 1;
+        while (n < lines.length && (lines[n] ?? '').trim() === '')
+            n++;
+        if (n >= lines.length || depths[n] !== 0)
+            break;
+        const next = (lines[n] ?? '').trim();
+        const startsCont = !next.startsWith('//') && !next.startsWith('/*') && CONTINUES_AT_START.test(next);
+        if (!startsCont && !CONTINUES_AT_END.test(code))
+            break;
+        e = blockEnd(depths, n, lines.length);
+    }
+    return e;
+}
+function detectJs(lines, path) {
+    const depths = nestingDepths(lines, PROFILE);
+    const { symbols, emit } = symbolEmitter(lines, depths);
+    const next = nextRoutePath(path);
+    const jsx = /\.(tsx|jsx)$/.test(path);
+    // What stands for a symbol's declaration depends on its kind.
+    const push = (name, kind, exported, from, to) => emit(name, kind, from, { exported, end: to, decl: jsDecl(lines, kind, name, from, to) });
+    for (const [i, line] of lines.entries()) {
+        const t = line.trim();
+        if (!t || t.startsWith('//') || t.startsWith('*') || t.startsWith('/*'))
+            continue;
+        const route = JS_ROUTE.exec(t);
+        if (route) {
+            const [, router = '', verb = '', , target = ''] = route;
+            if (ROUTER_NAME.test(router)) {
+                push(`${verb.toUpperCase()} ${target}`, 'route', true, i, blockEnd(depths, i, lines.length));
+            }
+        }
+        if (depths[i] !== 0)
+            continue;
+        const end = () => blockEnd(depths, i, lines.length);
+        const stmtEnd = () => extendStatement(lines, depths, end());
+        let m;
+        if ((m = JS_FN.exec(t))) {
+            const [, exported, isDefault, , name = 'default'] = m;
+            if (next && !next.app && isDefault) {
+                push(`ALL ${next.path}`, 'route', true, i, end());
+            }
+            else if (next?.app && HTTP_METHODS.has(name)) {
+                push(`${name} ${next.path}`, 'route', true, i, end());
+            }
+            else {
+                const kind = /^[A-Z]/.test(name) && jsx ? 'component' : 'function';
+                push(name, kind, !!exported, i, end());
+            }
+        }
+        else if ((m = JS_CLASS.exec(t))) {
+            const [, exported, , name = ''] = m;
+            const e = end();
+            push(name, 'class', !!exported, i, e);
+            jsMethods(lines, depths, i, e, name, !!exported, push);
+        }
+        else if ((m = JS_IFACE.exec(t))) {
+            const [, exported, name = ''] = m;
+            push(name, 'interface', !!exported, i, end());
+        }
+        else if ((m = JS_TYPE.exec(t))) {
+            const [, exported, name = ''] = m;
+            push(name, 'type', !!exported, i, stmtEnd());
+        }
+        else if ((m = JS_ENUM.exec(t))) {
+            const [, exported, name = ''] = m;
+            push(name, 'type', !!exported, i, end());
+        }
+        else if ((m = JS_VAR.exec(t))) {
+            const [, exported, , name = '', init = ''] = m;
+            const e = stmtEnd();
+            const rhs = [init, ...lines.slice(i + 1, e + 1)].join(' ').slice(0, 600).trim();
+            const isFn = ARROW.test(rhs) || WRAPPED.test(rhs);
+            if (next?.app && HTTP_METHODS.has(name) && exported) {
+                push(`${name} ${next.path}`, 'route', true, i, e);
+            }
+            else if (isFn) {
+                const component = WRAPPED.test(rhs) || (/^[A-Z]/.test(name) && jsx);
+                push(name, component ? 'component' : 'function', !!exported, i, e);
+            }
+            else if (exported || /^[A-Z][A-Z0-9_]+$/.test(name)) {
+                push(name, 'constant', !!exported, i, e);
+            }
+        }
+        else if ((m = JS_CJS.exec(t))) {
+            const [, name = '', init = ''] = m;
+            const e = stmtEnd();
+            const isFn = ARROW.test([init, ...lines.slice(i + 1, e + 1)].join(' ').slice(0, 600).trim());
+            push(name, isFn ? 'function' : 'constant', true, i, e);
+        }
+        else if (JS_DEFAULT_EXPR.test(t)) {
+            push('default', next && !next.app ? 'route' : 'function', true, i, stmtEnd());
+        }
+    }
+    return symbols;
+}
+function jsMethods(lines, depths, classStart, classEnd, className, classExported, push) {
+    let prefix = '';
+    for (let k = Math.max(0, classStart - 3); k < classStart; k++) {
+        const c = NEST_CONTROLLER.exec((lines[k] ?? '').trim());
+        if (c)
+            prefix = c[1] ?? '';
+    }
+    let pending = null;
+    for (let l = classStart + 1; l < classEnd; l++) {
+        if (depths[l] !== 1)
+            continue;
+        const t = (lines[l] ?? '').trim();
+        const nest = NEST_ROUTE.exec(t);
+        if (nest) {
+            const [, verb = '', path = ''] = nest;
+            pending = { method: verb.toUpperCase(), path };
+            continue;
+        }
+        if (!t || t.startsWith('//') || t.startsWith('*') || t.startsWith('/*') || t.startsWith('@'))
+            continue;
+        const method = JS_METHOD.exec(t);
+        const member = method ?? JS_PROP_FN.exec(t);
+        const name = (method ? method[3] : member?.[2]) ?? '';
+        if (!member || !name || NOT_METHODS.has(name)) {
+            pending = null;
+            continue;
+        }
+        const modifiers = member[1] ?? '';
+        const isPrivate = /\b(private|protected)\b/.test(modifiers) || name.startsWith('#');
+        const e = blockEnd(depths, l, lines.length);
+        if (pending) {
+            push(`${pending.method} ${joinRoute(prefix, pending.path)}`, 'route', true, l, e);
+            pending = null;
+        }
+        else {
+            push(`${className}.${name}`, 'method', classExported && !isPrivate, l, e);
+        }
+    }
+}
+const IMPORT_PATTERNS = [
+    /^\s*(?:import|export)\s+(?:type\s+)?[^'"`;]*?\sfrom\s*['"]([^'"\n]+)['"]/gm,
+    /^\s*import\s*['"]([^'"\n]+)['"]/gm,
+    /\brequire\s*\(\s*['"]([^'"\n]+)['"]\s*\)/g,
+    /\bimport\s*\(\s*['"]([^'"\n]+)['"]\s*\)/g,
+];
+/** True when the text before `index` on its line shows that the statement sits in a comment. */
+function inLineComment(text, index) {
+    const start = text.lastIndexOf('\n', index - 1) + 1;
+    const prefix = text.slice(start, index).trimStart();
+    return prefix.startsWith('//') || prefix.startsWith('*');
+}
+function extractImports(text) {
+    const refs = [];
+    for (const re of IMPORT_PATTERNS) {
+        for (const m of matchAll(text, re)) {
+            const [, spec = ''] = m;
+            if (!inLineComment(text, m.index))
+                refs.push({ lang: 'js', spec });
+        }
+    }
+    return refs;
+}
+const JS_EXTENSIONS = [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.cts',
+    '.json',
+    '.vue',
+    '.svelte',
+];
+function jsCandidates(base) {
+    const stem = base.replace(/\.(m|c)?js$/, '');
+    const list = [base, ...JS_EXTENSIONS.map((e) => base + e)];
+    if (stem !== base)
+        list.push(...['.ts', '.tsx', '.mts', '.cts'].map((e) => stem + e));
+    list.push(...JS_EXTENSIONS.map((e) => `${base}/index${e}`));
+    return list;
+}
+function resolveImport(importer, { spec }, index) {
+    const root = packageRootOf(importer);
+    let base = null;
+    if (spec.startsWith('./') || spec.startsWith('../') || spec === '.' || spec === '..') {
+        base = normalizePosix(joinPosix(dirname(importer), spec));
+    }
+    else if (spec.startsWith('@/') || spec.startsWith('~/') || spec.startsWith('#')) {
+        const rest = spec.replace(/^(@\/|~\/|#\/?)/, '');
+        const hit = index.firstKnown([
+            ...jsCandidates(joinPosix(root, 'src', rest)),
+            ...jsCandidates(joinPosix(root, rest)),
+        ]);
+        return hit ? [hit] : [joinPosix(root, 'src', rest)];
+    }
+    else {
+        for (const [name, dir] of index.packageDirs) {
+            if (spec === name || spec.startsWith(`${name}/`)) {
+                const sub = spec.slice(name.length).replace(/^\//, '');
+                const hit = index.firstKnown(jsCandidates(joinPosix(dir, 'src', sub || 'index')));
+                return [hit ?? joinPosix(dir, 'src', sub || 'index')];
+            }
+        }
+        return [];
+    }
+    if (base === null)
+        return [];
+    const hit = index.firstKnown(jsCandidates(base));
+    return [hit ?? base];
+}
+const IMPORTS = {
+    lang: 'js',
+    extract: extractImports,
+    resolve: resolveImport,
+};
+export const JAVASCRIPT = [
+    {
+        extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts'],
+        symbols: detectJs,
+        imports: IMPORTS,
+        comments: C_COMMENTS,
+        looseSyntax: true,
+    },
+    // Single-file components: their imports are read, their declarations are not.
+    { extensions: ['.vue', '.svelte'], imports: IMPORTS, comments: C_COMMENTS },
+];
+//# sourceMappingURL=javascript.js.map

package/dist/analyzer/languages/jvm.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageSupport } from './types.ts';
+export declare const JVM: readonly LanguageSupport[];