@leavepulse/ui 0.43.4 → 0.45.0

package/dist/composables/useHotkeys.js

@@ -1,7 +1,13 @@
-import { shallowReactive, computed, toValue, onMounted, onBeforeUnmount } 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 appleModifierLabel(key) {
-  if (!isAppleKeyboard) return key;
+function useAppleKeyboard() {
+  const apple = ref(false);
+  onMounted(() => apple.value = isAppleKeyboard);
+  return apple;
+}
+function appleModifierLabel(key, apple = isAppleKeyboard) {
+  if (!apple) return key;
   if (key === "Ctrl") return "⌘";
   if (key === "Alt") return "⌥";
   return key;
@@ -24,59 +30,182 @@ function isTextEntry(target) {
   }
   return false;
 }
-function matches(event, binding) {
+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;
-  if (ctrlHeld !== Boolean(binding.ctrl)) return false;
-  if (event.shiftKey !== Boolean(binding.shift)) return false;
-  if (event.altKey !== Boolean(binding.alt)) return false;
-  return event.key.toLowerCase() === binding.key.toLowerCase() || binding.code !== void 0 && event.code === binding.code;
-}
-const mounted = shallowReactive(/* @__PURE__ */ new Set());
-let mountOrder = 0;
-let listening = false;
+  const wantsCtrl = Boolean(binding.ctrl) || key === "control" || key === "meta";
+  if (ctrlHeld !== wantsCtrl) return false;
+  const symbol = key.length === 1 && key.toLowerCase() === key.toUpperCase();
+  const shiftFree = key === "shift" || binding.shift === void 0 && symbol;
+  if (!shiftFree && event.shiftKey !== Boolean(binding.shift)) return false;
+  if (key !== "alt" && event.altKey !== Boolean(binding.alt)) return false;
+  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] ??= {
+  mounted: shallowReactive(/* @__PURE__ */ new Set()),
+  order: 0,
+  listening: false
+};
+const mounted = state.mounted;
 function inScope(target, scope) {
   const el = toValue(scope);
   if (!el) return true;
   const node = target instanceof Node ? target : null;
   return !!node && (el === node || el.contains(node));
 }
-function onKeydown(event) {
-  if (event.isComposing) return;
+function topLayer() {
+  const layers = document.querySelectorAll("[data-dismissable-layer]");
+  return layers[layers.length - 1] ?? null;
+}
+function insideOf(entry, layer) {
+  const scope = toValue(entry.scope);
+  const node = scope ?? entry.host();
+  return !!node && layer.contains(node);
+}
+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);
     for (const binding of entry.read()) {
       if (inTextEntry && !binding.allowInInput) continue;
-      if (!matches(event, binding)) continue;
-      if (binding.handler(event) === false) continue;
+      if (event.repeat && binding.repeat === false) continue;
+      if (covered && !binding.overLayers) 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();
   const entry = {
     read: () => toValue(bindings),
     scope: options.scope,
     enabled: options.enabled,
     priority: options.priority,
-    order: ++mountOrder
+    order: ++state.order,
+    host: () => {
+      const el = instance?.vnode.el;
+      return el instanceof Node ? el : null;
+    }
   };
   onMounted(() => {
     mounted.add(entry);
-    if (!listening) {
+    warnConflicts();
+    if (!state.listening) {
       window.addEventListener("keydown", onKeydown);
-      listening = true;
+      window.addEventListener("blur", resetSequence);
+      state.listening = true;
     }
   });
   onBeforeUnmount(() => {
     mounted.delete(entry);
-    if (!mounted.size && listening) {
+    if (!mounted.size && state.listening) {
       window.removeEventListener("keydown", onKeydown);
-      listening = false;
+      window.removeEventListener("blur", resetSequence);
+      state.listening = false;
+      resetSequence();
     }
   });
 }
@@ -92,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);
     }
   }
@@ -127,7 +318,14 @@ function mergeShortcutGroups(...lists) {
 export {
   activeShortcuts,
   appleModifierLabel,
+  findHotkeyConflicts,
+  hotkeyConflicts,
+  hotkeySteps,
   isAppleKeyboard,
+  matchesHotkey,
   mergeShortcutGroups,
+  pendingHotkey,
+  sequenceProgress,
+  useAppleKeyboard,
   useHotkeys
 };

package/dist/composables/useInputFilter.d.ts

@@ -5,9 +5,26 @@ export interface UseInputFilterOptions {
     /** RegExp/string the full value must match to be valid. Validation only. */
     pattern?: MaybeRefOrGetter<RegExp | string | undefined>;
 }
+/**
+ * Anchor a pattern to the whole string, like HTML's `pattern` attribute. The
+ * source is wrapped, never edited: anchors the caller wrote stay valid inside
+ * the group, while trimming a trailing `$` broke an escaped `\$` into an
+ * unterminated group.
+ */
+export declare function anchorPattern(p: RegExp | string): RegExp;
+/**
+ * `text` with every disallowed character removed, and where `caret` lands once
+ * the characters before it that were removed are gone.
+ */
+export declare function stripDisallowed(text: string, charRe: RegExp, caret?: number): {
+    text: string;
+    caret: number;
+};
 export declare function useInputFilter(options?: UseInputFilterOptions): {
     isInvalid: (value: string | undefined) => boolean;
     onBeforeInput: (event: InputEvent) => void;
+    onInput: (event: Event) => void;
+    onCompositionEnd: (event: CompositionEvent) => void;
     onPaste: (event: ClipboardEvent) => void;
     patternRe: import("vue").ComputedRef<RegExp | undefined>;
     restrict: import("vue").ComputedRef<RegExp | undefined>;

package/dist/composables/useInputFilter.js

@@ -1,23 +1,38 @@
 import { computed, toValue } from "vue";
-function toAnchored(p) {
-  if (p instanceof RegExp) {
-    const src = p.source.replace(/^\^/, "").replace(/\$$/, "");
-    return new RegExp(`^(?:${src})$`, p.flags.replace(/[gy]/g, ""));
-  }
+function anchorPattern(p) {
+  if (p instanceof RegExp) return new RegExp(`^(?:${p.source})$`, p.flags.replace(/[gy]/g, ""));
   return new RegExp(`^(?:${p})$`);
 }
-function allAllowed(text, charRe) {
+function charTester(charRe) {
   const re = new RegExp(charRe.source, charRe.flags.replace(/[gy]/g, ""));
+  return (ch) => re.test(ch);
+}
+function allAllowed(text, charRe) {
+  const ok = charTester(charRe);
   for (const ch of text) {
-    if (!re.test(ch)) return false;
+    if (!ok(ch)) return false;
   }
   return true;
 }
+function stripDisallowed(text, charRe, caret = text.length) {
+  const ok = charTester(charRe);
+  let kept = "";
+  let at = 0;
+  let offset = 0;
+  for (const ch of text) {
+    if (ok(ch)) {
+      kept += ch;
+      if (offset < caret) at += ch.length;
+    }
+    offset += ch.length;
+  }
+  return { text: kept, caret: at };
+}
 function useInputFilter(options = {}) {
   const restrict = computed(() => toValue(options.restrict));
   const patternRe = computed(() => {
     const p = toValue(options.pattern);
-    return p === void 0 ? void 0 : toAnchored(p);
+    return p === void 0 ? void 0 : anchorPattern(p);
   });
   function isInvalid(value) {
     const re = patternRe.value;
@@ -27,18 +42,40 @@ function useInputFilter(options = {}) {
   function onBeforeInput(event) {
     const re = restrict.value;
     if (!re || event.isComposing) return;
-    const data = event.data;
+    const data = event.data ?? event.dataTransfer?.getData("text") ?? null;
     if (data == null) return;
     if (!allAllowed(data, re)) event.preventDefault();
   }
+  function sanitize(target) {
+    const re = restrict.value;
+    if (!re) return false;
+    if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) return false;
+    const { text, caret } = stripDisallowed(target.value, re, target.selectionStart ?? target.value.length);
+    if (text === target.value) return false;
+    target.value = text;
+    try {
+      target.setSelectionRange(caret, caret);
+    } catch {
+    }
+    return true;
+  }
+  function onInput(event) {
+    if (event.isComposing) return;
+    sanitize(event.target);
+  }
+  function onCompositionEnd(event) {
+    if (sanitize(event.target)) event.target?.dispatchEvent(new Event("input", { bubbles: true }));
+  }
   function onPaste(event) {
     const re = restrict.value;
     if (!re) return;
     const text = event.clipboardData?.getData("text") ?? "";
     if (text && !allAllowed(text, re)) event.preventDefault();
   }
-  return { isInvalid, onBeforeInput, onPaste, patternRe, restrict };
+  return { isInvalid, onBeforeInput, onInput, onCompositionEnd, onPaste, patternRe, restrict };
 }
 export {
+  anchorPattern,
+  stripDisallowed,
   useInputFilter
 };

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/useLpConfig.d.ts

@@ -0,0 +1,24 @@
+import { type App, type Component, type ComputedRef, type InjectionKey, type MaybeRefOrGetter } from "vue";
+export type LabelScope = Record<string, string>;
+export interface LpConfig {
+    /** Component rendered for internal links (RouterLink, NuxtLink). Plain `<a>` when unset. */
+    linkComponent?: Component | string;
+    /** Text overrides by scope: `{ lightbox: { previous: "Back" } }`. */
+    labels?: Partial<Record<string, Partial<LabelScope>>>;
+}
+export declare const LP_CONFIG: InjectionKey<MaybeRefOrGetter<LpConfig>>;
+/** Provide kit configuration to every component below the caller. */
+export declare function provideLpConfig(config: MaybeRefOrGetter<LpConfig>): void;
+/** Install the configuration app-wide: `app.use(lpConfig({ ... }))`. */
+export declare function lpConfig(config: MaybeRefOrGetter<LpConfig>): {
+    install: (app: App) => void;
+};
+export declare function mergeConfig(outer: LpConfig, inner: LpConfig): LpConfig;
+export declare function useLpConfig(): ComputedRef<LpConfig>;
+/**
+ * The labels a component renders: its own `labels` prop over the configured
+ * scope over its defaults.
+ */
+export declare function useLabels<T extends LabelScope>(scope: string, defaults: T, own?: () => Partial<T> | undefined): ComputedRef<T>;
+/** The link component to render for an internal destination. */
+export declare function useLinkComponent(): ComputedRef<Component | string>;