ferrovue 0.3.0 → 0.4.0

package/dist/parens.js

@@ -1,7 +1,3 @@
-/* Rust expressions put together with parentheses only where Rust needs them, so that generated code
- * reads as written by hand and passes rustc's `unused_parens` and clippy without an allow. */
-/** How tightly an expression's outermost operator binds, loosest first. `LOOSE` is anything that is
- * not an operand on its own: `if … { } else { }`, a block, a closure, a range, a struct literal. */
 const LOOSE = 0;
 export const OR = 1;
 const AND = 2;
@@ -10,9 +6,7 @@ const ADD = 4;
 const MUL = 5;
 export const AS = 6;
 export const UNARY = 7;
-/** A path, a literal, a call, a macro, a method chain, a field, or something already in brackets. */
 const ATOM = 8;
-/** Binary operators as generated code writes them, one space either side. */
 const BINARY = [
     [/^ \|\| /, OR],
     [/^ && /, AND],
@@ -21,8 +15,6 @@ const BINARY = [
     [/^ [*/%] /, MUL],
     [/^ as /, AS],
 ];
-/** The index of the last character of a string or character literal that opens at `i`, or `i`
- * itself for anything else — a lifetime's quote among them, which is never closed. */
 function literalEnd(code, i) {
     if (code[i] === "'") {
         if (code[i + 1] === "\\")
@@ -39,7 +31,6 @@ function literalEnd(code, i) {
     }
     return code.length;
 }
-/** The index of the bracket that closes the one at `i`, or -1. Literals are skipped. */
 function closing(code, i) {
     let depth = 0;
     for (let j = i; j < code.length; j++) {
@@ -56,8 +47,6 @@ function closing(code, i) {
     }
     return -1;
 }
-/** The binary operators at the outermost level of `code`, each with where its spaced form starts and
- * how tightly it binds; `null` for anything the scan does not recognise as operands and operators. */
 function topLevel(code) {
     if (/^(?:if|match|let|move|loop|unsafe)\b/.test(code) || code.startsWith("|") || code.startsWith("{"))
         return null;
@@ -87,8 +76,6 @@ function topLevel(code) {
     }
     return ops;
 }
-/** How tightly `code` binds as an operand. Read from its text: only its outermost level counts, and
- * anything the scan does not recognise counts as `LOOSE`, which only ever adds parentheses. */
 export function binding(code) {
     const ops = topLevel(code);
     if (!ops)
@@ -97,64 +84,45 @@ export function binding(code) {
         return Math.min(...ops.map((o) => o.p));
     return /^[&*!-]/.test(code) ? UNARY : ATOM;
 }
-/** How many times `code` names the variable `name`: not inside a literal, and not as a field, which
- * `.name` is — though `1..=name` is the variable. */
 export function occurrences(code, name) {
     const text = code.replace(/'(?:[^'\\]|\\u\{[0-9a-f]+\}|\\.)'|"(?:[^"\\]|\\.)*"/g, '""');
     return text.match(new RegExp(`(?<![\\w$])(?<![^.]\\.)${name.replace(/\$/g, "\\$")}(?![\\w$])`, "g"))?.length ?? 0;
 }
-/** `code` as an operand that must bind at least as tightly as `min`. */
 export function operand(code, min) {
     return binding(code) >= min ? code : `(${code})`;
 }
-/** `code` before `.method()` or `.field`. */
 export function atom(code) {
     return operand(code, ATOM);
 }
-/** `code` as a whole expression — an argument, a binding's value, a block's result — without
- * parentheses that only wrap all of it. */
 export function bare(code) {
     while (code.startsWith("(") && enclosed(code))
         code = code.slice(1, -1);
     return code;
 }
-/** Whether `code` is one bracketed group: `(…)`, `[…]`, `{…}`. */
 export function enclosed(code) {
     return /^[([{]/.test(code) && closing(code, 0) === code.length - 1;
 }
-/** `code` as an `if`'s condition: bare, unless it is a block, whose `{` Rust would read as the
- * start of the body. */
 export function condition(code) {
     const inner = bare(code);
     return inner.startsWith("{") ? `(${inner})` : inner;
 }
-/** A float literal as generated code writes one: `0.5f64`, `2.0f64`, `1e-7f64`. */
 const FLOAT_LITERAL = /^-?\d[\d.]*(?:e-?\d+)?f64$/;
-/** `a op b`, each side parenthesised only where Rust would read it otherwise. Rust's comparisons do
- * not chain, so both of their operands bind more tightly than they do. A float literal beside a
- * value drops its suffix, the value giving it its type, but keeps it beside another literal. */
 export function binary(a, op, b) {
     const p = BINARY.find(([re]) => re.test(` ${op} `))[1];
     const plain = (x, other) => (FLOAT_LITERAL.test(x) && !FLOAT_LITERAL.test(other) ? x.slice(0, -3) : x);
-    // `x as f64 < y` would read the `<` as the start of the type's generic arguments.
     const left = operand(plain(a, b), p === CMP ? p + 1 : p);
     const cast = op === "<" && topLevel(left)?.at(-1)?.op === "as";
     const right = operand(plain(b, a), p + 1);
-    // `&x == &y` compares what they borrow, which `x == y` does without the borrows.
     if ((op === "==" || op === "!=") && /^&[^&]/.test(left) && /^&[^&]/.test(right))
         return `${left.slice(1)} ${op} ${right.slice(1)}`;
     return `${cast ? `(${left})` : left} ${op} ${right}`;
 }
-/** `-code`, where `-(-x)` is `x`. */
 export function negate(code) {
     if (code.startsWith("-") && binding(code) === UNARY)
         return code.slice(1);
     return `-${operand(code, UNARY)}`;
 }
-/** Each ordering comparison's opposite, where neither side is NaN. */
 export const FLIPPED = { "<": ">=", ">": "<=", "<=": ">", ">=": "<" };
-/** `!code`, folded where it can be: `!true` is `false`, `!!x` is `x`, `!(a == b)` is `a != b`, and
- * `!(a < b)` is `a >= b` unless one is NaN. */
 export function not(code) {
     if (code === "true" || code === "false")
         return String(code === "false");
@@ -167,7 +135,6 @@ export function not(code) {
     const eq = cmps.length === 1 && (cmps[0].op === "==" || cmps[0].op === "!=") ? cmps[0] : null;
     if (eq)
         return `${code.slice(0, eq.at)} ${eq.op === "==" ? "!=" : "=="} ${code.slice(eq.at + eq.op.length + 2)}`;
-    // Of doubles, `!(a < b)` also holds when either is NaN.
     const order = cmps.length === 1 ? cmps[0] : null;
     if (order) {
         const [a, b] = [code.slice(0, order.at), code.slice(order.at + order.op.length + 2)];
@@ -176,7 +143,6 @@ export function not(code) {
     }
     return `!${operand(code, UNARY)}`;
 }
-/** `a && b` and `a || b`, with a constant side folded away. Neither side has effects. */
 export function logical(a, op, b) {
     const absorbing = op === "&&" ? "false" : "true";
     if (a === absorbing || b === absorbing)
@@ -188,11 +154,9 @@ export function logical(a, op, b) {
         return a;
     return binary(a, op, b);
 }
-/** `if test { yes } else { no }` taken apart, or `null` for anything else. */
 export function ifElse(code) {
     if (!code.startsWith("if "))
         return null;
-    // The body opens at the first brace outside brackets: a condition holds none of its own.
     let open = -1;
     for (let i = 3; i < code.length && open < 0; i++) {
         const ch = code[i];
@@ -210,10 +174,7 @@ export function ifElse(code) {
         return null;
     return { test: code.slice(3, open - 1), yes: code.slice(open + 2, close - 1), no: code.slice(close + 9, -2) };
 }
-/** A `&str` expression where a `&str` parameter takes it: `&*x` is `&x`, which deref coercion turns
- * into the `&str`, and `&**v` is `v`. */
 export function strArg(code) {
-    // Each branch of an `if` is coerced on its own.
     const branches = ifElse(code);
     if (branches)
         return `if ${branches.test} { ${strArg(branches.yes)} } else { ${strArg(branches.no)} }`;
@@ -222,17 +183,12 @@ export function strArg(code) {
         return code;
     return m[1] ? m[2] : `&${m[2]}`;
 }
-/** `recv.call` for a method of `str` that returns a `bool`: on each branch when `recv` is an `if`,
- * whose branches may borrow different types that only a parameter would coerce. */
 export function callOn(recv, call) {
     const branches = ifElse(recv);
     if (branches)
         return `if ${branches.test} { ${callOn(branches.yes, call)} } else { ${callOn(branches.no, call)} }`;
     return `${receiver(recv)}.${call}`;
 }
-/** The receiver of a method of `str` or `f64`: `&*x` and `*v` are `x` and `v`, which auto-deref
- * reaches the value through. Not for a method that references have too, such as `to_owned`. A
- * float literal keeps its suffix, without which the method's receiver type would be ambiguous. */
 export function receiver(code) {
     const m = /^[&*]+(.*)$/s.exec(code);
     return m && binding(m[1]) === ATOM ? m[1] : atom(code);

package/dist/plugin.d.ts

@@ -0,0 +1,84 @@
+import type { SFCDescriptor } from "@vue/compiler-sfc";
+import { type Component, type N, type Scope, type Struct, type StructTy, type Ty, type Val } from "./model.ts";
+import { type Config } from "./context.ts";
+import { type Emitter } from "./emitter.ts";
+import type { Presence } from "./narrowing.ts";
+export interface RenderParam {
+    name: string;
+    ty: string;
+    pageTy: string;
+    reads(comp: Component): boolean;
+    test: {
+        lines: string[];
+        arg: string;
+        fixture?: boolean;
+        after?: string[];
+    };
+    fixtureField?: string;
+    fixtureDefault?: string;
+    testSupport?: string;
+}
+export interface SlotField {
+    js: string;
+    rust: string;
+    doc: string;
+}
+export interface ValueHooks {
+    describe?(ty: Ty): string | undefined;
+    truthy?(v: Val): string | undefined;
+    interpolate?(e: Emitter, v: Val): boolean;
+    unbindable?(ty: Ty): {
+        what: string;
+        fix: string;
+    } | undefined;
+    nullish?(s: Scope, a: Val, b: Val, n: N): Val | undefined;
+    equals?(a: Val, b: Val): string | undefined;
+    isArray?(v: Val): Val | undefined;
+}
+export interface ReadComponent {
+    comp: Component;
+    ssr: string;
+    children: Map<string, string>;
+    attrsBindings: Set<string>;
+}
+export interface Plugin<Run = unknown, Local = unknown> {
+    name: string;
+    configure?(config: Config, root: string): Run;
+    prepare?(root: string): void;
+    sfc?(comp: Component, descriptor: SFCDescriptor, file: string, source: string): void;
+    templateOptions?(comp: Component): {
+        id: string;
+        scoped: boolean;
+        slotted: boolean;
+    };
+    importedType?(comp: Component, file: string, name: string, local: string): boolean;
+    struct?(ty: StructTy): {
+        st: Struct | undefined;
+        module: string;
+    } | null;
+    compiled?(comp: Component, code: string, script: N[]): void;
+    analyse?(read: ReadComponent[]): void;
+    scope?(s: Scope): Local;
+    scriptImport?(s: Scope, st: N, from: string): boolean;
+    scriptBinding?(s: Scope, d: N): boolean;
+    global?(s: Scope, name: string, n: N): Val | null;
+    call?(s: Scope, n: N): Val | null;
+    member?(s: Scope, base: Val, prop: string, n: N, computed: boolean): Val | null;
+    equality?(s: Scope, n: N): Val | null;
+    presence?(s: Scope, n: N): Presence | null | undefined;
+    values?: ValueHooks;
+    resolveComponent?(s: Scope, local: string, name: string): boolean;
+    component?(s: Scope, e: Emitter, n: N): boolean;
+    child?(s: Scope, child: Component, n: N): void;
+    childIds?(s: Scope, child: Component, passesAttrs: boolean, inSlot: boolean, n: N): string | null;
+    statement?(s: Scope, e: Emitter, call: N, st: N): boolean;
+    params?: RenderParam[];
+    slotFields?(comp: Component): SlotField[];
+    modules?(): [string, string][];
+}
+export declare function runOf<Run>(plugin: Plugin<Run>): Run;
+export declare function scopeOf<Local>(plugin: Plugin<unknown, Local>, s: Scope): Local;
+export declare function claim<T>(ask: (p: Plugin) => T | null | undefined): T | undefined;
+export declare function renderParams(): RenderParam[];
+export declare function paramsOf(comp: Component): RenderParam[];
+export declare function slotFieldsOf(comp: Component): SlotField[];

package/dist/plugin.js

@@ -0,0 +1,26 @@
+import {} from "./model.js";
+import { ctx } from "./context.js";
+import {} from "./emitter.js";
+export function runOf(plugin) {
+    return ctx.runs.get(plugin);
+}
+export function scopeOf(plugin, s) {
+    return s.plugins.get(plugin);
+}
+export function claim(ask) {
+    for (const p of ctx.plugins) {
+        const answer = ask(p);
+        if (answer !== null && answer !== undefined)
+            return answer;
+    }
+    return undefined;
+}
+export function renderParams() {
+    return ctx.plugins.flatMap((p) => p.params ?? []);
+}
+export function paramsOf(comp) {
+    return renderParams().filter((p) => comp.takes.has(p.name));
+}
+export function slotFieldsOf(comp) {
+    return ctx.plugins.flatMap((p) => p.slotFields?.(comp) ?? []);
+}

package/dist/plugins/i18n.d.ts

@@ -0,0 +1,23 @@
+import { type Component, type N } from "../model.ts";
+import { type Plugin } from "../plugin.ts";
+export interface LocaleMessages {
+    name: string;
+    file: string;
+    messages: Map<string, N>;
+}
+export interface I18nSetup {
+    dir: string;
+    locales: LocaleMessages[];
+    locale: string;
+    fallback: string[];
+}
+interface I18nRun {
+    setup: I18nSetup | null;
+    readers: Set<Component>;
+}
+interface I18nScope {
+    useI18n: string | null;
+    t: Set<string>;
+}
+export declare const i18n: Plugin<I18nRun, I18nScope>;
+export {};

package/dist/{i18n.js → plugins/i18n.js}

@@ -1,17 +1,13 @@
-/* vue-i18n: the locale files read and compiled to Rust tables, and `$t` / `useI18n().t` calls. */
 import { readdirSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { createParser } from "@intlify/message-compiler";
-import { fail, GenError, rustStr, STR } from "./model.js";
-import { ctx } from "./context.js";
-import { expr } from "./expr.js";
-import { bare, strArg } from "./parens.js";
-import { header } from "./rust.js";
-/** The modifiers vue-i18n defines for linked messages; any other would throw in the browser. */
+import { fail, GenError, rustStr, STR } from "../model.js";
+import { expr } from "../expr.js";
+import { bare, strArg } from "../parens.js";
+import { header } from "../rust.js";
+import { runOf, scopeOf } from "../plugin.js";
 const MODIFIERS = new Set(["upper", "lower", "capitalize"]);
-/** Every message of every `*.json` locale file in the directory: nested objects joined with dots,
- * as vue-i18n resolves a path — a nested key first, then a flat key of the same spelling. */
-export function readLocales(root, config) {
+function readLocales(root, config) {
     const dir = join(root, config.messages);
     const files = readdirSync(dir).filter((f) => f.endsWith(".json")).toSorted();
     const parser = createParser({});
@@ -30,7 +26,6 @@ export function readLocales(root, config) {
         const walk = (value, path) => {
             if (typeof value === "string") {
                 const key = path.join(".");
-                // A key spelled with dots is reached only when no nested path is.
                 (path.length > 1 ? nested : flat).set(key, value);
             }
             else if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -52,7 +47,6 @@ export function readLocales(root, config) {
     const fallback = config.fallbackLocale === undefined ? [] : Array.isArray(config.fallbackLocale) ? config.fallbackLocale : [config.fallbackLocale];
     return { dir: config.messages, locales, locale: config.locale ?? "en", fallback };
 }
-/** A message's AST as the Rust `Message` literal: its cases, each a list of `Part`s. */
 function messageSource(file, key, ast) {
     const body = ast.body;
     const cases = body.type === 1 ? body.cases : [body];
@@ -82,11 +76,10 @@ function messageSource(file, key, ast) {
     const items = (c) => c.items ?? (c.static !== undefined ? [{ type: 3, value: c.static }] : []);
     return `Message { cases: &[${cases.map((c) => `&[${items(c).map(part).join(", ")}]`).join(", ")}] }`;
 }
-/** Keys in the order Rust's `str` sorts them — byte order — for the table's binary search. */
 function byteOrder(a, b) {
     return Buffer.compare(Buffer.from(a), Buffer.from(b));
 }
-export function i18nSource(setup) {
+function i18nSource(setup) {
     const locales = setup.locales
         .map((l) => {
         const keys = [...l.messages.keys()].toSorted(byteOrder);
@@ -121,7 +114,6 @@ pub fn i18n(locale: &str) -> ferrovue::I18n {
 }
 `;
 }
-/** A value interpolated into a message, as \`ferrovue::i18n::Value\`. */
 function i18nValue(s, n) {
     const v = expr(s, n);
     switch (v.ty.k) {
@@ -137,10 +129,8 @@ function i18nValue(s, n) {
             return fail(s.comp, "a value given to `t()` is a string, a number or a boolean that is present: narrow an optional one with `v-if` first", n);
     }
 }
-/** `t(key)`, `t(key, plural)`, `t(key, { named })`, `t(key, [list])`, `t(key, { named }, plural)`:
- * the message translated in the request's locale. */
-export function translate(s, args, n) {
-    if (!ctx.i18n)
+function translate(s, args, n) {
+    if (!runOf(i18n).setup)
         fail(s.comp, "`t()` needs `i18n` in ferrovue.config.json: where the locale files are", n);
     if (args.length < 1 || args.length > 3)
         fail(s.comp, "`t()` takes a key, then named values, a list or a plural number", n);
@@ -173,3 +163,70 @@ export function translate(s, args, n) {
     }
     return { code: `&*fv_i18n.t(${strArg(key.code)}, &fv::i18n::Args { named: ${named}, list: ${list}, plural: ${plural} })`, ty: STR };
 }
+export const i18n = {
+    name: "i18n",
+    configure: (config, root) => ({ setup: config.i18n ? readLocales(root, config.i18n) : null, readers: new Set() }),
+    compiled(comp, code) {
+        if (code.includes("_ctx.$t("))
+            runOf(i18n).readers.add(comp);
+    },
+    scope: () => ({ useI18n: null, t: new Set() }),
+    scriptImport(s, st, from) {
+        if (from !== "vue-i18n")
+            return false;
+        for (const sp of st.specifiers) {
+            const name = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : null;
+            if (name === "useI18n")
+                scopeOf(i18n, s).useI18n = sp.local.name;
+            else
+                s.clientOnly.set(sp.local.name, `\`${name}\` from vue-i18n does not run on the server`);
+        }
+        return true;
+    },
+    scriptBinding(s, d) {
+        const own = scopeOf(i18n, s);
+        const init = d.init;
+        if (own.useI18n === null || d.id.type !== "ObjectPattern" || init?.type !== "CallExpression" || init.callee.type !== "Identifier" || init.callee.name !== own.useI18n) {
+            return false;
+        }
+        for (const p of d.id.properties) {
+            if (p.type !== "ObjectProperty" || p.computed || p.value.type !== "Identifier") {
+                fail(s.comp, "`useI18n()` is destructured into plain names", p);
+            }
+            const key = p.key.name ?? p.key.value;
+            if (key === "t")
+                own.t.add(p.value.name);
+            else if (key === "locale") {
+                s.setup.set(p.value.name, { code: "fv_i18n.locale()", ty: STR });
+                s.refs.add(p.value.name);
+            }
+            else
+                s.clientOnly.set(p.value.name, `\`${key}\` from \`useI18n()\` does not run on the server`);
+        }
+        runOf(i18n).readers.add(s.comp);
+        return true;
+    },
+    call(s, n) {
+        const callee = n.callee;
+        const { t } = scopeOf(i18n, s);
+        const translates = callee.type === "Identifier"
+            ? t.has(callee.name)
+            : callee.object.type === "Identifier" &&
+                ((callee.object.name === "_ctx" && callee.property.name === "$t") || (callee.object.name === "$setup" && t.has(callee.property.name)));
+        return translates ? translate(s, n.arguments, n) : null;
+    },
+    params: [
+        {
+            name: "fv_i18n",
+            ty: "&fv::I18n",
+            pageTy: "&'p fv::I18n",
+            reads: (c) => runOf(i18n).readers.has(c),
+            test: { lines: ["let i18n = i18n::i18n(fixture.locale.as_deref().unwrap_or(i18n::LOCALE));"], arg: "&i18n", fixture: true },
+            fixtureField: '    #[serde(rename = "$locale", default)]\n    locale: Option<String>,',
+        },
+    ],
+    modules() {
+        const { setup } = runOf(i18n);
+        return setup ? [["i18n.rs", i18nSource(setup)]] : [];
+    },
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from "../plugin.ts";
+export declare const PLUGINS: readonly Plugin[];

package/dist/plugins/index.js

@@ -0,0 +1,8 @@
+import {} from "../plugin.js";
+import { router } from "./router.js";
+import { piniaStores } from "./stores.js";
+import { sharedTypes } from "./shared-types.js";
+import { i18n } from "./i18n.js";
+import { teleport } from "./teleport.js";
+import { scoped } from "./scoped.js";
+export const PLUGINS = [router, piniaStores, sharedTypes, i18n, teleport, scoped];

package/dist/plugins/router-link.d.ts

@@ -0,0 +1,8 @@
+import { type N, type Scope, type Val } from "../model.ts";
+import { Emitter } from "../emitter.ts";
+export declare const ROUTER_LINK_PROPS: Set<string>;
+export declare const ROUTER_LINK_INERT: Set<string>;
+export declare function routeParams(path: string): string[];
+export declare function urlText(s: Scope, v: Val, n: N): string;
+export declare function resolveLink(s: Scope, e: Emitter, to: N): void;
+export declare function routerLink(s: Scope, e: Emitter, n: N): void;

package/dist/{router.js → plugins/router-link.js}

@@ -1,28 +1,27 @@
-/* `<RouterLink>`, its locations, and the routes file. */
 import { escapeHtml } from "@vue/shared";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { camelize, fail, GenError, rustStr } from "./model.js";
-import { allRoutes, CONFIG_FILE, ctx } from "./context.js";
-import { expr, lonely } from "./expr.js";
-import { bare, condition, strArg } from "./parens.js";
-import { Emitter } from "./emitter.js";
-import { attrOf, classItems, dollarAttrs, IGNORED_PROPS, isAttrs, mergedParts, mergeProps, renderDynamicAttr, renderStyle } from "./attrs.js";
-import { slotBody, statements } from "./template.js";
+import { camelize, fail, rustStr } from "../model.js";
+import { CONFIG_FILE } from "../context.js";
+import { expr } from "../expr.js";
+import { lonely } from "../strings.js";
+import { bare, condition, strArg } from "../parens.js";
+import { Emitter } from "../emitter.js";
+import { attrOf, dollarAttrs, IGNORED_PROPS, isAttrs, mergedParts, mergeProps, renderDynamicAttr } from "../attrs.js";
+import { renderStyle } from "../styles.js";
+import { classItems } from "../classes.js";
+import { statements } from "../template.js";
+import { slotBody } from "../slots.js";
+import { runOf } from "../plugin.js";
+import { scopeIdOf } from "./scoped.js";
+import { allRoutes, router } from "./router.js";
 export const ROUTER_LINK_PROPS = new Set(["to", "class", "activeClass", "exactActiveClass", "ariaCurrentValue"]);
-/** `<RouterLink>` props that change only what a click does, which the server does not render. */
 export const ROUTER_LINK_INERT = new Set(["replace", "viewTransition"]);
-/** The parameter names of a route path, in order. */
 export function routeParams(path) {
     return [...path.matchAll(/:(\w+)/g)].map((m) => m[1]);
 }
-/** A string written into a link, which vue-router percent-encodes: half of a surrogate pair makes
- * `encodeURI` throw, so Vue renders no page at all. */
 function noHalves(s, v, n) {
     if (v.lone)
         fail(s.comp, lonely("a `<RouterLink>` location"), n);
 }
-/** A value written into a URL — a parameter or a query value — as the `&str` vue-router stringifies. */
 export function urlText(s, v, n) {
     noHalves(s, v, n);
     if (v.ty.k === "str")
@@ -33,7 +32,6 @@ export function urlText(s, v, n) {
         return `if ${condition(v.code)} { "true" } else { "false" }`;
     return fail(s.comp, "a route parameter is a string or a number that is present", n);
 }
-/** \`let fv_link = …;\`: a \`<RouterLink>\`'s \`to\` resolved from the reader's route. */
 export function resolveLink(s, e, to) {
     if (to.type !== "ObjectExpression") {
         const target = expr(s, to);
@@ -56,7 +54,6 @@ export function resolveLink(s, e, to) {
     }
     e.open("let fv_link =");
     const query = parts.get("query");
-    // The query, built only when the location has one.
     const search = query ? "&fv_search" : '""';
     if (query) {
         e.stmt("let mut fv_search = String::new();");
@@ -67,7 +64,6 @@ export function resolveLink(s, e, to) {
                 fail(s.comp, "a query holds plain keys", p);
             const key = String(p.key.name ?? p.key.value);
             const v = expr(s, p.value);
-            // An absent value leaves its key out, as `undefined` does.
             if (v.ty.k === "undef")
                 continue;
             if (v.ty.k === "opt") {
@@ -93,7 +89,7 @@ export function resolveLink(s, e, to) {
     if (name) {
         if (name.type !== "StringLiteral")
             fail(s.comp, "a `to`'s `name` is a string literal, checked against the routes", name);
-        const route = allRoutes(ctx.routes).find((r) => r.name === name.value);
+        const route = allRoutes(runOf(router).routes).find((r) => r.name === name.value);
         if (!route)
             fail(s.comp, `no route is called \`${name.value}\``, name);
         const wanted = routeParams(route.fullPath);
@@ -130,8 +126,6 @@ export function resolveLink(s, e, to) {
         fail(s.comp, "a `to` object has a `name` or a `path`", to);
     e.close(";");
 }
-/** \`<RouterLink to="...">\` as vue-router renders it: \`aria-current\` and the active classes when it
- * points where the reader is, then \`href\`, then the link's own class and attributes. */
 export function routerLink(s, e, n) {
     const [, rawProps, slots, , slotScopeId] = n.arguments;
     let props = rawProps;
@@ -161,18 +155,11 @@ export function routerLink(s, e, n) {
     const to = fields.get("to");
     if (!to)
         fail(s.comp, "`<RouterLink>` needs `to`", n);
-    /* vue-router renders the link from virtual nodes (`renderElementVNode`). The `<a>` takes the ids
-     * of a component's root after its attributes: what the parent passes on when the link is its
-     * root, the id of the component that wrote it, and the slot scope ids around it — as
-     * `scope_attrs` gathers them. Its content takes that component's id, which the compiled template
-     * spells out, and the slot scope ids again, each once: unlike the raw `_scopeId` the compiled
-     * elements would write, so an element there is refused when there are some. */
     const passed = (rawProps?.type === "Identifier" && rawProps.name === "_attrs") || rawProps?.arguments?.some((a) => a.type === "Identifier" && a.name === "_attrs");
     const base = passed ? s.attrs : null;
     const slotted = slotScopeId ? s.sid : null;
-    const scopeId = s.comp.scopeId;
+    const scopeId = scopeIdOf(s.comp);
     const content = slots?.type === "ObjectExpression" ? slots.properties.filter((p) => (p.key?.name ?? p.key?.value) !== "_").map((p) => p.value) : [];
-    /** Whether the link's content holds a node that `is` picks out. */
     const holds = (is) => {
         const within = (x) => !!x && typeof x === "object" && (is(x) || Object.values(x).some(within));
         return content.some((c) => slotBody(s, c).some(within));
@@ -181,13 +168,11 @@ export function routerLink(s, e, n) {
     if (slotted !== null && holds(writesScopeId)) {
         fail(s.comp, "an element inside a `<RouterLink>` in slot content given a slot scope id: vue-router writes those ids by rules of its own", to);
     }
-    // A `<slot>` there is rendered as a virtual node too, which passes its own slot scope ids.
     if ((scopeId !== null || slotted !== null || base !== null) && holds((x) => x.type === "CallExpression" && x.callee.name === "_ssrRenderSlot")) {
         fail(s.comp, "a `<slot>` inside a `<RouterLink>` that takes scope ids: vue-router renders it by rules of its own", to);
     }
-    if (!ctx.routes)
+    if (!runOf(router).routes)
         fail(s.comp, `\`<RouterLink>\` needs \`routes\` in ${CONFIG_FILE}: the paths it resolves against`, n);
-    /** A literal-string prop, which the class names and `aria-current` must be. */
     const literal = (key, fallback) => {
         const v = fields.get(key);
         if (!v)
@@ -196,14 +181,12 @@ export function routerLink(s, e, n) {
             fail(s.comp, `\`${key}\` on \`<RouterLink>\` is a string literal`, v);
         return v.value;
     };
-    const activeClass = literal("activeClass", ctx.linkActive);
-    const exactClass = literal("exactActiveClass", ctx.linkExactActive);
+    const activeClass = literal("activeClass", runOf(router).linkActive);
+    const exactClass = literal("exactActiveClass", runOf(router).linkExactActive);
     const ariaCurrent = literal("ariaCurrentValue", "page");
     e.open("");
     resolveLink(s, e, to);
     e.lit("<a");
-    /* Attributes this component is passed fall through to the link: merged into its virtual node's
-     * props with the template's, then onto the `<a>` vue-router renders. */
     const parts = mergedParts(rawProps);
     const passedOn = (p) => s.fallthrough !== null && ((isAttrs(p) && s.comp.inheritAttrs) || dollarAttrs(s, p));
     const fallsThrough = parts.some(passedOn);
@@ -224,8 +207,6 @@ export function routerLink(s, e, n) {
     e.lit(' href="');
     e.stmt("fv::escape_into(out, &fv_link.href);");
     e.lit('" class="');
-    // `{ [activeClass]: isActive, [exactActiveClass]: isExactActive }`. When the two are one class,
-    // the later key wins: the class goes with `isExactActive`.
     const linkItems = activeClass === exactClass
         ? [`if fv_link.exact { ${rustStr(exactClass)} } else { "" }`]
         : [`if fv_link.active { ${rustStr(activeClass)} } else { "" }`, `if fv_link.exact { ${rustStr(exactClass)} } else { "" }`];
@@ -251,7 +232,6 @@ export function routerLink(s, e, n) {
         e.stmt(`out.push_str(&fv::scope_attrs(${base ?? '""'}, ${scopeId === null ? '""' : rustStr(scopeId)}, ${slotted ?? '""'}));`);
     if (fallsThrough) {
         e.close(" else {");
-        // The template's attributes for the link, merged in their order with those passed on.
         const sources = [];
         for (const p of parts) {
             if (passedOn(p))
@@ -274,7 +254,6 @@ export function routerLink(s, e, n) {
         const ids = base === null && slotted === null
             ? rustStr(scopeId === null ? "" : ` ${scopeId}`)
             : `&fv::scope_attrs(${base ?? '""'}, ${scopeId === null ? '""' : rustStr(scopeId)}, ${slotted ?? '""'})`;
-        // vue-router's own: `aria-current` (`null` when the link is not exact), `href`, its classes.
         const linkOwn = [
             `("aria-current", if fv_link.exact { fv::Attr::str(${rustStr(ariaCurrent)}) } else { fv::Attr::Undefined })`,
             '("href", fv::Attr::str(&fv_link.href))',
@@ -299,24 +278,3 @@ export function routerLink(s, e, n) {
     e.lit("</a>");
     e.close();
 }
-/** The routes file: vue-router paths, each a string or `{ "path", "name" }`. */
-export function readRoutes(root, file) {
-    const raw = JSON.parse(readFileSync(join(root, file), "utf8"));
-    if (!Array.isArray(raw))
-        throw new GenError(`${file} lists the routes in an array`);
-    const read = (list, parent) => list.map((r) => {
-        const o = (typeof r === "string" ? { path: r } : r);
-        if (typeof o?.path !== "string" || (o.name !== undefined && typeof o.name !== "string") || (o.children !== undefined && !Array.isArray(o.children))) {
-            throw new GenError(`${file}: a route is a path, or \`{ "path": "…", "name": "…", "children": [ … ] }\``);
-        }
-        // A child's path joins its parent's unless it starts with `/`; an empty one is the parent's.
-        const fullPath = parent === null || o.path.startsWith("/") ? o.path : `${parent}${parent.endsWith("/") || o.path === "" ? "" : "/"}${o.path}`;
-        const def = { path: o.path, fullPath };
-        if (o.name !== undefined)
-            def.name = o.name;
-        if (o.children)
-            def.children = read(o.children, fullPath);
-        return def;
-    });
-    return read(raw, null);
-}