@funstack/ui 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/combobox/combobox-popup.d.mts

@@ -0,0 +1,49 @@
+import { RenderProp, StateValue } from "../internal/types.mjs";
+import { CSSProperties, ComponentPropsWithRef, ReactNode, ViewTransitionClass } from "react";
+//#region src/combobox/combobox-popup.d.ts
+export interface ComboboxPopupState {
+  /** Committed open state. Read `:popover-open` for the DOM truth. */
+  readonly open: boolean;
+  /** The results shown are for an older text. */
+  readonly stale: boolean;
+  /** The deferred text the results are for. */
+  readonly query: string;
+}
+export interface ComboboxPopupProps extends Omit<ComponentPropsWithRef<"div">, "id" | "popover" | "onToggle" | "onBeforeToggle" | "onPointerDown" | "onMouseDown" | "className" | "style" | "children"> {
+  /**
+   * `false` (default): the children are not rendered while the listbox is closed. `true`: they
+   * stay mounted inside `<Activity mode="hidden">`.
+   */
+  keepMounted?: boolean;
+  /**
+   * Forwarded to the `<ViewTransition default>` around the popover element itself. Animates
+   * library-driven opens and closes (typing, the Trigger, an accepted option) in every engine;
+   * dismissals are the browser's (CSS only). **A deferred results render also activates the
+   * boundary** (React: updates from `useDeferredValue` animate), so use a type map with
+   * `default: "none"` unless every result change should cross-fade. Static.
+   */
+  transition?: ViewTransitionClass;
+  className?: StateValue<string | undefined, ComboboxPopupState>;
+  style?: StateValue<CSSProperties | undefined, ComboboxPopupState>;
+  children?: StateValue<ReactNode, ComboboxPopupState>;
+  /** Must render a `<div>`: a `<dialog>` would pull focus out of the input. */
+  render?: RenderProp<ComponentPropsWithRef<"div">, ComboboxPopupState>;
+}
+/**
+ * The listbox's container: `<div popover="auto">`, opened by the library with
+ * `showPopover({ source: input })` and placed below (or, flipped, above) the input with CSS
+ * Anchor Positioning, at least as wide as the input. Focus never enters it: a press anywhere in
+ * it is `preventDefault()`ed so the input keeps focus (design 7.1). Holds the `List` and, outside
+ * it, `Empty` and `Status`. Style it with `:popover-open`; it emits `data-stale` but no
+ * `data-open`.
+ *
+ * Owned keys (conventions 1.2): `id`, `popover`, `onPointerDown`, `onMouseDown`, `data-stale`.
+ * Inline `position-area`, `position-try-fallbacks` and `min-width` sit under the consumer's
+ * `style` (`style={{ positionTryFallbacks: "none" }}` removes the flip).
+ */
+export declare function ComboboxPopup({ keepMounted, transition, className, style, children, render, ...rest }: ComboboxPopupProps): ReactNode;
+export declare namespace ComboboxPopup {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=combobox-popup.d.mts.map

package/dist/combobox/combobox-popup.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combobox-popup.d.mts","names":[],"sources":["../../src/combobox/combobox-popup.tsx"],"mappings":";;;iBAmBiB;;WAEN;;WAEA;;WAEA;;iBAGM,2BAA2B,KAC1C;;;;;EAeA;;;;;;;;EAQA,aAAa;EACb,YAAY,+BAA+B;EAC3C,QAAQ,WAAW,2BAA2B;EAC9C,WAAW,WAAW,WAAW;;EAEjC,SAAS,WAAW,8BAA8B;;;;;;;;;;;;;;wBAmBpC,gBACd,aACA,YACA,WACA,OACA,UACA,WACG,QACF,qBAAkB;yBARL"}

package/dist/combobox/combobox-popup.mjs

@@ -0,0 +1,86 @@
+"use client";
+import { useTransitionBoundary } from "../internal/transition-boundary.mjs";
+import { dataAttr } from "../internal/data-attr.mjs";
+import { mergeRefs } from "../internal/merge-props.mjs";
+import { resolveStateValue, useRender } from "../internal/use-render.mjs";
+import { usePopoverPopup } from "../internal/use-popover-popup.mjs";
+import { ComboboxPopupContext, useComboboxContext } from "./combobox-context.mjs";
+import { Activity, useCallback, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/combobox/combobox-popup.tsx
+const isDev = process.env.NODE_ENV !== "production";
+const preventDefault = (event) => event.preventDefault();
+/**
+* The listbox's container: `<div popover="auto">`, opened by the library with
+* `showPopover({ source: input })` and placed below (or, flipped, above) the input with CSS
+* Anchor Positioning, at least as wide as the input. Focus never enters it: a press anywhere in
+* it is `preventDefault()`ed so the input keeps focus (design 7.1). Holds the `List` and, outside
+* it, `Empty` and `Status`. Style it with `:popover-open`; it emits `data-stale` but no
+* `data-open`.
+*
+* Owned keys (conventions 1.2): `id`, `popover`, `onPointerDown`, `onMouseDown`, `data-stale`.
+* Inline `position-area`, `position-try-fallbacks` and `min-width` sit under the consumer's
+* `style` (`style={{ positionTryFallbacks: "none" }}` removes the flip).
+*/
+function ComboboxPopup({ keepMounted, transition, className, style, children, render, ...rest }) {
+	const ctx = useComboboxContext("Combobox.Popup");
+	const { popover } = ctx;
+	const { setElement, visible, wrapContent } = usePopoverPopup(popover, {
+		part: "Combobox.Popup",
+		initialFocus: void 0,
+		resolveInitialFocus: () => null,
+		keepMounted,
+		transition
+	});
+	const devRef = useCallback((element) => {
+		if (isDev && element.tagName !== "DIV") console.error(`Combobox.Popup: rendered a <${element.tagName.toLowerCase()}>. Render a <div>: a <dialog popover> runs the dialog focusing steps and takes focus out of the input.`);
+		return () => {};
+	}, []);
+	const ref = useMemo(() => mergeRefs(setElement, devRef), [setElement, devRef]);
+	const state = {
+		open: popover.committed,
+		stale: ctx.stale,
+		query: ctx.query
+	};
+	const libraryProps = {
+		id: popover.ids.popup,
+		popover: "auto",
+		onPointerDown: (event) => preventDefault(event),
+		onMouseDown: (event) => preventDefault(event),
+		"data-stale": dataAttr(ctx.stale)
+	};
+	const content = (s) => {
+		let node;
+		if (keepMounted === true) node = /* @__PURE__ */ jsx(Activity, {
+			mode: visible ? "visible" : "hidden",
+			children: wrapContent(resolveStateValue(children, s))
+		});
+		else node = visible ? wrapContent(resolveStateValue(children, s)) : null;
+		return /* @__PURE__ */ jsx(ComboboxPopupContext, {
+			value: true,
+			children: node
+		});
+	};
+	const element = useRender({
+		defaultElement: "div",
+		render,
+		state,
+		className,
+		style: (s) => ({
+			positionArea: "block-end span-inline-end",
+			positionTryFallbacks: "flip-block",
+			minWidth: "anchor-size(width)",
+			...resolveStateValue(style, s)
+		}),
+		children: content,
+		props: rest,
+		libraryProps,
+		ref
+	});
+	return useTransitionBoundary("Combobox.Popup", transition, element);
+}
+ComboboxPopup.displayName = "ComboboxPopup";
+//#endregion
+export { ComboboxPopup };
+
+//# sourceMappingURL=combobox-popup.mjs.map

package/dist/combobox/combobox-popup.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"combobox-popup.mjs","names":[],"sources":["../../src/combobox/combobox-popup.tsx"],"sourcesContent":["\"use client\";\nimport { Activity, useCallback, useMemo } from \"react\";\nimport type {\n  ComponentPropsWithRef,\n  CSSProperties,\n  MouseEvent,\n  PointerEvent,\n  ReactNode,\n  ViewTransitionClass,\n} from \"react\";\nimport { dataAttr } from \"../internal/data-attr.js\";\nimport { mergeRefs } from \"../internal/merge-props.js\";\nimport { useTransitionBoundary } from \"../internal/transition-boundary.js\";\nimport type { RenderProp, StateValue } from \"../internal/types.js\";\nimport { usePopoverPopup } from \"../internal/use-popover-popup.js\";\nimport { resolveStateValue, useRender } from \"../internal/use-render.js\";\nimport type { DataAttributes } from \"../internal/use-render.js\";\nimport { ComboboxPopupContext, useComboboxContext } from \"./combobox-context.js\";\n\nexport interface ComboboxPopupState {\n  /** Committed open state. Read `:popover-open` for the DOM truth. */\n  readonly open: boolean;\n  /** The results shown are for an older text. */\n  readonly stale: boolean;\n  /** The deferred text the results are for. */\n  readonly query: string;\n}\n\nexport interface ComboboxPopupProps extends Omit<\n  ComponentPropsWithRef<\"div\">,\n  | \"id\"\n  | \"popover\"\n  | \"onToggle\"\n  | \"onBeforeToggle\"\n  | \"onPointerDown\"\n  | \"onMouseDown\"\n  | \"className\"\n  | \"style\"\n  | \"children\"\n> {\n  /**\n   * `false` (default): the children are not rendered while the listbox is closed. `true`: they\n   * stay mounted inside `<Activity mode=\"hidden\">`.\n   */\n  keepMounted?: boolean;\n  /**\n   * Forwarded to the `<ViewTransition default>` around the popover element itself. Animates\n   * library-driven opens and closes (typing, the Trigger, an accepted option) in every engine;\n   * dismissals are the browser's (CSS only). **A deferred results render also activates the\n   * boundary** (React: updates from `useDeferredValue` animate), so use a type map with\n   * `default: \"none\"` unless every result change should cross-fade. Static.\n   */\n  transition?: ViewTransitionClass;\n  className?: StateValue<string | undefined, ComboboxPopupState>;\n  style?: StateValue<CSSProperties | undefined, ComboboxPopupState>;\n  children?: StateValue<ReactNode, ComboboxPopupState>;\n  /** Must render a `<div>`: a `<dialog>` would pull focus out of the input. */\n  render?: RenderProp<ComponentPropsWithRef<\"div\">, ComboboxPopupState>;\n}\n\nconst isDev = process.env.NODE_ENV !== \"production\";\n\nconst preventDefault = (event: { preventDefault(): void }) => event.preventDefault();\n\n/**\n * The listbox's container: `<div popover=\"auto\">`, opened by the library with\n * `showPopover({ source: input })` and placed below (or, flipped, above) the input with CSS\n * Anchor Positioning, at least as wide as the input. Focus never enters it: a press anywhere in\n * it is `preventDefault()`ed so the input keeps focus (design 7.1). Holds the `List` and, outside\n * it, `Empty` and `Status`. Style it with `:popover-open`; it emits `data-stale` but no\n * `data-open`.\n *\n * Owned keys (conventions 1.2): `id`, `popover`, `onPointerDown`, `onMouseDown`, `data-stale`.\n * Inline `position-area`, `position-try-fallbacks` and `min-width` sit under the consumer's\n * `style` (`style={{ positionTryFallbacks: \"none\" }}` removes the flip).\n */\nexport function ComboboxPopup({\n  keepMounted,\n  transition,\n  className,\n  style,\n  children,\n  render,\n  ...rest\n}: ComboboxPopupProps) {\n  const ctx = useComboboxContext(\"Combobox.Popup\");\n  const { popover } = ctx;\n\n  const { setElement, visible, wrapContent } = usePopoverPopup(popover, {\n    part: \"Combobox.Popup\",\n    initialFocus: undefined,\n    // Focus stays in the input: nothing inside the popup is ever focused.\n    resolveInitialFocus: () => null,\n    keepMounted,\n    transition,\n  });\n\n  const devRef = useCallback((element: HTMLElement) => {\n    if (isDev && element.tagName !== \"DIV\") {\n      console.error(\n        `Combobox.Popup: rendered a <${element.tagName.toLowerCase()}>. Render a <div>: a ` +\n          \"<dialog popover> runs the dialog focusing steps and takes focus out of the input.\",\n      );\n    }\n    return () => {};\n  }, []);\n  const ref = useMemo(() => mergeRefs(setElement, devRef), [setElement, devRef]);\n\n  const state: ComboboxPopupState = {\n    open: popover.committed,\n    stale: ctx.stale,\n    query: ctx.query,\n  };\n\n  const libraryProps: ComponentPropsWithRef<\"div\"> & DataAttributes = {\n    id: popover.ids.popup,\n    popover: \"auto\",\n    onPointerDown: (event: PointerEvent<HTMLDivElement>) => preventDefault(event),\n    onMouseDown: (event: MouseEvent<HTMLDivElement>) => preventDefault(event),\n    \"data-stale\": dataAttr(ctx.stale),\n  };\n\n  const content = (s: ComboboxPopupState): ReactNode => {\n    let node: ReactNode;\n    if (keepMounted === true) {\n      node = (\n        <Activity mode={visible ? \"visible\" : \"hidden\"}>\n          {wrapContent(resolveStateValue(children, s))}\n        </Activity>\n      );\n    } else {\n      node = visible ? wrapContent(resolveStateValue(children, s)) : null;\n    }\n    return <ComboboxPopupContext value={true}>{node}</ComboboxPopupContext>;\n  };\n\n  const element = useRender<ComponentPropsWithRef<\"div\">, ComboboxPopupState>({\n    defaultElement: \"div\",\n    render,\n    state,\n    className,\n    // Logical keywords: right under `direction: rtl` with no JS (design 7.2). The consumer wins.\n    style: (s) => ({\n      positionArea: \"block-end span-inline-end\",\n      positionTryFallbacks: \"flip-block\",\n      minWidth: \"anchor-size(width)\",\n      ...resolveStateValue(style, s),\n    }),\n    children: content,\n    props: rest,\n    libraryProps,\n    ref,\n  });\n\n  return useTransitionBoundary(\"Combobox.Popup\", transition, element);\n}\n\nComboboxPopup.displayName = \"ComboboxPopup\";\n"],"mappings":";;;;;;;;;;AA4DA,MAAM,QAAQ,QAAQ,IAAI,aAAa;AAEvC,MAAM,kBAAkB,UAAsC,MAAM,eAAe;;;;;;;;;;;;;AAcnF,SAAgB,cAAc,EAC5B,aACA,YACA,WACA,OACA,UACA,QACA,GAAG,QACkB;CACrB,MAAM,MAAM,mBAAmB,gBAAgB;CAC/C,MAAM,EAAE,YAAY;CAEpB,MAAM,EAAE,YAAY,SAAS,gBAAgB,gBAAgB,SAAS;EACpE,MAAM;EACN,cAAc,KAAA;EAEd,2BAA2B;EAC3B;EACA;CACF,CAAC;CAED,MAAM,SAAS,aAAa,YAAyB;EACnD,IAAI,SAAS,QAAQ,YAAY,OAC/B,QAAQ,MACN,+BAA+B,QAAQ,QAAQ,YAAY,EAAE,uGAE/D;EAEF,aAAa,CAAC;CAChB,GAAG,CAAC,CAAC;CACL,MAAM,MAAM,cAAc,UAAU,YAAY,MAAM,GAAG,CAAC,YAAY,MAAM,CAAC;CAE7E,MAAM,QAA4B;EAChC,MAAM,QAAQ;EACd,OAAO,IAAI;EACX,OAAO,IAAI;CACb;CAEA,MAAM,eAA8D;EAClE,IAAI,QAAQ,IAAI;EAChB,SAAS;EACT,gBAAgB,UAAwC,eAAe,KAAK;EAC5E,cAAc,UAAsC,eAAe,KAAK;EACxE,cAAc,SAAS,IAAI,KAAK;CAClC;CAEA,MAAM,WAAW,MAAqC;EACpD,IAAI;EACJ,IAAI,gBAAgB,MAClB,OACE,oBAAC,UAAD;GAAU,MAAM,UAAU,YAAY;GACnC,UAAA,YAAY,kBAAkB,UAAU,CAAC,CAAC;EACnC,CAAA;OAGZ,OAAO,UAAU,YAAY,kBAAkB,UAAU,CAAC,CAAC,IAAI;EAEjE,OAAO,oBAAC,sBAAD;GAAsB,OAAO;GAAO,UAAA;EAA2B,CAAA;CACxE;CAEA,MAAM,UAAU,UAA4D;EAC1E,gBAAgB;EAChB;EACA;EACA;EAEA,QAAQ,OAAO;GACb,cAAc;GACd,sBAAsB;GACtB,UAAU;GACV,GAAG,kBAAkB,OAAO,CAAC;EAC/B;EACA,UAAU;EACV,OAAO;EACP;EACA;CACF,CAAC;CAED,OAAO,sBAAsB,kBAAkB,YAAY,OAAO;AACpE;AAEA,cAAc,cAAc"}

package/dist/combobox/combobox-root.d.mts

@@ -0,0 +1,135 @@
+import { ActionDetails, ChangeAction, ChangeReason, StateValue, UrgentChangeAction } from "../internal/types.mjs";
+import { ReactNode } from "react";
+//#region src/combobox/combobox-root.d.ts
+/** Details passed as the second argument of `Combobox.Root`'s `valueChangeAction`. */
+export interface ComboboxValueChangeDetails extends ActionDetails {
+  /**
+   * `"activate"`: the user accepted an option (Enter, click; `details.event` is the `keydown` or
+   * `click`), committed free text with `allowCustomValue` (Enter: the `keydown`; focus leaving:
+   * the `focusout`), or pressed Clear (`click`).
+   * `"platform"`: a form reset (`details.event` is the `reset` event).
+   */
+  readonly reason: ChangeReason;
+  /** `true` when `next` is free text committed under `allowCustomValue`, not an option's value. */
+  readonly custom: boolean;
+}
+/** Details passed as the second argument of `Combobox.Root`'s `inputValueChangeAction`. */
+export interface ComboboxInputValueChangeDetails extends ActionDetails {
+  /**
+   * `"activate"`: typing (the `input` event), an accepted option's label, Clear.
+   * `"dismiss"`: a revert: focus left with unmatched text, or the selection rolled back.
+   * `"platform"`: form reset (the `reset` event), or text found in the input at mount
+   * (`undefined`).
+   */
+  readonly reason: ChangeReason;
+}
+/** Details passed as the second argument of `Combobox.Root`'s `openChangeAction`. */
+export interface ComboboxOpenChangeDetails extends ActionDetails {
+  /**
+   * `"activate"`: typing, ArrowDown / ArrowUp / Alt+ArrowDown, the Trigger, a click on the input
+   * with `openOnClick`, an accepted option (the close after it), a foreign `showPopover()`.
+   * `"dismiss"`: Escape, light dismiss, focus leaving the combobox, another top-layer element.
+   * `"platform"`: the popup was found open on mount (only script can cause it).
+   */
+  readonly reason: ChangeReason;
+}
+export interface ComboboxRootState {
+  /** Optimistic selection. Content rendered from it must not suspend. */
+  readonly value: string | null;
+  /** The text in the input (urgent). */
+  readonly inputValue: string;
+  /** The deferred text the mounted results are for. */
+  readonly query: string;
+  /** `inputValue !== query`: the results shown are for an older text. */
+  readonly stale: boolean;
+  /** The value of the option `aria-activedescendant` points at, or `null`. */
+  readonly activeValue: string | null;
+  /** Optimistic open state. */
+  readonly open: boolean;
+  /** A `valueChangeAction` or `openChangeAction` dispatched through this Combobox is in flight. */
+  readonly pending: boolean;
+  readonly disabled: boolean;
+}
+export interface ComboboxRootProps {
+  /** Controlled selection. `null`: nothing selected. `undefined`: uncontrolled. */
+  value?: string | null;
+  /** Initial selection in uncontrolled mode. Default `null`. */
+  defaultValue?: string | null;
+  /**
+   * Runs inside the Root's transition when the user accepts an option, commits free text
+   * (`allowCustomValue`), presses Clear, or the form resets. Awaited; the listbox closes in the
+   * commit that ends it; a rejection rolls the input text and `data-selected` back and leaves
+   * the listbox open. May be a Server Function. A `setState` after your own `await` needs
+   * `startTransition`.
+   */
+  valueChangeAction?: ChangeAction<string | null, ComboboxValueChangeDetails>;
+  /** Controlled input text. `undefined`: uncontrolled. */
+  inputValue?: string;
+  /**
+   * Initial input text. Default `""`. Pass the selected value's label when `defaultValue` is
+   * set: the library never derives the text from the value.
+   */
+  defaultInputValue?: string;
+  /**
+   * The urgent lane: called synchronously, outside any Transition, on every change of the text
+   * (typing, and the library's own writes: an accepted option's label, a revert, Clear, a form
+   * reset, text typed before hydration). Not awaited; nothing is pending for it. A controlled
+   * parent updates its state in the body (an urgent update, which is what a controlled text
+   * input needs).
+   */
+  inputValueChangeAction?: UrgentChangeAction<string, ComboboxInputValueChangeDetails>;
+  /** Controlled open state. `undefined`: uncontrolled. */
+  open?: boolean;
+  /** Initial open state when uncontrolled. Opens after hydration. */
+  defaultOpen?: boolean;
+  /**
+   * Awaited for opens and for the close after an accepted option (or the Trigger); a
+   * notification for dismissals (Escape, a click outside, focus leaving).
+   */
+  openChangeAction?: ChangeAction<boolean, ComboboxOpenChangeDetails>;
+  /**
+   * Free text is a value: Enter with no active option, or focus leaving with text that is not
+   * the selected option's label, dispatches the text with `details.custom: true` (empty text
+   * dispatches `null`). Default `false`: unmatched text reverts to the selection's label when
+   * focus leaves.
+   */
+  allowCustomValue?: boolean;
+  /**
+   * Make the first enabled option active when the results for an open or an edit settle (APG
+   * "automatic selection"). Stale results are never highlighted. Default `false`.
+   */
+  autoHighlight?: boolean;
+  /** Open the listbox on a pointer click in the input (not on focus). Default `false`. */
+  openOnClick?: boolean;
+  /** Wrap from the last option to the first and back with the arrow keys. Default `false`. */
+  loop?: boolean;
+  /**
+   * The message `ariaNotify()` announces on the List when the results settle, from the number
+   * of mounted options. Default (English): `"No results"`, `"1 result"`, `"N results"`. Override
+   * for localisation or a richer message; return `null` to announce nothing. Ignored where
+   * `ariaNotify` is missing.
+   */
+  announce?: (count: number, state: ComboboxRootState) => string | null;
+  /** Form participation through a hidden input with this name (value `""` for `null`). */
+  name?: string;
+  /** The `form` attribute of the hidden input. */
+  form?: string;
+  /** Disables the Input, Trigger and Clear; nothing dispatches for user interaction. */
+  disabled?: boolean;
+  children?: StateValue<ReactNode, ComboboxRootState>;
+}
+/**
+ * Owns the two states of a combobox (design/components/combobox.md 2): the selection (`value`,
+ * a transition with `useOptimistic`, like every other value) and the text (`inputValue`, the
+ * library's **urgent** lane: `inputValueChangeAction` is called synchronously, outside any
+ * transition). The results render from `useDeferredValue(inputValue)`; the active option is
+ * urgent virtual focus (`aria-activedescendant`); the listbox is a `popover="auto"` opened by the
+ * library with the input as `source`. Renders no DOM, except one `<input type="hidden">` when
+ * `name` is given.
+ */
+export declare function ComboboxRoot(props: ComboboxRootProps): import("react").JSX.Element;
+export declare namespace ComboboxRoot {
+  var displayName: string;
+}
+//#endregion
+//# sourceMappingURL=combobox-root.d.mts.map

package/dist/combobox/combobox-root.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combobox-root.d.mts","names":[],"sources":["../../src/combobox/combobox-root.tsx"],"mappings":";;;;iBAmCiB,mCAAmC;;;;;;;WAOzC,QAAQ;;WAER;;;iBAIM,wCAAwC;;;;;;;WAO9C,QAAQ;;;iBAIF,kCAAkC;;;;;;;WAOxC,QAAQ;;iBAGF;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;;iBAGM;;EAEf;;EAEA;;;;;;;;EAQA,oBAAoB,4BAA4B;;EAGhD;;;;;EAKA;;;;;;;;EAQA,yBAAyB,2BAA2B;;EAGpD;;EAEA;;;;;EAKA,mBAAmB,sBAAsB;;;;;;;EAQzC;;;;;EAKA;;EAEA;;EAEA;;;;;;;EAOA,YAAY,eAAe,OAAO;;EAGlC;;EAEA;;EAEA;EACA,WAAW,WAAW,WAAW;;;;;;;;;;;wBA+DnB,aAAa,OAAO,oCAAiB,IAAA;yBAArC"}