ferrovue 0.3.0 → 0.4.0

package/dist/model.d.ts

@@ -1,12 +1,11 @@
 import type { SourceMapConsumer } from "source-map-js";
+import type { Plugin } from "./plugin.ts";
 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";
@@ -18,82 +17,42 @@ export type 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. */
- | {
+} | StructTy | {
     k: "html";
-}
-/** Another component's `Props`, imported from its `.vue` file: what `v-bind` hands that child. */
- | {
+} | {
     k: "child";
     name: string;
+} | PluginTys[keyof PluginTys];
+export interface StructTy {
+    k: "struct";
+    name: string;
+    home?: string;
 }
-/** `useRoute()` or `$route`: the reader's location, as vue-router resolved it. */
- | {
-    k: "route";
-}
-/** `route.params`. */
- | {
-    k: "params";
+export interface PluginTys {
 }
-/** `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[];
@@ -106,164 +65,76 @@ 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;
-/** `camelize` in `@vue/shared`: how Vue matches an attribute a parent passes to a declared prop. */
 export declare function camelize(key: string): string;
-/** Whether a component declares the prop a parent passes as `key`, as `setFullProps` decides. */
 export declare function declares(comp: Component, key: string): boolean;
-/** Whether a component may be passed attributes beyond its props, and so takes `fv::Attrs`. */
 export declare function takesAttrs(comp: Component): boolean;
 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;
     };
-    /** A root `<Transition>` or `<KeepAlive>` around anything but one plain element — a `v-if`, a
-     * `<template>` — whose content Vue's server gives no attributes and its client does. */
     attrsDropped?: N;
     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. */
+    takes: Set<string>;
     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;
-    /** The attributes a parent may pass it beyond its props, by name: what falls through to its root,
-     * or to the element that binds `$attrs`. With any, its `render_scoped` takes them as
-     * `fv::Attrs`. Known once every component is read (`attrsFlow`). */
     attrNames: Set<string>;
-    /** Whether its `$attrs` may hold scope ids: it is the root of a component that may be handed
-     * some, which passes them on as attributes. */
     idsInAttrs: boolean;
 }
+export declare function blankComponent(name: string, module: string, file: string, structs?: Map<string, Struct>): Component;
 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 `fv::Attrs` a parent passes this render beyond its props — `$attrs`, and what
-     * `_attrs` holds before the scope ids — or `null` when no parent passes any. */
     fallthrough: string | null;
-    /** Setup bindings holding `useAttrs()`, which the template may bind as `$attrs`. */
     attrsBindings: Set<string>;
-    /** 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;
     };
+    plugins: Map<Plugin, unknown>;
 }
-/** 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

@@ -1,4 +1,3 @@
-/* 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" };
@@ -6,22 +5,21 @@ 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. */
+const NOT_RAW = new Set(["self", "Self", "super", "crate"]);
 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(/^_/, "");
+    if (NOT_RAW.has(s))
+        return `${s}_`;
     return RUST_KEYWORDS.has(s) ? `r#${s}` : s;
 }
-/** `camelize` in `@vue/shared`: how Vue matches an attribute a parent passes to a declared prop. */
 export function camelize(key) {
     return key.replace(/-(\w)/g, (_, c) => c.toUpperCase());
 }
-/** Whether a component declares the prop a parent passes as `key`, as `setFullProps` decides. */
 export function declares(comp, key) {
     const camel = camelize(key);
     return comp.props.fields.some((f) => camelize(f.js) === camel);
 }
-/** Whether a component may be passed attributes beyond its props, and so takes `fv::Attrs`. */
 export function takesAttrs(comp) {
     return comp.attrNames.size > 0;
 }
@@ -46,7 +44,6 @@ export function rustStr(s) {
     }
     return out + '"';
 }
-/** One character as a Rust `char` literal. */
 export function rustChar(ch) {
     if (ch === "'")
         return "'\\''";
@@ -56,9 +53,31 @@ export function rustChar(ch) {
 }
 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 blankComponent(name, module, file, structs = new Map()) {
+    return {
+        name,
+        module,
+        file,
+        props: { name: "Props", fields: [] },
+        structs,
+        trustedName: null,
+        floatName: null,
+        childProps: new Map(),
+        imports: new Set(),
+        slotNames: [],
+        takes: new Set(),
+        models: new Map(),
+        aliases: new Map(),
+        importedTypes: new Map(),
+        slotShapes: new Map(),
+        inheritAttrs: true,
+        inherits: false,
+        passesSlotIds: false,
+        attrNames: new Set(),
+        idsInAttrs: false,
+    };
+}
 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);
@@ -77,7 +96,6 @@ export function tagAst(node, origin, seen = new WeakSet()) {
             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)
@@ -88,19 +106,16 @@ function locate(comp, node) {
         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}^`;
 }

package/dist/narrowing.d.ts

@@ -0,0 +1,19 @@
+import { type N, type Scope, type Ty, type Val } from "./model.ts";
+export declare function known(v: Val): boolean | undefined;
+export declare function truthy(v: Val): string;
+export declare function pathOf(n: N): string | null;
+export interface Presence {
+    path: string;
+    pattern: (name: string) => string;
+    option: string;
+    present: string;
+    of: Ty;
+    negated: boolean;
+    truthy: boolean;
+}
+export declare function presence(s: Scope, n: N): Presence | null;
+export declare function narrowTo(s: Scope, p: Presence, name: string): Scope;
+export declare function narrowing(s: Scope, p: Presence, present: (s: Scope) => string, absent: (s: Scope) => string): string;
+export declare function choice(test: string, yes: string, no: string): string;
+export declare function cond(s: Scope, n: N): string;
+export declare function boolOf(code: string): Val;

package/dist/narrowing.js

@@ -0,0 +1,126 @@
+import { BOOL } 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";
+export function known(v) {
+    if (v.konst !== undefined)
+        return v.konst;
+    if (v.ty.k === "str" && /^"(?:[^"\\]|\\.)*"$/.test(v.code))
+        return v.code !== '""';
+    if (v.num !== undefined)
+        return v.num !== 0 && !Number.isNaN(v.num);
+    return undefined;
+}
+export function truthy(v) {
+    const k = known(v);
+    if (k !== undefined)
+        return String(k);
+    const branches = v.ty.k === "str" || isNumber(v.ty) ? ifElse(v.code) : null;
+    if (branches)
+        return choice(branches.test, truthy({ code: branches.yes, ty: v.ty }), truthy({ code: branches.no, ty: v.ty }));
+    switch (v.ty.k) {
+        case "str":
+            return `!${receiver(v.code)}.is_empty()`;
+        case "int":
+            return binary(v.code, "!=", "0");
+        case "float":
+            return `${binary(v.code, "!=", "0.0")} && !${receiver(v.code)}.is_nan()`;
+        case "bool":
+            return v.code;
+        case "undef":
+            return "false";
+        case "opt":
+            return `${atom(v.code)}.is_some_and(|v| ${truthy({ code: "v", ty: v.ty.of })})`;
+        default:
+            return claim((p) => p.values?.truthy?.(v)) ?? "true";
+    }
+}
+export function pathOf(n) {
+    if (n.type === "Identifier")
+        return n.name;
+    if (n.type !== "MemberExpression")
+        return null;
+    const base = pathOf(n.object);
+    if (base === null)
+        return null;
+    if (!n.computed && n.property.type === "Identifier")
+        return `${base}.${n.property.name}`;
+    if (n.computed && n.property.type === "StringLiteral")
+        return `${base}.${n.property.value}`;
+    return null;
+}
+export function presence(s, n) {
+    for (const p of ctx.plugins) {
+        const own = p.presence?.(s, n);
+        if (own !== undefined)
+            return own;
+    }
+    let target = n;
+    let negated = false;
+    let byTruth = true;
+    if (n.type === "UnaryExpression" && n.operator === "!") {
+        target = n.argument;
+        negated = true;
+    }
+    else if (n.type === "BinaryExpression" && (n.operator === "===" || n.operator === "!==")) {
+        const isUndef = (m) => m.type === "Identifier" && m.name === "undefined";
+        if (isUndef(n.right))
+            target = n.left;
+        else if (isUndef(n.left))
+            target = n.right;
+        else
+            return null;
+        negated = n.operator === "===";
+        byTruth = false;
+    }
+    const path = pathOf(target);
+    if (path === null)
+        return null;
+    const v = expr(s, target);
+    if (v.ty.k !== "opt")
+        return null;
+    const of = v.ty.of;
+    const scalar = of.k === "str" || of.k === "int" || of.k === "float" || of.k === "bool";
+    const filtered = byTruth && scalar;
+    const option = filtered ? `${atom(v.code)}.filter(|v| ${truthy({ code: "*v", ty: of })})` : v.code;
+    const present = filtered ? truthy(v) : `${atom(v.code)}.is_some()`;
+    return { path, of, negated, truthy: byTruth, option, present, pattern: (name) => `let Some(${name}) = ${option}` };
+}
+export function narrowTo(s, p, name) {
+    return { ...s, narrowed: new Map(s.narrowed).set(p.path, { code: name, ty: p.of }) };
+}
+export function narrowing(s, p, present, absent) {
+    const name = `n${++ctx.narrowCount}`;
+    const then = bare(present(narrowTo(s, p, name)));
+    const otherwise = bare(absent(s));
+    if (occurrences(then, name))
+        return `if ${p.pattern(name)} { ${then} } else { ${otherwise} }`;
+    return choice(p.present, then, otherwise);
+}
+export function choice(test, yes, no) {
+    const binds = test.startsWith("let ");
+    if (yes === no && !binds)
+        return yes;
+    if (yes === "true" && no === "false" && !binds)
+        return test;
+    if (yes === "false" && no === "true" && !binds)
+        return not(test);
+    return `if ${condition(test)} { ${yes} } else { ${no} }`;
+}
+export function cond(s, n) {
+    if (n.type === "LogicalExpression" && (n.operator === "||" || n.operator === "&&")) {
+        const p = presence(s, n.left);
+        if (p && p.negated === (n.operator === "||")) {
+            return narrowing(s, p, (inner) => cond(inner, n.right), () => String(n.operator === "||"));
+        }
+        return logical(cond(s, n.left), n.operator, cond(s, n.right));
+    }
+    if (n.type === "UnaryExpression" && n.operator === "!")
+        return negatedOrder(s, n.argument)?.code ?? not(cond(s, n.argument));
+    return truthy(expr(s, n));
+}
+export function boolOf(code) {
+    return code === "true" || code === "false" ? { code, ty: BOOL, konst: code === "true" } : { code, ty: BOOL };
+}

package/dist/numbers.d.ts

@@ -0,0 +1,8 @@
+import { type N, type Scope, type Ty, type Val } from "./model.ts";
+export declare function isNumber(ty: Ty): boolean;
+export declare function asF64(v: Val): string;
+export declare function intFromF64(f64: string): Val;
+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;

package/dist/numbers.js

@@ -0,0 +1,73 @@
+import { BOOL, FLOAT, INT } from "./model.js";
+import { AS, binary, FLIPPED, operand } from "./parens.js";
+import { expr } from "./expr.js";
+export function isNumber(ty) {
+    return ty.k === "int" || ty.k === "float";
+}
+export function asF64(v) {
+    if (v.f64 !== undefined)
+        return v.f64;
+    return v.ty.k === "float" ? v.code : `${operand(v.code, AS)} as f64`;
+}
+export function intFromF64(f64) {
+    return { code: `${operand(f64, AS)} as i64`, ty: INT, f64 };
+}
+function floatLiteral(x) {
+    if (Number.isNaN(x))
+        return "f64::NAN";
+    if (!Number.isFinite(x))
+        return x > 0 ? "f64::INFINITY" : "f64::NEG_INFINITY";
+    const spelled = String(Math.abs(x)).replace("e+", "e");
+    return `${x < 0 || Object.is(x, -0) ? "-" : ""}${/[.e]/.test(spelled) ? spelled : `${spelled}.0`}f64`;
+}
+export function numberVal(x, int) {
+    if (!int)
+        return { code: floatLiteral(x), ty: FLOAT, num: x };
+    if (!Number.isSafeInteger(x))
+        return { ...intFromF64(floatLiteral(x)), num: x };
+    return { code: `${x === 0 ? 0 : x}i64`, ty: INT, f64: floatLiteral(x), num: x };
+}
+function fold(a, op, b) {
+    switch (op) {
+        case "+":
+            return a + b;
+        case "-":
+            return a - b;
+        case "*":
+            return a * b;
+        case "/":
+            return a / b;
+        case "%":
+            return a % b;
+        case "<":
+            return a < b;
+        case ">":
+            return a > b;
+        case "<=":
+            return a <= b;
+        case ">=":
+            return a >= b;
+        default:
+            return a === b;
+    }
+}
+export function arithmetic(a, op, b, int) {
+    if (a.num !== undefined && b.num !== undefined)
+        return numberVal(fold(a.num, op, b.num), int);
+    const f64 = binary(asF64(a), op, asF64(b));
+    return int ? intFromF64(f64) : { code: f64, ty: FLOAT };
+}
+export function compare(a, op, b) {
+    if (a.num !== undefined && b.num !== undefined) {
+        const konst = fold(a.num, op, b.num);
+        return { code: String(konst), ty: BOOL, konst };
+    }
+    return { code: binary(asF64(a), op, asF64(b)), ty: BOOL };
+}
+export function negatedOrder(s, n) {
+    if (n.type !== "BinaryExpression" || !(n.operator in FLIPPED))
+        return null;
+    const a = expr(s, n.left);
+    const b = expr(s, n.right);
+    return a.ty.k === "int" && b.ty.k === "int" ? compare(a, FLIPPED[n.operator], b) : null;
+}

package/dist/parens.d.ts

@@ -2,50 +2,23 @@ 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;