@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/chunks/Tones-DSlTgkaB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tones-DSlTgkaB.js","sources":["../../src/foundation/styles/constants/Tones.ts"],"sourcesContent":["import type { Tone } from '../enums/StyleTokens';\n\n/* Contains the (variant-family × tone) → Tailwind class lookup shared between\n   `surfaceVariants` and `buttonVariants` (and any future variant config). */\n\n/** Defines a tone-family — the variant group that picks the same bg/border/text palette. */\nexport const ToneFamily = {\n  /** Refers to an opaque tone bg + foreground. */\n  Solid: 'solid',\n  /** Refers to a muted/tinted bg + tone-readable foreground. */\n  Soft: 'soft',\n  /** Refers to a popover bg + tone-accent border. */\n  Surface: 'surface',\n  /** Refers to a transparent bg, tone border + tone text. */\n  Outline: 'outline',\n  /** Refers to a translucent tone bg + blur. */\n  Glass: 'glass',\n  /** Refers to a glass fill + tone-accent border at 50% alpha. */\n  GlassOutline: 'glassOutline',\n  /** Refers to a low-alpha tinted fill + neutral border, no shadow. */\n  Subtle: 'subtle',\n} as const;\n\nexport type ToneFamily = (typeof ToneFamily)[keyof typeof ToneFamily];\n\n/** Contains the cross-engine palette: bg / text (+ border where applicable) per tone-family × tone. */\nexport const Tones: Record<ToneFamily, Record<Tone, string>> = {\n  /** Opaque tone bg + foreground. Used by `solid`, `elevated`, `flat`, button defaults. */\n  solid: {\n    neutral: 'bg-popover text-popover-foreground',\n    primary: 'bg-primary text-primary-foreground',\n    danger: 'bg-destructive text-destructive-foreground',\n    success: 'bg-success text-success-foreground',\n    warning: 'bg-warning text-warning-foreground',\n    info: 'bg-info text-info-foreground',\n  },\n  /**\n   * Muted/tinted bg + tone-readable foreground.\n   *\n   * Pairs `bg-{tone}-soft` with `text-{tone}-soft-foreground`, the token minted for\n   * exactly this background — `themes/Validate.ts` asserts that pair at AA. The\n   * full-strength `text-{tone}` is a *solid*-fill foreground: on the soft tint it\n   * measured 2.07:1 for `warning` and 3.15:1 for `success`.\n   */\n  soft: {\n    neutral: 'bg-muted text-foreground',\n    primary: 'bg-primary-soft text-primary-soft-foreground',\n    danger: 'bg-destructive-soft text-destructive-soft-foreground',\n    success: 'bg-success-soft text-success-soft-foreground',\n    warning: 'bg-warning-soft text-warning-soft-foreground',\n    info: 'bg-info-soft text-info-soft-foreground',\n  },\n  /** Popover bg + tone-accent border. The \"default\" subtle look. */\n  surface: {\n    neutral: 'border-border bg-popover text-popover-foreground',\n    primary: 'border-primary/40 bg-popover text-popover-foreground',\n    danger: 'border-destructive/40 bg-popover text-popover-foreground',\n    success: 'border-success/40 bg-popover text-popover-foreground',\n    warning: 'border-warning/40 bg-popover text-popover-foreground',\n    info: 'border-info/40 bg-popover text-popover-foreground',\n  },\n  /**\n   * Transparent bg, tone border + tone text.\n   *\n   * The fill is transparent, so the text lands on whatever surface hosts the\n   * component — the same situation `-soft-foreground` is toned for. Keeping the\n   * border at full-strength `{tone}` preserves the tone read; only the text\n   * darkens (light) / lightens (dark). Full-strength `text-{tone}` measured\n   * 2.15:1 for `warning` on the default light background.\n   */\n  outline: {\n    neutral: 'border-border text-foreground',\n    primary: 'border-primary text-primary-soft-foreground',\n    danger: 'border-destructive text-destructive-soft-foreground',\n    success: 'border-success text-success-soft-foreground',\n    warning: 'border-warning text-warning-soft-foreground',\n    info: 'border-info text-info-soft-foreground',\n  },\n  /**\n   * Translucent fills use soft foregrounds, verified over background/card/popover/muted.\n   * Custom colors and image backdrops require contrast verification by the caller.\n   */\n  glass: {\n    neutral: 'bg-popover/70 text-popover-foreground',\n    primary: 'bg-primary/30 text-primary-soft-foreground',\n    danger: 'bg-destructive/30 text-destructive-soft-foreground',\n    success: 'bg-success/30 text-success-soft-foreground',\n    warning: 'bg-warning/30 text-warning-soft-foreground',\n    info: 'bg-info/30 text-info-soft-foreground',\n  },\n  /** Glass + tone-accent border at 50% alpha. Same foreground reasoning as `glass`. */\n  glassOutline: {\n    neutral: 'border-border/50 bg-popover/70 text-popover-foreground',\n    primary: 'border-primary/50 bg-primary/30 text-primary-soft-foreground',\n    danger: 'border-destructive/50 bg-destructive/30 text-destructive-soft-foreground',\n    success: 'border-success/50 bg-success/30 text-success-soft-foreground',\n    warning: 'border-warning/50 bg-warning/30 text-warning-soft-foreground',\n    info: 'border-info/50 bg-info/30 text-info-soft-foreground',\n  },\n  /**\n   * Low-alpha tinted fill + neutral `border-border`, no shadow. The understated\n   * \"tinted panel / section band\" look — quieter than `soft`, flatter than `surface`.\n   * Neutral fills from the muted token; coloured tones tint their `-soft` token at low alpha.\n   */\n  subtle: {\n    neutral: 'border-border bg-muted/30 text-foreground',\n    primary: 'border-primary/20 bg-primary-soft/60 text-foreground',\n    danger: 'border-destructive/20 bg-destructive-soft/60 text-foreground',\n    success: 'border-success/20 bg-success-soft/60 text-foreground',\n    warning: 'border-warning/20 bg-warning-soft/60 text-foreground',\n    info: 'border-info/20 bg-info-soft/60 text-foreground',\n  },\n};\n"],"names":[],"mappings":"AAMO,MAAM,aAAa;AAAA;AAAA,EAExB,OAAO;AAAA;AAAA,EAEP,MAAM;AAAA;AAAA,EAEN,SAAS;AAAA;AAAA,EAET,SAAS;AAAA;AAAA,EAET,OAAO;AAAA;AAAA,EAEP,cAAc;AAAA;AAAA,EAEd,QAAQ;AACV;AAKO,MAAM,QAAkD;AAAA;AAAA,EAE7D,OAAO;AAAA,IACL,SAAS;AAAA,IACT,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,SAAS;AAAA,IACT,MAAM;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUR,MAAM;AAAA,IACJ,SAAS;AAAA,IACT,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,SAAS;AAAA,IACT,MAAM;AAAA,EAAA;AAAA;AAAA,EAGR,SAAS;AAAA,IACP,SAAS;AAAA,IACT,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,SAAS;AAAA,IACT,MAAM;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWR,SAAS;AAAA,IACP,SAAS;AAAA,IACT,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,SAAS;AAAA,IACT,MAAM;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMR,OAAO;AAAA,IACL,SAAS;AAAA,IACT,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,SAAS;AAAA,IACT,MAAM;AAAA,EAAA;AAAA;AAAA,EAGR,cAAc;AAAA,IACZ,SAAS;AAAA,IACT,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,SAAS;AAAA,IACT,MAAM;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOR,QAAQ;AAAA,IACN,SAAS;AAAA,IACT,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,SAAS;AAAA,IACT,MAAM;AAAA,EAAA;AAEV;"}

package/dist/chunks/TransitionExtensions-HyBfcJnn.js

@@ -0,0 +1,19 @@
+const DefaultDurationMs = 200;
+function resolveDuration(d) {
+  if (typeof d === "number") return { enter: d, exit: d };
+  if (d && typeof d === "object") {
+    return {
+      enter: d.enter ?? DefaultDurationMs,
+      exit: d.exit ?? DefaultDurationMs
+    };
+  }
+  return { enter: DefaultDurationMs, exit: DefaultDurationMs };
+}
+const TransitionExtensions = {
+  resolveDuration,
+  duration: { default: DefaultDurationMs }
+};
+export {
+  TransitionExtensions as T
+};
+//# sourceMappingURL=TransitionExtensions-HyBfcJnn.js.map

package/dist/chunks/TransitionExtensions-HyBfcJnn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransitionExtensions-HyBfcJnn.js","sources":["../../src/foundation/animation/TransitionExtensions.ts"],"sourcesContent":["/* Transition / animation utility extensions — duration normalization, defaults. */\n\n// =============================================================================\n// Types — presence-style asymmetric durations (enter/exit). Not every animation\n// has an enter/exit phase (loops, one-shots, springs); this shape applies\n// specifically to mount/unmount or appear/disappear transitions.\n// =============================================================================\n\n/** Input prop — symmetric number OR asymmetric `{ enter, exit }`. */\nexport type PresenceAnimationDurationProp = number | { enter?: number; exit?: number };\n\n/** Resolved (canonical) — both sides always present. */\nexport interface PresenceAnimationDuration {\n  enter: number;\n  exit: number;\n}\n\n// =============================================================================\n// Defaults\n// =============================================================================\n\nconst DefaultDurationMs = 200;\n\n// =============================================================================\n// Internal resolvers\n// =============================================================================\n\nfunction resolveDuration(d: PresenceAnimationDurationProp | undefined): PresenceAnimationDuration {\n  if (typeof d === 'number') return { enter: d, exit: d };\n  if (d && typeof d === 'object') {\n    return {\n      enter: d.enter ?? DefaultDurationMs,\n      exit: d.exit ?? DefaultDurationMs,\n    };\n  }\n  return { enter: DefaultDurationMs, exit: DefaultDurationMs };\n}\n\n// =============================================================================\n// Grouped namespace export\n// =============================================================================\n\nexport const TransitionExtensions = {\n  resolveDuration,\n  duration: { default: DefaultDurationMs },\n} as const;\n"],"names":[],"mappings":"AAqBA,MAAM,oBAAoB;AAM1B,SAAS,gBAAgB,GAAyE;AAChG,MAAI,OAAO,MAAM,SAAU,QAAO,EAAE,OAAO,GAAG,MAAM,EAAA;AACpD,MAAI,KAAK,OAAO,MAAM,UAAU;AAC9B,WAAO;AAAA,MACL,OAAO,EAAE,SAAS;AAAA,MAClB,MAAM,EAAE,QAAQ;AAAA,IAAA;AAAA,EAEpB;AACA,SAAO,EAAE,OAAO,mBAAmB,MAAM,kBAAA;AAC3C;AAMO,MAAM,uBAAuB;AAAA,EAClC;AAAA,EACA,UAAU,EAAE,SAAS,kBAAA;AACvB;"}

package/dist/chunks/UrlExtensions-DqgLm0KY.js

@@ -0,0 +1,46 @@
+const NavigationProtocols = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:"]);
+const ResourceProtocols = /* @__PURE__ */ new Set(["http:", "https:", "blob:"]);
+const ParserBase = "https://url-validation.invalid/";
+function decodeReferences(value) {
+  return value.replace(/&(#x[\da-f]+|#\d+|colon|tab|newline|amp);?/gi, (match, reference) => {
+    const name = reference.toLowerCase();
+    if (name === "colon") return ":";
+    if (name === "tab") return "	";
+    if (name === "newline") return "\n";
+    if (name === "amp") return "&";
+    const point = name.startsWith("#x") ? Number.parseInt(name.slice(2), 16) : Number.parseInt(name.slice(1), 10);
+    return Number.isFinite(point) && point > 0 && point <= 1114111 ? String.fromCodePoint(point) : match;
+  });
+}
+function selectSafeUrl(value, protocols) {
+  if (typeof value !== "string") return void 0;
+  if ([...value].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) return void 0;
+  let candidate = value.trim();
+  for (let pass = 0; pass < 4; pass += 1) {
+    const decoded = decodeReferences(candidate);
+    if (decoded === candidate) break;
+    candidate = decoded;
+  }
+  if (/&(?:#|colon|tab|newline|amp)/i.test(candidate)) return void 0;
+  if ([...candidate].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) {
+    return void 0;
+  }
+  try {
+    const parsed = new URL(candidate, ParserBase);
+    return protocols.has(parsed.protocol) ? candidate : void 0;
+  } catch {
+    return void 0;
+  }
+}
+const UrlExtensions = {
+  safeNavigation(value) {
+    return selectSafeUrl(value, NavigationProtocols);
+  },
+  safeResource(value) {
+    return selectSafeUrl(value, ResourceProtocols);
+  }
+};
+export {
+  UrlExtensions as U
+};
+//# sourceMappingURL=UrlExtensions-DqgLm0KY.js.map

package/dist/chunks/UrlExtensions-DqgLm0KY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UrlExtensions-DqgLm0KY.js","sources":["../../src/foundation/dom/UrlExtensions.ts"],"sourcesContent":["const NavigationProtocols = new Set(['http:', 'https:', 'mailto:', 'tel:']);\nconst ResourceProtocols = new Set(['http:', 'https:', 'blob:']);\nconst ParserBase = 'https://url-validation.invalid/';\n\n/** Decodes scheme-relevant HTML references before URL policy checks. */\nfunction decodeReferences(value: string): string {\n  return value.replace(/&(#x[\\da-f]+|#\\d+|colon|tab|newline|amp);?/gi, (match, reference: string) => {\n    const name = reference.toLowerCase();\n    if (name === 'colon') return ':';\n    if (name === 'tab') return '\\t';\n    if (name === 'newline') return '\\n';\n    if (name === 'amp') return '&';\n    const point = name.startsWith('#x') ? Number.parseInt(name.slice(2), 16) : Number.parseInt(name.slice(1), 10);\n    return Number.isFinite(point) && point > 0 && point <= 0x10ffff ? String.fromCodePoint(point) : match;\n  });\n}\n\nfunction selectSafeUrl(value: unknown, protocols: ReadonlySet<string>): string | undefined {\n  if (typeof value !== 'string') return undefined;\n  if ([...value].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) return undefined;\n  let candidate = value.trim();\n  // A Markdown/HTML pipeline may have decoded one layer already. Normalize a bounded number;\n  // unresolved references are rejected so additional downstream decoding cannot alter the scheme.\n  for (let pass = 0; pass < 4; pass += 1) {\n    const decoded = decodeReferences(candidate);\n    if (decoded === candidate) break;\n    candidate = decoded;\n  }\n  if (/&(?:#|colon|tab|newline|amp)/i.test(candidate)) return undefined;\n  if ([...candidate].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) {\n    return undefined;\n  }\n  try {\n    const parsed = new URL(candidate, ParserBase);\n    return protocols.has(parsed.protocol) ? candidate : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Selects a URL only when its parsed scheme is allowed at the corresponding DOM boundary. */\nexport const UrlExtensions = {\n  safeNavigation(value: unknown): string | undefined {\n    return selectSafeUrl(value, NavigationProtocols);\n  },\n  safeResource(value: unknown): string | undefined {\n    return selectSafeUrl(value, ResourceProtocols);\n  },\n} as const;\n"],"names":[],"mappings":"AAAA,MAAM,0CAA0B,IAAI,CAAC,SAAS,UAAU,WAAW,MAAM,CAAC;AAC1E,MAAM,oBAAoB,oBAAI,IAAI,CAAC,SAAS,UAAU,OAAO,CAAC;AAC9D,MAAM,aAAa;AAGnB,SAAS,iBAAiB,OAAuB;AAC/C,SAAO,MAAM,QAAQ,gDAAgD,CAAC,OAAO,cAAsB;AACjG,UAAM,OAAO,UAAU,YAAA;AACvB,QAAI,SAAS,QAAS,QAAO;AAC7B,QAAI,SAAS,MAAO,QAAO;AAC3B,QAAI,SAAS,UAAW,QAAO;AAC/B,QAAI,SAAS,MAAO,QAAO;AAC3B,UAAM,QAAQ,KAAK,WAAW,IAAI,IAAI,OAAO,SAAS,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,OAAO,SAAS,KAAK,MAAM,CAAC,GAAG,EAAE;AAC5G,WAAO,OAAO,SAAS,KAAK,KAAK,QAAQ,KAAK,SAAS,UAAW,OAAO,cAAc,KAAK,IAAI;AAAA,EAClG,CAAC;AACH;AAEA,SAAS,cAAc,OAAgB,WAAoD;AACzF,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,MAAI,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,cAAc,UAAU,WAAW,CAAC,IAAI,MAAM,UAAU,WAAW,CAAC,MAAM,GAAG,EAAG,QAAO;AAC5G,MAAI,YAAY,MAAM,KAAA;AAGtB,WAAS,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG;AACtC,UAAM,UAAU,iBAAiB,SAAS;AAC1C,QAAI,YAAY,UAAW;AAC3B,gBAAY;AAAA,EACd;AACA,MAAI,gCAAgC,KAAK,SAAS,EAAG,QAAO;AAC5D,MAAI,CAAC,GAAG,SAAS,EAAE,KAAK,CAAC,cAAc,UAAU,WAAW,CAAC,IAAI,MAAM,UAAU,WAAW,CAAC,MAAM,GAAG,GAAG;AACvG,WAAO;AAAA,EACT;AACA,MAAI;AACF,UAAM,SAAS,IAAI,IAAI,WAAW,UAAU;AAC5C,WAAO,UAAU,IAAI,OAAO,QAAQ,IAAI,YAAY;AAAA,EACtD,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAGO,MAAM,gBAAgB;AAAA,EAC3B,eAAe,OAAoC;AACjD,WAAO,cAAc,OAAO,mBAAmB;AAAA,EACjD;AAAA,EACA,aAAa,OAAoC;AAC/C,WAAO,cAAc,OAAO,iBAAiB;AAAA,EAC/C;AACF;"}

package/dist/chunks/UseClipboard-x6nEdQ9f.js

@@ -0,0 +1,230 @@
+import { shallowRef, onScopeDispose, toValue } from "vue";
+import { t as toError } from "./ToError-vXncXe19.js";
+import { A as AriaAttribute } from "./AriaAttribute-CmUjjXjp.js";
+function nameOf(value) {
+  try {
+    if (typeof value !== "object" || value === null) return void 0;
+    const name = value.name;
+    return typeof name === "string" ? name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isPermissionRefusal(value) {
+  const name = nameOf(value);
+  return name === "NotAllowedError" || name === "SecurityError";
+}
+function toClipboardFailure(error) {
+  const failure = toError(error);
+  return isPermissionRefusal(error) ? { status: "denied", error: failure } : { status: "failed", error: failure };
+}
+function reportClipboardOutcome(result, onError) {
+  if (onError === void 0) return result;
+  if (result.ok || !("error" in result.failure)) return result;
+  try {
+    onError(result.failure.error);
+  } catch {
+  }
+  return result;
+}
+function member(source, key) {
+  try {
+    return source[key];
+  } catch {
+    return void 0;
+  }
+}
+function clipboardApi() {
+  try {
+    if (typeof navigator === "undefined") return void 0;
+    const clipboard = member(navigator, "clipboard");
+    if (typeof clipboard !== "object" || clipboard === null) return void 0;
+    return clipboard;
+  } catch {
+    return void 0;
+  }
+}
+const ClipboardMethodName = {
+  /** Names `clipboard.writeText` — the plain-text write, implemented in every engine with a clipboard. */
+  WriteText: "writeText",
+  /** Names `clipboard.write` — the `ClipboardItem` write, for images and multi-flavour payloads. */
+  Write: "write",
+  /** Names `clipboard.readText` — the plain-text read. */
+  ReadText: "readText"
+};
+function clipboardMethod(name) {
+  const clipboard = clipboardApi();
+  if (clipboard === void 0) return void 0;
+  const method = member(clipboard, name);
+  if (typeof method !== "function") return void 0;
+  try {
+    return method.bind(clipboard);
+  } catch {
+    return void 0;
+  }
+}
+function clipboardItemConstructor() {
+  try {
+    const constructor = member(globalThis, "ClipboardItem");
+    if (typeof constructor !== "function") return void 0;
+    return constructor;
+  } catch {
+    return void 0;
+  }
+}
+function canCopy() {
+  return clipboardMethod(ClipboardMethodName.WriteText) !== void 0;
+}
+function canCopyItems() {
+  return clipboardMethod(ClipboardMethodName.Write) !== void 0 && clipboardItemConstructor() !== void 0;
+}
+function canReadClipboard() {
+  return clipboardMethod(ClipboardMethodName.ReadText) !== void 0;
+}
+function canLegacyCopy() {
+  try {
+    if (typeof document === "undefined") return false;
+    return typeof member(document, "execCommand") === "function";
+  } catch {
+    return false;
+  }
+}
+const HiddenTextareaCss = "position:fixed;top:0;left:0;width:1px;height:1px;padding:0;margin:0;border:none;outline:none;box-shadow:none;background:transparent;opacity:0;pointer-events:none;";
+function restoreFocus(previous) {
+  try {
+    if (previous === null) return;
+    const focus = previous.focus;
+    if (typeof focus !== "function") return;
+    previous.focus({ preventScroll: true });
+  } catch {
+  }
+}
+function detach(element) {
+  try {
+    if (typeof element.remove === "function") {
+      element.remove();
+      return;
+    }
+    element.parentNode?.removeChild(element);
+  } catch {
+  }
+}
+function legacyCopyText(text) {
+  if (!canLegacyCopy()) return { ok: false, failure: { status: "unsupported" } };
+  let element;
+  let previouslyFocused = null;
+  try {
+    const body = document.body;
+    if (typeof body !== "object" || body === null) return { ok: false, failure: { status: "unsupported" } };
+    previouslyFocused = document.activeElement;
+    element = document.createElement("textarea");
+    element.value = text;
+    element.setAttribute(AriaAttribute.Hidden, "true");
+    element.setAttribute("tabindex", "-1");
+    element.setAttribute("readonly", "readonly");
+    element.style.cssText = HiddenTextareaCss;
+    body.appendChild(element);
+    element.focus({ preventScroll: true });
+    element.select();
+    element.setSelectionRange(0, text.length);
+    const copied = document.execCommand("copy");
+    return copied ? { ok: true, value: void 0 } : {
+      ok: false,
+      failure: { status: "failed", error: new Error('document.execCommand("copy") reported failure.') }
+    };
+  } catch (error) {
+    return { ok: false, failure: toClipboardFailure(error) };
+  } finally {
+    if (element !== void 0) detach(element);
+    restoreFocus(previouslyFocused);
+  }
+}
+function withLegacyFallback(modern, text, options) {
+  if (modern.ok) return modern;
+  if (options?.legacyFallback !== true) return modern;
+  if (text === void 0) return modern;
+  const legacy = legacyCopyText(text);
+  if (legacy.ok) return legacy;
+  return modern.failure.status === "unsupported" ? legacy : modern;
+}
+async function writeTextThroughApi(text) {
+  const writeText = clipboardMethod("writeText");
+  if (writeText === void 0) return { ok: false, failure: { status: "unsupported" } };
+  try {
+    await writeText(text);
+    return { ok: true, value: void 0 };
+  } catch (error) {
+    return { ok: false, failure: toClipboardFailure(error) };
+  }
+}
+async function copyText(text, options) {
+  try {
+    if (typeof text !== "string") {
+      return reportClipboardOutcome(
+        { ok: false, failure: { status: "failed", error: new TypeError("copyText expects a string.") } },
+        options?.onError
+      );
+    }
+    const result = withLegacyFallback(await writeTextThroughApi(text), text, options);
+    return reportClipboardOutcome(result, options?.onError);
+  } catch (error) {
+    return reportClipboardOutcome({ ok: false, failure: toClipboardFailure(error) }, options?.onError);
+  }
+}
+function useClipboard({ resetAfter = 2e3 } = {}) {
+  const copied = shallowRef(false);
+  const error = shallowRef(null);
+  let timeout = null;
+  let generation = 0;
+  let disposed = false;
+  const reset = () => {
+    generation++;
+    if (timeout) clearTimeout(timeout);
+    timeout = null;
+    copied.value = false;
+    error.value = null;
+  };
+  const copy = async (text) => {
+    const operation = ++generation;
+    if (timeout) clearTimeout(timeout);
+    timeout = null;
+    const result = await copyText(text);
+    if (disposed || operation !== generation) return result;
+    if (result.ok) {
+      error.value = null;
+      copied.value = true;
+      const resetWindow = toValue(resetAfter);
+      if (resetWindow > 0) {
+        if (timeout) clearTimeout(timeout);
+        timeout = setTimeout(() => {
+          timeout = null;
+          copied.value = false;
+        }, resetWindow);
+      }
+    } else {
+      copied.value = false;
+      error.value = result.failure.status === "unsupported" ? new Error("Clipboard is unavailable.") : result.failure.error;
+    }
+    return result;
+  };
+  onScopeDispose(() => {
+    disposed = true;
+    if (timeout) clearTimeout(timeout);
+  });
+  return { copied, error, copy, reset };
+}
+export {
+  clipboardItemConstructor as a,
+  copyText as b,
+  clipboardMethod as c,
+  canCopy as d,
+  canCopyItems as e,
+  canLegacyCopy as f,
+  canReadClipboard as g,
+  legacyCopyText as l,
+  reportClipboardOutcome as r,
+  toClipboardFailure as t,
+  useClipboard as u,
+  withLegacyFallback as w
+};
+//# sourceMappingURL=UseClipboard-x6nEdQ9f.js.map

package/dist/chunks/UseClipboard-x6nEdQ9f.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseClipboard-x6nEdQ9f.js","sources":["../../src/foundation/clipboard/ClipboardResult.ts","../../src/foundation/clipboard/ClipboardSupport.ts","../../src/foundation/clipboard/LegacyCopy.ts","../../src/foundation/clipboard/CopyText.ts","../../src/foundation/clipboard/hooks/UseClipboard.ts"],"sourcesContent":["import type { ClipboardFailure } from './models/ClipboardFailure';\nimport type { Result } from '../results';\n\nimport { toError } from '../errors';\nexport type { ClipboardFailure } from './models/ClipboardFailure';\nexport type { ClipboardWriteResult } from './models/ClipboardWriteResult';\n\n/** The `status` discriminant of a {@link ClipboardWriteResult} — for a consumer's own switch or status→copy map. */\nexport type ClipboardWriteStatus = 'copied' | ClipboardFailure['status'];\n\n/** One MIME-typed payload read off the system clipboard. */\nexport interface ClipboardReadItem {\n  /** The MIME type the platform reported — `text/plain`, `text/html`, `image/png`, … */\n  readonly type: string;\n\n  /** The payload itself. Read it with `blob.text()` for textual types, or hand it to `URL.createObjectURL`. */\n  readonly blob: Blob;\n}\nexport type { ClipboardReadTextResult } from './models/ClipboardReadTextResult';\nexport type { ClipboardReadItemsResult } from './models/ClipboardReadItemsResult';\n\n/** The `status` discriminant shared by both read results. */\nexport type ClipboardReadStatus = 'read' | ClipboardFailure['status'];\n\n/** Tunes a clipboard read. */\nexport interface ClipboardReadOptions {\n  /**\n   * Called with the normalized error on a `denied` or `failed` result — the seam for a toast or telemetry hook.\n   * Never called for `unsupported`, which is a capability fact rather than a failure. A throw from this callback\n   * is swallowed. Called at most once per operation, on the final result.\n   */\n  readonly onError?: (error: Error) => void;\n}\n\n/** Tunes a clipboard write. */\nexport interface ClipboardCopyOptions extends ClipboardReadOptions {\n  /**\n   * Whether a write the Clipboard API cannot complete retries through the deprecated\n   * `document.execCommand('copy')` path. Defaults to `false`.\n   *\n   * Opt in for reach — older Safari and any non-secure context have no `navigator.clipboard` at all, and\n   * `execCommand` is the only write available there. Leave it off to stay on standards-track APIs only. See\n   * `LegacyCopy.ts` for the deprecation caveats and for exactly when the retry runs.\n   */\n  readonly legacyFallback?: boolean;\n}\n\n/** The shape every result family shares, so one reporter can serve every entry point. */\ntype ClipboardOutcome = Result<unknown, ClipboardFailure>;\n\n/** Reads a caught value's `name` as a string. Guarded, so a throwing getter reads as absent. */\nfunction nameOf(value: unknown): string | undefined {\n  try {\n    if (typeof value !== 'object' || value === null) return undefined;\n    const name: unknown = (value as { name?: unknown }).name;\n    return typeof name === 'string' ? name : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Checks whether a caught value is the platform refusing rather than breaking — the split behind `denied`.\n * Exported for the sibling modules; absent from the barrel, where the statuses are the answer callers want.\n *\n * @param value The caught value.\n */\nexport function isPermissionRefusal(value: unknown): boolean {\n  const name = nameOf(value);\n  return name === 'NotAllowedError' || name === 'SecurityError';\n}\n\n/**\n * Turns a caught value into the `denied` or `failed` arm it belongs in. Serves reads and writes alike — the\n * returned {@link ClipboardFailure} is assignable to every result union in the slice. Exported for the sibling\n * modules; absent from the barrel. Never throws: `toError` is total.\n *\n * @param error The caught value.\n */\nexport function toClipboardFailure(error: unknown): ClipboardFailure {\n  const failure = toError(error);\n  return isPermissionRefusal(error) ? { status: 'denied', error: failure } : { status: 'failed', error: failure };\n}\n\n/**\n * Hands a consumer's callback the failure carried by `result`, absorbing a throw from the callback itself. A\n * reporter that throws must not convert a typed result into an unhandled rejection.\n *\n * Called once per entry point, on the FINAL result — so a write that degrades through the legacy fallback\n * reports the outcome the caller receives, not each intermediate attempt. Exported for the sibling modules;\n * absent from the barrel.\n *\n * @param result The outcome about to be returned.\n * @param onError The consumer's reporter, if they supplied one.\n * @returns `result`, unchanged — so a call site can `return reportClipboardOutcome(...)`.\n */\nexport function reportClipboardOutcome<TResult extends ClipboardOutcome>(\n  result: TResult,\n  onError: ((error: Error) => void) | undefined,\n): TResult {\n  if (onError === undefined) return result;\n  if (result.ok || !('error' in result.failure)) return result;\n\n  try {\n    onError(result.failure.error);\n  } catch {\n    // The consumer's own reporter failed. There is nothing useful left to do with that — the result still\n    // reaches the caller, which is the guarantee that matters.\n  }\n  return result;\n}\n","/** The `ClipboardItem` constructor, narrowed to the one overload this slice calls. */\nexport type ClipboardItemConstructor = new (items: Record<string, Blob>) => ClipboardItem;\n\n/** Reads a member off an object, guarded — a throwing getter reads as `undefined`. */\nfunction member(source: object, key: string): unknown {\n  try {\n    return (source as Record<string, unknown>)[key];\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Reads `navigator.clipboard` if it is there and usable. Guarded end-to-end; returns `undefined` under SSR.\n * Exported for the sibling modules; absent from the barrel.\n */\nexport function clipboardApi(): Clipboard | undefined {\n  try {\n    if (typeof navigator === 'undefined') return undefined;\n    const clipboard = member(navigator, 'clipboard');\n    if (typeof clipboard !== 'object' || clipboard === null) return undefined;\n    return clipboard as Clipboard;\n  } catch {\n    return undefined;\n  }\n}\n\n/** The Clipboard API methods this slice calls. */\nexport const ClipboardMethodName = {\n  /** Names `clipboard.writeText` — the plain-text write, implemented in every engine with a clipboard. */\n  WriteText: 'writeText',\n\n  /** Names `clipboard.write` — the `ClipboardItem` write, for images and multi-flavour payloads. */\n  Write: 'write',\n\n  /** Names `clipboard.readText` — the plain-text read. */\n  ReadText: 'readText',\n\n  /** Names `clipboard.read` — the `ClipboardItem` read. */\n  Read: 'read',\n} as const;\n\n/** The Clipboard API methods this slice calls. */\nexport type ClipboardMethodName = (typeof ClipboardMethodName)[keyof typeof ClipboardMethodName];\n\n/**\n * Resolves one of the Clipboard API's methods, bound to the clipboard object, or `undefined` when this engine\n * does not implement it. The single gate every operation passes through. Exported for the sibling modules;\n * absent from the barrel.\n *\n * Bound rather than returned bare: a caller invoking a detached `writeText` would lose its receiver and get a\n * `TypeError` (\"Illegal invocation\") from the real implementation.\n *\n * @param name The method to resolve — `writeText`, `write`, `readText`, or `read`.\n */\nexport function clipboardMethod<TName extends ClipboardMethodName>(name: TName): Clipboard[TName] | undefined {\n  const clipboard = clipboardApi();\n  if (clipboard === undefined) return undefined;\n\n  const method = member(clipboard, name);\n  if (typeof method !== 'function') return undefined;\n\n  try {\n    return (method as (...args: unknown[]) => unknown).bind(clipboard) as Clipboard[TName];\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Reads the `ClipboardItem` constructor, which multi-format writes need and which Node and older Safari lack.\n * Exported for the sibling modules; absent from the barrel.\n */\nexport function clipboardItemConstructor(): ClipboardItemConstructor | undefined {\n  try {\n    const constructor = member(globalThis, 'ClipboardItem');\n    if (typeof constructor !== 'function') return undefined;\n    return constructor as ClipboardItemConstructor;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Whether plain-text copying is available — `navigator.clipboard.writeText`.\n *\n * `false` under SSR, in a non-secure context, and on engines predating the Clipboard API. It does NOT predict\n * the permission: a copy can still come back `denied` if the call has no user gesture behind it. Treat it as\n * \"is the road there\", not \"will the trip succeed\".\n */\nexport function canCopy(): boolean {\n  return clipboardMethod(ClipboardMethodName.WriteText) !== undefined;\n}\n\n/**\n * Whether multi-format copying is available — `navigator.clipboard.write` plus a `ClipboardItem` constructor.\n * Strictly narrower than {@link canCopy}: every engine shipped `writeText` first.\n */\nexport function canCopyItems(): boolean {\n  return clipboardMethod(ClipboardMethodName.Write) !== undefined && clipboardItemConstructor() !== undefined;\n}\n\n/**\n * Whether reading from the clipboard is available — `navigator.clipboard.readText`.\n *\n * Returns `false` when the method is absent, including under SSR. Even where present,\n * reading remains subject to browser permission and user-activation requirements. If all you need is the payload the\n * user just pasted, do not read at all — handle the `paste` event with `getPasteItems`, which needs no\n * permission and no prompt.\n */\nexport function canReadClipboard(): boolean {\n  return clipboardMethod(ClipboardMethodName.ReadText) !== undefined;\n}\n\n/**\n * Whether the deprecated `document.execCommand('copy')` path is available — the only write that exists in a\n * non-secure context or on older Safari. Requires a document; `false` under SSR.\n *\n * A `true` here does not mean the copy will succeed: `execCommand` still requires the call to sit inside a user\n * gesture, and reports its own refusal by returning `false`.\n */\nexport function canLegacyCopy(): boolean {\n  try {\n    if (typeof document === 'undefined') return false;\n    return typeof member(document, 'execCommand') === 'function';\n  } catch {\n    return false;\n  }\n}\n","import { AriaAttribute } from '../dom';\nimport { toClipboardFailure, type ClipboardCopyOptions, type ClipboardWriteResult } from './ClipboardResult';\nimport { canLegacyCopy } from './ClipboardSupport';\n\n/** Off-screen but laid out — selection requires a rendered element, so `display: none` would copy nothing. */\nconst HiddenTextareaCss =\n  'position:fixed;top:0;left:0;width:1px;height:1px;padding:0;margin:0;border:none;outline:none;box-shadow:none;background:transparent;opacity:0;pointer-events:none;';\n\n/** Restores focus to whatever held it before the textarea took it. Guarded — a stand-in may have no `focus`. */\nfunction restoreFocus(previous: Element | null): void {\n  try {\n    if (previous === null) return;\n    const focus = (previous as { focus?: unknown }).focus;\n    if (typeof focus !== 'function') return;\n    (previous as HTMLElement).focus({ preventScroll: true });\n  } catch {\n    // The previously focused element is gone or refuses focus. Not worth failing a completed copy over.\n  }\n}\n\n/** Detaches the temporary textarea, preferring `remove()` and falling back to the parent. Never throws. */\nfunction detach(element: HTMLTextAreaElement): void {\n  try {\n    if (typeof element.remove === 'function') {\n      element.remove();\n      return;\n    }\n    element.parentNode?.removeChild(element);\n  } catch {\n    // Nothing further to try. The failure to detach must not mask the copy's own result.\n  }\n}\n\n/**\n * Copies `text` through the deprecated `document.execCommand('copy')` path.\n *\n * Synchronous, unlike every other write in this slice — `execCommand` is. Requires a user gesture: outside one\n * the command reports its own refusal by returning `false`, which surfaces here as `failed` (the legacy API has\n * no way to say \"denied\" specifically). Returns `unsupported` under SSR or where `execCommand` is gone.\n *\n * Exported for the sibling modules and for a consumer that wants the legacy path explicitly; the temporary\n * element is removed on every path, including a throw from `execCommand` itself.\n *\n * Never throws.\n *\n * @param text The text to place on the clipboard.\n * @deprecated Prefer `copyText`, which uses the Clipboard API and falls back here only on `legacyFallback: true`.\n */\nexport function legacyCopyText(text: string): ClipboardWriteResult {\n  if (!canLegacyCopy()) return { ok: false, failure: { status: 'unsupported' } };\n\n  let element: HTMLTextAreaElement | undefined;\n  let previouslyFocused: Element | null = null;\n\n  try {\n    const body: unknown = document.body;\n    if (typeof body !== 'object' || body === null) return { ok: false, failure: { status: 'unsupported' } };\n\n    previouslyFocused = document.activeElement;\n\n    element = document.createElement('textarea');\n    element.value = text;\n    element.setAttribute(AriaAttribute.Hidden, 'true');\n    element.setAttribute('tabindex', '-1');\n    element.setAttribute('readonly', 'readonly');\n    element.style.cssText = HiddenTextareaCss;\n\n    (body as HTMLElement).appendChild(element);\n\n    element.focus({ preventScroll: true });\n    element.select();\n    element.setSelectionRange(0, text.length);\n\n    const copied = document.execCommand('copy');\n    return copied\n      ? { ok: true, value: undefined }\n      : {\n          ok: false,\n          failure: { status: 'failed', error: new Error('document.execCommand(\"copy\") reported failure.') },\n        };\n  } catch (error) {\n    return { ok: false, failure: toClipboardFailure(error) };\n  } finally {\n    if (element !== undefined) detach(element);\n    restoreFocus(previouslyFocused);\n  }\n}\n\n/**\n * Retries a write that the Clipboard API could not complete through the legacy path, when the caller opted in.\n *\n * The retry runs whenever `modern` is not `copied` — not only on `unsupported`. A `denied` from\n * `navigator.clipboard` is exactly the case `execCommand` can still serve: the legacy command is gated on the\n * user gesture the call already sits in, not on the Clipboard API's permission.\n *\n * Which result wins:\n *  - the legacy attempt, when it copied — a success outranks any diagnosis;\n *  - otherwise `modern`, when the Clipboard API was actually present (its `denied` / `failed` is the more\n *    specific account of what went wrong);\n *  - otherwise the legacy attempt's own result — with no Clipboard API at all, `modern` is a bare `unsupported`\n *    and the legacy failure says more.\n *\n * Exported for the sibling write modules; absent from the barrel. Never throws.\n *\n * @param modern The result the Clipboard API path produced.\n * @param text The plain-text payload, or `undefined` when the write has no text arm to degrade to.\n * @param options The caller's options — the retry runs only on `legacyFallback: true`.\n */\nexport function withLegacyFallback(\n  modern: ClipboardWriteResult,\n  text: string | undefined,\n  options: ClipboardCopyOptions | undefined,\n): ClipboardWriteResult {\n  if (modern.ok) return modern;\n  if (options?.legacyFallback !== true) return modern;\n  if (text === undefined) return modern;\n\n  const legacy = legacyCopyText(text);\n  if (legacy.ok) return legacy;\n  return modern.failure.status === 'unsupported' ? legacy : modern;\n}\n","import {\n  reportClipboardOutcome,\n  toClipboardFailure,\n  type ClipboardCopyOptions,\n  type ClipboardWriteResult,\n} from './ClipboardResult';\nimport { clipboardMethod } from './ClipboardSupport';\nimport { withLegacyFallback } from './LegacyCopy';\n\n/** Runs the Clipboard API write, mapping every outcome onto the result union. Never throws. */\nasync function writeTextThroughApi(text: string): Promise<ClipboardWriteResult> {\n  const writeText = clipboardMethod('writeText');\n  if (writeText === undefined) return { ok: false, failure: { status: 'unsupported' } };\n\n  try {\n    await writeText(text);\n    return { ok: true, value: undefined };\n  } catch (error) {\n    return { ok: false, failure: toClipboardFailure(error) };\n  }\n}\n\n/**\n * Writes `text` to the system clipboard.\n *\n * Call it from a user gesture: browsers require transient activation for a clipboard write, and without one the\n * platform refuses — which surfaces as `denied`, not `unsupported`, since the API was in fact present.\n *\n * Resolves to `unsupported` under SSR, in a non-secure context, and on engines with no Clipboard API. Pass\n * `legacyFallback: true` to retry those through the deprecated `document.execCommand` path.\n *\n * Never throws, never rejects.\n *\n * @param text The text to place on the clipboard. An empty string is a valid payload — it clears the clipboard.\n * @param options Error reporting and the legacy-fallback opt-in.\n */\nexport async function copyText(text: string, options?: ClipboardCopyOptions): Promise<ClipboardWriteResult> {\n  try {\n    if (typeof text !== 'string') {\n      return reportClipboardOutcome(\n        { ok: false, failure: { status: 'failed', error: new TypeError('copyText expects a string.') } } as const,\n        options?.onError,\n      );\n    }\n\n    const result = withLegacyFallback(await writeTextThroughApi(text), text, options);\n    return reportClipboardOutcome(result, options?.onError);\n  } catch (error) {\n    // Unreachable by design — every helper above is itself total. Kept so a future edit to one of them cannot\n    // turn this entry point into a rejecting promise.\n    return reportClipboardOutcome({ ok: false, failure: toClipboardFailure(error) }, options?.onError);\n  }\n}\n","import { onScopeDispose, shallowRef, toValue, type MaybeRefOrGetter, type ShallowRef } from 'vue';\nimport { copyText } from '../CopyText';\nimport type { ClipboardWriteResult } from '../ClipboardResult';\n\nexport interface UseClipboardOptions {\n  /** Reset `copied` back to false after this many ms. Default 2000. Set 0 to keep state until explicitly reset. */\n  resetAfter?: MaybeRefOrGetter<number>;\n}\n\nexport interface ClipboardControls {\n  /** True for `resetAfter` ms after a successful copy. */\n  copied: Readonly<ShallowRef<boolean>>;\n\n  /** Last error from `navigator.clipboard.writeText`, if any. */\n  error: Readonly<ShallowRef<Error | null>>;\n\n  /** Writes text and returns the completed success or failure to the caller. */\n  copy: (text: string) => Promise<ClipboardWriteResult>;\n\n  /** Force-clear the `copied` flag. */\n  reset: () => void;\n}\n\n/**\n * Wraps `navigator.clipboard.writeText` with a transient `copied` flag for\n * post-action UI (icon swap, \"Copied!\" tooltip). Pass `resetAfter: 0` to\n * keep `copied` true until you call `reset()`.\n *\n * `resetAfter` may be a ref or getter; it is read at copy time, so a window\n * changed between copies takes effect on the next one.\n */\nexport function useClipboard({ resetAfter = 2000 }: UseClipboardOptions = {}): ClipboardControls {\n  const copied = shallowRef(false);\n  const error = shallowRef<Error | null>(null);\n  let timeout: ReturnType<typeof setTimeout> | null = null;\n  let generation = 0;\n  let disposed = false;\n\n  const reset = (): void => {\n    generation++;\n    if (timeout) clearTimeout(timeout);\n    timeout = null;\n    copied.value = false;\n    error.value = null;\n  };\n\n  const copy = async (text: string): Promise<ClipboardWriteResult> => {\n    const operation = ++generation;\n    if (timeout) clearTimeout(timeout);\n    timeout = null;\n    const result = await copyText(text);\n    if (disposed || operation !== generation) return result;\n    if (result.ok) {\n      error.value = null;\n      copied.value = true;\n      const resetWindow = toValue(resetAfter);\n      if (resetWindow > 0) {\n        if (timeout) clearTimeout(timeout);\n        timeout = setTimeout(() => {\n          timeout = null;\n          copied.value = false;\n        }, resetWindow);\n      }\n    } else {\n      copied.value = false;\n      error.value =\n        result.failure.status === 'unsupported' ? new Error('Clipboard is unavailable.') : result.failure.error;\n    }\n    return result;\n  };\n\n  onScopeDispose(() => {\n    disposed = true;\n    if (timeout) clearTimeout(timeout);\n  });\n\n  return { copied, error, copy, reset };\n}\n"],"names":[],"mappings":"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"}

package/dist/chunks/UseControlled-BQneb7BW.js

@@ -0,0 +1,29 @@
+import { toValue, shallowRef, computed } from "vue";
+function useControlled({
+  controlled,
+  default: defaultValue,
+  onChange
+}) {
+  const seed = toValue(defaultValue);
+  const initialControlled = toValue(controlled);
+  const isControlled = initialControlled !== void 0;
+  const uncontrolled = shallowRef(seed);
+  const setValue = (next) => {
+    if (Object.is(value.value, next)) return;
+    if (!isControlled) uncontrolled.value = next;
+    onChange?.(next);
+  };
+  const value = computed({
+    get: () => {
+      const external = toValue(controlled);
+      if (!isControlled) return uncontrolled.value;
+      return external === void 0 ? initialControlled : external;
+    },
+    set: setValue
+  });
+  return { value, setValue, isControlled, reset: () => setValue(seed) };
+}
+export {
+  useControlled as u
+};
+//# sourceMappingURL=UseControlled-BQneb7BW.js.map

package/dist/chunks/UseControlled-BQneb7BW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseControlled-BQneb7BW.js","sources":["../../src/foundation/state/hooks/UseControlled.ts"],"sourcesContent":["import { computed, shallowRef, toValue, type MaybeRefOrGetter, type ShallowRef, type WritableComputedRef } from 'vue';\n\ninterface UseControlledOptions<T> {\n  controlled: MaybeRefOrGetter<T | undefined>;\n  default: MaybeRefOrGetter<T>;\n  onChange?: (value: T) => void;\n}\n\n/** The controlled/uncontrolled handle — a writable value plus the explicit setter it delegates to. */\nexport interface ControlledValue<T> {\n  /**\n   * The resolved value. Writable: `value.value = next` runs the same path as `setValue(next)`,\n   * so it drops straight into `v-model`. A writable computed rather than a plain ref because the\n   * controlled branch must never keep its own copy of the value.\n   */\n  readonly value: WritableComputedRef<T>;\n\n  /** Sets the next value — updates internal state when uncontrolled, and emits `onChange` only for a distinct value. */\n  readonly setValue: (value: T) => void;\n\n  /** Fixed ownership chosen at setup. */\n  readonly isControlled: boolean;\n\n  /** Requests the original default through the same ownership path as user edits. */\n  readonly reset: () => void;\n}\n\n/**\n * Standard controlled/uncontrolled pattern.\n *\n * - If `controlled` initially resolves to a defined value, the component is controlled — internal state is\n *   ignored, `setValue` only fires `onChange`.\n * - Otherwise the component owns its state, `setValue` updates it, and `onChange`\n *   still fires for consumers that want to observe changes.\n *\n * Pass `controlled` as a getter (`() => props.value`) so the controlled branch tracks the prop.\n * `default` is read once, at setup — it seeds the uncontrolled state, exactly as the original's\n * `useState(defaultValue)` did.\n */\nexport function useControlled<T>({\n  controlled,\n  default: defaultValue,\n  onChange,\n}: UseControlledOptions<T>): ControlledValue<T> {\n  // Cast: `shallowRef`'s return type is a conditional over an unresolved `T`, which leaves\n  // `.value` unassignable until `T` is known. The cast pins it to the shape it always has here.\n  const seed = toValue(defaultValue);\n  const initialControlled = toValue(controlled);\n  const isControlled = initialControlled !== undefined;\n  const uncontrolled = shallowRef(seed) as ShallowRef<T>;\n\n  const setValue = (next: T): void => {\n    if (Object.is(value.value, next)) return;\n    if (!isControlled) uncontrolled.value = next;\n    onChange?.(next);\n  };\n\n  const value = computed<T>({\n    get: () => {\n      const external = toValue(controlled);\n      if (!isControlled) return uncontrolled.value;\n      // Removing a controlled value violates the fixed-mode contract; retain the initial value\n      // instead of silently changing ownership.\n      return external === undefined ? (initialControlled as T) : external;\n    },\n    set: setValue,\n  });\n\n  return { value, setValue, isControlled, reset: () => setValue(seed) };\n}\n"],"names":[],"mappings":";AAuCO,SAAS,cAAiB;AAAA,EAC/B;AAAA,EACA,SAAS;AAAA,EACT;AACF,GAAgD;AAG9C,QAAM,OAAO,QAAQ,YAAY;AACjC,QAAM,oBAAoB,QAAQ,UAAU;AAC5C,QAAM,eAAe,sBAAsB;AAC3C,QAAM,eAAe,WAAW,IAAI;AAEpC,QAAM,WAAW,CAAC,SAAkB;AAClC,QAAI,OAAO,GAAG,MAAM,OAAO,IAAI,EAAG;AAClC,QAAI,CAAC,aAAc,cAAa,QAAQ;AACxC,eAAW,IAAI;AAAA,EACjB;AAEA,QAAM,QAAQ,SAAY;AAAA,IACxB,KAAK,MAAM;AACT,YAAM,WAAW,QAAQ,UAAU;AACnC,UAAI,CAAC,aAAc,QAAO,aAAa;AAGvC,aAAO,aAAa,SAAa,oBAA0B;AAAA,IAC7D;AAAA,IACA,KAAK;AAAA,EAAA,CACN;AAED,SAAO,EAAE,OAAO,UAAU,cAAc,OAAO,MAAM,SAAS,IAAI,EAAA;AACpE;"}

package/dist/chunks/UseDebounceHandler-BIZgvvGp.js

@@ -0,0 +1,20 @@
+import { toValue } from "vue";
+function useDebounceHandler(handler, ms) {
+  let lastTime = 0;
+  return (event) => {
+    const interval = toValue(ms);
+    if (interval !== void 0) {
+      const now = Date.now();
+      if (now - lastTime < interval) {
+        event.preventDefault();
+        return;
+      }
+      lastTime = now;
+    }
+    handler?.(event);
+  };
+}
+export {
+  useDebounceHandler as u
+};
+//# sourceMappingURL=UseDebounceHandler-BIZgvvGp.js.map

package/dist/chunks/UseDebounceHandler-BIZgvvGp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseDebounceHandler-BIZgvvGp.js","sources":["../../src/foundation/async/UseDebounceHandler.ts"],"sourcesContent":["import { toValue, type MaybeRefOrGetter } from 'vue';\n\n/**\n * Throttle a DOM event handler. First call in a `ms` window fires; subsequent\n * within the window are swallowed via `event.preventDefault()`. When `ms` is\n * `undefined`, the handler passes through unchanged. Use to prevent rapid-fire\n * gestures (double-clicks, double-submits, repeated touches) without wiring\n * timer state in the consumer.\n *\n * Functionally a *throttle* (first wins). The `Debounce` naming is kept for\n * vocabulary consistency with the `debounceMs` props on consuming components.\n *\n * `ms` may be a ref or getter and is read per event. `handler` is captured at\n * setup (a function argument cannot double as a getter) — wrap it when the\n * callee must stay live: `useDebounceHandler((e) => props.onClick?.(e), ms)`.\n */\nexport function useDebounceHandler<E extends Event = Event>(\n  handler: ((event: E) => void) | undefined,\n  ms: MaybeRefOrGetter<number | undefined>,\n): (event: E) => void {\n  let lastTime = 0;\n  return (event: E): void => {\n    const interval = toValue(ms);\n    if (interval !== undefined) {\n      const now = Date.now();\n      if (now - lastTime < interval) {\n        event.preventDefault();\n        return;\n      }\n      lastTime = now;\n    }\n    handler?.(event);\n  };\n}\n"],"names":[],"mappings":";AAgBO,SAAS,mBACd,SACA,IACoB;AACpB,MAAI,WAAW;AACf,SAAO,CAAC,UAAmB;AACzB,UAAM,WAAW,QAAQ,EAAE;AAC3B,QAAI,aAAa,QAAW;AAC1B,YAAM,MAAM,KAAK,IAAA;AACjB,UAAI,MAAM,WAAW,UAAU;AAC7B,cAAM,eAAA;AACN;AAAA,MACF;AACA,iBAAW;AAAA,IACb;AACA,cAAU,KAAK;AAAA,EACjB;AACF;"}

package/dist/chunks/UseEscape-CYPdpm_l.js

@@ -0,0 +1,15 @@
+import { watchPostEffect, toValue } from "vue";
+function useEscape(handler, enabled = true) {
+  watchPostEffect((onCleanup) => {
+    if (!toValue(enabled) || typeof document === "undefined") return;
+    const onKeyDown = (e) => {
+      if (e.key === "Escape") handler(e);
+    };
+    document.addEventListener("keydown", onKeyDown);
+    onCleanup(() => document.removeEventListener("keydown", onKeyDown));
+  });
+}
+export {
+  useEscape as u
+};
+//# sourceMappingURL=UseEscape-CYPdpm_l.js.map

package/dist/chunks/UseEscape-CYPdpm_l.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseEscape-CYPdpm_l.js","sources":["../../src/foundation/shortcuts/hooks/UseEscape.ts"],"sourcesContent":["import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\n/**\n * Fire `handler` when the Escape key is pressed at the document level.\n * For nested overlays, the topmost should call `event.stopPropagation()` in\n * its handler — `DismissableLayer` handles this stack-style.\n *\n * `enabled` may be a ref or a getter (`() => props.isOpen`); the listener\n * detaches and re-attaches as it flips.\n */\nexport function useEscape(handler: (event: KeyboardEvent) => void, enabled: MaybeRefOrGetter<boolean> = true): void {\n  watchPostEffect((onCleanup) => {\n    if (!toValue(enabled) || typeof document === 'undefined') return;\n    const onKeyDown = (e: KeyboardEvent): void => {\n      if (e.key === 'Escape') handler(e);\n    };\n    document.addEventListener('keydown', onKeyDown);\n    onCleanup(() => document.removeEventListener('keydown', onKeyDown));\n  });\n}\n"],"names":[],"mappings":";AAUO,SAAS,UAAU,SAAyC,UAAqC,MAAY;AAClH,kBAAgB,CAAC,cAAc;AAC7B,QAAI,CAAC,QAAQ,OAAO,KAAK,OAAO,aAAa,YAAa;AAC1D,UAAM,YAAY,CAAC,MAA2B;AAC5C,UAAI,EAAE,QAAQ,SAAU,SAAQ,CAAC;AAAA,IACnC;AACA,aAAS,iBAAiB,WAAW,SAAS;AAC9C,cAAU,MAAM,SAAS,oBAAoB,WAAW,SAAS,CAAC;AAAA,EACpE,CAAC;AACH;"}

package/dist/chunks/UseEventListener-C1WgWGoT.js

@@ -0,0 +1,17 @@
+import { watchPostEffect, toValue } from "vue";
+function useEventListener(event, handler, target = () => typeof document === "undefined" ? null : document, options) {
+  watchPostEffect((onCleanup) => {
+    const element = toValue(target);
+    if (!element) return;
+    const listenerOptions = toValue(options);
+    const capture = typeof listenerOptions === "boolean" ? listenerOptions : listenerOptions?.capture ?? false;
+    const type = toValue(event);
+    const listener = (e) => handler(e);
+    element.addEventListener(type, listener, listenerOptions);
+    onCleanup(() => element.removeEventListener(type, listener, capture));
+  });
+}
+export {
+  useEventListener as u
+};
+//# sourceMappingURL=UseEventListener-C1WgWGoT.js.map

package/dist/chunks/UseEventListener-C1WgWGoT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseEventListener-C1WgWGoT.js","sources":["../../src/foundation/dom/hooks/UseEventListener.ts"],"sourcesContent":["import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\ntype Target = Window | Document | HTMLElement | null | undefined;\n\n/**\n * Add an event listener and clean it up automatically. Every argument may be a\n * ref or a getter, so a `useTemplateRef` target attaches the moment the element\n * mounts and re-attaches if it is swapped — the Vue stand-in for the original's\n * handler-in-a-ref indirection.\n *\n * `handler` is captured at setup (it is a plain function, never a getter — a\n * getter is indistinguishable from the handler itself). Pass a wrapper when the\n * callee must stay live: `useEventListener('click', (e) => props.onClick?.(e))`.\n *\n * The default target is resolved lazily so importing this in an SSR pass never\n * touches `document`.\n */\nexport function useEventListener<K extends string>(\n  event: MaybeRefOrGetter<K>,\n  handler: (event: Event) => void,\n  target: MaybeRefOrGetter<Target> = () => (typeof document === 'undefined' ? null : document),\n  options?: MaybeRefOrGetter<boolean | AddEventListenerOptions | undefined>,\n): void {\n  watchPostEffect((onCleanup) => {\n    const element = toValue(target);\n    if (!element) return;\n    // Capture options at attach time — remove must use the same capture flag.\n    const listenerOptions = toValue(options);\n    const capture = typeof listenerOptions === 'boolean' ? listenerOptions : (listenerOptions?.capture ?? false);\n    const type = toValue(event);\n    const listener = (e: Event): void => handler(e);\n    element.addEventListener(type, listener, listenerOptions);\n    onCleanup(() => element.removeEventListener(type, listener, capture));\n  });\n}\n"],"names":[],"mappings":";AAiBO,SAAS,iBACd,OACA,SACA,SAAmC,MAAO,OAAO,aAAa,cAAc,OAAO,UACnF,SACM;AACN,kBAAgB,CAAC,cAAc;AAC7B,UAAM,UAAU,QAAQ,MAAM;AAC9B,QAAI,CAAC,QAAS;AAEd,UAAM,kBAAkB,QAAQ,OAAO;AACvC,UAAM,UAAU,OAAO,oBAAoB,YAAY,kBAAmB,iBAAiB,WAAW;AACtG,UAAM,OAAO,QAAQ,KAAK;AAC1B,UAAM,WAAW,CAAC,MAAmB,QAAQ,CAAC;AAC9C,YAAQ,iBAAiB,MAAM,UAAU,eAAe;AACxD,cAAU,MAAM,QAAQ,oBAAoB,MAAM,UAAU,OAAO,CAAC;AAAA,EACtE,CAAC;AACH;"}

package/dist/chunks/UseHotkeys-dSOwoutT.js

@@ -0,0 +1,82 @@
+import { computed, toValue, watchPostEffect } from "vue";
+import { p as parseChord, m as matchesChord } from "./Chord-C3OKRsgk.js";
+function isEditableTarget(target) {
+  if (!(target instanceof HTMLElement)) return false;
+  if (target.isContentEditable) return true;
+  const tag = target.tagName;
+  if (tag === "TEXTAREA" || tag === "SELECT") return true;
+  if (tag === "INPUT") {
+    const type = target.type;
+    return type !== "button" && type !== "checkbox" && type !== "radio" && type !== "submit" && type !== "reset";
+  }
+  return false;
+}
+function firesInEditable(chord) {
+  return chord.ctrl || chord.meta;
+}
+function resolveElement(options) {
+  if (options?.target !== void 0) return toValue(options.target) ?? null;
+  return typeof window === "undefined" ? null : window;
+}
+function useHotkeys(chords, handler, options) {
+  const applePlatform = options?.applePlatform;
+  const parsed = computed(() => {
+    const resolved = toValue(chords);
+    const list = typeof resolved === "string" ? [resolved] : resolved;
+    return list.map((c) => parseChord(c, { applePlatform }));
+  });
+  watchPostEffect((onCleanup) => {
+    const element = resolveElement(options);
+    if (element === null) return;
+    const eventType = options?.eventType ?? "keydown";
+    const chordList = parsed.value;
+    function onKey(event) {
+      if (toValue(options?.enabled ?? true) === false) return;
+      const ignoreInputs = toValue(options?.ignoreInputs ?? true);
+      const inEditable = ignoreInputs && isEditableTarget(event.target);
+      for (const chord of chordList) {
+        if (!matchesChord(event, chord)) continue;
+        if (inEditable && !firesInEditable(chord)) return;
+        if (toValue(options?.preventDefault ?? true) === true) event.preventDefault();
+        handler(event);
+        return;
+      }
+    }
+    element.addEventListener(eventType, onKey);
+    onCleanup(() => element.removeEventListener(eventType, onKey));
+  });
+}
+function useHotkeyMap(map, options) {
+  const applePlatform = options?.applePlatform;
+  const parsed = computed(() => {
+    const resolved = toValue(map);
+    return Object.keys(resolved).filter((c) => typeof resolved[c] === "function").sort().map((key) => ({ key, chord: parseChord(key, { applePlatform }) }));
+  });
+  watchPostEffect((onCleanup) => {
+    const element = resolveElement(options);
+    if (element === null) return;
+    const eventType = options?.eventType ?? "keydown";
+    const chordList = parsed.value;
+    function onKey(event) {
+      if (toValue(options?.enabled ?? true) === false) return;
+      const ignoreInputs = toValue(options?.ignoreInputs ?? true);
+      const inEditable = ignoreInputs && isEditableTarget(event.target);
+      for (const { chord, key } of chordList) {
+        if (!matchesChord(event, chord)) continue;
+        if (inEditable && !firesInEditable(chord)) return;
+        const handler = toValue(map)[key];
+        if (typeof handler !== "function") return;
+        if (toValue(options?.preventDefault ?? true) === true) event.preventDefault();
+        handler(event);
+        return;
+      }
+    }
+    element.addEventListener(eventType, onKey);
+    onCleanup(() => element.removeEventListener(eventType, onKey));
+  });
+}
+export {
+  useHotkeys as a,
+  useHotkeyMap as u
+};
+//# sourceMappingURL=UseHotkeys-dSOwoutT.js.map

package/dist/chunks/UseHotkeys-dSOwoutT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseHotkeys-dSOwoutT.js","sources":["../../src/foundation/shortcuts/hooks/UseHotkeys.ts"],"sourcesContent":["// The DOM binding layer of the shortcuts vector. `useHotkeys` attaches a keydown/keyup listener (to `window` or\n// a scoped element) that matches a chord and fires a handler; `useHotkeyMap` binds many chords at once — the\n// shape a command palette or an editor wants. Every option may be a ref or a getter, so a consumer never has to\n// re-invoke anything to change one, and both skip typing contexts by default (a bare `k` shouldn't fire while the\n// user types in an input), while still letting ⌘/Ctrl combos through so `mod+k` works even with a field focused.\n\nimport { computed, toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nimport { matchesChord, parseChord, type Chord, type ChordPlatformOptions } from '../Chord';\n\n/** Tunes how a hotkey binding listens. */\nexport interface HotkeyOptions extends ChordPlatformOptions {\n  /** Whether the binding is active. Defaults to `true`. */\n  readonly enabled?: MaybeRefOrGetter<boolean>;\n\n  /** Whether a match calls `event.preventDefault()`. Defaults to `true`. */\n  readonly preventDefault?: MaybeRefOrGetter<boolean>;\n\n  /**\n   * Whether to ignore keystrokes while a text input / textarea / select / `contenteditable` has focus.\n   * Defaults to `true` — but a chord carrying Ctrl or Meta still fires (so `mod+k` works inside a field).\n   */\n  readonly ignoreInputs?: MaybeRefOrGetter<boolean>;\n\n  /** The element to bind to; defaults to `window`. Pass a template ref to scope the shortcut to a subtree. */\n  readonly target?: MaybeRefOrGetter<HTMLElement | null | undefined>;\n\n  /** Which key phase to listen on. Defaults to `keydown`. */\n  readonly eventType?: 'keydown' | 'keyup';\n}\n\n/** Reports whether an event target is an editable field where bare-key shortcuts should be suppressed. */\nfunction isEditableTarget(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (target.isContentEditable) return true;\n  const tag = target.tagName;\n  if (tag === 'TEXTAREA' || tag === 'SELECT') return true;\n  if (tag === 'INPUT') {\n    // Buttons/checkboxes/etc. aren't typing contexts — only value-bearing inputs suppress bare shortcuts.\n    const type = (target as HTMLInputElement).type;\n    return type !== 'button' && type !== 'checkbox' && type !== 'radio' && type !== 'submit' && type !== 'reset';\n  }\n  return false;\n}\n\n/** Whether a chord may fire while a field is focused — Ctrl/Meta combos are allowed through, bare keys are not. */\nfunction firesInEditable(chord: Chord): boolean {\n  return chord.ctrl || chord.meta;\n}\n\n/** Resolves the node a binding attaches to — the scoped element when `target` is given, else `window`. */\nfunction resolveElement(options: HotkeyOptions | undefined): Window | HTMLElement | null {\n  if (options?.target !== undefined) return toValue(options.target) ?? null;\n  return typeof window === 'undefined' ? null : window;\n}\n\n/**\n * Binds one or more chord strings to a single handler. Multiple chords act as an OR (`['mod+k', 'ctrl+k']`).\n * The chords are parsed in a `computed`, so an inline array literal costs one parse; the handler and the\n * behavioural options are read at event time, so passing fresh closures is fine — the listener is attached\n * once per `target`/`eventType`/platform and reused.\n */\nexport function useHotkeys(\n  chords: MaybeRefOrGetter<string | ReadonlyArray<string>>,\n  handler: (event: KeyboardEvent) => void,\n  options?: HotkeyOptions,\n): void {\n  const applePlatform = options?.applePlatform;\n\n  const parsed = computed<Chord[]>(() => {\n    const resolved = toValue(chords);\n    const list = typeof resolved === 'string' ? [resolved] : resolved;\n    return list.map((c) => parseChord(c, { applePlatform }));\n  });\n\n  watchPostEffect((onCleanup) => {\n    const element = resolveElement(options);\n    if (element === null) return;\n\n    const eventType = options?.eventType ?? 'keydown';\n    const chordList = parsed.value;\n\n    function onKey(event: KeyboardEvent): void {\n      if (toValue(options?.enabled ?? true) === false) return;\n\n      const ignoreInputs = toValue(options?.ignoreInputs ?? true);\n      const inEditable = ignoreInputs && isEditableTarget(event.target);\n\n      for (const chord of chordList) {\n        if (!matchesChord(event, chord)) continue;\n        if (inEditable && !firesInEditable(chord)) return; // suppressed in a typing context\n        if (toValue(options?.preventDefault ?? true) === true) event.preventDefault();\n        handler(event);\n        return;\n      }\n    }\n\n    // `target` resolves through `toValue`, so the effect re-attaches when the ref fills, the event phase\n    // changes, or the parsed chords change. The handler and the behavioural options are read at event time,\n    // so they never force a re-attach.\n    element.addEventListener(eventType, onKey as EventListener);\n    onCleanup(() => element.removeEventListener(eventType, onKey as EventListener));\n  });\n}\n\n/** The per-chord handler a keymap holds; a falsy entry is a row the caller has disabled. */\ntype HotkeyMapHandler = ((event: KeyboardEvent) => void) | false | null | undefined;\n\n/**\n * Binds a map of `chord → handler` — the ergonomic shape for a command palette or editor keymap. Each entry is\n * an independent binding sharing the same `options`. A `false`/`null`/`undefined` handler entry is skipped, so a\n * caller can conditionally disable one row without restructuring the map.\n */\nexport function useHotkeyMap(\n  map: MaybeRefOrGetter<Readonly<Record<string, HotkeyMapHandler>>>,\n  options?: HotkeyOptions,\n): void {\n  const applePlatform = options?.applePlatform;\n\n  const parsed = computed<{ chord: Chord; key: string }[]>(() => {\n    const resolved = toValue(map);\n    return Object.keys(resolved)\n      .filter((c) => typeof resolved[c] === 'function')\n      .sort()\n      .map((key) => ({ key, chord: parseChord(key, { applePlatform }) }));\n  });\n\n  watchPostEffect((onCleanup) => {\n    const element = resolveElement(options);\n    if (element === null) return;\n\n    const eventType = options?.eventType ?? 'keydown';\n    const chordList = parsed.value;\n\n    function onKey(event: KeyboardEvent): void {\n      if (toValue(options?.enabled ?? true) === false) return;\n\n      const ignoreInputs = toValue(options?.ignoreInputs ?? true);\n      const inEditable = ignoreInputs && isEditableTarget(event.target);\n\n      for (const { chord, key } of chordList) {\n        if (!matchesChord(event, chord)) continue;\n        if (inEditable && !firesInEditable(chord)) return;\n        const handler = toValue(map)[key];\n        if (typeof handler !== 'function') return;\n        if (toValue(options?.preventDefault ?? true) === true) event.preventDefault();\n        handler(event);\n        return;\n      }\n    }\n\n    element.addEventListener(eventType, onKey as EventListener);\n    onCleanup(() => element.removeEventListener(eventType, onKey as EventListener));\n  });\n}\n"],"names":[],"mappings":"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"}

package/dist/chunks/UseId-CtgAhGrn.js

@@ -0,0 +1,9 @@
+import { useId as useId$1 } from "vue";
+function useId(prefix) {
+  const id = useId$1();
+  return prefix ? `${id}-${prefix}` : id;
+}
+export {
+  useId as u
+};
+//# sourceMappingURL=UseId-CtgAhGrn.js.map

package/dist/chunks/UseId-CtgAhGrn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseId-CtgAhGrn.js","sources":["../../src/foundation/identifiers/UseId.ts"],"sourcesContent":["import { useId as useVueId } from 'vue';\n\n/**\n * Wraps Vue 3.5's built-in `useId`. Optionally accepts a stable prefix so generated\n * IDs are easier to spot in DevTools (e.g. `useId('checkbox')` → `v-0-checkbox`).\n *\n * Must be called during `setup()` — the id is drawn from the app instance's counter,\n * which is what keeps it stable across a server render and its client hydration.\n */\nexport function useId(prefix?: string): string {\n  const id = useVueId();\n  return prefix ? `${id}-${prefix}` : id;\n}\n"],"names":["useVueId"],"mappings":";AASO,SAAS,MAAM,QAAyB;AAC7C,QAAM,KAAKA,QAAA;AACX,SAAO,SAAS,GAAG,EAAE,IAAI,MAAM,KAAK;AACtC;"}