@lerianstudio/sindarian-ui 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/esm/components/ui/sidebar/sidebar-expand-button.js

@@ -7,7 +7,21 @@ import { SidebarFooter } from './sidebar-components.js';
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '../../ui/tooltip/index.js';
 import { IconButton } from '../icon-button/index.js';
 export const SidebarExpandButton = ({ tooltip }) => {
-    const { isCollapsed, toggleSidebar } = useSidebar();
+    const { isCollapsed, isDrawer, toggleSidebar } = useSidebar();
+    /**
+     * Nothing to collapse in a drawer. The expanded branch below hangs its button
+     * at `right-[-20px]`, twenty pixels outside the rail — off the canvas of an
+     * overlay that has no page beside it — and collapsing to a 72px strip inside
+     * a 244px sheet is not a state worth reaching. The drawer's own close control
+     * and the backdrop are how it is dismissed.
+     *
+     * ⚠️ `isDrawer`, NOT `isMobile`. A consumer left on the default
+     * `mobile="inline"` still has a real rail below 768px, and its collapse
+     * control has to come with it.
+     */
+    if (isDrawer) {
+        return null;
+    }
     return (_jsxs(React.Fragment, { children: [!isCollapsed && (_jsx("div", { "data-slot": "sidebar-expand-button", className: "border-border bg-card flex w-full", children: _jsx("div", { className: "absolute right-[-20px] bottom-4", children: _jsx(IconButton, { variant: "secondary", rounded: true, onClick: toggleSidebar, "aria-label": tooltip || 'Collapse sidebar', "aria-expanded": true, children: _jsx(PanelLeftClose, { className: "text-muted-foreground" }) }) }) })), isCollapsed && (_jsx(SidebarFooter, { children: _jsx(TooltipProvider, { children: _jsxs(Tooltip, { children: [_jsx(TooltipTrigger
                             // `hover:text-accent-foreground` on the TRIGGER, not only on
                             // the glyph below. The base ink here used to be base/400, which

package/dist/esm/components/ui/sidebar/sidebar-item.d.ts

@@ -9,5 +9,5 @@ export type SidebarItemProps = React.ComponentProps<typeof SidebarItemButton> &
     disabled?: boolean;
     children?: React.ReactNode;
 };
-export declare const SidebarItem: ({ active, href, children: _children, ...props }: SidebarItemProps) => React.JSX.Element;
+export declare const SidebarItem: ({ active, href, children: _children, onClick, ...props }: SidebarItemProps) => React.JSX.Element;
 //# sourceMappingURL=sidebar-item.d.ts.map

package/dist/esm/components/ui/sidebar/sidebar-item.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sidebar-item.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/sidebar/sidebar-item.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAIlE,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,cAAc,CAAC,OAAO,iBAAiB,CAAC,GAC3E,KAAK,CAAC,cAAc,CAAC,OAAO,qBAAqB,CAAC,GAAG;IACnD,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,KAAK,CAAC,SAAS,CAAA;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAC3B,CAAA;AAEH,eAAO,MAAM,WAAW,GAAI,iDAKzB,gBAAgB,sBA0BlB,CAAA"}
+{"version":3,"file":"sidebar-item.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/sidebar/sidebar-item.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAA;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAIlE,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,cAAc,CAAC,OAAO,iBAAiB,CAAC,GAC3E,KAAK,CAAC,cAAc,CAAC,OAAO,qBAAqB,CAAC,GAAG;IACnD,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,KAAK,CAAC,SAAS,CAAA;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAC3B,CAAA;AAEH,eAAO,MAAM,WAAW,GAAI,0DAMzB,gBAAgB,sBAsDlB,CAAA"}

package/dist/esm/components/ui/sidebar/sidebar-item.js

@@ -4,13 +4,37 @@ import { SidebarItemButton } from './sidebar-item-button.js';
 import { SidebarItemIconButton } from './sidebar-item-icon-button.js';
 import { useSidebar } from './sidebar-provider.js';
 import { useSidebarRouter } from './sidebar-router.js';
-export const SidebarItem = ({ active, href, children: _children, ...props }) => {
+export const SidebarItem = ({ active, href, children: _children, onClick, ...props }) => {
     const { usePathname } = useSidebarRouter();
     const pathname = usePathname();
-    const { isCollapsed } = useSidebar();
+    const { isCollapsed, isDrawer, setOpenMobile } = useSidebar();
     const isActive = (href) => pathname === href;
+    /**
+     * ⛔ ACTIVATING A DESTINATION CLOSES THE DRAWER. It is the whole point of the
+     * drawer and it was the one interaction that left it open: Escape, the
+     * backdrop and the X all dismissed it, a navigation link did not.
+     *
+     * The overlay is modal, so `document.body` carries `pointer-events: none`
+     * while it is up, and a consumer's `SidebarItem` is a client-side `Link`
+     * under a provider that survives the route change — so the reader landed on
+     * the new page rendered INERT behind a drawer they had to dismiss a second
+     * time, on a phone.
+     *
+     * Here rather than in `SidebarRoot`, because this is the component that knows
+     * an activation happened; `SidebarBackButton` and every
+     * `SidebarItemCollapsibleContent` leaf render through it, so they are covered
+     * by construction. Guarded on `isDrawer` so an inline rail — where nothing is
+     * covering the page — behaves exactly as before, and the consumer's own
+     * handler still runs either way.
+     */
+    const handleClick = (event) => {
+        onClick?.(event);
+        if (isDrawer) {
+            setOpenMobile(false);
+        }
+    };
     if (isCollapsed) {
-        return (_jsx(SidebarItemIconButton, { "data-slot": "sidebar-item", href: href, active: isActive(href) || active, ...props }));
+        return (_jsx(SidebarItemIconButton, { "data-slot": "sidebar-item", href: href, active: isActive(href) || active, onClick: handleClick, ...props }));
     }
-    return (_jsx(SidebarItemButton, { "data-slot": "sidebar-item", href: href, active: isActive(href) || active, ...props }));
+    return (_jsx(SidebarItemButton, { "data-slot": "sidebar-item", href: href, active: isActive(href) || active, onClick: handleClick, ...props }));
 };

package/dist/esm/components/ui/sidebar/sidebar-provider.d.ts

@@ -1,12 +1,49 @@
 import React from 'react';
+/**
+ * The viewport below which the rail stops being a layout and becomes a drawer.
+ *
+ * 767px rather than 768px: this is the upper bound of `max-width`, so it is the
+ * complement of Tailwind's `md` breakpoint (`min-width: 768px`) and `md:hidden`
+ * on `SidebarTrigger` flips at exactly the same pixel the query does.
+ */
+export declare const SIDEBAR_MOBILE_QUERY = "(max-width: 767px)";
 export type SidebarContextProps = {
     isCollapsed: boolean;
+    /**
+     * True only inside a drawer that `SidebarRoot` is actually rendering, which
+     * needs `mobile="drawer"` as well as a narrow viewport. `SidebarRoot`
+     * re-provides the context for that subtree; nothing else sets it.
+     */
+    isDrawer: boolean;
+    /**
+     * True while the viewport is narrow enough for a drawer. Reported in BOTH
+     * modes, so a consumer still on `mobile="inline"` can build its own
+     * responsive behaviour from it.
+     */
+    isMobile: boolean;
+    /** Whether the mobile drawer is showing. Meaningless while `isMobile` is false. */
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    /**
+     * Puts focus back on whatever opened the drawer. `SidebarRoot` calls it when
+     * the drawer closes; nothing else should need it.
+     */
+    restoreDrawerFocus: () => void;
+    /** The drawer's DOM id, so `SidebarTrigger` can point `aria-controls` at it. */
+    sidebarId: string;
     items: Record<string, boolean>;
     setItems: React.Dispatch<React.SetStateAction<Record<string, boolean>>>;
     getItemCollapsed: (key: string) => boolean;
     setItemCollapsed: (key: string, value: boolean) => void;
     toggleSidebar: () => void;
 };
+/**
+ * Exported so `SidebarRoot` can re-provide it for the drawer's subtree. That
+ * subtree is the only place `isCollapsed` and `isDrawer` differ from the
+ * provider's own values, and scoping the override to it is what keeps a
+ * consumer on `mobile="inline"` seeing exactly today's rail.
+ */
+export declare const SidebarContext: React.Context<SidebarContextProps | undefined>;
 export declare const useSidebar: () => SidebarContextProps;
 export declare const SidebarProvider: ({ children }: React.PropsWithChildren) => React.JSX.Element;
 //# sourceMappingURL=sidebar-provider.d.ts.map

package/dist/esm/components/ui/sidebar/sidebar-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sidebar-provider.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/sidebar/sidebar-provider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,OAAO,CAAA;IACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;IACvE,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;IAC1C,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IACvD,aAAa,EAAE,MAAM,IAAI,CAAA;CAC1B,CAAA;AAMD,eAAO,MAAM,UAAU,2BAMtB,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,cAAc,KAAK,CAAC,iBAAiB,sBAqDpE,CAAA"}
+{"version":3,"file":"sidebar-provider.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/sidebar/sidebar-provider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,uBAAuB,CAAA;AAUxD,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,OAAO,CAAA;IACpB;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAA;IACjB;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAA;IACjB,mFAAmF;IACnF,UAAU,EAAE,OAAO,CAAA;IACnB,aAAa,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IACtC;;;OAGG;IACH,kBAAkB,EAAE,MAAM,IAAI,CAAA;IAC9B,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;IACvE,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;IAC1C,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IACvD,aAAa,EAAE,MAAM,IAAI,CAAA;CAC1B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,gDAEf,CAAA;AAEZ,eAAO,MAAM,UAAU,2BAMtB,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,cAAc,KAAK,CAAC,iBAAiB,sBAkKpE,CAAA"}

package/dist/esm/components/ui/sidebar/sidebar-provider.js

@@ -2,7 +2,28 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import { getStorage, getStorageObject } from '../../../lib/storage/index.js';
-const SidebarContext = React.createContext(undefined);
+/**
+ * The viewport below which the rail stops being a layout and becomes a drawer.
+ *
+ * 767px rather than 768px: this is the upper bound of `max-width`, so it is the
+ * complement of Tailwind's `md` breakpoint (`min-width: 768px`) and `md:hidden`
+ * on `SidebarTrigger` flips at exactly the same pixel the query does.
+ */
+export const SIDEBAR_MOBILE_QUERY = '(max-width: 767px)';
+/**
+ * Where focus goes when the rail has to receive it. The rail's own content is
+ * links and buttons, so this is deliberately the short list rather than the
+ * full tabbable grammar: a `[tabindex]` sweep would have to exclude `-1`, and
+ * nothing in a sidebar carries one.
+ */
+const FOCUSABLE = 'a[href], button:not([disabled])';
+/**
+ * Exported so `SidebarRoot` can re-provide it for the drawer's subtree. That
+ * subtree is the only place `isCollapsed` and `isDrawer` differ from the
+ * provider's own values, and scoping the override to it is what keeps a
+ * consumer on `mobile="inline"` seeing exactly today's rail.
+ */
+export const SidebarContext = React.createContext(undefined);
 export const useSidebar = () => {
     const context = React.useContext(SidebarContext);
     if (!context) {
@@ -14,6 +35,61 @@ export const SidebarProvider = ({ children }) => {
     const [hydrated, setHydrated] = React.useState(false);
     const [collapsed, setCollapsed] = React.useState(false);
     const [items, _setItems] = React.useState({});
+    const [isMobile, setIsMobile] = React.useState(false);
+    const [openMobile, _setOpenMobile] = React.useState(false);
+    const sidebarId = React.useId();
+    /**
+     * ⛔ RADIX CANNOT RESTORE THIS FOCUS BY ITSELF. `DialogContent` preventDefaults
+     * the focus scope's own restore and focuses `triggerRef.current` instead —
+     * the ref a `SheetTrigger` would have filled. The drawer is opened from this
+     * state rather than from a trigger inside the dialog, so that ref is null and
+     * closing dropped focus onto `<body>`: a keyboard reader who opened the
+     * navigation and pressed Escape was returned to the top of the document.
+     *
+     * Captured here rather than in `SidebarTrigger` so that a consumer opening
+     * the drawer from its own control gets the same behaviour.
+     */
+    const opener = React.useRef(null);
+    const setOpenMobile = React.useCallback((open) => {
+        if (open && typeof document !== 'undefined') {
+            opener.current = document.activeElement;
+        }
+        _setOpenMobile(open);
+    }, []);
+    /**
+     * ⛔ THE VIEWPORT AT THE MOMENT FOCUS MOVES, NOT AT THE MOMENT IT OPENED.
+     *
+     * Radix calls `restoreDrawerFocus` from the focus scope's UNMOUNT handler,
+     * which is the last thing in the commit to touch focus — later than any
+     * effect in this provider, so the decision has to be made inside the handler
+     * rather than beside it. By then `isMobile` has already flipped.
+     */
+    const isMobileRef = React.useRef(false);
+    isMobileRef.current = isMobile;
+    const restoreDrawerFocus = React.useCallback(() => {
+        // `isConnected`: the control that opened the drawer may itself have been
+        // unmounted by whatever the reader did inside it.
+        //
+        // ⛔ AND NOT AT ALL WHEN THE VIEWPORT IS THE ONE THAT DISMISSED IT. A
+        // tablet rotated from portrait to landscape with the navigation open
+        // crosses 768px, so the drawer is replaced by the rail and the opener is
+        // `SidebarTrigger` — which the same breakpoint just hid with `md:hidden`.
+        // `.focus()` on a `display: none` element is a silent no-op, and Radix's
+        // own restore is already `preventDefault()`ed, so focus fell to `<body>`
+        // and the reader lost their place (SC 2.4.3). Measured in Chromium at
+        // 390 → 1280: `{"rails":1,"triggerDisplay":"none","focus":"BODY:"}`.
+        if (isMobileRef.current && opener.current?.isConnected) {
+            opener.current.focus();
+            return;
+        }
+        // The rail is what the drawer became, so that is where the reader goes.
+        // Below the breakpoint there is nothing here to find — a closed drawer
+        // leaves no navigation in the DOM — and focus stays where Radix left it.
+        document
+            .getElementById(sidebarId)
+            ?.querySelector(FOCUSABLE)
+            ?.focus();
+    }, [sidebarId]);
     const toggleSidebar = () => setCollapsed((collapsed) => !collapsed);
     const getItemCollapsed = (key) => {
         return items[key] || false;
@@ -27,6 +103,37 @@ export const SidebarProvider = ({ children }) => {
         _setItems(getStorageObject('sidebar-items', {}));
         setHydrated(true);
     }, []);
+    /**
+     * ⚠️ FALSE UNTIL THE CLIENT SAYS OTHERWISE. There is no viewport on the
+     * server, so the first paint is always the rail and the drawer appears on
+     * hydration; starting from a guess would make the markup differ between the
+     * two renders. The `matchMedia` guard is the one `theme-provider.tsx` next
+     * door already carries: jsdom and some embedded runtimes ship without it, and
+     * a missing media API is a desktop, not a crash.
+     */
+    React.useEffect(() => {
+        if (typeof window.matchMedia !== 'function') {
+            return;
+        }
+        const media = window.matchMedia(SIDEBAR_MOBILE_QUERY);
+        const sync = () => setIsMobile(media.matches);
+        sync();
+        media.addEventListener('change', sync);
+        return () => media.removeEventListener('change', sync);
+    }, []);
+    /**
+     * A drawer left open while the viewport grows back would keep an overlay and
+     * a focus trap over a layout that is already showing its rail, with nothing
+     * on screen to dismiss them.
+     *
+     * Where focus goes afterwards is `restoreDrawerFocus`'s decision, not this
+     * effect's: Radix's unmount handler runs later than anything here.
+     */
+    React.useEffect(() => {
+        if (!isMobile) {
+            _setOpenMobile(false);
+        }
+    }, [isMobile]);
     // Only persist to localStorage after hydration to avoid overwriting stored values
     React.useEffect(() => {
         if (!hydrated) {
@@ -41,7 +148,21 @@ export const SidebarProvider = ({ children }) => {
         localStorage.setItem('sidebar-items', JSON.stringify(items));
     }, [items, hydrated]);
     return (_jsx(SidebarContext.Provider, { value: {
+            /**
+             * ⚠️ A NARROW VIEWPORT DOES NOT TOUCH THIS. It used to be forced false
+             * whenever `isMobile`, which silently changed the rail for every
+             * consumer — including the ones that never asked for a drawer.
+             * `SidebarRoot` overrides it for the drawer's own subtree instead, so
+             * the stored preference reaches an inline rail unchanged at every
+             * viewport.
+             */
             isCollapsed: collapsed,
+            isDrawer: false,
+            isMobile,
+            openMobile,
+            setOpenMobile,
+            restoreDrawerFocus,
+            sidebarId,
             items,
             setItems: _setItems,
             getItemCollapsed,

package/dist/esm/components/ui/sidebar/sidebar-root.d.ts

@@ -1,3 +1,40 @@
 import React from 'react';
-export declare const SidebarRoot: ({ className, ...props }: React.ComponentProps<"nav">) => React.JSX.Element;
+export type SidebarRootProps = React.ComponentProps<'nav'> & {
+    /**
+     * What this rail becomes below 768px.
+     *
+     * - `'inline'` (default): nothing changes. The rail renders at every
+     *   viewport exactly as it always has, and the reader's collapsed preference
+     *   is untouched.
+     * - `'drawer'`: the inline rail is not rendered below the breakpoint and the
+     *   navigation moves into an overlay drawer that `SidebarTrigger` opens.
+     *
+     * ⛔ THE DEFAULT IS NOT A TASTE, IT IS A CONSUMER-SAFETY RULE. `SidebarTrigger`
+     * is the only way back into the drawer and it must render inside
+     * `SidebarProvider`. A consumer that has not placed one yet — which is every
+     * consumer at the moment this shipped — would get a phone with NO navigation
+     * rather than a rail that takes 63% of it, and that is strictly worse. Opt in
+     * once there is somewhere to put the trigger.
+     */
+    mobile?: 'inline' | 'drawer';
+    /**
+     * The drawer's accessible name. A dialog needs one, and it is read out when
+     * the drawer opens. Unused while `mobile` is `'inline'`.
+     */
+    mobileTitle?: string;
+};
+/**
+ * ⛔ BELOW 768px A RAIL IS NOT A LAYOUT — once a consumer opts in.
+ *
+ * The widths above are a fixed share of a flex row, so at 390px the expanded
+ * rail took 63% of the screen and left the page 146px, and the only affordance
+ * — `SidebarExpandButton` — shrinks it to 72px, which is still 18% and still
+ * permanently on screen. There was nothing that removed it.
+ *
+ * With `mobile="drawer"` the rail is replaced below the breakpoint by an
+ * overlay drawer. Escape, the backdrop click, the focus trap and returning
+ * focus to whatever opened it are Radix Dialog's, through the kit's own
+ * `Sheet`; none of that is re-implemented here.
+ */
+export declare const SidebarRoot: ({ className, id, mobile, mobileTitle, ...props }: SidebarRootProps) => React.JSX.Element;
 //# sourceMappingURL=sidebar-root.d.ts.map

package/dist/esm/components/ui/sidebar/sidebar-root.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sidebar-root.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/sidebar/sidebar-root.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAA;AAoBzB,eAAO,MAAM,WAAW,GAAI,yBAGzB,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,sBAW7B,CAAA"}
+{"version":3,"file":"sidebar-root.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/sidebar/sidebar-root.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAA;AAqEzB,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG;IAC3D;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC5B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,kDAMzB,gBAAgB,sBA0GlB,CAAA"}

package/dist/esm/components/ui/sidebar/sidebar-root.js

@@ -1,20 +1,115 @@
 'use client';
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { cva } from 'class-variance-authority';
-import { useSidebar } from './sidebar-provider.js';
+import { SidebarContext, useSidebar } from './sidebar-provider.js';
 import { cn } from '../../../lib/utils.js';
+import { Sheet, SheetContent, SheetTitle } from '../sheet/index.js';
+/**
+ * ⛔ THE WIDTHS ARE TOKENS, NOT LITERALS.
+ *
+ * They were `w-[72px]` and `w-[244px]`, which a consumer could only override by
+ * winning a specificity argument with `cn`. `--sidebar-width` and
+ * `--sidebar-width-collapsed` are declared in `globals.css`, so the default
+ * still ships with the stylesheet, and a consumer re-points either one with
+ * `className="[--sidebar-width:280px]"` ON THE RAIL, which moves the rail and
+ * the mobile drawer together (see `liftWidthOverrides` below), or with a rule
+ * on `:root`/`html`.
+ *
+ * ⚠️ A DECLARATION ON A REACT-TREE ANCESTOR REACHES THE RAIL AND NOT THE
+ * DRAWER. Custom properties inherit down the DOM tree, and the drawer is
+ * portalled to `document.body`, so a layout wrapper is not an ancestor of it.
+ * `:root` is, which is why it is named above and a wrapper is not.
+ */
 const sidebarVariants = cva('group/sidebar shadow-sidebar relative flex flex-col transition-[width] duration-300 ease-in-out', {
     variants: {
         collapsed: {
-            true: 'w-[72px]',
-            false: 'w-[244px]'
+            true: 'w-[var(--sidebar-width-collapsed)]',
+            false: 'w-[var(--sidebar-width)]'
         }
     },
     defaultVariants: {
         collapsed: false
     }
 });
-export const SidebarRoot = ({ className, ...props }) => {
-    const { isCollapsed } = useSidebar();
-    return (_jsx("nav", { "data-slot": "sidebar-root", className: cn(sidebarVariants({ collapsed: isCollapsed }), className), "data-collapsed": isCollapsed, ...props }));
+/**
+ * Tailwind arbitrary-property classes that re-point the sidebar geometry, e.g.
+ * `[--sidebar-width:320px]` or `[--sidebar-width-collapsed:88px]`.
+ *
+ * ⚠️ ANCHORED TO A CLASS BOUNDARY, WHICH IS THE WHOLE POINT OF THE LOOKBEHIND.
+ * Unanchored it also matched the tail of `md:[--sidebar-width:320px]` and
+ * lifted it with the prefix stripped — an override a consumer scoped to
+ * ≥768px, applied unconditionally to the drawer that only exists below it.
+ */
+const WIDTH_OVERRIDE = /(?<=^|\s)\[--sidebar-width(?:-collapsed)?:[^\]]+\]/g;
+/**
+ * ⛔ THE ONE PART OF THE CONSUMER'S className THAT HAS TO CROSS THE PORTAL.
+ *
+ * `SheetContent` mounts through `SheetPortal` into `document.body`, and custom
+ * properties inherit down the DOM tree rather than the React tree. So the
+ * documented override — a class on the rail — set `--sidebar-width` on an
+ * element the drawer is not a descendant of, and the whole className that DOES
+ * travel lands on the inner `<nav>`, which is BELOW the element that reads the
+ * variable. Measured in Chromium: rail 320px, drawer 244px. Following the
+ * instruction handed to product-console produced a 280px rail on desktop and a
+ * 244px drawer on a phone, silently.
+ *
+ * ⚠️ ONLY THE GEOMETRY TOKENS. The rest of a rail className is rail-shaped —
+ * `h-full`, and the `data-[collapsed=false]:min-w-70` all eight console
+ * sidebars pass — and putting that on the sheet would reinstate the
+ * 280px-inside-a-244px-sheet overflow from the other side.
+ */
+function liftWidthOverrides(className) {
+    return className?.match(WIDTH_OVERRIDE)?.join(' ');
+}
+/**
+ * ⛔ BELOW 768px A RAIL IS NOT A LAYOUT — once a consumer opts in.
+ *
+ * The widths above are a fixed share of a flex row, so at 390px the expanded
+ * rail took 63% of the screen and left the page 146px, and the only affordance
+ * — `SidebarExpandButton` — shrinks it to 72px, which is still 18% and still
+ * permanently on screen. There was nothing that removed it.
+ *
+ * With `mobile="drawer"` the rail is replaced below the breakpoint by an
+ * overlay drawer. Escape, the backdrop click, the focus trap and returning
+ * focus to whatever opened it are Radix Dialog's, through the kit's own
+ * `Sheet`; none of that is re-implemented here.
+ */
+export const SidebarRoot = ({ className, id, mobile = 'inline', mobileTitle = 'Navigation', ...props }) => {
+    const context = useSidebar();
+    const { isCollapsed, isMobile, openMobile, setOpenMobile, restoreDrawerFocus, sidebarId } = context;
+    if (!isMobile || mobile === 'inline') {
+        return (_jsx("nav", { "data-slot": "sidebar-root", className: cn(sidebarVariants({ collapsed: isCollapsed }), className), "data-collapsed": isCollapsed, ...props, id: mobile === 'drawer' ? sidebarId : id }));
+    }
+    return (_jsx(SidebarContext.Provider, { value: { ...context, isCollapsed: false, isDrawer: true }, children: _jsx(Sheet, { open: openMobile, onOpenChange: setOpenMobile, children: _jsxs(SheetContent, { side: "left", 
+                // The Sheet's own paddings are built for a form panel; a rail brings
+                // its own. `max-w-full` so a consumer widening `--sidebar-width` past
+                // the viewport still cannot push the drawer off screen. The lifted
+                // override goes LAST so it re-points the variable this element reads.
+                className: cn('w-[var(--sidebar-width)] max-w-full gap-0 p-0', liftWidthOverrides(className)), "aria-describedby": undefined, 
+                // ⛔ RADIX'S OWN RESTORE GOES NOWHERE HERE. `DialogContent`
+                // preventDefaults the focus scope's restore and focuses the ref a
+                // `SheetTrigger` would have filled; this drawer is opened from provider
+                // state, so that ref is null and closing dropped focus onto `<body>`.
+                // Running first means `composeEventHandlers` skips Radix's half.
+                onCloseAutoFocus: (event) => {
+                    event.preventDefault();
+                    restoreDrawerFocus();
+                }, children: [_jsx(SheetTitle, { className: "sr-only", children: mobileTitle }), _jsx("nav", { "data-slot": "sidebar-root", "data-mobile": "true", 
+                        /* ⛔ NO `data-collapsed` HERE. The consumer className is forwarded
+                           verbatim, and all eight console sidebars pass
+                           `data-[collapsed=false]:min-w-70`; stamping the attribute armed
+                           it, giving the navigation a 280px min-width inside a 244px sheet.
+                           `min-width` resolves after `max-width`, so the sheet could not
+                           claw it back and the contents were 36px wider than the drawer.
+                           `data-mobile` already names this surface and a drawer is never
+                           collapsed, so the attribute had nothing left to say. */
+                        className: cn(sidebarVariants({ collapsed: false }), 'h-full w-full shadow-none', className), ...props, 
+                        /* ⛔ AFTER THE SPREAD, AND NOT THE CALLER'S. This is the target of
+                           `SidebarTrigger`'s `aria-controls` and the handle the provider
+                           uses to put focus back into the navigation when the viewport
+                           grows. Spread first, a caller that set `id` replaced it and left
+                           a dangling `aria-controls` — which axe reports as a CRITICAL
+                           `aria-valid-attr-value` — and a focus restore that lands on
+                           `<body>`. Both silent. */
+                        id: sidebarId })] }) }) }));
 };

package/dist/esm/components/ui/sidebar/sidebar-trigger.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { IconButton } from '../icon-button/index.js';
+export type SidebarTriggerProps = React.ComponentProps<typeof IconButton>;
+/**
+ * The control that opens the mobile drawer.
+ *
+ * `md:hidden` by default because above 768px the rail is already on screen and
+ * a second way to reach it is a second thing to explain; a consumer that wants
+ * it everywhere passes its own display class.
+ *
+ * ⚠️ `aria-controls` IS SET ONLY WHILE THE DRAWER EXISTS. Radix unmounts the
+ * dialog content when closed, and a reference to an element that is not in the
+ * DOM is what axe-core reports as a CRITICAL `aria-valid-attr-value` — the same
+ * defect the Autocomplete panel was repaired for (console-sdk#150). A toggle
+ * with `aria-expanded="false"` and no `aria-controls` is complete on its own.
+ */
+export declare const SidebarTrigger: ({ className, onClick, "aria-label": ariaLabel, ...props }: SidebarTriggerProps) => React.JSX.Element;
+//# sourceMappingURL=sidebar-trigger.d.ts.map

package/dist/esm/components/ui/sidebar/sidebar-trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sidebar-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/sidebar/sidebar-trigger.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAG3C,MAAM,MAAM,mBAAmB,GAAG,KAAK,CAAC,cAAc,CAAC,OAAO,UAAU,CAAC,CAAA;AAEzE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,GAAI,2DAK5B,mBAAmB,sBAqBrB,CAAA"}

package/dist/esm/components/ui/sidebar/sidebar-trigger.js

@@ -0,0 +1,26 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Menu } from 'lucide-react';
+import { cn } from '../../../lib/utils.js';
+import { IconButton } from '../icon-button/index.js';
+import { useSidebar } from './sidebar-provider.js';
+/**
+ * The control that opens the mobile drawer.
+ *
+ * `md:hidden` by default because above 768px the rail is already on screen and
+ * a second way to reach it is a second thing to explain; a consumer that wants
+ * it everywhere passes its own display class.
+ *
+ * ⚠️ `aria-controls` IS SET ONLY WHILE THE DRAWER EXISTS. Radix unmounts the
+ * dialog content when closed, and a reference to an element that is not in the
+ * DOM is what axe-core reports as a CRITICAL `aria-valid-attr-value` — the same
+ * defect the Autocomplete panel was repaired for (console-sdk#150). A toggle
+ * with `aria-expanded="false"` and no `aria-controls` is complete on its own.
+ */
+export const SidebarTrigger = ({ className, onClick, 'aria-label': ariaLabel = 'Open navigation', ...props }) => {
+    const { openMobile, setOpenMobile, sidebarId } = useSidebar();
+    return (_jsx(IconButton, { type: "button", variant: "outline", "data-slot": "sidebar-trigger", "aria-label": ariaLabel, "aria-expanded": openMobile, "aria-controls": openMobile ? sidebarId : undefined, className: cn('md:hidden', className), onClick: (event) => {
+            onClick?.(event);
+            setOpenMobile(!openMobile);
+        }, ...props, children: _jsx(Menu, { "aria-hidden": true }) }));
+};

package/dist/esm/components/ui/toggle-group/index.d.ts

@@ -13,6 +13,6 @@ declare const toggleVariants: (props?: ({
 declare function ToggleGroup({ className, variant, size, spacing, children, style, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants> & {
     spacing?: number;
 }): React.JSX.Element;
-declare function ToggleGroupItem({ className, children, variant, size, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): React.JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, onFocus, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): React.JSX.Element;
 export { ToggleGroup, ToggleGroupItem };
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/components/ui/toggle-group/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/toggle-group/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,oBAAoB,MAAM,8BAA8B,CAAA;AACpE,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAIjE;;;;GAIG;AACH,QAAA,MAAM,cAAc;;;8EAoBnB,CAAA;AAYD,iBAAS,WAAW,CAAC,EACnB,SAAS,EACT,OAAO,EACP,IAAI,EACJ,OAAW,EACX,QAAQ,EACR,KAAK,EACL,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,IAAI,CAAC,GACvD,YAAY,CAAC,OAAO,cAAc,CAAC,GAAG;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,qBAwBF;AAED,iBAAS,eAAe,CAAC,EACvB,SAAS,EACT,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,IAAI,CAAC,GACvD,YAAY,CAAC,OAAO,cAAc,CAAC,qBAuBpC;AAED,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/toggle-group/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,KAAK,oBAAoB,MAAM,8BAA8B,CAAA;AACpE,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAIjE;;;;GAIG;AACH,QAAA,MAAM,cAAc;;;8EAoBnB,CAAA;AA4DD,iBAAS,WAAW,CAAC,EACnB,SAAS,EACT,OAAO,EACP,IAAI,EACJ,OAAW,EACX,QAAQ,EACR,KAAK,EACL,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,IAAI,CAAC,GACvD,YAAY,CAAC,OAAO,cAAc,CAAC,GAAG;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,qBA+BF;AAED,iBAAS,eAAe,CAAC,EACvB,SAAS,EACT,QAAQ,EACR,OAAO,EACP,IAAI,EACJ,OAAO,EACP,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,oBAAoB,CAAC,IAAI,CAAC,GACvD,YAAY,CAAC,OAAO,cAAc,CAAC,qBAiDpC;AAED,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,CAAA"}

package/dist/esm/components/ui/toggle-group/index.js

@@ -26,12 +26,58 @@ const toggleVariants = cva("hover:bg-muted hover:text-muted-foreground focus-vis
         size: 'default'
     }
 });
+const ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];
+/**
+ * Is an arrow key down right now?
+ *
+ * This is how an item tells keyboard navigation apart from a pointer press or a
+ * programmatic focus, and it is the seam Radix uses for the same job in its own
+ * `RadioGroup`. It works because `RovingFocusGroup` defers the focus move to a
+ * `setTimeout`: the keydown has already bubbled to `document` and set the flag
+ * by the time the item receives `focus`.
+ *
+ * The distinction is not cosmetic. A pointer press focuses BEFORE the click
+ * lands, so selecting on every focus would turn one click into
+ * select-then-deselect and break mouse selection outright.
+ *
+ * Returns null when disabled, so `type="multiple"` carries no flag to read.
+ */
+function useArrowKeyPressed(enabled) {
+    const arrowKeyPressed = React.useRef(false);
+    React.useEffect(() => {
+        if (!enabled)
+            return;
+        const onKeyDown = (event) => {
+            if (ARROW_KEYS.includes(event.key))
+                arrowKeyPressed.current = true;
+        };
+        const onKeyUp = () => {
+            arrowKeyPressed.current = false;
+        };
+        document.addEventListener('keydown', onKeyDown);
+        document.addEventListener('keyup', onKeyUp);
+        window.addEventListener('blur', onKeyUp);
+        return () => {
+            document.removeEventListener('keydown', onKeyDown);
+            document.removeEventListener('keyup', onKeyUp);
+            window.removeEventListener('blur', onKeyUp);
+            // A group unmounted mid-keystroke never sees the keyup.
+            arrowKeyPressed.current = false;
+        };
+    }, [enabled]);
+    return enabled ? arrowKeyPressed : null;
+}
 const ToggleGroupContext = React.createContext({
     size: 'default',
     variant: 'default',
-    spacing: 0
+    spacing: 0,
+    arrowKeyPressed: null
 });
 function ToggleGroup({ className, variant, size, spacing = 0, children, style, ...props }) {
+    // Read, never destructured: `type` is the discriminant of the Radix props
+    // union, and pulling it out then spreading it back widens the union so the
+    // single/multiple props stop resolving.
+    const arrowKeyPressed = useArrowKeyPressed(props.type === 'single');
     return (_jsx(ToggleGroupPrimitive.Root, { "data-slot": "toggle-group", "data-variant": variant, "data-size": size, "data-spacing": spacing, 
         // Caller style first: `--gap` is ours and must survive, but everything
         // else the caller passes has to reach the element.
@@ -39,13 +85,36 @@ function ToggleGroup({ className, variant, size, spacing = 0, children, style, .
         // Legacy carried a `data-[spacing=default]:...:shadow-xs` rule here that
         // never matched — `data-spacing` is always a number. Removed rather than
         // activated, so the rendered pixels stay identical to sindarian-x.
-        'group/toggle-group flex w-fit items-center gap-[--spacing(var(--gap))] rounded-md', className), ...props, children: _jsx(ToggleGroupContext.Provider, { value: { variant, size, spacing }, children: children }) }));
+        'group/toggle-group flex w-fit items-center gap-[--spacing(var(--gap))] rounded-md', className), ...props, children: _jsx(ToggleGroupContext.Provider, { value: { variant, size, spacing, arrowKeyPressed }, children: children }) }));
 }
-function ToggleGroupItem({ className, children, variant, size, ...props }) {
+function ToggleGroupItem({ className, children, variant, size, onFocus, ...props }) {
     const context = React.useContext(ToggleGroupContext);
+    /**
+     * Selection follows focus, which is what `role="radio"` promises.
+     *
+     * With `type="single"` Radix puts the group on the ARIA radio pattern: the
+     * root is a `radiogroup`, each item a `radio` with `aria-checked`. Under that
+     * pattern an arrow key both moves focus and checks the item it lands on.
+     * Radix only moves focus, so a screen-reader operator used to arrow across
+     * "radio, not checked, 2 of 3" with nothing ever selected.
+     *
+     * `type="multiple"` is a `toolbar` of `aria-pressed` buttons and keeps its
+     * current behavior, where moving focus without pressing is correct: the flag
+     * is null there.
+     *
+     * Clicking the element rather than writing the value keeps a single
+     * activation path, so Radix's own toggle and any caller `onClick` both fire
+     * exactly as they do for a real click.
+     */
+    const handleFocus = (event) => {
+        onFocus?.(event);
+        if (context.arrowKeyPressed?.current) {
+            event.currentTarget.click();
+        }
+    };
     return (_jsx(ToggleGroupPrimitive.Item, { "data-slot": "toggle-group-item", "data-variant": context.variant || variant, "data-size": context.size || size, "data-spacing": context.spacing, className: cn(toggleVariants({
             variant: context.variant || variant,
             size: context.size || size
-        }), 'w-auto min-w-0 shrink-0 px-3 focus:z-10 focus-visible:z-10', 'data-[spacing=0]:rounded-none data-[spacing=0]:shadow-none data-[spacing=0]:first:rounded-l-md data-[spacing=0]:last:rounded-r-md data-[spacing=0]:data-[variant=outline]:border-l-0 data-[spacing=0]:data-[variant=outline]:first:border-l', className), ...props, children: children }));
+        }), 'w-auto min-w-0 shrink-0 px-3 focus:z-10 focus-visible:z-10', 'data-[spacing=0]:rounded-none data-[spacing=0]:shadow-none data-[spacing=0]:first:rounded-l-md data-[spacing=0]:last:rounded-r-md data-[spacing=0]:data-[variant=outline]:border-l-0 data-[spacing=0]:data-[variant=outline]:first:border-l', className), ...props, onFocus: handleFocus, children: children }));
 }
 export { ToggleGroup, ToggleGroupItem };

package/dist/esm/enterprise/number-input/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/enterprise/number-input/index.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,wDAAwD;IACxD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,+EAA+E;IAC/E,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAC5C,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,8CAA8C;IAC9C,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,sDAAsD;IACtD,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAmED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgBpE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAMxE;AAED,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,aAAa,EACb,GAAG,EACH,GAAG,EACH,IAAQ,EACR,SAAS,EACT,MAAM,EACN,QAAgB,EAChB,EAAE,EACF,SAAS,EACT,WAAW,EACX,YAAY,EAAE,SAAS,EACvB,kBAAkB,EAAE,eAAe,EACpC,EAAE,gBAAgB,qBAgJlB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/enterprise/number-input/index.tsx"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,wDAAwD;IACxD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,+EAA+E;IAC/E,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAC5C,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,8CAA8C;IAC9C,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,sDAAsD;IACtD,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAmED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgBpE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAMxE;AAED,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,aAAa,EACb,GAAG,EACH,GAAG,EACH,IAAQ,EACR,SAAS,EACT,MAAM,EACN,QAAgB,EAChB,EAAE,EACF,SAAS,EACT,WAAW,EACX,YAAY,EAAE,SAAS,EACvB,kBAAkB,EAAE,eAAe,EACpC,EAAE,gBAAgB,qBA2JlB"}