ferrovue 0.1.0 → 0.2.0

package/dist/model.d.ts

@@ -0,0 +1,248 @@
+import type { SourceMapConsumer } from "source-map-js";
+export type N = any;
+export type Ty = {
+    k: "str";
+} | {
+    k: "int";
+}
+/** `Float` from `ferrovue/types`, or a fractional literal: an `f64`, a JavaScript number. */
+ | {
+    k: "float";
+} | {
+    k: "bool";
+} | {
+    k: "undef";
+} | {
+    k: "opt";
+    of: Ty;
+} | {
+    k: "list";
+    of: Ty;
+}
+/** `Record<string, T>`: an object used as a dictionary, `ferrovue::Record` in Rust, its keys in
+ * JavaScript's order. */
+ | {
+    k: "record";
+    of: Ty;
+}
+/** `store` marks a Pinia store's state, or a type inside it, declared in a store's own file;
+ * `home` a type declared elsewhere: `"types"` for a shared `.ts` file, or the component whose
+ * `.vue` file declares it. */
+ | {
+    k: "struct";
+    name: string;
+    store?: true;
+    home?: string;
+}
+/** `TrustedHtml` from `ferrovue/types`: the configured Rust type, which `v-html` writes raw. */
+ | {
+    k: "html";
+}
+/** Another component's `Props`, imported from its `.vue` file: what `v-bind` hands that child. */
+ | {
+    k: "child";
+    name: string;
+}
+/** `useRoute()` or `$route`: the reader's location, as vue-router resolved it. */
+ | {
+    k: "route";
+}
+/** `route.params`. */
+ | {
+    k: "params";
+}
+/** `route.query`, and one of its values: a string, \`null\`, an array of those, or absent. */
+ | {
+    k: "queryobj";
+} | {
+    k: "query";
+};
+export interface Field {
+    js: string;
+    rust: string;
+    ty: Ty;
+    /** For an optional prop: the Rust value Vue uses when it is absent — its declared default, or
+     * `false` for a boolean, which Vue casts. Reading the prop reads this in place of `None`. */
+    dflt?: string;
+}
+export interface Struct {
+    name: string;
+    fields: Field[];
+    /** The props a scoped slot's outlet passes: fields that borrow from the render, read as they are. */
+    slot?: true;
+}
+/** A translated expression: Rust source, and the type it evaluates to. `konst` is a boolean known
+ * at generation time, which is how `Array.isArray` on a value that is never an array folds away. */
+export interface Val {
+    code: string;
+    ty: Ty;
+    konst?: boolean;
+    /** For an integer computed from others: the same computation on doubles, before it is rounded
+     * back to an \`i64\` — which keeps JavaScript's \`-0\`, so a division by it is \`-Infinity\`. */
+    f64?: string;
+    /** For a list a template computes — `filter`, `map`, `split`, `Object.keys` — an iterator of its
+     * items, each a `Cow<str>`, a copied number or boolean, or a borrowed object. `code` is then those
+     * items collected into a `Vec`. */
+    iter?: string;
+    /** For a string, or a list of strings: it may hold half of a surrogate pair, which JavaScript
+     * keeps and ferrovue writes as U+FFFD — so two such values are never compared or joined. */
+    lone?: boolean;
+    /** For an optional string a temporary owns: that `Option<Cow<str>>`, whose `.as_deref()` is
+     * `code`. A setup `let` keeps this. */
+    held?: string;
+    /** A number known at generation time: a literal, or literals JavaScript computed. */
+    num?: number;
+    /** For a string built by `format!`: its format string and arguments, which a string built from it
+     * joins rather than formatting it again. */
+    format?: {
+        text: string;
+        args: string[];
+    };
+}
+export declare const STR: Ty;
+export declare const INT: Ty;
+export declare const FLOAT: Ty;
+export declare const BOOL: Ty;
+export declare const UNDEF: Ty;
+export declare const opt: (of: Ty) => Ty;
+export declare const RUST_KEYWORDS: Set<string>;
+/** Types the generated code names, which an interface of the same name would shadow. */
+export declare const RUST_PRELUDE: Set<string>;
+export declare function snake(js: string): string;
+export declare function rustStr(s: string): string;
+/** One character as a Rust `char` literal. */
+export declare function rustChar(ch: string): string;
+export declare class GenError extends Error {
+}
+export interface Component {
+    /** `TagEditor` */
+    name: string;
+    /** `tag_editor` */
+    module: string;
+    file: string;
+    /** The file's text, which an error quotes. */
+    source?: string;
+    /** Vue's compiled template mapped back to the template, and where the template's content starts
+     * in the file, for an error found in the compiled code. */
+    templateMap?: SourceMapConsumer;
+    templateStart?: {
+        line: number;
+        column: number;
+    };
+    props: Struct;
+    structs: Map<string, Struct>;
+    /** The local name `TrustedHtml` was imported under from `ferrovue/types`, if it was. */
+    trustedName: string | null;
+    /** The local name `Float` was imported under from `ferrovue/types`, if it was. */
+    floatName: string | null;
+    /** Types imported as another component's `Props`: local name → that component's name. */
+    childProps: Map<string, string>;
+    /** The components it imports, by name. */
+    imports: Set<string>;
+    /** The slots its template renders with `<slot>`, by name, in order of first appearance. */
+    slotNames: string[];
+    /** Whether its template holds `<RouterView>`: the page, which the server supplies. */
+    routerView: boolean;
+    /** Whether its template holds `<RouterLink>`. */
+    routerLink: boolean;
+    /** Whether it reads the route itself: `useRoute()`, or `$route` in the template. */
+    readsRoute: boolean;
+    /** Whether it renders a `<RouterLink>` or reads the route, itself or through a child, and so
+     * takes the route. */
+    usesRoute: boolean;
+    /** Whether its setup reads a store. */
+    readsStores: boolean;
+    /** Whether it reads a store, itself or through a child, and so takes the stores' state. */
+    usesStores: boolean;
+    /** Whether it translates — \`$t\`, or \`useI18n()\` in setup — and whether it or a child does, and
+     * so takes the request's \`I18n\`. */
+    readsI18n: boolean;
+    usesI18n: boolean;
+    /** Whether it renders a \`<Teleport>\`, and whether it or a child does, and so takes the page's
+     * \`Teleports\`. */
+    readsTeleports: boolean;
+    usesTeleports: boolean;
+    /** `defineModel` bindings: local name → the prop it reads. */
+    models: Map<string, string>;
+    /** Type aliases it declares: name → the type. */
+    aliases: Map<string, N>;
+    /** Types it imports from elsewhere: local name → the type, marked with where it lives. */
+    importedTypes: Map<string, Ty>;
+    /** Its scoped slots, by name: the props each one's outlets pass, known once its render is
+     * generated, which is why a child is generated before its parents. */
+    slotShapes: Map<string, Struct>;
+    /** `data-v-…`, the id its `<style scoped>` gives its elements, or `null` without one. */
+    scopeId: string | null;
+    /** Whether its scoped styles use `:slotted()`, so that its outlets pass a slot scope id. */
+    slotted: boolean;
+    /** `inheritAttrs` from `defineOptions`: `false` drops what a parent passes on to its root. */
+    inheritAttrs: boolean;
+    /** Whether a parent may hand its root scope ids — its own, those passed on to it, or a slot's —
+     * which it then takes as `fv_attrs`. Known once every component is read (`scopeFlow`). */
+    inherits: boolean;
+    /** Whether its outlets may pass slot content a slot scope id, which the content then takes as
+     * `fv_sid`. Known once every component is read, as `inherits` is. */
+    passesSlotIds: boolean;
+}
+export interface Scope {
+    comp: Component;
+    components: Map<string, Component>;
+    /** Setup bindings the server can evaluate: `ref(...)` and `computed(() => ...)`. */
+    setup: Map<string, Val>;
+    /** Imported child components, by local name. */
+    children: Map<string, string>;
+    /** Imported helpers, by local name → helper name. */
+    helpers: Map<string, string>;
+    /** Loop variables in scope. */
+    locals: Map<string, Val>;
+    /** The identifier `defineProps` was assigned to in the script, if any. */
+    propsIdent: string | null;
+    /** Setup bindings that are refs — `ref`, `computed`, `storeToRefs`, `defineModel` — which code in
+     * the script reads through `.value`, and the template unwrapped. */
+    refs: Set<string>;
+    /** Setup bindings the server does not evaluate, and why. The template may name one only from an
+     * event handler, which the server drops. */
+    clientOnly: Map<string, string>;
+    /** Optional values a surrounding `v-if` has found present, by the JavaScript path that named them
+     * — what TypeScript narrows, and what the generated `if let` bound. */
+    narrowed: Map<string, Val>;
+    /** The name the compiled template resolved this component itself under, when it uses itself. */
+    selfAlias: {
+        name: string | null;
+    };
+    /** What the helper calls translated so far can write, shared by every copy of the scope. */
+    helperBytes: {
+        n: number;
+    };
+    /** The names the compiled template resolved `RouterLink` and `RouterView` under. */
+    router: Map<string, "RouterLink" | "RouterView">;
+    /** Directives the compiled template resolved by name: local → the directive's name. */
+    directives: Map<string, string>;
+    /** Setup bindings that are vue-i18n's \`t\`, from \`const { t } = useI18n()\`. */
+    i18nT: Set<string>;
+    /** Inside slot content whose emptiness is decided at run time: each push that is not a comment
+     * sets the closure's `filled`, which is how Vue tells content from nothing (`ssrRenderSlot`). */
+    fill: boolean;
+    /** Inside a `<RouterLink>`'s slot, which Vue renders from virtual nodes rather than pushes: an
+     * untaken `v-if` is `<!--v-if-->` there, not `<!---->`. */
+    vnode: boolean;
+    /** The Rust value of `_attrs`, the scope ids this render's root inherits, as `ssrRenderAttrs`
+     * writes them; `null` when the component inherits none. */
+    attrs: string | null;
+    /** The Rust value of `_scopeId` inside slot content: the slot scope id the content is given, or
+     * `null` where it is always empty. */
+    sid: string | null;
+    /** Inside a `v-for` over a list of the props: the Rust name of its item, and the list. */
+    loop?: {
+        item: string;
+        over: string;
+    };
+}
+/** Where a node came from, which decides how its position is read: `source` for an AST parsed
+ * from the file itself (a script block, a store, a type file), whose positions are the file's;
+ * `template` for Vue's compiled template, whose positions map back through its source map. */
+export type Origin = "source" | "template";
+/** Mark every node of an AST with where it came from, so that an error can point into the file. */
+export declare function tagAst(node: N, origin: Origin, seen?: WeakSet<object>): void;
+export declare function fail(comp: Component, what: string, node?: N): never;
+export declare function sameTy(a: Ty, b: Ty): boolean;

package/dist/model.js

@@ -0,0 +1,102 @@
+/* The compiler's model: the types it gives values, the shapes of components and scopes, and the errors it raises. (Not `types.ts`, which is the public `ferrovue/types` module.) */
+export const STR = { k: "str" };
+export const INT = { k: "int" };
+export const FLOAT = { k: "float" };
+export const BOOL = { k: "bool" };
+export const UNDEF = { k: "undef" };
+export const opt = (of) => (of.k === "opt" ? of : { k: "opt", of });
+export const RUST_KEYWORDS = new Set("as break const continue crate else enum extern false fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait true type unsafe use where while async await dyn abstract become box do final macro override priv typeof unsized virtual yield try".split(" "));
+/** Types the generated code names, which an interface of the same name would shadow. */
+export const RUST_PRELUDE = new Set(["Option", "Some", "None", "Vec", "String", "Box", "Result", "Ok", "Err", "Cow", "Slots", "Default"]);
+export function snake(js) {
+    const s = js.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase()).replace(/^_/, "");
+    return RUST_KEYWORDS.has(s) ? `r#${s}` : s;
+}
+export function rustStr(s) {
+    let out = '"';
+    for (const ch of s) {
+        const c = ch.codePointAt(0);
+        if (ch === '"')
+            out += '\\"';
+        else if (ch === "\\")
+            out += "\\\\";
+        else if (ch === "\n")
+            out += "\\n";
+        else if (ch === "\r")
+            out += "\\r";
+        else if (ch === "\t")
+            out += "\\t";
+        else if (c < 0x20 || c === 0x7f)
+            out += `\\u{${c.toString(16)}}`;
+        else
+            out += ch;
+    }
+    return out + '"';
+}
+/** One character as a Rust `char` literal. */
+export function rustChar(ch) {
+    if (ch === "'")
+        return "'\\''";
+    if (ch === '"')
+        return `'"'`;
+    return `'${rustStr(ch).slice(1, -1)}'`;
+}
+export class GenError extends Error {
+}
+/** Mark every node of an AST with where it came from, so that an error can point into the file. */
+export function tagAst(node, origin, seen = new WeakSet()) {
+    // `compileScript` links some nodes back to others, so the tree may hold cycles.
+    if (!node || typeof node !== "object" || seen.has(node))
+        return;
+    seen.add(node);
+    if (Array.isArray(node)) {
+        for (const n of node)
+            tagAst(n, origin, seen);
+        return;
+    }
+    if (typeof node.type === "string")
+        node.__fv = origin;
+    for (const key of Object.keys(node)) {
+        if (key === "loc" || key === "__fv")
+            continue;
+        const v = node[key];
+        if (v && typeof v === "object")
+            tagAst(v, origin, seen);
+    }
+}
+/** A node's position in the component's own file — line from 1, column from 0 — or `null`. */
+function locate(comp, node) {
+    const start = node?.loc?.start;
+    if (!start)
+        return null;
+    if (node.__fv === "source")
+        return { line: start.line, column: start.column };
+    if (node.__fv === "template" && comp.templateMap && comp.templateStart) {
+        const o = comp.templateMap.originalPositionFor({ line: start.line, column: start.column });
+        if (o.line == null || o.column == null)
+            return null;
+        // The template's content starts partway along the `<template>` line.
+        const t = comp.templateStart;
+        return o.line === 1 ? { line: t.line, column: t.column - 1 + o.column } : { line: t.line + o.line - 1, column: o.column };
+    }
+    return null;
+}
+/** The source line, with a caret under the column, as rustc shows it. */
+function snippet(comp, at) {
+    const text = comp.source?.split("\n")[at.line - 1];
+    if (text === undefined)
+        return "";
+    const n = String(at.line);
+    // Tabs are kept, so the caret lines up whatever the tab width.
+    const lead = text.slice(0, at.column).replace(/[^\t]/g, " ");
+    return `\n ${n} | ${text}\n ${" ".repeat(n.length)} | ${lead}^`;
+}
+export function fail(comp, what, node) {
+    const at = locate(comp, node);
+    if (!at)
+        throw new GenError(`${comp.file}: ${what}`);
+    throw new GenError(`${comp.file}:${at.line}:${at.column + 1}: ${what}${snippet(comp, at)}`);
+}
+export function sameTy(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}

package/dist/parens.d.ts

@@ -0,0 +1,51 @@
+export declare const OR = 1;
+export declare const CMP = 3;
+export declare const AS = 6;
+export declare const UNARY = 7;
+/** 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 declare function binding(code: string): number;
+/** 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 declare function occurrences(code: string, name: string): number;
+/** `code` as an operand that must bind at least as tightly as `min`. */
+export declare function operand(code: string, min: number): string;
+/** `code` before `.method()` or `.field`. */
+export declare function atom(code: string): string;
+/** `code` as a whole expression — an argument, a binding's value, a block's result — without
+ * parentheses that only wrap all of it. */
+export declare function bare(code: string): string;
+/** Whether `code` is one bracketed group: `(…)`, `[…]`, `{…}`. */
+export declare function enclosed(code: string): boolean;
+/** `code` as an `if`'s condition: bare, unless it is a block, whose `{` Rust would read as the
+ * start of the body. */
+export declare function condition(code: string): string;
+/** `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 declare function binary(a: string, op: string, b: string): string;
+/** `-code`, where `-(-x)` is `x`. */
+export declare function negate(code: string): string;
+/** Each ordering comparison's opposite, where neither side is NaN. */
+export declare const FLIPPED: Record<string, string>;
+/** `!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 declare function not(code: string): string;
+/** `a && b` and `a || b`, with a constant side folded away. Neither side has effects. */
+export declare function logical(a: string, op: "&&" | "||", b: string): string;
+/** `if test { yes } else { no }` taken apart, or `null` for anything else. */
+export declare function ifElse(code: string): {
+    test: string;
+    yes: string;
+    no: string;
+} | null;
+/** A `&str` expression where a `&str` parameter takes it: `&*x` is `&x`, which deref coercion turns
+ * into the `&str`, and `&**v` is `v`. */
+export declare function strArg(code: string): string;
+/** `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 declare function callOn(recv: string, call: string): string;
+/** 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 declare function receiver(code: string): string;

package/dist/parens.js

@@ -0,0 +1,239 @@
+/* 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;
+export const CMP = 3;
+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],
+    [/^ (?:==|!=|<=|>=|<|>) /, CMP],
+    [/^ [+-] /, ADD],
+    [/^ [*/%] /, 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] === "\\")
+            return code.indexOf("'", i + 3);
+        return code[i + 2] === "'" ? i + 2 : i;
+    }
+    if (code[i] !== '"')
+        return i;
+    for (let j = i + 1; j < code.length; j++) {
+        if (code[j] === "\\")
+            j++;
+        else if (code[j] === '"')
+            return j;
+    }
+    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++) {
+        const ch = code[j];
+        if (ch === '"' || ch === "'")
+            j = literalEnd(code, j);
+        else if (ch === "(" || ch === "[" || ch === "{")
+            depth++;
+        else if (ch === ")" || ch === "]" || ch === "}") {
+            depth--;
+            if (depth === 0)
+                return j;
+        }
+    }
+    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;
+    const ops = [];
+    for (let i = 0; i < code.length; i++) {
+        const ch = code[i];
+        if (ch === '"' || ch === "'") {
+            i = literalEnd(code, i);
+        }
+        else if (ch === "(" || ch === "[" || ch === "{") {
+            i = closing(code, i);
+            if (i < 0)
+                return null;
+        }
+        else if (ch === " ") {
+            const rest = code.slice(i);
+            const found = BINARY.find(([re]) => re.test(rest));
+            if (!found)
+                return null;
+            const spaced = rest.match(found[0])[0];
+            ops.push({ at: i, op: spaced.trim(), p: found[1] });
+            i += spaced.length - 1;
+        }
+        else if (ch === "." && code[i + 1] === ".") {
+            return null;
+        }
+    }
+    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)
+        return LOOSE;
+    if (ops.length)
+        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");
+    if (code.startsWith("!") && binding(code.slice(1)) >= UNARY)
+        return code.slice(1);
+    const option = /^(.*)\.is_(some|none)\(\)$/s.exec(code);
+    if (option && binding(code) === ATOM)
+        return `${option[1]}.is_${option[2] === "some" ? "none" : "some"}()`;
+    const cmps = binding(code) === CMP ? topLevel(code).filter((o) => o.p === CMP) : [];
+    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)];
+        const nan = [a, b].filter((x) => !/^-?[\d.]+(?:e-?\d+)?(?:f64)?$/.test(x)).map((x) => `${receiver(x)}.is_nan()`);
+        return [binary(a, FLIPPED[order.op], b), ...nan].join(" || ");
+    }
+    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)
+        return absorbing;
+    const identity = op === "&&" ? "true" : "false";
+    if (a === identity)
+        return b;
+    if (b === identity)
+        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];
+        if (ch === '"' || ch === "'")
+            i = literalEnd(code, i);
+        else if (ch === "(" || ch === "[")
+            i = closing(code, i);
+        else if (ch === "{")
+            open = i;
+        if (i < 0)
+            return null;
+    }
+    const close = open < 0 ? -1 : closing(code, open);
+    if (close < 0 || !code.startsWith(" else {", close + 1) || closing(code, close + 7) !== code.length - 1)
+        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)} }`;
+    const m = /^&\*(\**)(.*)$/s.exec(code);
+    if (!m || (binding(m[2]) < ATOM && !enclosed(m[2])))
+        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/router.d.ts

@@ -0,0 +1,17 @@
+import { type N, type Scope, type Val } from "./model.ts";
+import { type RouteDef } from "./context.ts";
+import { Emitter } from "./emitter.ts";
+export declare const ROUTER_LINK_PROPS: Set<string>;
+/** `<RouterLink>` props that change only what a click does, which the server does not render. */
+export declare const ROUTER_LINK_INERT: Set<string>;
+/** The parameter names of a route path, in order. */
+export declare function routeParams(path: string): string[];
+/** A value written into a URL — a parameter or a query value — as the `&str` vue-router stringifies. */
+export declare function urlText(s: Scope, v: Val, n: N): string;
+/** \`let fv_link = …;\`: a \`<RouterLink>\`'s \`to\` resolved from the reader's route. */
+export declare function resolveLink(s: Scope, e: Emitter, to: N): void;
+/** \`<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 declare function routerLink(s: Scope, e: Emitter, n: N): void;
+/** The routes file: vue-router paths, each a string or `{ "path", "name" }`. */
+export declare function readRoutes(root: string, file: string): RouteDef[];