@viax.io/uxm 4.36.0

package/README.md

@@ -0,0 +1,263 @@
+# @viax.io/uxm
+
+**React 19 UI primitives, design tokens, and theming previews — packaged as a standalone library.**
+
+BEM-classed components, a single design-token layer, and themable previews. Framework-agnostic React 19 — distributed as ESM + CJS with first-class `.d.ts`, no runtime dependencies beyond React, and `sideEffects: ["**/*.css"]` for full tree-shaking.
+
+The package ships **no `"use client"` / `"use server"` directives** by design: consumers are client-side SPAs, and framework-specific pragmas would leak into every one of them. Under a React Server Components setup (e.g. Next.js App Router) the consuming file is responsible for its own `"use client"` boundary.
+
+## What's in this package
+
+- **UI primitives** (`@viax.io/uxm/ui`) — BEM-classed React 19 components.
+- **Icon registry** (`@viax.io/uxm/ui`) — `ICONS`, `ICON_OPTIONS`, `getIcon`, `IconDef` for tooling that enumerates the bundled icon set.
+- **Design tokens** (`@viax.io/uxm/tokens`) — the canonical `themeTokens` array plus helpers (`findToken`, `resolveHex`, `isTokenValue`) and the `ThemeToken` type.
+- **Themable previews** (`@viax.io/uxm/previews`) — preview components (one per atom, plus composite previews) used by host shells like MODO's brand-settings editor to render live, knob-driven theme exploration.
+- **WCAG / contrast helpers** (`@viax.io/uxm`) — `contrastRatio`, `parseColor`, `rgbToHex`, `suggestAccessibleColor`, `suggestAccessibleToken`, `wcagLevel`, plus `RGB` and `TokenCandidate` types.
+- **Default stylesheets** — `@viax.io/uxm/ui.css` (component primitive defaults) and `@viax.io/uxm/tokens.css` (token declarations).
+
+## Install
+
+```bash
+npm install @viax.io/uxm
+```
+
+Peer deps: `react@^19`, `react-dom@^19`. Node `>=22.14.0` for local dev.
+
+The package is published to the private Viax Nexus npm registry; see [Configure the registry](#configure-the-registry) below.
+
+## Quick start
+
+Import both stylesheets once, at your application entry point:
+
+```ts
+// e.g. src/main.tsx
+import '@viax.io/uxm/tokens.css';
+import '@viax.io/uxm/ui.css';
+```
+
+Then use the primitives anywhere:
+
+```tsx
+import { ButtonPrimary, Icon } from '@viax.io/uxm/ui';
+
+export function Page() {
+  return (
+    <ButtonPrimary>
+      <Icon glyph="sparkles" /> Hello UXM
+    </ButtonPrimary>
+  );
+}
+```
+
+Consume tokens programmatically:
+
+```ts
+import { themeTokens, findToken, resolveHex } from '@viax.io/uxm/tokens';
+
+const accent = findToken('--color-accent-bold');
+const hex = resolveHex(accent?.cssVar ?? '#000');
+```
+
+Both primary entry points are also re-exported from the root:
+
+```ts
+import { ButtonPrimary, themeTokens } from '@viax.io/uxm';
+```
+
+## Subpath exports
+
+| Entry | Purpose |
+|-------|---------|
+| `@viax.io/uxm` | Root barrel — re-exports `ui` + `tokens` + WCAG helpers. |
+| `@viax.io/uxm/ui` | All UI primitives + icon registry. Tree-shake-friendly per-component imports. |
+| `@viax.io/uxm/ui.css` | Compiled component stylesheet — required for visual output. |
+| `@viax.io/uxm/tokens` | `themeTokens` array + `findToken` / `resolveHex` / `isTokenValue` + `ThemeToken` type. |
+| `@viax.io/uxm/tokens.css` | `--color-*` declarations on `:root`. |
+| `@viax.io/uxm/previews` | Preview components for host shells building theme editors. **No preview symbol leaks into `/ui`** — see the tree-shake guarantee below. |
+
+## Component catalog
+
+Every component folder ships a `README.md` documenting props, CSS variables, MODO-configurable design tokens, states/variants, and accessibility. Click through any name for the full reference.
+
+> The catalog below covers every folder in `src/ui/`. If you add a component, add it here too — and keep `src/ui/` the authoritative source if the two ever drift.
+
+### Forms & inputs
+[`calendar`](src/ui/calendar/README.md) · [`checkbox`](src/ui/checkbox/README.md) · [`color-input`](src/ui/color-input/README.md) (ColorInput + ColorInputPopover) · [`currency-input`](src/ui/currency-input/README.md) · [`date-input`](src/ui/date-input/README.md) · [`editable-cell`](src/ui/editable-cell/README.md) · [`field-error`](src/ui/field-error/README.md) · [`file-upload`](src/ui/file-upload/README.md) · [`form-field`](src/ui/form-field/README.md) · [`input`](src/ui/input/README.md) (TextInput + Select + Textarea) · [`input-with-icon`](src/ui/input-with-icon/README.md) · [`number-input`](src/ui/number-input/README.md) · [`number-stepper`](src/ui/number-stepper/README.md) · [`password-input`](src/ui/password-input/README.md) · [`phone-input`](src/ui/phone-input/README.md) · [`pill-select`](src/ui/pill-select/README.md) · [`radio-group`](src/ui/radio-group/README.md) · [`range-slider`](src/ui/range-slider/README.md) · [`search-dropdown`](src/ui/search-dropdown/README.md) · [`slider`](src/ui/slider/README.md) · [`time-input`](src/ui/time-input/README.md) · [`toggle-switch`](src/ui/toggle-switch/README.md)
+
+### Buttons & actions
+[`back-link`](src/ui/back-link/README.md) · [`bulk-action-bar`](src/ui/bulk-action-bar/README.md) · [`button`](src/ui/button/README.md) (Primary/Secondary/Tertiary/Ghost) · [`button-group`](src/ui/button-group/README.md) · [`button-icon`](src/ui/button-icon/README.md) · [`button-with-icon`](src/ui/button-with-icon/README.md) · [`icon-button`](src/ui/icon-button/README.md) · [`inline-action`](src/ui/inline-action/README.md) · [`link`](src/ui/link/README.md)
+
+### Navigation
+[`app-sidebar`](src/ui/app-sidebar/README.md) · [`app-top-bar`](src/ui/app-top-bar/README.md) · [`breadcrumb`](src/ui/breadcrumb/README.md) · [`filter-tabs`](src/ui/filter-tabs/README.md) · [`menu`](src/ui/menu/README.md) · [`sidebar-nav-item`](src/ui/sidebar-nav-item/README.md) · [`tabs`](src/ui/tabs/README.md) · [`tabs-underline`](src/ui/tabs-underline/README.md) · [`view-switcher`](src/ui/view-switcher/README.md)
+
+### Overlays & floating layers
+[`dialog`](src/ui/dialog/README.md) · [`hover-tooltip`](src/ui/hover-tooltip/README.md) · [`listbox`](src/ui/listbox/README.md) (Listbox + MultiListbox) · [`modal`](src/ui/modal/README.md) · [`option-list`](src/ui/option-list/README.md) · [`popover`](src/ui/popover/README.md) · [`toast`](src/ui/toast/README.md) (Toast + Toaster + the `toast.*` API)
+
+### Feedback & status
+[`badge`](src/ui/badge/README.md) · [`banner`](src/ui/banner/README.md) · [`chip`](src/ui/chip/README.md) · [`empty-state`](src/ui/empty-state/README.md) · [`error-page`](src/ui/error-page/README.md) · [`loader`](src/ui/loader/README.md) · [`progress-bar`](src/ui/progress-bar/README.md) · [`tag`](src/ui/tag/README.md) · [`tooltip`](src/ui/tooltip/README.md) (Tooltip + ContentTooltip)
+
+### Layout & structure
+[`card`](src/ui/card/README.md) · [`cluster`](src/ui/cluster/README.md) · [`detail-section`](src/ui/detail-section/README.md) · [`divider`](src/ui/divider/README.md) · [`inline-filter`](src/ui/inline-filter/README.md) · [`page-header`](src/ui/page-header/README.md) · [`page-shell`](src/ui/page-shell/README.md) · [`responsive-grid`](src/ui/responsive-grid/README.md) · [`section-header`](src/ui/section-header/README.md) · [`side-flexpane`](src/ui/side-flexpane/README.md) · [`stack`](src/ui/stack/README.md)
+
+### Data display
+[`avatar`](src/ui/avatar/README.md) · [`data-table`](src/ui/data-table/README.md) · [`disclosure`](src/ui/disclosure/README.md) · [`icon`](src/ui/icon/README.md) · [`icon-tile`](src/ui/icon-tile/README.md) · [`list`](src/ui/list/README.md) (List + ListItem) · [`meta-row`](src/ui/meta-row/README.md) · [`property-field`](src/ui/property-field/README.md) (PropertyField + PropertyGrid) · [`stat-card`](src/ui/stat-card/README.md) · [`thumbnail`](src/ui/thumbnail/README.md) · [`timeline-entry`](src/ui/timeline-entry/README.md) · [`type-overview-card`](src/ui/type-overview-card/README.md)
+
+### Configuration editor
+[`component-row`](src/ui/component-row/README.md) · [`config-component-row`](src/ui/config-component-row/README.md) · [`config-segment-item`](src/ui/config-segment-item/README.md) · [`explorer-list-item`](src/ui/explorer-list-item/README.md) · [`explorer-section`](src/ui/explorer-section/README.md) · [`segment-card`](src/ui/segment-card/README.md) · [`segment-row`](src/ui/segment-row/README.md)
+
+### Lifecycle diagrams
+[`lifecycle-connector`](src/ui/lifecycle-connector/README.md) · [`lifecycle-drop-slot`](src/ui/lifecycle-drop-slot/README.md) · [`lifecycle-edge-label`](src/ui/lifecycle-edge-label/README.md) · [`lifecycle-group-box`](src/ui/lifecycle-group-box/README.md) · [`lifecycle-minimap`](src/ui/lifecycle-minimap/README.md) · [`lifecycle-node-card`](src/ui/lifecycle-node-card/README.md) · [`lifecycle-terminal`](src/ui/lifecycle-terminal/README.md) · [`lifecycle-zoom-control`](src/ui/lifecycle-zoom-control/README.md)
+
+## Design tokens & MODO theming
+
+The library is built on a **two-layer customisation model**:
+
+1. **Component-scoped CSS variables** (`--uxm-{component}-*`) — per-instance fine-tuning set inline or via a higher CSS scope. Each component README lists its full surface.
+2. **Global design tokens** (`--color-*`) — declared on `:root` by `tokens.css`, consumed as fallbacks inside every component-scoped variable. This is the **MODO-configurable layer**: brand-settings UIs (like MODO's `BrandSettingsPreview`) edit these tokens centrally and instantly re-tint every consumer.
+
+The canonical token catalogue lives in `src/tokens/index.ts` as the `themeTokens` array. Each entry carries:
+
+- `name` — display label shown in MODO's brand-settings editor (e.g. `"Accent Bold"`)
+- `cssVar` — the `--color-*` identifier consumed by components
+- `hex` / `darkHex` — light/dark defaults
+- `group` — one of `surfaces` · `text` · `borders` · `accent` · `highlights` · `categories` · `semantic`
+
+```ts
+import { themeTokens, findToken } from '@viax.io/uxm/tokens';
+
+themeTokens.forEach((t) => {
+  console.log(`${t.group}/${t.name} → ${t.cssVar} = ${t.hex} (dark: ${t.darkHex})`);
+});
+
+const accent = findToken('--color-accent-bold');
+//    ^ { name: 'Accent Bold', cssVar: '--color-accent-bold', hex: '#1E7150', … }
+```
+
+Each component README's **Design tokens (MODO-configurable)** section names every token the component reads, paired with its `Group / Name` from `themeTokens` — making it straightforward to look up "if I edit X in MODO, what re-tints?"
+
+## Previews
+
+Previews live under `@viax.io/uxm/previews` and are designed for **host shells building theme editors**. Each preview:
+
+- Accepts a uniform `PreviewProps = { componentId, styles, variants, shell? }` signature.
+- Reads `styles` (slider/colorpicker knob values) and projects them as inline CSS variables on the component instance, exercising the production CSS path so what designers see is what consumers ship.
+- Optionally reads `shell` (host-provided context: brand, theme, `uploadAsset`) to integrate with the editor's broader state — e.g. `LoginPagePreview` and `BrandSettingsPreview` use `shell.uploadAsset` for logo uploads.
+
+```tsx
+import { ButtonPreview, type PreviewShellContext } from '@viax.io/uxm/previews';
+
+<ButtonPreview
+  componentId="button-primary"
+  styles={{ backgroundColor: '#1E7150', borderRadius: 8, paddingX: 20, paddingY: 10 }}
+  variants={{ state: 'hover' }}
+  shell={shell satisfies PreviewShellContext}
+/>;
+```
+
+**Tree-shake guarantee**: no preview symbols leak into `@viax.io/uxm/ui`, so consumers that only import primitives never pay for preview code. This is **upheld by convention, not enforced by the build** — nothing fails if a barrel breaks it. When you touch `src/ui/index.ts` or any `src/ui/*/index.ts`, check by hand that no `*-preview` module is re-exported; after a build, `grep "Preview" dist/ui/index.js` should return nothing.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────┐
+│  @viax.io/uxm/previews                             │  ← host editors (MODO brand-settings)
+│  themable, shell-aware preview components       │
+└────────────────┬────────────────────────────────┘
+                 │ consumes
+                 ▼
+┌─────────────────────────────────────────────────┐
+│  @viax.io/uxm/ui                                   │  ← application code
+│  BEM-classed React components                   │
+│  + Icon registry (ICONS, getIcon, …)            │
+└────────────────┬────────────────────────────────┘
+                 │ reads fallbacks
+                 ▼
+┌─────────────────────────────────────────────────┐
+│  @viax.io/uxm/tokens (+ tokens.css)                │  ← MODO brand-settings edits this
+│  themeTokens array + --color-* declarations     │
+└─────────────────────────────────────────────────┘
+```
+
+Every layer is independently importable; every layer has its own type declarations and own CSS bundle.
+
+## Install
+
+Published publicly on npm — no registry configuration and no VPN required:
+
+```bash
+npm install @viax.io/uxm
+```
+
+## Build & develop
+
+```bash
+npm install
+npm run dev:modo   # Vite dev server for the studio portal — fastest loop, no build needed
+npm run build      # full dist/ (see the pipeline below)
+npm run typecheck  # tsc --noEmit for src + portal
+npm run lint       # eslint .
+npm run lint:fix   # eslint . --fix
+npm run dev        # tsup --watch — only for local linked dev against a consumer
+```
+
+**`npm run dev:modo` is the fastest way to see a UI change.** The portal pulls `src/ui/**/*.scss` through `import.meta.glob`, so components render with real CSS over HMR without building `dist/` first.
+
+**There are no tests.** `test:ci` and `test:coverage` are intentional no-op stubs, so "tests pass" is never a meaningful verification here — use `typecheck`, `lint`, `build`, or the portal.
+
+`npm run build` chains five steps, and the order is deliberate:
+
+1. **`tsup`** — ESM + CJS JS with `bundle: false` and **`dts: false`** (one output per source file). Its `onSuccess` hook compiles `src/ui/**/*.scss` → sibling `dist/ui/**/*.css`, then copies `styles.css` and `tokens/index.css`.
+2. **`build:studio-css`** — Tailwind CLI compiles `src/studio/studio.css`.
+3. **`tsc -p tsconfig.build.json`** — a **separate** declaration pass. DTS is off in tsup because its single-worker DTS pass runs out of memory with 100+ unbundled entries.
+4. **`tsc-alias`** — rewrites `@/*` path aliases to relative paths across `dist` (JS + CJS + `.d.ts`).
+5. **`scripts/fix-cjs-requires.mjs`** — post-processes CJS `require()` calls.
+
+Skipping the separate `tsc` pass or the alias rewrite yields a `dist` with either no types or unresolved `@/` imports.
+
+Output layout under `dist/`:
+
+```
+dist/
+├── index.{js,cjs,d.ts}
+├── ui/
+│   ├── index.{js,cjs,d.ts}
+│   ├── styles.css
+│   └── …per-component files…
+├── tokens/
+│   ├── index.{js,cjs,d.ts}
+│   └── index.css
+└── previews/
+    ├── index.{js,cjs,d.ts}
+    └── …per-preview files…
+```
+
+## Local linked development (e.g. modo)
+
+From the consumer project (`apps/modo`):
+
+```bash
+npm install file:../../uxm          # adjust path
+```
+
+Run `npm run dev` here to keep `dist/` fresh; the consumer's dev server picks up changes after each recompile.
+
+To iterate on the components themselves rather than on the integration, prefer `npm run dev:modo` — it needs no build step at all.
+
+## Releases
+
+**Releases are fully automated — never publish by hand.** Merging to `master` runs semantic-release in CI, which derives the version bump from the Conventional Commit types, writes `CHANGELOG.md`, stamps the AI-skill version markers, publishes to Nexus, and creates the GitLab release.
+
+This makes commit types carry semver meaning: `fix` → PATCH, `feat` → MINOR, a `BREAKING CHANGE:` footer → MAJOR. Running `npm version` or `npm publish` locally would desynchronise the tags from what CI has already released.
+
+## Contributing
+
+- **Add a component**: create `src/ui/{name}/` with `{name}.tsx`, `{name}.scss`, `index.ts`. Re-export from **both** the folder `index.ts` and `src/ui/index.ts`. Add the compiled stylesheet to `src/ui/styles.css` as `@import "./{name}/{name}.css";` in cascade order — the aggregator is hand-written, and a component whose `@import` is missing ships with no CSS. Add a `README.md` mirroring [`button/README.md`](src/ui/button/README.md) (simple) or [`data-table/README.md`](src/ui/data-table/README.md) (complex).
+- **Update the AI skill in the same change**: `skills/viax-uxm/` needs a catalog row, a cheatsheet row, and a bullet under `### Unreleased` in `SKILL.md`. Leave the version and component-count markers alone — CI stamps those at release via `scripts/stamp-skill-version.mjs`.
+- **Add a preview**: create `{name}-preview.tsx` next to the component — previews live beside their component, not in `src/previews/`. Use `PreviewProps` and project knob values as inline CSS vars so production CSS rules paint them. Never re-export a preview from a `src/ui/` barrel (see the tree-shake guarantee above).
+- **Add a token**: add an entry to `themeTokens` in `src/tokens/index.ts` and declare the `--color-*` variable in `src/tokens/index.css`. Reference it from component SCSS via `var(--uxm-foo-bar, var(--color-new-token))` — never hardcode a colour, spacing, or radius.
+- Commits follow conventional-commit format (`commitizen` + `commitlint` enforced via `husky`); `npm run commit` walks you through it. Commit types drive the released version — see [Releases](#releases).
+- Run `npm run lint && npm run typecheck && npm run build` before opening a merge request.
+
+## License
+
+UNLICENSED — internal Viax use.

package/dist/helpers/cn.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cn_exports = {};
+__export(cn_exports, {
+  cn: () => cn
+});
+module.exports = __toCommonJS(cn_exports);
+function cn(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cn
+});
+//# sourceMappingURL=cn.cjs.map

package/dist/helpers/cn.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/cn.ts"],"sourcesContent":["export function cn(...parts: Array<string | false | null | undefined>): string {\n  return parts.filter(Boolean).join(' ');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,SAAS,MAAM,OAAyD;AAC7E,SAAO,MAAM,OAAO,OAAO,EAAE,KAAK,GAAG;AACvC;","names":[]}

package/dist/helpers/cn.d.ts

@@ -0,0 +1,2 @@
+export declare function cn(...parts: Array<string | false | null | undefined>): string;
+//# sourceMappingURL=cn.d.ts.map

package/dist/helpers/cn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cn.d.ts","sourceRoot":"","sources":["../../src/helpers/cn.ts"],"names":[],"mappings":"AAAA,wBAAgB,EAAE,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,MAAM,CAE7E"}

package/dist/helpers/cn.js

@@ -0,0 +1,7 @@
+function cn(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+export {
+  cn
+};
+//# sourceMappingURL=cn.js.map

package/dist/helpers/cn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/cn.ts"],"sourcesContent":["export function cn(...parts: Array<string | false | null | undefined>): string {\n  return parts.filter(Boolean).join(' ');\n}\n"],"mappings":"AAAO,SAAS,MAAM,OAAyD;AAC7E,SAAO,MAAM,OAAO,OAAO,EAAE,KAAK,GAAG;AACvC;","names":[]}

package/dist/helpers/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var helpers_exports = {};
+module.exports = __toCommonJS(helpers_exports);
+__reExport(helpers_exports, require("./cn.cjs"), module.exports);
+__reExport(helpers_exports, require("./merge-described-by.cjs"), module.exports);
+__reExport(helpers_exports, require("./merge-refs.cjs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./cn.cjs"),
+  ...require("./merge-described-by.cjs"),
+  ...require("./merge-refs.cjs")
+});
+//# sourceMappingURL=index.cjs.map

package/dist/helpers/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/index.ts"],"sourcesContent":["// Barrel for internal helpers. Consumers should not depend on this path —\n// it lives at `dist/helpers/` only as a build artefact of bundle:false mode\n// and is intentionally absent from `package.json#exports`.\nexport * from './cn';\nexport * from './merge-described-by';\nexport * from './merge-refs';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAGA,4BAAc,iBAHd;AAIA,4BAAc,iCAJd;AAKA,4BAAc,yBALd;","names":[]}

package/dist/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cn.js';
+export * from './merge-described-by.js';
+export * from './merge-refs.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAGA,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC"}

package/dist/helpers/index.js

@@ -0,0 +1,4 @@
+export * from "./cn.js";
+export * from "./merge-described-by.js";
+export * from "./merge-refs.js";
+//# sourceMappingURL=index.js.map

package/dist/helpers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/index.ts"],"sourcesContent":["// Barrel for internal helpers. Consumers should not depend on this path —\n// it lives at `dist/helpers/` only as a build artefact of bundle:false mode\n// and is intentionally absent from `package.json#exports`.\nexport * from './cn';\nexport * from './merge-described-by';\nexport * from './merge-refs';\n"],"mappings":"AAGA,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/helpers/merge-described-by.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var merge_described_by_exports = {};
+__export(merge_described_by_exports, {
+  mergeDescribedBy: () => mergeDescribedBy
+});
+module.exports = __toCommonJS(merge_described_by_exports);
+function mergeDescribedBy(consumer, managedId) {
+  return [consumer, managedId].filter(Boolean).join(" ") || void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeDescribedBy
+});
+//# sourceMappingURL=merge-described-by.cjs.map

package/dist/helpers/merge-described-by.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/merge-described-by.ts"],"sourcesContent":["/**\n * Merge a consumer-supplied `aria-describedby` with a managed id (typically\n * the atom's own FieldError id) instead of letting one wipe the other.\n *\n * Every input-family atom spreads `...rest` and then sets its managed\n * `aria-describedby` after, so a bare `aria-describedby={error ? errorId :\n * undefined}` silently wipes a describedby the consumer passed — which is how\n * `FormField`'s hint ends up unread. Order puts the consumer's ids first,\n * the managed id last, matching reading order (what it is → why it's wrong).\n */\nexport function mergeDescribedBy(\n  consumer: string | undefined,\n  managedId: string | undefined,\n): string | undefined {\n  return [consumer, managedId].filter(Boolean).join(' ') || undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUO,SAAS,iBACd,UACA,WACoB;AACpB,SAAO,CAAC,UAAU,SAAS,EAAE,OAAO,OAAO,EAAE,KAAK,GAAG,KAAK;AAC5D;","names":[]}

package/dist/helpers/merge-described-by.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Merge a consumer-supplied `aria-describedby` with a managed id (typically
+ * the atom's own FieldError id) instead of letting one wipe the other.
+ *
+ * Every input-family atom spreads `...rest` and then sets its managed
+ * `aria-describedby` after, so a bare `aria-describedby={error ? errorId :
+ * undefined}` silently wipes a describedby the consumer passed — which is how
+ * `FormField`'s hint ends up unread. Order puts the consumer's ids first,
+ * the managed id last, matching reading order (what it is → why it's wrong).
+ */
+export declare function mergeDescribedBy(consumer: string | undefined, managedId: string | undefined): string | undefined;
+//# sourceMappingURL=merge-described-by.d.ts.map

package/dist/helpers/merge-described-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-described-by.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-described-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,MAAM,GAAG,SAAS,CAEpB"}

package/dist/helpers/merge-described-by.js

@@ -0,0 +1,7 @@
+function mergeDescribedBy(consumer, managedId) {
+  return [consumer, managedId].filter(Boolean).join(" ") || void 0;
+}
+export {
+  mergeDescribedBy
+};
+//# sourceMappingURL=merge-described-by.js.map

package/dist/helpers/merge-described-by.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/merge-described-by.ts"],"sourcesContent":["/**\n * Merge a consumer-supplied `aria-describedby` with a managed id (typically\n * the atom's own FieldError id) instead of letting one wipe the other.\n *\n * Every input-family atom spreads `...rest` and then sets its managed\n * `aria-describedby` after, so a bare `aria-describedby={error ? errorId :\n * undefined}` silently wipes a describedby the consumer passed — which is how\n * `FormField`'s hint ends up unread. Order puts the consumer's ids first,\n * the managed id last, matching reading order (what it is → why it's wrong).\n */\nexport function mergeDescribedBy(\n  consumer: string | undefined,\n  managedId: string | undefined,\n): string | undefined {\n  return [consumer, managedId].filter(Boolean).join(' ') || undefined;\n}\n"],"mappings":"AAUO,SAAS,iBACd,UACA,WACoB;AACpB,SAAO,CAAC,UAAU,SAAS,EAAE,OAAO,OAAO,EAAE,KAAK,GAAG,KAAK;AAC5D;","names":[]}

package/dist/helpers/merge-refs.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var merge_refs_exports = {};
+__export(merge_refs_exports, {
+  mergeRefs: () => mergeRefs
+});
+module.exports = __toCommonJS(merge_refs_exports);
+function setRef(ref, node) {
+  if (!ref) return () => {
+  };
+  if (typeof ref === "function") {
+    const cleanup = ref(node);
+    return typeof cleanup === "function" ? cleanup : () => ref(null);
+  }
+  ref.current = node;
+  return () => {
+    ref.current = null;
+  };
+}
+function mergeRefs(...refs) {
+  return (node) => {
+    const cleanups = refs.map((ref) => setRef(ref, node));
+    return () => {
+      for (const cleanup of cleanups) cleanup();
+    };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeRefs
+});
+//# sourceMappingURL=merge-refs.cjs.map

package/dist/helpers/merge-refs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/merge-refs.ts"],"sourcesContent":["import type { Ref, RefCallback } from 'react';\n\n/**\n * Attach `node` to a single ref (function or object) and return a cleanup that\n * detaches it. For a React 19 ref callback that returns its own cleanup, that\n * cleanup is used; otherwise (legacy callback, object ref) the cleanup applies\n * the legacy detach — call the callback with `null`, or reset `.current`.\n */\nfunction setRef<T>(ref: Ref<T> | undefined, node: T | null): () => void {\n  if (!ref) return () => {};\n  if (typeof ref === 'function') {\n    const cleanup = ref(node);\n    return typeof cleanup === 'function' ? cleanup : () => ref(null);\n  }\n  // Object ref — `.current` is readonly on RefObject<T> in the types, but\n  // assigning it is exactly how React itself populates object refs.\n  (ref as { current: T | null }).current = node;\n  return () => {\n    (ref as { current: T | null }).current = null;\n  };\n}\n\n/**\n * Merge several refs into one callback ref, so a single element can feed BOTH\n * a ref the component owns internally AND one passed in by the consumer.\n *\n * Handles function refs and object refs (`{ current }`); `null` / `undefined`\n * entries are skipped. Returns a `RefCallback` — assign it to the element's\n * `ref`. Callers should memoise the result (`useMemo`) on the external ref so\n * the callback identity is stable across renders and React doesn't detach /\n * reattach every commit.\n *\n * React 19 aware: the returned callback returns an aggregate cleanup, so a\n * child ref callback that itself returns a cleanup (the React 19 style) has\n * that cleanup run on detach — while object refs and legacy `(node|null)`\n * callbacks are still reset on detach via the same aggregate.\n */\nexport function mergeRefs<T>(...refs: Array<Ref<T> | undefined>): RefCallback<T> {\n  return (node: T | null) => {\n    const cleanups = refs.map((ref) => setRef(ref, node));\n    return () => {\n      for (const cleanup of cleanups) cleanup();\n    };\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,OAAU,KAAyB,MAA4B;AACtE,MAAI,CAAC,IAAK,QAAO,MAAM;AAAA,EAAC;AACxB,MAAI,OAAO,QAAQ,YAAY;AAC7B,UAAM,UAAU,IAAI,IAAI;AACxB,WAAO,OAAO,YAAY,aAAa,UAAU,MAAM,IAAI,IAAI;AAAA,EACjE;AAGA,EAAC,IAA8B,UAAU;AACzC,SAAO,MAAM;AACX,IAAC,IAA8B,UAAU;AAAA,EAC3C;AACF;AAiBO,SAAS,aAAgB,MAAiD;AAC/E,SAAO,CAAC,SAAmB;AACzB,UAAM,WAAW,KAAK,IAAI,CAAC,QAAQ,OAAO,KAAK,IAAI,CAAC;AACpD,WAAO,MAAM;AACX,iBAAW,WAAW,SAAU,SAAQ;AAAA,IAC1C;AAAA,EACF;AACF;","names":[]}

package/dist/helpers/merge-refs.d.ts

@@ -0,0 +1,18 @@
+import type { Ref, RefCallback } from 'react';
+/**
+ * Merge several refs into one callback ref, so a single element can feed BOTH
+ * a ref the component owns internally AND one passed in by the consumer.
+ *
+ * Handles function refs and object refs (`{ current }`); `null` / `undefined`
+ * entries are skipped. Returns a `RefCallback` — assign it to the element's
+ * `ref`. Callers should memoise the result (`useMemo`) on the external ref so
+ * the callback identity is stable across renders and React doesn't detach /
+ * reattach every commit.
+ *
+ * React 19 aware: the returned callback returns an aggregate cleanup, so a
+ * child ref callback that itself returns a cleanup (the React 19 style) has
+ * that cleanup run on detach — while object refs and legacy `(node|null)`
+ * callbacks are still reset on detach via the same aggregate.
+ */
+export declare function mergeRefs<T>(...refs: Array<Ref<T> | undefined>): RefCallback<T>;
+//# sourceMappingURL=merge-refs.d.ts.map

package/dist/helpers/merge-refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-refs.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-refs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAsB9C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAO/E"}

package/dist/helpers/merge-refs.js

@@ -0,0 +1,24 @@
+function setRef(ref, node) {
+  if (!ref) return () => {
+  };
+  if (typeof ref === "function") {
+    const cleanup = ref(node);
+    return typeof cleanup === "function" ? cleanup : () => ref(null);
+  }
+  ref.current = node;
+  return () => {
+    ref.current = null;
+  };
+}
+function mergeRefs(...refs) {
+  return (node) => {
+    const cleanups = refs.map((ref) => setRef(ref, node));
+    return () => {
+      for (const cleanup of cleanups) cleanup();
+    };
+  };
+}
+export {
+  mergeRefs
+};
+//# sourceMappingURL=merge-refs.js.map

package/dist/helpers/merge-refs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/helpers/merge-refs.ts"],"sourcesContent":["import type { Ref, RefCallback } from 'react';\n\n/**\n * Attach `node` to a single ref (function or object) and return a cleanup that\n * detaches it. For a React 19 ref callback that returns its own cleanup, that\n * cleanup is used; otherwise (legacy callback, object ref) the cleanup applies\n * the legacy detach — call the callback with `null`, or reset `.current`.\n */\nfunction setRef<T>(ref: Ref<T> | undefined, node: T | null): () => void {\n  if (!ref) return () => {};\n  if (typeof ref === 'function') {\n    const cleanup = ref(node);\n    return typeof cleanup === 'function' ? cleanup : () => ref(null);\n  }\n  // Object ref — `.current` is readonly on RefObject<T> in the types, but\n  // assigning it is exactly how React itself populates object refs.\n  (ref as { current: T | null }).current = node;\n  return () => {\n    (ref as { current: T | null }).current = null;\n  };\n}\n\n/**\n * Merge several refs into one callback ref, so a single element can feed BOTH\n * a ref the component owns internally AND one passed in by the consumer.\n *\n * Handles function refs and object refs (`{ current }`); `null` / `undefined`\n * entries are skipped. Returns a `RefCallback` — assign it to the element's\n * `ref`. Callers should memoise the result (`useMemo`) on the external ref so\n * the callback identity is stable across renders and React doesn't detach /\n * reattach every commit.\n *\n * React 19 aware: the returned callback returns an aggregate cleanup, so a\n * child ref callback that itself returns a cleanup (the React 19 style) has\n * that cleanup run on detach — while object refs and legacy `(node|null)`\n * callbacks are still reset on detach via the same aggregate.\n */\nexport function mergeRefs<T>(...refs: Array<Ref<T> | undefined>): RefCallback<T> {\n  return (node: T | null) => {\n    const cleanups = refs.map((ref) => setRef(ref, node));\n    return () => {\n      for (const cleanup of cleanups) cleanup();\n    };\n  };\n}\n"],"mappings":"AAQA,SAAS,OAAU,KAAyB,MAA4B;AACtE,MAAI,CAAC,IAAK,QAAO,MAAM;AAAA,EAAC;AACxB,MAAI,OAAO,QAAQ,YAAY;AAC7B,UAAM,UAAU,IAAI,IAAI;AACxB,WAAO,OAAO,YAAY,aAAa,UAAU,MAAM,IAAI,IAAI;AAAA,EACjE;AAGA,EAAC,IAA8B,UAAU;AACzC,SAAO,MAAM;AACX,IAAC,IAA8B,UAAU;AAAA,EAC3C;AACF;AAiBO,SAAS,aAAgB,MAAiD;AAC/E,SAAO,CAAC,SAAmB;AACzB,UAAM,WAAW,KAAK,IAAI,CAAC,QAAQ,OAAO,KAAK,IAAI,CAAC;AACpD,WAAO,MAAM;AACX,iBAAW,WAAW,SAAU,SAAQ;AAAA,IAC1C;AAAA,EACF;AACF;","names":[]}

package/dist/hooks/use-dismiss.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var use_dismiss_exports = {};
+__export(use_dismiss_exports, {
+  useDismiss: () => useDismiss
+});
+module.exports = __toCommonJS(use_dismiss_exports);
+var import_react = require("react");
+function useDismiss({
+  enabled,
+  onDismiss,
+  refs,
+  excludeClosest,
+  closeOnEscape = true,
+  closeOnOutsideClick = true
+}) {
+  (0, import_react.useEffect)(() => {
+    if (!enabled || !closeOnOutsideClick) return;
+    function onMouseDown(e) {
+      const target = e.target;
+      if (!target) return;
+      for (const ref of refs) {
+        if (ref.current?.contains(target)) return;
+      }
+      if (excludeClosest && target instanceof Element) {
+        for (const selector of excludeClosest) {
+          if (target.closest(selector)) return;
+        }
+      }
+      onDismiss();
+    }
+    document.addEventListener("mousedown", onMouseDown);
+    return () => document.removeEventListener("mousedown", onMouseDown);
+  }, [enabled, closeOnOutsideClick, refs, excludeClosest, onDismiss]);
+  (0, import_react.useEffect)(() => {
+    if (!enabled || !closeOnEscape) return;
+    function onKeyDown(e) {
+      if (e.key === "Escape") {
+        e.stopPropagation();
+        onDismiss();
+      }
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [enabled, closeOnEscape, onDismiss]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDismiss
+});
+//# sourceMappingURL=use-dismiss.cjs.map

package/dist/hooks/use-dismiss.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-dismiss.ts"],"sourcesContent":["import { useEffect, type RefObject } from 'react';\n\nexport interface UseDismissOptions {\n  /** Only attach listeners while true. */\n  enabled: boolean;\n  /** Called when the user requests dismissal (Escape or outside click). */\n  onDismiss: () => void;\n  /**\n   * Refs whose elements are considered \"inside\" — clicks landing on these\n   * (or their descendants) do NOT dismiss. Pass the trigger AND the panel\n   * for popovers; pass just the panel for modal dialogs (clicks outside\n   * the panel = backdrop = dismiss).\n   *\n   * **Must be a stable/memoized array** (e.g. built with `useMemo`, or a\n   * ref/module-level constant) — it's a direct dependency of the outside-click\n   * effect below, so passing a fresh inline array literal on every render\n   * causes the `mousedown` listener to be torn down and re-subscribed on\n   * every render. See `popover.tsx`'s `dismissRefs` for the pattern.\n   */\n  refs: Array<RefObject<HTMLElement | null>>;\n  /**\n   * Selectors that also count as \"inside\" via `closest()`. Use for\n   * portaled child floating layers — a popover/listbox opened INSIDE a\n   * dialog mounts to `document.body`, so it's not a DOM descendant of\n   * the dialog's panel ref. Without this, picking an option in a nested\n   * dropdown would dismiss the surrounding dialog.\n   *\n   * Conventional list for dialog-like consumers: `[\".uxm-popover\"]`.\n   */\n  excludeClosest?: string[];\n  /** Default true. */\n  closeOnEscape?: boolean;\n  /** Default true. */\n  closeOnOutsideClick?: boolean;\n}\n\n/**\n * Shared dismissal primitive for floating UI (popovers, dialogs, date/time\n * pickers). Replaces three near-identical copies that previously lived\n * across popover.tsx, date-input.tsx, and time-input.tsx.\n *\n * Why `mousedown` rather than `click`: mousedown fires BEFORE focus\n * shifts, so clicking a different focusable element closes us cleanly\n * without leaving the floating panel briefly focused.\n *\n * Why `stopPropagation` on Escape: nested floating things (popover\n * inside a dialog) should close one layer at a time. The innermost\n * handler stops propagation so the outer's Escape doesn't also fire.\n *\n * Caller contract: `refs` (and `excludeClosest`, if passed) must be\n * stable/memoized — see the `refs` option doc below. An inline array\n * literal re-subscribes the outside-click listener on every render.\n */\nexport function useDismiss({\n  enabled,\n  onDismiss,\n  refs,\n  excludeClosest,\n  closeOnEscape = true,\n  closeOnOutsideClick = true,\n}: UseDismissOptions): void {\n  useEffect(() => {\n    if (!enabled || !closeOnOutsideClick) return;\n    function onMouseDown(e: MouseEvent) {\n      const target = e.target as Node | null;\n      if (!target) return;\n      for (const ref of refs) {\n        if (ref.current?.contains(target)) return;\n      }\n      if (excludeClosest && target instanceof Element) {\n        for (const selector of excludeClosest) {\n          if (target.closest(selector)) return;\n        }\n      }\n      onDismiss();\n    }\n    document.addEventListener('mousedown', onMouseDown);\n    return () => document.removeEventListener('mousedown', onMouseDown);\n  }, [enabled, closeOnOutsideClick, refs, excludeClosest, onDismiss]);\n\n  useEffect(() => {\n    if (!enabled || !closeOnEscape) return;\n    function onKeyDown(e: KeyboardEvent) {\n      if (e.key === 'Escape') {\n        e.stopPropagation();\n        onDismiss();\n      }\n    }\n    document.addEventListener('keydown', onKeyDown);\n    return () => document.removeEventListener('keydown', onKeyDown);\n  }, [enabled, closeOnEscape, onDismiss]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0C;AAqDnC,SAAS,WAAW;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,gBAAgB;AAAA,EAChB,sBAAsB;AACxB,GAA4B;AAC1B,8BAAU,MAAM;AACd,QAAI,CAAC,WAAW,CAAC,oBAAqB;AACtC,aAAS,YAAY,GAAe;AAClC,YAAM,SAAS,EAAE;AACjB,UAAI,CAAC,OAAQ;AACb,iBAAW,OAAO,MAAM;AACtB,YAAI,IAAI,SAAS,SAAS,MAAM,EAAG;AAAA,MACrC;AACA,UAAI,kBAAkB,kBAAkB,SAAS;AAC/C,mBAAW,YAAY,gBAAgB;AACrC,cAAI,OAAO,QAAQ,QAAQ,EAAG;AAAA,QAChC;AAAA,MACF;AACA,gBAAU;AAAA,IACZ;AACA,aAAS,iBAAiB,aAAa,WAAW;AAClD,WAAO,MAAM,SAAS,oBAAoB,aAAa,WAAW;AAAA,EACpE,GAAG,CAAC,SAAS,qBAAqB,MAAM,gBAAgB,SAAS,CAAC;AAElE,8BAAU,MAAM;AACd,QAAI,CAAC,WAAW,CAAC,cAAe;AAChC,aAAS,UAAU,GAAkB;AACnC,UAAI,EAAE,QAAQ,UAAU;AACtB,UAAE,gBAAgB;AAClB,kBAAU;AAAA,MACZ;AAAA,IACF;AACA,aAAS,iBAAiB,WAAW,SAAS;AAC9C,WAAO,MAAM,SAAS,oBAAoB,WAAW,SAAS;AAAA,EAChE,GAAG,CAAC,SAAS,eAAe,SAAS,CAAC;AACxC;","names":[]}