ferrovue 0.2.0 → 0.4.0

package/dist/script.js

@@ -1,27 +1,22 @@
-/* `<script setup>` read: what the server evaluates, and what stays on the client. */
 import { basename } from "node:path";
-import { fail, GenError, snake, STR } from "./model.js";
+import { fail, GenError, snake, takesAttrs } from "./model.js";
 import { CONFIG_FILE, ctx } from "./context.js";
 import { definePropsType } from "./typescript.js";
-import { expr, fieldVal, storeGetter, theRoute } from "./expr.js";
+import { expr, fieldVal } from "./expr.js";
 import { collected, heldList } from "./lists.js";
-import { storeImport } from "./stores.js";
 import { bare, operand, UNARY } from "./parens.js";
-/** Lifecycle hooks, which never run on the server: setup may register them freely. */
+import { known } from "./narrowing.js";
 export const CLIENT_HOOKS = new Set([
     "onMounted", "onBeforeMount", "onUnmounted", "onBeforeUnmount", "onUpdated", "onBeforeUpdate",
     "onActivated", "onDeactivated", "onErrorCaptured", "onRenderTracked", "onRenderTriggered",
 ]);
-/** Compiler macros and calls with no effect on the server's render. */
 export const INERT_CALLS = new Set(["defineEmits", "defineSlots", "defineOptions", "defineExpose", "defineProps", "withDefaults", "provide"]);
-/** A statement in setup that is a call on its own: allowed only when it cannot change the render. */
 export function setupStatement(comp, st) {
     const c = st.expression;
     const name = c?.type === "CallExpression" && c.callee.type === "Identifier" ? c.callee.name : null;
     if (name !== null && (CLIENT_HOOKS.has(name) || INERT_CALLS.has(name)))
         return;
     if (name === "watch") {
-        // A watcher's callback runs on the server only with `immediate`, and could then change state.
         const options = c.arguments[2];
         const immediate = options?.type === "ObjectExpression" && options.properties.some((p) => p.type === "ObjectProperty" && (p.key.name ?? p.key.value) === "immediate" && !(p.value.type === "BooleanLiteral" && !p.value.value));
         if (!immediate)
@@ -35,8 +30,6 @@ export function setupStatement(comp, st) {
         fail(comp, "`onServerPrefetch` fetches on the server; pass the data in as props instead", st);
     fail(comp, `\`${st.expression?.type === "CallExpression" ? `${name ?? "a call"}()` : st.expression?.type}\` in setup could change what renders, and is not translated`, st);
 }
-/** What a setup binding's value is computed from: `ref(x)` and `shallowRef(x)` hold `x`,
- * `computed(() => x)` is `x`, and a plain `const y = x` is `x`. */
 export function setupSource(init) {
     if (init.type === "CallExpression" && init.callee.type === "Identifier") {
         const name = init.callee.name;
@@ -56,7 +49,6 @@ export function setupSource(init) {
         return setupSource(init.expression);
     return init;
 }
-/** The names a destructuring pattern binds. */
 export function patternNames(p) {
     switch (p?.type) {
         case "Identifier":
@@ -87,21 +79,20 @@ export function scopeFor(comp, ast, components) {
         narrowed: new Map(),
         selfAlias: { name: null },
         helperBytes: { n: 0 },
-        router: new Map(),
         directives: new Map(),
-        i18nT: new Set(),
         fill: false,
         vnode: false,
-        attrs: comp.inherits ? "fv_attrs" : null,
+        attrs: comp.inherits ? (takesAttrs(comp) ? "fv_attrs.ids()" : "fv_attrs") : null,
+        fallthrough: takesAttrs(comp) ? "fv_attrs" : null,
+        attrsBindings: new Set(),
         sid: null,
+        plugins: new Map(),
     };
+    for (const p of ctx.plugins)
+        if (p.scope)
+            scope.plugins.set(p, p.scope(scope));
     const lets = [];
-    const storeHooks = new Map();
-    let storeToRefsName = null;
-    let useRouteName = null;
-    let useI18nName = null;
-    /** Setup bindings holding a store, by name. */
-    const storeValues = new Map();
+    let useAttrsName = null;
     for (const st of ast) {
         if (st.type === "ImportDeclaration") {
             const from = st.source.value;
@@ -109,46 +100,14 @@ export function scopeFor(comp, ast, components) {
                 const def = st.specifiers.find((x) => x.type === "ImportDefaultSpecifier");
                 if (def)
                     scope.children.set(def.local.name, basename(from, ".vue"));
+                continue;
             }
-            else if (storeImport(comp, from)) {
-                for (const sp of st.specifiers) {
-                    const hook = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : null;
-                    // A type from the store's file, which `readComponent` has already resolved.
-                    if (st.importKind === "type" || sp.importKind === "type" || (hook !== null && ctx.storeStructs.has(hook)))
-                        continue;
-                    const store = hook ? ctx.stores.get(hook) : undefined;
-                    if (!store || store.module !== storeImport(comp, from))
-                        fail(comp, "import a store by its `use…` hook", sp);
-                    storeHooks.set(sp.local.name, store);
-                }
-            }
-            else if (from === "vue-router") {
-                for (const sp of st.specifiers) {
-                    const name = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : null;
-                    if (name === "useRoute")
-                        useRouteName = sp.local.name;
-                    else if (name === "RouterLink" || name === "RouterView")
-                        scope.router.set(sp.local.name, name);
-                    else
-                        scope.clientOnly.set(sp.local.name, `\`${name}\` from vue-router does not run on the server`);
-                }
-            }
-            else if (from === "vue-i18n") {
-                for (const sp of st.specifiers) {
-                    const name = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : null;
-                    if (name === "useI18n")
-                        useI18nName = sp.local.name;
-                    else
-                        scope.clientOnly.set(sp.local.name, `\`${name}\` from vue-i18n does not run on the server`);
-                }
-            }
-            else if (from === "pinia") {
+            if (ctx.plugins.some((p) => p.scriptImport?.(scope, st, from)))
+                continue;
+            if (from === "vue") {
                 for (const sp of st.specifiers) {
-                    const name = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : null;
-                    if (name === "storeToRefs")
-                        storeToRefsName = sp.local.name;
-                    else
-                        scope.clientOnly.set(sp.local.name, `\`${name}\` from Pinia does not run on the server`);
+                    if (sp.type === "ImportSpecifier" && (sp.imported.name ?? sp.imported.value) === "useAttrs")
+                        useAttrsName = sp.local.name;
                 }
             }
             else if (ctx.helperModule !== null && from === ctx.helperModule) {
@@ -172,14 +131,10 @@ export function scopeFor(comp, ast, components) {
             setupStatement(comp, st);
             continue;
         }
-        // Setup runs on the server too, so a statement there can change what renders: `x.value = ...`
-        // after a `ref`, an `if`, a loop. None of it is translated, so none of it may exist.
         if (st.type !== "VariableDeclaration")
             fail(comp, `\`${st.type}\` in setup is not supported`, st);
         for (const d of st.declarations) {
             const init0 = d.init;
-            // `const { size = "md", label: l } = defineProps<...>()`: each name reads that prop, whose
-            // default `compileScript` already resolved.
             if (d.id.type === "ObjectPattern" && definePropsType(init0)) {
                 for (const p of d.id.properties) {
                     if (p.type !== "ObjectProperty" || p.computed)
@@ -192,67 +147,19 @@ export function scopeFor(comp, ast, components) {
                 }
                 continue;
             }
-            const calls = (name) => name !== null && init0?.type === "CallExpression" && init0.callee.type === "Identifier" && init0.callee.name === name;
-            // `const { t, locale } = useI18n()`: \`t\` translates, \`locale\` is the request's locale.
-            if (d.id.type === "ObjectPattern" && calls(useI18nName)) {
-                for (const p of d.id.properties) {
-                    if (p.type !== "ObjectProperty" || p.computed || p.value.type !== "Identifier") {
-                        fail(comp, "`useI18n()` is destructured into plain names", p);
-                    }
-                    const key = p.key.name ?? p.key.value;
-                    if (key === "t")
-                        scope.i18nT.add(p.value.name);
-                    else if (key === "locale") {
-                        scope.setup.set(p.value.name, { code: "fv_i18n.locale()", ty: STR });
-                        scope.refs.add(p.value.name);
-                    }
-                    else
-                        scope.clientOnly.set(p.value.name, `\`${key}\` from \`useI18n()\` does not run on the server`);
-                }
-                comp.readsI18n = true;
-                continue;
-            }
-            // `const { density, label: l } = storeToRefs(prefs)`: each name is that field of the state.
-            if (d.id.type === "ObjectPattern" && calls(storeToRefsName)) {
-                const arg = init0.arguments[0];
-                const store = arg?.type === "Identifier" ? storeValues.get(arg.name) : undefined;
-                if (!store || init0.arguments.length !== 1)
-                    fail(comp, "`storeToRefs` takes a store bound in this setup", d);
-                for (const p of d.id.properties) {
-                    if (p.type !== "ObjectProperty" || p.computed || p.value.type !== "Identifier") {
-                        fail(comp, "`storeToRefs` is destructured into plain names", p);
-                    }
-                    const key = p.key.type === "Identifier" ? p.key.name : p.key.value;
-                    const state = { code: `fv_stores.${store.field}`, ty: { k: "struct", name: store.state, store: true } };
-                    scope.setup.set(p.value.name, storeGetter(scope, state, key, p) ?? fieldVal(comp, state.code, state.ty, key, p));
-                    scope.refs.add(p.value.name);
-                }
-                comp.readsStores = true;
+            if (ctx.plugins.some((p) => p.scriptBinding?.(scope, d)))
                 continue;
-            }
             if (d.id.type !== "Identifier") {
-                // Destructuring anything else: client-side state the template may not read.
                 for (const name of patternNames(d.id))
                     scope.clientOnly.set(name, "it is destructured from a value the server does not have");
                 continue;
             }
             const local = d.id.name;
-            // `const prefs = usePrefs()`: the store's state, as the server was given it.
-            const hook = init0?.type === "CallExpression" && init0.callee.type === "Identifier" ? storeHooks.get(init0.callee.name) : undefined;
-            if (hook) {
-                if (init0.arguments.length)
-                    fail(comp, "a store hook takes no arguments", d);
-                storeValues.set(local, hook);
-                scope.setup.set(local, { code: `fv_stores.${hook.field}`, ty: { k: "struct", name: hook.state, store: true } });
-                comp.readsStores = true;
-                continue;
-            }
-            // `const route = useRoute()`: the reader's location.
-            if (useRouteName !== null && init0?.type === "CallExpression" && init0.callee.type === "Identifier" && init0.callee.name === useRouteName) {
-                scope.setup.set(local, theRoute(scope, d));
+            if (useAttrsName !== null && init0?.type === "CallExpression" && init0.callee.type === "Identifier" && init0.callee.name === useAttrsName) {
+                scope.attrsBindings.add(local);
+                scope.clientOnly.set(local, "`useAttrs()` is bound whole, with `v-bind`; a value read from it has no type");
                 continue;
             }
-            // `const model = defineModel<string>()`: the model's prop.
             const model = comp.models.get(local);
             if (model !== undefined) {
                 scope.setup.set(local, fieldVal(comp, "props", { k: "struct", name: "Props" }, model, d));
@@ -275,9 +182,6 @@ export function scopeFor(comp, ast, components) {
                 scope.clientOnly.set(local, "it is not a value the server computes: only `ref(…)`, `computed(() => …)` and plain expressions are");
                 continue;
             }
-            // Evaluated once, as setup is on the server. A value the server cannot evaluate is client-side
-            // state — a template ref, an element, a `reactive` object — which the template may still name
-            // from an event handler; a reference the server needs fails in `expr` with this reason.
             let v;
             try {
                 v = expr(scope, source);
@@ -288,25 +192,22 @@ export function scopeFor(comp, ast, components) {
                 scope.clientOnly.set(local, e.message.replace(/^[^:]*: /, ""));
                 continue;
             }
-            if (v.ty.k === "undef") {
+            if (v.ty.k === "undef" || (v.ty.k === "str" && known(v) !== undefined)) {
                 scope.setup.set(local, v);
                 continue;
             }
             const name = `s_${snake(local).replace(/^r#/, "")}`;
             const lone = v.lone ? { lone: true } : {};
-            // A computed list is kept as its items, and read again by item.
             if (v.ty.k === "list" && v.iter !== undefined) {
                 lets.push(`let ${name} = ${collected(v)};`);
                 scope.setup.set(local, heldList(name, v.ty.of, v.lone));
                 continue;
             }
-            // An optional string a temporary owns is kept as that `Option<Cow>`.
             if (v.held !== undefined) {
                 lets.push(`let ${name} = ${v.held};`);
                 scope.setup.set(local, { code: `${name}.as_deref()`, ty: v.ty, ...lone });
                 continue;
             }
-            // A list, a record or an object is a place in the props: borrowed, never moved out of them.
             const place = v.ty.k === "list" || v.ty.k === "record" || v.ty.k === "struct" || v.ty.k === "child";
             lets.push(`let ${name} = ${place ? `&${operand(v.code, UNARY)}` : bare(v.code)};`);
             scope.setup.set(local, { code: name, ty: v.ty, ...lone, ...(v.konst !== undefined ? { konst: v.konst } : {}) });

package/dist/slots.d.ts

@@ -0,0 +1,13 @@
+import { type Component, type N, type Scope, type Ty, type Val } from "./model.ts";
+import { Emitter } from "./emitter.ts";
+export declare function slotBody(s: Scope, value: N): N[];
+export declare function slotContent(s: Scope, value: N): {
+    body: N[];
+    param: N;
+};
+export declare function staticallyFilled(body: N[]): boolean;
+export declare function slotTypeName(slotName: string, suffix: string): string;
+export declare function slotFieldBorrows(ty: Ty): boolean;
+export declare function slotFieldTy(ty: Ty, comp: Component): string;
+export declare function slotFieldValue(s: Scope, v: Val, n: N): string;
+export declare function slotOutlet(s: Scope, e: Emitter, c: N): void;

package/dist/slots.js

@@ -0,0 +1,160 @@
+import { fail, GenError, rustStr, snake } from "./model.js";
+import { expr } from "./expr.js";
+import { atom, bare, operand, strArg, UNARY } from "./parens.js";
+import { Emitter } from "./emitter.js";
+import { rustTy } from "./rust.js";
+import { fieldInit } from "./children.js";
+import { pushesContent, statements } from "./template.js";
+function borrowed(code) {
+    return code.startsWith("&") || /^\w+$/.test(code) || /^fv_sp\d+\.\w+$/.test(code) ? code : `&${operand(code, UNARY)}`;
+}
+export function slotBody(s, value) {
+    return slotContent(s, value).body;
+}
+export function slotContent(s, value) {
+    const fn = value.type === "CallExpression" && value.callee.type === "Identifier" && value.callee.name === "_withCtx"
+        ? value.arguments[0]
+        : null;
+    if (fn?.type !== "ArrowFunctionExpression" || fn.body.type !== "BlockStatement") {
+        fail(s.comp, "unexpected slot content", value);
+    }
+    const branch = fn.body.body.length === 1 ? fn.body.body[0] : null;
+    if (branch?.type !== "IfStatement" || branch.test.type !== "Identifier" || branch.test.name !== "_push") {
+        fail(s.comp, "unexpected slot content", fn);
+    }
+    const body = branch.consequent.type === "BlockStatement" ? branch.consequent.body : [branch.consequent];
+    return { body, param: fn.params[0] };
+}
+export function staticallyFilled(body) {
+    return body.some((st) => st.type === "ExpressionStatement" && st.expression.type === "CallExpression" &&
+        st.expression.callee.type === "Identifier" && st.expression.callee.name === "_push" &&
+        pushesContent(st.expression.arguments[0]) === true);
+}
+export function slotTypeName(slotName, suffix) {
+    return slotName.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("") + suffix;
+}
+export function slotFieldBorrows(ty) {
+    const copied = (t) => t.k === "int" || t.k === "float" || t.k === "bool";
+    return !(copied(ty) || (ty.k === "opt" && copied(ty.of)));
+}
+export function slotFieldTy(ty, comp) {
+    const owned = (t) => rustTy(t, comp).replace(/'a\b/g, "'v");
+    switch (ty.k) {
+        case "int":
+            return "i64";
+        case "float":
+            return "f64";
+        case "bool":
+            return "bool";
+        case "str":
+            return "&'v str";
+        case "list":
+            return `&'v [${owned(ty.of)}]`;
+        case "struct":
+        case "child":
+        case "html":
+            return `&'v ${owned(ty)}`;
+        case "opt":
+            return `Option<${slotFieldTy(ty.of, comp)}>`;
+        default:
+            throw new GenError(`no Rust type for a slot prop of type ${JSON.stringify(ty)}`);
+    }
+}
+export function slotFieldValue(s, v, n) {
+    switch (v.ty.k) {
+        case "str":
+            return strArg(v.code);
+        case "int":
+        case "float":
+        case "bool":
+            return bare(v.code);
+        case "list":
+            if (v.code.startsWith("["))
+                fail(s.comp, "a slot prop is not an array literal: pass a list the component holds", n);
+            if (v.iter !== undefined)
+                fail(s.comp, "a slot prop is not a computed list: pass a list the component holds", n);
+            return borrowed(v.code);
+        case "struct":
+        case "child":
+        case "html":
+            return borrowed(v.code);
+        case "opt":
+            if (v.ty.of.k === "list")
+                return `${atom(v.code)}.map(|v| &v[..])`;
+            if (v.ty.of.k === "opt" || v.ty.of.k === "undef")
+                break;
+            return v.code;
+    }
+    return fail(s.comp, "a slot prop is a string, a number, a boolean, an object or a list", n);
+}
+export function slotOutlet(s, e, c) {
+    const [, nameNode, slotProps, fallback] = c.arguments;
+    if (nameNode?.type !== "StringLiteral")
+        fail(s.comp, "a slot's name is literal", c);
+    if (slotProps?.type !== "ObjectExpression")
+        fail(s.comp, "a slot's props are attributes or a `v-bind` object literal", c);
+    const slotName = nameNode.value;
+    const field = `fv_slots.${snake(slotName)}`;
+    const outlet = `\`<slot${slotName === "default" ? "" : ` name="${slotName}"`}>\``;
+    let fn = "fv::slot_into";
+    let args = field;
+    if (slotProps.properties.length) {
+        const fields = [];
+        const values = [];
+        for (const p of slotProps.properties) {
+            if (p.type !== "ObjectProperty" || p.computed)
+                fail(s.comp, "slot props hold plain names", p);
+            const key = p.key.name ?? p.key.value;
+            if (!/^[A-Za-z_$][\w$]*$/.test(key))
+                fail(s.comp, `slot prop \`${key}\` is not a plain name; write it in camelCase`, p);
+            const v = expr(s, p.value);
+            fields.push({ js: key, rust: snake(key), ty: v.ty });
+            values.push(fieldInit(snake(key), slotFieldValue(s, v, p.value)));
+        }
+        const name = slotTypeName(slotName, "SlotProps");
+        const shape = { name, fields, slot: true };
+        const had = s.comp.slotShapes.get(slotName);
+        if (had && JSON.stringify(had.fields) !== JSON.stringify(fields)) {
+            fail(s.comp, `every ${outlet} passes the same props, of the same types`, c);
+        }
+        if (!had) {
+            if (s.comp.structs.has(name) && !s.comp.structs.get(name).slot)
+                fail(s.comp, `\`${name}\` names this slot's props; rename the interface`, c);
+            s.comp.slotShapes.set(slotName, shape);
+            s.comp.structs.set(name, shape);
+        }
+        fn = "fv::scoped_slot_into";
+        args = `${field}, &${name} { ${values.join(", ")} }`;
+    }
+    else if (s.comp.slotShapes.has(slotName)) {
+        fail(s.comp, `every ${outlet} passes the same props, of the same types`, c);
+    }
+    const id = c.arguments[6];
+    let slotted = null;
+    if (id?.type === "StringLiteral")
+        slotted = rustStr(id.value);
+    else if (id?.type === "BinaryExpression" && id.operator === "+" && id.left.type === "StringLiteral" && id.right.type === "Identifier" && id.right.name === "_scopeId") {
+        slotted = s.sid === null ? rustStr(id.left.value) : `&[${rustStr(id.left.value)}, ${s.sid}].concat()`;
+    }
+    else if (id?.type === "Identifier" && id.name === "_scopeId")
+        slotted = s.sid;
+    else if (id && id.type !== "NullLiteral")
+        fail(s.comp, "unexpected slot scope id", id);
+    if (s.comp.passesSlotIds) {
+        fn = fn === "fv::slot_into" ? "fv::slot_into_slotted" : "fv::scoped_slot_into_slotted";
+        args += `, ${slotted ?? '""'}`;
+    }
+    else if (slotted !== null)
+        fail(s.comp, "a slot scope id passed to content that does not take one", c);
+    const call = (rest) => (s.fill ? `if ${fn}(out, ${args}, ${rest}) { filled = true; }` : `${fn}(out, ${args}, ${rest});`);
+    if (fallback?.type === "NullLiteral" || !fallback) {
+        e.stmt(call("None"));
+        return;
+    }
+    if (fallback.type !== "ArrowFunctionExpression" || fallback.body.type !== "BlockStatement") {
+        fail(s.comp, "unexpected slot fallback", fallback);
+    }
+    e.open(`${s.fill ? "if " : ""}${fn}(out, ${args}, Some(&mut |out: &mut String|`);
+    statements(s, e, fallback.body.body);
+    e.close(s.fill ? ")) { filled = true; }" : "));");
+}

package/dist/strings.d.ts

@@ -0,0 +1,13 @@
+import { type Component, type N, type Scope, type Val } from "./model.ts";
+export declare function lonely(what: string): string;
+export declare function meet(comp: Component, a: Val, b: Val, what: string, n: N, how: "equal" | "order" | "search" | "join"): void;
+export declare function loneOf(...vs: (Val | undefined)[]): {
+    lone?: true;
+};
+export declare function isTemporary(v: Val): boolean;
+export declare function asCow(v: Val): string;
+export declare function yieldsCow(code: string): boolean;
+export declare function unquote(literal: string): string;
+export declare function stringsEqual(a: Val, b: Val): string;
+export declare function formatted(comp: Component, parts: (string | Val)[], n: N, what: string): Val;
+export declare function stringMethod(s: Scope, target: Val, method: string, args: N[], n: N): Val | null;

package/dist/strings.js

@@ -0,0 +1,208 @@
+import { BOOL, fail, INT, opt, rustStr, STR } from "./model.js";
+import { atom, bare, binary, condition, enclosed, receiver, strArg } from "./parens.js";
+import { computed } from "./lists.js";
+import { expr } from "./expr.js";
+import { known } from "./narrowing.js";
+import { asF64, isNumber } from "./numbers.js";
+export function lonely(what) {
+    return `${what} with a string that may hold half of a surrogate pair (cut by \`slice\`, \`substring\`, \`at\`, \`charAt\`, \`split("")\` and the like): JavaScript keeps the half, which can match, order or join with another where ferrovue holds U+FFFD`;
+}
+export function meet(comp, a, b, what, n, how) {
+    const literal = (v) => v.code.startsWith('"');
+    const fffd = (v) => literal(v) && v.code.includes("\u{FFFD}");
+    const low = (v) => literal(v) && !/[\u{D800}-\u{10FFFF}]/u.test(v.code);
+    const refused = how === "order" ? (a.lone && !low(b)) || (b.lone && !low(a))
+        : how === "join" ? a.lone && b.lone
+            : how === "search" ? b.lone || (a.lone && fffd(b))
+                : (a.lone && b.lone) || (a.lone && fffd(b)) || (b.lone && fffd(a));
+    if (refused)
+        fail(comp, lonely(what), n);
+}
+export function loneOf(...vs) {
+    return vs.some((v) => v?.lone) ? { lone: true } : {};
+}
+function nonEmptyLiteral(v) {
+    return /^"[^"]/.test(v.code);
+}
+export function isTemporary(v) {
+    if (v.ty.k !== "str")
+        return false;
+    const trimmed = /^fv::js_trim(?:_start|_end)?\(([^]*)\)$/.exec(v.code);
+    if (trimmed?.[1] !== undefined)
+        return isTemporary({ code: trimmed[1].replace(/^&(?!\*)/, "&*"), ty: v.ty });
+    return /^&\*(?!\**[\w.]+$)/.test(v.code) || /\.unwrap_or\(&\*(?!\**[\w.]+\)$)/.test(v.code);
+}
+export function asCow(v) {
+    if (!isTemporary(v))
+        return `std::borrow::Cow::<str>::Borrowed(${bare(v.code)})`;
+    const built = /^&\*(.*)$/s.exec(v.code)?.[1];
+    if (built === undefined)
+        return `std::borrow::Cow::<str>::Owned(${atom(v.code)}.to_owned())`;
+    if (enclosed(built))
+        return bare(built);
+    if (yieldsCow(built))
+        return built.startsWith("fv::") ? `std::borrow::Cow::<str>::Owned(${built}.into_owned())` : bare(built);
+    if (/^fv::js_(?:char_at|trim|trim_start|trim_end)\(/.test(built))
+        return `std::borrow::Cow::<str>::Owned(${built}.to_owned())`;
+    return `std::borrow::Cow::<str>::Owned(${built})`;
+}
+export function yieldsCow(code) {
+    const routine = /^fv::js_(?:slice|substring|replace|replace_all|pad_start|pad_end)(?=\()/.exec(code);
+    if (routine !== null)
+        return enclosed(code.slice(routine[0].length));
+    const fallback = code.lastIndexOf(".unwrap_or(std::borrow::Cow::<str>::");
+    return fallback >= 0 && enclosed(code.slice(fallback + ".unwrap_or".length));
+}
+export function unquote(literal) {
+    const escapes = { n: "\n", r: "\r", t: "\t" };
+    return literal.slice(1, -1).replace(/\\(?:u\{([0-9a-f]+)\}|(.))/g, (_, hex, c) => (hex ? String.fromCodePoint(parseInt(hex, 16)) : (escapes[c] ?? c)));
+}
+export function stringsEqual(a, b) {
+    if (known(a) !== undefined && known(b) !== undefined)
+        return String(unquote(a.code) === unquote(b.code));
+    if (a.code === '""' || b.code === '""')
+        return `${receiver(a.code === '""' ? b.code : a.code)}.is_empty()`;
+    return binary(a.code, "==", b.code);
+}
+export function formatted(comp, parts, n, what) {
+    let fmt = "";
+    const args = [];
+    let before;
+    const lone = loneOf(...parts.map((p) => (typeof p === "string" ? undefined : p)));
+    for (const part of parts) {
+        if (typeof part === "string" || (part.ty.k === "str" && known(part) !== undefined)) {
+            const text = typeof part === "string" ? part : unquote(part.code);
+            if (text !== "")
+                before = undefined;
+            fmt += text.replace(/[{}]/g, (c) => c + c);
+            continue;
+        }
+        if (before)
+            meet(comp, before, part, what, n, "join");
+        before = part;
+        if (part.format) {
+            fmt += part.format.text;
+            args.push(...part.format.args);
+            continue;
+        }
+        if (part.ty.k === "str")
+            args.push(receiver(part.code).replace(/^(fv::Js\(.*\))\.to_string\(\)$/s, "$1"));
+        else if (isNumber(part.ty))
+            args.push(`fv::Js(${bare(part.code)})`);
+        else if (part.ty.k === "bool")
+            args.push(`if ${condition(part.code)} { "true" } else { "false" }`);
+        else
+            fail(comp, "a template literal interpolates strings, numbers and booleans that are present", n);
+        fmt += "{}";
+    }
+    if (!args.length)
+        return { code: rustStr(fmt.replace(/\{\{|\}\}/g, (c) => c[0])), ty: STR };
+    const one = parts.filter((p) => (typeof p === "string" ? p !== "" : p.code !== '""'));
+    if (fmt === "{}" && one.length === 1 && typeof one[0] !== "string" && one[0].ty.k === "str")
+        return one[0];
+    return { code: `&*format!(${rustStr(fmt)}, ${args.join(", ")})`, ty: STR, format: { text: fmt, args }, ...lone };
+}
+export function stringMethod(s, target, method, args, n) {
+    const comp = s.comp;
+    const t = strArg(target.code);
+    const arity = (least, most) => {
+        if (args.length < least || args.length > most) {
+            fail(comp, `\`.${method}()\` takes ${least === most ? least : `${least} to ${most}`} argument${most === 1 ? "" : "s"} here`, n);
+        }
+    };
+    const str = (i) => {
+        if (args[i]?.type === "RegExpLiteral")
+            fail(comp, `\`.${method}()\` with a regular expression, which the server does not run: give it a string`, args[i]);
+        const v = expr(s, args[i]);
+        if (v.ty.k !== "str")
+            fail(comp, `\`.${method}()\` takes a string that is present`, args[i]);
+        return v;
+    };
+    const num = (i, fallback) => {
+        if (args[i] === undefined)
+            return fallback;
+        const v = expr(s, args[i]);
+        if (v.ty.k === "undef")
+            return fallback;
+        if (!isNumber(v.ty))
+            fail(comp, `\`.${method}()\` takes a number that is present`, args[i]);
+        return asF64(v);
+    };
+    const cut = { lone: true };
+    switch (method) {
+        case "includes":
+        case "startsWith":
+        case "endsWith": {
+            arity(1, 1);
+            const x = str(0);
+            meet(comp, target, x, `\`.${method}()\``, n, "search");
+            const rust = { includes: "contains", startsWith: "starts_with", endsWith: "ends_with" }[method];
+            return { code: `${receiver(target.code)}.${rust}(${bare(x.code)})`, ty: BOOL };
+        }
+        case "indexOf":
+        case "lastIndexOf": {
+            arity(1, 1);
+            const x = str(0);
+            meet(comp, target, x, `\`.${method}()\``, n, "search");
+            return { code: `fv::js_${method === "indexOf" ? "index_of" : "last_index_of"}(${t}, ${strArg(x.code)})`, ty: INT };
+        }
+        case "slice":
+        case "substring": {
+            arity(0, 2);
+            const end = num(1, "");
+            return { code: `&*fv::js_${method}(${t}, ${num(0, "0.0")}, ${end ? `Some(${end})` : "None"})`, ty: STR, ...cut };
+        }
+        case "at": {
+            arity(1, 1);
+            const at = `fv::js_at(${t}, ${num(0, "0.0")})`;
+            if (!isTemporary(target))
+                return { code: at, ty: opt(STR), ...cut };
+            const held = `${at}.map(|v| std::borrow::Cow::<str>::Owned(v.to_owned()))`;
+            return { code: `${atom(held)}.as_deref()`, ty: opt(STR), held, ...cut };
+        }
+        case "charAt":
+            arity(0, 1);
+            return { code: `${isTemporary(target) ? "&*" : ""}fv::js_char_at(${t}, ${num(0, "0.0")})`, ty: STR, ...cut };
+        case "split": {
+            arity(1, 1);
+            const sep = str(0);
+            meet(comp, target, sep, "`.split()`", n, "search");
+            return computed(`fv::js_split(${t}, ${strArg(sep.code)}).into_iter()`, STR, target.lone || !nonEmptyLiteral(sep));
+        }
+        case "replace":
+        case "replaceAll": {
+            arity(2, 2);
+            if (args[1].type === "ArrowFunctionExpression" || args[1].type === "FunctionExpression") {
+                fail(comp, `\`.${method}()\` with a function, which the server does not run: give it a string`, args[1]);
+            }
+            const [pattern, replacement] = [str(0), str(1)];
+            meet(comp, target, pattern, `\`.${method}()\``, n, "search");
+            meet(comp, target, replacement, `\`.${method}()\``, n, "join");
+            const lone = target.lone || replacement.lone || (method === "replaceAll" && !nonEmptyLiteral(pattern));
+            return { code: `&*fv::js_${method === "replace" ? "replace" : "replace_all"}(${t}, ${strArg(pattern.code)}, ${strArg(replacement.code)})`, ty: STR, ...(lone ? cut : {}) };
+        }
+        case "padStart":
+        case "padEnd": {
+            arity(1, 2);
+            const fill = args.length > 1 ? str(1) : { code: '" "', ty: STR };
+            const whole = fill.code.startsWith('"') && !/[\u{10000}-\u{10FFFF}]/u.test(fill.code);
+            if (fill.lone || (method === "padStart" && target.lone && !whole))
+                fail(comp, lonely(`\`.${method}()\``), n);
+            return { code: `&*fv::js_${method === "padStart" ? "pad_start" : "pad_end"}(${t}, ${num(0, "0.0")}, ${strArg(fill.code)})`, ty: STR, ...(target.lone || !whole ? cut : {}) };
+        }
+        case "repeat": {
+            arity(1, 1);
+            const c = args[0];
+            if ((c.type === "UnaryExpression" && c.operator === "-" && c.argument.type === "NumericLiteral" && c.argument.value > 0) || (c.type === "Identifier" && c.name === "Infinity")) {
+                fail(comp, "`.repeat()` with a negative or infinite count, which throws a `RangeError`", c);
+            }
+            if (target.lone)
+                fail(comp, lonely("`.repeat()`"), n);
+            return { code: `&*fv::js_repeat(${t}, ${num(0, "0.0")})`, ty: STR };
+        }
+        case "toLocaleUpperCase":
+        case "toLocaleLowerCase":
+            return fail(comp, `\`.${method}()\` maps case by the locale the server runs in, which the browser need not share: use \`.${method.replace("Locale", "")}()\``, n);
+    }
+    return null;
+}