@nibapp/ui 0.0.0-stage → 0.1.0

package/dist/lib/shiki.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Lazily created, shared Shiki highlighter. `@nibapp/ui/shiki`, a preview API like CodeBlock: it may
+ * change in a minor version before 1.0.
+ *
+ * - Fine-grained bundle (`shiki/core`) + the JavaScript RegExp engine: no WASM, so it runs the same in
+ *   Tauri's webview, browsers and SSR.
+ * - Grammars are dynamic imports, loaded on demand; common ones are warmed in the background once the
+ *   highlighter exists.
+ * - Tokens carry `--shiki-light` / `--shiki-dark` CSS variables (`defaultColor: false`); `code.css`
+ *   resolves them with `light-dark()`, so highlighted code follows `data-theme` / `color-scheme`
+ *   without re-tokenizing on theme change.
+ */
+import { type HighlighterCore } from "shiki/core";
+import { type BundledLanguage } from "shiki/langs";
+export type ResolvedLanguage = BundledLanguage | "text";
+/** Normalizes a fence/info-string language to a Shiki language id, or `"text"` when unknown. */
+export declare function resolveLanguage(lang: string | null | undefined): ResolvedLanguage;
+/** Human label for a language id (`tsx` → `TSX`, `python` → `Python`). */
+export declare function languageLabel(lang: string | null | undefined): string;
+/** The highlighter if it already exists — lets components tokenize synchronously on remount. */
+export declare function getLoadedHighlighter(): HighlighterCore | null;
+/** True when `lang` can be tokenized synchronously right now. */
+export declare function isLanguageReady(lang: ResolvedLanguage): boolean;
+/** Resolves once the highlighter and `lang`'s grammar are loaded. */
+export declare function loadLanguage(lang: ResolvedLanguage): Promise<HighlighterCore>;
+/** One highlighted token. `style` holds `--shiki-light*` / `--shiki-dark*` custom properties. */
+interface CodeToken {
+    content: string;
+    style?: Record<string, string>;
+}
+export type CodeLine = readonly CodeToken[];
+/**
+ * Plain (uncolored) lines — the loading / not-yet-tokenized fallback. Same line split and one text
+ * run per line, so it lays out exactly like highlighted output (only the token spans differ).
+ */
+export declare function plainLines(code: string): CodeLine[];
+/** Synchronous tokenization; requires `isLanguageReady(lang)`. Uncached — prefer {@link tokenizeCached}. */
+export declare function tokenize(h: HighlighterCore, code: string, lang: ResolvedLanguage): CodeLine[];
+/**
+ * cyrb53: a fast, well-distributed 53-bit string hash (two 32-bit FNV-style lanes). Not
+ * cryptographic; cache hits also compare the source text, so a collision can never serve wrong
+ * tokens.
+ */
+export declare function hashString(text: string, seed?: number): number;
+export interface TokenCacheLimits {
+    /** Most entries kept. */
+    maxEntries: number;
+    /** Approximate heap budget in bytes (UTF-16 text + per-token overhead). */
+    maxBytes: number;
+}
+/**
+ * Least-recently-used token store keyed by (language, theme pair, source hash). A `Map` keeps
+ * insertion order, so re-inserting on read makes its first key the least recently used. Bounded by
+ * entry count and approximate size; a single entry larger than a quarter of the budget isn't kept.
+ */
+export declare class TokenCache {
+    private readonly limits;
+    private readonly entries;
+    private bytes;
+    constructor(limits: TokenCacheLimits);
+    get size(): number;
+    get approximateBytes(): number;
+    get(key: string, code: string): readonly CodeLine[] | undefined;
+    set(key: string, code: string, lines: readonly CodeLine[]): void;
+    clear(): void;
+    private delete;
+}
+/**
+ * Process-wide token cache, so a code block that remounts (a virtualized list's row scrolling
+ * back into view) renders highlighted on its first pass with no Shiki work. It holds only tokens
+ * derived from source text: locale- and request-independent, so sharing it across SSR requests is
+ * safe. 512 entries / ~16 MB.
+ */
+export declare const tokenCache: TokenCache;
+/** Cached tokens for `code`, if any (no tokenization). `"text"` is always available. */
+export declare function cachedTokens(code: string, lang: ResolvedLanguage): readonly CodeLine[] | undefined;
+/** Stores tokens produced elsewhere (e.g. a finished {@link StreamingTokenizer}). */
+export declare function storeTokens(code: string, lang: ResolvedLanguage, lines: readonly CodeLine[]): void;
+/** {@link tokenize} through the cache; requires `isLanguageReady(lang)`. */
+export declare function tokenizeCached(h: HighlighterCore, code: string, lang: ResolvedLanguage): readonly CodeLine[];
+/**
+ * Incremental tokenizer for code that only grows at the end (streaming). Completed lines are
+ * tokenized once and cached together with the grammar state; each update re-tokenizes just the
+ * newly completed lines plus the trailing partial line.
+ */
+export declare class StreamingTokenizer {
+    private readonly h;
+    readonly lang: ResolvedLanguage;
+    private stableText;
+    private stableLines;
+    private state;
+    constructor(h: HighlighterCore, lang: ResolvedLanguage);
+    /** True when `update(code)` only tokenizes what was appended since the previous update. */
+    isWarmFor(code: string): boolean;
+    update(code: string): CodeLine[];
+    private options;
+    private reset;
+}
+/** `src/app.tsx` → `tsx`, `Dockerfile` → `docker`, `README.md` → `markdown`; unknown → `"text"`. */
+export declare function languageForPath(path: string): ResolvedLanguage;
+export {};

package/dist/lib/shiki.js

@@ -0,0 +1,353 @@
+/**
+ * Lazily created, shared Shiki highlighter. `@nibapp/ui/shiki`, a preview API like CodeBlock: it may
+ * change in a minor version before 1.0.
+ *
+ * - Fine-grained bundle (`shiki/core`) + the JavaScript RegExp engine: no WASM, so it runs the same in
+ *   Tauri's webview, browsers and SSR.
+ * - Grammars are dynamic imports, loaded on demand; common ones are warmed in the background once the
+ *   highlighter exists.
+ * - Tokens carry `--shiki-light` / `--shiki-dark` CSS variables (`defaultColor: false`); `code.css`
+ *   resolves them with `light-dark()`, so highlighted code follows `data-theme` / `color-scheme`
+ *   without re-tokenizing on theme change.
+ */
+import { createHighlighterCore } from "shiki/core";
+import { createJavaScriptRegexEngine } from "shiki/engine/javascript";
+import { bundledLanguages } from "shiki/langs";
+import { NIB_SHIKI_THEMES, nibDarkTheme, nibLightTheme } from "./shiki-themes.js";
+import { extensionOf } from "./text.js";
+/** Grammars warmed right after the highlighter is created. */
+const PRELOADED_LANGUAGES = [
+    "ts",
+    "tsx",
+    "js",
+    "json",
+    "bash",
+    "python",
+    "rust",
+    "go",
+    "css",
+    "html",
+    "md",
+    "yaml",
+    "diff",
+    "sql",
+];
+/** Extra spellings agents and humans use in fences that Shiki doesn't alias itself. */
+const EXTRA_ALIASES = {
+    typescriptreact: "tsx",
+    javascriptreact: "jsx",
+    golang: "go",
+    "objective-c++": "objective-cpp",
+    dockerfile: "docker",
+    ps: "powershell",
+    patch: "diff",
+    env: "dotenv",
+    rb: "ruby",
+};
+const PLAIN = new Set(["", "text", "txt", "plain", "plaintext", "none", "output", "log"]);
+const isBundled = (lang) => Object.hasOwn(bundledLanguages, lang);
+/** Normalizes a fence/info-string language to a Shiki language id, or `"text"` when unknown. */
+export function resolveLanguage(lang) {
+    const key = (lang ?? "").trim().toLowerCase().split(/[\s{]/, 1)[0] ?? "";
+    if (PLAIN.has(key))
+        return "text";
+    if (isBundled(key))
+        return key;
+    const alias = EXTRA_ALIASES[key];
+    return alias ?? "text";
+}
+/** Human label for a language id (`tsx` → `TSX`, `python` → `Python`). */
+export function languageLabel(lang) {
+    const raw = (lang ?? "").trim().split(/[\s{]/, 1)[0] ?? "";
+    if (raw === "" || PLAIN.has(raw.toLowerCase()))
+        return "text";
+    return raw.toLowerCase();
+}
+let instance = null;
+let creating = null;
+const languageLoads = new Map();
+function warmCommonLanguages(h) {
+    const run = () => {
+        for (const lang of PRELOADED_LANGUAGES)
+            void ensureLoaded(h, lang).catch(() => undefined);
+    };
+    if (typeof requestIdleCallback === "function")
+        requestIdleCallback(run, { timeout: 2000 });
+    else
+        setTimeout(run, 200);
+}
+/** The shared highlighter (created on first call). */
+function getHighlighter() {
+    if (instance)
+        return Promise.resolve(instance);
+    creating ??= createHighlighterCore({
+        themes: [nibLightTheme, nibDarkTheme],
+        langs: [],
+        engine: createJavaScriptRegexEngine({ forgiving: true }),
+    }).then((h) => {
+        instance = h;
+        warmCommonLanguages(h);
+        return h;
+    }, (error) => {
+        creating = null;
+        throw error;
+    });
+    return creating;
+}
+/** The highlighter if it already exists — lets components tokenize synchronously on remount. */
+export function getLoadedHighlighter() {
+    return instance;
+}
+function ensureLoaded(h, lang) {
+    if (lang === "text" || h.getLoadedLanguages().includes(lang))
+        return Promise.resolve();
+    let load = languageLoads.get(lang);
+    if (!load) {
+        load = h.loadLanguage(bundledLanguages[lang]).catch((error) => {
+            languageLoads.delete(lang);
+            throw error;
+        });
+        languageLoads.set(lang, load);
+    }
+    return load;
+}
+/** True when `lang` can be tokenized synchronously right now. */
+export function isLanguageReady(lang) {
+    if (!instance)
+        return false;
+    if (lang === "text")
+        return true;
+    return instance.getLoadedLanguages().includes(lang);
+}
+/** Resolves once the highlighter and `lang`'s grammar are loaded. */
+export async function loadLanguage(lang) {
+    const h = await getHighlighter();
+    await ensureLoaded(h, lang);
+    return h;
+}
+const toLine = (tokens) => tokens.map((t) => (t.htmlStyle ? { content: t.content, style: t.htmlStyle } : { content: t.content }));
+const TOKEN_OPTIONS = {
+    themes: NIB_SHIKI_THEMES,
+    defaultColor: false,
+    tokenizeMaxLineLength: 4000,
+    // The JS engine compiles a grammar's regexes lazily; the first line of a big grammar (TS) can take
+    // ~1s cold. Shiki's 500ms default would then give up mid-line and leave it half-colored.
+    tokenizeTimeLimit: 2500,
+};
+/** Shiki's own line split (`\r\n` or `\n`), so plain and highlighted output have the same lines. */
+const LINE_BREAK = /\r?\n/;
+const LINE_BREAK_END = /\r?\n$/;
+/**
+ * Plain (uncolored) lines — the loading / not-yet-tokenized fallback. Same line split and one text
+ * run per line, so it lays out exactly like highlighted output (only the token spans differ).
+ */
+export function plainLines(code) {
+    return code.split(LINE_BREAK).map((line) => (line === "" ? [] : [{ content: line }]));
+}
+/** Synchronous tokenization; requires `isLanguageReady(lang)`. Uncached — prefer {@link tokenizeCached}. */
+export function tokenize(h, code, lang) {
+    if (lang === "text")
+        return plainLines(code);
+    return h.codeToTokens(code, { lang, ...TOKEN_OPTIONS }).tokens.map(toLine);
+}
+/* ------------------------------------------------------------------------------------------ */
+/* Token cache                                                                                */
+/* ------------------------------------------------------------------------------------------ */
+/**
+ * cyrb53: a fast, well-distributed 53-bit string hash (two 32-bit FNV-style lanes). Not
+ * cryptographic; cache hits also compare the source text, so a collision can never serve wrong
+ * tokens.
+ */
+export function hashString(text, seed = 0) {
+    let h1 = 0xdeadbeef ^ seed;
+    let h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+}
+/** Rough heap cost of one token beyond its text (object, style record, two CSS-variable strings). */
+const TOKEN_OVERHEAD_BYTES = 96;
+/**
+ * Least-recently-used token store keyed by (language, theme pair, source hash). A `Map` keeps
+ * insertion order, so re-inserting on read makes its first key the least recently used. Bounded by
+ * entry count and approximate size; a single entry larger than a quarter of the budget isn't kept.
+ */
+export class TokenCache {
+    limits;
+    entries = new Map();
+    bytes = 0;
+    constructor(limits) {
+        this.limits = limits;
+    }
+    get size() {
+        return this.entries.size;
+    }
+    get approximateBytes() {
+        return this.bytes;
+    }
+    get(key, code) {
+        const entry = this.entries.get(key);
+        if (entry === undefined || entry.code !== code)
+            return undefined;
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        return entry.lines;
+    }
+    set(key, code, lines) {
+        let tokens = 0;
+        for (const line of lines)
+            tokens += line.length;
+        const bytes = code.length * 2 + tokens * TOKEN_OVERHEAD_BYTES;
+        this.delete(key);
+        if (bytes > this.limits.maxBytes / 4)
+            return;
+        this.entries.set(key, { code, lines, bytes });
+        this.bytes += bytes;
+        for (const [oldest, entry] of this.entries) {
+            if (this.entries.size <= this.limits.maxEntries && this.bytes <= this.limits.maxBytes)
+                break;
+            this.entries.delete(oldest);
+            this.bytes -= entry.bytes;
+        }
+    }
+    clear() {
+        this.entries.clear();
+        this.bytes = 0;
+    }
+    delete(key) {
+        const entry = this.entries.get(key);
+        if (entry === undefined)
+            return;
+        this.entries.delete(key);
+        this.bytes -= entry.bytes;
+    }
+}
+const THEME_KEY = `${NIB_SHIKI_THEMES.light}/${NIB_SHIKI_THEMES.dark}`;
+/**
+ * Process-wide token cache, so a code block that remounts (a virtualized list's row scrolling
+ * back into view) renders highlighted on its first pass with no Shiki work. It holds only tokens
+ * derived from source text: locale- and request-independent, so sharing it across SSR requests is
+ * safe. 512 entries / ~16 MB.
+ */
+export const tokenCache = new TokenCache({ maxEntries: 512, maxBytes: 16 * 1024 * 1024 });
+const cacheKey = (code, lang) => `${lang}\u0000${THEME_KEY}\u0000${hashString(code)}`;
+/** Cached tokens for `code`, if any (no tokenization). `"text"` is always available. */
+export function cachedTokens(code, lang) {
+    if (lang === "text")
+        return plainLines(code);
+    return tokenCache.get(cacheKey(code, lang), code);
+}
+/** Stores tokens produced elsewhere (e.g. a finished {@link StreamingTokenizer}). */
+export function storeTokens(code, lang, lines) {
+    if (lang !== "text")
+        tokenCache.set(cacheKey(code, lang), code, lines);
+}
+/** {@link tokenize} through the cache; requires `isLanguageReady(lang)`. */
+export function tokenizeCached(h, code, lang) {
+    const hit = cachedTokens(code, lang);
+    if (hit !== undefined)
+        return hit;
+    const lines = tokenize(h, code, lang);
+    storeTokens(code, lang, lines);
+    return lines;
+}
+/**
+ * Incremental tokenizer for code that only grows at the end (streaming). Completed lines are
+ * tokenized once and cached together with the grammar state; each update re-tokenizes just the
+ * newly completed lines plus the trailing partial line.
+ */
+export class StreamingTokenizer {
+    h;
+    lang;
+    stableText = "";
+    stableLines = [];
+    state;
+    constructor(h, lang) {
+        this.h = h;
+        this.lang = lang;
+    }
+    /** True when `update(code)` only tokenizes what was appended since the previous update. */
+    isWarmFor(code) {
+        return this.stableText !== "" && code.startsWith(this.stableText);
+    }
+    update(code) {
+        if (this.lang === "text")
+            return plainLines(code);
+        const cut = code.lastIndexOf("\n") + 1;
+        const stable = code.slice(0, cut);
+        if (!stable.startsWith(this.stableText))
+            this.reset();
+        const delta = stable.slice(this.stableText.length);
+        if (delta !== "") {
+            const result = this.h.codeToTokens(delta.replace(LINE_BREAK_END, ""), this.options());
+            this.stableLines = [...this.stableLines, ...result.tokens.map(toLine)];
+            this.state = result.grammarState;
+            this.stableText = stable;
+        }
+        const tail = code.slice(cut);
+        const tailLine = tail === "" ? [] : (this.h.codeToTokens(tail, this.options()).tokens[0] ?? []);
+        return [...this.stableLines, toLine(tailLine)];
+    }
+    options() {
+        const base = { lang: this.lang, ...TOKEN_OPTIONS };
+        return this.state ? { ...base, grammarState: this.state } : base;
+    }
+    reset() {
+        this.stableText = "";
+        this.stableLines = [];
+        this.state = undefined;
+    }
+}
+/** File-extension and well-known file-name aliases Shiki doesn't resolve by itself. */
+const EXTENSION_ALIASES = {
+    mjs: "javascript",
+    cjs: "javascript",
+    mts: "typescript",
+    cts: "typescript",
+    py: "python",
+    pyi: "python",
+    rs: "rust",
+    rb: "ruby",
+    kt: "kotlin",
+    kts: "kotlin",
+    cs: "csharp",
+    hpp: "cpp",
+    cc: "cpp",
+    hh: "cpp",
+    h: "c",
+    md: "markdown",
+    mdx: "mdx",
+    yml: "yaml",
+    zsh: "bash",
+    sh: "bash",
+    ps1: "powershell",
+    tf: "hcl",
+    gql: "graphql",
+    lock: "text",
+    txt: "text",
+};
+const FILENAME_LANGUAGES = {
+    dockerfile: "docker",
+    makefile: "make",
+    gemfile: "ruby",
+    rakefile: "ruby",
+    ".env": "dotenv",
+    ".gitignore": "text",
+    ".bashrc": "bash",
+    ".zshrc": "bash",
+    "bun.lock": "json",
+};
+/** `src/app.tsx` → `tsx`, `Dockerfile` → `docker`, `README.md` → `markdown`; unknown → `"text"`. */
+export function languageForPath(path) {
+    const name = (path.split(/[/\\]/).pop() ?? path).toLowerCase();
+    const byName = FILENAME_LANGUAGES[name];
+    if (byName !== undefined)
+        return resolveLanguage(byName);
+    const ext = extensionOf(name);
+    return ext === undefined ? "text" : resolveLanguage(EXTENSION_ALIASES[ext] ?? ext);
+}

package/dist/lib/shortcut-context.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from "react";
+/** An action's keys (logical, as in `<Shortcut>`), or undefined when it has no binding. */
+export type ShortcutResolver = (action: string) => readonly string[] | undefined;
+/**
+ * The actions the kit's own components take from the keyboard, and their keys when the host binds
+ * them to nothing else: a diff's comment is sent with ⌘↵ (Ctrl+Enter elsewhere).
+ */
+export declare const KIT_SHORTCUTS: {
+    readonly sendComments: readonly ["mod", "enter"];
+};
+/**
+ * The host's keymap for every tooltip and menu item below it: `<Tooltip action="…">` shows the keys
+ * the action is actually bound to, so a hint can't drift from the binding. Without a provider only the
+ * kit's own actions answer (`KIT_SHORTCUTS`).
+ */
+export declare function ShortcutProvider({ resolve, children, }: {
+    readonly resolve: ShortcutResolver;
+    readonly children: ReactNode;
+}): import("react").JSX.Element;
+/** The keys bound to `action`, or undefined (no action, or no binding). */
+export declare function useShortcut(action: string | undefined): readonly string[] | undefined;
+/** The resolver itself, for lists that map many actions at once (a command palette). */
+export declare function useShortcutResolver(): ShortcutResolver;

package/dist/lib/shortcut-context.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, use } from "react";
+/**
+ * The actions the kit's own components take from the keyboard, and their keys when the host binds
+ * them to nothing else: a diff's comment is sent with ⌘↵ (Ctrl+Enter elsewhere).
+ */
+export const KIT_SHORTCUTS = {
+    sendComments: ["mod", "enter"],
+};
+const KIT_KEYS = new Map(Object.entries(KIT_SHORTCUTS));
+const ShortcutContext = createContext((action) => KIT_KEYS.get(action));
+/**
+ * The host's keymap for every tooltip and menu item below it: `<Tooltip action="…">` shows the keys
+ * the action is actually bound to, so a hint can't drift from the binding. Without a provider only the
+ * kit's own actions answer (`KIT_SHORTCUTS`).
+ */
+export function ShortcutProvider({ resolve, children, }) {
+    return _jsx(ShortcutContext, { value: resolve, children: children });
+}
+/** The keys bound to `action`, or undefined (no action, or no binding). */
+export function useShortcut(action) {
+    const resolve = use(ShortcutContext);
+    return action === undefined ? undefined : resolve(action);
+}
+/** The resolver itself, for lists that map many actions at once (a command palette). */
+export function useShortcutResolver() {
+    return use(ShortcutContext);
+}

package/dist/lib/text.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Text measured and shaped the way people read it: in graphemes (`Intl.Segmenter`), so a cut never
+ * splits an emoji, a flag or a letter with its accents, in any script; cased, sorted and listed in the
+ * reader's locale. Each `Intl` object is built once per locale and options and kept, keyed by them, so
+ * one process can serve several locales.
+ */
+/**
+ * How many words the text has, as its language divides them (`Intl.Segmenter`, granularity
+ * `word`): Chinese or Japanese, written without spaces, count word by word too.
+ */
+export declare function wordCount(text: string, locale?: string): number;
+/** The text's graphemes, the characters a reader sees ("é" and "👍🏽" are one each). */
+export declare function graphemesOf(text: string, locale?: string): string[];
+/**
+ * The text cut to at most `max` graphemes, an ellipsis standing in for the rest. It reads at most
+ * `max + 1` graphemes, however long the text.
+ */
+export declare function truncateText(text: string, max: number, locale?: string): string;
+/** The text's first `count` graphemes ("Éla" of "Élan" for 3); it reads no further than that. */
+export declare function graphemePrefix(text: string, count: number, locale?: string): string;
+/**
+ * The longest start of the text within `max` UTF-16 units that ends between graphemes: typed text
+ * kept to a cap a schema counts in `.length`, never splitting an emoji or a letter from its accents.
+ * No ellipsis: it is what the person typed, shortened.
+ */
+export declare function clipToLength(text: string, max: number, locale?: string): string;
+/** A collator for `locale`: lists people read sort in their own language's order. */
+export declare function collatorFor(locale: string, options?: Intl.CollatorOptions): Intl.Collator;
+/** Items as one phrase in a locale's list pattern ("a, b and c", "a, b or c"), as the catalogues join them. */
+export declare function formatList(items: readonly string[], locale: string, type?: Intl.ListFormatType): string;
+/**
+ * The parts of one status as a screen reader says them ("Running, rate limited, 1 minute"): the
+ * language's own list separator and no "and" ("a、b、c" in Japanese). It's the narrow conjunction
+ * pattern, which every ICU build separates; the `unit` pattern lost its Russian commas in newer CLDR.
+ */
+export declare function spokenParts(items: readonly string[], locale: string): string;
+/** Upper-cases the first grapheme for `locale` ("élan" → "Élan"); the rest stays as it is. */
+export declare function capitalize(text: string, locale: string): string;
+/**
+ * An identifier's words, lower-cased for `locale`: camelCase, kebab-case, snake_case and dotted ids
+ * split ("repoName", "repo-name", "repo_name" → "repo name"; "parseHTMLFile" → "parse html file").
+ */
+export declare function idWords(id: string, locale: string): string;
+/**
+ * An identifier as words in sentence case, for a label it doesn't have: "spendByDay" → "Spend by
+ * day", "team_invite" → "Team invite". The id itself when it has no words.
+ */
+export declare function humanizeId(id: string, locale: string): string;
+/**
+ * Up to `max` initials of a name, upper-cased for `locale`: the first grapheme of its first word and
+ * of its last ones ("Ava Chen" and "Ava Maria Chen" → "AC", "kai-rivera" → "KR", "Milo" → "M",
+ * "émile zola" → "ÉZ"). Spaces and punctuation separate words. Empty when the name has none.
+ */
+export declare function initialsOf(name: string, locale: string, max?: number): string;
+/** A file name's extension, lower case ("tsx"), or undefined for none (`Makefile`, `.env`, `notes.`). */
+export declare function extensionOf(name: string): string | undefined;