@ariakit/react-components 0.1.0

package/dist/group/group.js

@@ -0,0 +1,47 @@
+"use client";
+import { GroupLabelContext } from "./group-label-context.js";
+import { createElement, createHook, forwardRef, useWrapElement } from "@ariakit/react-utils";
+import { removeUndefinedValues } from "@ariakit/utils";
+import { useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/group/group.tsx
+const TagName = "div";
+/**
+* Returns props to create a `Group` component.
+* @see https://ariakit.com/components/group
+* @example
+* ```jsx
+* const props = useGroup();
+* <Role {...props}>Group</Role>
+* ```
+*/
+const useGroup = createHook(function useGroup(props) {
+	const [labelId, setLabelId] = useState();
+	props = useWrapElement(props, (element) => /* @__PURE__ */ jsx(GroupLabelContext.Provider, {
+		value: setLabelId,
+		children: element
+	}), []);
+	props = {
+		role: "group",
+		"aria-labelledby": props["aria-label"] != null ? void 0 : labelId,
+		...props
+	};
+	return removeUndefinedValues(props);
+});
+/**
+* Renders a group element. Optionally, a
+* [`GroupLabel`](https://ariakit.com/reference/group-label) can be rendered as
+* a child to provide a label for the group.
+* @see https://ariakit.com/components/group
+* @example
+* ```jsx
+* <Group>Group</Group>
+* ```
+*/
+const Group = forwardRef(function Group(props) {
+	return createElement(TagName, useGroup(props));
+});
+//#endregion
+export { Group, useGroup };
+
+//# sourceMappingURL=group.js.map

package/dist/group/group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.js","names":[],"sources":["../../src/group/group.tsx"],"sourcesContent":["import {\n  useWrapElement,\n  createElement,\n  createHook,\n  forwardRef,\n} from \"@ariakit/react-utils\";\nimport type { Options, Props } from \"@ariakit/react-utils\";\nimport { removeUndefinedValues } from \"@ariakit/utils\";\nimport type { ElementType } from \"react\";\nimport { useState } from \"react\";\nimport { GroupLabelContext } from \"./group-label-context.tsx\";\n\nconst TagName = \"div\" satisfies ElementType;\ntype TagName = typeof TagName;\n\n/**\n * Returns props to create a `Group` component.\n * @see https://ariakit.com/components/group\n * @example\n * ```jsx\n * const props = useGroup();\n * <Role {...props}>Group</Role>\n * ```\n */\nexport const useGroup = createHook<TagName, GroupOptions>(\n  function useGroup(props) {\n    const [labelId, setLabelId] = useState<string>();\n\n    props = useWrapElement(\n      props,\n      (element) => (\n        <GroupLabelContext.Provider value={setLabelId}>\n          {element}\n        </GroupLabelContext.Provider>\n      ),\n      [],\n    );\n\n    props = {\n      role: \"group\",\n      \"aria-labelledby\": props[\"aria-label\"] != null ? undefined : labelId,\n      ...props,\n    };\n\n    return removeUndefinedValues(props);\n  },\n);\n\n/**\n * Renders a group element. Optionally, a\n * [`GroupLabel`](https://ariakit.com/reference/group-label) can be rendered as\n * a child to provide a label for the group.\n * @see https://ariakit.com/components/group\n * @example\n * ```jsx\n * <Group>Group</Group>\n * ```\n */\nexport const Group = forwardRef(function Group(props: GroupProps) {\n  const htmlProps = useGroup(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport type GroupOptions<_T extends ElementType = TagName> = Options;\n\nexport type GroupProps<T extends ElementType = TagName> = Props<\n  T,\n  GroupOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;MA0BI,WAAgB,WAAA,SAAc,SAAiB,OAAA;CAE/C,MAAA,CAAA,SAAQ,cACN,SACC;SACoC,eAAA,QAAA,YAAA,oBAAA,kBAAA,UAAA;;EAEP,UAGhC;CAEA,CAAA,GAAA,CAAA,CAAA;SACQ;EACN,MAAA;EACA,mBAAG,MAAA,iBAAA,OAAA,KAAA,IAAA;EACL,GAAA;CAEA;CAEJ,OAAA,sBAAA,KAAA;;;;;;;;;;;;MAcE,QAAO,WAAc,SADH,MAAS,OACY;CACxC,OAAA,cAAA,SAAA,SAAA,KAAA,CAAA"}

package/dist/group-CamegDJA.d.ts

@@ -0,0 +1,32 @@
+import { Options, Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/group/group.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `Group` component.
+ * @see https://ariakit.com/components/group
+ * @example
+ * ```jsx
+ * const props = useGroup();
+ * <Role {...props}>Group</Role>
+ * ```
+ */
+declare const useGroup: import("@ariakit/react-utils").Hook<"div", Options>;
+/**
+ * Renders a group element. Optionally, a
+ * [`GroupLabel`](https://ariakit.com/reference/group-label) can be rendered as
+ * a child to provide a label for the group.
+ * @see https://ariakit.com/components/group
+ * @example
+ * ```jsx
+ * <Group>Group</Group>
+ * ```
+ */
+declare const Group: (props: GroupProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+type GroupOptions<_T extends ElementType = TagName> = Options;
+type GroupProps<T extends ElementType = TagName> = Props<T, GroupOptions<T>>;
+//#endregion
+export { useGroup as i, GroupOptions as n, GroupProps as r, Group as t };
+//# sourceMappingURL=group-CamegDJA.d.ts.map

package/dist/group-CamegDJA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-CamegDJA.d.ts","names":["Options","Props","ElementType","TagName","useGroup","Hook","Group","GroupProps","props","ReactElement","JSXElementConstructor","GroupOptions","_T","T"],"sources":["../src/group/group.d.ts"],"mappings":";;;;cAEcG,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFY;;;;AACpB;AAAA;;;;AADoB,cAYpBC,QAAAA,iCAAyCC,IAAAA,QAAYL,OAAO;AAAjF;;;;AAAiF;AAWjF;;;;;AAXA,cAWqBM,KAAAA,GAAQE,KAAAA,EAAOD,UAAU,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,KAClGC,YAAAA,YAAwBT,WAAAA,GAAcC,OAAAA,IAAWH,OAAAA;AAAAA,KACjDO,UAAAA,WAAqBL,WAAAA,GAAcC,OAAAA,IAAWF,KAAAA,CAAMY,CAAAA,EAAGF,YAAAA,CAAaE,CAAAA"}

package/dist/group-label-C16IDs1b.d.ts

@@ -0,0 +1,37 @@
+import { Options, Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/group/group-label.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `GroupLabel` component. This hook must be used in a
+ * component that's wrapped with `Group` so the `aria-labelledby` prop is
+ * properly set on the group element.
+ * @see https://ariakit.com/components/group
+ * @example
+ * ```jsx
+ * // This component must be wrapped with Group
+ * const props = useGroupLabel();
+ * <Role {...props}>Label</Role>
+ * ```
+ */
+declare const useGroupLabel: import("@ariakit/react-utils").Hook<"div", GroupLabelOptions<"div">>;
+/**
+ * Renders a label in a group. This component should be wrapped with a
+ * [`Group`](https://ariakit.com/reference/group) so the `aria-labelledby`
+ * prop is correctly set on the group element.
+ * @see https://ariakit.com/components/group
+ * @example
+ * ```jsx
+ * <Group>
+ *   <GroupLabel>Label</GroupLabel>
+ * </Group>
+ * ```
+ */
+declare const GroupLabel: (props: GroupLabelProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface GroupLabelOptions<_T extends ElementType = TagName> extends Options {}
+type GroupLabelProps<T extends ElementType = TagName> = Props<T, GroupLabelOptions<T>>;
+//#endregion
+export { useGroupLabel as i, GroupLabelOptions as n, GroupLabelProps as r, GroupLabel as t };
+//# sourceMappingURL=group-label-C16IDs1b.d.ts.map

package/dist/group-label-C16IDs1b.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-label-C16IDs1b.d.ts","names":["Options","Props","ElementType","TagName","useGroupLabel","GroupLabelOptions","Hook","GroupLabel","GroupLabelProps","props","ReactElement","JSXElementConstructor","_T","T"],"sources":["../src/group/group-label.d.ts"],"mappings":";;;;cAEcG,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAFY;;;;AACpB;AAAA;;;;AACQ;AAa7B;;AAfyC,cAepBC,aAAAA,iCAA8CE,IAAAA,QAAYD,iBAAiB;;AAAA;AAahG;;;;;;;;;AAA6I;cAAxHE,UAAAA,GAAaE,KAAAA,EAAOD,eAAe,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACvGN,iBAAAA,YAA6BH,WAAAA,GAAcC,OAAAA,UAAiBH,OAAAA;AAAAA,KAEjEQ,eAAAA,WAA0BN,WAAAA,GAAcC,OAAAA,IAAWF,KAAAA,CAAMY,CAAAA,EAAGR,iBAAAA,CAAkBQ,CAAAA"}

package/dist/heading/heading-context.d.ts

@@ -0,0 +1,7 @@
+import { t as HeadingLevels } from "../utils-DUF1aMov.js";
+
+//#region src/heading/heading-context.d.ts
+declare const HeadingContext: import("react").Context<0 | HeadingLevels>;
+//#endregion
+export { HeadingContext };
+//# sourceMappingURL=heading-context.d.ts.map

package/dist/heading/heading-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading-context.d.ts","names":["HeadingLevels","HeadingContext","Context"],"sources":["../../src/heading/heading-context.d.ts"],"mappings":";;;cACqBC,cAAAA,kBAAgCC,OAAAA,KAAYF,aAAa"}

package/dist/heading/heading-context.js

@@ -0,0 +1,8 @@
+"use client";
+import { createContext } from "react";
+//#region src/heading/heading-context.tsx
+const HeadingContext = createContext(0);
+//#endregion
+export { HeadingContext };
+
+//# sourceMappingURL=heading-context.js.map

package/dist/heading/heading-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading-context.js","names":[],"sources":["../../src/heading/heading-context.tsx"],"sourcesContent":["import { createContext } from \"react\";\nimport type { HeadingLevels } from \"./utils.ts\";\n\nexport const HeadingContext = createContext<HeadingLevels | 0>(0);\n"],"mappings":""}

package/dist/heading/heading-level.d.ts

@@ -0,0 +1,35 @@
+import { t as HeadingLevels } from "../utils-DUF1aMov.js";
+import { ReactNode } from "react";
+
+//#region src/heading/heading-level.d.ts
+/**
+ * A component that sets the heading level for its children. It doesn't render
+ * any HTML element, just sets the
+ * [`level`](https://ariakit.com/reference/heading-level#level) prop on the
+ * context.
+ * @see https://ariakit.com/components/heading
+ * @example
+ * ```jsx
+ * <HeadingLevel>
+ *   <Heading>Heading 1</Heading>
+ *   <HeadingLevel>
+ *     <Heading>Heading 2</Heading>
+ *   </HeadingLevel>
+ * </HeadingLevel>
+ * ```
+ */
+declare function HeadingLevel({
+  level,
+  children
+}: HeadingLevelProps): import("react/jsx-runtime").JSX.Element;
+interface HeadingLevelProps {
+  /**
+   * The heading level. By default, it'll increase the level by 1 based on the
+   * context.
+   */
+  level?: HeadingLevels;
+  children?: ReactNode;
+}
+//#endregion
+export { HeadingLevel, HeadingLevelProps };
+//# sourceMappingURL=heading-level.d.ts.map

package/dist/heading/heading-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading-level.d.ts","names":["ReactNode","HeadingLevels","HeadingLevel","level","children","HeadingLevelProps","JSX","Element"],"sources":["../../src/heading/heading-level.d.ts"],"mappings":";;;;;;AAkBA;;;;;;;;;;;;;;iBAAwBE,YAAAA,CAAAA;EAAeC,KAAAA;EAAOC;AAAAA,GAAYC,iBAAAA,+BAAgDC,GAAAA,CAAIC,OAAAA;AAAAA,UAC7FF,iBAAAA;EADoG;AACrH;;;EAKIF,KAAAA,GAAQF,aAAAA;EACRG,QAAAA,GAAWJ,SAAS;AAAA"}

package/dist/heading/heading-level.js

@@ -0,0 +1,33 @@
+"use client";
+import { HeadingContext } from "./heading-context.js";
+import { useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/heading/heading-level.tsx
+/**
+* A component that sets the heading level for its children. It doesn't render
+* any HTML element, just sets the
+* [`level`](https://ariakit.com/reference/heading-level#level) prop on the
+* context.
+* @see https://ariakit.com/components/heading
+* @example
+* ```jsx
+* <HeadingLevel>
+*   <Heading>Heading 1</Heading>
+*   <HeadingLevel>
+*     <Heading>Heading 2</Heading>
+*   </HeadingLevel>
+* </HeadingLevel>
+* ```
+*/
+function HeadingLevel({ level, children }) {
+	const contextLevel = useContext(HeadingContext);
+	const nextLevel = Math.max(Math.min(level || contextLevel + 1, 6), 1);
+	return /* @__PURE__ */ jsx(HeadingContext.Provider, {
+		value: nextLevel,
+		children
+	});
+}
+//#endregion
+export { HeadingLevel };
+
+//# sourceMappingURL=heading-level.js.map

package/dist/heading/heading-level.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading-level.js","names":[],"sources":["../../src/heading/heading-level.tsx"],"sourcesContent":["import type { ReactNode } from \"react\";\nimport { useContext } from \"react\";\nimport { HeadingContext } from \"./heading-context.tsx\";\nimport type { HeadingLevels } from \"./utils.ts\";\n\n/**\n * A component that sets the heading level for its children. It doesn't render\n * any HTML element, just sets the\n * [`level`](https://ariakit.com/reference/heading-level#level) prop on the\n * context.\n * @see https://ariakit.com/components/heading\n * @example\n * ```jsx\n * <HeadingLevel>\n *   <Heading>Heading 1</Heading>\n *   <HeadingLevel>\n *     <Heading>Heading 2</Heading>\n *   </HeadingLevel>\n * </HeadingLevel>\n * ```\n */\nexport function HeadingLevel({ level, children }: HeadingLevelProps) {\n  const contextLevel = useContext(HeadingContext);\n  const nextLevel = Math.max(\n    Math.min(level || contextLevel + 1, 6),\n    1,\n  ) as HeadingLevels;\n  return (\n    <HeadingContext.Provider value={nextLevel}>\n      {children}\n    </HeadingContext.Provider>\n  );\n}\n\nexport interface HeadingLevelProps {\n  /**\n   * The heading level. By default, it'll increase the level by 1 based on the\n   * context.\n   */\n  level?: HeadingLevels;\n  children?: ReactNode;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;SAsBQ,aAAe,EAAA,OAAA,YAAW;CAChC,MAAM,eAAY,WACX,cAAa;CAGpB,MAAA,YACE,KAAA,IAAC,KAAA,IAAA,SAAe,eAAhB,GAAA,CAAA,GAAA,CAAA;QAAgC,oBAAA,eAAA,UAAA;EAC7B,OAAA;EACsB;CAE7B,CAAA"}

package/dist/heading/heading.d.ts

@@ -0,0 +1,2 @@
+import { i as useHeading, n as HeadingOptions, r as HeadingProps, t as Heading } from "../heading-zY9g_9K-.js";
+export { Heading, HeadingOptions, HeadingProps, useHeading };

package/dist/heading/heading.js

@@ -0,0 +1,56 @@
+"use client";
+import { HeadingContext } from "./heading-context.js";
+import { createElement, createHook, forwardRef, useMergeRefs, useTagName } from "@ariakit/react-utils";
+import { useContext, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/heading/heading.tsx
+const TagName = "h1";
+/**
+* Returns props to create a `Heading` component. The element type (or the
+* `aria-level` prop, if the element type is not a native heading) is determined
+* by the context level provided by the parent `HeadingLevel` component.
+* @see https://ariakit.com/components/heading
+* @example
+* ```jsx
+* const props = useHeading();
+* <Role {...props}>Heading</Role>
+* ```
+*/
+const useHeading = createHook(function useHeading(props) {
+	const ref = useRef(null);
+	const level = useContext(HeadingContext) || 1;
+	const Element = `h${level}`;
+	const tagName = useTagName(ref, Element);
+	const isNativeHeading = useMemo(() => !!tagName && /^h\d$/.test(tagName), [tagName]);
+	props = {
+		render: /* @__PURE__ */ jsx(Element, {}),
+		role: !isNativeHeading ? "heading" : void 0,
+		"aria-level": !isNativeHeading ? level : void 0,
+		...props,
+		ref: useMergeRefs(ref, props.ref)
+	};
+	return props;
+});
+/**
+* Renders a heading element. The element type (or the `aria-level` attribute,
+* if the element type is not a native heading) is determined by the context
+* level provided by the closest
+* [`HeadingLevel`](https://ariakit.com/reference/heading-level) ancestor.
+* @see https://ariakit.com/components/heading
+* @example
+* ```jsx
+* <HeadingLevel>
+*   <Heading>Heading 1</Heading>
+*   <HeadingLevel>
+*     <Heading>Heading 2</Heading>
+*   </HeadingLevel>
+* </HeadingLevel>
+* ```
+*/
+const Heading = forwardRef(function Heading(props) {
+	return createElement(TagName, useHeading(props));
+});
+//#endregion
+export { Heading, useHeading };
+
+//# sourceMappingURL=heading.js.map

package/dist/heading/heading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading.js","names":[],"sources":["../../src/heading/heading.tsx"],"sourcesContent":["import {\n  useMergeRefs,\n  useTagName,\n  createElement,\n  createHook,\n  forwardRef,\n} from \"@ariakit/react-utils\";\nimport type { Options, Props } from \"@ariakit/react-utils\";\nimport type { ElementType } from \"react\";\nimport { useContext, useMemo, useRef } from \"react\";\nimport { HeadingContext } from \"./heading-context.tsx\";\nimport type { HeadingLevels } from \"./utils.ts\";\n\ntype HeadingElements = `h${HeadingLevels}`;\nconst TagName = \"h1\" satisfies ElementType;\ntype TagName = HeadingElements;\ntype HTMLType = HTMLElementTagNameMap[TagName];\n\n/**\n * Returns props to create a `Heading` component. The element type (or the\n * `aria-level` prop, if the element type is not a native heading) is determined\n * by the context level provided by the parent `HeadingLevel` component.\n * @see https://ariakit.com/components/heading\n * @example\n * ```jsx\n * const props = useHeading();\n * <Role {...props}>Heading</Role>\n * ```\n */\nexport const useHeading = createHook<TagName, HeadingOptions>(\n  function useHeading(props) {\n    const ref = useRef<HTMLType>(null);\n    const level: HeadingLevels = useContext(HeadingContext) || 1;\n    const Element = `h${level}` as const;\n    const tagName = useTagName(ref, Element);\n    const isNativeHeading = useMemo(\n      () => !!tagName && /^h\\d$/.test(tagName),\n      [tagName],\n    );\n\n    props = {\n      render: <Element />,\n      role: !isNativeHeading ? \"heading\" : undefined,\n      \"aria-level\": !isNativeHeading ? level : undefined,\n      ...props,\n      ref: useMergeRefs(ref, props.ref),\n    };\n\n    return props;\n  },\n);\n\n/**\n * Renders a heading element. The element type (or the `aria-level` attribute,\n * if the element type is not a native heading) is determined by the context\n * level provided by the closest\n * [`HeadingLevel`](https://ariakit.com/reference/heading-level) ancestor.\n * @see https://ariakit.com/components/heading\n * @example\n * ```jsx\n * <HeadingLevel>\n *   <Heading>Heading 1</Heading>\n *   <HeadingLevel>\n *     <Heading>Heading 2</Heading>\n *   </HeadingLevel>\n * </HeadingLevel>\n * ```\n */\nexport const Heading = forwardRef(function Heading(props: HeadingProps) {\n  const htmlProps = useHeading(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface HeadingOptions<\n  _T extends ElementType = TagName,\n> extends Options {}\n\nexport type HeadingProps<T extends ElementType = TagName> = Props<\n  T,\n  HeadingOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;MA+BI,aAAY,WAAqB,SAAA,WAAA,OAAA;CACjC,MAAM,MAAA,OAAuB,IAAA;CAC7B,MAAM,QAAA,WAAc,cAAA,KAAA;CACpB,MAAM,UAAU,IAAA;CAChB,MAAM,UAAA,WAAkB,KAAA,OACf;CAIT,MAAA,kBAAQ,cAAA,CAAA,CAAA,WAAA,QAAA,KAAA,OAAA,GAAA,CAAA,OAAA,CAAA;SACN;EACA,QAAO,oBAAkB,SAAY,CAAA,CAAA;EACrC,MAAA,CAAA,kBAAe,YAAkB,KAAQ;EACzC,cAAG,CAAA,kBAAA,QAAA,KAAA;EACH,GAAA;EACF,KAAA,aAAA,KAAA,MAAA,GAAA;CAEA;CAEJ,OAAA;;;;;;;;;;;;;;;;;;MAoBE,UAAO,WAAc,SADH,QAAW,OACU;CACxC,OAAA,cAAA,SAAA,WAAA,KAAA,CAAA"}

package/dist/heading/utils.d.ts

@@ -0,0 +1,2 @@
+import { t as HeadingLevels } from "../utils-DUF1aMov.js";
+export { HeadingLevels };

package/dist/heading/utils.js

@@ -0,0 +1 @@
+"use client";

package/dist/heading-zY9g_9K-.d.ts

@@ -0,0 +1,42 @@
+import { t as HeadingLevels } from "./utils-DUF1aMov.js";
+import { Options, Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/heading/heading.d.ts
+type HeadingElements = `h${HeadingLevels}`;
+declare const TagName = "h1";
+type TagName = HeadingElements;
+/**
+ * Returns props to create a `Heading` component. The element type (or the
+ * `aria-level` prop, if the element type is not a native heading) is determined
+ * by the context level provided by the parent `HeadingLevel` component.
+ * @see https://ariakit.com/components/heading
+ * @example
+ * ```jsx
+ * const props = useHeading();
+ * <Role {...props}>Heading</Role>
+ * ```
+ */
+declare const useHeading: import("@ariakit/react-utils").Hook<"h1" | "h2" | "h3" | "h4" | "h5" | "h6", HeadingOptions<"h1" | "h2" | "h3" | "h4" | "h5" | "h6">>;
+/**
+ * Renders a heading element. The element type (or the `aria-level` attribute,
+ * if the element type is not a native heading) is determined by the context
+ * level provided by the closest
+ * [`HeadingLevel`](https://ariakit.com/reference/heading-level) ancestor.
+ * @see https://ariakit.com/components/heading
+ * @example
+ * ```jsx
+ * <HeadingLevel>
+ *   <Heading>Heading 1</Heading>
+ *   <HeadingLevel>
+ *     <Heading>Heading 2</Heading>
+ *   </HeadingLevel>
+ * </HeadingLevel>
+ * ```
+ */
+declare const Heading: (props: HeadingProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface HeadingOptions<_T extends ElementType = TagName> extends Options {}
+type HeadingProps<T extends ElementType = TagName> = Props<T, HeadingOptions<T>>;
+//#endregion
+export { useHeading as i, HeadingOptions as n, HeadingProps as r, Heading as t };
+//# sourceMappingURL=heading-zY9g_9K-.d.ts.map

package/dist/heading-zY9g_9K-.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading-zY9g_9K-.d.ts","names":["Options","Props","ElementType","HeadingLevels","HeadingElements","TagName","useHeading","HeadingOptions","Hook","Heading","HeadingProps","props","ReactElement","JSXElementConstructor","_T","T"],"sources":["../src/heading/heading.d.ts"],"mappings":";;;;;KAGKI,eAAAA,OAAsBD,aAAa;AAAA,cAC1BE,OAAAA;AAAAA,KACTA,OAAAA,GAAUD,eAAe;;;;AAFU;AAAA;;;;AACnB;AAAA;;cAaAE,UAAAA,iCAA2CE,IAAAA,0CAA8CD,cAAc;;AAZ9F;AAY9B;;;;AAA4H;AAiB5H;;;;;;;;;cAAqBE,OAAAA,GAAUE,KAAAA,EAAOD,YAAY,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACjGN,cAAAA,YAA0BL,WAAAA,GAAcG,OAAAA,UAAiBL,OAAAA;AAAAA,KAE9DU,YAAAA,WAAuBR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMc,CAAAA,EAAGR,cAAAA,CAAeQ,CAAAA"}

package/dist/hovercard/hovercard-anchor.d.ts

@@ -0,0 +1,59 @@
+import { n as FocusableOptions } from "../focusable-B00tOxtB.js";
+import { t as HovercardStore } from "../hovercard-store-gIeoQEn_.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType, MouseEvent } from "react";
+import { BooleanOrCallback } from "@ariakit/utils";
+
+//#region src/hovercard/hovercard-anchor.d.ts
+declare const TagName = "a";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `HovercardAnchor` component.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx
+ * const store = useHovercardStore();
+ * const props = useHovercardAnchor({ store });
+ * <Role {...props} render={<a />}>@username</Role>
+ * <Hovercard store={store}>Details</Hovercard>
+ * ```
+ */
+declare const useHovercardAnchor: import("@ariakit/react-utils").Hook<"a", HovercardAnchorOptions<"a">>;
+/**
+ * Renders an anchor element that will open a
+ * [`Hovercard`](https://ariakit.com/reference/hovercard) popup on hover.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx {2}
+ * <HovercardProvider>
+ *   <HovercardAnchor>@username</HovercardAnchor>
+ *   <Hovercard>Details</Hovercard>
+ * </HovercardProvider>
+ * ```
+ */
+declare const HovercardAnchor: (props: HovercardAnchorProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface HovercardAnchorOptions<T extends ElementType = TagName> extends FocusableOptions<T> {
+  /**
+   * Object returned by the
+   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)
+   * hook. If not provided, the closest
+   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)
+   * component's context will be used.
+   */
+  store?: HovercardStore;
+  /**
+   * Shows the content element based on the user's _hover intent_ over the
+   * anchor element. This behavior purposely ignores mobile touch and
+   * unintentional mouse enter events, like those that happen during scrolling.
+   *
+   * Live examples:
+   * - [Navigation Menubar](https://ariakit.com/examples/menubar-navigation)
+   * - [Sliding Menu](https://ariakit.com/examples/menu-slide)
+   * @default true
+   */
+  showOnHover?: BooleanOrCallback<MouseEvent<HTMLElement>>;
+}
+type HovercardAnchorProps<T extends ElementType = TagName> = Props<T, HovercardAnchorOptions<T>>;
+//#endregion
+export { HovercardAnchor, HovercardAnchorOptions, HovercardAnchorProps, useHovercardAnchor };
+//# sourceMappingURL=hovercard-anchor.d.ts.map

package/dist/hovercard/hovercard-anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-anchor.d.ts","names":["Props","BooleanOrCallback","ElementType","MouseEvent","ReactMouseEvent","FocusableOptions","HovercardStore","TagName","useHovercardAnchor","HovercardAnchorOptions","Hook","HovercardAnchor","HovercardAnchorProps","props","ReactElement","JSXElementConstructor","T","HTMLElement","store","showOnHover"],"sources":["../../src/hovercard/hovercard-anchor.d.ts"],"mappings":";;;;;;;cAKcO,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF8B;;;;AACtC;AAAA;;;;AACQ;AAY7B;AAd2D,cActCC,kBAAAA,iCAAmDE,IAAAA,MAAUD,sBAAsB;;;AAAA;AAaxG;;;;;;;;;cAAqBE,eAAAA,GAAkBE,KAAAA,EAAOD,oBAAoB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UACjHN,sBAAAA,WAAiCP,WAAAA,GAAcK,OAAAA,UAAiBF,gBAAAA,CAAiBW,CAAAA;EAA3D;;;;;;;EAQnCE,KAAAA,GAAQZ,cAAAA;EAWML;;;;;;;;;;EAAdkB,WAAAA,GAAclB,iBAAAA,CAAkBG,UAAAA,CAAgBa,WAAAA;AAAAA;AAAAA,KAExCL,oBAAAA,WAA+BV,WAAAA,GAAcK,OAAAA,IAAWP,KAAAA,CAAMgB,CAAAA,EAAGP,sBAAAA,CAAuBO,CAAAA"}

package/dist/hovercard/hovercard-anchor.js

@@ -0,0 +1,106 @@
+"use client";
+import { useFocusable } from "../focusable/focusable.js";
+import { useHovercardProviderContext } from "./hovercard-context.js";
+import { createElement, createHook, forwardRef, useBooleanEvent, useEvent, useIsMouseMoving, useMergeRefs } from "@ariakit/react-utils";
+import { addGlobalEventListener, disabledFromProps, invariant } from "@ariakit/utils";
+import { useCallback, useEffect, useRef } from "react";
+//#region src/hovercard/hovercard-anchor.tsx
+const TagName = "a";
+/**
+* Returns props to create a `HovercardAnchor` component.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx
+* const store = useHovercardStore();
+* const props = useHovercardAnchor({ store });
+* <Role {...props} render={<a />}>@username</Role>
+* <Hovercard store={store}>Details</Hovercard>
+* ```
+*/
+const useHovercardAnchor = createHook(function useHovercardAnchor({ store, showOnHover = true, ...props }) {
+	const context = useHovercardProviderContext();
+	store = store || context;
+	invariant(store, "HovercardAnchor must receive a `store` prop or be wrapped in a HovercardProvider component.");
+	const disabled = disabledFromProps(props);
+	const showTimeoutRef = useRef(0);
+	useEffect(() => () => window.clearTimeout(showTimeoutRef.current), []);
+	useEffect(() => {
+		const onMouseLeave = (event) => {
+			if (!store) return;
+			const { anchorElement } = store.getState();
+			if (!anchorElement) return;
+			if (event.target !== anchorElement) return;
+			window.clearTimeout(showTimeoutRef.current);
+			showTimeoutRef.current = 0;
+		};
+		return addGlobalEventListener("mouseleave", onMouseLeave, true);
+	}, [store]);
+	const onMouseMoveProp = props.onMouseMove;
+	const showOnHoverProp = useBooleanEvent(showOnHover);
+	const isMouseMoving = useIsMouseMoving();
+	const onMouseMove = useEvent((event) => {
+		onMouseMoveProp?.(event);
+		if (disabled) return;
+		if (!store) return;
+		if (event.defaultPrevented) return;
+		if (showTimeoutRef.current) return;
+		if (!isMouseMoving()) return;
+		if (!showOnHoverProp(event)) return;
+		const element = event.currentTarget;
+		store.setAnchorElement(element);
+		store.setDisclosureElement(element);
+		const { showTimeout, timeout } = store.getState();
+		const showHovercard = () => {
+			showTimeoutRef.current = 0;
+			if (!isMouseMoving()) return;
+			store?.setAnchorElement(element);
+			store?.show();
+			queueMicrotask(() => {
+				store?.setDisclosureElement(element);
+			});
+		};
+		const timeoutMs = showTimeout ?? timeout;
+		if (timeoutMs === 0) showHovercard();
+		else showTimeoutRef.current = window.setTimeout(showHovercard, timeoutMs);
+	});
+	const onClickProp = props.onClick;
+	const onClick = useEvent((event) => {
+		onClickProp?.(event);
+		if (!store) return;
+		window.clearTimeout(showTimeoutRef.current);
+		showTimeoutRef.current = 0;
+	});
+	const ref = useCallback((element) => {
+		if (!store) return;
+		const { anchorElement } = store.getState();
+		if (anchorElement?.isConnected) return;
+		store.setAnchorElement(element);
+	}, [store]);
+	props = {
+		...props,
+		ref: useMergeRefs(ref, props.ref),
+		onMouseMove,
+		onClick
+	};
+	props = useFocusable(props);
+	return props;
+});
+/**
+* Renders an anchor element that will open a
+* [`Hovercard`](https://ariakit.com/reference/hovercard) popup on hover.
+* @see https://ariakit.com/components/hovercard
+* @example
+* ```jsx {2}
+* <HovercardProvider>
+*   <HovercardAnchor>@username</HovercardAnchor>
+*   <Hovercard>Details</Hovercard>
+* </HovercardProvider>
+* ```
+*/
+const HovercardAnchor = forwardRef(function HovercardAnchor(props) {
+	return createElement(TagName, useHovercardAnchor(props));
+});
+//#endregion
+export { HovercardAnchor, useHovercardAnchor };
+
+//# sourceMappingURL=hovercard-anchor.js.map

package/dist/hovercard/hovercard-anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-anchor.js","names":[],"sources":["../../src/hovercard/hovercard-anchor.tsx"],"sourcesContent":["import {\n  useBooleanEvent,\n  useEvent,\n  useIsMouseMoving,\n  useMergeRefs,\n  createElement,\n  createHook,\n  forwardRef,\n} from \"@ariakit/react-utils\";\nimport type { Props } from \"@ariakit/react-utils\";\nimport {\n  addGlobalEventListener,\n  disabledFromProps,\n  invariant,\n} from \"@ariakit/utils\";\nimport type { BooleanOrCallback } from \"@ariakit/utils\";\nimport type { ElementType, MouseEvent as ReactMouseEvent } from \"react\";\nimport { useCallback, useEffect, useRef } from \"react\";\nimport type { FocusableOptions } from \"../focusable/focusable.tsx\";\nimport { useFocusable } from \"../focusable/focusable.tsx\";\nimport { useHovercardProviderContext } from \"./hovercard-context.tsx\";\nimport type { HovercardStore } from \"./hovercard-store.ts\";\n\nconst TagName = \"a\" satisfies ElementType;\ntype TagName = typeof TagName;\ntype HTMLType = HTMLElementTagNameMap[TagName];\n\n/**\n * Returns props to create a `HovercardAnchor` component.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx\n * const store = useHovercardStore();\n * const props = useHovercardAnchor({ store });\n * <Role {...props} render={<a />}>@username</Role>\n * <Hovercard store={store}>Details</Hovercard>\n * ```\n */\nexport const useHovercardAnchor = createHook<TagName, HovercardAnchorOptions>(\n  function useHovercardAnchor({ store, showOnHover = true, ...props }) {\n    const context = useHovercardProviderContext();\n    store = store || context;\n\n    invariant(\n      store,\n      process.env.NODE_ENV !== \"production\" &&\n        \"HovercardAnchor must receive a `store` prop or be wrapped in a HovercardProvider component.\",\n    );\n\n    const disabled = disabledFromProps(props);\n    const showTimeoutRef = useRef(0);\n\n    // Clear the show timeout if the anchor is unmounted\n    useEffect(() => () => window.clearTimeout(showTimeoutRef.current), []);\n\n    // Clear the show timeout if the mouse leaves the anchor element. We're\n    // using the native mouseleave event instead of React's onMouseLeave so we\n    // bypass the event.stopPropagation() logic set on the Hovercard component\n    // for when the mouse is moving toward the Hovercard.\n    useEffect(() => {\n      const onMouseLeave = (event: MouseEvent) => {\n        if (!store) return;\n        const { anchorElement } = store.getState();\n        if (!anchorElement) return;\n        if (event.target !== anchorElement) return;\n        window.clearTimeout(showTimeoutRef.current);\n        showTimeoutRef.current = 0;\n      };\n      return addGlobalEventListener(\"mouseleave\", onMouseLeave, true);\n    }, [store]);\n\n    const onMouseMoveProp = props.onMouseMove;\n    const showOnHoverProp = useBooleanEvent(showOnHover);\n    const isMouseMoving = useIsMouseMoving();\n\n    const onMouseMove = useEvent((event: ReactMouseEvent<HTMLType>) => {\n      onMouseMoveProp?.(event);\n      if (disabled) return;\n      if (!store) return;\n      if (event.defaultPrevented) return;\n      if (showTimeoutRef.current) return;\n      if (!isMouseMoving()) return;\n      if (!showOnHoverProp(event)) return;\n      const element = event.currentTarget;\n      store.setAnchorElement(element);\n      store.setDisclosureElement(element);\n      const { showTimeout, timeout } = store.getState();\n      const showHovercard = () => {\n        showTimeoutRef.current = 0;\n        // Let's check again if the mouse is moving. This is to avoid showing\n        // the hovercard on mobile clicks or after clicking on the anchor.\n        if (!isMouseMoving()) return;\n        store?.setAnchorElement(element);\n        store?.show();\n        queueMicrotask(() => {\n          // We need to set the anchor element as the hovercard disclosure\n          // element only when the hovercard is shown so it doesn't get\n          // assigned an arbitrary element by the dialog component.\n          store?.setDisclosureElement(element);\n        });\n      };\n      const timeoutMs = showTimeout ?? timeout;\n      if (timeoutMs === 0) {\n        showHovercard();\n      } else {\n        showTimeoutRef.current = window.setTimeout(showHovercard, timeoutMs);\n      }\n    });\n\n    const onClickProp = props.onClick;\n\n    const onClick = useEvent((event: ReactMouseEvent<HTMLType>) => {\n      onClickProp?.(event);\n      if (!store) return;\n      // Resets showOnHover when the anchor is clicked so the consumer (for\n      // example, TooltipAnchor) has the chance to prevent the hovercard from\n      // showing on mousemove after a click.\n      window.clearTimeout(showTimeoutRef.current);\n      showTimeoutRef.current = 0;\n    });\n\n    const ref = useCallback(\n      (element: HTMLElement | null) => {\n        if (!store) return;\n        const { anchorElement } = store.getState();\n        if (anchorElement?.isConnected) return;\n        // We can set the anchor element only if it isn't already set or if it's\n        // not linked to the DOM. This helps prevent the anchor element from\n        // being reassigned to a different element when using multiple anchors\n        // and new anchors are added to the DOM.\n        store.setAnchorElement(element);\n      },\n      [store],\n    );\n\n    props = {\n      ...props,\n      ref: useMergeRefs(ref, props.ref),\n      onMouseMove,\n      onClick,\n    };\n\n    props = useFocusable<TagName>(props);\n\n    return props;\n  },\n);\n\n/**\n * Renders an anchor element that will open a\n * [`Hovercard`](https://ariakit.com/reference/hovercard) popup on hover.\n * @see https://ariakit.com/components/hovercard\n * @example\n * ```jsx {2}\n * <HovercardProvider>\n *   <HovercardAnchor>@username</HovercardAnchor>\n *   <Hovercard>Details</Hovercard>\n * </HovercardProvider>\n * ```\n */\nexport const HovercardAnchor = forwardRef(function HovercardAnchor(\n  props: HovercardAnchorProps,\n) {\n  const htmlProps = useHovercardAnchor(props);\n  return createElement(TagName, htmlProps);\n});\n\nexport interface HovercardAnchorOptions<\n  T extends ElementType = TagName,\n> extends FocusableOptions<T> {\n  /**\n   * Object returned by the\n   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)\n   * hook. If not provided, the closest\n   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)\n   * component's context will be used.\n   */\n  store?: HovercardStore;\n  /**\n   * Shows the content element based on the user's _hover intent_ over the\n   * anchor element. This behavior purposely ignores mobile touch and\n   * unintentional mouse enter events, like those that happen during scrolling.\n   *\n   * Live examples:\n   * - [Navigation Menubar](https://ariakit.com/examples/menubar-navigation)\n   * - [Sliding Menu](https://ariakit.com/examples/menu-slide)\n   * @default true\n   */\n  showOnHover?: BooleanOrCallback<ReactMouseEvent<HTMLElement>>;\n}\n\nexport type HovercardAnchorProps<T extends ElementType = TagName> = Props<\n  T,\n  HovercardAnchorOptions<T>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;MAwCI,qBAAgB,WAAA,SAA4B,mBAAA,EAAA,OAAA,cAAA,MAAA,GAAA,SAAA;CAC5C,MAAA,UAAQ,4BAAS;CAEjB,QAAA,SAGI;CAGJ,UAAM,OAAW,6FAAuB;CACxC,MAAM,WAAA,kBAAyB,KAAA;CAG/B,MAAA,iBAAsB,OAAO,CAAA;CAM7B,sBAAgB,OAAA,aAAA,eAAA,OAAA,GAAA,CAAA,CAAA;iBACR;QACC,gBAAO,UAAA;GACZ,IAAA,CAAA,OAAQ;GACR,MAAK,EAAA,kBAAe,MAAA,SAAA;GACpB,IAAI,CAAA,eAAM;GACV,IAAA,MAAO,WAAa,eAAe;GACnC,OAAA,aAAe,eAAU,OAAA;GAC3B,eAAA,UAAA;EACA;EACF,OAAI,uBAAM,cAAA,cAAA,IAAA;CAEV,GAAA,CAAA,KAAM,CAAA;CACN,MAAM,kBAAkB,MAAA;CACxB,MAAM,kBAAgB,gBAAiB,WAAA;CAEvC,MAAM,gBAAc,iBAAU;OAC5B,cAAkB,UAAK,UAAA;EACvB,kBAAc,KAAA;EACd,IAAI,UAAQ;EACZ,IAAI,CAAA,OAAM;EACV,IAAI,MAAA,kBAAwB;EAC5B,IAAI,eAAe,SAAG;EACtB,IAAI,CAAC,cAAA,GAAgB;EACrB,IAAA,CAAA,gBAAgB,KAAM,GAAA;EACtB,MAAM,UAAA,MAAA;EACN,MAAM,iBAAA,OAAqB;EAC3B,MAAM,qBAAe,OAAY;EACjC,MAAM,EAAA,aAAA,YAAsB,MAAA,SAAA;QAC1B,sBAAyB;GAGzB,eAAK,UAAiB;GACtB,IAAA,CAAA,cAAO,GAAA;GACP,OAAO,iBAAK,OAAA;GACZ,OAAA,KAAA;wBAIS;IACR,OAAA,qBAAA,OAAA;GACH,CAAA;EACA;EACA,MAAI,YAAc,eAChB;oBAEA,GAAe,cAAU;OAE5B,eAAA,UAAA,OAAA,WAAA,eAAA,SAAA;CAED,CAAA;CAEA,MAAM,cAAU,MAAU;OACxB,UAAc,UAAK,UAAA;EACnB,cAAY,KAAA;EAIZ,IAAA,CAAA,OAAO;EACP,OAAA,aAAe,eAAU,OAAA;EAC1B,eAAA,UAAA;CAED,CAAA;OAES,MAAA,aAAO,YAAA;EACZ,IAAA,CAAA,OAAQ;EACR,MAAI,EAAA,kBAAe,MAAa,SAAA;EAKhC,IAAA,eAAM,aAAwB;EAChC,MACC,iBACH,OAAA;CAEA,GAAA,CAAA,KAAQ,CAAA;SACH;EACH,GAAA;EACA,KAAA,aAAA,KAAA,MAAA,GAAA;EACA;EACF;CAEA;CAEA,QAAO,aAAA,KAAA;CAEX,OAAA;;;;;;;;;;;;;;MAkBE,kBAAqB,WADH,SAAA,gBACqB,OAAA;CACxC,OAAA,cAAA,SAAA,mBAAA,KAAA,CAAA"}

package/dist/hovercard/hovercard-arrow.d.ts

@@ -0,0 +1,54 @@
+import { t as HovercardStore } from "../hovercard-store-gIeoQEn_.js";
+import { PopoverArrowOptions } from "../popover/popover-arrow.js";
+import { Props } from "@ariakit/react-utils";
+import { ElementType } from "react";
+
+//#region src/hovercard/hovercard-arrow.d.ts
+declare const TagName = "div";
+type TagName = typeof TagName;
+/**
+ * Returns props to create a `HovercardArrow` component.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx
+ * const store = useHovercardStore();
+ * const props = useHovercardArrow({ store });
+ * <Hovercard store={store}>
+ *   <Role {...props} />
+ *   Details
+ * </Hovercard>
+ * ```
+ */
+declare const useHovercardArrow: import("@ariakit/react-utils").Hook<"div", HovercardArrowOptions<"div">>;
+/**
+ * Renders an arrow element inside a
+ * [`Hovercard`](https://ariakit.com/reference/hovercard) component that points
+ * to the anchor element.
+ * @see https://ariakit.com/components/hovercard
+ * @example
+ * ```jsx {4}
+ * <HovercardProvider>
+ *   <HovercardAnchor>@username</HovercardAnchor>
+ *   <Hovercard>
+ *     <HovercardArrow />
+ *     Details
+ *   </Hovercard>
+ * </HovercardProvider>
+ * ```
+ */
+declare const HovercardArrow: (props: HovercardArrowProps) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+interface HovercardArrowOptions<T extends ElementType = TagName> extends PopoverArrowOptions<T> {
+  /**
+   * Object returned by the
+   * [`useHovercardStore`](https://ariakit.com/reference/use-hovercard-store)
+   * hook. If not provided, the closest
+   * [`Hovercard`](https://ariakit.com/reference/hovercard) or
+   * [`HovercardProvider`](https://ariakit.com/reference/hovercard-provider)
+   * components' context will be used.
+   */
+  store?: HovercardStore;
+}
+type HovercardArrowProps<T extends ElementType = TagName> = Props<T, HovercardArrowOptions<T>>;
+//#endregion
+export { HovercardArrow, HovercardArrowOptions, HovercardArrowProps, useHovercardArrow };
+//# sourceMappingURL=hovercard-arrow.d.ts.map

package/dist/hovercard/hovercard-arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hovercard-arrow.d.ts","names":["Props","ElementType","PopoverArrowOptions","HovercardStore","TagName","useHovercardArrow","HovercardArrowOptions","Hook","HovercardArrow","HovercardArrowProps","props","ReactElement","JSXElementConstructor","T","store"],"sources":["../../src/hovercard/hovercard-arrow.d.ts"],"mappings":";;;;;;cAIcI,OAAAA;AAAAA,KACTA,OAAAA,UAAiBA,OAAO;AAF8B;;;;AACtC;AAAA;;;;AACQ;AAc7B;;;AAhB2D,cAgBtCC,iBAAAA,iCAAkDE,IAAAA,QAAYD,qBAAqB;AAAA;AAiBxG;;;;;;;;;AAAqJ;AACrJ;;;;;AAlBwG,cAiBnFE,cAAAA,GAAiBE,KAAAA,EAAOD,mBAAmB,qBAAqBE,YAAAA,+BAA2CC,qBAAAA;AAAAA,UAC/GN,qBAAAA,WAAgCL,WAAAA,GAAcG,OAAAA,UAAiBF,mBAAAA,CAAoBW,CAAAA;EAApBX;;;;;;;;EAS5EY,KAAAA,GAAQX,cAAAA;AAAAA;AAAAA,KAEAM,mBAAAA,WAA8BR,WAAAA,GAAcG,OAAAA,IAAWJ,KAAAA,CAAMa,CAAAA,EAAGP,qBAAAA,CAAsBO,CAAAA"}