initial commit

node_modules/@headlessui/react/README.md

@@ -0,0 +1,34 @@
+<h3 align="center">
+  @headlessui/react
+</h3>
+
+<p align="center">
+  A set of completely unstyled, fully accessible UI components for React, designed to integrate
+  beautifully with Tailwind CSS.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@headlessui/react"><img src="https://img.shields.io/npm/dt/@headlessui/react.svg" alt="Total Downloads"></a>
+  <a href="https://github.com/tailwindlabs/headlessui/releases"><img src="https://img.shields.io/npm/v/@headlessui/react.svg" alt="Latest Release"></a>
+  <a href="https://github.com/tailwindlabs/headlessui/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@headlessui/react.svg" alt="License"></a>
+</p>
+
+## Installation
+
+```sh
+npm install @headlessui/react
+```
+
+## Documentation
+
+For full documentation, visit [headlessui.dev](https://headlessui.dev/react/menu).
+
+## Community
+
+For help, discussion about best practices, or any other conversation that would benefit from being searchable:
+
+[Discuss Headless UI on GitHub](https://github.com/tailwindlabs/headlessui/discussions)
+
+For casual chit-chat with others using the library:
+
+[Join the Tailwind CSS Discord Server](https://discord.gg/7NF8GNe)

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

node_modules/@headlessui/react/dist/headlessui.esm.js

@@ -0,0 +1 @@
+import"client-only";export*from'./components/combobox/combobox.js';export*from'./components/dialog/dialog.js';export*from'./components/disclosure/disclosure.js';export*from'./components/focus-trap/focus-trap.js';export*from'./components/listbox/listbox.js';export*from'./components/menu/menu.js';export*from'./components/popover/popover.js';export*from'./components/radio-group/radio-group.js';export*from'./components/switch/switch.js';export*from'./components/tabs/tabs.js';export*from'./components/transitions/transition.js';import{Portal as d}from'./components/portal/portal.js';export{d as Portal};

node_modules/@headlessui/react/dist/hooks/__mocks__/use-id.d.ts

@@ -0,0 +1 @@
+export declare function useId(): number;

node_modules/@headlessui/react/dist/hooks/document-overflow/adjust-scrollbar-padding.d.ts

@@ -0,0 +1,2 @@
+import { ScrollLockStep } from './overflow-store.js';
+export declare function adjustScrollbarPadding(): ScrollLockStep;

node_modules/@headlessui/react/dist/hooks/document-overflow/adjust-scrollbar-padding.js

@@ -0,0 +1 @@
+function c(){let o;return{before({doc:e}){var l;let n=e.documentElement;o=((l=e.defaultView)!=null?l:window).innerWidth-n.clientWidth},after({doc:e,d:n}){let t=e.documentElement,l=t.clientWidth-t.offsetWidth,r=o-l;n.style(t,"paddingRight",`${r}px`)}}}export{c as adjustScrollbarPadding};

node_modules/@headlessui/react/dist/hooks/document-overflow/handle-ios-locking.d.ts

@@ -0,0 +1,6 @@
+import { ScrollLockStep } from './overflow-store.js';
+interface ContainerMetadata {
+    containers: (() => HTMLElement[])[];
+}
+export declare function handleIOSLocking(): ScrollLockStep<ContainerMetadata>;
+export {};

node_modules/@headlessui/react/dist/hooks/document-overflow/handle-ios-locking.js

@@ -0,0 +1 @@
+import{disposables as m}from'../../utils/disposables.js';import{isIOS as f}from'../../utils/platform.js';function T(){if(!f())return{};let l;return{before(){l=window.pageYOffset},after({doc:o,d:t,meta:s}){function i(n){return s.containers.flatMap(e=>e()).some(e=>e.contains(n))}t.microTask(()=>{if(window.getComputedStyle(o.documentElement).scrollBehavior!=="auto"){let e=m();e.style(o.documentElement,"scroll-behavior","auto"),t.add(()=>t.microTask(()=>e.dispose()))}t.style(o.body,"marginTop",`-${l}px`),window.scrollTo(0,0);let n=null;t.addEventListener(o,"click",e=>{if(e.target instanceof HTMLElement)try{let r=e.target.closest("a");if(!r)return;let{hash:c}=new URL(r.href),a=o.querySelector(c);a&&!i(a)&&(n=a)}catch{}},!0),t.addEventListener(o,"touchmove",e=>{e.target instanceof HTMLElement&&!i(e.target)&&e.preventDefault()},{passive:!1}),t.add(()=>{window.scrollTo(0,window.pageYOffset+l),n&&n.isConnected&&(n.scrollIntoView({block:"nearest"}),n=null)})})}}}export{T as handleIOSLocking};

node_modules/@headlessui/react/dist/hooks/document-overflow/overflow-store.d.ts

@@ -0,0 +1,19 @@
+import { Disposables } from '../../utils/disposables.js';
+interface DocEntry {
+    doc: Document;
+    count: number;
+    d: Disposables;
+    meta: Set<MetaFn>;
+}
+export type MetaFn = (meta: Record<string, any>) => Record<string, any>;
+export interface Context<MetaType extends Record<string, any> = any> {
+    doc: Document;
+    d: Disposables;
+    meta: MetaType;
+}
+export interface ScrollLockStep<MetaType extends Record<string, any> = any> {
+    before?(ctx: Context<MetaType>): void;
+    after?(ctx: Context<MetaType>): void;
+}
+export declare let overflows: import('../../utils/store.js').Store<Map<Document, DocEntry>, "PUSH" | "POP" | "SCROLL_PREVENT" | "SCROLL_ALLOW" | "TEARDOWN">;
+export {};

node_modules/@headlessui/react/dist/hooks/document-overflow/overflow-store.js

@@ -0,0 +1 @@
+import{disposables as s}from'../../utils/disposables.js';import{createStore as i}from'../../utils/store.js';import{adjustScrollbarPadding as l}from'./adjust-scrollbar-padding.js';import{handleIOSLocking as d}from'./handle-ios-locking.js';import{preventScroll as p}from'./prevent-scroll.js';function m(e){let n={};for(let t of e)Object.assign(n,t(n));return n}let a=i(()=>new Map,{PUSH(e,n){var o;let t=(o=this.get(e))!=null?o:{doc:e,count:0,d:s(),meta:new Set};return t.count++,t.meta.add(n),this.set(e,t),this},POP(e,n){let t=this.get(e);return t&&(t.count--,t.meta.delete(n)),this},SCROLL_PREVENT({doc:e,d:n,meta:t}){let o={doc:e,d:n,meta:m(t)},c=[d(),l(),p()];c.forEach(({before:r})=>r==null?void 0:r(o)),c.forEach(({after:r})=>r==null?void 0:r(o))},SCROLL_ALLOW({d:e}){e.dispose()},TEARDOWN({doc:e}){this.delete(e)}});a.subscribe(()=>{let e=a.getSnapshot(),n=new Map;for(let[t]of e)n.set(t,t.documentElement.style.overflow);for(let t of e.values()){let o=n.get(t.doc)==="hidden",c=t.count!==0;(c&&!o||!c&&o)&&a.dispatch(t.count>0?"SCROLL_PREVENT":"SCROLL_ALLOW",t),t.count===0&&a.dispatch("TEARDOWN",t)}});export{a as overflows};

node_modules/@headlessui/react/dist/hooks/document-overflow/prevent-scroll.d.ts

@@ -0,0 +1,2 @@
+import { ScrollLockStep } from './overflow-store.js';
+export declare function preventScroll(): ScrollLockStep;

node_modules/@headlessui/react/dist/hooks/document-overflow/prevent-scroll.js

@@ -0,0 +1 @@
+function l(){return{before({doc:e,d:o}){o.style(e.documentElement,"overflow","hidden")}}}export{l as preventScroll};

node_modules/@headlessui/react/dist/hooks/document-overflow/use-document-overflow.d.ts

@@ -0,0 +1 @@
+export declare function useDocumentOverflowLockedEffect(doc: Document | null, shouldBeLocked: boolean, meta: (meta: Record<string, any>) => Record<string, any>): boolean;

node_modules/@headlessui/react/dist/hooks/document-overflow/use-document-overflow.js

@@ -0,0 +1 @@
+import{useIsoMorphicEffect as u}from'../use-iso-morphic-effect.js';import{useStore as s}from'../../hooks/use-store.js';import{overflows as t}from'./overflow-store.js';function p(e,r,n){let f=s(t),o=e?f.get(e):void 0,i=o?o.count>0:!1;return u(()=>{if(!(!e||!r))return t.dispatch("PUSH",e,n),()=>t.dispatch("POP",e,n)},[r,e]),i}export{p as useDocumentOverflowLockedEffect};

node_modules/@headlessui/react/dist/hooks/use-computed.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function useComputed<T>(cb: () => T, dependencies: React.DependencyList): T;

node_modules/@headlessui/react/dist/hooks/use-computed.js

@@ -0,0 +1 @@
+import{useState as s}from"react";import{useIsoMorphicEffect as f}from'./use-iso-morphic-effect.js';import{useLatestValue as m}from'./use-latest-value.js';function i(e,o){let[u,t]=s(e),r=m(e);return f(()=>t(r.current),[r,t,...o]),u}export{i as useComputed};

node_modules/@headlessui/react/dist/hooks/use-controllable.d.ts

@@ -0,0 +1 @@
+export declare function useControllable<T>(controlledValue: T | undefined, onChange?: (value: T) => void, defaultValue?: T): readonly [NonNullable<T>, (value: any) => void | undefined];

node_modules/@headlessui/react/dist/hooks/use-controllable.js

@@ -0,0 +1 @@
+import{useRef as o,useState as f}from"react";import{useEvent as a}from'./use-event.js';function T(l,r,c){let[i,s]=f(c),e=l!==void 0,t=o(e),u=o(!1),d=o(!1);return e&&!t.current&&!u.current?(u.current=!0,t.current=e,console.error("A component is changing from uncontrolled to controlled. This may be caused by the value changing from undefined to a defined value, which should not happen.")):!e&&t.current&&!d.current&&(d.current=!0,t.current=e,console.error("A component is changing from controlled to uncontrolled. This may be caused by the value changing from a defined value to undefined, which should not happen.")),[e?l:i,a(n=>(e||s(n),r==null?void 0:r(n)))]}export{T as useControllable};

node_modules/@headlessui/react/dist/hooks/use-disposables.d.ts

@@ -0,0 +1,21 @@
+export declare function useDisposables(): {
+    addEventListener<TEventName extends keyof WindowEventMap>(element: HTMLElement | Window | Document, name: TEventName, listener: (event: WindowEventMap[TEventName]) => any, options?: boolean | AddEventListenerOptions | undefined): () => void;
+    requestAnimationFrame(callback: FrameRequestCallback): () => void;
+    nextFrame(callback: FrameRequestCallback): () => void;
+    setTimeout(callback: (...args: any[]) => void, ms?: number | undefined, ...args: any[]): () => void;
+    microTask(cb: () => void): () => void;
+    style(node: HTMLElement, property: string, value: string): () => void;
+    group(cb: (d: {
+        addEventListener<TEventName extends keyof WindowEventMap>(element: HTMLElement | Window | Document, name: TEventName, listener: (event: WindowEventMap[TEventName]) => any, options?: boolean | AddEventListenerOptions | undefined): () => void;
+        requestAnimationFrame(callback: FrameRequestCallback): () => void;
+        nextFrame(callback: FrameRequestCallback): () => void;
+        setTimeout(callback: (...args: any[]) => void, ms?: number | undefined, ...args: any[]): () => void;
+        microTask(cb: () => void): () => void;
+        style(node: HTMLElement, property: string, value: string): () => void;
+        group(cb: any): () => void;
+        add(cb: () => void): () => void;
+        dispose(): void;
+    }) => void): () => void;
+    add(cb: () => void): () => void;
+    dispose(): void;
+};

node_modules/@headlessui/react/dist/hooks/use-disposables.js

@@ -0,0 +1 @@
+import{useState as s,useEffect as o}from"react";import{disposables as t}from'../utils/disposables.js';function p(){let[e]=s(t);return o(()=>()=>e.dispose(),[e]),e}export{p as useDisposables};

node_modules/@headlessui/react/dist/hooks/use-document-event.d.ts

@@ -0,0 +1 @@
+export declare function useDocumentEvent<TType extends keyof DocumentEventMap>(type: TType, listener: (ev: DocumentEventMap[TType]) => any, options?: boolean | AddEventListenerOptions): void;

node_modules/@headlessui/react/dist/hooks/use-document-event.js

@@ -0,0 +1 @@
+import{useEffect as m}from"react";import{useLatestValue as c}from'./use-latest-value.js';function d(e,r,n){let o=c(r);m(()=>{function t(u){o.current(u)}return document.addEventListener(e,t,n),()=>document.removeEventListener(e,t,n)},[e,n])}export{d as useDocumentEvent};

node_modules/@headlessui/react/dist/hooks/use-event-listener.d.ts

@@ -0,0 +1 @@
+export declare function useEventListener<TType extends keyof WindowEventMap>(element: HTMLElement | Document | Window | EventTarget | null | undefined, type: TType, listener: (event: WindowEventMap[TType]) => any, options?: boolean | AddEventListenerOptions): void;

node_modules/@headlessui/react/dist/hooks/use-event-listener.js

@@ -0,0 +1 @@
+import{useEffect as d}from"react";import{useLatestValue as s}from'./use-latest-value.js';function E(n,e,a,t){let i=s(a);d(()=>{n=n!=null?n:window;function r(o){i.current(o)}return n.addEventListener(e,r,t),()=>n.removeEventListener(e,r,t)},[n,e,t])}export{E as useEventListener};

node_modules/@headlessui/react/dist/hooks/use-event.d.ts

@@ -0,0 +1 @@
+export declare let useEvent: <F extends (...args: any[]) => any, P extends any[] = Parameters<F>, R = ReturnType<F>>(cb: (...args: P) => R) => (...args: P) => R;

node_modules/@headlessui/react/dist/hooks/use-event.js

@@ -0,0 +1 @@
+import a from"react";import{useLatestValue as n}from'./use-latest-value.js';let o=function(t){let e=n(t);return a.useCallback((...r)=>e.current(...r),[e])};export{o as useEvent};

node_modules/@headlessui/react/dist/hooks/use-flags.d.ts

@@ -0,0 +1,7 @@
+export declare function useFlags(initialFlags?: number): {
+    flags: number;
+    addFlag: (flag: number) => void;
+    hasFlag: (flag: number) => boolean;
+    removeFlag: (flag: number) => void;
+    toggleFlag: (flag: number) => void;
+};

node_modules/@headlessui/react/dist/hooks/use-flags.js

@@ -0,0 +1 @@
+import{useState as f,useCallback as n}from"react";import{useIsMounted as i}from'./use-is-mounted.js';function c(a=0){let[l,r]=f(a),t=i(),o=n(e=>{t.current&&r(u=>u|e)},[l,t]),m=n(e=>Boolean(l&e),[l]),s=n(e=>{t.current&&r(u=>u&~e)},[r,t]),g=n(e=>{t.current&&r(u=>u^e)},[r]);return{flags:l,addFlag:o,hasFlag:m,removeFlag:s,toggleFlag:g}}export{c as useFlags};

node_modules/@headlessui/react/dist/hooks/use-id.d.ts

@@ -0,0 +1 @@
+export declare let useId: any;

node_modules/@headlessui/react/dist/hooks/use-id.js

@@ -0,0 +1 @@
+var o;import t from"react";import{useIsoMorphicEffect as d}from'./use-iso-morphic-effect.js';import{useServerHandoffComplete as f}from'./use-server-handoff-complete.js';import{env as r}from'../utils/env.js';let I=(o=t.useId)!=null?o:function(){let n=f(),[e,u]=t.useState(n?()=>r.nextId():null);return d(()=>{e===null&&u(r.nextId())},[e]),e!=null?""+e:void 0};export{I as useId};

node_modules/@headlessui/react/dist/hooks/use-inert.d.ts

@@ -0,0 +1,2 @@
+import { MutableRefObject } from 'react';
+export declare function useInert<TElement extends HTMLElement>(node: MutableRefObject<TElement | null> | (() => TElement | null), enabled?: boolean): void;

node_modules/@headlessui/react/dist/hooks/use-inert.js

@@ -0,0 +1 @@
+import{useIsoMorphicEffect as s}from'./use-iso-morphic-effect.js';let u=new Map,t=new Map;function h(r,l=!0){s(()=>{var o;if(!l)return;let e=typeof r=="function"?r():r.current;if(!e)return;function a(){var d;if(!e)return;let i=(d=t.get(e))!=null?d:1;if(i===1?t.delete(e):t.set(e,i-1),i!==1)return;let n=u.get(e);n&&(n["aria-hidden"]===null?e.removeAttribute("aria-hidden"):e.setAttribute("aria-hidden",n["aria-hidden"]),e.inert=n.inert,u.delete(e))}let f=(o=t.get(e))!=null?o:0;return t.set(e,f+1),f!==0||(u.set(e,{"aria-hidden":e.getAttribute("aria-hidden"),inert:e.inert}),e.setAttribute("aria-hidden","true"),e.inert=!0),a},[r,l])}export{h as useInert};

node_modules/@headlessui/react/dist/hooks/use-is-initial-render.d.ts

@@ -0,0 +1 @@
+export declare function useIsInitialRender(): boolean;

node_modules/@headlessui/react/dist/hooks/use-is-initial-render.js

@@ -0,0 +1 @@
+import{useRef as r,useEffect as t}from"react";function n(){let e=r(!0);return t(()=>(e.current=!1,()=>{e.current=!0}),[]),e.current}export{n as useIsInitialRender};

node_modules/@headlessui/react/dist/hooks/use-is-mounted.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function useIsMounted(): import("react").MutableRefObject<boolean>;

node_modules/@headlessui/react/dist/hooks/use-is-mounted.js

@@ -0,0 +1 @@
+import{useRef as r}from"react";import{useIsoMorphicEffect as t}from'./use-iso-morphic-effect.js';function f(){let e=r(!1);return t(()=>(e.current=!0,()=>{e.current=!1}),[]),e}export{f as useIsMounted};

node_modules/@headlessui/react/dist/hooks/use-iso-morphic-effect.d.ts

@@ -0,0 +1,2 @@
+import { EffectCallback, DependencyList } from 'react';
+export declare let useIsoMorphicEffect: (effect: EffectCallback, deps?: DependencyList | undefined) => void;

node_modules/@headlessui/react/dist/hooks/use-iso-morphic-effect.js

@@ -0,0 +1 @@
+import{useLayoutEffect as t,useEffect as c}from"react";import{env as i}from'../utils/env.js';let l=(e,f)=>{i.isServer?c(e,f):t(e,f)};export{l as useIsoMorphicEffect};

node_modules/@headlessui/react/dist/hooks/use-latest-value.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function useLatestValue<T>(value: T): import("react").MutableRefObject<T>;

node_modules/@headlessui/react/dist/hooks/use-latest-value.js

@@ -0,0 +1 @@
+import{useRef as t}from"react";import{useIsoMorphicEffect as o}from'./use-iso-morphic-effect.js';function s(e){let r=t(e);return o(()=>{r.current=e},[e]),r}export{s as useLatestValue};

node_modules/@headlessui/react/dist/hooks/use-on-unmount.d.ts

@@ -0,0 +1 @@
+export declare function useOnUnmount(cb: () => void): void;

node_modules/@headlessui/react/dist/hooks/use-on-unmount.js

@@ -0,0 +1 @@
+import{useRef as u,useEffect as n}from"react";import{microTask as o}from'../utils/micro-task.js';import{useEvent as f}from'./use-event.js';function c(t){let r=f(t),e=u(!1);n(()=>(e.current=!1,()=>{e.current=!0,o(()=>{e.current&&r()})}),[r])}export{c as useOnUnmount};

node_modules/@headlessui/react/dist/hooks/use-outside-click.d.ts

@@ -0,0 +1,6 @@
+import { MutableRefObject } from 'react';
+type Container = MutableRefObject<HTMLElement | null> | HTMLElement | null;
+type ContainerCollection = Container[] | Set<Container>;
+type ContainerInput = Container | ContainerCollection;
+export declare function useOutsideClick(containers: ContainerInput | (() => ContainerInput), cb: (event: MouseEvent | PointerEvent | FocusEvent | TouchEvent, target: HTMLElement) => void, enabled?: boolean): void;
+export {};

node_modules/@headlessui/react/dist/hooks/use-outside-click.js

@@ -0,0 +1 @@
+import{useEffect as d,useRef as f}from"react";import{FocusableMode as p,isFocusableElement as C}from'../utils/focus-management.js';import{useDocumentEvent as l}from'./use-document-event.js';import{useWindowEvent as M}from'./use-window-event.js';function h(s,m,a=!0){let i=f(!1);d(()=>{requestAnimationFrame(()=>{i.current=a})},[a]);function c(e,r){if(!i.current||e.defaultPrevented)return;let t=r(e);if(t===null||!t.getRootNode().contains(t)||!t.isConnected)return;let E=function u(n){return typeof n=="function"?u(n()):Array.isArray(n)||n instanceof Set?n:[n]}(s);for(let u of E){if(u===null)continue;let n=u instanceof HTMLElement?u:u.current;if(n!=null&&n.contains(t)||e.composed&&e.composedPath().includes(n))return}return!C(t,p.Loose)&&t.tabIndex!==-1&&e.preventDefault(),m(e,t)}let o=f(null);l("pointerdown",e=>{var r,t;i.current&&(o.current=((t=(r=e.composedPath)==null?void 0:r.call(e))==null?void 0:t[0])||e.target)},!0),l("mousedown",e=>{var r,t;i.current&&(o.current=((t=(r=e.composedPath)==null?void 0:r.call(e))==null?void 0:t[0])||e.target)},!0),l("click",e=>{o.current&&(c(e,()=>o.current),o.current=null)},!0),l("touchend",e=>c(e,()=>e.target instanceof HTMLElement?e.target:null),!0),M("blur",e=>c(e,()=>window.document.activeElement instanceof HTMLIFrameElement?window.document.activeElement:null),!0)}export{h as useOutsideClick};

node_modules/@headlessui/react/dist/hooks/use-owner.d.ts

@@ -0,0 +1,2 @@
+import { getOwnerDocument } from '../utils/owner.js';
+export declare function useOwnerDocument(...args: Parameters<typeof getOwnerDocument>): Document | null;

node_modules/@headlessui/react/dist/hooks/use-owner.js

@@ -0,0 +1 @@
+import{useMemo as t}from"react";import{getOwnerDocument as o}from'../utils/owner.js';function n(...e){return t(()=>o(...e),[...e])}export{n as useOwnerDocument};

node_modules/@headlessui/react/dist/hooks/use-resolve-button-type.d.ts

@@ -0,0 +1,5 @@
+import { MutableRefObject } from 'react';
+export declare function useResolveButtonType<TTag>(props: {
+    type?: string;
+    as?: TTag;
+}, ref: MutableRefObject<HTMLElement | null>): string | undefined;

node_modules/@headlessui/react/dist/hooks/use-resolve-button-type.js

@@ -0,0 +1 @@
+import{useState as o}from"react";import{useIsoMorphicEffect as r}from'./use-iso-morphic-effect.js';function i(t){var n;if(t.type)return t.type;let e=(n=t.as)!=null?n:"button";if(typeof e=="string"&&e.toLowerCase()==="button")return"button"}function s(t,e){let[n,u]=o(()=>i(t));return r(()=>{u(i(t))},[t.type,t.as]),r(()=>{n||e.current&&e.current instanceof HTMLButtonElement&&!e.current.hasAttribute("type")&&u("button")},[n,e]),n}export{s as useResolveButtonType};

node_modules/@headlessui/react/dist/hooks/use-root-containers.d.ts

@@ -0,0 +1,15 @@
+import React, { MutableRefObject } from 'react';
+export declare function useRootContainers({ defaultContainers, portals, mainTreeNodeRef: _mainTreeNodeRef, }?: {
+    defaultContainers?: (HTMLElement | null | MutableRefObject<HTMLElement | null>)[];
+    portals?: MutableRefObject<HTMLElement[]>;
+    mainTreeNodeRef?: MutableRefObject<HTMLElement | null>;
+}): {
+    resolveContainers: () => HTMLElement[];
+    contains: (element: HTMLElement) => boolean;
+    mainTreeNodeRef: React.MutableRefObject<HTMLElement | null>;
+    MainTreeNode: () => JSX.Element | null;
+};
+export declare function useMainTreeNode(): {
+    mainTreeNodeRef: React.MutableRefObject<HTMLElement | null>;
+    MainTreeNode: () => JSX.Element;
+};

node_modules/@headlessui/react/dist/hooks/use-root-containers.js

@@ -0,0 +1 @@
+import s,{useRef as a,useMemo as m}from"react";import{Hidden as M,Features as d}from'../internal/hidden.js';import{useEvent as H}from'./use-event.js';import{useOwnerDocument as E}from'./use-owner.js';function j({defaultContainers:t=[],portals:r,mainTreeNodeRef:u}={}){var c;let o=a((c=u==null?void 0:u.current)!=null?c:null),l=E(o),f=H(()=>{var i;let n=[];for(let e of t)e!==null&&(e instanceof HTMLElement?n.push(e):"current"in e&&e.current instanceof HTMLElement&&n.push(e.current));if(r!=null&&r.current)for(let e of r.current)n.push(e);for(let e of(i=l==null?void 0:l.querySelectorAll("html > *, body > *"))!=null?i:[])e!==document.body&&e!==document.head&&e instanceof HTMLElement&&e.id!=="headlessui-portal-root"&&(e.contains(o.current)||n.some(T=>e.contains(T))||n.push(e));return n});return{resolveContainers:f,contains:H(n=>f().some(i=>i.contains(n))),mainTreeNodeRef:o,MainTreeNode:m(()=>function(){return u!=null?null:s.createElement(M,{features:d.Hidden,ref:o})},[o,u])}}function y(){let t=a(null);return{mainTreeNodeRef:t,MainTreeNode:m(()=>function(){return s.createElement(M,{features:d.Hidden,ref:t})},[t])}}export{y as useMainTreeNode,j as useRootContainers};

node_modules/@headlessui/react/dist/hooks/use-server-handoff-complete.d.ts

@@ -0,0 +1 @@
+export declare function useServerHandoffComplete(): boolean;

node_modules/@headlessui/react/dist/hooks/use-server-handoff-complete.js

@@ -0,0 +1 @@
+import*as t from"react";import{env as f}from'../utils/env.js';function s(){let r=typeof document=="undefined";return"useSyncExternalStore"in t?(o=>o.useSyncExternalStore)(t)(()=>()=>{},()=>!1,()=>!r):!1}function l(){let r=s(),[e,n]=t.useState(f.isHandoffComplete);return e&&f.isHandoffComplete===!1&&n(!1),t.useEffect(()=>{e!==!0&&n(!0)},[e]),t.useEffect(()=>f.handoff(),[]),r?!1:e}export{l as useServerHandoffComplete};

node_modules/@headlessui/react/dist/hooks/use-store.d.ts

@@ -0,0 +1,2 @@
+import { Store } from '../utils/store.js';
+export declare function useStore<T>(store: Store<T, any>): T;

node_modules/@headlessui/react/dist/hooks/use-store.js

@@ -0,0 +1 @@
+import{useSyncExternalStore as r}from'../use-sync-external-store-shim/index.js';function S(t){return r(t.subscribe,t.getSnapshot,t.getSnapshot)}export{S as useStore};

node_modules/@headlessui/react/dist/hooks/use-sync-refs.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare function optionalRef<T>(cb: (ref: T) => void, isOptional?: boolean): ((ref: T) => void) & {
+    [x: symbol]: boolean;
+};
+export declare function useSyncRefs<TType>(...refs: (React.MutableRefObject<TType | null> | ((instance: TType) => void) | null)[]): ((value: TType) => void) | undefined;

node_modules/@headlessui/react/dist/hooks/use-sync-refs.js

@@ -0,0 +1 @@
+import{useRef as l,useEffect as i}from"react";import{useEvent as r}from'./use-event.js';let u=Symbol();function T(t,n=!0){return Object.assign(t,{[u]:n})}function y(...t){let n=l(t);i(()=>{n.current=t},[t]);let c=r(e=>{for(let o of n.current)o!=null&&(typeof o=="function"?o(e):o.current=e)});return t.every(e=>e==null||(e==null?void 0:e[u]))?void 0:c}export{T as optionalRef,y as useSyncRefs};

node_modules/@headlessui/react/dist/hooks/use-tab-direction.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare enum Direction {
+    Forwards = 0,
+    Backwards = 1
+}
+export declare function useTabDirection(): import("react").MutableRefObject<Direction>;

node_modules/@headlessui/react/dist/hooks/use-tab-direction.js

@@ -0,0 +1 @@
+import{useRef as t}from"react";import{useWindowEvent as a}from'./use-window-event.js';var s=(r=>(r[r.Forwards=0]="Forwards",r[r.Backwards=1]="Backwards",r))(s||{});function n(){let e=t(0);return a("keydown",o=>{o.key==="Tab"&&(e.current=o.shiftKey?1:0)},!0),e}export{s as Direction,n as useTabDirection};

node_modules/@headlessui/react/dist/hooks/use-text-value.d.ts

@@ -0,0 +1,2 @@
+import { MutableRefObject } from 'react';
+export declare function useTextValue(element: MutableRefObject<HTMLElement | null>): () => string;

node_modules/@headlessui/react/dist/hooks/use-text-value.js

@@ -0,0 +1 @@
+import{useRef as l}from"react";import{getTextValue as i}from'../utils/get-text-value.js';import{useEvent as o}from'./use-event.js';function b(c){let t=l(""),r=l("");return o(()=>{let e=c.current;if(!e)return"";let u=e.innerText;if(t.current===u)return r.current;let n=i(e).trim().toLowerCase();return t.current=u,r.current=n,n})}export{b as useTextValue};

node_modules/@headlessui/react/dist/hooks/use-tracked-pointer.d.ts

@@ -0,0 +1,4 @@
+export declare function useTrackedPointer(): {
+    wasMoved(evt: PointerEvent): boolean;
+    update(evt: PointerEvent): void;
+};

node_modules/@headlessui/react/dist/hooks/use-tracked-pointer.js

@@ -0,0 +1 @@
+import{useRef as o}from"react";function t(e){return[e.screenX,e.screenY]}function u(){let e=o([-1,-1]);return{wasMoved(r){let n=t(r);return e.current[0]===n[0]&&e.current[1]===n[1]?!1:(e.current=n,!0)},update(r){e.current=t(r)}}}export{u as useTrackedPointer};

node_modules/@headlessui/react/dist/hooks/use-transition.d.ts

@@ -0,0 +1,20 @@
+import { MutableRefObject } from 'react';
+interface TransitionArgs {
+    immediate: boolean;
+    container: MutableRefObject<HTMLElement | null>;
+    classes: MutableRefObject<{
+        base: string[];
+        enter: string[];
+        enterFrom: string[];
+        enterTo: string[];
+        leave: string[];
+        leaveFrom: string[];
+        leaveTo: string[];
+        entered: string[];
+    }>;
+    direction: 'enter' | 'leave' | 'idle';
+    onStart: MutableRefObject<(direction: TransitionArgs['direction']) => void>;
+    onStop: MutableRefObject<(direction: TransitionArgs['direction']) => void>;
+}
+export declare function useTransition({ immediate, container, direction, classes, onStart, onStop, }: TransitionArgs): void;
+export {};

node_modules/@headlessui/react/dist/hooks/use-transition.js

@@ -0,0 +1 @@
+import{transition as f}from'../components/transitions/utils/transition.js';import{disposables as m}from'../utils/disposables.js';import{useDisposables as p}from'./use-disposables.js';import{useIsMounted as b}from'./use-is-mounted.js';import{useIsoMorphicEffect as o}from'./use-iso-morphic-effect.js';import{useLatestValue as g}from'./use-latest-value.js';function E({immediate:t,container:s,direction:n,classes:u,onStart:a,onStop:c}){let l=b(),d=p(),e=g(n);o(()=>{t&&(e.current="enter")},[t]),o(()=>{let r=m();d.add(r.dispose);let i=s.current;if(i&&e.current!=="idle"&&l.current)return r.dispose(),a.current(e.current),r.add(f(i,u.current,e.current==="enter",()=>{r.dispose(),c.current(e.current)})),r.dispose},[n])}export{E as useTransition};

node_modules/@headlessui/react/dist/hooks/use-tree-walker.d.ts

@@ -0,0 +1,8 @@
+type AcceptNode = (node: HTMLElement) => typeof NodeFilter.FILTER_ACCEPT | typeof NodeFilter.FILTER_SKIP | typeof NodeFilter.FILTER_REJECT;
+export declare function useTreeWalker({ container, accept, walk, enabled, }: {
+    container: HTMLElement | null;
+    accept: AcceptNode;
+    walk(node: HTMLElement): void;
+    enabled?: boolean;
+}): void;
+export {};

node_modules/@headlessui/react/dist/hooks/use-tree-walker.js

@@ -0,0 +1 @@
+import{useRef as E,useEffect as m}from"react";import{useIsoMorphicEffect as T}from'./use-iso-morphic-effect.js';import{getOwnerDocument as N}from'../utils/owner.js';function F({container:e,accept:t,walk:r,enabled:c=!0}){let o=E(t),l=E(r);m(()=>{o.current=t,l.current=r},[t,r]),T(()=>{if(!e||!c)return;let n=N(e);if(!n)return;let f=o.current,p=l.current,d=Object.assign(i=>f(i),{acceptNode:f}),u=n.createTreeWalker(e,NodeFilter.SHOW_ELEMENT,d,!1);for(;u.nextNode();)p(u.currentNode)},[e,c,o,l])}export{F as useTreeWalker};

node_modules/@headlessui/react/dist/hooks/use-watch.d.ts

@@ -0,0 +1 @@
+export declare function useWatch<T extends any[]>(cb: (newValues: [...T], oldValues: [...T]) => void | (() => void), dependencies: [...T]): void;