accel2spa 0.0.0-stage → 0.1.0

package/dist/scanners/js.js

@@ -0,0 +1,213 @@
+/**
+ * Lightweight detection of HTTP calls in JavaScript (also used for inline <script> blocks in JSPs).
+ * Regex based: no JS parser.
+ */
+const CONTEXT_PATH_RE = /context\s*path/i;
+/** Normalize a URL-ish string: strips context path, query/hash; dynamic parts become `{param}`. */
+export function normalizeUrlText(raw) {
+    let s = raw.replace(/\$\{([^}]*)\}/g, (_m, e) => (CONTEXT_PATH_RE.test(e) ? '' : '{param}'));
+    s = s.split(/[?#]/)[0].trim();
+    s = s.replace(/(\{param\})+/g, '{param}').replace(/^\{param\}(?=\/)/, '');
+    if (!s || s === '{param}')
+        return undefined;
+    if (/^https?:\/\//i.test(s) || s.startsWith('//'))
+        return s;
+    if (!s.startsWith('/'))
+        s = '/' + s;
+    return s;
+}
+export function isStaticUrl(url) {
+    return /\.(css|js|png|jpe?g|gif|svg|ico|woff2?|ttf|eot|map|html?)$/i.test(url) || /^\/(_ui|medias|webjars)\b/.test(url);
+}
+function skipString(s, i) {
+    const q = s[i];
+    let j = i + 1;
+    while (j < s.length && s[j] !== q) {
+        if (s[j] === '\\')
+            j++;
+        j++;
+    }
+    return j; // index of closing quote (or s.length)
+}
+/** Text between the parenthesis at `openIdx` and its matching close. Tolerant of unbalanced input. */
+function callArgs(code, openIdx) {
+    let depth = 0;
+    const limit = Math.min(code.length, openIdx + 4000);
+    for (let i = openIdx; i < limit; i++) {
+        const ch = code[i];
+        if (ch === '"' || ch === "'" || ch === '`') {
+            i = skipString(code, i);
+            continue;
+        }
+        if (ch === '(')
+            depth++;
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0)
+                return { text: code.slice(openIdx + 1, i), end: i };
+        }
+    }
+    return { text: code.slice(openIdx + 1, limit), end: limit };
+}
+/** Split on top-level commas; stops at an unmatched closing bracket. */
+function splitTopLevel(s) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === '"' || ch === "'" || ch === '`') {
+            i = skipString(s, i);
+            continue;
+        }
+        if (ch === '(' || ch === '{' || ch === '[')
+            depth++;
+        else if (ch === ')' || ch === '}' || ch === ']') {
+            depth--;
+            if (depth < 0) {
+                parts.push(s.slice(start, i));
+                return parts;
+            }
+        }
+        else if (ch === ',' && depth === 0) {
+            parts.push(s.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(s.slice(start));
+    return parts;
+}
+/** Evaluate a concatenation like `ctx + '/a/' + id` into `/a/{param}`. */
+export function evalUrlExpr(expr) {
+    const seg = splitTopLevel(expr)[0].trim();
+    let out = '';
+    let any = false;
+    let i = 0;
+    while (i < seg.length) {
+        const ch = seg[i];
+        if (/\s|\+/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            const j = skipString(seg, i);
+            out += seg.slice(i + 1, j);
+            i = j + 1;
+            any = true;
+            continue;
+        }
+        const idm = /^[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*|\[[^\]]*\])*(?:\([^()]*\))?/.exec(seg.slice(i));
+        if (idm) {
+            out += CONTEXT_PATH_RE.test(idm[0]) ? '' : '${dynamic}';
+            i += idm[0].length;
+            any = true;
+            continue;
+        }
+        if (ch === '(' || ch === ')') {
+            i++;
+            continue;
+        }
+        break;
+    }
+    return any ? normalizeUrlText(out) : undefined;
+}
+const CALL_RE = /(\$\.ajax|jQuery\.ajax|\$\.getJSON|\$\.get|\$\.post|jQuery\.get|jQuery\.post|\bfetch|\baxios(?:\.(?:get|post|put|patch|delete))?|\.open)\s*\(/g;
+const RESPONSE_IGNORE = new Set([
+    'length', 'then', 'catch', 'finally', 'json', 'text', 'ok', 'status', 'statusText', 'forEach', 'map', 'filter',
+    'done', 'fail', 'always', 'success', 'error', 'headers', 'push', 'toString', 'hasOwnProperty'
+]);
+function objectKeys(body) {
+    const keys = [];
+    const re = /(?:^|[,{\s])(?:([A-Za-z_$][\w$]*)|'([^']+)'|"([^"]+)")\s*:/g;
+    let m;
+    while ((m = re.exec(body)))
+        keys.push(m[1] ?? m[2] ?? m[3]);
+    return keys;
+}
+/**
+ * Scan JavaScript source for $.ajax / $.get / $.post / fetch / axios / XHR calls.
+ * `lineAt` maps an index in `code` to a line number in the original file.
+ */
+export function scanJsEndpoints(code, lineAt) {
+    const result = [];
+    const matches = [];
+    CALL_RE.lastIndex = 0;
+    let m;
+    while ((m = CALL_RE.exec(code))) {
+        matches.push({ index: m.index, name: m[1], openIdx: m.index + m[0].length - 1 });
+    }
+    matches.forEach((call, idx) => {
+        const { text: args, end } = callArgs(code, call.openIdx);
+        const name = call.name.replace(/^\\b/, '');
+        let method = 'GET';
+        let kind = 'ajax';
+        let urlExpr;
+        if (name === '.open') {
+            const first = /^\s*['"]([A-Za-z]+)['"]\s*,/.exec(args);
+            if (!first)
+                return;
+            method = first[1].toUpperCase();
+            kind = 'xhr';
+            urlExpr = args.slice(first[0].length);
+        }
+        else {
+            if (/fetch$/.test(name))
+                kind = 'fetch';
+            if (/\.post$/.test(name))
+                method = 'POST';
+            else if (/\.put$/.test(name))
+                method = 'PUT';
+            else if (/\.patch$/.test(name))
+                method = 'PATCH';
+            else if (/\.delete$/.test(name))
+                method = 'DELETE';
+            if (/(ajax|fetch|axios)$/.test(name)) {
+                const mm = /\b(?:type|method)\s*:\s*['"`]([A-Za-z]+)['"`]/.exec(args);
+                if (mm)
+                    method = mm[1].toUpperCase();
+            }
+            if (args.trimStart().startsWith('{')) {
+                const um = /\burl\s*:\s*/.exec(args);
+                if (um)
+                    urlExpr = args.slice(um.index + um[0].length);
+            }
+            else {
+                urlExpr = args;
+            }
+        }
+        if (!urlExpr)
+            return;
+        const url = evalUrlExpr(urlExpr);
+        if (!url)
+            return;
+        // Request payload keys.
+        const requestFields = new Set();
+        const dataRe = /\b(?:data|body|params)\s*:\s*(?:JSON\.stringify\(\s*)?\{([^{}]*)\}/g;
+        let dm;
+        while ((dm = dataRe.exec(args)))
+            objectKeys(dm[1]).forEach((k) => requestFields.add(k));
+        if (/\$\.(post|get)|jQuery\.(post|get)/.test(name)) {
+            const second = splitTopLevel(args)[1]?.trim();
+            if (second?.startsWith('{'))
+                objectKeys(second.slice(1)).forEach((k) => requestFields.add(k));
+        }
+        // Response properties read in the code that follows the call (until the next call).
+        const nextIdx = matches[idx + 1]?.index ?? code.length;
+        const windowText = code.slice(call.openIdx, Math.min(end + 900, nextIdx));
+        const responseFields = new Set();
+        const respRe = /\b(?:data|response|resp|result|res|json|payload)\.([A-Za-z_]\w*)/g;
+        let rm;
+        while ((rm = respRe.exec(windowText)))
+            if (!RESPONSE_IGNORE.has(rm[1]))
+                responseFields.add(rm[1]);
+        result.push({
+            kind,
+            method,
+            url,
+            line: lineAt(call.index),
+            requestFields: [...requestFields],
+            responseFields: [...responseFields]
+        });
+    });
+    return result;
+}

package/dist/scanners/jsp.d.ts

@@ -0,0 +1,87 @@
+import { type RawEndpoint } from './js.js';
+import type { ConditionalKind, ConditionalLayout } from '../model.js';
+export interface TaglibDecl {
+    prefix: string;
+    uri?: string;
+    tagdir?: string;
+    line: number;
+}
+export interface TagUsage {
+    prefix: string;
+    name: string;
+    tagdir: string;
+    line: number;
+    offset: number;
+}
+export interface IncludeRef {
+    kind: 'jsp:include' | 'directive' | 'c:import';
+    target: string;
+    line: number;
+}
+export interface I18nRef {
+    key: string;
+    tag: string;
+    line: number;
+    offset: number;
+    defaultText?: string;
+    dynamic: boolean;
+}
+export interface HardcodedRef {
+    text: string;
+    line: number;
+    kind: 'text' | 'attribute';
+    attribute?: string;
+}
+export interface ElRef {
+    path: string;
+    line: number;
+}
+export interface AliasDecl {
+    /** Simple class name from `<%@ attribute type="...OrderData" %>`. */
+    declaredType?: string;
+    /** EL path this variable was derived from (`c:forEach items` / `c:set value`). */
+    from?: string;
+    /** `from` is a collection and the variable is one element. */
+    element?: boolean;
+    /** Variable is something we cannot type (loop status, literals...). */
+    ignore?: boolean;
+}
+export interface RawConditional {
+    id: string;
+    kind: ConditionalKind;
+    test?: string;
+    line: number;
+    endLine: number;
+    depth: number;
+    parent?: string;
+    chooseGroup?: string;
+    layout: ConditionalLayout;
+    containsTags: string[];
+    containsI18nKeys: string[];
+    label: string;
+}
+export type ScanEndpoint = RawEndpoint & {
+    usage: 'ajax' | 'navigation';
+};
+export interface TemplateScan {
+    file: string;
+    taglibs: TaglibDecl[];
+    tagUsages: TagUsage[];
+    includes: IncludeRef[];
+    conditionals: RawConditional[];
+    i18n: I18nRef[];
+    hardcoded: HardcodedRef[];
+    elRefs: ElRef[];
+    aliases: Record<string, AliasDecl>;
+    endpoints: ScanEndpoint[];
+    scriptRefs: string[];
+    cmsSlots: Array<{
+        position: string;
+        line: number;
+    }>;
+    warnings: string[];
+}
+export declare function parseAttrs(s: string): Record<string, string>;
+/** Extract `a.b.c` style data paths from an EL expression body. */
+export declare function elPaths(expr: string): string[];
+export declare function scanTemplate(source: string, file: string): TemplateScan;

package/dist/scanners/jsp.js

@@ -0,0 +1,394 @@
+/**
+ * Tolerant scanner for JSP / .tag files. Regex + a small tokenizer; no full JSP grammar.
+ * Never throws: oddities are recorded in `warnings`.
+ */
+import { LineMap, blank } from '../util.js';
+import { isStaticUrl, normalizeUrlText, scanJsEndpoints } from './js.js';
+const STD_URIS = {
+    'http://java.sun.com/jsp/jstl/core': 'c',
+    'jakarta.tags.core': 'c',
+    'http://java.sun.com/jsp/jstl/fmt': 'fmt',
+    'jakarta.tags.fmt': 'fmt',
+    'http://www.springframework.org/tags': 'spring',
+    'http://www.springframework.org/tags/form': 'form',
+    'http://java.sun.com/jsp/jstl/functions': 'fn'
+};
+const TEXT_ATTRS = ['title', 'alt', 'placeholder', 'aria-label'];
+const TOKEN_RE = /<(\/?)([A-Za-z][\w:.-]*)((?:"[^"]*"|'[^']*'|[^'">])*)>/g;
+export function parseAttrs(s) {
+    const out = {};
+    const re = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+    let m;
+    while ((m = re.exec(s)))
+        out[m[1]] = m[2] ?? m[3] ?? '';
+    return out;
+}
+const stripEl = (v) => {
+    const m = /^\s*\$\{([\s\S]*)\}\s*$/.exec(v);
+    return m ? m[1].trim() : undefined;
+};
+/** Extract `a.b.c` style data paths from an EL expression body. */
+export function elPaths(expr) {
+    const cleaned = expr.replace(/'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/g, "''");
+    const re = /(?<![\w.:$])([A-Za-z_]\w*)((?:\s*\.\s*[A-Za-z_]\w*|\s*\[[^\]]*\])+)/g;
+    const out = [];
+    let m;
+    while ((m = re.exec(cleaned))) {
+        const segs = m[2].replace(/\[[^\]]*\]/g, '').replace(/\s+/g, '');
+        if (!segs)
+            continue;
+        out.push(m[1] + segs);
+    }
+    return out;
+}
+export function scanTemplate(source, file) {
+    const warnings = [];
+    const scan = {
+        file,
+        taglibs: [],
+        tagUsages: [],
+        includes: [],
+        conditionals: [],
+        i18n: [],
+        hardcoded: [],
+        elRefs: [],
+        aliases: {},
+        endpoints: [],
+        scriptRefs: [],
+        cmsSlots: [],
+        warnings
+    };
+    try {
+        doScan(source, file, scan);
+    }
+    catch (e) {
+        warnings.push(`${file}: scanner error: ${e.message}`);
+    }
+    return scan;
+}
+function doScan(source, file, scan) {
+    const { warnings } = scan;
+    const lines = new LineMap(source);
+    const base = file.split('/').pop() ?? file;
+    // 1. Mask comments, then directives/scriptlets (extract taglib + attribute directives first).
+    let masked = source
+        .replace(/<%--[\s\S]*?--%>/g, blank)
+        .replace(/<!--[\s\S]*?-->/g, blank);
+    const dirRe = /<%@\s*(taglib|attribute|include)\b([\s\S]*?)%>/g;
+    let dm;
+    while ((dm = dirRe.exec(masked))) {
+        const attrs = parseAttrs(dm[2]);
+        const line = lines.lineAt(dm.index);
+        if (dm[1] === 'taglib' && attrs.prefix) {
+            scan.taglibs.push({ prefix: attrs.prefix, uri: attrs.uri, tagdir: attrs.tagdir, line });
+        }
+        else if (dm[1] === 'attribute' && attrs.name) {
+            const t = attrs.type?.split('.').pop();
+            scan.aliases[attrs.name] = { declaredType: t };
+        }
+        else if (dm[1] === 'include' && attrs.file) {
+            scan.includes.push({ kind: 'directive', target: attrs.file, line });
+        }
+    }
+    masked = masked.replace(/<%[\s\S]*?%>/g, blank);
+    // 2. Blank <script>/<style> bodies for the HTML-oriented passes; scan inline scripts separately.
+    const scriptBodies = [];
+    const noScript = masked.replace(/(<(script|style)\b[^>]*>)([\s\S]*?)(<\/\2\s*>)/gi, (full, open, tag, body, close, offset) => {
+        if (tag.toLowerCase() === 'script') {
+            scriptBodies.push({ offset: offset + open.length, code: body, hasSrc: /\bsrc\s*=/.test(open) });
+        }
+        return open + blank(body) + close;
+    });
+    // 3. Tokenize.
+    const tokens = [];
+    TOKEN_RE.lastIndex = 0;
+    let tm;
+    while ((tm = TOKEN_RE.exec(noScript))) {
+        const attrText = tm[3];
+        tokens.push({
+            name: tm[2],
+            closing: tm[1] === '/',
+            selfClosing: /\/\s*$/.test(attrText),
+            attrs: tm[1] === '/' ? {} : parseAttrs(attrText),
+            start: tm.index,
+            end: tm.index + tm[0].length,
+            line: lines.lineAt(tm.index)
+        });
+    }
+    const prefixCanon = {};
+    const tagdirByPrefix = new Map();
+    for (const t of scan.taglibs) {
+        if (t.uri && STD_URIS[t.uri])
+            prefixCanon[t.prefix] = STD_URIS[t.uri];
+        if (t.tagdir)
+            tagdirByPrefix.set(t.prefix, t.tagdir);
+    }
+    const canon = (name) => {
+        const i = name.indexOf(':');
+        if (i < 0)
+            return name;
+        const p = name.slice(0, i);
+        return (prefixCanon[p] ?? p) + ':' + name.slice(i + 1);
+    };
+    const stack = [];
+    const condRanges = new Map();
+    const usedIds = new Set();
+    const mkId = (line) => {
+        let id = `${base}:${line}`;
+        let n = 2;
+        while (usedIds.has(id))
+            id = `${base}:${line}#${n++}`;
+        usedIds.add(id);
+        return id;
+    };
+    const nearestCond = () => {
+        for (let i = stack.length - 1; i >= 0; i--)
+            if (stack[i].cond)
+                return stack[i].cond;
+        return undefined;
+    };
+    const condDepth = () => stack.filter((s) => s.cond).length;
+    const closeEntry = (e, endOffset, endLine) => {
+        if (e.cond) {
+            e.cond.endLine = endLine;
+            condRanges.set(e.cond, { start: e.startOffset ?? 0, end: endOffset });
+        }
+    };
+    const pendingEndpoints = [];
+    for (const tok of tokens) {
+        const cname = canon(tok.name);
+        const prefix = tok.name.includes(':') ? tok.name.slice(0, tok.name.indexOf(':')) : '';
+        // --- conditionals ---
+        if (cname === 'c:if' || cname === 'c:choose' || cname === 'c:when' || cname === 'c:otherwise') {
+            if (!tok.closing) {
+                if (tok.selfClosing)
+                    continue;
+                if (cname === 'c:choose') {
+                    stack.push({ name: cname, chooseId: mkId(tok.line) });
+                }
+                else {
+                    const parent = nearestCond();
+                    let chooseGroup;
+                    if (cname !== 'c:if') {
+                        for (let i = stack.length - 1; i >= 0; i--) {
+                            if (stack[i].name === 'c:choose') {
+                                chooseGroup = stack[i].chooseId;
+                                break;
+                            }
+                        }
+                        if (!chooseGroup)
+                            warnings.push(`${file}:${tok.line}: <${tok.name}> outside of c:choose`);
+                    }
+                    const kind = cname === 'c:if' ? 'if' : cname === 'c:when' ? 'when' : 'otherwise';
+                    const rawTest = tok.attrs.test;
+                    const cond = {
+                        id: mkId(tok.line),
+                        kind,
+                        test: rawTest === undefined ? undefined : (stripEl(rawTest) ?? rawTest),
+                        line: tok.line,
+                        endLine: tok.line,
+                        depth: condDepth(),
+                        parent: parent?.id,
+                        chooseGroup,
+                        layout: 'text',
+                        containsTags: [],
+                        containsI18nKeys: [],
+                        label: ''
+                    };
+                    if (kind !== 'otherwise' && rawTest === undefined)
+                        warnings.push(`${file}:${tok.line}: <${tok.name}> without test attribute`);
+                    scan.conditionals.push(cond);
+                    stack.push({ name: cname, cond, startOffset: tok.end });
+                }
+            }
+            else {
+                let idx = -1;
+                for (let i = stack.length - 1; i >= 0; i--) {
+                    if (stack[i].name === cname) {
+                        idx = i;
+                        break;
+                    }
+                }
+                if (idx < 0) {
+                    warnings.push(`${file}:${tok.line}: unmatched </${tok.name}>`);
+                }
+                else {
+                    while (stack.length - 1 > idx) {
+                        const dangling = stack.pop();
+                        warnings.push(`${file}:${tok.line}: <${dangling.name}> was not closed before </${tok.name}>`);
+                        closeEntry(dangling, tok.start, tok.line);
+                    }
+                    closeEntry(stack.pop(), tok.start, tok.line);
+                }
+            }
+            continue;
+        }
+        if (tok.closing)
+            continue;
+        // --- tag-file usage ---
+        const tagdir = prefix ? tagdirByPrefix.get(prefix) : undefined;
+        if (tagdir) {
+            scan.tagUsages.push({ prefix, name: tok.name.slice(prefix.length + 1), tagdir, line: tok.line, offset: tok.start });
+        }
+        // --- i18n ---
+        if (cname === 'spring:theme' || cname === 'spring:message' || cname === 'fmt:message') {
+            const key = cname === 'fmt:message' ? tok.attrs.key : tok.attrs.code;
+            if (key !== undefined) {
+                scan.i18n.push({
+                    key,
+                    tag: cname,
+                    line: tok.line,
+                    offset: tok.start,
+                    defaultText: tok.attrs.text,
+                    dynamic: key.includes('${') || key.trim() === ''
+                });
+            }
+        }
+        // --- aliases ---
+        if (cname === 'c:forEach') {
+            const expr = tok.attrs.items ? stripEl(tok.attrs.items) : undefined;
+            const from = expr ? elPaths(expr)[0] ?? (/^[A-Za-z_]\w*$/.test(expr) ? expr : undefined) : undefined;
+            if (tok.attrs.var)
+                scan.aliases[tok.attrs.var] = from ? { from, element: true } : { ignore: true };
+            if (tok.attrs.varStatus)
+                scan.aliases[tok.attrs.varStatus] = { ignore: true };
+        }
+        else if (cname === 'c:set') {
+            if (tok.attrs.var) {
+                const expr = tok.attrs.value ? stripEl(tok.attrs.value) : undefined;
+                const from = expr ? elPaths(expr)[0] ?? (/^[A-Za-z_]\w*$/.test(expr) ? expr : undefined) : undefined;
+                scan.aliases[tok.attrs.var] = from ? { from } : { ignore: true };
+            }
+        }
+        else if (tok.attrs.var && !scan.aliases[tok.attrs.var]) {
+            scan.aliases[tok.attrs.var] = { ignore: true };
+        }
+        // --- includes / scripts / cms ---
+        if (cname === 'jsp:include' && tok.attrs.page)
+            scan.includes.push({ kind: 'jsp:include', target: tok.attrs.page, line: tok.line });
+        if (cname === 'jsp:directive.include' && tok.attrs.file)
+            scan.includes.push({ kind: 'directive', target: tok.attrs.file, line: tok.line });
+        if (cname === 'c:import' && tok.attrs.url)
+            scan.includes.push({ kind: 'c:import', target: tok.attrs.url, line: tok.line });
+        if (tok.name.toLowerCase() === 'script' && tok.attrs.src)
+            scan.scriptRefs.push(tok.attrs.src);
+        if (cname === 'cms:pageSlot' && tok.attrs.position)
+            scan.cmsSlots.push({ position: tok.attrs.position, line: tok.line });
+        // --- URL candidates ---
+        if (cname === 'c:url' && tok.attrs.value) {
+            const url = normalizeUrlText(tok.attrs.value);
+            if (url && !isStaticUrl(url)) {
+                pendingEndpoints.push({
+                    tok,
+                    varName: tok.attrs.var,
+                    raw: { kind: 'c:url', method: 'ANY', url, line: tok.line, requestFields: [], responseFields: [], usage: 'navigation' }
+                });
+            }
+        }
+        if ((tok.name === 'form' || cname === 'form:form') && tok.attrs.action) {
+            const url = normalizeUrlText(tok.attrs.action);
+            const method = (tok.attrs.method ?? (cname === 'form:form' ? 'POST' : 'GET')).toUpperCase();
+            if (url && !isStaticUrl(url)) {
+                scan.endpoints.push({
+                    kind: 'form',
+                    method,
+                    url,
+                    line: tok.line,
+                    requestFields: [],
+                    responseFields: [],
+                    usage: method === 'GET' ? 'navigation' : 'ajax'
+                });
+            }
+        }
+    }
+    while (stack.length) {
+        const dangling = stack.pop();
+        warnings.push(`${file}: <${dangling.name}> was never closed`);
+        closeEntry(dangling, source.length, lines.lineAt(source.length));
+    }
+    // 5. Conditional contents (tags, i18n keys, layout hint).
+    const HTML_LAYOUT = { th: 'column', td: 'column', tr: 'row', li: 'item' };
+    for (const cond of scan.conditionals) {
+        const range = condRanges.get(cond);
+        if (!range)
+            continue;
+        for (const u of scan.tagUsages) {
+            if (u.offset >= range.start && u.offset < range.end)
+                cond.containsTags.push(`${u.prefix}:${u.name}`);
+        }
+        for (const r of scan.i18n) {
+            if (r.offset >= range.start && r.offset < range.end && !r.dynamic)
+                cond.containsI18nKeys.push(r.key);
+        }
+        const first = tokens.find((t) => t.start >= range.start && t.start < range.end && !t.closing && !t.name.includes(':'));
+        cond.layout = first ? (HTML_LAYOUT[first.name.toLowerCase()] ?? 'block') : cond.containsTags.length ? 'block' : 'text';
+        cond.containsTags = [...new Set(cond.containsTags)];
+        cond.containsI18nKeys = [...new Set(cond.containsI18nKeys)];
+        cond.label = cond.containsI18nKeys[0] ? `\`${cond.containsI18nKeys[0]}\`` : cond.containsTags[0] ? `\`<${cond.containsTags[0]}>\`` : 'content';
+    }
+    // 6. EL references.
+    const elRe = /\$\{([^}]*)\}/g;
+    const seen = new Set();
+    let em;
+    while ((em = elRe.exec(masked))) {
+        const line = lines.lineAt(em.index);
+        for (const p of elPaths(em[1])) {
+            const k = `${p}@${line}`;
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            scan.elRefs.push({ path: p, line });
+        }
+    }
+    // 7. Endpoints from c:url (usage heuristic) and inline scripts.
+    const scriptText = scriptBodies.map((s) => s.code).join('\n');
+    for (const p of pendingEndpoints) {
+        if (!p.raw)
+            continue;
+        if (p.varName) {
+            const v = p.varName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const inData = new RegExp(`data-[\\w-]+\\s*=\\s*["'][^"']*\\$\\{\\s*${v}\\s*\\}`).test(noScript);
+            const inScript = new RegExp(`\\$\\{\\s*${v}\\s*\\}`).test(scriptText);
+            if (inData || inScript)
+                p.raw.usage = 'ajax';
+        }
+        scan.endpoints.push(p.raw);
+    }
+    for (const s of scriptBodies) {
+        if (!s.code.trim())
+            continue;
+        for (const ep of scanJsEndpoints(s.code, (i) => lines.lineAt(s.offset + i))) {
+            if (!isStaticUrl(ep.url))
+                scan.endpoints.push({ ...ep, usage: 'ajax' });
+        }
+    }
+    // 8. Hardcoded user-facing text.
+    const pieces = [];
+    let cursor = 0;
+    for (const t of tokens) {
+        pieces.push(noScript.slice(cursor, t.start), blank(noScript.slice(t.start, t.end)));
+        cursor = t.end;
+    }
+    pieces.push(noScript.slice(cursor));
+    const textOnly = pieces
+        .join('')
+        .replace(/\$\{[^}]*\}/g, blank)
+        .replace(/&#?\w+;/g, blank);
+    const textLines = textOnly.split('\n');
+    textLines.forEach((ln, i) => {
+        const text = ln.trim();
+        if (/[A-Za-zÀ-ɏ]{2,}/.test(text))
+            scan.hardcoded.push({ text, line: i + 1, kind: 'text' });
+    });
+    for (const t of tokens) {
+        if (t.closing)
+            continue;
+        for (const a of TEXT_ATTRS) {
+            const v = t.attrs[a];
+            if (v && !v.includes('${') && /[A-Za-zÀ-ɏ]{2,}/.test(v)) {
+                scan.hardcoded.push({ text: v.trim(), line: t.line, kind: 'attribute', attribute: a });
+            }
+        }
+    }
+    scan.hardcoded.sort((a, b) => a.line - b.line);
+}