@leavepulse/ui 0.44.0 → 0.45.1

package/dist/composables/useHotkeys.d.ts

@@ -1,7 +1,18 @@
 import { type MaybeRefOrGetter } from "vue";
-export interface HotkeyBinding {
-    /** Layout-produced key, compared case-insensitively ("l", "f2", "escape"). */
+/** One key of a sequence: a bare key ("g") or a full chord. */
+export interface HotkeyStep {
     key: string;
+    code?: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+}
+export interface HotkeyBinding {
+    /**
+     * Layout-produced key, compared case-insensitively ("l", "f2", "escape").
+     * Required unless the binding is a `sequence`.
+     */
+    key?: string;
     /**
      * Physical key position ("KeyL", "F2", "Digit1"). Matches on its own, which
      * is what makes non-Latin layouts work.
@@ -11,6 +22,16 @@ export interface HotkeyBinding {
     ctrl?: boolean;
     shift?: boolean;
     alt?: boolean;
+    /**
+     * Keys pressed one after another: `"g i"`, or steps for chords and physical
+     * positions (`[{ key: "g", code: "KeyG" }, { key: "i", code: "KeyI" }]`).
+     * The string form splits on spaces, so a Space step needs the array form.
+     */
+    sequence?: string | (string | HotkeyStep)[];
+    /** How long a sequence waits for its next key, in ms. Default 1000. */
+    timeout?: number;
+    /** Extra condition checked on every press; `false` leaves the key alone. */
+    when?: (event: KeyboardEvent) => boolean;
     /**
      * Runs even while a text field has focus. Only for shortcuts that mean
      * something there — Escape, and the palette the user reaches from anywhere.
@@ -48,14 +69,19 @@ export interface HotkeyHelp {
     /**
      * Written the way it reads, "+"-separated. Defaults to one built from the
      * binding; set it where the binding is not the whole story, such as the
-     * second key of a chord ("G+D") or a key that needs Shift to type ("?").
+     * key that needs Shift to type ("?"). Sequences read with spaces: "G I".
      */
     combo?: string;
 }
 export interface ShortcutEntry {
-    /** Rendered one <kbd> per "+"-separated key, so write it the way it reads. */
+    /**
+     * Rendered one <kbd> per "+"-separated key, so write it the way it reads.
+     * Spaces separate the steps of a sequence ("G I", "Ctrl+K Ctrl+S").
+     */
     combo: string;
     label: string;
+    /** Another mounted binding answers the same keys at the same priority. */
+    conflict?: boolean;
 }
 export interface ShortcutGroup {
     title: string;
@@ -77,7 +103,15 @@ export declare function useAppleKeyboard(): import("vue").Ref<boolean, boolean>;
  * Meta as one modifier, so only the label may differ — never the binding.
  */
 export declare function appleModifierLabel(key: string, apple?: boolean): string;
-export declare function matchesHotkey(event: KeyboardEvent, binding: HotkeyBinding): boolean;
+type KeyLike = Pick<KeyboardEvent, "key" | "code" | "ctrlKey" | "metaKey" | "shiftKey" | "altKey">;
+export declare function matchesHotkey(event: KeyLike, binding: HotkeyBinding | HotkeyStep): boolean;
+/** The keys a binding waits for, in order: one step for a plain binding. */
+export declare function hotkeySteps(binding: HotkeyBinding): HotkeyStep[];
+/**
+ * Where a run of presses stands against a binding: "full" when they spell it
+ * out, "prefix" when more keys would, otherwise null.
+ */
+export declare function sequenceProgress(presses: KeyLike[], binding: HotkeyBinding): "full" | "prefix" | null;
 /**
  * Bind a list of hotkeys for as long as the calling component is mounted.
  *
@@ -102,7 +136,32 @@ export interface UseHotkeysOptions {
      */
     scope?: MaybeRefOrGetter<HTMLElement | null | undefined>;
 }
+/**
+ * The keys of a sequence typed so far ("G" after the first key of "g i"),
+ * empty when nothing is pending. For a "G…" hint while the next key is awaited.
+ */
+export declare const pendingHotkey: import("vue").ComputedRef<string[]>;
 export declare function useHotkeys(bindings: MaybeRefOrGetter<HotkeyBinding[]>, options?: UseHotkeysOptions): void;
+export interface HotkeyConflict {
+    /** The keys both answer, written as in the shortcut reference. */
+    combo: string;
+    /** `help` labels of the clashing bindings; unlabelled ones are omitted. */
+    labels: string[];
+    priority: number;
+}
+/**
+ * Pure part of `hotkeyConflicts`: bindings from different `useHotkeys` calls
+ * answering the same keys at the same priority within the same scope. Within
+ * one call a repeat is deliberate (the first may decline), and a binding with
+ * `when` is conditional by design, so neither counts.
+ */
+export declare function findHotkeyConflicts(groups: {
+    bindings: HotkeyBinding[];
+    priority: number;
+    scope: unknown;
+}[]): HotkeyConflict[];
+/** Bindings among the mounted ones that answer the same keys. */
+export declare const hotkeyConflicts: import("vue").ComputedRef<HotkeyConflict[]>;
 /**
  * The shortcuts that work right now, grouped for `LpShortcutsDialog`: every
  * binding with `help` from every mounted `useHotkeys`. A screen that binds its
@@ -115,3 +174,4 @@ export declare const activeShortcuts: import("vue").ComputedRef<ShortcutGroup[]>
  * when it lists both its own entries and the live ones.
  */
 export declare function mergeShortcutGroups(...lists: ShortcutGroup[][]): ShortcutGroup[];
+export {};

package/dist/composables/useHotkeys.js

@@ -1,4 +1,4 @@
-import { shallowReactive, computed, toValue, getCurrentInstance, onMounted, onBeforeUnmount, ref } from "vue";
+import { shallowReactive, ref, computed, toValue, getCurrentInstance, onMounted, onBeforeUnmount } from "vue";
 import { topModalElement } from "../components/modalDepth.js";
 const isAppleKeyboard = typeof navigator !== "undefined" && /Mac|iPhone|iPad|iPod/.test(navigator.platform || "");
 function useAppleKeyboard() {
@@ -32,6 +32,7 @@ function isTextEntry(target) {
 }
 const MODIFIER_KEYS = /* @__PURE__ */ new Set(["control", "meta", "shift", "alt"]);
 function matchesHotkey(event, binding) {
+  if (binding.key === void 0) return false;
   const key = binding.key.toLowerCase();
   const ctrlHeld = event.ctrlKey || event.metaKey;
   const wantsCtrl = Boolean(binding.ctrl) || key === "control" || key === "meta";
@@ -43,6 +44,24 @@ function matchesHotkey(event, binding) {
   if (MODIFIER_KEYS.has(key)) return event.key.toLowerCase() === key;
   return event.key.toLowerCase() === key || binding.code !== void 0 && event.code === binding.code;
 }
+function hotkeySteps(binding) {
+  const raw = binding.sequence;
+  if (raw === void 0) {
+    if (binding.key === void 0) return [];
+    const { key, code, ctrl, shift, alt } = binding;
+    return [{ key, code, ctrl, shift, alt }];
+  }
+  const list = typeof raw === "string" ? raw.trim().split(/\s+/) : raw;
+  return list.map((step) => typeof step === "string" ? { key: step } : step);
+}
+function sequenceProgress(presses, binding) {
+  const steps = hotkeySteps(binding);
+  if (!steps.length || presses.length > steps.length) return null;
+  for (let i = 0; i < presses.length; i++) {
+    if (!matchesHotkey(presses[i], steps[i])) return null;
+  }
+  return presses.length === steps.length ? "full" : "prefix";
+}
 const STATE_KEY = /* @__PURE__ */ Symbol.for("@leavepulse/ui:hotkeys");
 const g = globalThis;
 const state = g[STATE_KEY] ??= {
@@ -66,13 +85,23 @@ function insideOf(entry, layer) {
   const node = scope ?? entry.host();
   return !!node && layer.contains(node);
 }
-function onKeydown(event) {
-  if (event.isComposing || event.defaultPrevented) return;
+const DEFAULT_TIMEOUT = 1e3;
+const pressed = [];
+let held = [];
+let holdTimer;
+const pendingKeys = ref([]);
+const pendingHotkey = computed(() => pendingKeys.value);
+function snapshot(event) {
+  const { key, code, ctrlKey, metaKey, shiftKey, altKey } = event;
+  return { key, code, ctrlKey, metaKey, shiftKey, altKey };
+}
+function eligible(event) {
   const inTextEntry = isTextEntry(event.target);
   const blocker = event.key === "Escape" ? topLayer() : topModalElement();
   const entries = [...mounted].sort(
     (a, b) => Number(toValue(b.priority) || 0) - Number(toValue(a.priority) || 0) || b.order - a.order
   );
+  const out = [];
   for (const entry of entries) {
     if (toValue(entry.enabled) === false || !inScope(event.target, entry.scope)) continue;
     const covered = !!blocker && !insideOf(entry, blocker);
@@ -80,12 +109,73 @@ function onKeydown(event) {
       if (inTextEntry && !binding.allowInInput) continue;
       if (event.repeat && binding.repeat === false) continue;
       if (covered && !binding.overLayers) continue;
-      if (!matchesHotkey(event, binding)) continue;
-      if (binding.handler(event) === false) continue;
+      if (binding.when && !binding.when(event)) continue;
+      out.push(binding);
+    }
+  }
+  return out;
+}
+function run(candidates) {
+  for (const { binding, event } of candidates) {
+    if (binding.handler(event) !== false) return true;
+  }
+  return false;
+}
+function resetSequence() {
+  clearTimeout(holdTimer);
+  holdTimer = void 0;
+  pressed.length = 0;
+  held = [];
+  pendingKeys.value = [];
+}
+function flushHeld() {
+  const waiting = held;
+  resetSequence();
+  run(waiting);
+}
+function onKeydown(event) {
+  if (event.isComposing || event.defaultPrevented) return;
+  if (pressed.length && MODIFIER_KEYS.has(event.key.toLowerCase())) return;
+  if (pressed.length && event.key === "Escape") {
+    resetSequence();
+  }
+  const presses = [...pressed, snapshot(event)];
+  const bindings = eligible(event);
+  const full = [];
+  let waitFor = 0;
+  for (const binding of bindings) {
+    const progress = sequenceProgress(presses, binding);
+    if (progress === "full") full.push({ binding, event });
+    else if (progress === "prefix") waitFor = Math.max(waitFor, binding.timeout ?? DEFAULT_TIMEOUT);
+  }
+  if (waitFor) {
+    clearTimeout(holdTimer);
+    pressed.push(snapshot(event));
+    held = full;
+    pendingKeys.value = pressed.map(pressLabel);
+    holdTimer = setTimeout(flushHeld, waitFor);
+    event.preventDefault();
+    return;
+  }
+  if (full.length) {
+    resetSequence();
+    if (run(full)) {
       event.preventDefault();
       return;
     }
   }
+  if (pressed.length) {
+    flushHeld();
+    onKeydown(event);
+  }
+}
+function pressLabel(press) {
+  return chordOf({
+    key: press.key,
+    ctrl: press.ctrlKey || press.metaKey,
+    alt: press.altKey,
+    shift: press.shiftKey && press.key.length !== 1
+  });
 }
 function useHotkeys(bindings, options = {}) {
   const instance = getCurrentInstance();
@@ -102,8 +192,10 @@ function useHotkeys(bindings, options = {}) {
   };
   onMounted(() => {
     mounted.add(entry);
+    warnConflicts();
     if (!state.listening) {
       window.addEventListener("keydown", onKeydown);
+      window.addEventListener("blur", resetSequence);
       state.listening = true;
     }
   });
@@ -111,7 +203,9 @@ function useHotkeys(bindings, options = {}) {
     mounted.delete(entry);
     if (!mounted.size && state.listening) {
       window.removeEventListener("keydown", onKeydown);
+      window.removeEventListener("blur", resetSequence);
       state.listening = false;
+      resetSequence();
     }
   });
 }
@@ -127,20 +221,82 @@ const KEY_NAMES = {
   arrowleft: "←",
   arrowright: "→"
 };
+function chordOf(step) {
+  const key = step.key.toLowerCase();
+  const name = KEY_NAMES[key] ?? (key.length === 1 || /^f\d+$/.test(key) ? key.toUpperCase() : step.key);
+  return [step.ctrl && "Ctrl", step.alt && "Alt", step.shift && "Shift", name].filter(Boolean).join("+");
+}
 function comboOf(binding) {
-  const key = binding.key.toLowerCase();
-  const name = KEY_NAMES[key] ?? (key.length === 1 || /^f\d+$/.test(key) ? key.toUpperCase() : binding.key);
-  return [binding.ctrl && "Ctrl", binding.alt && "Alt", binding.shift && "Shift", name].filter(Boolean).join("+");
+  return hotkeySteps(binding).map(chordOf).join(" ");
+}
+function signatureOf(binding) {
+  return hotkeySteps(binding).map((step) => {
+    const key = step.key.toLowerCase();
+    const symbol = key.length === 1 && key === key.toUpperCase();
+    const shift = step.shift === void 0 && symbol ? "*" : String(Boolean(step.shift));
+    return `${Boolean(step.ctrl)}:${Boolean(step.alt)}:${shift}:${key}`;
+  }).join(" ");
+}
+function findHotkeyConflicts(groups) {
+  const scopeIds = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Map();
+  groups.forEach((group, owner) => {
+    if (!scopeIds.has(group.scope)) scopeIds.set(group.scope, scopeIds.size);
+    for (const binding of group.bindings) {
+      if (binding.when || !hotkeySteps(binding).length) continue;
+      const id = `${group.priority}|${scopeIds.get(group.scope)}|${signatureOf(binding)}`;
+      const slot = seen.get(id) ?? {
+        combo: binding.help?.combo ?? comboOf(binding),
+        labels: [],
+        owners: /* @__PURE__ */ new Set(),
+        priority: group.priority
+      };
+      slot.owners.add(owner);
+      if (binding.help && !slot.labels.includes(binding.help.label)) slot.labels.push(binding.help.label);
+      seen.set(id, slot);
+    }
+  });
+  return [...seen.values()].filter((slot) => slot.owners.size > 1).map(({ combo, labels, priority }) => ({ combo, labels, priority }));
+}
+const hotkeyConflicts = computed(
+  () => findHotkeyConflicts(
+    [...mounted].filter((entry) => toValue(entry.enabled) !== false).map((entry) => ({
+      bindings: entry.read(),
+      priority: Number(toValue(entry.priority) || 0),
+      scope: toValue(entry.scope) ?? null
+    }))
+  )
+);
+const warned = /* @__PURE__ */ new Set();
+function isDev() {
+  try {
+    return process.env.NODE_ENV !== "production";
+  } catch {
+    return false;
+  }
+}
+function warnConflicts() {
+  if (!isDev()) return;
+  for (const conflict of hotkeyConflicts.value) {
+    const id = `${conflict.priority}|${conflict.combo}`;
+    if (warned.has(id)) continue;
+    warned.add(id);
+    console.warn(
+      `[@leavepulse/ui] ${conflict.combo} is bound more than once at priority ${conflict.priority}` + (conflict.labels.length ? ` (${conflict.labels.join(", ")})` : "") + "; only the most recently mounted one runs unless it declines."
+    );
+  }
 }
 const activeShortcuts = computed(() => {
   const groups = /* @__PURE__ */ new Map();
+  const clashing = new Set(hotkeyConflicts.value.map((c) => c.combo));
   for (const entry of mounted) {
     if (toValue(entry.enabled) === false) continue;
     for (const binding of entry.read()) {
       if (!binding.help) continue;
       const combo = binding.help.combo ?? comboOf(binding);
       const entries = groups.get(binding.help.group) ?? [];
-      if (!entries.some((e) => e.combo === combo)) entries.push({ combo, label: binding.help.label });
+      const conflict = clashing.has(combo) || void 0;
+      if (!entries.some((e) => e.combo === combo)) entries.push({ combo, label: binding.help.label, conflict });
       groups.set(binding.help.group, entries);
     }
   }
@@ -162,9 +318,14 @@ function mergeShortcutGroups(...lists) {
 export {
   activeShortcuts,
   appleModifierLabel,
+  findHotkeyConflicts,
+  hotkeyConflicts,
+  hotkeySteps,
   isAppleKeyboard,
   matchesHotkey,
   mergeShortcutGroups,
+  pendingHotkey,
+  sequenceProgress,
   useAppleKeyboard,
   useHotkeys
 };

package/dist/composables/useInputMask.d.ts

@@ -0,0 +1,59 @@
+import { type MaybeRefOrGetter } from "vue";
+export type MaskToken = RegExp | {
+    pattern: RegExp;
+    transform?: (ch: string) => string;
+};
+export type MaskTokens = Record<string, MaskToken>;
+export type MaskSpec = string | readonly string[] | ((raw: string) => string);
+export declare const DEFAULT_MASK_TOKENS: MaskTokens;
+type Slot = {
+    literal: string;
+} | {
+    test: (ch: string) => boolean;
+    transform: (ch: string) => string;
+};
+export interface MaskResult {
+    masked: string;
+    raw: string;
+    /** Caret offset in `masked`. */
+    caret: number;
+    /** Every token of the mask is filled. */
+    complete: boolean;
+}
+export interface MaskOptions {
+    mask: MaskSpec;
+    tokens?: MaskTokens;
+    /**
+     * Caret position: an offset into `input`, or with `fromRaw` the number of raw
+     * characters before it. Defaults to the end.
+     */
+    caret?: number;
+    /** `input` holds raw characters only; literals in it are never consumed as mask literals. */
+    fromRaw?: boolean;
+}
+export declare function parseMask(mask: string, tokens?: MaskTokens): Slot[];
+/** Format `input` through a mask and map the caret into the result. */
+export declare function applyMask(input: string, options: MaskOptions): MaskResult;
+/**
+ * The value after deleting one accepted character next to a collapsed caret,
+ * skipping over literals, or null when there is nothing to delete that way.
+ */
+export declare function maskDelete(value: string, caret: number, direction: "backward" | "forward", options: Omit<MaskOptions, "caret" | "fromRaw">): MaskResult | null;
+export interface UseInputMaskOptions {
+    mask: MaybeRefOrGetter<MaskSpec | undefined>;
+    tokens?: MaybeRefOrGetter<MaskTokens | undefined>;
+    /** Called with every value the user produces. */
+    onChange?: (masked: string, raw: string, complete: boolean) => void;
+}
+/**
+ * Bind `onBeforeInput`, `onInput` and `onCompositionEnd` to the input, and show
+ * `format(model).masked` as its value.
+ */
+export declare function useInputMask(options: UseInputMaskOptions): {
+    active: import("vue").ComputedRef<boolean>;
+    format: (value: string | null | undefined) => MaskResult;
+    onBeforeInput: (event: InputEvent) => void;
+    onInput: (event: Event) => void;
+    onCompositionEnd: (event: CompositionEvent) => void;
+};
+export {};

package/dist/composables/useInputMask.js

@@ -0,0 +1,170 @@
+import { computed, toValue } from "vue";
+const DEFAULT_MASK_TOKENS = {
+  "0": /\d/,
+  a: new RegExp("\\p{L}", "u"),
+  A: { pattern: new RegExp("\\p{L}", "u"), transform: (ch) => ch.toLocaleUpperCase() },
+  "*": /[\p{L}\d]/u
+};
+function tester(token) {
+  const pattern = token instanceof RegExp ? token : token.pattern;
+  const re = new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, ""));
+  const transform = token instanceof RegExp ? void 0 : token.transform;
+  return { test: (ch) => re.test(ch), transform: transform ?? ((ch) => ch) };
+}
+function parseMask(mask, tokens = DEFAULT_MASK_TOKENS) {
+  const slots = [];
+  const chars = Array.from(mask);
+  for (let i = 0; i < chars.length; i++) {
+    const ch = chars[i];
+    if (ch === "\\" && i + 1 < chars.length) {
+      slots.push({ literal: chars[++i] });
+      continue;
+    }
+    const token = tokens[ch];
+    slots.push(token ? tester(token) : { literal: ch });
+  }
+  return slots;
+}
+function run(slots, input, caret, fromRaw) {
+  const tokenStarts = [];
+  const tokenEnds = [];
+  const tokenOffsets = [];
+  let out = "";
+  let raw = "";
+  let pending = "";
+  let si = 0;
+  let offset = 0;
+  let before = 0;
+  let overflow = false;
+  for (const ch of input) {
+    const at2 = offset;
+    offset += ch.length;
+    if (si >= slots.length) {
+      if (slots.some((s) => "test" in s && s.test(ch))) overflow = true;
+      continue;
+    }
+    while (si < slots.length) {
+      const slot = slots[si];
+      if ("literal" in slot) {
+        pending += slot.literal;
+        si++;
+        if (!fromRaw && slot.literal === ch) break;
+        continue;
+      }
+      if (slot.test(ch)) {
+        const value = slot.transform(ch);
+        out += pending;
+        pending = "";
+        tokenStarts.push(out.length);
+        out += value;
+        tokenEnds.push(out.length);
+        raw += value;
+        tokenOffsets.push(at2);
+        si++;
+        if (fromRaw ? raw.length <= caret : at2 < caret) before++;
+      }
+      break;
+    }
+  }
+  const rest = slots.slice(si);
+  const complete = !rest.some((s) => "test" in s);
+  if (complete && out) out += pending + rest.map((s) => "literal" in s ? s.literal : "").join("");
+  const at = before === 0 ? tokenStarts[0] ?? 0 : tokenEnds[before - 1];
+  return {
+    masked: out,
+    raw,
+    caret: complete && before === tokenEnds.length ? out.length : at,
+    complete,
+    overflow,
+    tokenOffsets
+  };
+}
+function resolve(options, input, caret) {
+  const tokens = options.tokens ?? DEFAULT_MASK_TOKENS;
+  const fromRaw = !!options.fromRaw;
+  const { mask } = options;
+  if (typeof mask === "string") return run(parseMask(mask, tokens), input, caret, fromRaw);
+  if (typeof mask === "function") {
+    let current = mask("");
+    let result = run(parseMask(current, tokens), input, caret, fromRaw);
+    for (let i = 0; i < 4; i++) {
+      const next = mask(result.raw);
+      if (next === current) break;
+      current = next;
+      result = run(parseMask(current, tokens), input, caret, fromRaw);
+    }
+    return result;
+  }
+  let last;
+  for (const m of mask) {
+    last = run(parseMask(m, tokens), input, caret, fromRaw);
+    if (!last.overflow) return last;
+  }
+  return last ?? run([], input, caret, fromRaw);
+}
+function applyMask(input, options) {
+  const caret = options.caret ?? (options.fromRaw ? Number.POSITIVE_INFINITY : input.length);
+  const { masked, raw, caret: at, complete } = resolve(options, input, caret);
+  return { masked, raw, caret: at, complete };
+}
+function maskDelete(value, caret, direction, options) {
+  const { tokenOffsets, raw } = resolve(options, value, caret);
+  const index = direction === "backward" ? tokenOffsets.filter((o) => o < caret).length - 1 : tokenOffsets.findIndex((o) => o >= caret);
+  if (index < 0) return null;
+  const chars = Array.from(raw);
+  chars.splice(index, 1);
+  return applyMask(chars.join(""), { ...options, caret: index, fromRaw: true });
+}
+function useInputMask(options) {
+  const spec = computed(() => {
+    const mask = toValue(options.mask);
+    return mask === void 0 || mask === "" ? void 0 : { mask, tokens: toValue(options.tokens) };
+  });
+  function format(value) {
+    const s = spec.value;
+    const text = value ?? "";
+    return s ? applyMask(text, s) : { masked: text, raw: text, caret: text.length, complete: true };
+  }
+  function commit(el, result) {
+    if (el.value !== result.masked) el.value = result.masked;
+    if (el.ownerDocument.activeElement === el) {
+      try {
+        el.setSelectionRange(result.caret, result.caret);
+      } catch {
+      }
+    }
+    options.onChange?.(result.masked, result.raw, result.complete);
+  }
+  function onBeforeInput(event) {
+    const s = spec.value;
+    const el = event.target;
+    if (!s || event.isComposing || !(el instanceof HTMLInputElement)) return;
+    const backward = event.inputType === "deleteContentBackward";
+    if (!backward && event.inputType !== "deleteContentForward") return;
+    const start = el.selectionStart;
+    if (start === null || start !== el.selectionEnd) return;
+    event.preventDefault();
+    const result = maskDelete(el.value, start, backward ? "backward" : "forward", s);
+    if (result) commit(el, result);
+  }
+  function reformat(el) {
+    const s = spec.value;
+    if (!s) return;
+    commit(el, applyMask(el.value, { ...s, caret: el.selectionStart ?? el.value.length }));
+  }
+  function onInput(event) {
+    if (event.isComposing || !(event.target instanceof HTMLInputElement)) return;
+    reformat(event.target);
+  }
+  function onCompositionEnd(event) {
+    if (event.target instanceof HTMLInputElement) reformat(event.target);
+  }
+  return { active: computed(() => !!spec.value), format, onBeforeInput, onInput, onCompositionEnd };
+}
+export {
+  DEFAULT_MASK_TOKENS,
+  applyMask,
+  maskDelete,
+  parseMask,
+  useInputMask
+};

package/dist/composables/useLocale.d.ts

@@ -0,0 +1,2 @@
+import { type ComputedRef, type MaybeRefOrGetter } from "vue";
+export declare function useLocale(own?: MaybeRefOrGetter<string | undefined>): ComputedRef<string | undefined>;

package/dist/composables/useLocale.js

@@ -0,0 +1,9 @@
+import { computed, toValue } from "vue";
+import { injectConfigProviderContext } from "reka-ui";
+function useLocale(own) {
+  const context = injectConfigProviderContext({});
+  return computed(() => toValue(own) || context.locale?.value || void 0);
+}
+export {
+  useLocale
+};

package/dist/composables/usePaintSelect.d.ts

@@ -0,0 +1,22 @@
+import { type MaybeRefOrGetter, type Ref } from "vue";
+import { type HotkeyHelp } from "./useHotkeys";
+export interface UsePaintSelectOptions<K> {
+    /** The element that holds the items. */
+    root: Ref<HTMLElement | null>;
+    selection: () => readonly K[];
+    set: (keys: K[]) => void;
+    /** Turn painting off without unmounting (e.g. selection mode is off). */
+    enabled?: MaybeRefOrGetter<boolean>;
+    /** Map an item's `data-paint-key` back to its key. Defaults to the string itself. */
+    resolve?: (raw: string) => K | undefined;
+    /** Every key, for Ctrl+A while the focus is inside `root`. Omit to leave Ctrl+A alone. */
+    selectAll?: () => K[];
+    /** How Ctrl+A is listed in the shortcuts reference. */
+    help?: MaybeRefOrGetter<HotkeyHelp | undefined>;
+}
+export declare function usePaintSelect<K = string>(options: UsePaintSelectOptions<K>): {
+    onPointerDown: (event: PointerEvent, key: K, behaviour?: {
+        hold?: number;
+    }) => void;
+    painting: Readonly<Ref<boolean, boolean>>;
+};