Add comprehensive frontend UI and distributed infrastructure

Frontend Enhancements:
- Complete React TypeScript frontend with modern UI components
- Distributed workflows management interface with real-time updates
- Socket.IO integration for live agent status monitoring
- Agent management dashboard with cluster visualization
- Project management interface with metrics and task tracking
- Responsive design with proper error handling and loading states

Backend Infrastructure:
- Distributed coordinator for multi-agent workflow orchestration
- Cluster management API with comprehensive agent operations
- Enhanced database models for agents and projects
- Project service for filesystem-based project discovery
- Performance monitoring and metrics collection
- Comprehensive API documentation and error handling

Documentation:
- Complete distributed development guide (README_DISTRIBUTED.md)
- Comprehensive development report with architecture insights
- System configuration templates and deployment guides

The platform now provides a complete web interface for managing the distributed AI cluster
with real-time monitoring, workflow orchestration, and agent coordination capabilities.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

frontend/node_modules/@headlessui/react/dist/components/combobox/combobox.d.ts

@@ -0,0 +1,138 @@
+import React, { type ElementType, type Ref } from 'react';
+import type { ByComparator, EnsureArray, Expand, Props } from '../../types.js';
+import { type HasDisplayName, type PropsForFeatures, type RefProp } from '../../utils/render.js';
+declare let DEFAULT_COMBOBOX_TAG: React.ExoticComponent<{
+    children?: React.ReactNode;
+}>;
+interface ComboboxRenderPropArg<TValue, TActive = TValue> {
+    open: boolean;
+    disabled: boolean;
+    activeIndex: number | null;
+    activeOption: TActive | null;
+    value: TValue;
+}
+type O = 'value' | 'defaultValue' | 'nullable' | 'multiple' | 'onChange' | 'by';
+type ComboboxValueProps<TValue, TNullable extends boolean | undefined, TMultiple extends boolean | undefined, TTag extends ElementType> = Extract<({
+    value?: EnsureArray<TValue>;
+    defaultValue?: EnsureArray<TValue>;
+    nullable: true;
+    multiple: true;
+    onChange?(value: EnsureArray<TValue>): void;
+    by?: ByComparator<TValue>;
+} & Props<TTag, ComboboxRenderPropArg<EnsureArray<TValue>, TValue>, O>) | ({
+    value?: TValue | null;
+    defaultValue?: TValue | null;
+    nullable: true;
+    multiple?: false;
+    onChange?(value: TValue | null): void;
+    by?: ByComparator<TValue | null>;
+} & Expand<Props<TTag, ComboboxRenderPropArg<TValue | null>, O>>) | ({
+    value?: EnsureArray<TValue>;
+    defaultValue?: EnsureArray<TValue>;
+    nullable?: false;
+    multiple: true;
+    onChange?(value: EnsureArray<TValue>): void;
+    by?: ByComparator<TValue extends Array<infer U> ? U : TValue>;
+} & Expand<Props<TTag, ComboboxRenderPropArg<EnsureArray<TValue>, TValue>, O>>) | ({
+    value?: TValue;
+    nullable?: false;
+    multiple?: false;
+    defaultValue?: TValue;
+    onChange?(value: TValue): void;
+    by?: ByComparator<TValue>;
+} & Props<TTag, ComboboxRenderPropArg<TValue>, O>), {
+    nullable?: TNullable;
+    multiple?: TMultiple;
+}>;
+export type ComboboxProps<TValue, TNullable extends boolean | undefined, TMultiple extends boolean | undefined, TTag extends ElementType> = ComboboxValueProps<TValue, TNullable, TMultiple, TTag> & {
+    disabled?: boolean;
+    __demoMode?: boolean;
+    form?: string;
+    name?: string;
+};
+declare function ComboboxFn<TValue, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(props: ComboboxProps<TValue, true, true, TTag>, ref: Ref<HTMLElement>): JSX.Element;
+declare function ComboboxFn<TValue, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(props: ComboboxProps<TValue, true, false, TTag>, ref: Ref<HTMLElement>): JSX.Element;
+declare function ComboboxFn<TValue, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(props: ComboboxProps<TValue, false, false, TTag>, ref: Ref<HTMLElement>): JSX.Element;
+declare function ComboboxFn<TValue, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(props: ComboboxProps<TValue, false, true, TTag>, ref: Ref<HTMLElement>): JSX.Element;
+declare let DEFAULT_INPUT_TAG: "input";
+interface InputRenderPropArg {
+    open: boolean;
+    disabled: boolean;
+}
+type InputPropsWeControl = 'aria-activedescendant' | 'aria-autocomplete' | 'aria-controls' | 'aria-expanded' | 'aria-labelledby' | 'disabled' | 'role';
+export type ComboboxInputProps<TTag extends ElementType, TType> = Props<TTag, InputRenderPropArg, InputPropsWeControl, {
+    defaultValue?: TType;
+    displayValue?(item: TType): string;
+    onChange?(event: React.ChangeEvent<HTMLInputElement>): void;
+}>;
+declare function InputFn<TTag extends ElementType = typeof DEFAULT_INPUT_TAG, TType = Parameters<typeof ComboboxRoot>[0]['value']>(props: ComboboxInputProps<TTag, TType>, ref: Ref<HTMLInputElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_BUTTON_TAG: "button";
+interface ButtonRenderPropArg {
+    open: boolean;
+    disabled: boolean;
+    value: any;
+}
+type ButtonPropsWeControl = 'aria-controls' | 'aria-expanded' | 'aria-haspopup' | 'aria-labelledby' | 'disabled' | 'tabIndex';
+export type ComboboxButtonProps<TTag extends ElementType> = Props<TTag, ButtonRenderPropArg, ButtonPropsWeControl>;
+declare function ButtonFn<TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: ComboboxButtonProps<TTag>, ref: Ref<HTMLButtonElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_LABEL_TAG: "label";
+interface LabelRenderPropArg {
+    open: boolean;
+    disabled: boolean;
+}
+export type ComboboxLabelProps<TTag extends ElementType> = Props<TTag, LabelRenderPropArg>;
+declare function LabelFn<TTag extends ElementType = typeof DEFAULT_LABEL_TAG>(props: ComboboxLabelProps<TTag>, ref: Ref<HTMLLabelElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_OPTIONS_TAG: "ul";
+interface OptionsRenderPropArg {
+    open: boolean;
+    option: unknown;
+}
+type OptionsPropsWeControl = 'aria-labelledby' | 'aria-multiselectable' | 'role' | 'tabIndex';
+declare let OptionsRenderFeatures: number;
+export type ComboboxOptionsProps<TTag extends ElementType> = Props<TTag, OptionsRenderPropArg, OptionsPropsWeControl, PropsForFeatures<typeof OptionsRenderFeatures> & {
+    hold?: boolean;
+}>;
+declare function OptionsFn<TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG>(props: ComboboxOptionsProps<TTag>, ref: Ref<HTMLUListElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_OPTION_TAG: "li";
+interface OptionRenderPropArg {
+    active: boolean;
+    selected: boolean;
+    disabled: boolean;
+}
+type OptionPropsWeControl = 'role' | 'tabIndex' | 'aria-disabled' | 'aria-selected';
+export type ComboboxOptionProps<TTag extends ElementType, TType> = Props<TTag, OptionRenderPropArg, OptionPropsWeControl, {
+    disabled?: boolean;
+    value: TType;
+    order?: number;
+}>;
+declare function OptionFn<TTag extends ElementType = typeof DEFAULT_OPTION_TAG, TType = Parameters<typeof ComboboxRoot>[0]['value']>(props: ComboboxOptionProps<TTag, TType>, ref: Ref<HTMLLIElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+export interface _internal_ComponentCombobox extends HasDisplayName {
+    <TValue, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(props: ComboboxProps<TValue, true, true, TTag> & RefProp<typeof ComboboxFn>): JSX.Element;
+    <TValue, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(props: ComboboxProps<TValue, true, false, TTag> & RefProp<typeof ComboboxFn>): JSX.Element;
+    <TValue, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(props: ComboboxProps<TValue, false, true, TTag> & RefProp<typeof ComboboxFn>): JSX.Element;
+    <TValue, TTag extends ElementType = typeof DEFAULT_COMBOBOX_TAG>(props: ComboboxProps<TValue, false, false, TTag> & RefProp<typeof ComboboxFn>): JSX.Element;
+}
+export interface _internal_ComponentComboboxButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: ComboboxButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+export interface _internal_ComponentComboboxInput extends HasDisplayName {
+    <TType, TTag extends ElementType = typeof DEFAULT_INPUT_TAG>(props: ComboboxInputProps<TTag, TType> & RefProp<typeof InputFn>): JSX.Element;
+}
+export interface _internal_ComponentComboboxLabel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_LABEL_TAG>(props: ComboboxLabelProps<TTag> & RefProp<typeof LabelFn>): JSX.Element;
+}
+export interface _internal_ComponentComboboxOptions extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG>(props: ComboboxOptionsProps<TTag> & RefProp<typeof OptionsFn>): JSX.Element;
+}
+export interface _internal_ComponentComboboxOption extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OPTION_TAG, TType = Parameters<typeof ComboboxRoot>[0]['value']>(props: ComboboxOptionProps<TTag, TType> & RefProp<typeof OptionFn>): JSX.Element;
+}
+declare let ComboboxRoot: _internal_ComponentCombobox;
+export declare let Combobox: _internal_ComponentCombobox & {
+    Input: _internal_ComponentComboboxInput;
+    Button: _internal_ComponentComboboxButton;
+    Label: _internal_ComponentComboboxLabel;
+    Options: _internal_ComponentComboboxOptions;
+    Option: _internal_ComponentComboboxOption;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/description/description.d.ts

@@ -0,0 +1,23 @@
+import React, { type ElementType, type ReactNode, type Ref } from 'react';
+import { Props } from '../../types.js';
+import { type HasDisplayName, type RefProp } from '../../utils/render.js';
+interface SharedData {
+    slot?: {};
+    name?: string;
+    props?: {};
+}
+interface DescriptionProviderProps extends SharedData {
+    children: ReactNode;
+}
+export declare function useDescriptions(): [
+    string | undefined,
+    (props: DescriptionProviderProps) => JSX.Element
+];
+declare let DEFAULT_DESCRIPTION_TAG: "p";
+export type DescriptionProps<TTag extends ElementType = typeof DEFAULT_DESCRIPTION_TAG> = Props<TTag>;
+declare function DescriptionFn<TTag extends ElementType = typeof DEFAULT_DESCRIPTION_TAG>(props: DescriptionProps<TTag>, ref: Ref<HTMLParagraphElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+export interface _internal_ComponentDescription extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_DESCRIPTION_TAG>(props: DescriptionProps<TTag> & RefProp<typeof DescriptionFn>): JSX.Element;
+}
+export declare let Description: _internal_ComponentDescription;
+export {};

frontend/node_modules/@headlessui/react/dist/components/description/description.js

@@ -0,0 +1 @@
+import u,{createContext as m,useContext as D,useMemo as l,useState as T}from"react";import{useEvent as P}from'../../hooks/use-event.js';import{useId as g}from'../../hooks/use-id.js';import{useIsoMorphicEffect as E}from'../../hooks/use-iso-morphic-effect.js';import{useSyncRefs as x}from'../../hooks/use-sync-refs.js';import{forwardRefWithAs as y,render as R}from'../../utils/render.js';let d=m(null);function f(){let r=D(d);if(r===null){let t=new Error("You used a <Description /> component, but it is not inside a relevant parent.");throw Error.captureStackTrace&&Error.captureStackTrace(t,f),t}return r}function w(){let[r,t]=T([]);return[r.length>0?r.join(" "):void 0,l(()=>function(e){let i=P(s=>(t(o=>[...o,s]),()=>t(o=>{let p=o.slice(),c=p.indexOf(s);return c!==-1&&p.splice(c,1),p}))),n=l(()=>({register:i,slot:e.slot,name:e.name,props:e.props}),[i,e.slot,e.name,e.props]);return u.createElement(d.Provider,{value:n},e.children)},[t])]}let I="p";function S(r,t){let a=g(),{id:e=`headlessui-description-${a}`,...i}=r,n=f(),s=x(t);E(()=>n.register(e),[e,n.register]);let o={ref:s,...n.props,id:e};return R({ourProps:o,theirProps:i,slot:n.slot||{},defaultTag:I,name:n.name||"Description"})}let h=y(S),G=Object.assign(h,{});export{G as Description,w as useDescriptions};

frontend/node_modules/@headlessui/react/dist/components/dialog/dialog.d.ts

@@ -0,0 +1,69 @@
+import React, { type ElementType, type MutableRefObject, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type PropsForFeatures, type RefProp } from '../../utils/render.js';
+import { _internal_ComponentDescription } from '../description/description.js';
+declare let DEFAULT_DIALOG_TAG: "div";
+interface DialogRenderPropArg {
+    open: boolean;
+}
+type DialogPropsWeControl = 'aria-describedby' | 'aria-labelledby' | 'aria-modal';
+declare let DialogRenderFeatures: number;
+export type DialogProps<TTag extends ElementType> = Props<TTag, DialogRenderPropArg, DialogPropsWeControl, PropsForFeatures<typeof DialogRenderFeatures> & {
+    open?: boolean;
+    onClose(value: boolean): void;
+    initialFocus?: MutableRefObject<HTMLElement | null>;
+    role?: 'dialog' | 'alertdialog';
+    __demoMode?: boolean;
+}>;
+declare function DialogFn<TTag extends ElementType = typeof DEFAULT_DIALOG_TAG>(props: DialogProps<TTag>, ref: Ref<HTMLDivElement>): JSX.Element;
+declare let DEFAULT_OVERLAY_TAG: "div";
+interface OverlayRenderPropArg {
+    open: boolean;
+}
+type OverlayPropsWeControl = 'aria-hidden';
+export type DialogOverlayProps<TTag extends ElementType> = Props<TTag, OverlayRenderPropArg, OverlayPropsWeControl>;
+declare function OverlayFn<TTag extends ElementType = typeof DEFAULT_OVERLAY_TAG>(props: DialogOverlayProps<TTag>, ref: Ref<HTMLDivElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_BACKDROP_TAG: "div";
+interface BackdropRenderPropArg {
+    open: boolean;
+}
+type BackdropPropsWeControl = 'aria-hidden';
+export type DialogBackdropProps<TTag extends ElementType> = Props<TTag, BackdropRenderPropArg, BackdropPropsWeControl>;
+declare function BackdropFn<TTag extends ElementType = typeof DEFAULT_BACKDROP_TAG>(props: DialogBackdropProps<TTag>, ref: Ref<HTMLDivElement>): JSX.Element;
+declare let DEFAULT_PANEL_TAG: "div";
+interface PanelRenderPropArg {
+    open: boolean;
+}
+export type DialogPanelProps<TTag extends ElementType> = Props<TTag, PanelRenderPropArg>;
+declare function PanelFn<TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: DialogPanelProps<TTag>, ref: Ref<HTMLDivElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_TITLE_TAG: "h2";
+interface TitleRenderPropArg {
+    open: boolean;
+}
+export type DialogTitleProps<TTag extends ElementType> = Props<TTag, TitleRenderPropArg>;
+declare function TitleFn<TTag extends ElementType = typeof DEFAULT_TITLE_TAG>(props: DialogTitleProps<TTag>, ref: Ref<HTMLHeadingElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+export interface _internal_ComponentDialog extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_DIALOG_TAG>(props: DialogProps<TTag> & RefProp<typeof DialogFn>): JSX.Element;
+}
+export interface _internal_ComponentDialogBackdrop extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BACKDROP_TAG>(props: DialogBackdropProps<TTag> & RefProp<typeof BackdropFn>): JSX.Element;
+}
+export interface _internal_ComponentDialogPanel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: DialogPanelProps<TTag> & RefProp<typeof PanelFn>): JSX.Element;
+}
+export interface _internal_ComponentDialogOverlay extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OVERLAY_TAG>(props: DialogOverlayProps<TTag> & RefProp<typeof OverlayFn>): JSX.Element;
+}
+export interface _internal_ComponentDialogTitle extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TITLE_TAG>(props: DialogTitleProps<TTag> & RefProp<typeof TitleFn>): JSX.Element;
+}
+export interface _internal_ComponentDialogDescription extends _internal_ComponentDescription {
+}
+export declare let Dialog: _internal_ComponentDialog & {
+    Backdrop: _internal_ComponentDialogBackdrop;
+    Panel: _internal_ComponentDialogPanel;
+    Overlay: _internal_ComponentDialogOverlay;
+    Title: _internal_ComponentDialogTitle;
+    Description: _internal_ComponentDialogDescription;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/disclosure/disclosure.d.ts

@@ -0,0 +1,45 @@
+import React, { type ElementType, type MutableRefObject, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type PropsForFeatures, type RefProp } from '../../utils/render.js';
+declare let DEFAULT_DISCLOSURE_TAG: React.ExoticComponent<{
+    children?: React.ReactNode;
+}>;
+interface DisclosureRenderPropArg {
+    open: boolean;
+    close(focusableElement?: HTMLElement | MutableRefObject<HTMLElement | null>): void;
+}
+export type DisclosureProps<TTag extends ElementType> = Props<TTag, DisclosureRenderPropArg> & {
+    defaultOpen?: boolean;
+};
+declare function DisclosureFn<TTag extends ElementType = typeof DEFAULT_DISCLOSURE_TAG>(props: DisclosureProps<TTag>, ref: Ref<HTMLElement>): JSX.Element;
+declare let DEFAULT_BUTTON_TAG: "button";
+interface ButtonRenderPropArg {
+    open: boolean;
+}
+type ButtonPropsWeControl = 'aria-controls' | 'aria-expanded';
+export type DisclosureButtonProps<TTag extends ElementType> = Props<TTag, ButtonRenderPropArg, ButtonPropsWeControl, {
+    disabled?: boolean;
+}>;
+declare function ButtonFn<TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: DisclosureButtonProps<TTag>, ref: Ref<HTMLButtonElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_PANEL_TAG: "div";
+interface PanelRenderPropArg {
+    open: boolean;
+    close: (focusableElement?: HTMLElement | MutableRefObject<HTMLElement | null>) => void;
+}
+declare let PanelRenderFeatures: number;
+export type DisclosurePanelProps<TTag extends ElementType> = Props<TTag, PanelRenderPropArg> & PropsForFeatures<typeof PanelRenderFeatures>;
+declare function PanelFn<TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: DisclosurePanelProps<TTag>, ref: Ref<HTMLDivElement>): JSX.Element;
+export interface _internal_ComponentDisclosure extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_DISCLOSURE_TAG>(props: DisclosureProps<TTag> & RefProp<typeof DisclosureFn>): JSX.Element;
+}
+export interface _internal_ComponentDisclosureButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: DisclosureButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+export interface _internal_ComponentDisclosurePanel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: DisclosurePanelProps<TTag> & RefProp<typeof PanelFn>): JSX.Element;
+}
+export declare let Disclosure: _internal_ComponentDisclosure & {
+    Button: _internal_ComponentDisclosureButton;
+    Panel: _internal_ComponentDisclosurePanel;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/disclosure/disclosure.js

@@ -0,0 +1 @@
+import E,{createContext as I,Fragment as H,useContext as x,useEffect as h,useMemo as S,useReducer as G,useRef as R}from"react";import{useEvent as A}from'../../hooks/use-event.js';import{useId as U}from'../../hooks/use-id.js';import{useResolveButtonType as j}from'../../hooks/use-resolve-button-type.js';import{optionalRef as W,useSyncRefs as L}from'../../hooks/use-sync-refs.js';import{OpenClosedProvider as $,State as b,useOpenClosed as J}from'../../internal/open-closed.js';import{isDisabledReactIssue7711 as X}from'../../utils/bugs.js';import{match as O}from'../../utils/match.js';import{getOwnerDocument as q}from'../../utils/owner.js';import{Features as w,forwardRefWithAs as B,render as k,useMergeRefsFn as N}from'../../utils/render.js';import{startTransition as z}from'../../utils/start-transition.js';import{Keys as g}from'../keyboard.js';var Q=(o=>(o[o.Open=0]="Open",o[o.Closed=1]="Closed",o))(Q||{}),V=(t=>(t[t.ToggleDisclosure=0]="ToggleDisclosure",t[t.CloseDisclosure=1]="CloseDisclosure",t[t.SetButtonId=2]="SetButtonId",t[t.SetPanelId=3]="SetPanelId",t[t.LinkPanel=4]="LinkPanel",t[t.UnlinkPanel=5]="UnlinkPanel",t))(V||{});let Y={[0]:e=>({...e,disclosureState:O(e.disclosureState,{[0]:1,[1]:0})}),[1]:e=>e.disclosureState===1?e:{...e,disclosureState:1},[4](e){return e.linkedPanel===!0?e:{...e,linkedPanel:!0}},[5](e){return e.linkedPanel===!1?e:{...e,linkedPanel:!1}},[2](e,n){return e.buttonId===n.buttonId?e:{...e,buttonId:n.buttonId}},[3](e,n){return e.panelId===n.panelId?e:{...e,panelId:n.panelId}}},M=I(null);M.displayName="DisclosureContext";function _(e){let n=x(M);if(n===null){let o=new Error(`<${e} /> is missing a parent <Disclosure /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(o,_),o}return n}let v=I(null);v.displayName="DisclosureAPIContext";function K(e){let n=x(v);if(n===null){let o=new Error(`<${e} /> is missing a parent <Disclosure /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(o,K),o}return n}let F=I(null);F.displayName="DisclosurePanelContext";function Z(){return x(F)}function ee(e,n){return O(n.type,Y,e,n)}let te=H;function ne(e,n){let{defaultOpen:o=!1,...i}=e,f=R(null),l=L(n,W(u=>{f.current=u},e.as===void 0||e.as===H)),t=R(null),d=R(null),s=G(ee,{disclosureState:o?0:1,linkedPanel:!1,buttonRef:d,panelRef:t,buttonId:null,panelId:null}),[{disclosureState:c,buttonId:a},D]=s,p=A(u=>{D({type:1});let y=q(f);if(!y||!a)return;let r=(()=>u?u instanceof HTMLElement?u:u.current instanceof HTMLElement?u.current:y.getElementById(a):y.getElementById(a))();r==null||r.focus()}),P=S(()=>({close:p}),[p]),T=S(()=>({open:c===0,close:p}),[c,p]),C={ref:l};return E.createElement(M.Provider,{value:s},E.createElement(v.Provider,{value:P},E.createElement($,{value:O(c,{[0]:b.Open,[1]:b.Closed})},k({ourProps:C,theirProps:i,slot:T,defaultTag:te,name:"Disclosure"}))))}let le="button";function oe(e,n){let o=U(),{id:i=`headlessui-disclosure-button-${o}`,...f}=e,[l,t]=_("Disclosure.Button"),d=Z(),s=d===null?!1:d===l.panelId,c=R(null),a=L(c,n,s?null:l.buttonRef),D=N();h(()=>{if(!s)return t({type:2,buttonId:i}),()=>{t({type:2,buttonId:null})}},[i,t,s]);let p=A(r=>{var m;if(s){if(l.disclosureState===1)return;switch(r.key){case g.Space:case g.Enter:r.preventDefault(),r.stopPropagation(),t({type:0}),(m=l.buttonRef.current)==null||m.focus();break}}else switch(r.key){case g.Space:case g.Enter:r.preventDefault(),r.stopPropagation(),t({type:0});break}}),P=A(r=>{switch(r.key){case g.Space:r.preventDefault();break}}),T=A(r=>{var m;X(r.currentTarget)||e.disabled||(s?(t({type:0}),(m=l.buttonRef.current)==null||m.focus()):t({type:0}))}),C=S(()=>({open:l.disclosureState===0}),[l]),u=j(e,c),y=s?{ref:a,type:u,onKeyDown:p,onClick:T}:{ref:a,id:i,type:u,"aria-expanded":l.disclosureState===0,"aria-controls":l.linkedPanel?l.panelId:void 0,onKeyDown:p,onKeyUp:P,onClick:T};return k({mergeRefs:D,ourProps:y,theirProps:f,slot:C,defaultTag:le,name:"Disclosure.Button"})}let re="div",se=w.RenderStrategy|w.Static;function ue(e,n){let o=U(),{id:i=`headlessui-disclosure-panel-${o}`,...f}=e,[l,t]=_("Disclosure.Panel"),{close:d}=K("Disclosure.Panel"),s=N(),c=L(n,l.panelRef,T=>{z(()=>t({type:T?4:5}))});h(()=>(t({type:3,panelId:i}),()=>{t({type:3,panelId:null})}),[i,t]);let a=J(),D=(()=>a!==null?(a&b.Open)===b.Open:l.disclosureState===0)(),p=S(()=>({open:l.disclosureState===0,close:d}),[l,d]),P={ref:c,id:i};return E.createElement(F.Provider,{value:l.panelId},k({mergeRefs:s,ourProps:P,theirProps:f,slot:p,defaultTag:re,features:se,visible:D,name:"Disclosure.Panel"}))}let ie=B(ne),ae=B(oe),pe=B(ue),Ae=Object.assign(ie,{Button:ae,Panel:pe});export{Ae as Disclosure};

frontend/node_modules/@headlessui/react/dist/components/focus-trap/focus-trap.d.ts

@@ -0,0 +1,32 @@
+import { type ElementType, type MutableRefObject, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type RefProp } from '../../utils/render.js';
+type Containers = (() => Iterable<HTMLElement>) | MutableRefObject<Set<MutableRefObject<HTMLElement | null>>>;
+declare let DEFAULT_FOCUS_TRAP_TAG: "div";
+declare enum Features {
+    /** No features enabled for the focus trap. */
+    None = 1,
+    /** Ensure that we move focus initially into the container. */
+    InitialFocus = 2,
+    /** Ensure that pressing `Tab` and `Shift+Tab` is trapped within the container. */
+    TabLock = 4,
+    /** Ensure that programmatically moving focus outside of the container is disallowed. */
+    FocusLock = 8,
+    /** Ensure that we restore the focus when unmounting the focus trap. */
+    RestoreFocus = 16,
+    /** Enable all features. */
+    All = 30
+}
+export type FocusTrapProps<TTag extends ElementType> = Props<TTag> & {
+    initialFocus?: MutableRefObject<HTMLElement | null>;
+    features?: Features;
+    containers?: Containers;
+};
+declare function FocusTrapFn<TTag extends ElementType = typeof DEFAULT_FOCUS_TRAP_TAG>(props: FocusTrapProps<TTag>, ref: Ref<HTMLDivElement>): JSX.Element;
+export interface _internal_ComponentFocusTrap extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_FOCUS_TRAP_TAG>(props: FocusTrapProps<TTag> & RefProp<typeof FocusTrapFn>): JSX.Element;
+}
+export declare let FocusTrap: _internal_ComponentFocusTrap & {
+    features: typeof Features;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/focus-trap/focus-trap.js

@@ -0,0 +1 @@
+import E,{useRef as d}from"react";import{useDisposables as U}from'../../hooks/use-disposables.js';import{useEvent as v}from'../../hooks/use-event.js';import{useEventListener as x}from'../../hooks/use-event-listener.js';import{useIsMounted as g}from'../../hooks/use-is-mounted.js';import{useOnUnmount as N}from'../../hooks/use-on-unmount.js';import{useOwnerDocument as I}from'../../hooks/use-owner.js';import{useServerHandoffComplete as G}from'../../hooks/use-server-handoff-complete.js';import{useSyncRefs as K}from'../../hooks/use-sync-refs.js';import{Direction as L,useTabDirection as W}from'../../hooks/use-tab-direction.js';import{useWatch as b}from'../../hooks/use-watch.js';import{Features as A,Hidden as O}from'../../internal/hidden.js';import{history as F}from'../../utils/active-element-history.js';import{Focus as p,focusElement as f,focusIn as M,FocusResult as V}from'../../utils/focus-management.js';import{match as k}from'../../utils/match.js';import{microTask as C}from'../../utils/micro-task.js';import{forwardRefWithAs as q,render as J}from'../../utils/render.js';function P(t){if(!t)return new Set;if(typeof t=="function")return new Set(t());let n=new Set;for(let e of t.current)e.current instanceof HTMLElement&&n.add(e.current);return n}let X="div";var _=(r=>(r[r.None=1]="None",r[r.InitialFocus=2]="InitialFocus",r[r.TabLock=4]="TabLock",r[r.FocusLock=8]="FocusLock",r[r.RestoreFocus=16]="RestoreFocus",r[r.All=30]="All",r))(_||{});function z(t,n){let e=d(null),o=K(e,n),{initialFocus:l,containers:c,features:r=30,...s}=t;G()||(r=1);let i=I(e);Y({ownerDocument:i},Boolean(r&16));let u=Z({ownerDocument:i,container:e,initialFocus:l},Boolean(r&2));$({ownerDocument:i,container:e,containers:c,previousActiveElement:u},Boolean(r&8));let y=W(),R=v(a=>{let m=e.current;if(!m)return;(B=>B())(()=>{k(y.current,{[L.Forwards]:()=>{M(m,p.First,{skipElements:[a.relatedTarget]})},[L.Backwards]:()=>{M(m,p.Last,{skipElements:[a.relatedTarget]})}})})}),h=U(),H=d(!1),j={ref:o,onKeyDown(a){a.key=="Tab"&&(H.current=!0,h.requestAnimationFrame(()=>{H.current=!1}))},onBlur(a){let m=P(c);e.current instanceof HTMLElement&&m.add(e.current);let T=a.relatedTarget;T instanceof HTMLElement&&T.dataset.headlessuiFocusGuard!=="true"&&(S(m,T)||(H.current?M(e.current,k(y.current,{[L.Forwards]:()=>p.Next,[L.Backwards]:()=>p.Previous})|p.WrapAround,{relativeTo:a.target}):a.target instanceof HTMLElement&&f(a.target)))}};return E.createElement(E.Fragment,null,Boolean(r&4)&&E.createElement(O,{as:"button",type:"button","data-headlessui-focus-guard":!0,onFocus:R,features:A.Focusable}),J({ourProps:j,theirProps:s,defaultTag:X,name:"FocusTrap"}),Boolean(r&4)&&E.createElement(O,{as:"button",type:"button","data-headlessui-focus-guard":!0,onFocus:R,features:A.Focusable}))}let D=q(z),de=Object.assign(D,{features:_});function Q(t=!0){let n=d(F.slice());return b(([e],[o])=>{o===!0&&e===!1&&C(()=>{n.current.splice(0)}),o===!1&&e===!0&&(n.current=F.slice())},[t,F,n]),v(()=>{var e;return(e=n.current.find(o=>o!=null&&o.isConnected))!=null?e:null})}function Y({ownerDocument:t},n){let e=Q(n);b(()=>{n||(t==null?void 0:t.activeElement)===(t==null?void 0:t.body)&&f(e())},[n]),N(()=>{n&&f(e())})}function Z({ownerDocument:t,container:n,initialFocus:e},o){let l=d(null),c=g();return b(()=>{if(!o)return;let r=n.current;r&&C(()=>{if(!c.current)return;let s=t==null?void 0:t.activeElement;if(e!=null&&e.current){if((e==null?void 0:e.current)===s){l.current=s;return}}else if(r.contains(s)){l.current=s;return}e!=null&&e.current?f(e.current):M(r,p.First)===V.Error&&console.warn("There are no focusable elements inside the <FocusTrap />"),l.current=t==null?void 0:t.activeElement})},[o]),l}function $({ownerDocument:t,container:n,containers:e,previousActiveElement:o},l){let c=g();x(t==null?void 0:t.defaultView,"focus",r=>{if(!l||!c.current)return;let s=P(e);n.current instanceof HTMLElement&&s.add(n.current);let i=o.current;if(!i)return;let u=r.target;u&&u instanceof HTMLElement?S(s,u)?(o.current=u,f(u)):(r.preventDefault(),r.stopPropagation(),f(i)):f(o.current)},!0)}function S(t,n){for(let e of t)if(e.contains(n))return!0;return!1}export{de as FocusTrap};

frontend/node_modules/@headlessui/react/dist/components/keyboard.d.ts

@@ -0,0 +1,16 @@
+export declare enum Keys {
+    Space = " ",
+    Enter = "Enter",
+    Escape = "Escape",
+    Backspace = "Backspace",
+    Delete = "Delete",
+    ArrowLeft = "ArrowLeft",
+    ArrowUp = "ArrowUp",
+    ArrowRight = "ArrowRight",
+    ArrowDown = "ArrowDown",
+    Home = "Home",
+    End = "End",
+    PageUp = "PageUp",
+    PageDown = "PageDown",
+    Tab = "Tab"
+}

frontend/node_modules/@headlessui/react/dist/components/keyboard.js

@@ -0,0 +1 @@
+var o=(r=>(r.Space=" ",r.Enter="Enter",r.Escape="Escape",r.Backspace="Backspace",r.Delete="Delete",r.ArrowLeft="ArrowLeft",r.ArrowUp="ArrowUp",r.ArrowRight="ArrowRight",r.ArrowDown="ArrowDown",r.Home="Home",r.End="End",r.PageUp="PageUp",r.PageDown="PageDown",r.Tab="Tab",r))(o||{});export{o as Keys};

frontend/node_modules/@headlessui/react/dist/components/label/label.d.ts

@@ -0,0 +1,22 @@
+import React, { type ElementType, type ReactNode, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type RefProp } from '../../utils/render.js';
+interface SharedData {
+    slot?: {};
+    name?: string;
+    props?: {};
+}
+interface LabelProviderProps extends SharedData {
+    children: ReactNode;
+}
+export declare function useLabels(): [string | undefined, (props: LabelProviderProps) => JSX.Element];
+declare let DEFAULT_LABEL_TAG: "label";
+export type LabelProps<TTag extends ElementType = typeof DEFAULT_LABEL_TAG> = Props<TTag> & {
+    passive?: boolean;
+};
+declare function LabelFn<TTag extends ElementType = typeof DEFAULT_LABEL_TAG>(props: LabelProps<TTag>, ref: Ref<HTMLLabelElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+export interface _internal_ComponentLabel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_LABEL_TAG>(props: LabelProps<TTag> & RefProp<typeof LabelFn>): JSX.Element;
+}
+export declare let Label: _internal_ComponentLabel;
+export {};

frontend/node_modules/@headlessui/react/dist/components/label/label.js

@@ -0,0 +1 @@
+import c,{createContext as m,useContext as L,useMemo as f,useState as b}from"react";import{useEvent as T}from'../../hooks/use-event.js';import{useId as y}from'../../hooks/use-id.js';import{useIsoMorphicEffect as E}from'../../hooks/use-iso-morphic-effect.js';import{useSyncRefs as g}from'../../hooks/use-sync-refs.js';import{forwardRefWithAs as x,render as P}from'../../utils/render.js';let d=m(null);function u(){let a=L(d);if(a===null){let t=new Error("You used a <Label /> component, but it is not inside a relevant parent.");throw Error.captureStackTrace&&Error.captureStackTrace(t,u),t}return a}function F(){let[a,t]=b([]);return[a.length>0?a.join(" "):void 0,f(()=>function(e){let s=T(r=>(t(l=>[...l,r]),()=>t(l=>{let n=l.slice(),p=n.indexOf(r);return p!==-1&&n.splice(p,1),n}))),o=f(()=>({register:s,slot:e.slot,name:e.name,props:e.props}),[s,e.slot,e.name,e.props]);return c.createElement(d.Provider,{value:o},e.children)},[t])]}let A="label";function h(a,t){let i=y(),{id:e=`headlessui-label-${i}`,passive:s=!1,...o}=a,r=u(),l=g(t);E(()=>r.register(e),[e,r.register]);let n={ref:l,...r.props,id:e};return s&&("onClick"in n&&(delete n.htmlFor,delete n.onClick),"onClick"in o&&delete o.onClick),P({ourProps:n,theirProps:o,slot:r.slot||{},defaultTag:A,name:r.name||"Label"})}let v=x(h),B=Object.assign(v,{});export{B as Label,F as useLabels};

frontend/node_modules/@headlessui/react/dist/components/listbox/listbox.d.ts

@@ -0,0 +1,82 @@
+import React, { type ElementType, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type PropsForFeatures, type RefProp } from '../../utils/render.js';
+declare let DEFAULT_LISTBOX_TAG: React.ExoticComponent<{
+    children?: React.ReactNode;
+}>;
+interface ListboxRenderPropArg<T> {
+    open: boolean;
+    disabled: boolean;
+    value: T;
+}
+export type ListboxProps<TTag extends ElementType, TType, TActualType> = Props<TTag, ListboxRenderPropArg<TType>, 'value' | 'defaultValue' | 'onChange' | 'by' | 'disabled' | 'horizontal' | 'name' | 'multiple'> & {
+    value?: TType;
+    defaultValue?: TType;
+    onChange?(value: TType): void;
+    by?: (keyof TActualType & string) | ((a: TActualType, z: TActualType) => boolean);
+    disabled?: boolean;
+    horizontal?: boolean;
+    form?: string;
+    name?: string;
+    multiple?: boolean;
+};
+declare function ListboxFn<TTag extends ElementType = typeof DEFAULT_LISTBOX_TAG, TType = string, TActualType = TType extends (infer U)[] ? U : TType>(props: ListboxProps<TTag, TType, TActualType>, ref: Ref<HTMLElement>): JSX.Element;
+declare let DEFAULT_BUTTON_TAG: "button";
+interface ButtonRenderPropArg {
+    open: boolean;
+    disabled: boolean;
+    value: any;
+}
+type ButtonPropsWeControl = 'aria-controls' | 'aria-expanded' | 'aria-haspopup' | 'aria-labelledby' | 'disabled';
+export type ListboxButtonProps<TTag extends ElementType> = Props<TTag, ButtonRenderPropArg, ButtonPropsWeControl>;
+declare function ButtonFn<TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: ListboxButtonProps<TTag>, ref: Ref<HTMLButtonElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_LABEL_TAG: "label";
+interface LabelRenderPropArg {
+    open: boolean;
+    disabled: boolean;
+}
+export type ListboxLabelProps<TTag extends ElementType> = Props<TTag, LabelRenderPropArg>;
+declare function LabelFn<TTag extends ElementType = typeof DEFAULT_LABEL_TAG>(props: ListboxLabelProps<TTag>, ref: Ref<HTMLElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_OPTIONS_TAG: "ul";
+interface OptionsRenderPropArg {
+    open: boolean;
+}
+type OptionsPropsWeControl = 'aria-activedescendant' | 'aria-labelledby' | 'aria-multiselectable' | 'aria-orientation' | 'role' | 'tabIndex';
+declare let OptionsRenderFeatures: number;
+export type ListboxOptionsProps<TTag extends ElementType> = Props<TTag, OptionsRenderPropArg, OptionsPropsWeControl> & PropsForFeatures<typeof OptionsRenderFeatures>;
+declare function OptionsFn<TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG>(props: ListboxOptionsProps<TTag>, ref: Ref<HTMLElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_OPTION_TAG: "li";
+interface OptionRenderPropArg {
+    active: boolean;
+    selected: boolean;
+    disabled: boolean;
+}
+type OptionPropsWeControl = 'aria-disabled' | 'aria-selected' | 'role' | 'tabIndex';
+export type ListboxOptionProps<TTag extends ElementType, TType> = Props<TTag, OptionRenderPropArg, OptionPropsWeControl, {
+    disabled?: boolean;
+    value: TType;
+}>;
+declare function OptionFn<TTag extends ElementType = typeof DEFAULT_OPTION_TAG, TType = Parameters<typeof ListboxRoot>[0]['value']>(props: ListboxOptionProps<TTag, TType>, ref: Ref<HTMLElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+export interface _internal_ComponentListbox extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_LISTBOX_TAG, TType = string, TActualType = TType extends (infer U)[] ? U : TType>(props: ListboxProps<TTag, TType, TActualType> & RefProp<typeof ListboxFn>): JSX.Element;
+}
+export interface _internal_ComponentListboxButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: ListboxButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+export interface _internal_ComponentListboxLabel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_LABEL_TAG>(props: ListboxLabelProps<TTag> & RefProp<typeof LabelFn>): JSX.Element;
+}
+export interface _internal_ComponentListboxOptions extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG>(props: ListboxOptionsProps<TTag> & RefProp<typeof OptionsFn>): JSX.Element;
+}
+export interface _internal_ComponentListboxOption extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OPTION_TAG, TType = Parameters<typeof ListboxRoot>[0]['value']>(props: ListboxOptionProps<TTag, TType> & RefProp<typeof OptionFn>): JSX.Element;
+}
+declare let ListboxRoot: _internal_ComponentListbox;
+export declare let Listbox: _internal_ComponentListbox & {
+    Button: _internal_ComponentListboxButton;
+    Label: _internal_ComponentListboxLabel;
+    Options: _internal_ComponentListboxOptions;
+    Option: _internal_ComponentListboxOption;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/menu/menu.d.ts

@@ -0,0 +1,62 @@
+import React, { type ElementType, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type PropsForFeatures, type RefProp } from '../../utils/render.js';
+declare let DEFAULT_MENU_TAG: React.ExoticComponent<{
+    children?: React.ReactNode;
+}>;
+interface MenuRenderPropArg {
+    open: boolean;
+    close: () => void;
+}
+export type MenuProps<TTag extends ElementType> = Props<TTag, MenuRenderPropArg, never, {
+    __demoMode?: boolean;
+}>;
+declare function MenuFn<TTag extends ElementType = typeof DEFAULT_MENU_TAG>(props: MenuProps<TTag>, ref: Ref<HTMLElement>): JSX.Element;
+declare let DEFAULT_BUTTON_TAG: "button";
+interface ButtonRenderPropArg {
+    open: boolean;
+}
+type ButtonPropsWeControl = 'aria-controls' | 'aria-expanded' | 'aria-haspopup';
+export type MenuButtonProps<TTag extends ElementType> = Props<TTag, ButtonRenderPropArg, ButtonPropsWeControl, {
+    disabled?: boolean;
+}>;
+declare function ButtonFn<TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: MenuButtonProps<TTag>, ref: Ref<HTMLButtonElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_ITEMS_TAG: "div";
+interface ItemsRenderPropArg {
+    open: boolean;
+}
+type ItemsPropsWeControl = 'aria-activedescendant' | 'aria-labelledby' | 'role' | 'tabIndex';
+declare let ItemsRenderFeatures: number;
+export type MenuItemsProps<TTag extends ElementType> = Props<TTag, ItemsRenderPropArg, ItemsPropsWeControl> & PropsForFeatures<typeof ItemsRenderFeatures>;
+declare function ItemsFn<TTag extends ElementType = typeof DEFAULT_ITEMS_TAG>(props: MenuItemsProps<TTag>, ref: Ref<HTMLDivElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_ITEM_TAG: React.ExoticComponent<{
+    children?: React.ReactNode;
+}>;
+interface ItemRenderPropArg {
+    active: boolean;
+    disabled: boolean;
+    close: () => void;
+}
+type ItemPropsWeControl = 'aria-disabled' | 'role' | 'tabIndex';
+export type MenuItemProps<TTag extends ElementType> = Props<TTag, ItemRenderPropArg, ItemPropsWeControl> & {
+    disabled?: boolean;
+};
+declare function ItemFn<TTag extends ElementType = typeof DEFAULT_ITEM_TAG>(props: MenuItemProps<TTag>, ref: Ref<HTMLElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+export interface _internal_ComponentMenu extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_MENU_TAG>(props: MenuProps<TTag> & RefProp<typeof MenuFn>): JSX.Element;
+}
+export interface _internal_ComponentMenuButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: MenuButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+export interface _internal_ComponentMenuItems extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_ITEMS_TAG>(props: MenuItemsProps<TTag> & RefProp<typeof ItemsFn>): JSX.Element;
+}
+export interface _internal_ComponentMenuItem extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_ITEM_TAG>(props: MenuItemProps<TTag> & RefProp<typeof ItemFn>): JSX.Element;
+}
+export declare let Menu: _internal_ComponentMenu & {
+    Button: _internal_ComponentMenuButton;
+    Items: _internal_ComponentMenuItems;
+    Item: _internal_ComponentMenuItem;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/popover/popover.d.ts

@@ -0,0 +1,68 @@
+import React, { type ElementType, type MouseEventHandler, type MutableRefObject, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type PropsForFeatures, type RefProp } from '../../utils/render.js';
+type MouseEvent<T> = Parameters<MouseEventHandler<T>>[0];
+declare let DEFAULT_POPOVER_TAG: "div";
+interface PopoverRenderPropArg {
+    open: boolean;
+    close(focusableElement?: HTMLElement | MutableRefObject<HTMLElement | null> | MouseEvent<HTMLElement>): void;
+}
+export type PopoverProps<TTag extends ElementType> = Props<TTag, PopoverRenderPropArg, never, {
+    __demoMode?: boolean;
+}>;
+declare function PopoverFn<TTag extends ElementType = typeof DEFAULT_POPOVER_TAG>(props: PopoverProps<TTag>, ref: Ref<HTMLElement>): JSX.Element;
+declare let DEFAULT_BUTTON_TAG: "button";
+interface ButtonRenderPropArg {
+    open: boolean;
+}
+type ButtonPropsWeControl = 'aria-controls' | 'aria-expanded';
+export type PopoverButtonProps<TTag extends ElementType> = Props<TTag, ButtonRenderPropArg, ButtonPropsWeControl, {
+    disabled?: boolean;
+}>;
+declare function ButtonFn<TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: PopoverButtonProps<TTag>, ref: Ref<HTMLButtonElement>): JSX.Element;
+declare let DEFAULT_OVERLAY_TAG: "div";
+interface OverlayRenderPropArg {
+    open: boolean;
+}
+type OverlayPropsWeControl = 'aria-hidden';
+declare let OverlayRenderFeatures: number;
+export type PopoverOverlayProps<TTag extends ElementType> = Props<TTag, OverlayRenderPropArg, OverlayPropsWeControl> & PropsForFeatures<typeof OverlayRenderFeatures>;
+declare function OverlayFn<TTag extends ElementType = typeof DEFAULT_OVERLAY_TAG>(props: PopoverOverlayProps<TTag>, ref: Ref<HTMLDivElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_PANEL_TAG: "div";
+interface PanelRenderPropArg {
+    open: boolean;
+    close: (focusableElement?: HTMLElement | MutableRefObject<HTMLElement | null>) => void;
+}
+declare let PanelRenderFeatures: number;
+type PanelPropsWeControl = 'tabIndex';
+export type PopoverPanelProps<TTag extends ElementType> = Props<TTag, PanelRenderPropArg, PanelPropsWeControl, PropsForFeatures<typeof PanelRenderFeatures> & {
+    focus?: boolean;
+}>;
+declare function PanelFn<TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: PopoverPanelProps<TTag>, ref: Ref<HTMLDivElement>): JSX.Element;
+declare let DEFAULT_GROUP_TAG: "div";
+interface GroupRenderPropArg {
+}
+export type PopoverGroupProps<TTag extends ElementType> = Props<TTag, GroupRenderPropArg>;
+declare function GroupFn<TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: PopoverGroupProps<TTag>, ref: Ref<HTMLElement>): JSX.Element;
+export interface _internal_ComponentPopover extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_POPOVER_TAG>(props: PopoverProps<TTag> & RefProp<typeof PopoverFn>): JSX.Element;
+}
+export interface _internal_ComponentPopoverButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: PopoverButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+export interface _internal_ComponentPopoverOverlay extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OVERLAY_TAG>(props: PopoverOverlayProps<TTag> & RefProp<typeof OverlayFn>): JSX.Element;
+}
+export interface _internal_ComponentPopoverPanel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: PopoverPanelProps<TTag> & RefProp<typeof PanelFn>): JSX.Element;
+}
+export interface _internal_ComponentPopoverGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(props: PopoverGroupProps<TTag> & RefProp<typeof GroupFn>): JSX.Element;
+}
+export declare let Popover: _internal_ComponentPopover & {
+    Button: _internal_ComponentPopoverButton;
+    Overlay: _internal_ComponentPopoverOverlay;
+    Panel: _internal_ComponentPopoverPanel;
+    Group: _internal_ComponentPopoverGroup;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/portal/portal.d.ts

@@ -0,0 +1,32 @@
+import React, { type ElementType, type MutableRefObject, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { HasDisplayName, RefProp } from '../../utils/render.js';
+declare let DEFAULT_PORTAL_TAG: React.ExoticComponent<{
+    children?: React.ReactNode;
+}>;
+interface PortalRenderPropArg {
+}
+export type PortalProps<TTag extends ElementType> = Props<TTag, PortalRenderPropArg>;
+declare function PortalFn<TTag extends ElementType = typeof DEFAULT_PORTAL_TAG>(props: PortalProps<TTag>, ref: Ref<HTMLElement>): React.ReactPortal | null;
+declare let DEFAULT_GROUP_TAG: React.ExoticComponent<{
+    children?: React.ReactNode;
+}>;
+interface GroupRenderPropArg {
+}
+export type PortalGroupProps<TTag extends ElementType> = Props<TTag, GroupRenderPropArg> & {
+    target: MutableRefObject<HTMLElement | null>;
+};
+declare function GroupFn<TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(props: PortalGroupProps<TTag>, ref: Ref<HTMLElement>): JSX.Element;
+export declare function useNestedPortals(): readonly [React.MutableRefObject<HTMLElement[]>, ({ children }: {
+    children: React.ReactNode;
+}) => JSX.Element];
+export interface _internal_ComponentPortal extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PORTAL_TAG>(props: PortalProps<TTag> & RefProp<typeof PortalFn>): JSX.Element;
+}
+export interface _internal_ComponentPortalGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(props: PortalGroupProps<TTag> & RefProp<typeof GroupFn>): JSX.Element;
+}
+export declare let Portal: _internal_ComponentPortal & {
+    Group: _internal_ComponentPortalGroup;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/portal/portal.js

@@ -0,0 +1 @@
+import T,{createContext as P,Fragment as m,useContext as s,useEffect as d,useMemo as g,useRef as R,useState as E}from"react";import{createPortal as C}from"react-dom";import{useEvent as c}from'../../hooks/use-event.js';import{useIsoMorphicEffect as y}from'../../hooks/use-iso-morphic-effect.js';import{useOnUnmount as H}from'../../hooks/use-on-unmount.js';import{useOwnerDocument as x}from'../../hooks/use-owner.js';import{useServerHandoffComplete as b}from'../../hooks/use-server-handoff-complete.js';import{optionalRef as h,useSyncRefs as L}from'../../hooks/use-sync-refs.js';import{usePortalRoot as O}from'../../internal/portal-force-root.js';import{env as A}from'../../utils/env.js';import{forwardRefWithAs as G,render as M}from'../../utils/render.js';function F(p){let n=O(),l=s(_),e=x(p),[a,o]=E(()=>{if(!n&&l!==null||A.isServer)return null;let t=e==null?void 0:e.getElementById("headlessui-portal-root");if(t)return t;if(e===null)return null;let r=e.createElement("div");return r.setAttribute("id","headlessui-portal-root"),e.body.appendChild(r)});return d(()=>{a!==null&&(e!=null&&e.body.contains(a)||e==null||e.body.appendChild(a))},[a,e]),d(()=>{n||l!==null&&o(l.current)},[l,o,n]),a}let U=m;function N(p,n){let l=p,e=R(null),a=L(h(u=>{e.current=u}),n),o=x(e),t=F(e),[r]=E(()=>{var u;return A.isServer?null:(u=o==null?void 0:o.createElement("div"))!=null?u:null}),i=s(f),v=b();return y(()=>{!t||!r||t.contains(r)||(r.setAttribute("data-headlessui-portal",""),t.appendChild(r))},[t,r]),y(()=>{if(r&&i)return i.register(r)},[i,r]),H(()=>{var u;!t||!r||(r instanceof Node&&t.contains(r)&&t.removeChild(r),t.childNodes.length<=0&&((u=t.parentElement)==null||u.removeChild(t)))}),v?!t||!r?null:C(M({ourProps:{ref:a},theirProps:l,defaultTag:U,name:"Portal"}),r):null}let S=m,_=P(null);function j(p,n){let{target:l,...e}=p,o={ref:L(n)};return T.createElement(_.Provider,{value:l},M({ourProps:o,theirProps:e,defaultTag:S,name:"Popover.Group"}))}let f=P(null);function ee(){let p=s(f),n=R([]),l=c(o=>(n.current.push(o),p&&p.register(o),()=>e(o))),e=c(o=>{let t=n.current.indexOf(o);t!==-1&&n.current.splice(t,1),p&&p.unregister(o)}),a=g(()=>({register:l,unregister:e,portals:n}),[l,e,n]);return[n,g(()=>function({children:t}){return T.createElement(f.Provider,{value:a},t)},[a])]}let D=G(N),I=G(j),te=Object.assign(D,{Group:I});export{te as Portal,ee as useNestedPortals};

frontend/node_modules/@headlessui/react/dist/components/radio-group/radio-group.d.ts

@@ -0,0 +1,49 @@
+import { type ElementType, type Ref } from 'react';
+import { _internal_ComponentDescription } from '../../components/description/description.js';
+import { _internal_ComponentLabel } from '../../components/label/label.js';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type RefProp } from '../../utils/render.js';
+declare let DEFAULT_RADIO_GROUP_TAG: "div";
+interface RadioGroupRenderPropArg<TType> {
+    value: TType;
+}
+type RadioGroupPropsWeControl = 'role' | 'aria-labelledby' | 'aria-describedby';
+export type RadioGroupProps<TTag extends ElementType, TType> = Props<TTag, RadioGroupRenderPropArg<TType>, RadioGroupPropsWeControl, {
+    value?: TType;
+    defaultValue?: TType;
+    onChange?(value: TType): void;
+    by?: (keyof TType & string) | ((a: TType, z: TType) => boolean);
+    disabled?: boolean;
+    form?: string;
+    name?: string;
+}>;
+declare function RadioGroupFn<TTag extends ElementType = typeof DEFAULT_RADIO_GROUP_TAG, TType = string>(props: RadioGroupProps<TTag, TType>, ref: Ref<HTMLElement>): JSX.Element;
+declare let DEFAULT_OPTION_TAG: "div";
+interface OptionRenderPropArg {
+    checked: boolean;
+    active: boolean;
+    disabled: boolean;
+}
+type OptionPropsWeControl = 'aria-checked' | 'aria-describedby' | 'aria-lablledby' | 'role' | 'tabIndex';
+export type RadioOptionProps<TTag extends ElementType, TType> = Props<TTag, OptionRenderPropArg, OptionPropsWeControl, {
+    value: TType;
+    disabled?: boolean;
+}>;
+declare function OptionFn<TTag extends ElementType = typeof DEFAULT_OPTION_TAG, TType = Parameters<typeof RadioGroupRoot>[0]['value']>(props: RadioOptionProps<TTag, TType>, ref: Ref<HTMLElement>): JSX.Element;
+export interface _internal_ComponentRadioGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_RADIO_GROUP_TAG, TType = string>(props: RadioGroupProps<TTag, TType> & RefProp<typeof RadioGroupFn>): JSX.Element;
+}
+export interface _internal_ComponentRadioOption extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OPTION_TAG, TType = string>(props: RadioOptionProps<TTag, TType> & RefProp<typeof OptionFn>): JSX.Element;
+}
+export interface _internal_ComponentRadioLabel extends _internal_ComponentLabel {
+}
+export interface _internal_ComponentRadioDescription extends _internal_ComponentDescription {
+}
+declare let RadioGroupRoot: _internal_ComponentRadioGroup;
+export declare let RadioGroup: _internal_ComponentRadioGroup & {
+    Option: _internal_ComponentRadioOption;
+    Label: _internal_ComponentRadioLabel;
+    Description: _internal_ComponentRadioDescription;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/switch/switch.d.ts

@@ -0,0 +1,42 @@
+import React, { type ElementType, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type RefProp } from '../../utils/render.js';
+import { _internal_ComponentDescription } from '../description/description.js';
+import { _internal_ComponentLabel } from '../label/label.js';
+declare let DEFAULT_GROUP_TAG: React.ExoticComponent<{
+    children?: React.ReactNode;
+}>;
+export type SwitchGroupProps<TTag extends ElementType> = Props<TTag>;
+declare function GroupFn<TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(props: SwitchGroupProps<TTag>): JSX.Element;
+declare let DEFAULT_SWITCH_TAG: "button";
+interface SwitchRenderPropArg {
+    checked: boolean;
+}
+type SwitchPropsWeControl = 'aria-checked' | 'aria-describedby' | 'aria-labelledby' | 'role';
+export type SwitchProps<TTag extends ElementType> = Props<TTag, SwitchRenderPropArg, SwitchPropsWeControl, {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?(checked: boolean): void;
+    name?: string;
+    value?: string;
+    disabled?: boolean;
+    form?: string;
+    tabIndex?: number;
+}>;
+declare function SwitchFn<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG>(props: SwitchProps<TTag>, ref: Ref<HTMLButtonElement>): JSX.Element;
+export interface _internal_ComponentSwitch extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_SWITCH_TAG>(props: SwitchProps<TTag> & RefProp<typeof SwitchFn>): JSX.Element;
+}
+export interface _internal_ComponentSwitchGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(props: SwitchGroupProps<TTag> & RefProp<typeof GroupFn>): JSX.Element;
+}
+export interface _internal_ComponentSwitchLabel extends _internal_ComponentLabel {
+}
+export interface _internal_ComponentSwitchDescription extends _internal_ComponentDescription {
+}
+export declare let Switch: _internal_ComponentSwitch & {
+    Group: _internal_ComponentSwitchGroup;
+    Label: _internal_ComponentSwitchLabel;
+    Description: _internal_ComponentSwitchDescription;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/switch/switch.js

@@ -0,0 +1 @@
+import l,{createContext as A,Fragment as H,useContext as F,useEffect as M,useMemo as P,useRef as U,useState as I}from"react";import{useControllable as K}from'../../hooks/use-controllable.js';import{useDisposables as B}from'../../hooks/use-disposables.js';import{useEvent as h}from'../../hooks/use-event.js';import{useId as O}from'../../hooks/use-id.js';import{useResolveButtonType as W}from'../../hooks/use-resolve-button-type.js';import{useSyncRefs as N}from'../../hooks/use-sync-refs.js';import{Features as J,Hidden as X}from'../../internal/hidden.js';import{isDisabledReactIssue7711 as j}from'../../utils/bugs.js';import{attemptSubmit as $}from'../../utils/form.js';import{compact as q,forwardRefWithAs as z,render as g}from'../../utils/render.js';import{Description as Q,useDescriptions as V}from'../description/description.js';import{Keys as D}from'../keyboard.js';import{Label as Y,useLabels as Z}from'../label/label.js';let S=A(null);S.displayName="GroupContext";let ee=H;function te(r){var u;let[n,p]=I(null),[c,T]=Z(),[o,b]=V(),a=P(()=>({switch:n,setSwitch:p,labelledby:c,describedby:o}),[n,p,c,o]),d={},y=r;return l.createElement(b,{name:"Switch.Description"},l.createElement(T,{name:"Switch.Label",props:{htmlFor:(u=a.switch)==null?void 0:u.id,onClick(m){n&&(m.currentTarget.tagName==="LABEL"&&m.preventDefault(),n.click(),n.focus({preventScroll:!0}))}}},l.createElement(S.Provider,{value:a},g({ourProps:d,theirProps:y,defaultTag:ee,name:"Switch.Group"}))))}let ne="button";function re(r,n){var E;let p=O(),{id:c=`headlessui-switch-${p}`,checked:T,defaultChecked:o=!1,onChange:b,disabled:a=!1,name:d,value:y,form:u,...m}=r,t=F(S),f=U(null),C=N(f,n,t===null?null:t.setSwitch),[i,s]=K(T,b,o),w=h(()=>s==null?void 0:s(!i)),L=h(e=>{if(j(e.currentTarget))return e.preventDefault();e.preventDefault(),w()}),x=h(e=>{e.key===D.Space?(e.preventDefault(),w()):e.key===D.Enter&&$(e.currentTarget)}),v=h(e=>e.preventDefault()),G=P(()=>({checked:i}),[i]),R={id:c,ref:C,role:"switch",type:W(r,f),tabIndex:r.tabIndex===-1?0:(E=r.tabIndex)!=null?E:0,"aria-checked":i,"aria-labelledby":t==null?void 0:t.labelledby,"aria-describedby":t==null?void 0:t.describedby,disabled:a,onClick:L,onKeyUp:x,onKeyPress:v},k=B();return M(()=>{var _;let e=(_=f.current)==null?void 0:_.closest("form");e&&o!==void 0&&k.addEventListener(e,"reset",()=>{s(o)})},[f,s]),l.createElement(l.Fragment,null,d!=null&&i&&l.createElement(X,{features:J.Hidden,...q({as:"input",type:"checkbox",hidden:!0,readOnly:!0,disabled:a,form:u,checked:i,name:d,value:y})}),g({ourProps:R,theirProps:m,slot:G,defaultTag:ne,name:"Switch"}))}let oe=z(re),ie=te,_e=Object.assign(oe,{Group:ie,Label:Y,Description:Q});export{_e as Switch};

frontend/node_modules/@headlessui/react/dist/components/tabs/tabs.d.ts

@@ -0,0 +1,73 @@
+import React, { type ElementType, type Ref } from 'react';
+import type { Props } from '../../types.js';
+import { type HasDisplayName, type PropsForFeatures, type RefProp } from '../../utils/render.js';
+declare let DEFAULT_TABS_TAG: React.ExoticComponent<{
+    children?: React.ReactNode;
+}>;
+interface TabsRenderPropArg {
+    selectedIndex: number;
+}
+export type TabGroupProps<TTag extends ElementType> = Props<TTag, TabsRenderPropArg, never, {
+    defaultIndex?: number;
+    onChange?: (index: number) => void;
+    selectedIndex?: number;
+    vertical?: boolean;
+    manual?: boolean;
+}>;
+declare function GroupFn<TTag extends ElementType = typeof DEFAULT_TABS_TAG>(props: TabGroupProps<TTag>, ref: Ref<HTMLElement>): JSX.Element;
+declare let DEFAULT_LIST_TAG: "div";
+interface ListRenderPropArg {
+    selectedIndex: number;
+}
+type ListPropsWeControl = 'aria-orientation' | 'role';
+export type TabListProps<TTag extends ElementType> = Props<TTag, ListRenderPropArg, ListPropsWeControl, {}>;
+declare function ListFn<TTag extends ElementType = typeof DEFAULT_LIST_TAG>(props: TabListProps<TTag>, ref: Ref<HTMLElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_TAB_TAG: "button";
+interface TabRenderPropArg {
+    selected: boolean;
+    disabled: boolean;
+}
+type TabPropsWeControl = 'aria-controls' | 'aria-selected' | 'role' | 'tabIndex';
+export type TabProps<TTag extends ElementType> = Props<TTag, TabRenderPropArg, TabPropsWeControl> & {
+    disabled?: boolean;
+};
+declare function TabFn<TTag extends ElementType = typeof DEFAULT_TAB_TAG>(props: TabProps<TTag>, ref: Ref<HTMLElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_PANELS_TAG: "div";
+interface PanelsRenderPropArg {
+    selectedIndex: number;
+}
+export type TabPanelsProps<TTag extends ElementType> = Props<TTag, PanelsRenderPropArg>;
+declare function PanelsFn<TTag extends ElementType = typeof DEFAULT_PANELS_TAG>(props: TabPanelsProps<TTag>, ref: Ref<HTMLElement>): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+declare let DEFAULT_PANEL_TAG: "div";
+interface PanelRenderPropArg {
+    selected: boolean;
+}
+type PanelPropsWeControl = 'role' | 'aria-labelledby';
+declare let PanelRenderFeatures: number;
+export type TabPanelProps<TTag extends ElementType> = Props<TTag, PanelRenderPropArg, PanelPropsWeControl, PropsForFeatures<typeof PanelRenderFeatures> & {
+    id?: string;
+    tabIndex?: number;
+}>;
+declare function PanelFn<TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: TabPanelProps<TTag>, ref: Ref<HTMLElement>): JSX.Element | null;
+export interface _internal_ComponentTab extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TAB_TAG>(props: TabProps<TTag> & RefProp<typeof TabFn>): JSX.Element;
+}
+export interface _internal_ComponentTabGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TABS_TAG>(props: TabGroupProps<TTag> & RefProp<typeof GroupFn>): JSX.Element;
+}
+export interface _internal_ComponentTabList extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_LIST_TAG>(props: TabListProps<TTag> & RefProp<typeof ListFn>): JSX.Element;
+}
+export interface _internal_ComponentTabPanels extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANELS_TAG>(props: TabPanelsProps<TTag> & RefProp<typeof PanelsFn>): JSX.Element;
+}
+export interface _internal_ComponentTabPanel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: TabPanelProps<TTag> & RefProp<typeof PanelFn>): JSX.Element;
+}
+export declare let Tab: _internal_ComponentTab & {
+    Group: _internal_ComponentTabGroup;
+    List: _internal_ComponentTabList;
+    Panels: _internal_ComponentTabPanels;
+    Panel: _internal_ComponentTabPanel;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/transitions/transition.d.ts

@@ -0,0 +1,41 @@
+import { type ElementType, type MutableRefObject, type Ref } from 'react';
+import type { Props, ReactTag } from '../../types.js';
+import { Features, type HasDisplayName, type PropsForFeatures, type RefProp } from '../../utils/render.js';
+export interface TransitionClasses {
+    enter?: string;
+    enterFrom?: string;
+    enterTo?: string;
+    entered?: string;
+    leave?: string;
+    leaveFrom?: string;
+    leaveTo?: string;
+}
+export interface TransitionEvents {
+    beforeEnter?: () => void;
+    afterEnter?: () => void;
+    beforeLeave?: () => void;
+    afterLeave?: () => void;
+}
+export type TransitionChildProps<TTag extends ReactTag> = Props<TTag, TransitionChildRenderPropArg, never, PropsForFeatures<typeof TransitionChildRenderFeatures> & TransitionClasses & TransitionEvents & {
+    appear?: boolean;
+}>;
+declare let DEFAULT_TRANSITION_CHILD_TAG: "div";
+type TransitionChildRenderPropArg = MutableRefObject<HTMLDivElement>;
+declare let TransitionChildRenderFeatures: Features;
+declare function TransitionChildFn<TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_TAG>(props: TransitionChildProps<TTag>, ref: Ref<HTMLElement>): JSX.Element;
+export type TransitionRootProps<TTag extends ElementType> = TransitionChildProps<TTag> & {
+    show?: boolean;
+    appear?: boolean;
+};
+declare function TransitionRootFn<TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_TAG>(props: TransitionRootProps<TTag>, ref: Ref<HTMLElement>): JSX.Element;
+export interface _internal_ComponentTransitionRoot extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_TAG>(props: TransitionRootProps<TTag> & RefProp<typeof TransitionRootFn>): JSX.Element;
+}
+export interface _internal_ComponentTransitionChild extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_TAG>(props: TransitionChildProps<TTag> & RefProp<typeof TransitionChildFn>): JSX.Element;
+}
+export declare let Transition: _internal_ComponentTransitionRoot & {
+    Child: _internal_ComponentTransitionChild;
+    Root: _internal_ComponentTransitionRoot;
+};
+export {};

frontend/node_modules/@headlessui/react/dist/components/transitions/utils/transition.d.ts

@@ -0,0 +1,10 @@
+export declare function transition(node: HTMLElement, classes: {
+    base: string[];
+    enter: string[];
+    enterFrom: string[];
+    enterTo: string[];
+    leave: string[];
+    leaveFrom: string[];
+    leaveTo: string[];
+    entered: string[];
+}, show: boolean, done?: () => void): () => void;

frontend/node_modules/@headlessui/react/dist/components/transitions/utils/transition.js

@@ -0,0 +1 @@
+import{disposables as f}from'../../../utils/disposables.js';import{match as d}from'../../../utils/match.js';import{once as s}from'../../../utils/once.js';function g(t,...e){t&&e.length>0&&t.classList.add(...e)}function v(t,...e){t&&e.length>0&&t.classList.remove(...e)}function b(t,e){let n=f();if(!t)return n.dispose;let{transitionDuration:m,transitionDelay:a}=getComputedStyle(t),[u,p]=[m,a].map(l=>{let[r=0]=l.split(",").filter(Boolean).map(i=>i.includes("ms")?parseFloat(i):parseFloat(i)*1e3).sort((i,T)=>T-i);return r}),o=u+p;if(o!==0){n.group(r=>{r.setTimeout(()=>{e(),r.dispose()},o),r.addEventListener(t,"transitionrun",i=>{i.target===i.currentTarget&&r.dispose()})});let l=n.addEventListener(t,"transitionend",r=>{r.target===r.currentTarget&&(e(),l())})}else e();return n.add(()=>e()),n.dispose}function M(t,e,n,m){let a=n?"enter":"leave",u=f(),p=m!==void 0?s(m):()=>{};a==="enter"&&(t.removeAttribute("hidden"),t.style.display="");let o=d(a,{enter:()=>e.enter,leave:()=>e.leave}),l=d(a,{enter:()=>e.enterTo,leave:()=>e.leaveTo}),r=d(a,{enter:()=>e.enterFrom,leave:()=>e.leaveFrom});return v(t,...e.base,...e.enter,...e.enterTo,...e.enterFrom,...e.leave,...e.leaveFrom,...e.leaveTo,...e.entered),g(t,...e.base,...o,...r),u.nextFrame(()=>{v(t,...e.base,...o,...r),g(t,...e.base,...o,...l),b(t,()=>(v(t,...e.base,...o),g(t,...e.base,...e.entered),p()))}),u.dispose}export{M as transition};