ferrovue 0.7.2 → 0.9.0

package/dist/narrowing.js

@@ -1,9 +1,9 @@
-import { absence, BOOL, fail, nothing } from "./model.js";
+import { absence, BOOL, fail, nothing, rustStr, STR } from "./model.js";
 import { ctx } from "./context.js";
 import { claim } from "./plugin.js";
 import { atom, bare, binary, condition, ifElse, logical, not, occurrences, receiver } from "./parens.js";
 import { isNumber, negatedOrder } from "./numbers.js";
-import { expr } from "./expr.js";
+import { describeTy, expr } from "./expr.js";
 export function known(v) {
     if (v.konst !== undefined)
         return v.konst;
@@ -34,8 +34,10 @@ export function truthy(v) {
         case "undef":
         case "null":
             return "false";
-        case "opt":
-            return `${atom(v.code)}.is_some_and(|v| ${truthy({ code: "v", ty: v.ty.of })})`;
+        case "opt": {
+            const each = truthy({ code: "v", ty: v.ty.of });
+            return each === "true" ? `${atom(v.code)}.is_some()` : `${atom(v.code)}.is_some_and(|v| ${each})`;
+        }
         default:
             return claim((p) => p.values?.truthy?.(v)) ?? "true";
     }
@@ -52,6 +54,8 @@ export function pathOf(n) {
         return `${base}.${n.property.name}`;
     if (n.computed && n.property.type === "StringLiteral")
         return `${base}.${n.property.value}`;
+    if (n.computed && n.property.type === "NumericLiteral")
+        return `${base}[${n.property.value}]`;
     return null;
 }
 function nothingLiteral(n) {
@@ -83,6 +87,72 @@ export function checkNullTest(s, t, v) {
     const what = none === "null" ? "is `T | null`, never `undefined`" : "is optional, which is `undefined` when absent, never `null`";
     fail(s.comp, "FV0627", `\`${op}= ${t.literal}\` of a value that ${what}: compare with \`${other}\``, t.target);
 }
+export function typeofCompare(n) {
+    if (n.type !== "BinaryExpression" || !["===", "!==", "==", "!="].includes(n.operator))
+        return null;
+    const isTypeof = (m) => m.type === "UnaryExpression" && m.operator === "typeof";
+    const [t, lit] = isTypeof(n.left) && n.right.type === "StringLiteral" ? [n.left, n.right] : isTypeof(n.right) && n.left.type === "StringLiteral" ? [n.right, n.left] : [null, null];
+    return t ? { target: t.argument, literal: lit.value, equal: n.operator.startsWith("=") } : null;
+}
+function typeName(s, ty, n) {
+    switch (ty.k) {
+        case "str":
+        case "html":
+            return "string";
+        case "int":
+        case "float":
+            return "number";
+        case "bool":
+            return "boolean";
+        case "undef":
+            return "undefined";
+        case "null":
+        case "list":
+        case "record":
+        case "struct":
+        case "child":
+        case "date":
+            return "object";
+        default:
+            return fail(s.comp, "FV0722", `\`typeof\` of ${describeTy(ty)}, whose JavaScript type the compiler does not know`, n);
+    }
+}
+/** What `typeof v` gives: `present` for a value that is there, and `absent` for an optional one
+ * that is not (`null` when `v` cannot be absent, `either` when it may be `null` or `undefined`). */
+function typeNames(s, v, n) {
+    if (v.ty.k !== "opt")
+        return { present: typeName(s, v.ty, n), absent: null };
+    const absent = v.ty.none === "null" ? "object" : v.ty.none === "either" ? "either" : "undefined";
+    return { present: typeName(s, v.ty.of, n), absent };
+}
+function eitherRefused(s, literal, n) {
+    return fail(s.comp, "FV0722", `\`typeof\` compared with "${literal}" of a value that may be \`null\` (an "object") or \`undefined\`, which its Rust \`Option\` cannot tell apart: test it with \`== null\``, n);
+}
+export function typeofVal(s, n) {
+    const v = expr(s, n.argument);
+    const { present, absent } = typeNames(s, v, n.argument);
+    if (absent === null || absent === present)
+        return { code: rustStr(present), ty: STR };
+    if (absent === "either")
+        return eitherRefused(s, present, n);
+    return { code: `if ${atom(v.code)}.is_some() { ${rustStr(present)} } else { ${rustStr(absent)} }`, ty: STR };
+}
+export function typeofTest(s, t, n) {
+    const v = expr(s, t.target);
+    const { present, absent } = typeNames(s, v, t.target);
+    const konst = (is) => ({ code: String(is === t.equal), ty: BOOL, konst: is === t.equal });
+    if (absent === null)
+        return konst(present === t.literal);
+    if (absent === "either" && (t.literal === "undefined" || t.literal === "object"))
+        return eitherRefused(s, t.literal, n);
+    if (present === t.literal && absent === t.literal)
+        return konst(true);
+    if (present === t.literal)
+        return boolOf(t.equal ? `${atom(v.code)}.is_some()` : `${atom(v.code)}.is_none()`);
+    if (absent === t.literal)
+        return boolOf(t.equal ? `${atom(v.code)}.is_none()` : `${atom(v.code)}.is_some()`);
+    return konst(false);
+}
 export function presence(s, n) {
     for (const p of ctx.plugins) {
         const own = p.presence?.(s, n);
@@ -97,12 +167,19 @@ export function presence(s, n) {
         negated = true;
     }
     else if (n.type === "BinaryExpression") {
+        const tested = typeofCompare(n);
         const test = nullTest(n);
-        if (!test)
+        if (tested) {
+            target = tested.target;
+            byTruth = false;
+        }
+        else if (!test)
             return null;
-        target = test.target;
-        negated = test.is;
-        byTruth = false;
+        else {
+            target = test.target;
+            negated = test.is;
+            byTruth = false;
+        }
     }
     const path = pathOf(target);
     if (path === null)
@@ -110,7 +187,19 @@ export function presence(s, n) {
     const v = expr(s, target);
     if (v.ty.k !== "opt")
         return null;
-    if (n.type === "BinaryExpression")
+    const tested = typeofCompare(n);
+    if (tested) {
+        const { present, absent } = typeNames(s, v, target);
+        if (absent === "either" || present === absent)
+            return null;
+        if (tested.literal === present)
+            negated = !tested.equal;
+        else if (tested.literal === absent)
+            negated = tested.equal;
+        else
+            return null;
+    }
+    else if (n.type === "BinaryExpression")
         checkNullTest(s, nullTest(n), v);
     const of = v.ty.of;
     const scalar = of.k === "str" || of.k === "int" || of.k === "float" || of.k === "bool";

package/dist/numbers.d.ts

@@ -6,3 +6,7 @@ export declare function numberVal(x: number, int: boolean): Val;
 export declare function arithmetic(a: Val, op: string, b: Val, int: boolean): Val;
 export declare function compare(a: Val, op: string, b: Val): Val;
 export declare function negatedOrder(s: Scope, n: N): Val | null;
+/** `a ** b` where every engine gives the same answer: an integer to a whole power from 0 whose
+ * result is an integer within ±2⁵³, worked out exactly; `null` for any other. */
+export declare function exactPower(a: number, b: number): number | null;
+export declare function power(s: Scope, base: N, exponent: N, n: N, what: string): Val;

package/dist/numbers.js

@@ -1,5 +1,5 @@
-import { BOOL, FLOAT, INT } from "./model.js";
-import { AS, binary, FLIPPED, operand, UNARY } from "./parens.js";
+import { BOOL, fail, FLOAT, INT } from "./model.js";
+import { AS, atom, binary, FLIPPED, operand, UNARY } from "./parens.js";
 import { expr } from "./expr.js";
 export function isNumber(ty) {
     return ty.k === "int" || ty.k === "float";
@@ -20,7 +20,31 @@ function floatLiteral(x) {
     const spelled = String(Math.abs(x)).replace("e+", "e");
     return `${x < 0 || Object.is(x, -0) ? "-" : ""}${/[.e]/.test(spelled) ? spelled : `${spelled}.0`}f64`;
 }
+const RUST_CONSTANTS = new Map(Object.entries({
+    E: "2.71828182845904523536028747135266250",
+    FRAC_1_PI: "0.318309886183790671537767526745028724",
+    FRAC_1_SQRT_2: "0.707106781186547524400844362104849039",
+    FRAC_2_PI: "0.636619772367581343075535053490057448",
+    FRAC_2_SQRT_PI: "1.12837916709551257389615890312154517",
+    FRAC_PI_2: "1.57079632679489661923132169163975144",
+    FRAC_PI_3: "1.04719755119659774615421446109316763",
+    FRAC_PI_4: "0.785398163397448309615660845819875721",
+    FRAC_PI_6: "0.52359877559829887307710723054658381",
+    FRAC_PI_8: "0.39269908169872415480783042290993786",
+    LN_10: "2.30258509299404568401799145468436421",
+    LN_2: "0.693147180559945309417232121458176568",
+    LOG10_2: "0.301029995663981195213738894724493027",
+    LOG10_E: "0.434294481903251827651128918916605082",
+    LOG2_10: "3.32192809488736234787031942948939018",
+    LOG2_E: "1.44269504088896340735992468100189214",
+    PI: "3.14159265358979323846264338327950288",
+    SQRT_2: "1.41421356237309504880168872420969808",
+    TAU: "6.28318530717958647692528676655900577",
+}).map(([name, digits]) => [Number(digits), `std::f64::consts::${name}`]));
 export function numberVal(x, int) {
+    const constant = int ? undefined : RUST_CONSTANTS.get(Math.abs(x));
+    if (constant !== undefined)
+        return { code: x < 0 ? `-${constant}` : constant, ty: FLOAT, num: x };
     if (!int)
         return { code: floatLiteral(x), ty: FLOAT, num: x };
     if (!Number.isSafeInteger(x))
@@ -63,6 +87,13 @@ export function compare(a, op, b) {
         const konst = fold(a.num, op, b.num);
         return { code: String(konst), ty: BOOL, konst };
     }
+    if (asF64(a) === asF64(b)) {
+        if (op === "<" || op === ">")
+            return { code: "false", ty: BOOL, konst: false };
+        if (a.ty.k === "int")
+            return { code: "true", ty: BOOL, konst: true };
+        return { code: `!${atom(asF64(a))}.is_nan()`, ty: BOOL };
+    }
     return { code: binary(asF64(a), op, asF64(b)), ty: BOOL };
 }
 export function negatedOrder(s, n) {
@@ -72,3 +103,31 @@ export function negatedOrder(s, n) {
     const b = expr(s, n.right);
     return a.ty.k === "int" && b.ty.k === "int" ? compare(a, FLIPPED[n.operator], b) : null;
 }
+/** `a ** b` where every engine gives the same answer: an integer to a whole power from 0 whose
+ * result is an integer within ±2⁵³, worked out exactly; `null` for any other. */
+export function exactPower(a, b) {
+    if (!Number.isInteger(a) || !Number.isInteger(b) || b < 0 || Math.abs(a) > 2 ** 53)
+        return null;
+    if (b === 0)
+        return 1;
+    if (Object.is(a, -0))
+        return b % 2 === 1 ? -0 : 0;
+    if (Math.abs(a) > 1 && b > 53)
+        return null;
+    const r = BigInt(a) ** BigInt(b);
+    const limit = 2n ** 53n;
+    return r > limit || r < -limit ? null : Number(r);
+}
+export function power(s, base, exponent, n, what) {
+    const [a, b] = [expr(s, base), expr(s, exponent)];
+    if (!isNumber(a.ty) || !isNumber(b.ty))
+        return fail(s.comp, "FV0720", `${what} of numbers that are present`, n);
+    const engines = "Node 22 writes `10 ** -20` as `1.0000000000000001e-20`, and engines round powers beyond 2⁵³ in their own ways";
+    if (a.num === undefined || b.num === undefined) {
+        return fail(s.comp, "FV0720", `${what} of a value known only when rendering: ferrovue works ${what} out when compiling, for an integer to a whole power from 0 whose result is within ±2⁵³, since ${engines}: compute it in Rust and pass it as a prop`, n);
+    }
+    const r = exactPower(a.num, b.num);
+    if (r === null)
+        return fail(s.comp, "FV0720", `${what} of ${String(a.num)} and ${String(b.num)}, which is not an integer to a whole power from 0 with a result within ±2⁵³: ${engines}`, n);
+    return numberVal(r, true);
+}

package/dist/parens.js

@@ -178,7 +178,14 @@ export function strArg(code) {
     const branches = ifElse(code);
     if (branches)
         return `if ${branches.test} { ${strArg(branches.yes)} } else { ${strArg(branches.no)} }`;
+    if (/^\(\*\w+\)$/.test(code))
+        return bare(code);
     const m = /^&\*(\**)(.*)$/s.exec(code);
+    if (m && !m[1]) {
+        const lazy = /^\(\*(\w+)\)$/.exec(m[2])?.[1];
+        if (lazy !== undefined)
+            return `&${lazy}`;
+    }
     if (!m || (binding(m[2]) < ATOM && !enclosed(m[2])))
         return code;
     return m[1] ? m[2] : `&${m[2]}`;

package/dist/plugin.d.ts

@@ -34,6 +34,9 @@ export interface ValueHooks {
     } | undefined;
     nullish?(s: Scope, a: Val, b: Val, n: N): Val | undefined;
     equals?(a: Val, b: Val): string | undefined;
+    order?(a: Val, op: string, b: Val): Val | undefined;
+    refuseEquality?(s: Scope, a: Val, b: Val, n: N): void;
+    json?(v: Val): string | undefined;
     isArray?(v: Val): Val | undefined;
 }
 export interface ReadComponent {
@@ -75,6 +78,8 @@ export interface Plugin<Run = unknown, Local = unknown> {
     };
     global?(s: Scope, name: string, n: N): Val | null;
     call?(s: Scope, n: N): Val | null;
+    construct?(s: Scope, n: N): Val | null;
+    method?(s: Scope, target: Val, method: string, args: N[], 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;

package/dist/plugins/dates.d.ts

@@ -0,0 +1,25 @@
+import { type N, type Scope } from "../model.ts";
+import { type Plugin } from "../plugin.ts";
+declare module "../model.ts" {
+    interface PluginTys {
+        date: {
+            k: "date";
+        };
+    }
+}
+/** The time value `Date.parse(s)` gives a string every JavaScript engine reads alike: one in
+ * ECMAScript's date time string format, a date alone or a date and time with a `Z` or an offset, its
+ * fields within their ranges. `undefined` for any other string, which an engine may read by rules of
+ * its own, or in the time zone of the machine running it, and for a date and time whose fields lie
+ * beyond ±8.64 × 10¹⁵ ms read as UTC while its offset brings it within, which Safari reads as an
+ * invalid date and the other engines as a valid one. */
+export declare function portableTime(s: string): number | undefined;
+/** Whether `Date.UTC(...parts)` gives what every JavaScript engine gives. V8 reads a year beyond
+ * ±1,000,000, a month beyond ±10,000,000, and a year before −399,999 once the month is carried into
+ * it by rules of its own, which Firefox and Safari do not share, so those are portable only where
+ * the date is invalid in every engine; and a part worth more than 2⁵³ ms that the others bring back
+ * within the range of dates is rounded by Node otherwise than by the browsers. */
+export declare function portableUtc(parts: readonly number[]): boolean;
+/** The refusal of anything that formats by locale, which `Intl` decides from data each engine ships. */
+export declare function localeRefusal(s: Scope, what: string, n: N): never;
+export declare const dates: Plugin;

package/dist/plugins/dates.js

@@ -0,0 +1,224 @@
+import { fail, FLOAT, nothing, STR } from "../model.js";
+import {} from "../plugin.js";
+import { bare, strArg } from "../parens.js";
+import { asF64, compare, numberVal } from "../numbers.js";
+import { describeTy, expr } from "../expr.js";
+const GUIDE = "see the `dates_and_prices` guide";
+const PORTABLE = /^([+-]\d{6}|\d{4})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{3})?)?(Z|[+-](\d{2}):(\d{2}))?)?$/;
+function daysInMonth(year, month) {
+    if (month === 2)
+        return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28;
+    return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+/** The time value `Date.parse(s)` gives a string every JavaScript engine reads alike: one in
+ * ECMAScript's date time string format, a date alone or a date and time with a `Z` or an offset, its
+ * fields within their ranges. `undefined` for any other string, which an engine may read by rules of
+ * its own, or in the time zone of the machine running it, and for a date and time whose fields lie
+ * beyond ±8.64 × 10¹⁵ ms read as UTC while its offset brings it within, which Safari reads as an
+ * invalid date and the other engines as a valid one. */
+export function portableTime(s) {
+    const m = PORTABLE.exec(s);
+    if (!m || m[1] === "-000000" || (m[4] !== undefined && m[7] === undefined))
+        return undefined;
+    const [year, month, day, hours, minutes, seconds, , zoneHours, zoneMinutes] = m.slice(1).map((x) => (x === undefined ? undefined : Number(x)));
+    const within = (x, low, high) => x === undefined || (x >= low && x <= high);
+    const fields = [within(month, 1, 12), within(day, 1, daysInMonth(year, month ?? 1)), within(hours, 0, 23), within(minutes, 0, 59), within(seconds, 0, 59), within(zoneHours, 0, 23), within(zoneMinutes, 0, 59)];
+    if (!fields.every(Boolean))
+        return undefined;
+    const t = Date.parse(s);
+    const zone = m[7];
+    if (zone !== undefined && zone !== "Z" && Number.isNaN(Date.parse(s.slice(0, -zone.length) + "Z")) && !Number.isNaN(t))
+        return undefined;
+    return t;
+}
+const COMMON_DAYS = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
+function v8Day(year, month, date) {
+    const before = (y) => 365 * (y + 399_999) + Math.trunc((y + 399_999) / 4) - Math.trunc((y + 399_999) / 100) + Math.trunc((y + 399_999) / 400);
+    let y = Math.trunc(year) + Math.trunc(Math.trunc(month) / 12);
+    let m = Math.trunc(month) % 12;
+    if (m < 0)
+        [m, y] = [m + 12, y - 1];
+    const leap = y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0);
+    return before(y) - before(1970) + COMMON_DAYS[m] + (leap && m >= 2 ? 1 : 0) - 1 + Math.trunc(date);
+}
+/** Whether `Date.UTC(...parts)` gives what every JavaScript engine gives. V8 reads a year beyond
+ * ±1,000,000, a month beyond ±10,000,000, and a year before −399,999 once the month is carried into
+ * it by rules of its own, which Firefox and Safari do not share, so those are portable only where
+ * the date is invalid in every engine; and a part worth more than 2⁵³ ms that the others bring back
+ * within the range of dates is rounded by Node otherwise than by the browsers. */
+export function portableUtc(parts) {
+    const [year = NaN, month = 0, date = 1, hours = 0, minutes = 0, seconds = 0, ms = 0] = parts;
+    if (![year, month, date, hours, minutes, seconds, ms].every(Number.isFinite))
+        return true;
+    const int = Math.trunc;
+    const terms = [int(hours) * 3_600_000, int(minutes) * 60_000, int(seconds) * 1000];
+    const time = terms[0] + terms[1] + terms[2] + int(ms);
+    if (!Number.isFinite(time))
+        return true;
+    const y = int(year) >= 0 && int(year) <= 99 ? 1900 + int(year) : year;
+    const carried = int(y) + Math.floor(int(month) / 12);
+    if (!(Math.abs(y) <= 1e6 && Math.abs(month) <= 1e7 && carried >= -399_999)) {
+        return Math.abs(carried) >= 399_999 && Math.abs(int(date)) <= 1e7 && Math.abs(time) <= 1e15;
+    }
+    const days = v8Day(y, month, date) * 86_400_000;
+    const t = days + time;
+    const largest = Math.max(Math.abs(days), ...terms.map(Math.abs));
+    return !(Number.isFinite(t) && largest > 2 ** 53 && Math.abs(t) <= 8.64e15 + largest * 2 ** -50);
+}
+const UTC_DEFAULTS = ["0.0f64", "1.0f64", "0.0f64", "0.0f64", "0.0f64", "0.0f64"];
+function fromParts(s, n) {
+    const args = n.arguments;
+    if (args.length < 1 || args.length > 7)
+        return fail(s.comp, "FV1807", `\`Date.UTC()\` takes from one to seven numbers: a year, a month from 0 and the day, hours, minutes, seconds and milliseconds that follow (${GUIDE})`, n);
+    const vals = args.map((a) => {
+        const v = expr(s, a);
+        if (v.ty.k !== "int" && v.ty.k !== "float")
+            fail(s.comp, "FV1807", `\`Date.UTC()\` takes numbers that are present: this is ${describeTy(v.ty)}`, a);
+        return v;
+    });
+    if (vals.every((v) => v.num !== undefined)) {
+        const parts = vals.map((v) => v.num);
+        if (!portableUtc(parts)) {
+            return fail(s.comp, "FV1808", `\`Date.UTC(${parts.join(", ")})\` is a date engines compute differently: V8 reads a year beyond ±1,000,000, a month beyond ±10,000,000 and a year before −399,999 by rules of its own, and Node rounds a part beyond 2⁵³ ms otherwise than the browsers (${GUIDE})`, n);
+        }
+        return numberVal(Date.UTC(...parts), false);
+    }
+    const code = [...vals.map((v) => bare(asF64(v))), ...UTC_DEFAULTS.slice(vals.length - 1)].join(", ");
+    return { code: `fv::js_date_utc(${code})`, ty: FLOAT };
+}
+const LOCAL_GETTERS = new Map([
+    ["getFullYear", "getUTCFullYear"],
+    ["getYear", "getUTCFullYear"],
+    ["getMonth", "getUTCMonth"],
+    ["getDate", "getUTCDate"],
+    ["getDay", "getUTCDay"],
+    ["getHours", "getUTCHours"],
+    ["getMinutes", "getUTCMinutes"],
+    ["getSeconds", "getUTCSeconds"],
+    ["getMilliseconds", "getUTCMilliseconds"],
+]);
+const UTC_GETTERS = new Map([
+    ["getUTCFullYear", "full_year"],
+    ["getUTCMonth", "month"],
+    ["getUTCDate", "date"],
+    ["getUTCDay", "day"],
+    ["getUTCHours", "hours"],
+    ["getUTCMinutes", "minutes"],
+    ["getUTCSeconds", "seconds"],
+    ["getUTCMilliseconds", "milliseconds"],
+]);
+const LOCALE_METHODS = new Set(["toLocaleString", "toLocaleDateString", "toLocaleTimeString", "localeCompare"]);
+const DATE = { k: "date" };
+function global(s, n, name) {
+    return n?.type === "Identifier" && n.name === name && !s.locals.has(name) && !s.setup.has(name);
+}
+function rootOf(n) {
+    while (n?.type === "MemberExpression" || n?.type === "CallExpression" || n?.type === "NewExpression")
+        n = n.type === "MemberExpression" ? n.object : n.callee;
+    return n;
+}
+/** The refusal of anything that formats by locale, which `Intl` decides from data each engine ships. */
+export function localeRefusal(s, what, n) {
+    return fail(s.comp, "FV1805", `${what} formats by locale with \`Intl\`, whose output differs between Node, Chromium, Firefox and Safari: format the value in Rust and pass a string, or translate it with \`$t\` (${GUIDE})`, n);
+}
+function parsed(s, arg, what) {
+    if (arg.type === "StringLiteral") {
+        const t = portableTime(arg.value);
+        if (t === undefined) {
+            fail(s.comp, "FV1803", `${what} of ${JSON.stringify(arg.value)}, which is not a date alone nor a date and time with a \`Z\` or an offset in ECMAScript's date time string format, so each browser may read it differently (${GUIDE})`, arg);
+        }
+        return numberVal(t, false);
+    }
+    const v = expr(s, arg);
+    if (v.ty.k !== "str")
+        return fail(s.comp, "FV1802", `${what} takes a string that is present`, arg);
+    return { code: `fv::js_date_parse(${strArg(v.code)})`, ty: FLOAT };
+}
+function constructed(s, n) {
+    const args = n.arguments;
+    if (args.length === 0)
+        return fail(s.comp, "FV1801", `\`new Date()\` is the time it runs, which differs between the server's render and the browser's hydration: pass the time as a prop (${GUIDE})`, n);
+    if (args.length > 1) {
+        return fail(s.comp, "FV1802", `\`new Date(year, month, …)\` reads its parts in the time zone of the machine running it: pass an ISO string with a \`Z\` or an offset, or a number of milliseconds (${GUIDE})`, n);
+    }
+    if (args[0].type === "StringLiteral")
+        return { code: parsed(s, args[0], "`new Date()`").code, ty: DATE };
+    const v = expr(s, args[0]);
+    if (v.ty.k === "date")
+        return v;
+    if (v.ty.k === "str")
+        return { code: `fv::js_date_parse(${strArg(v.code)})`, ty: DATE };
+    if (v.ty.k === "int" || v.ty.k === "float")
+        return { code: `fv::js_time_clip(${bare(asF64(v))})`, ty: DATE };
+    return fail(s.comp, "FV1802", `\`new Date()\` takes one string or one number that is present (${GUIDE})`, args[0]);
+}
+export const dates = {
+    name: "dates",
+    construct(s, n) {
+        if (global(s, rootOf(n.callee), "Intl"))
+            return localeRefusal(s, "`Intl`", n);
+        return global(s, n.callee, "Date") ? constructed(s, n) : null;
+    },
+    call(s, n) {
+        const callee = n.callee;
+        if (callee.type !== "MemberExpression" || callee.computed)
+            return null;
+        const method = callee.property.name;
+        const object = callee.object;
+        if (object.type === "Identifier" && object.name === "_ctx" && (method === "$d" || method === "$n"))
+            return localeRefusal(s, `vue-i18n's \`${method}\``, n);
+        const own = object.type === "Identifier" && (object.name === "_ctx" || object.name === "$setup");
+        if (!own && LOCALE_METHODS.has(method))
+            return localeRefusal(s, `\`.${method}()\``, n);
+        if (!global(s, object, "Date"))
+            return null;
+        if (method === "now")
+            return fail(s.comp, "FV1801", `\`Date.now()\` is the time it runs, which differs between the server's render and the browser's hydration: pass the time as a prop (${GUIDE})`, n);
+        if (method === "parse" && n.arguments.length === 1)
+            return parsed(s, n.arguments[0], "`Date.parse()`");
+        if (method === "UTC")
+            return fromParts(s, n);
+        return fail(s.comp, "FV1804", `\`Date.${method}()\` is not supported: build a date with \`new Date()\` of an ISO string or a number of milliseconds, or with \`Date.UTC()\` of its parts (${GUIDE})`, n);
+    },
+    method(s, target, method, args, n) {
+        if (target.ty.k !== "date")
+            return null;
+        const t = bare(target.code);
+        const plain = args.length === 0;
+        if (plain && method === "toISOString")
+            return { code: `&*fv::js_to_iso_string(${t})`, ty: STR };
+        if (plain && method === "toUTCString")
+            return { code: `&*fv::js_to_utc_string(${t})`, ty: STR };
+        if (plain && method === "toJSON")
+            return { code: `fv::js_to_json(${t}).as_deref()`, ty: { k: "opt", of: STR, none: "null" }, held: `fv::js_to_json(${t}).map(std::borrow::Cow::<str>::Owned)` };
+        if (plain && (method === "getTime" || method === "valueOf"))
+            return { code: target.code, ty: FLOAT };
+        const utc = UTC_GETTERS.get(method);
+        if (plain && utc !== undefined)
+            return { code: `fv::js_utc_${utc}(${t})`, ty: FLOAT };
+        if (LOCAL_GETTERS.has(method) || method === "getTimezoneOffset") {
+            const instead = LOCAL_GETTERS.get(method);
+            return fail(s.comp, "FV1804", `\`.${method}()\` reads the date in the time zone of the machine running it, which differs between the server and the reader's browser${instead ? `: use \`.${instead}()\`` : ""} (${GUIDE})`, n);
+        }
+        return fail(s.comp, "FV1804", `\`.${method}(${plain ? "" : "…"})\` on a \`Date\` is not supported: a date is read with \`.toISOString()\`, \`.toUTCString()\`, \`.toJSON()\`, \`.getTime()\` and the \`.getUTC…()\` methods (${GUIDE})`, n);
+    },
+    values: {
+        order(a, op, b) {
+            if (a.ty.k !== "date" || b.ty.k !== "date")
+                return undefined;
+            return compare({ code: a.code, ty: FLOAT }, op, { code: b.code, ty: FLOAT });
+        },
+        refuseEquality(s, a, b, n) {
+            const dated = (ty) => ty.k === "date" || (ty.k === "opt" && ty.of.k === "date");
+            if (!(dated(a.ty) || dated(b.ty)) || nothing(a.ty) || nothing(b.ty))
+                return;
+            const why = dated(a.ty) && dated(b.ty)
+                ? "is true only when the two are one object, so two dates of the same time are unequal"
+                : "compares the date as an object, or as its `.toString()` in the time zone of the machine running it";
+            fail(s.comp, "FV1809", `\`${n.operator}\` between ${describeTy(a.ty)} and ${describeTy(b.ty)} ${why}: compare time values, \`a.getTime() === b.getTime()\` (${GUIDE})`, n);
+        },
+        json: (v) => (v.ty.k === "date" ? `fv::js_json_date(${bare(v.code)})` : undefined),
+        describe: (ty) => (ty.k === "date" ? "a `Date`" : undefined),
+        unbindable: (ty) => ty.k === "date" ? { what: "a `Date`", fix: "bind `.toISOString()`, or format it in Rust and pass a string" } : undefined,
+    },
+};

package/dist/plugins/i18n.js

@@ -67,7 +67,7 @@ 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(", ")}] }`;
+    return `Message::new(&[${cases.map((c) => `&[${items(c).map(part).join(", ")}]`).join(", ")}])`;
 }
 function byteOrder(a, b) {
     return Buffer.compare(Buffer.from(a), Buffer.from(b));
@@ -76,13 +76,12 @@ function i18nSource(setup) {
     const locales = setup.locales
         .map((l) => {
         const keys = [...l.messages.keys()].toSorted(byteOrder);
-        const entries = keys.map((k) => `            (${rustStr(k)}, ${messageSource(l.file, k, l.messages.get(k))}),`).join("\n");
-        return `    Locale {
-        name: ${rustStr(l.name)},
-        messages: &[
+        if (keys.length === 0)
+            return `    Locale::new(${rustStr(l.name)}, &[]),`;
+        const entries = keys.map((k) => `        (${rustStr(k)}, ${messageSource(l.file, k, l.messages.get(k))}),`).join("\n");
+        return `    Locale::new(${rustStr(l.name)}, &[
 ${entries}
-        ],
-    },`;
+    ]),`;
     })
         .join("\n");
     return `${header(setup.dir.replace(/\/?$/, "/"), "the locale files")}
@@ -130,9 +129,9 @@ function translate(s, args, n) {
     const key = expr(s, args[0]);
     if (key.ty.k !== "str")
         fail(s.comp, "FV1409", "the key given to `t()` is a string", args[0]);
-    let named = "&[]";
-    let list = "&[]";
-    let plural = "None";
+    let named = "";
+    let list = "";
+    let plural = "";
     for (const a of args.slice(1)) {
         if (a.type === "ObjectExpression") {
             const pairs = a.properties.map((p) => {
@@ -140,10 +139,10 @@ function translate(s, args, n) {
                     fail(s.comp, "FV1410", "named values hold plain keys", p);
                 return `(${rustStr(String(p.key.name ?? p.key.value))}, ${i18nValue(s, p.value)})`;
             });
-            named = `&[${pairs.join(", ")}]`;
+            named = `.with_named(&[${pairs.join(", ")}])`;
         }
         else if (a.type === "ArrayExpression") {
-            list = `&[${a.elements.map((el) => i18nValue(s, el)).join(", ")}]`;
+            list = `.with_list(&[${a.elements.map((el) => i18nValue(s, el)).join(", ")}])`;
         }
         else {
             const v = expr(s, a);
@@ -151,10 +150,10 @@ function translate(s, args, n) {
                 fail(s.comp, "FV1411", "a default message given to `t()` is not supported: add the message to the locale files", a);
             if (v.ty.k !== "int")
                 fail(s.comp, "FV1412", "the plural number given to `t()` is an integer", a);
-            plural = `Some(${bare(v.code)})`;
+            plural = `.with_plural(${bare(v.code)})`;
         }
     }
-    return { code: `&*fv_i18n.t(${strArg(key.code)}, &fv::i18n::Args { named: ${named}, list: ${list}, plural: ${plural} })`, ty: STR };
+    return { code: `&*fv_i18n.t(${strArg(key.code)}, &fv::i18n::Args::new()${named}${list}${plural})`, ty: STR };
 }
 export const i18n = {
     name: "i18n",
@@ -193,6 +192,9 @@ export const i18n = {
                 s.setup.set(p.value.name, { code: "fv_i18n.locale()", ty: STR });
                 s.refs.add(p.value.name);
             }
+            else if (key === "d" || key === "n") {
+                s.clientOnly.set(p.value.name, `\`${key}\` from \`useI18n()\` formats by locale with \`Intl\`, whose output differs between Node and each browser (see the \`dates_and_prices\` guide)`);
+            }
             else
                 s.clientOnly.set(p.value.name, `\`${key}\` from \`useI18n()\` does not run on the server`);
         }

package/dist/plugins/index.js

@@ -10,4 +10,5 @@ import { twinsPlugin } from "./twins.js";
 import { provideInject } from "./provide.js";
 import { head } from "./head.js";
 import { cssModules } from "./css-modules.js";
-export const PLUGINS = [router, piniaStores, sharedTypes, i18n, teleport, scoped, clientOnly, twinsPlugin, provideInject, head, cssModules];
+import { dates } from "./dates.js";
+export const PLUGINS = [router, piniaStores, sharedTypes, i18n, teleport, scoped, clientOnly, twinsPlugin, provideInject, head, cssModules, dates];

package/dist/plugins/router.js

@@ -109,9 +109,10 @@ function routeDefs(routes, depth) {
     const pad = "    ".repeat(depth);
     return routes
         .map((r) => {
-        const name = r.name === undefined ? "None" : `Some(${rustStr(r.name)})`;
-        const children = r.children?.length ? `&[\n${routeDefs(r.children, depth + 1)}\n${pad}]` : "&[]";
-        return `${pad}ferrovue::RouteDef { path: ${rustStr(r.path)}, name: ${name}, view: ${r.view !== false}, children: ${children} },`;
+        const name = r.name === undefined ? "" : `.with_name(${rustStr(r.name)})`;
+        const view = r.view === false ? ".with_view(false)" : "";
+        const children = r.children?.length ? `.with_children(&[\n${routeDefs(r.children, depth + 1)}\n${pad}])` : "";
+        return `${pad}ferrovue::RouteDef::new(${rustStr(r.path)})${name}${view}${children},`;
     })
         .join("\n");
 }
@@ -206,7 +207,7 @@ export const router = {
             return null;
         const v = expr(s, tested.target);
         if (v.ty.k !== "query")
-            fail(s.comp, "FV1234", '`typeof` tests a query value only, as `typeof route.query.q === "string"`', n);
+            return null;
         const one = `${atom(v.code)}.attr_value().is_some()`;
         return boolOf(tested.negated ? not(one) : one);
     },
@@ -216,7 +217,9 @@ export const router = {
             return undefined;
         const path = pathOf(t.target);
         const v = expr(s, t.target);
-        if (path === null || v.ty.k !== "query")
+        if (v.ty.k !== "query")
+            return undefined;
+        if (path === null)
             return null;
         const option = `${atom(v.code)}.attr_value()`;
         return { path, of: STR, negated: t.negated, truthy: false, option, present: `${option}.is_some()`, pattern: (name) => `let Some(${name}) = ${option}` };