tgui-core 1.1.11 → 1.1.13

package/dist/components/Stack.js

@@ -0,0 +1,67 @@
+import { jsx as l } from "react/jsx-runtime";
+import { classes as o } from "../common/react.js";
+import { computeBoxClassName as _ } from "./Box.js";
+import { computeFlexClassName as f, computeFlexProps as w, computeFlexItemProps as n } from "./Flex.js";
+import '../assets/Stack.css';const h = "_fill_wrul1_9", p = "_horizontal_wrul1_13", z = "_item_wrul1_13", x = "_vertical_wrul1_20", N = "_reverse_wrul1_27", b = "_reverse__vertical_wrul1_35", S = "_zebra_wrul1_43", k = "_divider_wrul1_47", F = "_divider__hidden_wrul1_47", e = {
+  fill: h,
+  horizontal: p,
+  item: z,
+  vertical: x,
+  reverse: N,
+  reverse__vertical: b,
+  zebra: S,
+  divider: k,
+  divider__hidden: F
+};
+function a(t) {
+  const { className: s, vertical: r, fill: i, reverse: c, zebra: d, ...v } = t, m = r ? "column" : "row", u = c ? "-reverse" : "";
+  return /* @__PURE__ */ l(
+    "div",
+    {
+      className: o([
+        i && e.fill,
+        r ? e.vertical : e.horizontal,
+        d && e.zebra,
+        c && e[`reverse${r ? "__vertical" : ""}`],
+        s,
+        f(t)
+      ]),
+      ...w({
+        direction: `${m}${u}`,
+        ...v
+      })
+    }
+  );
+}
+function I(t) {
+  const { className: s, innerRef: r, ...i } = t;
+  return /* @__PURE__ */ l(
+    "div",
+    {
+      className: o([e.item, s, _(i)]),
+      ref: r,
+      ...n(i)
+    }
+  );
+}
+a.Item = I;
+function P(t) {
+  const { className: s, hidden: r, ...i } = t;
+  return /* @__PURE__ */ l(
+    "div",
+    {
+      className: o([
+        e.item,
+        e.divider,
+        r && e.divider__hidden,
+        s,
+        _(i)
+      ]),
+      ...n(i)
+    }
+  );
+}
+a.Divider = P;
+export {
+  a as Stack
+};

package/dist/components/StyleableSection.d.ts

@@ -0,0 +1,11 @@
+import { PropsWithChildren, ReactNode } from 'react';
+
+type Props = Partial<{
+    style: Record<string, any>;
+    textStyle: Record<string, any>;
+    title: ReactNode;
+    titleStyle: Record<string, any>;
+    titleSubtext: string;
+}> & PropsWithChildren;
+export declare function StyleableSection(props: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/StyleableSection.js

@@ -0,0 +1,16 @@
+import { jsxs as s, jsx as l } from "react/jsx-runtime";
+import { s as t } from "../Section.module-CLVHJ4yA.js";
+import { Box as e } from "./Box.js";
+function h(i) {
+  const { children: r, titleStyle: c, titleSubtext: n, title: o, textStyle: a, style: m } = i;
+  return /* @__PURE__ */ s(e, { style: m, children: [
+    /* @__PURE__ */ s(e, { className: t.title, style: c, children: [
+      /* @__PURE__ */ l(e, { className: t.titleText, style: a, children: o }),
+      /* @__PURE__ */ l("div", { className: t.buttons, children: n })
+    ] }),
+    /* @__PURE__ */ l(e, { className: t.rest, children: /* @__PURE__ */ l(e, { className: t.content, children: r }) })
+  ] });
+}
+export {
+  h as StyleableSection
+};

package/dist/components/Table.d.ts

@@ -0,0 +1,29 @@
+import { BoxProps } from './Box';
+
+type Props = Partial<{
+    /** Collapses table to the smallest possible size. */
+    collapsing: boolean;
+}> & BoxProps;
+export declare function Table(props: Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace Table {
+    var Row: typeof TableRow;
+    var Cell: typeof TableCell;
+}
+type RowProps = Partial<{
+    /** Whether this is a header cell. */
+    header: boolean;
+}> & BoxProps;
+export declare function TableRow(props: RowProps): import("react/jsx-runtime").JSX.Element;
+type CellProps = Partial<{
+    /** Additional columns for this cell to expand, assuming there is room. */
+    colSpan: number;
+    /** Collapses table cell to the smallest possible size,
+    and stops any text inside from wrapping. */
+    collapsing: boolean;
+    /** Whether this is a header cell. */
+    header: boolean;
+    /** Rows for this cell to expand, assuming there is room. */
+    rowSpan: number;
+}> & BoxProps;
+export declare function TableCell(props: CellProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Table.js

@@ -0,0 +1,67 @@
+import { jsx as s } from "react/jsx-runtime";
+import { classes as t } from "../common/react.js";
+import { computeBoxClassName as n, computeBoxProps as r } from "./Box.js";
+import '../assets/Table.css';const m = "_table_1hctn_5", d = "_collapsing_1hctn_13", p = "_row_1hctn_17", g = "_cell_1hctn_21", w = "_row__header_1hctn_32", b = "_cell__header_1hctn_33", u = "_cell__collapsing_1hctn_38", e = {
+  table: m,
+  collapsing: d,
+  row: p,
+  cell: g,
+  row__header: w,
+  cell__header: b,
+  cell__collapsing: u
+};
+function h(l) {
+  const { className: c, collapsing: o, children: _, ...a } = l;
+  return /* @__PURE__ */ s(
+    "table",
+    {
+      className: t([
+        e.table,
+        o && e.collapsing,
+        c,
+        n(a)
+      ]),
+      ...r(a),
+      children: /* @__PURE__ */ s("tbody", { children: _ })
+    }
+  );
+}
+function N(l) {
+  const { className: c, header: o, ..._ } = l;
+  return /* @__PURE__ */ s(
+    "tr",
+    {
+      className: t([
+        e.row,
+        o && e.row__header,
+        c,
+        n(l)
+      ]),
+      ...r(_)
+    }
+  );
+}
+h.Row = N;
+function f(l) {
+  const { className: c, collapsing: o, colSpan: _, header: a, ...i } = l;
+  return /* @__PURE__ */ s(
+    "td",
+    {
+      className: t([
+        e.cell,
+        o && e.cell__collapsing,
+        a && e.cell__header,
+        c,
+        n(l)
+      ]),
+      colSpan: _,
+      ...r(i)
+    }
+  );
+}
+h.Cell = f;
+export {
+  h as Table,
+  f as TableCell,
+  N as TableRow
+};

package/dist/components/Tabs.d.ts

@@ -0,0 +1,23 @@
+import { PropsWithChildren, ReactNode } from 'react';
+import { BoxProps } from './Box';
+
+type Props = Partial<{
+    className: string;
+    fill: boolean;
+    fluid: boolean;
+    vertical: boolean;
+}> & BoxProps & PropsWithChildren;
+type TabProps = Partial<{
+    className: string;
+    color: string;
+    icon: string;
+    leftSlot: ReactNode;
+    onClick: (e?: any) => void;
+    rightSlot: ReactNode;
+    selected: boolean;
+}> & BoxProps & PropsWithChildren;
+export declare function Tabs(props: Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace Tabs {
+    var Tab: (props: TabProps) => import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/dist/components/Tabs.js

@@ -0,0 +1,89 @@
+import { jsx as o, jsxs as f } from "react/jsx-runtime";
+import { classes as h, canRender as i } from "../common/react.js";
+import { computeBoxClassName as b, computeBoxProps as d } from "./Box.js";
+import { Icon as m } from "./Icon.js";
+import '../assets/Tabs.css';const v = "_tabs_9h380_13", p = "_fill_9h380_20", u = "_vertical_9h380_35", w = "_horizontal_9h380_40", x = "_tabs__tab_9h380_48", y = "_fluid_9h380_52", N = "_tab_9h380_13", k = "_selected_9h380_66", z = "_tab__text_9h380_75", T = "_tab__left_9h380_80", j = "_tab__right_9h380_86", B = "_color__black_9h380_113", S = "_color__white_9h380_125", C = "_color__red_9h380_137", I = "_color__orange_9h380_149", P = "_color__yellow_9h380_161", R = "_color__olive_9h380_173", q = "_color__green_9h380_185", A = "_color__teal_9h380_197", D = "_color__blue_9h380_209", E = "_color__violet_9h380_221", F = "_color__purple_9h380_233", G = "_color__pink_9h380_245", H = "_color__brown_9h380_257", J = "_color__grey_9h380_269", K = "_color__good_9h380_293", L = "_color__average_9h380_305", M = "_color__bad_9h380_317", O = "_color__label_9h380_329", _ = {
+  tabs: v,
+  fill: p,
+  vertical: u,
+  horizontal: w,
+  tabs__tab: x,
+  fluid: y,
+  tab: N,
+  selected: k,
+  tab__text: z,
+  tab__left: T,
+  tab__right: j,
+  color__black: B,
+  color__white: S,
+  color__red: C,
+  color__orange: I,
+  color__yellow: P,
+  color__olive: R,
+  color__green: q,
+  color__teal: A,
+  color__blue: D,
+  color__violet: E,
+  color__purple: F,
+  color__pink: G,
+  color__brown: H,
+  color__grey: J,
+  "color__light-grey": "_color__light-grey_9h380_281",
+  color__good: K,
+  color__average: L,
+  color__bad: M,
+  color__label: O
+};
+function Q(r) {
+  const { className: e, vertical: a, fill: s, fluid: c, children: t, ...l } = r;
+  return /* @__PURE__ */ o(
+    "div",
+    {
+      className: h([
+        _.tabs,
+        a ? _.vertical : _.horizontal,
+        s && _.fill,
+        c && _.fluid,
+        e,
+        b(l)
+      ]),
+      ...d(l),
+      children: t
+    }
+  );
+}
+function U(r) {
+  const {
+    className: e,
+    selected: a,
+    color: s,
+    icon: c,
+    leftSlot: t,
+    rightSlot: l,
+    children: g,
+    ...n
+  } = r;
+  return /* @__PURE__ */ f(
+    "div",
+    {
+      className: h([
+        _.tab,
+        _.tabs__tab,
+        _["color__" + s],
+        a && _.selected,
+        e,
+        b(n)
+      ]),
+      ...d(n),
+      children: [
+        i(t) && /* @__PURE__ */ o("div", { className: _.tab__left, children: t }) || !!c && /* @__PURE__ */ o("div", { className: _.tab__left, children: /* @__PURE__ */ o(m, { name: c }) }),
+        /* @__PURE__ */ o("div", { className: _.tab__text, children: g }),
+        i(l) && /* @__PURE__ */ o("div", { className: _.tab__right, children: l })
+      ]
+    }
+  );
+}
+Q.Tab = U;
+export {
+  Q as Tabs
+};

package/dist/components/TextArea.d.ts

@@ -0,0 +1,39 @@
+import { SyntheticEvent } from 'react';
+
+export declare const TextArea: import('react').ForwardRefExoticComponent<Partial<{
+    autoFocus: boolean;
+    autoSelect: boolean;
+    displayedValue: string;
+    dontUseTabForIndent: boolean;
+    fluid: boolean;
+    maxLength: number;
+    noborder: boolean;
+    /** Fires when user is 'done typing': Clicked out, blur, enter key (but not shift+enter) */
+    onChange: (event: SyntheticEvent<HTMLTextAreaElement>, value: string) => void;
+    /** Fires once the enter key is pressed */
+    onEnter: (event: SyntheticEvent<HTMLTextAreaElement>, value: string) => void;
+    /** Fires once the escape key is pressed */
+    onEscape: (event: SyntheticEvent<HTMLTextAreaElement>) => void;
+    /** Fires on each key press / value change. Used for searching */
+    onInput: (event: SyntheticEvent<HTMLTextAreaElement>, value: string) => void;
+    placeholder: string;
+    scrollbar: boolean;
+    selfClear: boolean;
+    value: string;
+}> & Partial<{
+    as: string;
+    children: import('react').ReactNode;
+    className: string | import('../common/react').BooleanLike;
+    style: import('react').CSSProperties;
+}> & Partial<Record<"bold" | "italic" | "nowrap" | "fillPositionedParent" | "inline" | "preserveWhitespace", boolean>> & Partial<Record<"fontWeight" | "textAlign" | "bottom" | "fontFamily" | "fontSize" | "height" | "left" | "maxHeight" | "maxWidth" | "minHeight" | "minWidth" | "opacity" | "overflow" | "overflowX" | "overflowY" | "position" | "right" | "top" | "verticalAlign" | "width" | "color" | "backgroundColor" | "align" | "lineHeight" | "m" | "mb" | "ml" | "mr" | "mt" | "mx" | "my" | "p" | "pb" | "pl" | "pr" | "pt" | "px" | "py" | "textColor", string | import('../common/react').BooleanLike>> & Partial<{
+    onClick: import('react').MouseEventHandler<HTMLDivElement>;
+    onContextMenu: import('react').MouseEventHandler<HTMLDivElement>;
+    onDoubleClick: import('react').MouseEventHandler<HTMLDivElement>;
+    onKeyDown: import('react').KeyboardEventHandler<HTMLDivElement>;
+    onKeyUp: import('react').KeyboardEventHandler<HTMLDivElement>;
+    onMouseDown: import('react').MouseEventHandler<HTMLDivElement>;
+    onMouseMove: import('react').MouseEventHandler<HTMLDivElement>;
+    onMouseOver: import('react').MouseEventHandler<HTMLDivElement>;
+    onMouseUp: import('react').MouseEventHandler<HTMLDivElement>;
+    onScroll: import('react').UIEventHandler<HTMLDivElement>;
+}> & import('react').RefAttributes<HTMLTextAreaElement>>;

package/dist/components/TextArea.js

@@ -0,0 +1,118 @@
+import { jsxs as I, jsx as f } from "react/jsx-runtime";
+import { forwardRef as Y, useRef as C, useState as H, useImperativeHandle as L, useEffect as g } from "react";
+import { KEY as p } from "../common/keys.js";
+import { classes as d } from "../common/react.js";
+import { Box as P } from "./Box.js";
+import { toInputValue as T } from "./Input.js";
+import '../assets/TextArea.css';const U = "_textArea_1bert_20", $ = "_fluid_1bert_33", q = "_noborder_1bert_39", z = "_inner_1bert_43", G = "_scrollable_1bert_43", J = "_custom_1bert_78", M = "_nowrap_1bert_83", O = "_wrapper_1bert_89", e = {
+  textArea: U,
+  fluid: $,
+  noborder: q,
+  inner: z,
+  scrollable: G,
+  custom: J,
+  nowrap: M,
+  wrapper: O
+}, er = Y(
+  (x, w) => {
+    const {
+      autoFocus: m,
+      autoSelect: l,
+      displayedValue: a,
+      dontUseTabForIndent: y,
+      maxLength: h,
+      noborder: A,
+      onChange: s,
+      onEnter: n,
+      onEscape: u,
+      onInput: c,
+      placeholder: N,
+      scrollbar: S,
+      selfClear: b,
+      value: i,
+      ...E
+    } = x, { className: K, fluid: k, nowrap: D, ...R } = E, t = C(null), [V, j] = H(0);
+    function B(r) {
+      if (r.key === p.Enter) {
+        if (r.shiftKey) {
+          r.currentTarget.focus();
+          return;
+        }
+        n == null || n(r, r.currentTarget.value), b && (r.currentTarget.value = ""), r.currentTarget.blur();
+        return;
+      }
+      if (r.key === p.Escape) {
+        u == null || u(r), b ? r.currentTarget.value = "" : (r.currentTarget.value = T(i), r.currentTarget.blur());
+        return;
+      }
+      if (!y && r.key === p.Tab) {
+        r.preventDefault();
+        const { value: o, selectionStart: _, selectionEnd: F } = r.currentTarget;
+        r.currentTarget.value = o.substring(0, _) + "	" + o.substring(F), r.currentTarget.selectionEnd = _ + 1;
+      }
+    }
+    return L(
+      w,
+      () => t.current
+    ), g(() => {
+      if (!m && !l) return;
+      const r = t.current;
+      r && (m || l) && setTimeout(() => {
+        r.focus(), l && r.select();
+      }, 1);
+    }, []), g(() => {
+      const r = t.current;
+      if (!r) return;
+      const o = T(i);
+      r.value !== o && (r.value = o);
+    }, [i]), /* @__PURE__ */ I(
+      P,
+      {
+        className: d([
+          e.textArea,
+          k && e.fluid,
+          A && e.noborder,
+          K
+        ]),
+        ...R,
+        children: [
+          !!a && /* @__PURE__ */ f("div", { className: e.wrapper, children: /* @__PURE__ */ f(
+            "div",
+            {
+              className: d([e.inner, e.custom]),
+              style: {
+                transform: `translateY(-${V}px)`
+              },
+              children: a
+            }
+          ) }),
+          /* @__PURE__ */ f(
+            "textarea",
+            {
+              className: d([
+                e.inner,
+                S && e.scrollable,
+                D && e.nowrap
+              ]),
+              maxLength: h,
+              onBlur: (r) => s == null ? void 0 : s(r, r.target.value),
+              onChange: (r) => c == null ? void 0 : c(r, r.target.value),
+              onKeyDown: B,
+              onScroll: () => {
+                a && t.current && j(t.current.scrollTop);
+              },
+              placeholder: N,
+              ref: t,
+              style: {
+                color: a ? "rgba(0, 0, 0, 0)" : "inherit"
+              }
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+export {
+  er as TextArea
+};

package/dist/components/TimeDisplay.js

@@ -0,0 +1,34 @@
+import { Component as r } from "react";
+import { formatTime as u } from "../common/format.js";
+function s(e) {
+  return typeof e == "number" && Number.isFinite(e) && !Number.isNaN(e);
+}
+class o extends r {
+  constructor(t) {
+    super(t), this.timer = null, this.last_seen_value = void 0, this.state = {
+      value: 0
+    }, s(t.value) && (this.state.value = Number(t.value), this.last_seen_value = Number(t.value));
+  }
+  componentDidUpdate() {
+    this.props.auto !== void 0 && (clearInterval(this.timer), this.timer = setInterval(() => this.tick(), 1e3));
+  }
+  tick() {
+    let t = Number(this.state.value);
+    this.props.value !== this.last_seen_value && (this.last_seen_value = this.props.value, t = this.props.value);
+    const i = this.props.auto === "up" ? 10 : -10, a = Math.max(0, t + i);
+    this.setState({ value: a });
+  }
+  componentDidMount() {
+    this.props.auto !== void 0 && (this.timer = setInterval(() => this.tick(), 1e3));
+  }
+  componentWillUnmount() {
+    clearInterval(this.timer);
+  }
+  render() {
+    const t = this.state.value;
+    return s(t) ? u(t) : this.state.value || null;
+  }
+}
+export {
+  o as TimeDisplay
+};

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,29 @@
+import { createPopper, Placement, VirtualElement } from '@popperjs/core';
+import { Component, ReactNode } from 'react';
+
+type Props = {
+    /** The content to display in the tooltip */
+    content: ReactNode;
+} & Partial<{
+    /** Hovering this element will show the tooltip */
+    children: ReactNode;
+    /** Where to place the tooltip relative to the reference element */
+    position: Placement;
+}>;
+type State = {
+    hovered: boolean;
+};
+export declare class Tooltip extends Component<Props, State> {
+    static renderedTooltip: HTMLDivElement | undefined;
+    static singletonPopper: ReturnType<typeof createPopper> | undefined;
+    static currentHoveredElement: Element | undefined;
+    static virtualElement: VirtualElement;
+    getDOMNode(): Element;
+    componentDidMount(): void;
+    fadeOut(): void;
+    renderPopperContent(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    render(): ReactNode;
+}
+export {};

package/dist/components/Tooltip.js

@@ -0,0 +1,83 @@
+import '../assets/Tooltip.css';var s = Object.defineProperty;
+var p = (o, e, n) => e in o ? s(o, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : o[e] = n;
+var r = (o, e, n) => p(o, typeof e != "symbol" ? e + "" : e, n);
+import { jsx as l } from "react/jsx-runtime";
+import { Component as c } from "react";
+import { findDOMNode as m, render as a } from "react-dom";
+import { c as u } from "../popper-CiqSDJTE.js";
+const h = "_tooltip_1pib4_13", f = {
+  tooltip: h
+}, i = {
+  modifiers: [
+    {
+      name: "eventListeners",
+      enabled: !1
+    }
+  ]
+}, v = {
+  width: 0,
+  height: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  x: 0,
+  y: 0,
+  toJSON: () => null
+}, t = class t extends c {
+  getDOMNode() {
+    return m(this);
+  }
+  componentDidMount() {
+    const e = this.getDOMNode();
+    e && (e.addEventListener("mouseenter", () => {
+      let n = t.renderedTooltip;
+      n === void 0 && (n = document.createElement("div"), n.className = f.tooltip, document.body.appendChild(n), t.renderedTooltip = n), t.currentHoveredElement = e, n.style.opacity = "1", this.renderPopperContent();
+    }), e.addEventListener("mouseleave", () => {
+      this.fadeOut();
+    }));
+  }
+  fadeOut() {
+    t.currentHoveredElement === this.getDOMNode() && (t.currentHoveredElement = void 0, t.renderedTooltip.style.opacity = "0");
+  }
+  renderPopperContent() {
+    const e = t.renderedTooltip;
+    e && a(/* @__PURE__ */ l("span", { children: this.props.content }), e, () => {
+      let n = t.singletonPopper;
+      n === void 0 ? (n = u(
+        t.virtualElement,
+        e,
+        {
+          ...i,
+          placement: this.props.position || "auto"
+        }
+      ), t.singletonPopper = n) : (n.setOptions({
+        ...i,
+        placement: this.props.position || "auto"
+      }), n.update());
+    });
+  }
+  componentDidUpdate() {
+    t.currentHoveredElement === this.getDOMNode() && this.renderPopperContent();
+  }
+  componentWillUnmount() {
+    this.fadeOut();
+  }
+  render() {
+    return this.props.children;
+  }
+};
+// Mounting poppers is really laggy because popper.js is very slow.
+// Thus, instead of using the Popper component, Tooltip creates ONE popper
+// and stores every tooltip inside that.
+// This means you can never have two tooltips at once, for instance.
+r(t, "renderedTooltip"), r(t, "singletonPopper"), r(t, "currentHoveredElement"), r(t, "virtualElement", {
+  getBoundingClientRect: () => {
+    var e;
+    return ((e = t.currentHoveredElement) == null ? void 0 : e.getBoundingClientRect()) ?? v;
+  }
+});
+let d = t;
+export {
+  d as Tooltip
+};

package/dist/components/TrackOutsideClicks.d.ts

@@ -0,0 +1,13 @@
+import { Component, PropsWithChildren } from 'react';
+
+type Props = {
+    onOutsideClick: () => void;
+} & PropsWithChildren;
+export declare class TrackOutsideClicks extends Component<Props> {
+    ref: import('react').RefObject<HTMLDivElement>;
+    constructor(props: any);
+    componentWillUnmount(): void;
+    handleOutsideClick(event: MouseEvent): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/dist/components/TrackOutsideClicks.js

@@ -0,0 +1,24 @@
+var n = Object.defineProperty;
+var s = (i, t, e) => t in i ? n(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var r = (i, t, e) => s(i, typeof t != "symbol" ? t + "" : t, e);
+import { jsx as c } from "react/jsx-runtime";
+import { Component as d, createRef as o } from "react";
+class a extends d {
+  constructor(e) {
+    super(e);
+    r(this, "ref", o());
+    this.handleOutsideClick = this.handleOutsideClick.bind(this), document.addEventListener("click", this.handleOutsideClick);
+  }
+  componentWillUnmount() {
+    document.removeEventListener("click", this.handleOutsideClick);
+  }
+  handleOutsideClick(e) {
+    e.target instanceof Node && this.ref.current && !this.ref.current.contains(e.target) && this.props.onOutsideClick();
+  }
+  render() {
+    return /* @__PURE__ */ c("div", { ref: this.ref, children: this.props.children });
+  }
+}
+export {
+  a as TrackOutsideClicks
+};

package/dist/components/VirtualList.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+
+/**
+ * A vertical list that renders items to fill space up to the extents of the
+ * current window, and then defers rendering of other items until they come
+ * into view.
+ */
+export declare function VirtualList(props: PropsWithChildren): import("react/jsx-runtime").JSX.Element;