nene-lang 0.1.0 → 0.1.2

package/build/lsp.js

@@ -4,14 +4,25 @@
 // できること:
 //   - 保存前の内容も含めて型検査し、エラーを表示する（diagnostics）
 //   - 名前やタグにカーソルを置くと型を表示する（hover）
-//   - 定義へ移動する（definition）
+//   - 定義へ移動する（definition）、参照一覧（references）、名前の一括変更（rename）
 //   - 補完（タグと必須の属性・閉じタグ、属性、import するモジュール、フィールド、名前）
+//   - 関数の引数のヒント（signatureHelp）
 //   - 色分け（部品と HTML 要素、コンストラクタ、フィールド、引数などを区別する semantic tokens）
+//   - アウトライン（documentSymbol）、プロジェクト全体のシンボル検索（workspace/symbol）
+//   - 折りたたみ（foldingRange）、構造に沿った選択（selectionRange）
+//   - 整形（formatting。nene fmt と同じ）
+//   - コードアクション（部品の import を足す、JSX の {} の式を where に取り出す）
+import { readFileSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { compileProgram, listModules, projectRoot } from "./compiler.js";
+import { codeActions } from "./actions.js";
+import { compileProgram, listModules, projectFiles, projectRoot } from "./compiler.js";
+import { format } from "./format.js";
+import { foldingRanges, outline, parse, selectionRange } from "./outline.js";
+import { definitionOf, referencesOf, renameProblem, replacementFor } from "./references.js";
 import { HTML_ATTRS, HTML_ELEMENTS } from "./checker.js";
 import { CompileError } from "./syntax.js";
 import { flattenRecord, prune } from "./types.js";
+const VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 const docs = new Map(); // uri → 編集中の内容
 const results = new Map(); // uri → 最後に成功した検査結果と、そのときの内容
 const timers = new Map();
@@ -101,6 +112,188 @@ function schedule(uri) {
     clearTimeout(timers.get(uri));
     timers.set(uri, setTimeout(() => validate(uri), 150));
 }
+// ---- プロジェクト全体 ----
+function textOf(uri) {
+    const open = docs.get(uri);
+    if (open !== undefined)
+        return open;
+    try {
+        return readFileSync(fileURLToPath(uri), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+// このファイルのプロジェクトのフォルダ（src/ など。モジュール名から求める）
+function rootOf(uri) {
+    const name = /^module\s+([\w.]+)/m.exec(textOf(uri))?.[1];
+    return name ? projectRoot(fileURLToPath(uri), name) : null;
+}
+// プロジェクトのすべてのモジュールを、編集中の内容で型検査したもの。型検査の通らないモジュールは除く
+function projectModules(uri) {
+    const root = rootOf(uri);
+    if (!root)
+        return compiledModule(uri) ? [compiledModule(uri)] : [];
+    const overrides = new Map();
+    for (const [u, text] of docs)
+        overrides.set(fileURLToPath(u), text);
+    const seen = new Map();
+    for (const file of projectFiles(root)) {
+        if (seen.has(file))
+            continue;
+        try {
+            for (const m of compileProgram(file, { overrides, requireMain: false }).modules)
+                seen.set(m.file, m);
+        }
+        catch {
+            // エラーのあるモジュールは、参照を数えられない
+        }
+    }
+    return [...seen.values()];
+}
+const inside = (file, root) => file.startsWith(root.endsWith("/") ? root : root + "/");
+function locationOf(o) {
+    return { uri: pathToFileURL(o.file).href, range: toRange(o.pos, o.length) };
+}
+function references(uri, line, character) {
+    const h = hoverAt(uri, line, character);
+    const def = h && definitionOf(h);
+    if (!def)
+        return [];
+    return referencesOf(def, projectModules(uri)).map(locationOf);
+}
+// 名前を変えられるかを確かめ、変える名前の範囲を返す。変えられないときは理由
+function renameTarget(uri, line, character) {
+    const h = hoverAt(uri, line, character);
+    const def = h && definitionOf(h);
+    if (!h || !def || h.label?.().startsWith("module "))
+        return "ここには変えられる名前がありません";
+    const root = rootOf(uri);
+    if (!root || !inside(def.file, root))
+        return "標準ライブラリやパッケージの名前は変えられません";
+    const name = h.name.slice(h.name.lastIndexOf(".") + 1);
+    const file = def.file.split("/").pop().replace(/\.nn$/, "");
+    if (name.toLowerCase() === file.toLowerCase())
+        return `${name} はファイルと同じ名前の主部品なので、ファイル名と一緒に変えてください`;
+    const col = h.pos.col + (h.name.length - name.length);
+    return { def, occurrence: { file: fileURLToPath(uri), pos: { line: h.pos.line, col }, length: name.length, text: name } };
+}
+function rename(uri, line, character, newName) {
+    const target = renameTarget(uri, line, character);
+    if (typeof target === "string")
+        throw new LspError(target);
+    const refs = referencesOf(target.def, projectModules(uri));
+    // 定義に書いてある名前で、新しい名前の種類を確かめる
+    const original = refs.find((r) => r.file === target.def.file && r.pos.line === target.def.pos.line)?.text ?? target.occurrence.text;
+    const problem = renameProblem(original, newName);
+    if (problem)
+        throw new LspError(problem);
+    const changes = {};
+    for (const r of refs) {
+        const u = pathToFileURL(r.file).href;
+        // 型検査のあとで書き換わっていたら、その場所は変えない
+        const lineText = textOf(u).split("\n")[r.pos.line - 1] ?? "";
+        if (lineText.slice(r.pos.col - 1, r.pos.col - 1 + r.length) !== r.text)
+            continue;
+        (changes[u] ??= []).push({ range: toRange(r.pos, r.length), newText: replacementFor(r.text, newName) });
+    }
+    return { changes };
+}
+class LspError extends Error {
+}
+// ---- シンボル ----
+function workspaceSymbols(query) {
+    const anyUri = [...docs.keys()][0];
+    const root = anyUri ? rootOf(anyUri) : null;
+    if (!root)
+        return [];
+    const q = query.toLowerCase();
+    const out = [];
+    for (const file of projectFiles(root)) {
+        const uri = pathToFileURL(file).href;
+        const text = textOf(uri);
+        const mod = parse(text, file);
+        if (!mod)
+            continue;
+        const walk = (symbols, container) => {
+            for (const sym of symbols) {
+                if (sym.name.toLowerCase().includes(q))
+                    out.push({ name: sym.name, kind: sym.kind, containerName: container ?? mod.name, location: { uri, range: sym.selectionRange } });
+                if (sym.children)
+                    walk(sym.children, sym.name);
+            }
+        };
+        walk(outline(text, mod));
+    }
+    return out.slice(0, 500);
+}
+// ---- 引数のヒント ----
+// カーソルの前にある関数適用（f a b ...）の、関数の型と、いま何番目の引数を書いているか
+function signatureHelp(uri, line, character) {
+    const mod = compiledModule(uri);
+    if (!mod)
+        return null;
+    const before = (textOf(uri).split("\n")[line] ?? "").slice(0, character);
+    // 開いた括弧や = のあとから、カーソルまでを見る
+    let depth = 0;
+    let start = before.length;
+    for (let i = before.length - 1; i >= 0; i--) {
+        const c = before[i];
+        if (c === ")" || c === "]" || c === "}")
+            depth++;
+        else if (c === "(" || c === "[" || c === "{") {
+            if (depth === 0)
+                break;
+            depth--;
+        }
+        else if (depth === 0 && (c === "=" || c === "," || c === "|" || c === "$"))
+            break;
+        start = i;
+    }
+    const expr = before.slice(start);
+    const m = /^\s*([A-Z][\w]*(?:\.[A-Z][\w]*)*\.)?([a-z_][\w']*)\s/.exec(expr);
+    if (!m)
+        return null;
+    const name = (m[1] ?? "") + m[2];
+    const detail = m[1]
+        ? mod.completion.quals.get(m[1].slice(0, -1))?.find((q) => q.name === m[2])?.detail
+        : mod.completion.values.find((v) => v.name === name)?.detail;
+    if (!detail || !detail.includes("->"))
+        return null;
+    const params = splitArrows(detail);
+    params.pop(); // 結果の型
+    // 書き終えた引数の数（括弧の中をまとめた単語の数）
+    const args = expr.slice(m[0].length).replace(/\([^()]*\)|\[[^\[\]]*\]|\{[^{}]*\}|"[^"]*"/g, "x").trim();
+    const written = args === "" ? 0 : args.split(/\s+/).length - (before.endsWith(" ") ? 0 : 1);
+    const label = `${name} :: ${detail}`;
+    let offset = label.indexOf("::") + 3;
+    const parameters = params.map((p) => {
+        const at = label.indexOf(p, offset);
+        offset = at + p.length;
+        return { label: [at, at + p.length] };
+    });
+    return { signatures: [{ label, parameters }], activeSignature: 0, activeParameter: Math.min(written, Math.max(0, params.length - 1)) };
+}
+// a -> (b -> c) -> d を [a, (b -> c), d] に分ける
+function splitArrows(type) {
+    const out = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < type.length; i++) {
+        const c = type[i];
+        if (c === "(" || c === "[" || c === "{")
+            depth++;
+        else if (c === ")" || c === "]" || c === "}")
+            depth--;
+        else if (depth === 0 && type.startsWith(" -> ", i)) {
+            out.push(type.slice(start, i).trim());
+            start = i + 4;
+            i += 3;
+        }
+    }
+    out.push(type.slice(start).trim());
+    return out;
+}
 // ---- 色分け ----
 const TOKEN_TYPES = ["namespace", "type", "class", "enumMember", "function", "variable", "parameter", "property", "macro"];
 function semanticTokens(uri) {
@@ -247,8 +440,17 @@ function handle(msg) {
                     definitionProvider: true,
                     completionProvider: { triggerCharacters: ["<", ".", " "] },
                     semanticTokensProvider: { legend: { tokenTypes: TOKEN_TYPES, tokenModifiers: [] }, full: true },
+                    referencesProvider: true,
+                    renameProvider: { prepareProvider: true },
+                    documentSymbolProvider: true,
+                    workspaceSymbolProvider: true,
+                    foldingRangeProvider: true,
+                    selectionRangeProvider: true,
+                    documentFormattingProvider: true,
+                    codeActionProvider: { codeActionKinds: ["quickfix", "refactor.extract"] },
+                    signatureHelpProvider: { triggerCharacters: [" "], retriggerCharacters: [" "] },
                 },
-                serverInfo: { name: "nene", version: "0.1.0" },
+                serverInfo: { name: "nene", version: VERSION },
             });
             return;
         case "textDocument/completion":
@@ -286,6 +488,64 @@ function handle(msg) {
             });
             return;
         }
+        case "textDocument/references":
+            respond(id, references(params.textDocument.uri, params.position.line, params.position.character));
+            return;
+        case "textDocument/prepareRename": {
+            const target = renameTarget(params.textDocument.uri, params.position.line, params.position.character);
+            if (typeof target === "string")
+                send({ id, error: { code: -32803, message: target } });
+            else
+                respond(id, { range: toRange(target.occurrence.pos, target.occurrence.length), placeholder: target.occurrence.text });
+            return;
+        }
+        case "textDocument/rename":
+            try {
+                respond(id, rename(params.textDocument.uri, params.position.line, params.position.character, params.newName));
+            }
+            catch (e) {
+                if (!(e instanceof LspError))
+                    throw e;
+                send({ id, error: { code: -32803, message: e.message } });
+            }
+            return;
+        case "textDocument/documentSymbol": {
+            const uri = params.textDocument.uri;
+            const mod = parse(textOf(uri), fileURLToPath(uri));
+            respond(id, mod ? outline(textOf(uri), mod) : []);
+            return;
+        }
+        case "workspace/symbol":
+            respond(id, workspaceSymbols(params.query ?? ""));
+            return;
+        case "textDocument/foldingRange": {
+            const uri = params.textDocument.uri;
+            respond(id, foldingRanges(textOf(uri), parse(textOf(uri), fileURLToPath(uri))));
+            return;
+        }
+        case "textDocument/selectionRange": {
+            const uri = params.textDocument.uri;
+            const mod = parse(textOf(uri), fileURLToPath(uri));
+            respond(id, params.positions.map((p) => selectionRange(textOf(uri), mod, p.line, p.character) ?? { range: { start: p, end: p } }));
+            return;
+        }
+        case "textDocument/formatting": {
+            const text = textOf(params.textDocument.uri);
+            const formatted = format(text);
+            const lines = text.split("\n");
+            const whole = { start: { line: 0, character: 0 }, end: { line: lines.length, character: 0 } };
+            respond(id, formatted === text ? [] : [{ range: whole, newText: formatted }]);
+            return;
+        }
+        case "textDocument/codeAction": {
+            const uri = params.textDocument.uri;
+            const root = rootOf(uri);
+            respond(id, codeActions({ uri, text: textOf(uri), diagnostics: params.context.diagnostics, modules: root ? listModules(root) : [] }));
+            return;
+        }
+        case "textDocument/signatureHelp":
+            respond(id, signatureHelp(params.textDocument.uri, params.position.line, params.position.character));
+            return;
         case "textDocument/definition": {
             const h = hoverAt(params.textDocument.uri, params.position.line, params.position.character);
             const def = typeof h?.def === "function" ? h.def() : h?.def;

package/build/outline.d.ts

@@ -0,0 +1,49 @@
+import type { Module } from "./syntax.ts";
+export interface Range {
+    start: {
+        line: number;
+        character: number;
+    };
+    end: {
+        line: number;
+        character: number;
+    };
+}
+export interface OutlineSymbol {
+    name: string;
+    detail?: string;
+    kind: number;
+    range: Range;
+    selectionRange: Range;
+    children?: OutlineSymbol[];
+}
+export declare const SYMBOL: {
+    module: number;
+    class: number;
+    method: number;
+    field: number;
+    enum: number;
+    function: number;
+    variable: number;
+    enumMember: number;
+    struct: number;
+};
+export interface FoldingRange {
+    startLine: number;
+    endLine: number;
+    kind?: "comment" | "imports" | "region";
+}
+export declare function parse(text: string, file: string): Module | null;
+export declare function outline(text: string, mod: Module): OutlineSymbol[];
+interface Span {
+    start: number;
+    end: number;
+}
+export declare function jsxElements(text: string): Span[];
+export declare function foldingRanges(text: string, mod: Module | null): FoldingRange[];
+export interface SelectionRange {
+    range: Range;
+    parent?: SelectionRange;
+}
+export declare function selectionRange(text: string, mod: Module | null, line: number, character: number): SelectionRange | null;
+export {};

package/build/outline.js

@@ -0,0 +1,298 @@
+// ファイルの構造を、エディタの機能のために取り出す
+//
+//   - アウトライン（関数・型・コンストラクタ・フィールド・where の中の定義）
+//   - 折りたたみ（宣言・where・JSX の要素・import のまとまり・コメント・style ブロック）
+//   - 構造に沿った選択（名前 → JSX の要素 → 等式 → 宣言 と広げる）
+//
+// 型検査が通らない書きかけのファイルでも使えるよう、構文だけを見る。
+import { parseModule } from "./parser.js";
+export const SYMBOL = { module: 2, class: 5, method: 6, field: 8, enum: 10, function: 12, variable: 13, enumMember: 22, struct: 23 };
+// 構文が読めなければ null
+export function parse(text, file) {
+    try {
+        return parseModule(text, file);
+    }
+    catch {
+        return null;
+    }
+}
+// ---- アウトライン ----
+export function outline(text, mod) {
+    const lines = text.split("\n");
+    const ends = declEnds(lines, mod);
+    const range = (pos) => ({
+        start: { line: pos.line - 1, character: pos.col - 1 },
+        end: { line: ends(pos.line - 1), character: lines[ends(pos.line - 1)]?.length ?? 0 },
+    });
+    const name = (pos, n) => ({
+        start: { line: pos.line - 1, character: pos.col - 1 },
+        end: { line: pos.line - 1, character: pos.col - 1 + n.length },
+    });
+    const symbols = [];
+    for (const d of mod.datas) {
+        symbols.push({
+            name: d.name,
+            detail: d.params.join(" "),
+            kind: SYMBOL.enum,
+            range: range(d.pos),
+            selectionRange: name(d.namePos, d.name),
+            children: d.ctors.map((c) => ({ name: c.name, kind: SYMBOL.enumMember, range: name(c.pos, c.name), selectionRange: name(c.pos, c.name) })),
+        });
+    }
+    for (const a of mod.aliases) {
+        const fields = a.body.k === "trecord" ? a.body.fields : [];
+        symbols.push({
+            name: a.name,
+            kind: SYMBOL.struct,
+            range: range(a.pos),
+            selectionRange: name(a.namePos, a.name),
+            children: fields.map((f) => ({ name: f.name, kind: SYMBOL.field, range: name(f.pos, f.name), selectionRange: name(f.pos, f.name) })),
+        });
+    }
+    for (const f of mod.foreigns) {
+        symbols.push({ name: f.name, detail: "foreign", kind: SYMBOL.function, range: range(f.pos), selectionRange: name(f.sig.pos, f.name) });
+    }
+    for (const b of mod.body.bindings)
+        symbols.push(bindingSymbol(b, lines, range(b.sig?.pos ?? b.pos)));
+    if (mod.style) {
+        const line = mod.style.pos.line - 2; // style と書いた行
+        const r = { start: { line, character: 0 }, end: { line: lines.length - 1, character: 0 } };
+        symbols.push({ name: "style", kind: SYMBOL.module, range: r, selectionRange: { start: { line, character: 0 }, end: { line, character: 5 } } });
+    }
+    return symbols.sort((a, b) => a.range.start.line - b.range.start.line);
+}
+function bindingSymbol(b, lines, range) {
+    const sigText = b.sig ? (lines[b.sig.pos.line - 1] ?? "").split("::").slice(1).join("::").trim() : undefined;
+    const isFunction = b.equations[0].params.length > 0 || (sigText?.includes("->") ?? false);
+    const pos = b.equations[0].pos;
+    const children = b.equations.flatMap((eq) => eq.where.bindings).map((w) => {
+        const first = w.equations[0].pos;
+        const last = w.equations[w.equations.length - 1].pos;
+        const start = (w.sig?.pos ?? first).line - 1;
+        const r = { start: { line: start, character: 0 }, end: { line: blockEnd(lines, last.line - 1), character: 0 } };
+        return bindingSymbol(w, lines, r);
+    });
+    return {
+        name: b.name,
+        detail: sigText,
+        kind: isFunction ? SYMBOL.function : SYMBOL.variable,
+        range,
+        selectionRange: { start: { line: pos.line - 1, character: pos.col - 1 }, end: { line: pos.line - 1, character: pos.col - 1 + b.name.length } },
+        children: children.length > 0 ? children : undefined,
+    };
+}
+// トップレベルの宣言が終わる行（次の宣言の手前。末尾の空行とコメントは含めない）
+function declEnds(lines, mod) {
+    const starts = [
+        ...mod.imports.map((d) => d.pos.line - 1),
+        ...mod.datas.map((d) => d.pos.line - 1),
+        ...mod.aliases.map((d) => d.pos.line - 1),
+        ...mod.foreigns.map((d) => d.pos.line - 1),
+        ...mod.body.bindings.map((b) => (b.sig?.pos ?? b.pos).line - 1),
+        ...mod.body.bindings.flatMap((b) => b.equations.map((e) => e.pos.line - 1)),
+        ...(mod.style ? [mod.style.pos.line - 2] : []),
+        lines.length,
+    ].sort((a, b) => a - b);
+    return (line) => {
+        let next = starts.find((s) => s > line) ?? lines.length;
+        // 同じ名前の等式が続くときは、まとめて 1 つの宣言とみなす
+        while (next < lines.length && sameBinding(lines[line], lines[next]))
+            next = starts.find((s) => s > next) ?? lines.length;
+        let end = next - 1;
+        while (end > line && /^\s*(--.*)?$/.test(lines[end]))
+            end--;
+        return end;
+    };
+}
+const KEYWORDS = new Set(["module", "import", "foreign", "data", "type", "style"]);
+function sameBinding(a, b) {
+    const name = (l) => /^([a-z_][\w']*)\s/.exec(l)?.[1];
+    const na = name(a);
+    return na !== undefined && !KEYWORDS.has(na) && na === name(b) && !/^\S+\s+::/.test(b);
+}
+// その行から、字下げがより深い行が続くあいだ（where の中の定義の終わり）
+function blockEnd(lines, line) {
+    const indent = lines[line].length - lines[line].trimStart().length;
+    let end = line;
+    for (let i = line + 1; i < lines.length; i++) {
+        if (lines[i].trim() === "")
+            continue;
+        if (lines[i].length - lines[i].trimStart().length <= indent)
+            break;
+        end = i;
+    }
+    return end;
+}
+// JSX の要素（<Tag ...>...</Tag>、<Tag />、<>...</>）の範囲。文字列とコメントは読み飛ばす
+export function jsxElements(text) {
+    const spans = [];
+    const stack = [];
+    let i = 0;
+    while (i < text.length) {
+        const c = text[i];
+        if (c === '"') {
+            i++;
+            while (i < text.length && text[i] !== '"' && text[i] !== "\n")
+                i += text[i] === "\\" ? 2 : 1;
+            i++;
+            continue;
+        }
+        if (c === "-" && text[i + 1] === "-") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (c === "\n" && text.startsWith("style\n", i + 1))
+            break; // style ブロックは CSS
+        if (c === "<" && text[i + 1] === "/") {
+            const close = text.indexOf(">", i);
+            if (close < 0)
+                break;
+            const start = stack.pop();
+            if (start !== undefined)
+                spans.push({ start, end: close + 1 });
+            i = close + 1;
+            continue;
+        }
+        if (c === "<" && /[A-Za-z>]/.test(text[i + 1] ?? "")) {
+            const end = tagEnd(text, i);
+            if (end < 0)
+                break;
+            if (text[end - 1] === "/")
+                spans.push({ start: i, end: end + 1 });
+            else
+                stack.push(i);
+            i = end + 1;
+            continue;
+        }
+        i++;
+    }
+    return spans;
+}
+// 開きタグの > の位置（属性の {…} と "…" の中の > は数えない）
+function tagEnd(text, from) {
+    let depth = 0;
+    for (let i = from + 1; i < text.length; i++) {
+        const c = text[i];
+        if (c === '"') {
+            i = text.indexOf('"', i + 1);
+            if (i < 0)
+                return -1;
+        }
+        else if (c === "{")
+            depth++;
+        else if (c === "}")
+            depth--;
+        else if (c === ">" && depth === 0)
+            return i;
+    }
+    return -1;
+}
+// ---- 折りたたみ ----
+export function foldingRanges(text, mod) {
+    const lines = text.split("\n");
+    const out = [];
+    const add = (startLine, endLine, kind) => {
+        if (endLine > startLine)
+            out.push({ startLine, endLine, ...(kind ? { kind } : {}) });
+    };
+    if (mod) {
+        const walk = (symbols) => {
+            for (const s of symbols) {
+                add(s.range.start.line, s.range.end.line);
+                if (s.children)
+                    walk(s.children);
+            }
+        };
+        walk(outline(text, mod));
+        if (mod.imports.length > 1)
+            add(mod.imports[0].pos.line - 1, mod.imports[mod.imports.length - 1].pos.line - 1, "imports");
+    }
+    const lineOf = offsetToLine(text);
+    // JSX の要素は、閉じタグの行を残して畳む（<Row ... /> のような自分で閉じる要素は最後の行まで）
+    for (const s of jsxElements(text)) {
+        const last = lineOf(s.end - 1);
+        add(lineOf(s.start), text[s.end - 2] === "/" ? last : last - 1);
+    }
+    // 続けて書いた -- のコメント（style ブロックの CSS 変数は除く）
+    const codeEnd = lines.indexOf("style");
+    for (let i = 0; i < (codeEnd < 0 ? lines.length : codeEnd); i++) {
+        if (!/^\s*--/.test(lines[i]))
+            continue;
+        let j = i;
+        while (j + 1 < lines.length && /^\s*--/.test(lines[j + 1]))
+            j++;
+        add(i, j, "comment");
+        i = j;
+    }
+    return out;
+}
+const offsetToLine = (text) => {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++)
+        if (text[i] === "\n")
+            starts.push(i + 1);
+    return (offset) => {
+        let lo = 0;
+        let hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (starts[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo;
+    };
+};
+// 名前 → それを囲む JSX の要素（内側から）→ 等式・定義 → トップレベルの宣言
+export function selectionRange(text, mod, line, character) {
+    const lines = text.split("\n");
+    const lineStarts = [0];
+    for (let i = 0; i < text.length; i++)
+        if (text[i] === "\n")
+            lineStarts.push(i + 1);
+    const offset = (lineStarts[line] ?? text.length) + character;
+    const toPos = (o) => {
+        let l = lineStarts.length - 1;
+        while (lineStarts[l] > o)
+            l--;
+        return { line: l, character: o - lineStarts[l] };
+    };
+    const spans = [];
+    const word = /[\w'.]*$/.exec(text.slice(0, offset))[0].length;
+    const after = /^[\w']*/.exec(text.slice(offset))[0].length;
+    if (word + after > 0)
+        spans.push({ start: offset - word, end: offset + after });
+    const elements = jsxElements(text)
+        .filter((s) => s.start <= offset && offset < s.end)
+        .sort((a, b) => b.start - a.start || a.end - b.end);
+    spans.push(...elements);
+    if (mod) {
+        const nested = [];
+        const walk = (symbols) => {
+            for (const s of symbols) {
+                if (s.range.start.line <= line && line <= s.range.end.line) {
+                    nested.unshift(s.range);
+                    if (s.children)
+                        walk(s.children);
+                }
+            }
+        };
+        walk(outline(text, mod));
+        for (const r of nested) {
+            spans.push({ start: lineStarts[r.start.line], end: lineStarts[r.end.line] + lines[r.end.line].length });
+        }
+    }
+    // 外側ほど広くなるよう、広がらないものは除く
+    const chain = [];
+    for (const s of spans) {
+        const prev = chain[chain.length - 1];
+        if (!prev || (s.start <= prev.start && s.end >= prev.end && (s.start < prev.start || s.end > prev.end)))
+            chain.push(s);
+    }
+    let result;
+    for (const s of chain.reverse())
+        result = { range: { start: toPos(s.start), end: toPos(s.end) }, parent: result };
+    return result ?? null;
+}

package/build/packages.js

@@ -1,5 +1,5 @@
 // Nene のパッケージを探す。パッケージは package.json に次のように書いた npm パッケージで、
-// source のフォルダにモジュールを置く（nene-ui なら src/Ui/Button.nn が Ui.Button）
+// source のフォルダにモジュールを置く（nene-lang-ui なら src/Ui/Button.nn が Ui.Button）
 //
 //   "nene": { "source": "src" }
 //

package/build/prerender.d.ts

@@ -0,0 +1,8 @@
+export interface PrerenderOptions {
+    outDir: string;
+    entry: string;
+    base: string;
+    env: Record<string, string>;
+    mount?: string;
+}
+export declare function prerenderSite(options: PrerenderOptions): string[];