@chassis-ui/react 0.1.3 → 0.3.0

package/dist/chunks/index-DaHQdNul.d.ts

@@ -0,0 +1,182 @@
+import "./focus-ring-SR_LwaN7.js";
+import { i as IconValue } from "./iconConfig-C6gbYhsD.js";
+import { CSSProperties, ReactElement, ReactNode, Ref } from "react";
+import { Key as Key$1, Selection } from "react-aria-components";
+//#region src/components/tree/Tree.d.ts
+interface TreeProps<T extends object> {
+  /**
+   * An accessible name for the tree, when no visible heading names it.
+   */
+  'aria-label'?: string;
+  /**
+   * The id of the visible heading that names the tree.
+   */
+  'aria-labelledby'?: string;
+  /**
+   * Focus the tree when it mounts: `true` or `'first'` focuses its first item, `'last'` its last.
+   */
+  autoFocus?: boolean | 'first' | 'last';
+  /**
+   * Draw a checkbox in every item, which selects the item. On by default with
+   * `selectionMode="multiple"` and the `'toggle'` selection behavior, off otherwise.
+   */
+  checkboxes?: boolean;
+  /**
+   * `TreeItem` elements, or a render function called once per entry of `items`, returning that
+   * entry's `TreeItem`.
+   */
+  children: ReactNode | ((item: T) => ReactElement);
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * The keys of the items expanded at first (uncontrolled).
+   */
+  defaultExpandedKeys?: Iterable<Key$1>;
+  /**
+   * The keys of the items selected at first (uncontrolled): `'all'`, or an iterable of keys.
+   */
+  defaultSelectedKeys?: 'all' | Iterable<Key$1>;
+  /**
+   * Values that should rebuild the items when using the `items`/render-function form of
+   * `children` — e.g. a value from outside `items` that the render function reads. Without this,
+   * changing that value won't re-render the items, which are only rebuilt when `items` or
+   * `dependencies` change by reference.
+   */
+  dependencies?: ReadonlyArray<unknown>;
+  /**
+   * Whether `disabledKeys` disables every interaction with an item, or only its selection.
+   *
+   * @default 'all'
+   */
+  disabledBehavior?: 'all' | 'selection';
+  /**
+   * The keys of the items that are disabled.
+   */
+  disabledKeys?: Iterable<Key$1>;
+  /**
+   * Keep at least one item selected: the last selected item can't be deselected.
+   */
+  disallowEmptySelection?: boolean;
+  /**
+   * The keys of the expanded items (controlled).
+   */
+  expandedKeys?: Iterable<Key$1>;
+  /**
+   * The chevron of an item with child items, in place of `IconProvider`'s `expand` icon: an icon
+   * name, or an element.
+   */
+  expandIcon?: IconValue;
+  /**
+   * The id of the tree element.
+   */
+  id?: string;
+  /**
+   * The data to render as items, through the function form of `children`.
+   */
+  items?: Iterable<T>;
+  /**
+   * Called with an item's key when the item is activated: with Enter, or with a click when the
+   * tree has no selection. An item's own `onAction` is called too.
+   */
+  onAction?: (key: Key$1) => void;
+  /**
+   * Called with the keys of the expanded items when an item expands or collapses.
+   */
+  onExpandedChange?: (keys: Set<Key$1>) => void;
+  /**
+   * Called with the keys of the selected items (`'all'`, or a `Set`) when the selection changes.
+   */
+  onSelectionChange?: (keys: Selection) => void;
+  /**
+   * What to render in place of the items when there are none.
+   */
+  renderEmptyState?: () => ReactNode;
+  /**
+   * The keys of the selected items (controlled): `'all'`, or an iterable of keys.
+   */
+  selectedKeys?: 'all' | Iterable<Key$1>;
+  /**
+   * How a click changes a multiple selection: `'toggle'` adds or removes the clicked item,
+   * `'replace'` selects it alone, with Ctrl, Cmd and Shift for more, as a file manager does.
+   *
+   * @default 'toggle'
+   */
+  selectionBehavior?: 'toggle' | 'replace';
+  /**
+   * Whether items can be selected, and how many at a time.
+   *
+   * @default 'none'
+   */
+  selectionMode?: 'none' | 'single' | 'multiple';
+  /**
+   * Inline styles for the tree element.
+   */
+  style?: CSSProperties;
+}
+declare const Tree$1: <T extends object>(props: TreeProps<T> & {
+  ref?: Ref<HTMLDivElement>;
+}) => ReactElement;
+//#endregion
+//#region src/components/tree/TreeItem.d.ts
+interface TreeItemProps<T extends object = object> {
+  /**
+   * The item's child items: `TreeItem` elements, or a render function called once per entry of
+   * `items`, returning that entry's `TreeItem`.
+   */
+  children?: ReactNode | ((item: T) => ReactElement);
+  /**
+   * A string of all className you want applied to the item.
+   */
+  className?: string;
+  /**
+   * Values that should rebuild the child items when using the `items`/render-function form of
+   * `children`, as `Tree`'s `dependencies`.
+   */
+  dependencies?: ReadonlyArray<unknown>;
+  /**
+   * Toggle the disabled state for the item, as a key in the tree's `disabledKeys` does.
+   */
+  disabled?: boolean;
+  /**
+   * An icon drawn before the label.
+   */
+  icon?: ReactNode;
+  /**
+   * The item's key, named by `expandedKeys`, `selectedKeys` and `disabledKeys`. Defaults to the
+   * key of the data entry the item renders, or to the item's position.
+   */
+  id?: Key$1;
+  /**
+   * The data to render as child items, through the function form of `children`.
+   */
+  items?: Iterable<T>;
+  /**
+   * The item's content.
+   */
+  label: ReactNode;
+  /**
+   * Called when the item is activated: with Enter, or with a click when the tree has no
+   * selection.
+   */
+  onAction?: () => void;
+  /**
+   * Inline styles for the item's row.
+   */
+  style?: CSSProperties;
+  /**
+   * The item's text, which typing a letter in the tree searches. Defaults to `label` when it is a
+   * string.
+   */
+  textValue?: string;
+}
+/**
+ * An item of a `Tree`: a row with a label, an optional icon, and child items among its children.
+ */
+declare const TreeItem$1: <T extends object = object>(props: TreeItemProps<T> & {
+  ref?: Ref<HTMLDivElement>;
+}) => ReactElement;
+//#endregion
+export { TreeProps as i, TreeItemProps as n, Tree$1 as r, TreeItem$1 as t };
+//# sourceMappingURL=index-DaHQdNul.d.ts.map

package/dist/chunks/index-Dcc_W6Kv.d.ts

@@ -0,0 +1,147 @@
+import "./focus-ring-SR_LwaN7.js";
+import { n as PolymorphicRef, t as PolymorphicComponentProps } from "./polymorphic-CVHbTHSN.js";
+import React, { DetailsHTMLAttributes, ElementType, HTMLAttributes, ReactElement, ReactNode } from "react";
+//#region src/components/accordion/Accordion.d.ts
+interface AccordionItemDef {
+  /**
+   * Let this item stay open when another item opens, overriding the accordion's `alwaysOpen` setting.
+   */
+  alwaysOpen?: boolean;
+  /**
+   * Body content, rendered inside a `AccordionBody`.
+   */
+  body: ReactNode;
+  /**
+   * A string of all className you want applied to this item.
+   */
+  className?: string;
+  /**
+   * Header content, rendered inside a `AccordionHeader`.
+   */
+  header: ReactNode;
+  /**
+   * React key for this item. Falls back to its index when omitted.
+   */
+  id?: number | string;
+  /**
+   * The group this item shares with other items so only one can be open at a time, overriding the
+   * accordion's shared `name`.
+   */
+  name?: string;
+  /**
+   * Callback fired when this item's open state changes. Chained after `Accordion`'s own handling
+   * of `expandedKeys`/`onExpandedChange`, so it fires regardless of whether those are used.
+   */
+  onToggle?: (event: React.SyntheticEvent<HTMLDetailsElement>) => void;
+  /**
+   * Start the item in the open state (uncontrolled). Ignored for items whose key is included in
+   * `expandedKeys`/`defaultExpandedKeys` on the parent `Accordion`.
+   */
+  open?: boolean;
+}
+interface AccordionProps extends HTMLAttributes<HTMLDivElement> {
+  /**
+   * Make accordion items stay open when another item is opened.
+   */
+  alwaysOpen?: boolean;
+  /**
+   * Move the caret icon to the end of the header.
+   */
+  caretEnd?: boolean;
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * The keys of the initially expanded items (uncontrolled). Only applies to items rendered via
+   * the `items` prop — a composed `AccordionItem` already supports native controlled `open`/
+   * `onToggle` directly.
+   */
+  defaultExpandedKeys?: Array<number | string>;
+  /**
+   * The keys of the currently expanded items (controlled). Only applies to items rendered via the
+   * `items` prop — a composed `AccordionItem` already supports native controlled `open`/`onToggle`
+   * directly.
+   */
+  expandedKeys?: Array<number | string>;
+  /**
+   * Removes the default background-context, some borders, and some rounded corners to render accordions edge-to-edge with their parent container.
+   */
+  flush?: boolean;
+  /**
+   * Array of item definitions for data-driven rendering. When provided, children are ignored.
+   */
+  items?: AccordionItemDef[];
+  /**
+   * The shared group name used by items that don't set their own `name`. Defaults to an auto-generated id.
+   */
+  name?: string;
+  /**
+   * Callback fired with the updated set of expanded item keys, reflecting the native `<details>`
+   * elements' actual open state (including items the browser closed itself via a shared `name`
+   * group). Only fires for items rendered via the `items` prop.
+   */
+  onExpandedChange?: (keys: Array<number | string>) => void;
+  /**
+   * Size the component sm or lg.
+   */
+  size?: 'sm' | 'lg';
+}
+declare const Accordion: React.ForwardRefExoticComponent<AccordionProps & React.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/accordion/AccordionBody.d.ts
+type AccordionBodyOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  component?: C;
+};
+type AccordionBodyProps<C extends ElementType = 'div'> = PolymorphicComponentProps<C, AccordionBodyOwnProps<C>>;
+type AccordionBodyComponent = (<C extends ElementType = 'div'>(props: AccordionBodyProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const AccordionBody: AccordionBodyComponent;
+//#endregion
+//#region src/components/accordion/AccordionHeader.d.ts
+interface AccordionHeaderProps extends HTMLAttributes<HTMLElement> {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+}
+declare const AccordionHeader: React.ForwardRefExoticComponent<AccordionHeaderProps & React.RefAttributes<HTMLElement>>;
+//#endregion
+//#region src/components/accordion/AccordionItem.d.ts
+interface AccordionItemProps extends DetailsHTMLAttributes<HTMLDetailsElement> {
+  /**
+   * Let this item stay open when another item opens, overriding the accordion's `alwaysOpen` setting.
+   */
+  alwaysOpen?: boolean;
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * The group this item shares with other items so only one can be open at a time, overriding the
+   * accordion's shared `name`.
+   */
+  name?: string;
+  /**
+   * Start the item in the open state.
+   */
+  open?: boolean;
+  /**
+   * @deprecated No longer used. The native details element manages its own state.
+   */
+  itemKey?: number | string;
+}
+declare const AccordionItem: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDetailsElement>>;
+//#endregion
+export { AccordionBody as a, AccordionItemDef as c, AccordionHeaderProps as i, AccordionProps as l, AccordionItemProps as n, AccordionBodyProps as o, AccordionHeader as r, Accordion as s, AccordionItem as t };
+//# sourceMappingURL=index-Dcc_W6Kv.d.ts.map

package/dist/chunks/index-DceCODH9.d.ts

@@ -0,0 +1,138 @@
+import "./focus-ring-SR_LwaN7.js";
+import { n as PolymorphicRef, r as PolymorphicRefWithFallback, t as PolymorphicComponentProps } from "./polymorphic-CVHbTHSN.js";
+import { n as ContextColor, r as ContextStyle, t as Breakpoint } from "./types-CS_40Txv.js";
+import { i as IconValue } from "./iconConfig-C6gbYhsD.js";
+import React, { ElementType, HTMLAttributes, ReactElement } from "react";
+//#region src/components/navbar/Navbar.d.ts
+type NavbarOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Sets the color of the component to one of Chassis context colors.
+   */
+  color?: ContextColor;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  component?: C;
+  /**
+   * Defines optional container wrapping children elements.
+   */
+  container?: boolean | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'fluid';
+  /**
+   * Opts this navbar into the framework's dark or light theming, independent of the page's own
+   * theme.
+   */
+  'data-cx-theme'?: 'dark' | 'light';
+  /**
+   * Renders inline at and above this breakpoint, as a drawer below it. `true` renders inline at
+   * every width; omit to keep the drawer at every width.
+   */
+  expand?: boolean | Breakpoint;
+  /**
+   * Place component in non-static positions.
+   */
+  placement?: 'fixed-top' | 'fixed-bottom' | 'sticky-top' | 'sticky-bottom';
+  /**
+   * Blurs and saturates whatever sits behind the navbar — useful when it's positioned over a
+   * hero image, video, or scrollable content.
+   */
+  translucent?: boolean;
+  /**
+   * Sets the context style of the component. `basic` (the default) renders with no extra class.
+   */
+  variant?: ContextStyle;
+};
+type NavbarProps<C extends ElementType = 'nav'> = PolymorphicComponentProps<C, NavbarOwnProps<C>>;
+type NavbarComponent = (<C extends ElementType = 'nav'>(props: NavbarProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const Navbar: NavbarComponent;
+//#endregion
+//#region src/components/navbar/NavbarBrand.d.ts
+type NavbarBrandOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   * Defaults to `span`, or `a` when `href` is set.
+   */
+  component?: C;
+  /**
+   * The href attribute specifies the URL of the page the link goes to. Defaults `component` to
+   * `a`.
+   */
+  href?: string;
+};
+type NavbarBrandProps<C extends ElementType = 'span'> = PolymorphicComponentProps<C, NavbarBrandOwnProps<C>>;
+type NavbarBrandComponent = (<C extends ElementType = 'span'>(props: NavbarBrandProps<C> & {
+  ref?: PolymorphicRefWithFallback<C, HTMLSpanElement | HTMLAnchorElement>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const NavbarBrand: NavbarBrandComponent;
+//#endregion
+//#region src/components/navbar/NavbarNav.d.ts
+type NavbarNavOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  component?: C;
+};
+type NavbarNavProps<C extends ElementType = 'ul'> = PolymorphicComponentProps<C, NavbarNavOwnProps<C>>;
+type NavbarNavComponent = (<C extends ElementType = 'ul'>(props: NavbarNavProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const NavbarNav: NavbarNavComponent;
+//#endregion
+//#region src/components/navbar/NavbarText.d.ts
+type NavbarTextOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use a HTML element or a component.
+   */
+  component?: C;
+};
+type NavbarTextProps<C extends ElementType = 'span'> = PolymorphicComponentProps<C, NavbarTextOwnProps<C>>;
+type NavbarTextComponent = (<C extends ElementType = 'span'>(props: NavbarTextProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const NavbarText: NavbarTextComponent;
+//#endregion
+//#region src/components/navbar/NavbarToggler.d.ts
+interface NavbarTogglerProps extends HTMLAttributes<HTMLButtonElement> {
+  /**
+   * A string of all className you want applied to the base component.
+   */
+  className?: string;
+  /**
+   * The toggler icon: an icon name, or an element of your own icon set. Defaults to
+   * `IconProvider`'s `menu` icon.
+   */
+  icon?: IconValue;
+  /**
+   * The accessible label announced by assistive technology when no children are provided.
+   */
+  label?: string;
+}
+declare const NavbarToggler: React.ForwardRefExoticComponent<NavbarTogglerProps & React.RefAttributes<HTMLButtonElement>>;
+//#endregion
+export { NavbarNav as a, NavbarBrandProps as c, NavbarTextProps as i, Navbar as l, NavbarTogglerProps as n, NavbarNavProps as o, NavbarText as r, NavbarBrand as s, NavbarToggler as t, NavbarProps as u };
+//# sourceMappingURL=index-DceCODH9.d.ts.map

package/dist/chunks/index-Ddd7iWfm.d.ts

@@ -0,0 +1,32 @@
+import "./focus-ring-SR_LwaN7.js";
+import { n as PolymorphicRef, t as PolymorphicComponentProps } from "./polymorphic-CVHbTHSN.js";
+import { ElementType, ReactElement } from "react";
+//#region src/components/visually-hidden/VisuallyHidden.d.ts
+type VisuallyHiddenOwnProps<C extends ElementType> = {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Component used for the root node. Either a string to use an HTML element or a component.
+   *
+   * @default 'span'
+   */
+  component?: C;
+  /**
+   * Shows the element while it, or an element inside it, has keyboard focus: a skip link, or a
+   * group of controls only keyboard users reach. Renders `.visually-hidden-focusable` instead of
+   * `.visually-hidden`.
+   */
+  focusable?: boolean;
+};
+type VisuallyHiddenProps<C extends ElementType = 'span'> = PolymorphicComponentProps<C, VisuallyHiddenOwnProps<C>>;
+type VisuallyHiddenComponent = (<C extends ElementType = 'span'>(props: VisuallyHiddenProps<C> & {
+  ref?: PolymorphicRef<C>;
+}) => ReactElement | null) & {
+  displayName?: string;
+};
+declare const VisuallyHidden: VisuallyHiddenComponent;
+//#endregion
+export { VisuallyHiddenProps as n, VisuallyHidden as t };
+//# sourceMappingURL=index-Ddd7iWfm.d.ts.map

package/dist/chunks/index-Dfg4Ftb8.d.ts

@@ -0,0 +1,69 @@
+import "./focus-ring-SR_LwaN7.js";
+import React, { ReactNode, TextareaHTMLAttributes } from "react";
+//#region src/components/textarea/Textarea.d.ts
+interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'defaultValue' | 'onChange' | 'value'> {
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * The value of the textarea, uncontrolled.
+   */
+  defaultValue?: string;
+  /**
+   * Toggle the disabled state for the component.
+   */
+  disabled?: boolean;
+  /**
+   * A description for the field, rendered below the textarea.
+   */
+  help?: ReactNode;
+  /**
+   * Set component validation state to invalid.
+   */
+  invalid?: boolean;
+  /**
+   * An error message for the field, rendered below the textarea when `invalid` is set.
+   */
+  invalidFeedback?: ReactNode;
+  /**
+   * The field's caption, rendered as a `FormLabel` associated with this textarea.
+   */
+  label?: ReactNode;
+  /**
+   * Handler that is called when the value changes.
+   */
+  onChange?: (value: string) => void;
+  /**
+   * Render the component styled as plain text. Removes the default form field styling and preserve the correct margin and padding. Recommend to use only along side `readonly`.
+   */
+  plainText?: boolean;
+  /**
+   * Toggle the readonly state for the component.
+   */
+  readOnly?: boolean;
+  /**
+   * The number of visible text lines for the control.
+   */
+  rows?: number;
+  /**
+   * Size the component sm or lg.
+   */
+  size?: 'sm' | 'lg';
+  /**
+   * Set component validation state to valid.
+   */
+  valid?: boolean;
+  /**
+   * A success message for the field, rendered below the textarea when `valid` is set.
+   */
+  validFeedback?: ReactNode;
+  /**
+   * The value of the textarea, controlled.
+   */
+  value?: string;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+//#endregion
+export { TextareaProps as n, Textarea as t };
+//# sourceMappingURL=index-Dfg4Ftb8.d.ts.map

package/dist/chunks/index-Dfy1YW5j.d.ts

@@ -0,0 +1,74 @@
+import { n as ContextColor, t as Breakpoint } from "./types-CS_40Txv.js";
+import React, { ReactNode, TableHTMLAttributes } from "react";
+//#region src/utils/tableClassName.d.ts
+interface TableStyleProps {
+  /**
+   * Set the vertical alignment of cell content.
+   */
+  align?: 'bottom' | 'middle' | 'top';
+  /**
+   * Add borders on all sides of the table and cells.
+   */
+  bordered?: boolean;
+  /**
+   * Remove borders on all sides of the table and cells.
+   */
+  borderless?: boolean;
+  /**
+   * A string of all className you want applied to the component.
+   */
+  className?: string;
+  /**
+   * Sets the color of the component.
+   */
+  color?: ContextColor;
+  /**
+   * Enable a hover state on table rows.
+   */
+  hover?: boolean;
+  /**
+   * Make any table responsive across all viewports or pick a maximum breakpoint.
+   */
+  responsive?: boolean | Breakpoint;
+  /**
+   * Make table more compact by cutting all cell padding.
+   */
+  sm?: boolean;
+  /**
+   * Convert rows into stacked label/value blocks below a container width, for tables with too
+   * many columns to read comfortably even with horizontal scrolling. `true` always stacks; a
+   * breakpoint name stacks only below it. Implies `responsive` when `responsive` isn't set
+   * separately, since stacking needs the same `.table-responsive` container-query ancestor.
+   */
+  stacked?: boolean | Breakpoint;
+  /**
+   * Add zebra-striping to table rows.
+   */
+  striped?: boolean;
+}
+//#endregion
+//#region src/components/static-table/StaticTable.d.ts
+interface StaticTableProps extends TableStyleProps, Omit<TableHTMLAttributes<HTMLTableElement>, 'align' | 'color'> {
+  /**
+   * Content shown above the table, functioning as a heading for it.
+   */
+  caption?: ReactNode;
+  /**
+   * The table's own markup — plain `<thead>`/`<tbody>`/`<tfoot>`/`<tr>`/`<th>`/`<td>` elements,
+   * rendered as-is.
+   */
+  children?: ReactNode;
+  /**
+   * Convert rows into stacked label/value blocks below a container width, for tables with too
+   * many columns to read comfortably even with horizontal scrolling. `true` always stacks; a
+   * breakpoint name stacks only below it. Implies `responsive` when `responsive` isn't set
+   * separately. Unlike `Table`, which derives each cell's label from its column header, a static
+   * table has no collection to read labels from — give each `<td>` a `data-cell` attribute with
+   * the label to show before its value.
+   */
+  stacked?: TableStyleProps['stacked'];
+}
+declare const StaticTable: React.ForwardRefExoticComponent<StaticTableProps & React.RefAttributes<HTMLTableElement>>;
+//#endregion
+export { StaticTableProps as n, StaticTable as t };
+//# sourceMappingURL=index-Dfy1YW5j.d.ts.map