@textui/core 0.1.0

package/dist/core/focus.d.ts

@@ -0,0 +1,69 @@
+import type { FocusableOptions, FocusDirection, FocusManager, FocusScopeOptions } from '../types/focus.js';
+import type { KeyEvent } from '../types/input.js';
+import type { Rect } from '../types/geometry.js';
+import type { Disposable } from '../types/disposable.js';
+/** The scope every global handler lives in, always active and always last. */
+export declare const GLOBAL_SCOPE = "__global__";
+/**
+ * Focus.
+ *
+ * Tab order is registration order within a scope unless a node states one.
+ * Directional navigation is geometric, because in a terminal "the thing to the
+ * right" is a real question a table, a menu and a dashboard all ask, and none
+ * of them can answer it from document order.
+ */
+export declare class Focus implements FocusManager {
+    private onChange;
+    private scopes;
+    private nodes;
+    /** Registration order, which is tab order when nothing states otherwise. */
+    private order_;
+    private stack;
+    private current;
+    constructor(onChange?: () => void);
+    registerScope(options: FocusScopeOptions): Disposable;
+    activateScope(id: string): void;
+    deactivateScope(id: string): void;
+    activeScope(): string | null;
+    /** The innermost active scope that traps, if any. */
+    private trappingScope;
+    /** Which scope a focusable belongs to. `GLOBAL_SCOPE` when it names none. */
+    scopeOf(nodeId: string): string;
+    register(options: FocusableOptions): Disposable;
+    update(id: string, patch: Partial<FocusableOptions>): void;
+    has(id: string): boolean;
+    focus(id: string): boolean;
+    blur(): void;
+    focused(): string | null;
+    chain(): string[];
+    /** Tab order: explicit `order` first, then registration order. */
+    order(scopeId?: string): string[];
+    move(direction: FocusDirection): string | null;
+    /**
+     * Geometric navigation. Candidates must lie in the requested direction; the
+     * winner is the nearest, with distance along the axis weighted more heavily
+     * than drift across it, so `right` from a table cell finds the next column
+     * rather than a distant button that happens to be closer in a straight line.
+     */
+    private moveDirectional;
+    at(x: number, y: number): string | null;
+    /**
+     * Focused node first, then outward through active scopes, then global -
+     * except that a trap stops the walk at itself.
+     *
+     * `order` and `move` already honoured the trap, so tab could not leave a
+     * modal; keys could, and did. A menu bar whose labels live in the global
+     * scope kept receiving every arrow while its own dropdown was open, so down
+     * re-opened the menu instead of moving inside it, and a palette opened over
+     * the top inherited the same problem - two layers reading one keystroke, and
+     * two escapes needed to get out.
+     *
+     * A trap owns the keyboard. Nothing outside it is a target, including a
+     * focused node left over from before it opened.
+     */
+    dispatch(event: KeyEvent): boolean;
+    /** Called by the renderer after layout, so hit-testing has real rects. */
+    setRect(id: string, rect: Rect): void;
+}
+export declare function createFocus(onChange?: () => void): Focus;
+//# sourceMappingURL=focus.d.ts.map

package/dist/core/focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus.d.ts","sourceRoot":"","sources":["../../src/core/focus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAAE,cAAc,EAAE,YAAY,EAAE,iBAAiB,EAClE,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AASzD,8EAA8E;AAC9E,eAAO,MAAM,YAAY,eAAe,CAAC;AAEzC;;;;;;;GAOG;AACH,qBAAa,KAAM,YAAW,YAAY;IAQ5B,OAAO,CAAC,QAAQ;IAP5B,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,KAAK,CAAuC;IACpD,4EAA4E;IAC5E,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,OAAO,CAAuB;gBAElB,QAAQ,GAAE,MAAM,IAAe;IAOnD,aAAa,CAAC,OAAO,EAAE,iBAAiB,GAAG,UAAU;IAQrD,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAe/B,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAgCjC,WAAW,IAAI,MAAM,GAAG,IAAI;IAK5B,qDAAqD;IACrD,OAAO,CAAC,aAAa;IAQrB,6EAA6E;IAC7E,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAM/B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,UAAU;IAiC/C,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;IAgB1D,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIxB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAa1B,IAAI,IAAI,IAAI;IAQZ,OAAO,IAAI,MAAM,GAAG,IAAI;IAIxB,KAAK,IAAI,MAAM,EAAE;IAOjB,kEAAkE;IAClE,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAsBjC,IAAI,CAAC,SAAS,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI;IAe9C;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAwCvB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAgBvC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO;IAiClC,0EAA0E;IAC1E,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI;CAItC;AAED,wBAAgB,WAAW,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,KAAK,CAExD"}

package/dist/core/focus.js

@@ -0,0 +1,336 @@
+import { toDisposable } from '../util/disposable.js';
+import { rectContains } from '../types/geometry.js';
+/** The scope every global handler lives in, always active and always last. */
+export const GLOBAL_SCOPE = '__global__';
+/**
+ * Focus.
+ *
+ * Tab order is registration order within a scope unless a node states one.
+ * Directional navigation is geometric, because in a terminal "the thing to the
+ * right" is a real question a table, a menu and a dashboard all ask, and none
+ * of them can answer it from document order.
+ */
+export class Focus {
+    onChange;
+    scopes = new Map();
+    nodes = new Map();
+    /** Registration order, which is tab order when nothing states otherwise. */
+    order_ = [];
+    stack = [];
+    current = null;
+    constructor(onChange = () => { }) {
+        this.onChange = onChange;
+        this.scopes.set(GLOBAL_SCOPE, { id: GLOBAL_SCOPE, priority: -1, restoreTo: null });
+        this.stack.push(GLOBAL_SCOPE);
+    }
+    // ------------------------------------------------------------- scopes
+    registerScope(options) {
+        this.scopes.set(options.id, { ...options, restoreTo: null });
+        return toDisposable(() => {
+            this.deactivateScope(options.id);
+            this.scopes.delete(options.id);
+        });
+    }
+    activateScope(id) {
+        const scope = this.scopes.get(id);
+        if (!scope)
+            return;
+        if (this.stack.includes(id))
+            return;
+        scope.restoreTo = this.current;
+        this.stack.push(id);
+        if (scope.autoFocus) {
+            const first = this.order(id)[0];
+            if (first)
+                this.focus(first);
+        }
+        this.onChange();
+    }
+    deactivateScope(id) {
+        const index = this.stack.indexOf(id);
+        if (index <= 0)
+            return;
+        const scope = this.scopes.get(id);
+        this.stack.splice(index, 1);
+        // A scope closing may only move focus it was holding. Blurring regardless
+        // took focus off whatever was driving the change - a sidebar that swaps
+        // the screen beside it lost focus on every arrow press, and the incoming
+        // screen then claimed it, so the sidebar could be moved exactly once.
+        // "Nothing holds focus" counts as held: a scope closing takes its own
+        // contents with it, so by the time this runs the thing it had focused has
+        // usually already unmounted. What must not count is focus sitting on
+        // something *outside* - that belongs to whoever put it there.
+        const held = this.current === null || this.scopeOf(this.current) === id;
+        if (scope?.restore && held) {
+            const target = scope.restoreTo;
+            scope.restoreTo = null;
+            if (target && this.nodes.has(target)) {
+                this.focus(target);
+                return;
+            }
+            this.blur();
+        }
+        else if (scope?.restore) {
+            scope.restoreTo = null;
+        }
+        else if (held) {
+            this.blur();
+        }
+        this.onChange();
+    }
+    activeScope() {
+        const top = this.stack[this.stack.length - 1];
+        return top === GLOBAL_SCOPE ? null : top ?? null;
+    }
+    /** The innermost active scope that traps, if any. */
+    trappingScope() {
+        for (let i = this.stack.length - 1; i >= 0; i--) {
+            const id = this.stack[i];
+            if (this.scopes.get(id)?.trap)
+                return id;
+        }
+        return null;
+    }
+    /** Which scope a focusable belongs to. `GLOBAL_SCOPE` when it names none. */
+    scopeOf(nodeId) {
+        return this.nodes.get(nodeId)?.scopeId ?? GLOBAL_SCOPE;
+    }
+    // ---------------------------------------------------------- focusables
+    register(options) {
+        const existing = this.nodes.has(options.id);
+        this.nodes.set(options.id, options);
+        if (!existing)
+            this.order_.push(options.id);
+        // A scope that asked to take focus takes it here, as its first control
+        // arrives - not when it was activated, because a scope is empty then. Its
+        // contents register on the way up, one effect at a time, and effects run
+        // parent-first, so `autoFocus` at activation could only ever have found
+        // something in a scope that already had something in it.
+        //
+        // Only when *nothing at all* holds focus. That is the difference between
+        // the screen this is for - pushed over whatever had focus, which the push
+        // unmounted, leaving none - and a dialog, which opens while its opener
+        // still holds focus and whose own controls say which of them wants it.
+        if (!existing && options.disabled !== true && this.current === null) {
+            const scopeId = options.scopeId ?? GLOBAL_SCOPE;
+            if (this.scopes.get(scopeId)?.autoFocus === true && this.stack.includes(scopeId)) {
+                this.focus(options.id);
+            }
+        }
+        return toDisposable(() => {
+            this.nodes.delete(options.id);
+            const i = this.order_.indexOf(options.id);
+            if (i >= 0)
+                this.order_.splice(i, 1);
+            if (this.current === options.id) {
+                this.current = null;
+                this.onChange();
+            }
+        });
+    }
+    update(id, patch) {
+        const node = this.nodes.get(id);
+        if (!node)
+            return;
+        this.nodes.set(id, { ...node, ...patch });
+        // Focus cannot sit on something that has just been disabled. Nothing else
+        // would move it - the keys it would have handled are now nobody's - so the
+        // tab order is the only way out and this is what puts the reader back in
+        // it.
+        if (patch.disabled === true && this.current === id) {
+            this.current = null;
+            node.onBlur?.();
+            this.onChange();
+        }
+    }
+    has(id) {
+        return this.nodes.has(id);
+    }
+    focus(id) {
+        const node = this.nodes.get(id);
+        if (!node || node.disabled)
+            return false;
+        if (this.current === id)
+            return true;
+        const previous = this.current ? this.nodes.get(this.current) : undefined;
+        this.current = id;
+        previous?.onBlur?.();
+        node.onFocus?.();
+        this.onChange();
+        return true;
+    }
+    blur() {
+        if (!this.current)
+            return;
+        const node = this.nodes.get(this.current);
+        this.current = null;
+        node?.onBlur?.();
+        this.onChange();
+    }
+    focused() {
+        return this.current;
+    }
+    chain() {
+        const out = [];
+        if (this.current)
+            out.push(this.current);
+        for (let i = this.stack.length - 1; i >= 0; i--)
+            out.push(this.stack[i]);
+        return out;
+    }
+    /** Tab order: explicit `order` first, then registration order. */
+    order(scopeId) {
+        const trap = this.trappingScope();
+        const scope = scopeId ?? trap ?? undefined;
+        const candidates = this.order_
+            .map((id) => this.nodes.get(id))
+            .filter((n) => {
+            if (!n || n.disabled || n.skipTab)
+                return false;
+            if (scope === undefined)
+                return true;
+            return (n.scopeId ?? GLOBAL_SCOPE) === scope;
+        });
+        return candidates
+            .map((n, i) => ({ n, i }))
+            .sort((a, b) => {
+            const ao = a.n.order ?? Number.MAX_SAFE_INTEGER;
+            const bo = b.n.order ?? Number.MAX_SAFE_INTEGER;
+            return ao === bo ? a.i - b.i : ao - bo;
+        })
+            .map((e) => e.n.id);
+    }
+    move(direction) {
+        if (direction === 'next' || direction === 'previous') {
+            const list = this.order();
+            if (list.length === 0)
+                return null;
+            const index = this.current ? list.indexOf(this.current) : -1;
+            const step = direction === 'next' ? 1 : -1;
+            const nextIndex = index === -1
+                ? (direction === 'next' ? 0 : list.length - 1)
+                : (index + step + list.length) % list.length;
+            const id = list[nextIndex];
+            return this.focus(id) ? id : null;
+        }
+        return this.moveDirectional(direction);
+    }
+    /**
+     * Geometric navigation. Candidates must lie in the requested direction; the
+     * winner is the nearest, with distance along the axis weighted more heavily
+     * than drift across it, so `right` from a table cell finds the next column
+     * rather than a distant button that happens to be closer in a straight line.
+     */
+    moveDirectional(direction) {
+        const from = this.current ? this.nodes.get(this.current) : undefined;
+        const origin = from?.rect;
+        if (!origin) {
+            const first = this.order()[0];
+            return first && this.focus(first) ? first : null;
+        }
+        const trap = this.trappingScope();
+        const cx = origin.x + origin.width / 2;
+        const cy = origin.y + origin.height / 2;
+        let best = null;
+        for (const node of this.nodes.values()) {
+            if (node.id === from.id || node.disabled || !node.rect)
+                continue;
+            if (trap && (node.scopeId ?? GLOBAL_SCOPE) !== trap)
+                continue;
+            const r = node.rect;
+            const nx = r.x + r.width / 2;
+            const ny = r.y + r.height / 2;
+            const dx = nx - cx;
+            const dy = ny - cy;
+            const along = direction === 'left' ? -dx : direction === 'right' ? dx
+                : direction === 'up' ? -dy : dy;
+            if (along <= 0)
+                continue;
+            const across = direction === 'left' || direction === 'right'
+                ? Math.abs(dy)
+                : Math.abs(dx);
+            const score = along + across * 3;
+            if (!best || score < best.score)
+                best = { id: node.id, score };
+        }
+        if (!best)
+            return null;
+        return this.focus(best.id) ? best.id : null;
+    }
+    at(x, y) {
+        let found = null;
+        let smallest = Infinity;
+        for (const node of this.nodes.values()) {
+            if (node.disabled || !node.rect)
+                continue;
+            if (!rectContains(node.rect, x, y))
+                continue;
+            // The innermost hit wins, and "innermost" is the smallest area.
+            const area = node.rect.width * node.rect.height;
+            if (area < smallest) {
+                smallest = area;
+                found = node.id;
+            }
+        }
+        return found;
+    }
+    /**
+     * Focused node first, then outward through active scopes, then global -
+     * except that a trap stops the walk at itself.
+     *
+     * `order` and `move` already honoured the trap, so tab could not leave a
+     * modal; keys could, and did. A menu bar whose labels live in the global
+     * scope kept receiving every arrow while its own dropdown was open, so down
+     * re-opened the menu instead of moving inside it, and a palette opened over
+     * the top inherited the same problem - two layers reading one keystroke, and
+     * two escapes needed to get out.
+     *
+     * A trap owns the keyboard. Nothing outside it is a target, including a
+     * focused node left over from before it opened.
+     */
+    dispatch(event) {
+        const trap = this.trappingScope();
+        const inTrap = (node) => trap === null || (node.scopeId ?? GLOBAL_SCOPE) === trap;
+        if (this.current) {
+            const node = this.nodes.get(this.current);
+            if (node && inTrap(node) && (node.onKey?.(event) === true || event.handled))
+                return true;
+        }
+        // Then the handlers that are not about one control.
+        //
+        // Only those. This loop used to offer the event to every registered
+        // handler, focused or not, which quietly undid the line above it: a list
+        // moved on an arrow it never received, because the arrow reached it here.
+        // With nothing focused it went to whichever focusable registered first -
+        // so a page with two lists moved the earlier one, and a tab strip and a
+        // list beneath it split the arrow keys between them by accident. That
+        // reads as working until the second list exists.
+        for (let i = this.stack.length - 1; i >= 0; i--) {
+            const scopeId = this.stack[i];
+            if (trap !== null && scopeId !== trap)
+                continue;
+            for (const node of this.nodes.values()) {
+                if (node.id === this.current)
+                    continue;
+                if (node.global !== true)
+                    continue;
+                if ((node.scopeId ?? GLOBAL_SCOPE) !== scopeId)
+                    continue;
+                if (!node.onKey)
+                    continue;
+                if (node.onKey(event) === true || event.handled)
+                    return true;
+            }
+        }
+        return false;
+    }
+    /** Called by the renderer after layout, so hit-testing has real rects. */
+    setRect(id, rect) {
+        const node = this.nodes.get(id);
+        if (node)
+            node.rect = rect;
+    }
+}
+export function createFocus(onChange) {
+    return new Focus(onChange);
+}

package/dist/core/i18n.d.ts

@@ -0,0 +1,27 @@
+import type { I18n, LocaleId, TranslationBundle } from '../types/i18n.js';
+import type { Disposable } from '../types/disposable.js';
+/**
+ * Lightweight i18n. Formatting is `Intl`'s job - recreating number, date and
+ * list formatting would be a second, worse implementation of something the
+ * runtime already ships.
+ */
+export declare class I18nRegistry implements I18n {
+    private fallbackLocale;
+    locale: LocaleId;
+    private bundles;
+    private listeners;
+    constructor(locale?: LocaleId, fallbackLocale?: LocaleId);
+    setLocale(locale: LocaleId): void;
+    register(bundle: TranslationBundle): Disposable;
+    locales(): LocaleId[];
+    /** Missing keys fall through to the fallback locale, then to the key. */
+    t(key: string, values?: Record<string, unknown>): string;
+    number(value: number, options?: Intl.NumberFormatOptions): string;
+    date(value: Date | number, options?: Intl.DateTimeFormatOptions): string;
+    relative(value: number, unit: Intl.RelativeTimeFormatUnit): string;
+    list(items: string[], options?: Intl.ListFormatOptions): string;
+    plural(count: number, forms: Record<string, string>): string;
+    onChange(fn: (locale: LocaleId) => void): Disposable;
+}
+export declare function createI18n(locale?: string, fallback?: string): I18nRegistry;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/core/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/core/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAsBzD;;;;GAIG;AACH,qBAAa,YAAa,YAAW,IAAI;IAOrC,OAAO,CAAC,cAAc;IANxB,MAAM,EAAE,QAAQ,CAAC;IACjB,OAAO,CAAC,OAAO,CAAgD;IAC/D,OAAO,CAAC,SAAS,CAAyC;gBAGxD,MAAM,GAAE,QAAe,EACf,cAAc,GAAE,QAAe;IAKzC,SAAS,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI;IAMjC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,UAAU;IAS/C,OAAO,IAAI,QAAQ,EAAE;IAIrB,yEAAyE;IACzE,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;IAgBxD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,GAAG,MAAM;IAIjE,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,qBAAqB,GAAG,MAAM;IAIxE,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,sBAAsB,GAAG,MAAM;IAIlE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,GAAG,MAAM;IAI/D,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;IAM5D,QAAQ,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,GAAG,UAAU;CAIrD;AAED,wBAAgB,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAE3E"}

package/dist/core/i18n.js

@@ -0,0 +1,88 @@
+import { toDisposable } from '../util/disposable.js';
+function lookup(messages, key) {
+    if (key in messages) {
+        const direct = messages[key];
+        return typeof direct === 'string' ? direct : undefined;
+    }
+    let cursor = messages;
+    for (const part of key.split('.')) {
+        if (cursor === null || typeof cursor !== 'object')
+            return undefined;
+        cursor = cursor[part];
+    }
+    return typeof cursor === 'string' ? cursor : undefined;
+}
+function interpolate(template, values) {
+    return template.replace(/\{(\w+)\}/g, (match, name) => name in values ? String(values[name]) : match);
+}
+/**
+ * Lightweight i18n. Formatting is `Intl`'s job - recreating number, date and
+ * list formatting would be a second, worse implementation of something the
+ * runtime already ships.
+ */
+export class I18nRegistry {
+    fallbackLocale;
+    locale;
+    bundles = new Map();
+    listeners = new Set();
+    constructor(locale = 'en', fallbackLocale = 'en') {
+        this.fallbackLocale = fallbackLocale;
+        this.locale = locale;
+    }
+    setLocale(locale) {
+        if (this.locale === locale)
+            return;
+        this.locale = locale;
+        for (const fn of [...this.listeners])
+            fn(locale);
+    }
+    register(bundle) {
+        const existing = this.bundles.get(bundle.locale) ?? {};
+        this.bundles.set(bundle.locale, { ...existing, ...bundle.messages });
+        if (this.locale === bundle.locale) {
+            for (const fn of [...this.listeners])
+                fn(this.locale);
+        }
+        return toDisposable(() => this.bundles.delete(bundle.locale));
+    }
+    locales() {
+        return [...this.bundles.keys()];
+    }
+    /** Missing keys fall through to the fallback locale, then to the key. */
+    t(key, values) {
+        const primary = this.bundles.get(this.locale);
+        const base = this.locale.includes('-')
+            ? this.bundles.get(this.locale.split('-')[0])
+            : undefined;
+        const fallback = this.bundles.get(this.fallbackLocale);
+        const template = (primary && lookup(primary, key)) ??
+            (base && lookup(base, key)) ??
+            (fallback && lookup(fallback, key)) ??
+            key;
+        return values ? interpolate(template, values) : template;
+    }
+    number(value, options) {
+        return new Intl.NumberFormat(this.locale, options).format(value);
+    }
+    date(value, options) {
+        return new Intl.DateTimeFormat(this.locale, options).format(value);
+    }
+    relative(value, unit) {
+        return new Intl.RelativeTimeFormat(this.locale, { numeric: 'auto' }).format(value, unit);
+    }
+    list(items, options) {
+        return new Intl.ListFormat(this.locale, options).format(items);
+    }
+    plural(count, forms) {
+        const rule = new Intl.PluralRules(this.locale).select(count);
+        const template = forms[rule] ?? forms.other ?? '';
+        return interpolate(template, { count });
+    }
+    onChange(fn) {
+        this.listeners.add(fn);
+        return toDisposable(() => this.listeners.delete(fn));
+    }
+}
+export function createI18n(locale, fallback) {
+    return new I18nRegistry(locale, fallback);
+}

package/dist/core/keybindings.d.ts

@@ -0,0 +1,53 @@
+import type { Chord, KeybindingDefinition, KeybindingRegistry } from '../types/keybinding.js';
+import type { KeyEvent } from '../types/input.js';
+import type { Disposable } from '../types/disposable.js';
+import type { WhenEngine } from '../types/when.js';
+import type { CommandRegistry } from '../types/command.js';
+/**
+ * Split one stroke into its modifiers and its key.
+ *
+ * Modifiers are consumed off the front by name and whatever survives is the
+ * key, verbatim. Splitting on `+` cannot work here: `+` is the separator and
+ * a key, so `'+'.split('+')` loses the only thing it was asked about. Parsing
+ * forwards means `+` is `+`, and `ctrl++` is ctrl and `+`.
+ *
+ * One parser, exported, because a chord that the test harness presses and a
+ * chord that the registry stored have to agree - and two implementations of
+ * one grammar disagree eventually.
+ */
+export declare function splitStroke(stroke: string): {
+    mods: string[];
+    key: string;
+};
+/** The canonical stroke a chord is filed under. `strokeOf` must agree with it. */
+export declare function normalizeStroke(stroke: string): string;
+export declare function strokeOf(event: KeyEvent): string;
+/**
+ * Keybindings resolve to commands, never to handlers, so the same action is
+ * reachable from a chord, a menu row and the palette without three copies.
+ * A partially typed chord is remembered, which is what makes `ctrl+k ctrl+s`
+ * possible without blocking `ctrl+k` on its own.
+ */
+export declare class Keybindings implements KeybindingRegistry {
+    private deps;
+    private bindings;
+    private pending;
+    private pendingTimer;
+    constructor(deps: {
+        when: WhenEngine;
+        commands: CommandRegistry;
+        activeScopes(): string[];
+        onError(err: unknown, context: string): void;
+        /** How long a half-typed chord waits for its next stroke. */
+        chordTimeoutMs?: number;
+    });
+    register(def: KeybindingDefinition): Disposable;
+    unregister(keys: Chord, commandId?: string): void;
+    list(): KeybindingDefinition[];
+    forCommand(commandId: string): Chord[];
+    private applicable;
+    handle(event: KeyEvent): 'handled' | 'pending' | 'unhandled';
+    reset(): void;
+}
+export declare function createKeybindings(deps: ConstructorParameters<typeof Keybindings>[0]): Keybindings;
+//# sourceMappingURL=keybindings.d.ts.map

package/dist/core/keybindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keybindings.d.ts","sourceRoot":"","sources":["../../src/core/keybindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC9F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAU3D;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAS3E;AAED,kFAAkF;AAClF,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAuBtD;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAYhD;AAED;;;;;GAKG;AACH,qBAAa,WAAY,YAAW,kBAAkB;IAMlD,OAAO,CAAC,IAAI;IALd,OAAO,CAAC,QAAQ,CAAwD;IACxE,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,YAAY,CAA8C;gBAGxD,IAAI,EAAE;QACZ,IAAI,EAAE,UAAU,CAAC;QACjB,QAAQ,EAAE,eAAe,CAAC;QAC1B,YAAY,IAAI,MAAM,EAAE,CAAC;QACzB,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QAC7C,6DAA6D;QAC7D,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;IAGH,QAAQ,CAAC,GAAG,EAAE,oBAAoB,GAAG,UAAU;IAU/C,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAOjD,IAAI,IAAI,oBAAoB,EAAE;IAI9B,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,EAAE;IAUtC,OAAO,CAAC,UAAU;IAMlB,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW;IAoC5D,KAAK,IAAI,IAAI;CAOd;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW,CAEjG"}