@12-apps/ui 6.49.3 → 6.50.1

package/dist/tokens.js

@@ -11,15 +11,15 @@ import {
 import {
   densityThemeOptions,
   useDensity
-} from "./chunk-3WWI75NM.js";
+} from "./chunk-SJ4IAZ3V.js";
 import {
   chipDensityOverrides,
   iconButtonDensityOverrides
-} from "./chunk-XK77FY42.js";
+} from "./chunk-25MSGLNU.js";
 import {
   checkboxRadioDensityOverrides,
   switchDensityOverrides
-} from "./chunk-4ELI2MM3.js";
+} from "./chunk-GAXHYRX6.js";
 import {
   paginationItemDensityOverrides,
   sliderDensityOverrides,
@@ -27,7 +27,7 @@ import {
   tableCellDensityOverrides,
   tabsIndicatorDensityOverrides,
   toggleButtonDensityOverrides
-} from "./chunk-K3YHXOWZ.js";
+} from "./chunk-NP6SHLQ3.js";
 import {
   headingMetrics
 } from "./chunk-PT6TCWIW.js";
@@ -40,7 +40,7 @@ import {
   fieldOverrides,
   fieldTextFieldStyles,
   mergeMuiComponents
-} from "./chunk-M47ZOUGF.js";
+} from "./chunk-2TZ6X265.js";
 import "./chunk-7FDU3FIN.js";
 import "./chunk-EPEJMTCQ.js";
 import {

package/dist/types/tokens/density-overrides.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"density-overrides.d.ts","sourceRoot":"","sources":["../../../src/tokens/density-overrides.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAa,KAAK,EAAE,MAAM,+BAA+B,CAAC;AAQlF,OAAO,EACL,4BAA4B,EAC5B,mBAAmB,EACnB,6BAA6B,EAC7B,yBAAyB,EACzB,8BAA8B,EAC9B,sBAAsB,GACvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,6BAA6B,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AA8GtG,4DAA4D;AAC5D,wBAAgB,0BAA0B,IAAI,UAAU,CAAC,KAAK,CAAC,CAU9D;AAwCD,2FAA2F;AAC3F,wBAAgB,oBAAoB,IAAI,UAAU,CAAC,KAAK,CAAC,CAWxD"}
+{"version":3,"file":"density-overrides.d.ts","sourceRoot":"","sources":["../../../src/tokens/density-overrides.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAa,KAAK,EAAE,MAAM,+BAA+B,CAAC;AAQlF,OAAO,EACL,4BAA4B,EAC5B,mBAAmB,EACnB,6BAA6B,EAC7B,yBAAyB,EACzB,8BAA8B,EAC9B,sBAAsB,GACvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,6BAA6B,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AA4HtG,4DAA4D;AAC5D,wBAAgB,0BAA0B,IAAI,UAAU,CAAC,KAAK,CAAC,CAU9D;AA0CD,2FAA2F;AAC3F,wBAAgB,oBAAoB,IAAI,UAAU,CAAC,KAAK,CAAC,CAWxD"}

package/dist/types/tokens/density-overrides.navigation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"density-overrides.navigation.d.ts","sourceRoot":"","sources":["../../../src/tokens/density-overrides.navigation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAa,KAAK,EAAE,MAAM,+BAA+B,CAAC;AAsDlF,8DAA8D;AAC9D,wBAAgB,4BAA4B,IAAI,UAAU,CAAC,KAAK,CAAC,CAUhE;AAYD,iFAAiF;AACjF,wBAAgB,mBAAmB,IAAI,UAAU,CAAC,KAAK,CAAC,CASvD;AAoBD,oEAAoE;AACpE,wBAAgB,yBAAyB,IAAI,UAAU,CAAC,KAAK,CAAC,CAS7D;AA0BD;;;GAGG;AACH,wBAAgB,8BAA8B,IAAI,UAAU,CAAC,KAAK,CAAC,CAUlE;AAwBD,8FAA8F;AAC9F,wBAAgB,sBAAsB,IAAI,UAAU,CAAC,KAAK,CAAC,CAW1D;AAsBD,0DAA0D;AAC1D,wBAAgB,6BAA6B,IAAI,UAAU,CAAC,KAAK,CAAC,CAQjE"}
+{"version":3,"file":"density-overrides.navigation.d.ts","sourceRoot":"","sources":["../../../src/tokens/density-overrides.navigation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAa,KAAK,EAAE,MAAM,+BAA+B,CAAC;AA+ElF,8DAA8D;AAC9D,wBAAgB,4BAA4B,IAAI,UAAU,CAAC,KAAK,CAAC,CAUhE;AAYD,iFAAiF;AACjF,wBAAgB,mBAAmB,IAAI,UAAU,CAAC,KAAK,CAAC,CASvD;AAiCD,oEAAoE;AACpE,wBAAgB,yBAAyB,IAAI,UAAU,CAAC,KAAK,CAAC,CAS7D;AA0BD;;;GAGG;AACH,wBAAgB,8BAA8B,IAAI,UAAU,CAAC,KAAK,CAAC,CAUlE;AAwBD,8FAA8F;AAC9F,wBAAgB,sBAAsB,IAAI,UAAU,CAAC,KAAK,CAAC,CAW1D;AAsBD,0DAA0D;AAC1D,wBAAgB,6BAA6B,IAAI,UAAU,CAAC,KAAK,CAAC,CAQjE"}

package/dist/types/tokens/density-overrides.selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"density-overrides.selection.d.ts","sourceRoot":"","sources":["../../../src/tokens/density-overrides.selection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAa,KAAK,EAAE,MAAM,+BAA+B,CAAC;AAoIlF;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,IAAI,UAAU,CAAC,KAAK,CAAC,CAKjE;AAgDD;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,UAAU,CAAC,KAAK,CAAC,CAW1D"}
+{"version":3,"file":"density-overrides.selection.d.ts","sourceRoot":"","sources":["../../../src/tokens/density-overrides.selection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAa,KAAK,EAAE,MAAM,+BAA+B,CAAC;AAuIlF;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,IAAI,UAAU,CAAC,KAAK,CAAC,CAKjE;AA8DD;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,UAAU,CAAC,KAAK,CAAC,CAW1D"}

package/dist/types/tokens/density.d.ts

@@ -104,5 +104,5 @@ export declare function useDensity(): ResolvedDensity;
  * createTheme(outer, { ...densityThemeOptions('compact') });
  * ```
  */
-export declare function densityThemeOptions(density: DensityLevel | number, factors?: Partial<Record<DensityLevel, number>>, fieldRadius?: number): Pick<ThemeOptions, 'typography' | 'spacing' | 'fieldHeight' | 'components'>;
+export declare function densityThemeOptions(density: DensityLevel | number, factors?: Partial<Record<DensityLevel, number>>, fieldRadius?: number): Pick<ThemeOptions, 'typography' | 'spacing' | 'fieldHeight' | 'fieldRadius' | 'components'>;
 //# sourceMappingURL=density.d.ts.map

package/dist/types/tokens/density.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"density.d.ts","sourceRoot":"","sources":["../../../src/tokens/density.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,EAKL,KAAK,YAAY,EACjB,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAC;AAgBxB;;;;;;GAMG;AAEH,OAAO,EACL,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC;AAExB,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,KAAK;QACb,iFAAiF;QACjF,OAAO,CAAC,EAAE,eAAe,CAAC;KAC3B;IACD,UAAU,YAAY;QACpB,iFAAiF;QACjF,OAAO,CAAC,EAAE,eAAe,CAAC;KAC3B;CACF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,IAAI,eAAe,CAE5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,YAAY,GAAG,MAAM,EAC9B,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,EAC/C,WAAW,GAAE,MAA6B,GACzC,IAAI,CAAC,YAAY,EAAE,YAAY,GAAG,SAAS,GAAG,aAAa,GAAG,YAAY,CAAC,CAqB7E"}
+{"version":3,"file":"density.d.ts","sourceRoot":"","sources":["../../../src/tokens/density.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,EAKL,KAAK,YAAY,EACjB,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAC;AAgBxB;;;;;;GAMG;AAEH,OAAO,EACL,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC;AAExB,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,KAAK;QACb,iFAAiF;QACjF,OAAO,CAAC,EAAE,eAAe,CAAC;KAC3B;IACD,UAAU,YAAY;QACpB,iFAAiF;QACjF,OAAO,CAAC,EAAE,eAAe,CAAC;KAC3B;CACF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,IAAI,eAAe,CAE5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,YAAY,GAAG,MAAM,EAC9B,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,EAC/C,WAAW,GAAE,MAA6B,GACzC,IAAI,CAAC,YAAY,EAAE,YAAY,GAAG,SAAS,GAAG,aAAa,GAAG,aAAa,GAAG,YAAY,CAAC,CA2B7F"}

package/dist/types/tokens/field-height.d.ts

@@ -49,6 +49,30 @@ export declare function fieldHeightOverrides(height?: number): Components<Theme>
  * top-level objects would drop every override but the last source's for a
  * component two sources both style (`fieldOverrides` below merges exactly
  * two; density's geometry overrides, FUT-2766–2768, add more).
+ *
+ * `styleOverrides` keeps the rule above, wholesale by inner slot key, with NO
+ * new closures — a slot's value is taken by reference from whichever source
+ * set it last, never wrapped, so two theme builds from the same options still
+ * compare equal (see `mergeMuiComponents`'s own suite).
+ *
+ * Three more keys survive the merge (FUT-2967), where they used to be
+ * silently dropped the moment a SECOND source styled the same component —
+ * exactly the shape density (FUT-2766–2768) and a host's own `components`
+ * both touching one component now takes:
+ *
+ *   - `defaultProps` — a SHALLOW merge, the later source winning per key
+ *     (the same precedence `styleOverrides` uses per slot, one level up);
+ *   - `variants` — every source's array CONCATENATED, earlier first, so a
+ *     host's own variant and a density/base one coexist rather than one
+ *     replacing the other;
+ *   - any OTHER top-level key on a component entry — taken from the later
+ *     source, the same "later wins" rule `styleOverrides` applies per slot,
+ *     just one level up, for a component key this function does not know the
+ *     shape of.
+ *
+ * A component only ONE source names keeps whatever that source gave it
+ * unchanged — `styleOverrides` alone if that is all it had, `defaultProps`/
+ * `variants` alone if that is all it had.
  */
 export declare function mergeMuiComponents(...sources: Components<Theme>[]): Components<Theme>;
 /**

package/dist/types/tokens/field-height.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field-height.d.ts","sourceRoot":"","sources":["../../../src/tokens/field-height.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,+BAA+B,CAAC;AAYlF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;GAOG;AAEH,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,cAAc,GACf,MAAM,qBAAqB,CAAC;AAE7B,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,KAAK;QACb,iHAAiH;QACjH,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB;IACD,UAAU,YAAY;QACpB,kHAAkH;QAClH,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB;CACF;AAED,4FAA4F;AAC5F,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE/D;AAED,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,SAAgB,GAAG,MAAM,CAExE;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAElE;AAQD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,SAAgB,GAAG,SAAS,CAgBlF;AASD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,MAA6B,GAAG,UAAU,CAAC,KAAK,CAAC,CAgB7F;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,OAAO,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,GAAG,UAAU,CAAC,KAAK,CAAC,CAUrF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,CAExG;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,SAAgB,GAAG,SAAS,CAMpF"}
+{"version":3,"file":"field-height.d.ts","sourceRoot":"","sources":["../../../src/tokens/field-height.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,+BAA+B,CAAC;AAYlF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;GAOG;AAEH,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,cAAc,GACf,MAAM,qBAAqB,CAAC;AAE7B,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,KAAK;QACb,iHAAiH;QACjH,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB;IACD,UAAU,YAAY;QACpB,kHAAkH;QAClH,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB;CACF;AAED,4FAA4F;AAC5F,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE/D;AAED,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,SAAgB,GAAG,MAAM,CAExE;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAElE;AAQD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,SAAgB,GAAG,SAAS,CAgBlF;AASD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,MAA6B,GAAG,UAAU,CAAC,KAAK,CAAC,CAgB7F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,OAAO,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,GAAG,UAAU,CAAC,KAAK,CAAC,CAiCrF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,CAExG;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,GAAE,SAAgB,GAAG,SAAS,CAMpF"}

package/dist/user-avatar.js

@@ -1,7 +1,7 @@
 import {
   UserAvatar,
   UserMenu
-} from "./chunk-UUJ7J7NE.js";
+} from "./chunk-MG3SRQ6N.js";
 import "./chunk-UDQSIRAP.js";
 import "./chunk-PGPPN63I.js";
 import "./chunk-TNQDSTIA.js";
@@ -15,14 +15,14 @@ import "./chunk-76X6JRVI.js";
 import "./chunk-FKUYRQSP.js";
 import "./chunk-JH7EEJEQ.js";
 import "./chunk-BA4RHQ3B.js";
-import "./chunk-K6LNHHSH.js";
-import "./chunk-ZKWVCSAB.js";
+import "./chunk-RIZRF5XR.js";
+import "./chunk-LTE2QHBH.js";
 import "./chunk-LN46DSMF.js";
 import "./chunk-TAMIZE4Q.js";
 import "./chunk-YZHX2HTC.js";
 import "./chunk-6IWO7CM2.js";
 import "./chunk-TYJR4GOF.js";
-import "./chunk-M47ZOUGF.js";
+import "./chunk-2TZ6X265.js";
 import "./chunk-7FDU3FIN.js";
 import "./chunk-EPEJMTCQ.js";
 import "./chunk-GDN2LUTZ.js";

package/dist/utility/WorkflowStep.js

@@ -7,12 +7,12 @@ import "../chunk-KNWG77FB.js";
 import "../chunk-TM5QQJTF.js";
 import "../chunk-3IPPMWUA.js";
 import "../chunk-7ZPUN7TV.js";
-import "../chunk-3WWI75NM.js";
-import "../chunk-XK77FY42.js";
-import "../chunk-4ELI2MM3.js";
-import "../chunk-K3YHXOWZ.js";
+import "../chunk-SJ4IAZ3V.js";
+import "../chunk-25MSGLNU.js";
+import "../chunk-GAXHYRX6.js";
+import "../chunk-NP6SHLQ3.js";
 import "../chunk-PT6TCWIW.js";
-import "../chunk-M47ZOUGF.js";
+import "../chunk-2TZ6X265.js";
 import "../chunk-7FDU3FIN.js";
 import "../chunk-EPEJMTCQ.js";
 import "../chunk-GDN2LUTZ.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@12-apps/ui",
-  "version": "6.49.3",
+  "version": "6.50.1",
   "license": "MIT",
   "packageManager": "pnpm@10.34.5",
   "type": "module",

package/src/tokens/density-overrides.navigation.ts

@@ -1,6 +1,7 @@
-import { tableCellClasses } from '@mui/material/TableCell/index.js';
+import generateUtilityClass from '@mui/material/generateUtilityClass/index.js';
 import type { Components, CSSObject, Theme } from '@mui/material/styles/index.js';
 
+import { fieldRadius } from './field-radius';
 import { rem, rems } from './relative';
 
 /**
@@ -16,7 +17,9 @@ import { rem, rems } from './relative';
  * them outright:
  *
  * - `ToggleButton`: `padding: 11/7/15` at medium(root)/small/large — same
- *   `root`/`sizeSmall`/`sizeLarge` shape as `iconButtonDensityOverrides`.
+ *   `root`/`sizeSmall`/`sizeLarge` shape as `iconButtonDensityOverrides`. The
+ *   `root` slot ALSO carries `theme.fieldRadius` (FUT-2967, `field-radius.ts`)
+ *   — see the note at the end of this docblock.
  * - `Tab`: `minHeight: 48`, `padding: '12px 16px'` on the root (via `rems()`).
  *   The icon+label combo (`minHeight: 72`, `paddingTop`/`Bottom: 9`) is a
  *   SEPARATE MUI variant, exposed as the `labelIcon` key.
@@ -46,10 +49,32 @@ import { rem, rems } from './relative';
  * `rem(theme, boxPx(size))` (`40` at `md`) — higher specificity than any
  * `MuiAvatar.styleOverrides.root`, dead code here, so it ships none.
  *
- * Geometry-neutral at `normal`; each slot a MODULE-LEVEL function, as above.
+ * PADDING is geometry-neutral at `normal` — the same 11/7/15 literals
+ * `ToggleButton.js` hard-codes; each slot a MODULE-LEVEL function, as above.
+ *
+ * `MuiToggleButton.root` is the one exception, and it is NOT neutral even at
+ * `normal` (FUT-2967): `fieldRadiusOverrides` (`field-radius.ts`) and this
+ * callback both style `MuiToggleButton.root` — the radius override's own
+ * `{ borderRadius }` and this one's `{ padding }` — and a `styleOverrides`
+ * slot two sources touch is replaced WHOLESALE by whichever is spread last
+ * (`mergeMuiComponents`), so a theme built with density silently dropped the
+ * field radius off a bare `<ToggleButton>` the moment density's `root`
+ * callback (this one) was the later source. Fixed AT THE SOURCE rather than
+ * in the merge: this MODULE-LEVEL callback (still a single, stable reference,
+ * so two builds still compare equal) reads `theme.fieldRadius` itself and
+ * returns the corner alongside the padding, so there is no second `root`
+ * value for a later merge to lose. The consequence is deliberate and worth
+ * naming: a host that applies ONLY `toggleButtonDensityOverrides()` to a
+ * plain MUI theme now gets the FIELD radius (8px, `DEFAULT_FIELD_RADIUS`) on
+ * `<ToggleButton>`, not MUI's own `shape.borderRadius` (4px) — matching the
+ * fields beside it, not a MUI default nothing else in this package still
+ * draws with.
  */
 
-const toggleButtonRootPadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 11) });
+const toggleButtonRootPadding = ({ theme }: { theme: Theme }): CSSObject => ({
+  padding: rem(theme, 11),
+  borderRadius: fieldRadius(theme),
+});
 const toggleButtonSmallPadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 7) });
 const toggleButtonLargePadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 15) });
 
@@ -98,9 +123,22 @@ const isDefaultTableCellPadding = (padding: TableCellOwnerStateForOverrides['pad
 const tableCellRootPadding: TableCellStyleFn = ({ theme, ownerState }) =>
   isDefaultTableCellPadding(ownerState?.padding) ? { padding: rem(theme, 16) } : {};
 
+/**
+ * Built with `generateUtilityClass`, not imported from
+ * `@mui/material/TableCell`'s own `tableCellClasses` — the same generated
+ * string (`TableCell.js` builds `tableCellClasses` from this exact helper),
+ * but without pulling `MuiTableCell` onto the critical path of every host
+ * that imports `densityThemeOptions`, the same reason `density-overrides.ts`'s
+ * `CHIP_LABEL` and `density-overrides.selection.ts`'s `SWITCH_*` constants
+ * are built this way instead of read off the component's own classes module
+ * (FUT-2993). It also honours a host's own `ClassNameGenerator.configure`,
+ * which a hand-typed `.MuiTableCell-paddingCheckbox` string would not.
+ */
+const TABLE_CELL_PADDING_CHECKBOX = generateUtilityClass('MuiTableCell', 'paddingCheckbox');
+
 const tableCellSmallPadding: TableCellStyleFn = ({ theme, ownerState }) => {
   const style: CSSObject = {
-    [`&.${tableCellClasses.paddingCheckbox}`]: { padding: rems(theme, 0, 12, 0, 16) },
+    [`&.${TABLE_CELL_PADDING_CHECKBOX}`]: { padding: rems(theme, 0, 12, 0, 16) },
   };
   if (isDefaultTableCellPadding(ownerState?.padding)) style.padding = rems(theme, 6, 16);
   return style;

package/src/tokens/density-overrides.selection.ts

@@ -1,4 +1,4 @@
-import { switchClasses } from '@mui/material/Switch/index.js';
+import generateUtilityClass from '@mui/material/generateUtilityClass/index.js';
 import type { Components, CSSObject, Theme } from '@mui/material/styles/index.js';
 
 import { rem, rems } from './relative';
@@ -94,14 +94,17 @@ import { rem, rems } from './relative';
  *   (one class) cannot out-specificity it, so at `size="small"` it would
  *   silently keep rendering MUI's unthemed `4px`/`16×16` at every density,
  *   the click target and thumb staying full-size while the track around them
- *   shrank. Fixed the same way: `sizeSmall`'s OWN nested `& .${switchClasses
- *   .switchBase}` / `& .${switchClasses.thumb}` rules, read through
- *   `switchClasses` (not a hand-typed selector string) for the same
- *   `ClassNameGenerator.configure` reason `chipClasses` is above, inserted
- *   as part of the SAME `sizeSmall` override object so they land AFTER
- *   `SwitchRoot`'s own baked-in small variant in the generated class's CSS
- *   text (later wins at matching two-class specificity) rather than trying
- *   to out-specificity it from a different slot.
+ *   shrank. Fixed the same way: `sizeSmall`'s OWN nested `& .${SWITCH_SWITCH_
+ *   BASE}` / `& .${SWITCH_THUMB}` rules, built with `generateUtilityClass`
+ *   (not a hand-typed selector string) for the same `ClassNameGenerator
+ *   .configure` reason `density-overrides.ts`'s `CHIP_LABEL` is — and, unlike
+ *   reading `switchClasses` off `@mui/material/Switch` itself, without
+ *   putting `MuiSwitch` on the critical path of every host that imports
+ *   `densityThemeOptions` (FUT-2993) — inserted as part of the SAME
+ *   `sizeSmall` override object so they land AFTER `SwitchRoot`'s own baked-in
+ *   small variant in the generated class's CSS text (later wins at matching
+ *   two-class specificity) rather than trying to out-specificity it from a
+ *   different slot.
  *
  * **The checked thumb's own travel distance is a FOURTH literal, found only
  * on adversarial review of the PR this doc comment first shipped in.**
@@ -111,7 +114,7 @@ import { rem, rems } from './relative';
  * `density: 'compact'` the checked thumb kept travelling the FULL, unscaled
  * distance while the track around it shrank ×0.9 — a visible overshoot.
  * `switchSwitchBasePadding`/`switchSizeSmall` each now carry their own
- * `&.${switchClasses.checked}` rule (`translateX(rem(theme, 20))`/`rem(theme,
+ * `&.${SWITCH_CHECKED}` rule (`translateX(rem(theme, 20))`/`rem(theme,
  * 16)`), composed onto the SAME generated class, in the SAME position
  * `padding` already occupies — so it wins by the identical mechanism, not a
  * new one. Proven at the pixel level, both sizes/densities: `switch-md-
@@ -146,6 +149,20 @@ export function checkboxRadioDensityOverrides(): Components<Theme> {
   };
 }
 
+/**
+ * Built with `generateUtilityClass`, not imported from `@mui/material/Switch`'s
+ * own `switchClasses` — the same generated strings (`Switch.js` builds
+ * `switchClasses` from this exact helper), but without pulling `MuiSwitch`
+ * onto the critical path of every host that imports `densityThemeOptions`
+ * (see the module doc comment, and FUT-2993). `SWITCH_CHECKED` is a GLOBAL
+ * state slot (`generateUtilityClass`'s `globalStateClasses` table), so it
+ * resolves to `Mui-checked`, not `MuiSwitch-checked` — the same string
+ * `switchClasses.checked` gives.
+ */
+const SWITCH_SWITCH_BASE = generateUtilityClass('MuiSwitch', 'switchBase');
+const SWITCH_THUMB = generateUtilityClass('MuiSwitch', 'thumb');
+const SWITCH_CHECKED = generateUtilityClass('MuiSwitch', 'checked');
+
 const switchRootGeometry = ({ theme }: { theme: Theme }): CSSObject => ({
   width: rems(theme, 34 + 12 * 2),
   height: rems(theme, 14 + 12 * 2),
@@ -163,7 +180,7 @@ const switchSwitchBasePadding = ({ theme }: { theme: Theme }): CSSObject => ({
   // own base/variants — see the module doc comment), so this nested rule
   // wins at the SAME (two-class, `.<hash>.Mui-checked`) specificity, the same
   // mechanism this function's own `padding` line already relies on.
-  [`&.${switchClasses.checked}`]: { transform: `translateX(${rem(theme, 20)})` },
+  [`&.${SWITCH_CHECKED}`]: { transform: `translateX(${rem(theme, 20)})` },
 });
 const switchThumbSize = ({ theme }: { theme: Theme }): CSSObject => ({
   width: rem(theme, 20),
@@ -177,7 +194,7 @@ const switchSizeSmall = ({ theme }: { theme: Theme }): CSSObject => ({
   // overrides above, inserted as part of THIS SAME generated class — see the
   // module doc comment for why a flat override cannot reach these at
   // `size="small"` on its own.
-  [`& .${switchClasses.switchBase}`]: {
+  [`& .${SWITCH_SWITCH_BASE}`]: {
     padding: rem(theme, 4),
     // Same overshoot as medium's, at `size="small"`'s OWN literal
     // (`SwitchRoot`'s baked-in `size: 'small'` variant, `Switch.js`:
@@ -187,9 +204,9 @@ const switchSizeSmall = ({ theme }: { theme: Theme }): CSSObject => ({
     // this rule, composed after it in the same generated class, so it wins
     // at matching specificity the same way the sibling `padding: rem(theme,
     // 4)` line above already does.
-    [`&.${switchClasses.checked}`]: { transform: `translateX(${rem(theme, 16)})` },
+    [`&.${SWITCH_CHECKED}`]: { transform: `translateX(${rem(theme, 16)})` },
   },
-  [`& .${switchClasses.thumb}`]: { width: rem(theme, 16), height: rem(theme, 16) },
+  [`& .${SWITCH_THUMB}`]: { width: rem(theme, 16), height: rem(theme, 16) },
 });
 
 /**

package/src/tokens/density-overrides.ts

@@ -1,4 +1,4 @@
-import { chipClasses } from '@mui/material/Chip/index.js';
+import generateUtilityClass from '@mui/material/generateUtilityClass/index.js';
 import type { Components, CSSObject, Theme } from '@mui/material/styles/index.js';
 
 import { rem } from './relative';
@@ -81,8 +81,13 @@ interface ChipOwnerStateForOverrides {
  * own single-class rule (`0,1,0`), so it wins regardless of source order —
  * the same technique `ChipRoot`'s OWN style already uses for its avatar/
  * icon/delete-icon sub-parts (`& .${chipClasses.avatar}`, etc., in
- * `Chip.js`), and read through the SAME `chipClasses` MUI's own `Chip.js`
- * generates the real DOM class from, not a hand-typed copy of it.
+ * `Chip.js`), and built the same way `Chip.js` itself builds that class:
+ * `generateUtilityClass('MuiChip', 'label')`, MUI's own public helper
+ * (`@mui/material/generateUtilityClass`), not a hand-typed copy of it and not
+ * `chipClasses` — importing `chipClasses` pulls in `@mui/material/Chip`
+ * itself, which puts `MuiChip` on the critical path of every host that
+ * imports `densityThemeOptions`, including one that never renders a density
+ * at all (FUT-2993).
  *
  * **That same higher specificity also outranks a HOST's own theming.** A
  * host writing `theme.components.MuiChip.styleOverrides.label` for its own
@@ -121,6 +126,15 @@ interface ChipOwnerStateForOverrides {
  * make them differ on nothing but identity.
  */
 
+/**
+ * Built with `generateUtilityClass`, not imported from `@mui/material/Chip`'s
+ * own `chipClasses` — the same generated string (`Chip.js` builds
+ * `chipClasses` from this exact helper), but without pulling `MuiChip` onto
+ * the critical path of every host that imports `densityThemeOptions` (see the
+ * module doc comment, and FUT-2993).
+ */
+const CHIP_LABEL = generateUtilityClass('MuiChip', 'label');
+
 const iconButtonRootPadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 8) });
 const iconButtonSmallPadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 5) });
 const iconButtonLargePadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 12) });
@@ -155,14 +169,16 @@ const chipRootHeight = ({
     // (two classes vs one) — wins over `chipLabelPadding`/`chipLabelSmallPadding`
     // below regardless of stylesheet insertion order. See the module doc
     // comment for why this must live here and not on the label slot itself.
-    // `chipClasses.label`, not a hand-typed `.MuiChip-label` string — the same
-    // module `Chip.js`'s own root style reads for its avatar/icon/delete-icon
-    // selectors, so this tracks whatever `Chip.js` itself puts on the label
-    // element rather than a separately-maintained copy of it. A host that
-    // calls `ClassNameGenerator.configure` before any `MuiChip` module loads
-    // renames the real class; a literal string would silently stop matching
-    // it, `chipClasses.label` cannot.
-    style[`& .${chipClasses.label}`] = { paddingLeft: rem(theme, px), paddingRight: rem(theme, px) };
+    // `CHIP_LABEL` (`generateUtilityClass('MuiChip', 'label')`), not a
+    // hand-typed `.MuiChip-label` string — the same helper `Chip.js`'s own
+    // root style reads for its avatar/icon/delete-icon selectors (via
+    // `chipClasses`), so this tracks whatever `Chip.js` itself puts on the
+    // label element rather than a separately-maintained copy of it. A host
+    // that calls `ClassNameGenerator.configure` before any `MuiChip` module
+    // loads renames the real class; a literal string would silently stop
+    // matching it, `generateUtilityClass` cannot — and unlike `chipClasses`,
+    // it does so without importing `@mui/material/Chip` at all (FUT-2993).
+    style[`& .${CHIP_LABEL}`] = { paddingLeft: rem(theme, px), paddingRight: rem(theme, px) };
   }
   return style;
 };

package/src/tokens/density.ts

@@ -147,13 +147,19 @@ export function densityThemeOptions(
   density: DensityLevel | number,
   factors?: Partial<Record<DensityLevel, number>>,
   fieldRadius: number = DEFAULT_FIELD_RADIUS,
-): Pick<ThemeOptions, 'typography' | 'spacing' | 'fieldHeight' | 'components'> {
+): Pick<ThemeOptions, 'typography' | 'spacing' | 'fieldHeight' | 'fieldRadius' | 'components'> {
   const { factor } = resolveDensityFactor(density, factors);
   const fieldHeight = densityFieldHeight(factor);
   return {
     typography: { fontSize: densityFontSize(factor) },
     spacing: densitySpacingUnit(factor),
     fieldHeight,
+    // A standalone host (never `createUiTheme`/`UiProvider`) that draws its
+    // OWN, non-default radius states it through this 3rd argument; reporting
+    // it back here (FUT-2967) lets `@12-apps/app-shell`'s `createAppTheme`
+    // spread this object's OWN `fieldRadius` into its `createTheme()` call
+    // instead of tracking the number separately — the two can never disagree.
+    fieldRadius,
     components: mergeMuiComponents(
       fieldOverrides(fieldRadius, fieldHeight),
       iconButtonDensityOverrides(),

package/src/tokens/field-height.ts

@@ -126,16 +126,63 @@ export function fieldHeightOverrides(height: number = DEFAULT_FIELD_HEIGHT): Com
  * top-level objects would drop every override but the last source's for a
  * component two sources both style (`fieldOverrides` below merges exactly
  * two; density's geometry overrides, FUT-2766–2768, add more).
+ *
+ * `styleOverrides` keeps the rule above, wholesale by inner slot key, with NO
+ * new closures — a slot's value is taken by reference from whichever source
+ * set it last, never wrapped, so two theme builds from the same options still
+ * compare equal (see `mergeMuiComponents`'s own suite).
+ *
+ * Three more keys survive the merge (FUT-2967), where they used to be
+ * silently dropped the moment a SECOND source styled the same component —
+ * exactly the shape density (FUT-2766–2768) and a host's own `components`
+ * both touching one component now takes:
+ *
+ *   - `defaultProps` — a SHALLOW merge, the later source winning per key
+ *     (the same precedence `styleOverrides` uses per slot, one level up);
+ *   - `variants` — every source's array CONCATENATED, earlier first, so a
+ *     host's own variant and a density/base one coexist rather than one
+ *     replacing the other;
+ *   - any OTHER top-level key on a component entry — taken from the later
+ *     source, the same "later wins" rule `styleOverrides` applies per slot,
+ *     just one level up, for a component key this function does not know the
+ *     shape of.
+ *
+ * A component only ONE source names keeps whatever that source gave it
+ * unchanged — `styleOverrides` alone if that is all it had, `defaultProps`/
+ * `variants` alone if that is all it had.
  */
 export function mergeMuiComponents(...sources: Components<Theme>[]): Components<Theme> {
-  type Entry = { styleOverrides?: Record<string, unknown> };
+  type Entry = {
+    styleOverrides?: Record<string, unknown>;
+    defaultProps?: Record<string, unknown>;
+    variants?: unknown[];
+    [key: string]: unknown;
+  };
   const maps = sources as unknown as Record<string, Entry>[];
   const names = new Set(maps.flatMap((map) => Object.keys(map)));
   return Object.fromEntries(
-    [...names].map((name) => [
-      name,
-      { styleOverrides: Object.assign({}, ...maps.map((map) => map[name]?.styleOverrides)) },
-    ]),
+    [...names].map((name) => {
+      const entries = maps.map((map) => map[name]).filter((entry): entry is Entry => entry !== undefined);
+      const styleOverrides = Object.assign({}, ...entries.map((entry) => entry.styleOverrides));
+      const defaultProps = Object.assign({}, ...entries.map((entry) => entry.defaultProps));
+      const variants = entries.flatMap((entry) => entry.variants ?? []);
+      const rest = entries.reduce<Record<string, unknown>>((acc, entry) => {
+        for (const key of Object.keys(entry)) {
+          if (key === 'styleOverrides' || key === 'defaultProps' || key === 'variants') continue;
+          acc[key] = entry[key];
+        }
+        return acc;
+      }, {});
+      return [
+        name,
+        {
+          ...rest,
+          styleOverrides,
+          ...(Object.keys(defaultProps).length > 0 ? { defaultProps } : {}),
+          ...(variants.length > 0 ? { variants } : {}),
+        },
+      ];
+    }),
   ) as Components<Theme>;
 }
 

package/dist/chunk-4ELI2MM3.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/tokens/density-overrides.selection.ts"],"sourcesContent":["import { switchClasses } from '@mui/material/Switch/index.js';\nimport type { Components, CSSObject, Theme } from '@mui/material/styles/index.js';\n\nimport { rem, rems } from './relative';\n\n/**\n * CHECKBOX / RADIO / SWITCH GEOMETRY, DENSITY-AWARE (FUT-2767).\n *\n * `Checkbox`/`Radio`/`Switch` are MUI's own components, unwrapped — but\n * **only two of the three `@12-apps/ui` wrappers actually forward their\n * geometry to MUI**, corrected here after an earlier revision of this doc\n * comment claimed all three did.\n *\n * - `Checkbox.tsx`'s `StyledCheckbox` and `RadioGroup.variants.tsx`'s\n *   `DefaultRadios` (the ONLY variant rendering a raw `<Radio>` — `cards`/\n *   `buttons`/`segments` draw custom controls, outside this ticket) set NO\n *   `padding` of their own, so `checkboxRadioDensityOverrides()` reaches\n *   both directly — confirmed by a real render, same computed padding as\n *   raw `MuiCheckbox`/`MuiRadio` at both densities\n *   (`density-overrides.test.stories.tsx`'s `ui-checkbox`/`ui-radio-group`).\n * - `Switch.styles.ts`'s `switchSx` is DIFFERENT: it draws root/switchBase/\n *   thumb geometry itself, per instance, from its own `SWITCH_SIZES` table\n *   (`Switch.metrics.ts`), every number already through `rem(theme, px)`.\n *   `Switch.parts.tsx`'s `StyledSwitch = styled(MuiSwitch, {...})(...)`\n *   composes these as an OUTER wrapper class whose nested `& .MuiSwitch-\n *   switchBase`/`& .MuiSwitch-thumb` selectors are a TWO-class compound —\n *   higher specificity than this file's `MuiSwitch.styleOverrides.\n *   switchBase`/`thumb`, which compose onto a single-class generated class.\n *   `switchDensityOverrides()` therefore has **NO effect on `@12-apps/ui`'s\n *   own `<Switch>`** — it only reaches a raw `@mui/material/Switch` consumer\n *   (a host's own `Table.tsx` density-toggle column, say). Not a gap:\n *   `switchSx` already reacts to `theme.typography.fontSize` on its own —\n *   including the CHECKED thumb's own travel distance, computed as\n *   `rem(theme, width - thumbSize - padding * 2)` from the SAME per-instance\n *   geometry, so it moves consistently with no help from this file.\n *   Confirmed by measurement, both sizes, both states, both densities\n *   (`ui-switch-*` cases); documented at `Switch.md`'s \"Density\" section.\n *\n * **The ticket's open question — does a `MuiSwitchBase` theme override reach\n * `Checkbox`/`Radio` at all? — is NO, verified two ways.** `Checkbox`/`Radio`\n * both render through `internal/SwitchBase.js`'s `SwitchBaseRoot`, which is\n * `styled(ButtonBase, { name: 'MuiSwitchBase' })({ padding: 9, ... })` — with\n * NO `slot` key. `@mui/system`'s `createStyled.js` computes\n * `overridesResolver = defaultOverridesResolver(lowercaseFirstLetter(slot))`,\n * and `defaultOverridesResolver` (`if (!slot) return null`) returns `null`\n * for an absent slot; the styled call itself then only pushes its\n * `styleThemeOverrides` expression `if (componentName && overridesResolver)`\n * — `null` is falsy, so for THIS styled call `theme.components.MuiSwitchBase\n * .styleOverrides` is never read at all. (`variants` is a SEPARATE check,\n * gated on `skipVariantsResolver` rather than `overridesResolver`, which is\n * why the ticket's own two-part specificity proof for Chip's label — probing\n * with `variants` — does not transfer here; `styleOverrides` is what dies.)\n * A render-level probe confirms it: a theme with `components.MuiSwitchBase\n * .styleOverrides.root = { padding: '999px' }`, rendering `<Switch />`,\n * `<Checkbox />` and `<Radio />` through it, leaves EVERY ONE of `.MuiSwitch-\n * switchBase`, `.MuiCheckbox-root` and `.MuiRadio-root` at their unthemed\n * padding (`9px`/`4px` — see below), never `999px`. The Decision's own\n * suggested `MuiSwitchBase` route is therefore the ticket's documented\n * fallback in disguise: this file skips straight to duplicating the override\n * under `MuiCheckbox` and `MuiRadio`, each independently confirmed LIVE by\n * the same probe (`components.MuiCheckbox.styleOverrides.root.padding` DOES\n * reach `.MuiCheckbox-root`, and the same for `MuiRadio`).\n *\n * - `Checkbox`/`Radio` (`internal/SwitchBase.js`, `Checkbox.js`, `Radio.js`):\n *   `padding: 9` — constant across `size=\"small\"`/`\"medium\"` today (neither\n *   `CheckboxRoot` nor `RadioRoot` carries a size-conditional padding rule),\n *   so ONE `root` override, no `sizeSmall`/`sizeMedium` split, covers both\n *   sizes without disturbing the glyph-driven size difference FUT-2585 left\n *   alone.\n * - `Switch` (`Switch.js`): root (the track) `width: 34+12*2`, `height:\n *   14+12*2`, `padding: 12` (medium); `switchBase` (the thumb's absolutely-\n *   positioned wrapper) — its OWN literal is NOT the `12` the ticket's\n *   Decision sketch names (that `12` is `SwitchRoot`'s own padding, a\n *   DIFFERENT slot); `switchBase` inherits `internal/SwitchBase.js`'s generic\n *   `padding: 9` unmodified at medium (`SwitchSwitchBase`'s own styles never\n *   set `padding`), confirmed by the same render probe with NO theme\n *   override at all (`.MuiSwitch-switchBase` computed padding: `9px`). This\n *   file overrides `MuiSwitch.styleOverrides.switchBase` (a LIVE key —\n *   `SwitchSwitchBase = styled(SwitchBase, { name: 'MuiSwitch', slot:\n *   'SwitchBase', ... })` DOES pass a `slot`) with `rem(theme, 9)`, the\n *   MEASURED default, not the ticket's `12` — using `12` here would move\n *   today's real 9px to 12px at `density: 'normal'`, failing the Done-when's\n *   own pixel-identical requirement, so the number is corrected against the\n *   probe rather than the sketch. `thumb`: `20×20`, unconditional.\n * - `Switch` `size=\"small\"` (`:82-100`, a `variants` entry on `SwitchRoot`\n *   itself): root `width: 40`, `height: 24`, `padding: 7`; a NESTED `&\n *   .${switchClasses.switchBase}` selector sets `padding: 4` (not 9); a\n *   NESTED `& .${switchClasses.thumb}` selector sets `20×20` down to\n *   `16×16`. Both nested rules are baked into `SwitchRoot`'s OWN generated\n *   class at TWO-class specificity (the size-small instance's unique class,\n *   plus `.MuiSwitch-switchBase`/`.MuiSwitch-thumb`) — exactly the Chip\n *   outlined-label shape this file already has above, and the SAME failure\n *   mode Lesson 1 warns about: a FLAT `styleOverrides.switchBase`/`thumb`\n *   (one class) cannot out-specificity it, so at `size=\"small\"` it would\n *   silently keep rendering MUI's unthemed `4px`/`16×16` at every density,\n *   the click target and thumb staying full-size while the track around them\n *   shrank. Fixed the same way: `sizeSmall`'s OWN nested `& .${switchClasses\n *   .switchBase}` / `& .${switchClasses.thumb}` rules, read through\n *   `switchClasses` (not a hand-typed selector string) for the same\n *   `ClassNameGenerator.configure` reason `chipClasses` is above, inserted\n *   as part of the SAME `sizeSmall` override object so they land AFTER\n *   `SwitchRoot`'s own baked-in small variant in the generated class's CSS\n *   text (later wins at matching two-class specificity) rather than trying\n *   to out-specificity it from a different slot.\n *\n * **The checked thumb's own travel distance is a FOURTH literal, found only\n * on adversarial review of the PR this doc comment first shipped in.**\n * `SwitchSwitchBase`'s base style bakes in `&.Mui-checked { transform:\n * translateX(20px) }` (medium), and `SwitchRoot`'s `size: 'small'` variant\n * nests the same at `16px` — both bare, never run through `pxToRem`, so at\n * `density: 'compact'` the checked thumb kept travelling the FULL, unscaled\n * distance while the track around it shrank ×0.9 — a visible overshoot.\n * `switchSwitchBasePadding`/`switchSizeSmall` each now carry their own\n * `&.${switchClasses.checked}` rule (`translateX(rem(theme, 20))`/`rem(theme,\n * 16)`), composed onto the SAME generated class, in the SAME position\n * `padding` already occupies — so it wins by the identical mechanism, not a\n * new one. Proven at the pixel level, both sizes/densities: `switch-md-\n * checked`/`switch-sm-checked` measure the thumb's final position against\n * the track's own edge, not just the transform string.\n *\n * At `density: 'normal'` every number above computes back to the literal it\n * replaces (`rem(theme, 9)` is `0.5625rem`, `9px` at the 16px root — no\n * visible change), the same geometry-neutral guarantee `iconButtonDensity\n * Overrides`/`chipDensityOverrides` give above. The same non-default-\n * `fontSize` caveat those two give applies here unchanged: `rem()` only ever\n * reads `theme.typography.fontSize`, so a host adopting\n * `checkboxRadioDensityOverrides`/`switchDensityOverrides` standalone moves\n * every number here by that one coefficient, same as everything else `rem()`\n * touches.\n */\n\nconst checkboxRadioRootPadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 9) });\n\n/**\n * `MuiCheckbox`/`MuiRadio`'s own padding — duplicated under both component\n * keys, the ticket's own documented fallback, since `MuiSwitchBase` cannot\n * reach either (see the module doc comment above). One module-level function\n * shared by both keys, and by `checkboxRadioDensityOverrides()`'s own two\n * calls across the two theme-build paths, for the same identity reason the\n * rest of this file's slots are module-level.\n */\nexport function checkboxRadioDensityOverrides(): Components<Theme> {\n  return {\n    MuiCheckbox: { styleOverrides: { root: checkboxRadioRootPadding } },\n    MuiRadio: { styleOverrides: { root: checkboxRadioRootPadding } },\n  };\n}\n\nconst switchRootGeometry = ({ theme }: { theme: Theme }): CSSObject => ({\n  width: rems(theme, 34 + 12 * 2),\n  height: rems(theme, 14 + 12 * 2),\n  padding: rem(theme, 12),\n});\nconst switchSwitchBasePadding = ({ theme }: { theme: Theme }): CSSObject => ({\n  padding: rem(theme, 9),\n  // FUT-2767 (adversarial-review fix) — `SwitchSwitchBase`'s OWN base style\n  // (`Switch.js`, medium) bakes in `&.Mui-checked { transform:\n  // translateX(20px) }`, a bare literal never run through `pxToRem` — at\n  // `density: 'compact'` the track/padding/thumb above all shrink ×0.9 but\n  // this offset stayed at a full 20px, so the checked thumb overshot the now-\n  // smaller track. Composed onto the SAME generated class as that base style,\n  // AFTER it (`createStyled` composes `styleThemeOverrides` after a slot's\n  // own base/variants — see the module doc comment), so this nested rule\n  // wins at the SAME (two-class, `.<hash>.Mui-checked`) specificity, the same\n  // mechanism this function's own `padding` line already relies on.\n  [`&.${switchClasses.checked}`]: { transform: `translateX(${rem(theme, 20)})` },\n});\nconst switchThumbSize = ({ theme }: { theme: Theme }): CSSObject => ({\n  width: rem(theme, 20),\n  height: rem(theme, 20),\n});\nconst switchSizeSmall = ({ theme }: { theme: Theme }): CSSObject => ({\n  width: rem(theme, 40),\n  height: rem(theme, 24),\n  padding: rem(theme, 7),\n  // Higher (two-class) specificity than the flat `switchBase`/`thumb`\n  // overrides above, inserted as part of THIS SAME generated class — see the\n  // module doc comment for why a flat override cannot reach these at\n  // `size=\"small\"` on its own.\n  [`& .${switchClasses.switchBase}`]: {\n    padding: rem(theme, 4),\n    // Same overshoot as medium's, at `size=\"small\"`'s OWN literal\n    // (`SwitchRoot`'s baked-in `size: 'small'` variant, `Switch.js`:\n    // `translateX(16px)`). Nested one level deeper so the compiled selector\n    // is `.<root-hash> .MuiSwitch-switchBase.Mui-checked` — the same THREE-\n    // class descendant compound MUI's own baked-in small variant uses for\n    // this rule, composed after it in the same generated class, so it wins\n    // at matching specificity the same way the sibling `padding: rem(theme,\n    // 4)` line above already does.\n    [`&.${switchClasses.checked}`]: { transform: `translateX(${rem(theme, 16)})` },\n  },\n  [`& .${switchClasses.thumb}`]: { width: rem(theme, 16), height: rem(theme, 16) },\n});\n\n/**\n * `MuiSwitch`'s own track (root), thumb wrapper (switchBase) and thumb\n * (thumb) geometry, at both sizes MUI has.\n */\nexport function switchDensityOverrides(): Components<Theme> {\n  return {\n    MuiSwitch: {\n      styleOverrides: {\n        root: switchRootGeometry,\n        switchBase: switchSwitchBasePadding,\n        thumb: switchThumbSize,\n        sizeSmall: switchSizeSmall,\n      },\n    },\n  };\n}\n"],"mappings":";;;;;;AAAA,SAAS,qBAAqB;AAmI9B,IAAM,2BAA2B,CAAC,EAAE,MAAM,OAAoC,EAAE,SAAS,IAAI,OAAO,CAAC,EAAE;AAUhG,SAAS,gCAAmD;AACjE,SAAO;AAAA,IACL,aAAa,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,EAAE;AAAA,IAClE,UAAU,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,EAAE;AAAA,EACjE;AACF;AAEA,IAAM,qBAAqB,CAAC,EAAE,MAAM,OAAoC;AAAA,EACtE,OAAO,KAAK,OAAO,KAAK,KAAK,CAAC;AAAA,EAC9B,QAAQ,KAAK,OAAO,KAAK,KAAK,CAAC;AAAA,EAC/B,SAAS,IAAI,OAAO,EAAE;AACxB;AACA,IAAM,0BAA0B,CAAC,EAAE,MAAM,OAAoC;AAAA,EAC3E,SAAS,IAAI,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWrB,CAAC,KAAK,cAAc,OAAO,EAAE,GAAG,EAAE,WAAW,cAAc,IAAI,OAAO,EAAE,CAAC,IAAI;AAC/E;AACA,IAAM,kBAAkB,CAAC,EAAE,MAAM,OAAoC;AAAA,EACnE,OAAO,IAAI,OAAO,EAAE;AAAA,EACpB,QAAQ,IAAI,OAAO,EAAE;AACvB;AACA,IAAM,kBAAkB,CAAC,EAAE,MAAM,OAAoC;AAAA,EACnE,OAAO,IAAI,OAAO,EAAE;AAAA,EACpB,QAAQ,IAAI,OAAO,EAAE;AAAA,EACrB,SAAS,IAAI,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKrB,CAAC,MAAM,cAAc,UAAU,EAAE,GAAG;AAAA,IAClC,SAAS,IAAI,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASrB,CAAC,KAAK,cAAc,OAAO,EAAE,GAAG,EAAE,WAAW,cAAc,IAAI,OAAO,EAAE,CAAC,IAAI;AAAA,EAC/E;AAAA,EACA,CAAC,MAAM,cAAc,KAAK,EAAE,GAAG,EAAE,OAAO,IAAI,OAAO,EAAE,GAAG,QAAQ,IAAI,OAAO,EAAE,EAAE;AACjF;AAMO,SAAS,yBAA4C;AAC1D,SAAO;AAAA,IACL,WAAW;AAAA,MACT,gBAAgB;AAAA,QACd,MAAM;AAAA,QACN,YAAY;AAAA,QACZ,OAAO;AAAA,QACP,WAAW;AAAA,MACb;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-K3YHXOWZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/tokens/density-overrides.navigation.ts"],"sourcesContent":["import { tableCellClasses } from '@mui/material/TableCell/index.js';\nimport type { Components, CSSObject, Theme } from '@mui/material/styles/index.js';\n\nimport { rem, rems } from './relative';\n\n/**\n * TOGGLEBUTTON / TAB / TABLECELL / PAGINATIONITEM / SLIDER GEOMETRY,\n * DENSITY-AWARE (FUT-2768).\n *\n * The remainder of the fixed-px geometry the density audit catalogued, none\n * of it hard-coded in `@12-apps/ui`'s own source. Verified against the\n * installed `@mui/material@6.5.0` source; each goes through the SAME\n * per-size/per-slot `overridesResolver` key MUI itself resolves\n * (`iconButtonDensityOverrides`/`chipDensityOverrides`'s own mechanism), so a\n * theme value composes with MUI's baked-in `variants` instead of replacing\n * them outright:\n *\n * - `ToggleButton`: `padding: 11/7/15` at medium(root)/small/large — same\n *   `root`/`sizeSmall`/`sizeLarge` shape as `iconButtonDensityOverrides`.\n * - `Tab`: `minHeight: 48`, `padding: '12px 16px'` on the root (via `rems()`).\n *   The icon+label combo (`minHeight: 72`, `paddingTop`/`Bottom: 9`) is a\n *   SEPARATE MUI variant, exposed as the `labelIcon` key.\n * - `TableCell`: `padding: 16` on the root, `'6px 16px'` at small, nested\n *   inside it `'0 12px 0 16px'` on the small+checkbox combo — all gated on\n *   `ownerState.padding === 'normal'` (MUI's default): `checkbox`/`none` are\n *   separate variants with their OWN unscaled padding (`'0 0 0 4px'`/`0`) an\n *   unconditional rule clobbered at every size but small (FUT-2861 review —\n *   the SAME Lesson-1 clobber the ellipsis fix above avoids, missed here).\n *   `@12-apps/ui`'s own `Table` (FUT-2769) wins regardless (two classes deep\n *   under its styled root); this reaches a BARE `<TableCell>`.\n * - `PaginationItem`: `minWidth/height: 32/26/40` at medium(root)/small/large.\n *   The ellipsis shares the SAME slot and `minWidth` but has NO `height` of\n *   its own (`'auto'`), gated on `ownerState.type` being neither\n *   `'start-ellipsis'` nor `'end-ellipsis'` — skipping it would force a\n *   height onto the ellipsis (Lesson 1).\n * - `Slider`: rail `height: 4/2` at `orientation=\"horizontal\"`/`size=\"small\"`\n *   — gated on `ownerState.orientation` since the SAME key answers for either\n *   axis (MUI sets `height` horizontal / `width` vertical, leaving the other\n *   `'100%'`). Thumb `20×20`/`12×12` needs no gate. `@12-apps/ui`'s own\n *   `Slider` already sets rail/thumb size through `rem()` and never forwards\n *   `size` — a no-op THERE, reaches a BARE `<Slider>`. The thumb's ring and\n *   the value-label offset were checked and left OUT — that story's own doc.\n *\n * `Avatar` is NOT in this file: `@12-apps/ui`'s own `Avatar` wraps `MuiAvatar`\n * in a `StyledAvatar` that ALREADY sets `width`/`height` through\n * `rem(theme, boxPx(size))` (`40` at `md`) — higher specificity than any\n * `MuiAvatar.styleOverrides.root`, dead code here, so it ships none.\n *\n * Geometry-neutral at `normal`; each slot a MODULE-LEVEL function, as above.\n */\n\nconst toggleButtonRootPadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 11) });\nconst toggleButtonSmallPadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 7) });\nconst toggleButtonLargePadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 15) });\n\n/** `MuiToggleButton`'s own padding, at every size MUI has. */\nexport function toggleButtonDensityOverrides(): Components<Theme> {\n  return {\n    MuiToggleButton: {\n      styleOverrides: {\n        root: toggleButtonRootPadding,\n        sizeSmall: toggleButtonSmallPadding,\n        sizeLarge: toggleButtonLargePadding,\n      },\n    },\n  };\n}\n\nconst tabRootGeometry = ({ theme }: { theme: Theme }): CSSObject => ({\n  minHeight: rem(theme, 48),\n  padding: rems(theme, 12, 16),\n});\nconst tabLabelIconGeometry = ({ theme }: { theme: Theme }): CSSObject => ({\n  minHeight: rem(theme, 72),\n  paddingTop: rem(theme, 9),\n  paddingBottom: rem(theme, 9),\n});\n\n/** `MuiTab`'s own root height/padding, and the icon+label combo's taller box. */\nexport function tabDensityOverrides(): Components<Theme> {\n  return {\n    MuiTab: {\n      styleOverrides: {\n        root: tabRootGeometry,\n        labelIcon: tabLabelIconGeometry,\n      },\n    },\n  };\n}\n\ninterface TableCellOwnerStateForOverrides {\n  padding?: 'normal' | 'checkbox' | 'none';\n}\ntype TableCellStyleFn = (props: { theme: Theme; ownerState?: TableCellOwnerStateForOverrides }) => CSSObject;\nconst isDefaultTableCellPadding = (padding: TableCellOwnerStateForOverrides['padding']): boolean =>\n  padding === undefined || padding === 'normal';\n\nconst tableCellRootPadding: TableCellStyleFn = ({ theme, ownerState }) =>\n  isDefaultTableCellPadding(ownerState?.padding) ? { padding: rem(theme, 16) } : {};\n\nconst tableCellSmallPadding: TableCellStyleFn = ({ theme, ownerState }) => {\n  const style: CSSObject = {\n    [`&.${tableCellClasses.paddingCheckbox}`]: { padding: rems(theme, 0, 12, 0, 16) },\n  };\n  if (isDefaultTableCellPadding(ownerState?.padding)) style.padding = rems(theme, 6, 16);\n  return style;\n};\n\n/** Reaches a BARE `<TableCell>` only — module doc comment above. */\nexport function tableCellDensityOverrides(): Components<Theme> {\n  return {\n    MuiTableCell: {\n      styleOverrides: {\n        root: tableCellRootPadding,\n        sizeSmall: tableCellSmallPadding,\n      },\n    },\n  };\n}\n\n/** The `ownerState` field that tells the ellipsis item apart from a real button. */\ninterface PaginationItemOwnerStateForOverrides {\n  type?: 'page' | 'first' | 'last' | 'start-ellipsis' | 'end-ellipsis' | 'previous' | 'next';\n}\ntype PaginationItemStyleFn = (props: {\n  theme: Theme;\n  ownerState?: PaginationItemOwnerStateForOverrides;\n}) => CSSObject;\n\nconst isPaginationEllipsis = (type: PaginationItemOwnerStateForOverrides['type']): boolean =>\n  type === 'start-ellipsis' || type === 'end-ellipsis';\n\n/** `minWidth` always; `height` only off the ellipsis, which has none of its own. */\nfunction paginationItemGeometryAt(px: number): PaginationItemStyleFn {\n  return ({ theme, ownerState }) => {\n    const style: CSSObject = { minWidth: rem(theme, px) };\n    if (!isPaginationEllipsis(ownerState?.type)) style.height = rem(theme, px);\n    return style;\n  };\n}\nconst paginationItemRootGeometry = paginationItemGeometryAt(32);\nconst paginationItemSmallGeometry = paginationItemGeometryAt(26);\nconst paginationItemLargeGeometry = paginationItemGeometryAt(40);\n\n/**\n * `MuiPaginationItem`'s own `minWidth`/`height`, at every size MUI has —\n * `height` skipped on the ellipsis item, which has none of its own (`auto`).\n */\nexport function paginationItemDensityOverrides(): Components<Theme> {\n  return {\n    MuiPaginationItem: {\n      styleOverrides: {\n        root: paginationItemRootGeometry,\n        sizeSmall: paginationItemSmallGeometry,\n        sizeLarge: paginationItemLargeGeometry,\n      },\n    },\n  };\n}\n\n/** The `ownerState` field that tells which axis the rail's `height`/`4` reads as. */\ninterface SliderOwnerStateForOverrides {\n  orientation?: 'horizontal' | 'vertical';\n}\ntype SliderStyleFn = (props: { theme: Theme; ownerState?: SliderOwnerStateForOverrides }) => CSSObject;\n\n/** The rail's `4`/`2` reads as `height` for a horizontal slider, `width` for a vertical one. */\nfunction sliderRailAxisAt(px: number): SliderStyleFn {\n  return ({ theme, ownerState }) =>\n    ownerState?.orientation === 'vertical' ? { width: rem(theme, px) } : { height: rem(theme, px) };\n}\nconst sliderRootGeometry = sliderRailAxisAt(4);\nconst sliderSmallGeometry = sliderRailAxisAt(2);\nconst sliderThumbGeometry = ({ theme }: { theme: Theme }): CSSObject => ({\n  width: rem(theme, 20),\n  height: rem(theme, 20),\n});\nconst sliderThumbSmallGeometry = ({ theme }: { theme: Theme }): CSSObject => ({\n  width: rem(theme, 12),\n  height: rem(theme, 12),\n});\n\n/** `MuiSlider`'s own rail thickness (root/sizeSmall) and thumb box (thumb/thumbSizeSmall). */\nexport function sliderDensityOverrides(): Components<Theme> {\n  return {\n    MuiSlider: {\n      styleOverrides: {\n        root: sliderRootGeometry,\n        sizeSmall: sliderSmallGeometry,\n        thumb: sliderThumbGeometry,\n        thumbSizeSmall: sliderThumbSmallGeometry,\n      },\n    },\n  };\n}\n\n/**\n * `MuiTabs`' own indicator thickness (`height: 2` horizontal, `width: 2`\n * vertical) — one short of `Tab` in the ticket's own literal list, added\n * after a FUT-2767-review pass over state/orientation-gated literals; same\n * orientation gate as the Slider rail. `@12-apps/ui`'s own `Tabs` draws its\n * OWN 3px indicator through `rem()` already, blocking THIS override there —\n * `tabDensityOverrides` reaches `Tab.root`'s `minHeight` instead (both\n * measured in `density-wrapper-reach.test.stories.tsx`).\n */\ninterface TabsIndicatorOwnerStateForOverrides {\n  orientation?: 'horizontal' | 'vertical';\n}\ntype TabsIndicatorStyleFn = (props: {\n  theme: Theme;\n  ownerState?: TabsIndicatorOwnerStateForOverrides;\n}) => CSSObject;\n\nconst tabsIndicatorAxisAt: TabsIndicatorStyleFn = ({ theme, ownerState }) =>\n  ownerState?.orientation === 'vertical' ? { width: rem(theme, 2) } : { height: rem(theme, 2) };\n\n/** `MuiTabs`' own indicator thickness, by orientation. */\nexport function tabsIndicatorDensityOverrides(): Components<Theme> {\n  return {\n    MuiTabs: {\n      styleOverrides: {\n        indicator: tabsIndicatorAxisAt,\n      },\n    },\n  };\n}\n"],"mappings":";;;;;;AAAA,SAAS,wBAAwB;AAmDjC,IAAM,0BAA0B,CAAC,EAAE,MAAM,OAAoC,EAAE,SAAS,IAAI,OAAO,EAAE,EAAE;AACvG,IAAM,2BAA2B,CAAC,EAAE,MAAM,OAAoC,EAAE,SAAS,IAAI,OAAO,CAAC,EAAE;AACvG,IAAM,2BAA2B,CAAC,EAAE,MAAM,OAAoC,EAAE,SAAS,IAAI,OAAO,EAAE,EAAE;AAGjG,SAAS,+BAAkD;AAChE,SAAO;AAAA,IACL,iBAAiB;AAAA,MACf,gBAAgB;AAAA,QACd,MAAM;AAAA,QACN,WAAW;AAAA,QACX,WAAW;AAAA,MACb;AAAA,IACF;AAAA,EACF;AACF;AAEA,IAAM,kBAAkB,CAAC,EAAE,MAAM,OAAoC;AAAA,EACnE,WAAW,IAAI,OAAO,EAAE;AAAA,EACxB,SAAS,KAAK,OAAO,IAAI,EAAE;AAC7B;AACA,IAAM,uBAAuB,CAAC,EAAE,MAAM,OAAoC;AAAA,EACxE,WAAW,IAAI,OAAO,EAAE;AAAA,EACxB,YAAY,IAAI,OAAO,CAAC;AAAA,EACxB,eAAe,IAAI,OAAO,CAAC;AAC7B;AAGO,SAAS,sBAAyC;AACvD,SAAO;AAAA,IACL,QAAQ;AAAA,MACN,gBAAgB;AAAA,QACd,MAAM;AAAA,QACN,WAAW;AAAA,MACb;AAAA,IACF;AAAA,EACF;AACF;AAMA,IAAM,4BAA4B,CAAC,YACjC,YAAY,UAAa,YAAY;AAEvC,IAAM,uBAAyC,CAAC,EAAE,OAAO,WAAW,MAClE,0BAA0B,YAAY,OAAO,IAAI,EAAE,SAAS,IAAI,OAAO,EAAE,EAAE,IAAI,CAAC;AAElF,IAAM,wBAA0C,CAAC,EAAE,OAAO,WAAW,MAAM;AACzE,QAAM,QAAmB;AAAA,IACvB,CAAC,KAAK,iBAAiB,eAAe,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,GAAG,IAAI,GAAG,EAAE,EAAE;AAAA,EAClF;AACA,MAAI,0BAA0B,YAAY,OAAO,EAAG,OAAM,UAAU,KAAK,OAAO,GAAG,EAAE;AACrF,SAAO;AACT;AAGO,SAAS,4BAA+C;AAC7D,SAAO;AAAA,IACL,cAAc;AAAA,MACZ,gBAAgB;AAAA,QACd,MAAM;AAAA,QACN,WAAW;AAAA,MACb;AAAA,IACF;AAAA,EACF;AACF;AAWA,IAAM,uBAAuB,CAAC,SAC5B,SAAS,oBAAoB,SAAS;AAGxC,SAAS,yBAAyB,IAAmC;AACnE,SAAO,CAAC,EAAE,OAAO,WAAW,MAAM;AAChC,UAAM,QAAmB,EAAE,UAAU,IAAI,OAAO,EAAE,EAAE;AACpD,QAAI,CAAC,qBAAqB,YAAY,IAAI,EAAG,OAAM,SAAS,IAAI,OAAO,EAAE;AACzE,WAAO;AAAA,EACT;AACF;AACA,IAAM,6BAA6B,yBAAyB,EAAE;AAC9D,IAAM,8BAA8B,yBAAyB,EAAE;AAC/D,IAAM,8BAA8B,yBAAyB,EAAE;AAMxD,SAAS,iCAAoD;AAClE,SAAO;AAAA,IACL,mBAAmB;AAAA,MACjB,gBAAgB;AAAA,QACd,MAAM;AAAA,QACN,WAAW;AAAA,QACX,WAAW;AAAA,MACb;AAAA,IACF;AAAA,EACF;AACF;AASA,SAAS,iBAAiB,IAA2B;AACnD,SAAO,CAAC,EAAE,OAAO,WAAW,MAC1B,YAAY,gBAAgB,aAAa,EAAE,OAAO,IAAI,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,IAAI,OAAO,EAAE,EAAE;AAClG;AACA,IAAM,qBAAqB,iBAAiB,CAAC;AAC7C,IAAM,sBAAsB,iBAAiB,CAAC;AAC9C,IAAM,sBAAsB,CAAC,EAAE,MAAM,OAAoC;AAAA,EACvE,OAAO,IAAI,OAAO,EAAE;AAAA,EACpB,QAAQ,IAAI,OAAO,EAAE;AACvB;AACA,IAAM,2BAA2B,CAAC,EAAE,MAAM,OAAoC;AAAA,EAC5E,OAAO,IAAI,OAAO,EAAE;AAAA,EACpB,QAAQ,IAAI,OAAO,EAAE;AACvB;AAGO,SAAS,yBAA4C;AAC1D,SAAO;AAAA,IACL,WAAW;AAAA,MACT,gBAAgB;AAAA,QACd,MAAM;AAAA,QACN,WAAW;AAAA,QACX,OAAO;AAAA,QACP,gBAAgB;AAAA,MAClB;AAAA,IACF;AAAA,EACF;AACF;AAmBA,IAAM,sBAA4C,CAAC,EAAE,OAAO,WAAW,MACrE,YAAY,gBAAgB,aAAa,EAAE,OAAO,IAAI,OAAO,CAAC,EAAE,IAAI,EAAE,QAAQ,IAAI,OAAO,CAAC,EAAE;AAGvF,SAAS,gCAAmD;AACjE,SAAO;AAAA,IACL,SAAS;AAAA,MACP,gBAAgB;AAAA,QACd,WAAW;AAAA,MACb;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-M47ZOUGF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/tokens/field-height.ts"],"sourcesContent":["import type { Components, CSSObject, Theme } from '@mui/material/styles/index.js';\n\nimport { fieldEdge } from './field-edge';\nimport { fieldRadiusOverrides, fieldRootStyles } from './field-radius';\nimport {\n  DEFAULT_FIELD_HEIGHT,\n  FIELD_BORDER_WIDTH,\n  FIELD_HEIGHT_SCALE,\n  fieldHeightRem,\n  resolveFieldHeight,\n} from './field-height.core';\n\nimport type { SizeValue } from './vocabulary';\n\n/**\n * THE FIELD HEIGHT AND BORDER ON THE WEB: the theme channel, the readers, and\n * the styles that put a MUI text field or select on them.\n *\n * The argument for one height is in `./field-height.core.ts`. It is a top-level\n * theme key for the reason `fieldRadius` is (`./field-radius.ts`): MUI types\n * `shape` in `@mui/system`, which this package does not depend on.\n */\n\nexport {\n  DEFAULT_FIELD_HEIGHT,\n  FIELD_BORDER_WIDTH,\n  FIELD_HEIGHT_SCALE,\n  fieldHeightPx,\n  fieldHeightRem,\n} from './field-height.core';\n\ndeclare module '@mui/material/styles' {\n  interface Theme {\n    /** The standard field height, in multiples of the default font size. See `@12-apps/ui/tokens`' `fieldHeight`. */\n    fieldHeight?: number;\n  }\n  interface ThemeOptions {\n    /** The standard field height, in multiples of the default font size. Defaults to {@link DEFAULT_FIELD_HEIGHT}. */\n    fieldHeight?: number;\n  }\n}\n\n/** A component's own size string as a step of the field scale — `md` when it is not one. */\nexport function asFieldSize(size: string | undefined): SizeValue {\n  return size !== undefined && size in FIELD_HEIGHT_SCALE ? (size as SizeValue) : 'md';\n}\n\n/** A field's height for a size, as CSS — `2.5rem` for the default. */\nexport function fieldHeight(theme: Theme, size: SizeValue = 'md'): string {\n  return `${fieldHeightRem(resolveFieldHeight(theme.fieldHeight), size)}rem`;\n}\n\n/** The resting border every field draws: 1px in {@link fieldEdge}'s colour. */\nexport function fieldBorder(theme: Theme, surface?: string): string {\n  return `${FIELD_BORDER_WIDTH}px solid ${fieldEdge(theme, surface)}`;\n}\n\n/**\n * The vertical padding that makes a one-line box `height` tall around MUI's\n * `1.4375em` line — in `em`, so it is measured against the field's own type.\n */\nconst verticalInset = (height: string): string => `calc((${height} - 1.4375em) / 2)`;\n\n/**\n * A MUI `TextField` / `Select` / `Autocomplete` (outlined, one line) at the\n * field height for `size`: the root's own vertical padding goes, the input\n * takes the inset, and the resting label sits on the new centre line.\n *\n * Multiline fields are left alone — their height is their content's — and so\n * are `filled` and `standard`, whose label sits inside the box and which draw\n * their own heights as variants.\n */\nexport function fieldControlStyles(theme: Theme, size: SizeValue = 'md'): CSSObject {\n  const inset = verticalInset(fieldHeight(theme, size));\n  return {\n    '& .MuiOutlinedInput-root:not(.MuiInputBase-multiline)': {\n      paddingTop: 0,\n      paddingBottom: 0,\n      '& .MuiOutlinedInput-input, & .MuiSelect-select': { paddingTop: inset, paddingBottom: inset },\n      // A select's display box inherits the ROOT's line height as an absolute\n      // length, so at a smaller font (0.875rem) it outgrew the inset measured in\n      // its own `em` — 42.88px in a 40px row. Its line follows its own type now.\n      '& .MuiSelect-select': { lineHeight: '1.4375em' },\n    },\n    '& .MuiInputLabel-outlined:not(.MuiInputLabel-shrink)': {\n      transform: `translate(14px, ${inset}) scale(1)`,\n    },\n  };\n}\n\n/**\n * The notched outline's resting colour, as a MUI style-override callback. One\n * function, not one per call: two themes built from the same options must\n * compare equal, and a fresh closure each time would make them differ.\n */\nconst restingEdge = ({ theme }: { theme: Theme }): CSSObject => ({ borderColor: fieldEdge(theme) });\n\n/**\n * MUI component overrides that put MUI's OWN outlined fields on the standard\n * height and the one resting border — for a host's bare `TextField` / `Select`,\n * the way `fieldRadiusOverrides` rounds them. Every size MUI has maps to the standard:\n * a host that wants another density asks this package's fields for a `size`.\n */\nexport function fieldHeightOverrides(height: number = DEFAULT_FIELD_HEIGHT): Components<Theme> {\n  const inset = verticalInset(`${fieldHeightRem(height)}rem`);\n  return {\n    MuiOutlinedInput: {\n      styleOverrides: {\n        input: { '&:not(.MuiInputBase-inputMultiline)': { paddingTop: inset, paddingBottom: inset } },\n        // The one resting border; MUI's hover, focus and error rules outrank it.\n        notchedOutline: restingEdge,\n      },\n    },\n    MuiInputLabel: {\n      styleOverrides: {\n        outlined: { '&:not(.MuiInputLabel-shrink)': { transform: `translate(14px, ${inset}) scale(1)` } },\n      },\n    },\n  };\n}\n\n/**\n * Several `Components<Theme>` override sets, merged per component name — a\n * later source's `styleOverrides` win over an earlier one's for the SAME\n * inner key, but neither erases the other's keys. A plain spread of the\n * top-level objects would drop every override but the last source's for a\n * component two sources both style (`fieldOverrides` below merges exactly\n * two; density's geometry overrides, FUT-2766–2768, add more).\n */\nexport function mergeMuiComponents(...sources: Components<Theme>[]): Components<Theme> {\n  type Entry = { styleOverrides?: Record<string, unknown> };\n  const maps = sources as unknown as Record<string, Entry>[];\n  const names = new Set(maps.flatMap((map) => Object.keys(map)));\n  return Object.fromEntries(\n    [...names].map((name) => [\n      name,\n      { styleOverrides: Object.assign({}, ...maps.map((map) => map[name]?.styleOverrides)) },\n    ]),\n  ) as Components<Theme>;\n}\n\n/**\n * Both field overrides — the corner and the height — merged per component.\n * They meet on `MuiOutlinedInput` (`root` from the radius, `input` from the\n * height), so a plain spread would lose one of them.\n */\nexport function fieldOverrides(radius: number | undefined, height: number | undefined): Components<Theme> {\n  return mergeMuiComponents(fieldRadiusOverrides(radius), fieldHeightOverrides(height));\n}\n\n/**\n * THE field standard on a MUI `TextField` / `Select` / `Autocomplete`, for a\n * composite that renders MUI's own: the field radius, the field height for\n * `size`, and the one resting border ({@link fieldEdge}). MUI's own hover,\n * focus and error borders outrank the resting one, so they still show.\n */\nexport function fieldTextFieldStyles(theme: Theme, size: SizeValue = 'md'): CSSObject {\n  return {\n    ...fieldRootStyles(theme),\n    ...fieldControlStyles(theme, size),\n    '& .MuiOutlinedInput-notchedOutline': { borderColor: fieldEdge(theme) },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA2CO,SAAS,YAAY,MAAqC;AAC/D,SAAO,SAAS,UAAa,QAAQ,qBAAsB,OAAqB;AAClF;AAGO,SAAS,YAAY,OAAc,OAAkB,MAAc;AACxE,SAAO,GAAG,eAAe,mBAAmB,MAAM,WAAW,GAAG,IAAI,CAAC;AACvE;AAGO,SAAS,YAAY,OAAc,SAA0B;AAClE,SAAO,GAAG,kBAAkB,YAAY,UAAU,OAAO,OAAO,CAAC;AACnE;AAMA,IAAM,gBAAgB,CAAC,WAA2B,SAAS,MAAM;AAW1D,SAAS,mBAAmB,OAAc,OAAkB,MAAiB;AAClF,QAAM,QAAQ,cAAc,YAAY,OAAO,IAAI,CAAC;AACpD,SAAO;AAAA,IACL,yDAAyD;AAAA,MACvD,YAAY;AAAA,MACZ,eAAe;AAAA,MACf,kDAAkD,EAAE,YAAY,OAAO,eAAe,MAAM;AAAA;AAAA;AAAA;AAAA,MAI5F,uBAAuB,EAAE,YAAY,WAAW;AAAA,IAClD;AAAA,IACA,wDAAwD;AAAA,MACtD,WAAW,mBAAmB,KAAK;AAAA,IACrC;AAAA,EACF;AACF;AAOA,IAAM,cAAc,CAAC,EAAE,MAAM,OAAoC,EAAE,aAAa,UAAU,KAAK,EAAE;AAQ1F,SAAS,qBAAqB,SAAiB,sBAAyC;AAC7F,QAAM,QAAQ,cAAc,GAAG,eAAe,MAAM,CAAC,KAAK;AAC1D,SAAO;AAAA,IACL,kBAAkB;AAAA,MAChB,gBAAgB;AAAA,QACd,OAAO,EAAE,uCAAuC,EAAE,YAAY,OAAO,eAAe,MAAM,EAAE;AAAA;AAAA,QAE5F,gBAAgB;AAAA,MAClB;AAAA,IACF;AAAA,IACA,eAAe;AAAA,MACb,gBAAgB;AAAA,QACd,UAAU,EAAE,gCAAgC,EAAE,WAAW,mBAAmB,KAAK,aAAa,EAAE;AAAA,MAClG;AAAA,IACF;AAAA,EACF;AACF;AAUO,SAAS,sBAAsB,SAAiD;AAErF,QAAM,OAAO;AACb,QAAM,QAAQ,IAAI,IAAI,KAAK,QAAQ,CAAC,QAAQ,OAAO,KAAK,GAAG,CAAC,CAAC;AAC7D,SAAO,OAAO;AAAA,IACZ,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC,SAAS;AAAA,MACvB;AAAA,MACA,EAAE,gBAAgB,OAAO,OAAO,CAAC,GAAG,GAAG,KAAK,IAAI,CAAC,QAAQ,IAAI,IAAI,GAAG,cAAc,CAAC,EAAE;AAAA,IACvF,CAAC;AAAA,EACH;AACF;AAOO,SAAS,eAAe,QAA4B,QAA+C;AACxG,SAAO,mBAAmB,qBAAqB,MAAM,GAAG,qBAAqB,MAAM,CAAC;AACtF;AAQO,SAAS,qBAAqB,OAAc,OAAkB,MAAiB;AACpF,SAAO;AAAA,IACL,GAAG,gBAAgB,KAAK;AAAA,IACxB,GAAG,mBAAmB,OAAO,IAAI;AAAA,IACjC,sCAAsC,EAAE,aAAa,UAAU,KAAK,EAAE;AAAA,EACxE;AACF;","names":[]}

package/dist/chunk-XK77FY42.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/tokens/density-overrides.ts"],"sourcesContent":["import { chipClasses } from '@mui/material/Chip/index.js';\nimport type { Components, CSSObject, Theme } from '@mui/material/styles/index.js';\n\nimport { rem } from './relative';\n\n// Re-exported so every existing import site (`./density`, `./scales`,\n// `../provider/mui-bridge`) keeps resolving `from './density-overrides'`\n// unchanged — the split below is purely a file-layout move to stay under\n// the 400-line `quality:complexity` cap, not a public-API change.\nexport {\n  toggleButtonDensityOverrides,\n  tabDensityOverrides,\n  tabsIndicatorDensityOverrides,\n  tableCellDensityOverrides,\n  paginationItemDensityOverrides,\n  sliderDensityOverrides,\n} from './density-overrides.navigation';\nexport { checkboxRadioDensityOverrides, switchDensityOverrides } from './density-overrides.selection';\n\n/** The `ownerState` fields `MuiChip`'s two styled slots (root, label) both receive. */\ninterface ChipOwnerStateForOverrides {\n  variant?: 'filled' | 'outlined';\n  size?: 'small' | 'medium';\n}\n\n/**\n * ICONBUTTON / CHIP GEOMETRY, DENSITY-AWARE (FUT-2766).\n *\n * Both are MUI's own components, unwrapped: `@12-apps/ui` has no\n * `components/*` subpath for `IconButton`, and its `Chip` wrapper\n * (`components/data-display/Chip`) hands the drawing to `MuiChip` and adds\n * only hover/selection/transition `sx` — no geometry of its own (unlike\n * `Button`, which already draws every dimension through `rem()`,\n * `components/form/Button/Button.styles.ts`). So both draw MUI's OWN fixed-px\n * padding/height, verified against the installed `@mui/material@6.5.0` source:\n *\n * - `IconButton` (`node_modules/@mui/material/IconButton/IconButton.js`):\n *   `padding: 8` on the root (medium, the default), `padding: 5` at\n *   `size=\"small\"`, `padding: 12` at `size=\"large\"`. The icon's own `fontSize`\n *   is already relative (`pxToRem(18/24/28)`) — only `padding` was the gap.\n * - `Chip` (`node_modules/@mui/material/Chip/Chip.js`): `height: 32` on the\n *   root (medium, the default), `height: 24` at `size=\"small\"`. The label's\n *   own side padding is a SEPARATE slot (`name: 'MuiChip', slot: 'Label'`,\n *   override key `label`/`labelSmall`) at `paddingLeft`/`paddingRight: 12`\n *   default, `8` at `size=\"small\"` — restated in this package's own\n *   `Chip.metrics.ts` (`CHIP_SIZES`), which both renderers already read.\n *\n * Neither dimension moved when `theme.typography.fontSize` changed (they are\n * not written through `pxToRem`), so at `density: 'compact'` an\n * `IconButton`/`Chip` next to a now-smaller `Button` looked unchanged — the\n * visual regression FUT-2764 exists to fix. `rem(theme, px)` is the same\n * helper `Button.styles.ts` already uses, so `padding`/`height` move exactly\n * as far as `theme.typography.fontSize`'s coefficient does, and are\n * geometry-neutral at `density: 'normal'`: `rem(theme, 8)` at the unchanged\n * `fontSize: 14` renders to the same computed px as the literal `8` it\n * replaces.\n *\n * **The OUTLINED chip's own label padding (`11`/`7`, one px tighter than\n * filled's `12`/`8`) is a SEPARATE number this file must not clobber** — a\n * bug an earlier revision of this file had (a `styleOverrides.label`/\n * `labelSmall` of `12`/`8` unconditionally wins for EVERY variant, because\n * `ChipLabel`'s own `overridesResolver` (`Chip.js`) returns\n * `[styles.label, styles[label${size}]]` with no variant check at all, and\n * `@mui/system`'s `createStyled` composes `styleThemeOverrides` AFTER the\n * slot's own base styles/variants — so a theme `styleOverrides.label` always\n * outranks `ChipLabel`'s own baked-in `{ props: { variant: 'outlined' },\n * style: { paddingLeft: 11, ... } }`, at ANY density, not just a scaled one).\n * Fixed by putting the outlined fix on the ROOT slot instead, as a nested\n * `.MuiChip-label` selector inside `styleOverrides.root` itself, keyed on\n * `ownerState.variant`/`.size` — proven correct two ways: (1) a probe render\n * confirmed the naive `components.MuiChip.variants` route CANNOT reach the\n * label slot at all — `createStyled`'s `skipVariantsResolver` defaults to\n * `true` for every slot but `'Root'`, so a theme-level `variants` entry is\n * simply never evaluated for `ChipLabel`, proven by rendering an outlined\n * Chip against a `components.MuiChip.variants` entry set to an absurd\n * `999px` and reading `.MuiChip-label`'s OWN computed style: still `11px`,\n * untouched — while the SAME entry DOES leak onto `.MuiChip-root` (`999px`),\n * confirming theme `variants` is a ROOT-slot-only mechanism for this\n * component; (2) a nested `.MuiChip-label` selector written from the ROOT\n * slot is a HIGHER-specificity rule (two classes, `0,2,0`) than the label's\n * own single-class rule (`0,1,0`), so it wins regardless of source order —\n * the same technique `ChipRoot`'s OWN style already uses for its avatar/\n * icon/delete-icon sub-parts (`& .${chipClasses.avatar}`, etc., in\n * `Chip.js`), and read through the SAME `chipClasses` MUI's own `Chip.js`\n * generates the real DOM class from, not a hand-typed copy of it.\n *\n * **That same higher specificity also outranks a HOST's own theming.** A\n * host writing `theme.components.MuiChip.styleOverrides.label` for its own\n * reasons (`0,1,0`) does not win against the outlined rule here (`0,2,0`) —\n * not a bug specific to this file, `ChipLabel`'s OWN baked-in outlined\n * variant already outranked a plain `styleOverrides.label` the same way,\n * before this file existed. A host that needs to change OUTLINED label\n * padding specifically cannot do it through `styleOverrides.label`/\n * `labelSmall` at all; it reaches it through `sx` (a per-instance override,\n * highest specificity of all) or its OWN `MuiChip.styleOverrides.root`\n * function written out in full — `mergeMuiComponents` replaces `root`\n * WHOLESALE when both sides set it (see `./density.ts`'s own doc comment),\n * so a host adding to it must restate `chipRootHeight`'s own height logic\n * alongside its outlined-label change, not merely add a sibling key.\n *\n * The avatar/icon/delete-icon sub-slots (margins, sizes) and IconButton's\n * `edge=\"start\"`/`\"end\"` negative margins are DELIBERATELY untouched by this\n * file — real override keys exist, but none is in the ticket's Done-when nor\n * exercised by a call site this initiative is chasing, so they stay MUI's\n * own literals at every density (including `compact`/`comfortable` — they do\n * NOT scale here; a future ticket that needs them scaled adds its own\n * override, the way `field-height.ts`'s siblings each own one slot).\n *\n * A host that adopts `iconButtonDensityOverrides`/`chipDensityOverrides`\n * standalone (the `@12-apps/ui/tokens` export, no density channel involved)\n * sees the SAME scaling from its own `typography.fontSize` alone — `rem()`\n * only ever reads that one theme number, so a theme with a non-default\n * `fontSize` (set directly, with no `density` in the picture at all) moves\n * these numbers exactly as it moves everything else written through `rem()`.\n *\n * Each slot below is a MODULE-LEVEL function, not a closure built fresh inside\n * `iconButtonDensityOverrides`/`chipDensityOverrides` — the same reason\n * `field-height.ts`'s `restingEdge` is one: two themes built from the same\n * options (the `muiThemeOptionsFrom` and `densityThemeOptions` paths, in\n * particular) must compare equal, and a fresh arrow function per call would\n * make them differ on nothing but identity.\n */\n\nconst iconButtonRootPadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 8) });\nconst iconButtonSmallPadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 5) });\nconst iconButtonLargePadding = ({ theme }: { theme: Theme }): CSSObject => ({ padding: rem(theme, 12) });\n\n/** `MuiIconButton`'s own padding, at every size MUI has. */\nexport function iconButtonDensityOverrides(): Components<Theme> {\n  return {\n    MuiIconButton: {\n      styleOverrides: {\n        root: iconButtonRootPadding,\n        sizeSmall: iconButtonSmallPadding,\n        sizeLarge: iconButtonLargePadding,\n      },\n    },\n  };\n}\n\n/** MUI's own outlined-label paddings (`ChipLabel`'s baked-in `variants`, `Chip.js`). */\nconst CHIP_OUTLINED_LABEL_PADDING = { medium: 11, small: 7 } as const;\n\nconst chipRootHeight = ({\n  theme,\n  ownerState,\n}: {\n  theme: Theme;\n  ownerState?: ChipOwnerStateForOverrides;\n}): CSSObject => {\n  const style: CSSObject = { height: rem(theme, 32) };\n  if (ownerState?.variant === 'outlined') {\n    const px = CHIP_OUTLINED_LABEL_PADDING[ownerState.size === 'small' ? 'small' : 'medium'];\n    // Higher CSS specificity than `.MuiChip-label`'s own single-class rule\n    // (two classes vs one) — wins over `chipLabelPadding`/`chipLabelSmallPadding`\n    // below regardless of stylesheet insertion order. See the module doc\n    // comment for why this must live here and not on the label slot itself.\n    // `chipClasses.label`, not a hand-typed `.MuiChip-label` string — the same\n    // module `Chip.js`'s own root style reads for its avatar/icon/delete-icon\n    // selectors, so this tracks whatever `Chip.js` itself puts on the label\n    // element rather than a separately-maintained copy of it. A host that\n    // calls `ClassNameGenerator.configure` before any `MuiChip` module loads\n    // renames the real class; a literal string would silently stop matching\n    // it, `chipClasses.label` cannot.\n    style[`& .${chipClasses.label}`] = { paddingLeft: rem(theme, px), paddingRight: rem(theme, px) };\n  }\n  return style;\n};\nconst chipSmallHeight = ({ theme }: { theme: Theme }): CSSObject => ({ height: rem(theme, 24) });\nconst chipLabelPadding = ({ theme }: { theme: Theme }): CSSObject => ({\n  paddingLeft: rem(theme, 12),\n  paddingRight: rem(theme, 12),\n});\nconst chipLabelSmallPadding = ({ theme }: { theme: Theme }): CSSObject => ({\n  paddingLeft: rem(theme, 8),\n  paddingRight: rem(theme, 8),\n});\n\n/** `MuiChip`'s own height (root) and label side padding (label), at both sizes MUI has. */\nexport function chipDensityOverrides(): Components<Theme> {\n  return {\n    MuiChip: {\n      styleOverrides: {\n        root: chipRootHeight,\n        sizeSmall: chipSmallHeight,\n        label: chipLabelPadding,\n        labelSmall: chipLabelSmallPadding,\n      },\n    },\n  };\n}\n"],"mappings":";;;;;AAAA,SAAS,mBAAmB;AA2H5B,IAAM,wBAAwB,CAAC,EAAE,MAAM,OAAoC,EAAE,SAAS,IAAI,OAAO,CAAC,EAAE;AACpG,IAAM,yBAAyB,CAAC,EAAE,MAAM,OAAoC,EAAE,SAAS,IAAI,OAAO,CAAC,EAAE;AACrG,IAAM,yBAAyB,CAAC,EAAE,MAAM,OAAoC,EAAE,SAAS,IAAI,OAAO,EAAE,EAAE;AAG/F,SAAS,6BAAgD;AAC9D,SAAO;AAAA,IACL,eAAe;AAAA,MACb,gBAAgB;AAAA,QACd,MAAM;AAAA,QACN,WAAW;AAAA,QACX,WAAW;AAAA,MACb;AAAA,IACF;AAAA,EACF;AACF;AAGA,IAAM,8BAA8B,EAAE,QAAQ,IAAI,OAAO,EAAE;AAE3D,IAAM,iBAAiB,CAAC;AAAA,EACtB;AAAA,EACA;AACF,MAGiB;AACf,QAAM,QAAmB,EAAE,QAAQ,IAAI,OAAO,EAAE,EAAE;AAClD,MAAI,YAAY,YAAY,YAAY;AACtC,UAAM,KAAK,4BAA4B,WAAW,SAAS,UAAU,UAAU,QAAQ;AAYvF,UAAM,MAAM,YAAY,KAAK,EAAE,IAAI,EAAE,aAAa,IAAI,OAAO,EAAE,GAAG,cAAc,IAAI,OAAO,EAAE,EAAE;AAAA,EACjG;AACA,SAAO;AACT;AACA,IAAM,kBAAkB,CAAC,EAAE,MAAM,OAAoC,EAAE,QAAQ,IAAI,OAAO,EAAE,EAAE;AAC9F,IAAM,mBAAmB,CAAC,EAAE,MAAM,OAAoC;AAAA,EACpE,aAAa,IAAI,OAAO,EAAE;AAAA,EAC1B,cAAc,IAAI,OAAO,EAAE;AAC7B;AACA,IAAM,wBAAwB,CAAC,EAAE,MAAM,OAAoC;AAAA,EACzE,aAAa,IAAI,OAAO,CAAC;AAAA,EACzB,cAAc,IAAI,OAAO,CAAC;AAC5B;AAGO,SAAS,uBAA0C;AACxD,SAAO;AAAA,IACL,SAAS;AAAA,MACP,gBAAgB;AAAA,QACd,MAAM;AAAA,QACN,WAAW;AAAA,QACX,OAAO;AAAA,QACP,YAAY;AAAA,MACd;AAAA,IACF;AAAA,EACF;AACF;","names":[]}