initial commit

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

@@ -0,0 +1,136 @@
+import React, { ElementType, Ref } from 'react';
+import { ByComparator, EnsureArray, Expand, Props } from '../../types.js';
+import { PropsForFeatures, HasDisplayName, 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;
+}
+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;
+}>;
+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;
+interface 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;
+}
+interface ComponentComboboxButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: ComboboxButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+interface ComponentComboboxInput extends HasDisplayName {
+    <TType, TTag extends ElementType = typeof DEFAULT_INPUT_TAG>(props: ComboboxInputProps<TTag, TType> & RefProp<typeof InputFn>): JSX.Element;
+}
+interface ComponentComboboxLabel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_LABEL_TAG>(props: ComboboxLabelProps<TTag> & RefProp<typeof LabelFn>): JSX.Element;
+}
+interface ComponentComboboxOptions extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG>(props: ComboboxOptionsProps<TTag> & RefProp<typeof OptionsFn>): JSX.Element;
+}
+interface 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: ComponentCombobox;
+export declare let Combobox: ComponentCombobox & {
+    Input: ComponentComboboxInput;
+    Button: ComponentComboboxButton;
+    Label: ComponentComboboxLabel;
+    Options: ComponentComboboxOptions;
+    Option: ComponentComboboxOption;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import React, { ElementType, ReactNode, Ref } from 'react';
+import { Props } from '../../types.js';
+import { HasDisplayName, 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 ComponentDescription extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_DESCRIPTION_TAG>(props: DescriptionProps<TTag> & RefProp<typeof DescriptionFn>): JSX.Element;
+}
+export declare let Description: ComponentDescription;
+export {};

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{useId as P}from'../../hooks/use-id.js';import{forwardRefWithAs as g,render as E}from'../../utils/render.js';import{useIsoMorphicEffect as x}from'../../hooks/use-iso-morphic-effect.js';import{useSyncRefs as R}from'../../hooks/use-sync-refs.js';import{useEvent as I}from'../../hooks/use-event.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 M(){let[r,t]=T([]);return[r.length>0?r.join(" "):void 0,l(()=>function(e){let i=I(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 S="p";function h(r,t){let a=P(),{id:e=`headlessui-description-${a}`,...i}=r,n=f(),s=R(t);x(()=>n.register(e),[e,n.register]);let o={ref:s,...n.props,id:e};return E({ourProps:o,theirProps:i,slot:n.slot||{},defaultTag:S,name:n.name||"Description"})}let y=g(h),b=Object.assign(y,{});export{b as Description,M as useDescriptions};

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

@@ -0,0 +1,68 @@
+import React, { ElementType, MutableRefObject, Ref } from 'react';
+import { Props } from '../../types.js';
+import { PropsForFeatures, HasDisplayName, RefProp } from '../../utils/render.js';
+import { ComponentDescription } from '../description/description.js';
+declare let DEFAULT_DIALOG_TAG: "div";
+interface DialogRenderPropArg {
+    open: boolean;
+}
+type DialogPropsWeControl = 'role' | '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>;
+    __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;
+interface ComponentDialog extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_DIALOG_TAG>(props: DialogProps<TTag> & RefProp<typeof DialogFn>): JSX.Element;
+}
+interface ComponentDialogBackdrop extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BACKDROP_TAG>(props: DialogBackdropProps<TTag> & RefProp<typeof BackdropFn>): JSX.Element;
+}
+interface ComponentDialogPanel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: DialogPanelProps<TTag> & RefProp<typeof PanelFn>): JSX.Element;
+}
+interface ComponentDialogOverlay extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OVERLAY_TAG>(props: DialogOverlayProps<TTag> & RefProp<typeof OverlayFn>): JSX.Element;
+}
+interface ComponentDialogTitle extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TITLE_TAG>(props: DialogTitleProps<TTag> & RefProp<typeof TitleFn>): JSX.Element;
+}
+interface ComponentDialogDescription extends ComponentDescription {
+}
+export declare let Dialog: ComponentDialog & {
+    Backdrop: ComponentDialogBackdrop;
+    Panel: ComponentDialogPanel;
+    Overlay: ComponentDialogOverlay;
+    Title: ComponentDialogTitle;
+    Description: ComponentDialogDescription;
+};
+export {};

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

@@ -0,0 +1,45 @@
+import React, { ElementType, MutableRefObject, Ref } from 'react';
+import { Props } from '../../types.js';
+import { PropsForFeatures, HasDisplayName, 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;
+interface ComponentDisclosure extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_DISCLOSURE_TAG>(props: DisclosureProps<TTag> & RefProp<typeof DisclosureFn>): JSX.Element;
+}
+interface ComponentDisclosureButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: DisclosureButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+interface ComponentDisclosurePanel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: DisclosurePanelProps<TTag> & RefProp<typeof PanelFn>): JSX.Element;
+}
+export declare let Disclosure: ComponentDisclosure & {
+    Button: ComponentDisclosureButton;
+    Panel: ComponentDisclosurePanel;
+};
+export {};

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

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

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

@@ -0,0 +1,32 @@
+import { ElementType, MutableRefObject, Ref } from 'react';
+import { Props } from '../../types.js';
+import { HasDisplayName, 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;
+interface ComponentFocusTrap extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_FOCUS_TRAP_TAG>(props: FocusTrapProps<TTag> & RefProp<typeof FocusTrapFn>): JSX.Element;
+}
+export declare let FocusTrap: ComponentFocusTrap & {
+    features: typeof Features;
+};
+export {};

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

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

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"
+}

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};

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

@@ -0,0 +1,22 @@
+import React, { ElementType, ReactNode, Ref } from 'react';
+import { Props } from '../../types.js';
+import { HasDisplayName, 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 ComponentLabel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_LABEL_TAG>(props: LabelProps<TTag> & RefProp<typeof LabelFn>): JSX.Element;
+}
+export declare let Label: ComponentLabel;
+export {};

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{useId as T}from'../../hooks/use-id.js';import{forwardRefWithAs as E,render as g}from'../../utils/render.js';import{useIsoMorphicEffect as x}from'../../hooks/use-iso-morphic-effect.js';import{useSyncRefs as P}from'../../hooks/use-sync-refs.js';import{useEvent as y}from'../../hooks/use-event.js';let d=m(null);function u(){let o=L(d);if(o===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 o}function H(){let[o,t]=b([]);return[o.length>0?o.join(" "):void 0,f(()=>function(e){let s=y(r=>(t(l=>[...l,r]),()=>t(l=>{let n=l.slice(),p=n.indexOf(r);return p!==-1&&n.splice(p,1),n}))),a=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:a},e.children)},[t])]}let A="label";function h(o,t){let i=T(),{id:e=`headlessui-label-${i}`,passive:s=!1,...a}=o,r=u(),l=P(t);x(()=>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 a&&delete a.onClick),g({ourProps:n,theirProps:a,slot:r.slot||{},defaultTag:A,name:r.name||"Label"})}let v=E(h),M=Object.assign(v,{});export{M as Label,H as useLabels};

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

@@ -0,0 +1,82 @@
+import React, { ElementType, Ref } from 'react';
+import { Props } from '../../types.js';
+import { PropsForFeatures, HasDisplayName, 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;
+interface 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;
+}
+interface ComponentListboxButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: ListboxButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+interface ComponentListboxLabel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_LABEL_TAG>(props: ListboxLabelProps<TTag> & RefProp<typeof LabelFn>): JSX.Element;
+}
+interface ComponentListboxOptions extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OPTIONS_TAG>(props: ListboxOptionsProps<TTag> & RefProp<typeof OptionsFn>): JSX.Element;
+}
+interface 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: ComponentListbox;
+export declare let Listbox: ComponentListbox & {
+    Button: ComponentListboxButton;
+    Label: ComponentListboxLabel;
+    Options: ComponentListboxOptions;
+    Option: ComponentListboxOption;
+};
+export {};

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

@@ -0,0 +1,62 @@
+import React, { ElementType, Ref } from 'react';
+import { Props } from '../../types.js';
+import { PropsForFeatures, HasDisplayName, 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;
+interface ComponentMenu extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_MENU_TAG>(props: MenuProps<TTag> & RefProp<typeof MenuFn>): JSX.Element;
+}
+interface ComponentMenuButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: MenuButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+interface ComponentMenuItems extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_ITEMS_TAG>(props: MenuItemsProps<TTag> & RefProp<typeof ItemsFn>): JSX.Element;
+}
+interface ComponentMenuItem extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_ITEM_TAG>(props: MenuItemProps<TTag> & RefProp<typeof ItemFn>): JSX.Element;
+}
+export declare let Menu: ComponentMenu & {
+    Button: ComponentMenuButton;
+    Items: ComponentMenuItems;
+    Item: ComponentMenuItem;
+};
+export {};

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

@@ -0,0 +1,68 @@
+import React, { ElementType, MutableRefObject, Ref, MouseEventHandler } from 'react';
+import { Props } from '../../types.js';
+import { PropsForFeatures, HasDisplayName, 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;
+interface ComponentPopover extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_POPOVER_TAG>(props: PopoverProps<TTag> & RefProp<typeof PopoverFn>): JSX.Element;
+}
+interface ComponentPopoverButton extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_BUTTON_TAG>(props: PopoverButtonProps<TTag> & RefProp<typeof ButtonFn>): JSX.Element;
+}
+interface ComponentPopoverOverlay extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OVERLAY_TAG>(props: PopoverOverlayProps<TTag> & RefProp<typeof OverlayFn>): JSX.Element;
+}
+interface ComponentPopoverPanel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: PopoverPanelProps<TTag> & RefProp<typeof PanelFn>): JSX.Element;
+}
+interface ComponentPopoverGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(props: PopoverGroupProps<TTag> & RefProp<typeof GroupFn>): JSX.Element;
+}
+export declare let Popover: ComponentPopover & {
+    Button: ComponentPopoverButton;
+    Overlay: ComponentPopoverOverlay;
+    Panel: ComponentPopoverPanel;
+    Group: ComponentPopoverGroup;
+};
+export {};

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

@@ -0,0 +1,32 @@
+import React, { ElementType, MutableRefObject, Ref } from 'react';
+import { Props } from '../../types.js';
+import { RefProp, HasDisplayName } 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];
+interface ComponentPortal extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PORTAL_TAG>(props: PortalProps<TTag> & RefProp<typeof PortalFn>): JSX.Element;
+}
+interface ComponentPortalGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(props: PortalGroupProps<TTag> & RefProp<typeof GroupFn>): JSX.Element;
+}
+export declare let Portal: ComponentPortal & {
+    Group: ComponentPortalGroup;
+};
+export {};

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

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

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

@@ -0,0 +1,49 @@
+import { ElementType, Ref } from 'react';
+import { Props } from '../../types.js';
+import { RefProp, HasDisplayName } from '../../utils/render.js';
+import { ComponentLabel } from '../../components/label/label.js';
+import { ComponentDescription } from '../../components/description/description.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;
+interface ComponentRadioGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_RADIO_GROUP_TAG, TType = string>(props: RadioGroupProps<TTag, TType> & RefProp<typeof RadioGroupFn>): JSX.Element;
+}
+interface ComponentRadioOption extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_OPTION_TAG, TType = string>(props: RadioOptionProps<TTag, TType> & RefProp<typeof OptionFn>): JSX.Element;
+}
+interface ComponentRadioLabel extends ComponentLabel {
+}
+interface ComponentRadioDescription extends ComponentDescription {
+}
+declare let RadioGroupRoot: ComponentRadioGroup;
+export declare let RadioGroup: ComponentRadioGroup & {
+    Option: ComponentRadioOption;
+    Label: ComponentRadioLabel;
+    Description: ComponentRadioDescription;
+};
+export {};

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

@@ -0,0 +1,40 @@
+import React, { ElementType, Ref } from 'react';
+import { Props } from '../../types.js';
+import { HasDisplayName, RefProp } from '../../utils/render.js';
+import { ComponentLabel } from '../label/label.js';
+import { ComponentDescription } from '../description/description.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' | 'tabIndex';
+export type SwitchProps<TTag extends ElementType> = Props<TTag, SwitchRenderPropArg, SwitchPropsWeControl, {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?(checked: boolean): void;
+    name?: string;
+    value?: string;
+    form?: string;
+}>;
+declare function SwitchFn<TTag extends ElementType = typeof DEFAULT_SWITCH_TAG>(props: SwitchProps<TTag>, ref: Ref<HTMLButtonElement>): JSX.Element;
+interface ComponentSwitch extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_SWITCH_TAG>(props: SwitchProps<TTag> & RefProp<typeof SwitchFn>): JSX.Element;
+}
+interface ComponentSwitchGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_GROUP_TAG>(props: SwitchGroupProps<TTag> & RefProp<typeof GroupFn>): JSX.Element;
+}
+interface ComponentSwitchLabel extends ComponentLabel {
+}
+interface ComponentSwitchDescription extends ComponentDescription {
+}
+export declare let Switch: ComponentSwitch & {
+    Group: ComponentSwitchGroup;
+    Label: ComponentSwitchLabel;
+    Description: ComponentSwitchDescription;
+};
+export {};

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

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

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

@@ -0,0 +1,70 @@
+import React, { ElementType, Ref } from 'react';
+import { Props } from '../../types.js';
+import { PropsForFeatures, RefProp, HasDisplayName } 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;
+}
+type TabPropsWeControl = 'aria-controls' | 'aria-selected' | 'role' | 'tabIndex';
+export type TabProps<TTag extends ElementType> = Props<TTag, TabRenderPropArg, TabPropsWeControl> & {};
+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;
+interface ComponentTab extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TAB_TAG>(props: TabProps<TTag> & RefProp<typeof TabFn>): JSX.Element;
+}
+interface ComponentTabGroup extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TABS_TAG>(props: TabGroupProps<TTag> & RefProp<typeof GroupFn>): JSX.Element;
+}
+interface ComponentTabList extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_LIST_TAG>(props: TabListProps<TTag> & RefProp<typeof ListFn>): JSX.Element;
+}
+interface ComponentTabPanels extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANELS_TAG>(props: TabPanelsProps<TTag> & RefProp<typeof PanelsFn>): JSX.Element;
+}
+interface ComponentTabPanel extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_PANEL_TAG>(props: TabPanelProps<TTag> & RefProp<typeof PanelFn>): JSX.Element;
+}
+export declare let Tab: ComponentTab & {
+    Group: ComponentTabGroup;
+    List: ComponentTabList;
+    Panels: ComponentTabPanels;
+    Panel: ComponentTabPanel;
+};
+export {};

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

@@ -0,0 +1,41 @@
+import { ElementType, MutableRefObject, Ref } from 'react';
+import { Props, ReactTag } from '../../types.js';
+import { Features, HasDisplayName, PropsForFeatures, 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;
+interface ComponentTransitionRoot extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_TAG>(props: TransitionRootProps<TTag> & RefProp<typeof TransitionRootFn>): JSX.Element;
+}
+interface ComponentTransitionChild extends HasDisplayName {
+    <TTag extends ElementType = typeof DEFAULT_TRANSITION_CHILD_TAG>(props: TransitionChildProps<TTag> & RefProp<typeof TransitionChildFn>): JSX.Element;
+}
+export declare let Transition: ComponentTransitionRoot & {
+    Child: ComponentTransitionChild;
+    Root: ComponentTransitionRoot;
+};
+export {};

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;

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

@@ -0,0 +1 @@
+import{once as s}from'../../../utils/once.js';import{disposables as f}from'../../../utils/disposables.js';import{match as d}from'../../../utils/match.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};