@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.0

package/highlight/index.jsx

@@ -0,0 +1,357 @@
+// Rivet-authored (no React Aria / Angular CDK counterpart): a small regex tokenizer for code in AI responses. Feature set
+// (syntax-highlighted code blocks for common languages) inspired by HeroUI Pro's public CodeBlock docs, which use Shiki;
+// this is an independent, dependency-free implementation: no grammar files, no WASM, synchronous, same output on the
+// server and in the browser. Tokens are plain data (`{ type, value }`); renderers wrap them in spans (no HTML strings).
+// - Languages: JavaScript / TypeScript (+ JSX / TSX), JSON, CSS / SCSS, HTML / XML / SVG / Vue, shell, Python, SQL,
+//   YAML, diff, and a C-family fallback (Rust, Go, Java, C, C++, C#, Kotlin, Swift, PHP, Ruby, Dart); anything else is
+//   plain text. `resolveLanguage` maps aliases (`ts`, `sh`, `py`, …).
+// - Joining every token `value` gives the input back exactly.
+const ALIASES = {
+    js: "js",
+    javascript: "js",
+    jsx: "js",
+    mjs: "js",
+    cjs: "js",
+    ts: "js",
+    typescript: "js",
+    tsx: "js",
+    mts: "js",
+    cts: "js",
+    json: "json",
+    jsonc: "json",
+    json5: "json",
+    css: "css",
+    scss: "css",
+    sass: "css",
+    less: "css",
+    postcss: "css",
+    html: "markup",
+    xml: "markup",
+    svg: "markup",
+    vue: "markup",
+    svelte: "markup",
+    astro: "markup",
+    sh: "shell",
+    bash: "shell",
+    zsh: "shell",
+    shell: "shell",
+    console: "shell",
+    shellscript: "shell",
+    terminal: "shell",
+    py: "python",
+    python: "python",
+    sql: "sql",
+    postgres: "sql",
+    postgresql: "sql",
+    mysql: "sql",
+    sqlite: "sql",
+    yaml: "yaml",
+    yml: "yaml",
+    toml: "yaml",
+    diff: "diff",
+    patch: "diff",
+    rust: "clike",
+    rs: "clike",
+    go: "clike",
+    golang: "clike",
+    java: "clike",
+    c: "clike",
+    h: "clike",
+    cpp: "clike",
+    "c++": "clike",
+    cs: "clike",
+    csharp: "clike",
+    kotlin: "clike",
+    kt: "clike",
+    swift: "clike",
+    php: "clike",
+    ruby: "clike",
+    rb: "clike",
+    dart: "clike",
+    scala: "clike",
+};
+/** Tokenizer family for a language id / alias (`"ts"` → `"js"`); unknown ids → `"plaintext"`. */
+export function resolveLanguage(language) {
+    return (language && ALIASES[language.trim().toLowerCase()]) || "plaintext";
+}
+/** Display name for a language id (`"ts"` → `"TypeScript"`); unknown ids are returned as given. */
+export function languageLabel(language) {
+    const id = (language ?? "").trim().toLowerCase();
+    const names = {
+        js: "JavaScript",
+        javascript: "JavaScript",
+        jsx: "JSX",
+        ts: "TypeScript",
+        typescript: "TypeScript",
+        tsx: "TSX",
+        json: "JSON",
+        css: "CSS",
+        scss: "SCSS",
+        html: "HTML",
+        xml: "XML",
+        svg: "SVG",
+        vue: "Vue",
+        sh: "Shell",
+        bash: "Bash",
+        zsh: "Zsh",
+        shell: "Shell",
+        console: "Console",
+        py: "Python",
+        python: "Python",
+        sql: "SQL",
+        yaml: "YAML",
+        yml: "YAML",
+        toml: "TOML",
+        diff: "Diff",
+        rust: "Rust",
+        rs: "Rust",
+        go: "Go",
+        java: "Java",
+        c: "C",
+        cpp: "C++",
+        cs: "C#",
+        csharp: "C#",
+        kotlin: "Kotlin",
+        swift: "Swift",
+        php: "PHP",
+        ruby: "Ruby",
+        dart: "Dart",
+        "": "Text",
+        text: "Text",
+        plaintext: "Text",
+        txt: "Text",
+    };
+    return names[id] ?? language ?? "Text";
+}
+const words = (list) => new Set(list.split(" "));
+const JS_KEYWORDS = words("abstract as async await break case catch class const constructor continue debugger declare default delete do else enum export extends finally for from function get if implements import in infer instanceof interface is keyof let module namespace new of override private protected public readonly return satisfies set static super switch this throw try type typeof var void while with yield");
+const JS_LITERALS = words("true false null undefined NaN Infinity");
+const PY_KEYWORDS = words("and as assert async await break class continue def del elif else except finally for from global if import in is lambda match case nonlocal not or pass raise return try while with yield");
+const PY_LITERALS = words("True False None self cls");
+const SHELL_KEYWORDS = words("if then else elif fi for while until do done case esac in function select return exit export local readonly unset source alias sudo");
+const SQL_KEYWORDS = words("select from where and or not insert into values update set delete create table index view drop alter add column primary key foreign references join left right inner outer full on group by order having limit offset as distinct union all exists in is like between case when then else end returning with default unique check constraint begin commit rollback transaction asc desc count sum avg min max");
+const SQL_LITERALS = words("null true false");
+const CLIKE_KEYWORDS = words("abstract as async await break case catch class const continue crate def default defer do dyn else enum extends extern final finally fn for foreach func go goto if impl implements import in interface internal let loop match mod module move mut namespace new nil override package private protected pub public readonly ref return select self Self sealed static struct super switch template this throw throws trait try type typedef typename union unsafe use using var virtual void volatile when where while yield val fun object companion lateinit init deinit guard protocol extension elif elsif unless until begin end require include echo function");
+const CLIKE_LITERALS = words("true false null nullptr nil None NULL");
+const CLIKE_TYPES = words("int long short char byte bool boolean float double string String str usize isize u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 void auto Vec Option Result Box Some Ok Err error any rune uint uint8 uint16 uint32 uint64 int8 int16 int32 int64 float32 float64 object dynamic");
+const NUMBER = /(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|(?:\d[\d_]*\.?[\d_]*|\.\d[\d_]*)(?:[eE][+-]?\d+)?)n?/y;
+const IDENT = /[A-Za-z_$][\w$]*/y;
+const SPACE = /\s+/y;
+const GRAMMARS = {
+    js: [
+        ["comment", /\/\/[^\n]*|\/\*[\s\S]*?(?:\*\/|$)/y],
+        ["string", /`(?:\\[\s\S]|\$\{[^}]*\}|[^\\`])*`?|"(?:\\.|[^\\"\n])*"?|'(?:\\.|[^\\'\n])*'?/y],
+        ["tag", /(?<![\w$)\]])<\/?(?=[A-Za-z])[\w.:-]*|\/>/y],
+        ["number", NUMBER],
+        ["ident", IDENT],
+        ["operator", /=>|\?\?=?|\?\.|\.\.\.|[=!]==?|[<>]=?|&&=?|\|\|=?|[-+*/%&|^~!?:]=?|=/y],
+        ["punctuation", /[{}()[\];,.@#]/y],
+    ],
+    json: [
+        ["comment", /\/\/[^\n]*|\/\*[\s\S]*?(?:\*\/|$)/y],
+        ["property", /"(?:\\.|[^\\"\n])*"(?=\s*:)/y],
+        ["string", /"(?:\\.|[^\\"\n])*"?/y],
+        ["number", /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y],
+        ["literal", /\b(?:true|false|null)\b/y],
+        ["punctuation", /[{}[\],:]/y],
+    ],
+    css: [
+        ["comment", /\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\n]*/y],
+        ["string", /"(?:\\.|[^\\"\n])*"?|'(?:\\.|[^\\'\n])*'?/y],
+        ["keyword", /@[\w-]+/y],
+        ["property", /--?[A-Za-z][\w-]*(?=\s*:(?!:))/y],
+        ["number", /#[\da-fA-F]{3,8}\b|-?(?:\d+\.?\d*|\.\d+)(?:%|[a-zA-Z]+)?/y],
+        ["function", /[\w-]+(?=\()/y],
+        ["variable", /\$[\w-]+|--[\w-]+/y],
+        ["tag", /[.#][A-Za-z_-][\w-]*|&/y],
+        ["plain", /[A-Za-z_-][\w-]*/y],
+        ["punctuation", /[{}()[\];:,>+~*=]/y],
+    ],
+    markup: [
+        ["comment", /<!--[\s\S]*?(?:-->|$)/y],
+        ["meta", /<![^>]*>?|<\?[\s\S]*?(?:\?>|$)/y],
+        ["tag", /<\/?[A-Za-z][\w.:-]*|\/?>/y],
+        ["attribute", /[A-Za-z_:@#.][\w:.-]*(?=\s*=)/y],
+        ["string", /"[^"]*"?|'[^']*'?/y],
+        ["operator", /=/y],
+        ["plain", /[^<"'=\s/>]+/y],
+    ],
+    shell: [
+        ["comment", /(?<![^\s;])#[^\n]*/y],
+        ["string", /"(?:\\.|[^\\"])*"?|'[^']*'?/y],
+        ["variable", /\$(?:\{[^}]*\}?|\w+|[@#?$!*-])/y],
+        ["attribute", /(?<=\s)--?[\w-]+/y],
+        ["meta", /^(?:\$|>|#) /my],
+        ["number", /\b\d+\b/y],
+        ["ident", /[A-Za-z_][\w.-]*/y],
+        ["operator", /&&|\|\||[|&;<>]=?|=/y],
+        ["punctuation", /[(){}[\]]/y],
+    ],
+    python: [
+        ["comment", /#[^\n]*/y],
+        ["string", /[rRbBfFuU]{0,2}(?:"""[\s\S]*?(?:"""|$)|'''[\s\S]*?(?:'''|$)|"(?:\\.|[^\\"\n])*"?|'(?:\\.|[^\\'\n])*'?)/y],
+        ["meta", /@[\w.]+/y],
+        ["number", NUMBER],
+        ["ident", IDENT],
+        ["operator", /\*\*=?|\/\/=?|->|:=|[=!<>]=?|[-+*/%&|^~@]=?/y],
+        ["punctuation", /[{}()[\];,.:]/y],
+    ],
+    sql: [
+        ["comment", /--[^\n]*|\/\*[\s\S]*?(?:\*\/|$)/y],
+        ["string", /'(?:''|[^'])*'?|"(?:""|[^"])*"?/y],
+        ["number", /\b\d+(?:\.\d+)?\b/y],
+        ["ident", /[A-Za-z_][\w$]*/y],
+        ["operator", /[<>!]=?|=|\|\||[-+*/%]/y],
+        ["punctuation", /[(),;.]/y],
+    ],
+    yaml: [
+        ["comment", /#[^\n]*/y],
+        ["meta", /^---$|^\.\.\.$|^\[[^\]\n]*\]$/my],
+        ["property", /[\w.-]+(?=\s*[:=](?:\s|$))|"[^"\n]*"(?=\s*:)/y],
+        ["string", /"(?:\\.|[^\\"\n])*"?|'(?:''|[^'\n])*'?/y],
+        ["literal", /\b(?:true|false|null|yes|no|on|off)\b|~/y],
+        ["number", /-?\b\d+(?:\.\d+)?\b/y],
+        ["variable", /[&*][\w-]+/y],
+        ["punctuation", /[-:[\]{},|>=]/y],
+        ["plain", /[^\s#:"'[\]{},]+/y],
+    ],
+    clike: [
+        ["comment", /\/\/[^\n]*|\/\*[\s\S]*?(?:\*\/|$)|#(?!\[)[^\n]*/y],
+        ["string", /r#*"[\s\S]*?"#*|"(?:\\.|[^\\"\n])*"?|`[^`]*`?|'(?:\\.|[^\\'\n]){0,2}'/y],
+        ["meta", /#\[[^\]\n]*\]?|@\w+/y],
+        ["number", NUMBER],
+        ["ident", IDENT],
+        ["operator", /::|->|=>|\.\.=?|[=!<>]=?|&&|\|\||[-+*/%&|^~!?]=?|:=?/y],
+        ["punctuation", /[{}()[\];,.]/y],
+    ],
+};
+function classify(language, word, rest, prev, lineStart) {
+    const call = /^\s*\(/.test(rest);
+    const afterDot = prev?.type === "punctuation" && prev.value === ".";
+    if (language === "js") {
+        if (afterDot)
+            return call ? "function" : "property";
+        if (JS_KEYWORDS.has(word))
+            return "keyword";
+        if (JS_LITERALS.has(word))
+            return "literal";
+        if (call)
+            return "function";
+        if (/^[A-Z]/.test(word))
+            return "type";
+        if (/^\s*:(?!:)/.test(rest) && prev?.value !== "?" && prev?.type !== "operator")
+            return "property";
+        return "plain";
+    }
+    if (language === "python") {
+        if (afterDot)
+            return call ? "function" : "property";
+        if (PY_KEYWORDS.has(word))
+            return "keyword";
+        if (PY_LITERALS.has(word))
+            return "literal";
+        if (call || prev?.value === "def")
+            return "function";
+        if (/^[A-Z]/.test(word) || prev?.value === "class")
+            return "type";
+        return "plain";
+    }
+    if (language === "shell") {
+        if (SHELL_KEYWORDS.has(word))
+            return "keyword";
+        // The command word of a line / after a pipe, `&&`, `;` or a prompt.
+        if (lineStart || prev?.type === "operator" || prev?.type === "meta")
+            return "function";
+        return "plain";
+    }
+    if (language === "sql") {
+        const lower = word.toLowerCase();
+        if (SQL_KEYWORDS.has(lower))
+            return "keyword";
+        if (SQL_LITERALS.has(lower))
+            return "literal";
+        if (call)
+            return "function";
+        return "plain";
+    }
+    // clike
+    if (afterDot)
+        return call ? "function" : "property";
+    if (CLIKE_KEYWORDS.has(word))
+        return "keyword";
+    if (CLIKE_LITERALS.has(word))
+        return "literal";
+    if (CLIKE_TYPES.has(word) || /^[A-Z][a-z]/.test(word))
+        return "type";
+    if (call || /^!\s*\(/.test(rest))
+        return "function";
+    return "plain";
+}
+/** Tokenize `code` for `language` (id or alias). Unknown languages give one plain token. */
+export function highlight(code, language) {
+    const lang = resolveLanguage(language);
+    if (lang === "plaintext")
+        return code ? [{ type: "plain", value: code }] : [];
+    if (lang === "diff")
+        return highlightDiff(code);
+    const rules = GRAMMARS[lang];
+    const out = [];
+    const push = (type, value) => {
+        const last = out[out.length - 1];
+        if (last && last.type === type && (type === "plain" || type === "punctuation"))
+            last.value += value;
+        else
+            out.push({ type, value });
+    };
+    let prev;
+    let lineStart = true;
+    let i = 0;
+    while (i < code.length) {
+        SPACE.lastIndex = i;
+        const space = SPACE.exec(code);
+        if (space) {
+            push("plain", space[0]);
+            if (space[0].includes("\n"))
+                lineStart = true;
+            i += space[0].length;
+            continue;
+        }
+        let matched = false;
+        for (const [type, re] of rules) {
+            re.lastIndex = i;
+            const m = re.exec(code);
+            if (!m || !m[0])
+                continue;
+            const value = m[0];
+            const resolved = type === "ident" ? classify(lang, value, code.slice(i + value.length, i + value.length + 3), prev, lineStart) : type;
+            push(resolved, value);
+            prev = { type: resolved, value };
+            lineStart = false;
+            i += value.length;
+            matched = true;
+            break;
+        }
+        if (!matched) {
+            push("plain", code[i]);
+            prev = { type: "plain", value: code[i] };
+            lineStart = false;
+            i++;
+        }
+    }
+    return out;
+}
+function highlightDiff(code) {
+    const out = [];
+    const lines = code.split(/(?<=\n)/);
+    for (const line of lines) {
+        const type = /^(?:\+\+\+|---|@@|diff |index )/.test(line)
+            ? "meta"
+            : line.startsWith("+")
+                ? "inserted"
+                : line.startsWith("-")
+                    ? "deleted"
+                    : "plain";
+        out.push({ type, value: line });
+    }
+    return out;
+}

package/i18n/filter.d.ts

@@ -0,0 +1,16 @@
+export interface Filter {
+    /** Returns whether a string starts with a given substring. */
+    startsWith: (string: string, substring: string) => boolean;
+    /** Returns whether a string ends with a given substring. */
+    endsWith: (string: string, substring: string) => boolean;
+    /** Returns whether a string contains a given substring. */
+    contains: (string: string, substring: string) => boolean;
+}
+/** Cached `Intl.Collator` for `locale` + `options` (react-aria `useCollator`). */
+export declare function getCollator(locale: string, options?: Intl.CollatorOptions): Intl.Collator;
+/**
+ * Provides localized string search functionality that is useful for filtering or matching items in
+ * a list (react-aria `useFilter`). Options can be provided to adjust the sensitivity to case,
+ * diacritics, and other parameters.
+ */
+export declare function createFilter(options?: Intl.CollatorOptions, locale?: string): Filter;

package/i18n/filter.js

@@ -0,0 +1,66 @@
+// Ported from react-spectrum (react-aria src/i18n/useFilter.ts, src/i18n/useCollator.ts), Apache-2.0, © Adobe.
+//
+// Locale-aware string filtering (startsWith / endsWith / contains over an `Intl.Collator` with
+// `usage: "search"`), used by ComboBox, Autocomplete and searchable Select.
+// Rivet:
+// - `useFilter(options)` → `createFilter(options, locale)`; `useCollator(options)` → `getCollator(locale, options)`
+//   (same module cache keyed by locale + sorted options). The locale is an explicit string (resolved
+//   at render, `resolveLocale()`); omitted → the current locale (`useLocale()`, render time only).
+// - The returned functions are plain closures: not serializable. Resumable code keeps the locale
+//   string and calls `createFilter` inside handlers / bindings (the collator is cached).
+import { resolveLocale } from "./index.js";
+const cache = new Map();
+/** Cached `Intl.Collator` for `locale` + `options` (react-aria `useCollator`). */
+export function getCollator(locale, options) {
+    const cacheKey = locale +
+        (options
+            ? Object.entries(options)
+                .sort((a, b) => (a[0] < b[0] ? -1 : 1))
+                .join()
+            : "");
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const collator = new Intl.Collator(locale, options);
+    cache.set(cacheKey, collator);
+    return collator;
+}
+/**
+ * Provides localized string search functionality that is useful for filtering or matching items in
+ * a list (react-aria `useFilter`). Options can be provided to adjust the sensitivity to case,
+ * diacritics, and other parameters.
+ */
+export function createFilter(options, locale) {
+    const collator = getCollator(locale ?? resolveLocale(), { usage: "search", ...options });
+    // TODO(later): these methods don't currently support the ignorePunctuation option.
+    const startsWith = (string, substring) => {
+        if (substring.length === 0)
+            return true;
+        // Normalize both strings so we can slice safely
+        string = string.normalize("NFC");
+        substring = substring.normalize("NFC");
+        return collator.compare(string.slice(0, substring.length), substring) === 0;
+    };
+    const endsWith = (string, substring) => {
+        if (substring.length === 0)
+            return true;
+        string = string.normalize("NFC");
+        substring = substring.normalize("NFC");
+        return collator.compare(string.slice(-substring.length), substring) === 0;
+    };
+    const contains = (string, substring) => {
+        if (substring.length === 0)
+            return true;
+        string = string.normalize("NFC");
+        substring = substring.normalize("NFC");
+        let scan = 0;
+        const sliceLen = substring.length;
+        for (; scan + sliceLen <= string.length; scan++) {
+            const slice = string.slice(scan, scan + sliceLen);
+            if (collator.compare(substring, slice) === 0)
+                return true;
+        }
+        return false;
+    };
+    return { startsWith, endsWith, contains };
+}

package/i18n/i18n-provider.d.ts

@@ -0,0 +1,10 @@
+import type { Content } from "@rivetjs/runtime/jsx-runtime";
+export { LocaleContext, useLocale, type Locale } from "./index.js";
+export interface I18nProviderProps {
+    /** Locale for the subtree (e.g. the `[[lang]]` route param of @rivetjs/i18n). Default: environment. */
+    locale?: string;
+    /** Content (plain children or a function): rendered inside the provider. */
+    children?: Content | (() => Content);
+}
+/** Provides `locale` (and its direction) to `useLocale()` below it. */
+export declare function I18nProvider(props: I18nProviderProps): import("@rivetjs/runtime/jsx-runtime").CompiledElement;

package/i18n/i18n-provider.jsx

@@ -0,0 +1,15 @@
+// Ported from @react-aria/i18n I18nProvider (react-spectrum, Apache-2.0, © Adobe).
+// Rivet: plain JSX children are a lazy compiler slot rendered inside the provider (`renderSlot`);
+// a function child (`{() => <Page />}`) works too.
+import { Provider } from "@rivetjs/runtime/dom";
+import { LocaleContext, getDefaultLocale, isRTL } from "./index.js";
+import { renderSlot } from "@rivetjs/runtime/slot";
+export { LocaleContext, useLocale } from "./index.js";
+/** Provides `locale` (and its direction) to `useLocale()` below it. */
+export function I18nProvider(props) {
+    const value = props.locale ? { locale: props.locale, direction: isRTL(props.locale) ? "rtl" : "ltr" } : getDefaultLocale();
+    const children = props.children;
+    return (<Provider token={LocaleContext} value={value}>
+      {renderSlot(children)}
+    </Provider>);
+}

package/i18n/index.d.ts

@@ -0,0 +1,27 @@
+import { DateFormatter } from "../date/DateFormatter.js";
+export type { Direction } from "../collections/types.js";
+import type { Direction } from "../collections/types.js";
+export interface Locale {
+    /** BCP 47 language tag, e.g. `en-US`. */
+    locale: string;
+    /** Writing direction of the locale. */
+    direction: Direction;
+}
+/** Whether `localeString` is written right to left. */
+export declare function isRTL(localeString: string): boolean;
+/** Locale of the environment: browser `<html lang>`, then `navigator.language`; server `en-US`. */
+export declare function getDefaultLocale(): Locale;
+/** Context carrying the current `Locale` (null: environment default). */
+export declare const LocaleContext: import("@rivetjs/reactivity").Context<Locale | null>;
+/** Current locale: the nearest `I18nProvider`, else the environment default. */
+export declare function useLocale(): Locale;
+/** `locale` (when given) or the current one. */
+export declare function resolveLocale(locale?: string | null): string;
+/** Cached `DateFormatter` for `locale` + `options` (react-aria `useDateFormatter`). */
+export declare function getDateFormatter(locale: string, options?: Intl.DateTimeFormatOptions): DateFormatter;
+/** Localized string tables: locale → key → `{name}` template. */
+export type LocalizedStrings<K extends string = string> = Record<string, Record<K, string>>;
+/** Strings of `locale` from `strings`: exact match, language-script, language, any region of the language, else `defaultLocale`. */
+export declare function getStringsForLocale<K extends string>(strings: LocalizedStrings<K>, locale: string, defaultLocale?: string): Record<K, string>;
+/** Interpolate `{name}` placeholders. */
+export declare function formatString(template: string, variables?: Record<string, string | number | boolean>): string;

package/i18n/index.js

@@ -0,0 +1,115 @@
+// Ported from react-spectrum (Apache-2.0, © Adobe): @react-aria/i18n (I18nProvider, useLocale,
+// isRTL, useDateFormatter cache) and @internationalized/string (LocalizedStringDictionary locale
+// matching, `{name}` interpolation). Minimal subset needed by the date widgets.
+//
+// Rivet differences:
+// - Default locale: `<html lang>` in the browser (what @rivetjs/i18n writes for the page's locale),
+//   then `navigator.language`; "en-US" on the server. React Aria defaults to `navigator.language`.
+// - Components never run in the browser on resumed pages: the locale is resolved while rendering
+//   on the server and stored (as a string) in widget state. `I18nProvider` therefore matters for
+//   server rendering and client-rendered subtrees.
+// - `I18nProvider` lives in `@rivetjs/cdk/i18n-provider` (JSX); this module is plain TypeScript.
+// - Localized strings are plain `{name}` templates (react-aria compiles its JSON to functions).
+import { createContext, useContext } from "@rivetjs/reactivity";
+import { resumableContext } from "@rivetjs/runtime/resume-format";
+import { DateFormatter } from "../date/DateFormatter.js";
+// https://en.wikipedia.org/wiki/Right-to-left
+const RTL_SCRIPTS = new Set(["Arab", "Syrc", "Samr", "Mand", "Thaa", "Mend", "Nkoo", "Adlm", "Rohg", "Hebr"]);
+const RTL_LANGS = new Set(["ae", "ar", "arc", "bcc", "bqi", "ckb", "dv", "fa", "glk", "he", "ku", "mzn", "nqo", "pnb", "ps", "sd", "ug", "ur", "yi"]);
+// Pure per locale string (Intl data): memoised, bounded. Widgets ask per instance and per segment
+// (`new Intl.Locale(…).maximize()` ≈ 1–3 µs each: 7% of a Select mount, HOTPATH 2026-10-09).
+const rtlCache = new Map();
+/** Whether `localeString` is written right to left. */
+export function isRTL(localeString) {
+    let rtl = rtlCache.get(localeString);
+    if (rtl === undefined) {
+        if (rtlCache.size >= 256)
+            rtlCache.clear();
+        rtlCache.set(localeString, (rtl = computeRTL(localeString)));
+    }
+    return rtl;
+}
+function computeRTL(localeString) {
+    if (Intl.Locale) {
+        const locale = new Intl.Locale(localeString).maximize();
+        const textInfo = typeof locale.getTextInfo === "function" ? locale.getTextInfo() : locale.textInfo;
+        if (textInfo)
+            return textInfo.direction === "rtl";
+        if (locale.script)
+            return RTL_SCRIPTS.has(locale.script);
+    }
+    return RTL_LANGS.has(localeString.split("-")[0]);
+}
+/** Locale of the environment: browser `<html lang>`, then `navigator.language`; server `en-US`. */
+export function getDefaultLocale() {
+    const requested = (typeof document !== "undefined" && document.documentElement?.lang) || (typeof navigator !== "undefined" && navigator.language) || "en-US";
+    // The environment is read on every call (`<html lang>` / `navigator.language` may change); the validation and
+    // direction of one requested string are pure, so the last one is reused (a fresh object per call, as before).
+    if (requested !== lastRequested) {
+        let locale = requested;
+        try {
+            Intl.DateTimeFormat.supportedLocalesOf([locale]);
+        }
+        catch {
+            locale = "en-US";
+        }
+        lastRequested = requested;
+        lastLocale = locale;
+        lastDirection = isRTL(locale) ? "rtl" : "ltr";
+    }
+    return { locale: lastLocale, direction: lastDirection };
+}
+let lastRequested, lastLocale = "en-US", lastDirection = "ltr";
+/** Context carrying the current `Locale` (null: environment default). */
+export const LocaleContext = resumableContext(createContext(null, { id: "rv-locale" }));
+/** Current locale: the nearest `I18nProvider`, else the environment default. */
+export function useLocale() {
+    return useContext(LocaleContext) ?? getDefaultLocale();
+}
+/** `locale` (when given) or the current one. */
+export function resolveLocale(locale) {
+    return locale || useLocale().locale;
+}
+const formatters = new Map();
+/** Cached `DateFormatter` for `locale` + `options` (react-aria `useDateFormatter`). */
+export function getDateFormatter(locale, options = {}) {
+    const key = locale + JSON.stringify(options);
+    let formatter = formatters.get(key);
+    if (!formatter) {
+        if (formatters.size > 256)
+            formatters.clear();
+        formatters.set(key, (formatter = new DateFormatter(locale, options)));
+    }
+    return formatter;
+}
+/** Strings of `locale` from `strings`: exact match, language-script, language, any region of the language, else `defaultLocale`. */
+export function getStringsForLocale(strings, locale, defaultLocale = "en-US") {
+    if (strings[locale])
+        return strings[locale];
+    const [language, script] = localeParts(locale);
+    if (script && strings[language + "-" + script])
+        return strings[language + "-" + script];
+    if (strings[language])
+        return strings[language];
+    for (const key in strings)
+        if (key.startsWith(language + "-"))
+            return strings[key];
+    return strings[defaultLocale];
+}
+// `[language, script]` of a locale string (pure; memoised like `isRTL`).
+const partsCache = new Map();
+function localeParts(locale) {
+    let parts = partsCache.get(locale);
+    if (!parts) {
+        const parsed = Intl.Locale ? new Intl.Locale(locale) : null;
+        parts = [parsed ? parsed.language : locale.split("-")[0], parsed?.script];
+        if (partsCache.size >= 256)
+            partsCache.clear();
+        partsCache.set(locale, parts);
+    }
+    return parts;
+}
+/** Interpolate `{name}` placeholders. */
+export function formatString(template, variables) {
+    return variables ? template.replace(/\{(\w+)\}/g, (match, name) => (name in variables ? String(variables[name]) : match)) : template;
+}

package/i18n/intl-cache.d.ts

@@ -0,0 +1,4 @@
+type Ctor<O, T> = new (locales: string | undefined, options: O) => T;
+/** Cached `new ctor(locale, options)`, e.g. `cachedIntl(Intl.NumberFormat, "en-US", { style: "currency", currency: "USD" })`. */
+export declare function cachedIntl<O extends object, T>(ctor: Ctor<O, T>, locale: string | undefined, options?: NoInfer<O>): T;
+export {};

package/i18n/intl-cache.js

@@ -0,0 +1,40 @@
+// Shared cache of `Intl` formatter instances (Rivet; upstream React Aria memoizes per hook call).
+//
+// Constructing an `Intl.NumberFormat` / `PluralRules` / `DisplayNames` / `ListFormat` /
+// `DateTimeFormat` costs 7–60 µs; `format` on a cached instance ≈ 0.2 µs. Render paths, bindings and
+// handlers call `cachedIntl(Intl.NumberFormat, locale, options)` instead of `new Intl.X(…)`.
+// Key = constructor + locale + options (sorted `key=value` pairs, so two option objects with the same
+// entries share one instance). One map per constructor, cleared past 256 entries.
+// Plain module function: resumable bindings / handlers may call it (only plain data is captured).
+const caches = new Map();
+/** Stable key of a flat options object (`Intl.*Options` values are primitives or string arrays). */
+function optionsKey(options) {
+    if (!options)
+        return "";
+    const keys = Object.keys(options);
+    if (keys.length === 0)
+        return "";
+    if (keys.length > 1)
+        keys.sort();
+    let key = "";
+    for (const k of keys) {
+        const value = options[k];
+        if (value !== undefined)
+            key += k + "=" + String(value) + ";";
+    }
+    return key;
+}
+/** Cached `new ctor(locale, options)`, e.g. `cachedIntl(Intl.NumberFormat, "en-US", { style: "currency", currency: "USD" })`. */
+export function cachedIntl(ctor, locale, options) {
+    let cache = caches.get(ctor);
+    if (!cache)
+        caches.set(ctor, (cache = new Map()));
+    const key = (locale ?? "") + "|" + optionsKey(options);
+    let instance = cache.get(key);
+    if (instance === undefined) {
+        if (cache.size >= 256)
+            cache.clear();
+        cache.set(key, (instance = new ctor(locale, options)));
+    }
+    return instance;
+}

package/i18n/list-formatter.d.ts

@@ -0,0 +1,2 @@
+/** Cached `Intl.ListFormat` for `locale` + `options` (react-aria `useListFormatter`). */
+export declare function listFormatter(locale: string, options?: Intl.ListFormatOptions): Intl.ListFormat;