@sisense/sdk-shared-ui 1.27.1 → 1.29.0

package/dist/useSlot-7x9FkqBW.js

@@ -0,0 +1,720 @@
+import * as f from "react";
+import k from "react";
+import { P as e } from "./index-D0lMis-I.js";
+import { o as lt, n as ct } from "./ThemeProvider-BCsnqK18.js";
+import { u as pt } from "./useTheme-eCVqNAnk.js";
+import { jsx as ft } from "react/jsx-runtime";
+import { _ as dt, T as Q, c as Y, b as Et, u as q, e as W, s as X } from "./useTimeout-BG7TPjEm.js";
+import { _ as mt } from "./setPrototypeOf-CEtRTXk2.js";
+import * as ht from "react-dom";
+import V from "react-dom";
+import { r as xt, m as gt, a as vt } from "./useSlotProps-BpXHXb21.js";
+function Tt() {
+  const n = pt(ct);
+  return process.env.NODE_ENV !== "production" && f.useDebugValue(n), n[lt] || n;
+}
+const z = {
+  disabled: !1
+};
+var yt = process.env.NODE_ENV !== "production" ? e.oneOfType([e.number, e.shape({
+  enter: e.number,
+  exit: e.number,
+  appear: e.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && e.oneOfType([e.string, e.shape({
+  enter: e.string,
+  exit: e.string,
+  active: e.string
+}), e.shape({
+  enter: e.string,
+  enterDone: e.string,
+  enterActive: e.string,
+  exit: e.string,
+  exitDone: e.string,
+  exitActive: e.string
+})]);
+var bt = function(s) {
+  return s.scrollTop;
+}, I = "unmounted", T = "exited", y = "entering", C = "entered", G = "exiting", h = /* @__PURE__ */ function(n) {
+  dt(s, n);
+  function s(i, o) {
+    var t;
+    t = n.call(this, i, o) || this;
+    var r = o, u = r && !r.isMounting ? i.enter : i.appear, l;
+    return t.appearStatus = null, i.in ? u ? (l = T, t.appearStatus = y) : l = C : i.unmountOnExit || i.mountOnEnter ? l = I : l = T, t.state = {
+      status: l
+    }, t.nextCallback = null, t;
+  }
+  s.getDerivedStateFromProps = function(o, t) {
+    var r = o.in;
+    return r && t.status === I ? {
+      status: T
+    } : null;
+  };
+  var a = s.prototype;
+  return a.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, a.componentDidUpdate = function(o) {
+    var t = null;
+    if (o !== this.props) {
+      var r = this.state.status;
+      this.props.in ? r !== y && r !== C && (t = y) : (r === y || r === C) && (t = G);
+    }
+    this.updateStatus(!1, t);
+  }, a.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, a.getTimeouts = function() {
+    var o = this.props.timeout, t, r, u;
+    return t = r = u = o, o != null && typeof o != "number" && (t = o.exit, r = o.enter, u = o.appear !== void 0 ? o.appear : r), {
+      exit: t,
+      enter: r,
+      appear: u
+    };
+  }, a.updateStatus = function(o, t) {
+    if (o === void 0 && (o = !1), t !== null)
+      if (this.cancelNextCallback(), t === y) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var r = this.props.nodeRef ? this.props.nodeRef.current : V.findDOMNode(this);
+          r && bt(r);
+        }
+        this.performEnter(o);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === T && this.setState({
+      status: I
+    });
+  }, a.performEnter = function(o) {
+    var t = this, r = this.props.enter, u = this.context ? this.context.isMounting : o, l = this.props.nodeRef ? [u] : [V.findDOMNode(this), u], p = l[0], d = l[1], v = this.getTimeouts(), b = u ? v.appear : v.enter;
+    if (!o && !r || z.disabled) {
+      this.safeSetState({
+        status: C
+      }, function() {
+        t.props.onEntered(p);
+      });
+      return;
+    }
+    this.props.onEnter(p, d), this.safeSetState({
+      status: y
+    }, function() {
+      t.props.onEntering(p, d), t.onTransitionEnd(b, function() {
+        t.safeSetState({
+          status: C
+        }, function() {
+          t.props.onEntered(p, d);
+        });
+      });
+    });
+  }, a.performExit = function() {
+    var o = this, t = this.props.exit, r = this.getTimeouts(), u = this.props.nodeRef ? void 0 : V.findDOMNode(this);
+    if (!t || z.disabled) {
+      this.safeSetState({
+        status: T
+      }, function() {
+        o.props.onExited(u);
+      });
+      return;
+    }
+    this.props.onExit(u), this.safeSetState({
+      status: G
+    }, function() {
+      o.props.onExiting(u), o.onTransitionEnd(r.exit, function() {
+        o.safeSetState({
+          status: T
+        }, function() {
+          o.props.onExited(u);
+        });
+      });
+    });
+  }, a.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, a.safeSetState = function(o, t) {
+    t = this.setNextCallback(t), this.setState(o, t);
+  }, a.setNextCallback = function(o) {
+    var t = this, r = !0;
+    return this.nextCallback = function(u) {
+      r && (r = !1, t.nextCallback = null, o(u));
+    }, this.nextCallback.cancel = function() {
+      r = !1;
+    }, this.nextCallback;
+  }, a.onTransitionEnd = function(o, t) {
+    this.setNextCallback(t);
+    var r = this.props.nodeRef ? this.props.nodeRef.current : V.findDOMNode(this), u = o == null && !this.props.addEndListener;
+    if (!r || u) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var l = this.props.nodeRef ? [this.nextCallback] : [r, this.nextCallback], p = l[0], d = l[1];
+      this.props.addEndListener(p, d);
+    }
+    o != null && setTimeout(this.nextCallback, o);
+  }, a.render = function() {
+    var o = this.state.status;
+    if (o === I)
+      return null;
+    var t = this.props, r = t.children;
+    t.in, t.mountOnEnter, t.unmountOnExit, t.appear, t.enter, t.exit, t.timeout, t.addEndListener, t.onEnter, t.onEntering, t.onEntered, t.onExit, t.onExiting, t.onExited, t.nodeRef;
+    var u = mt(t, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ k.createElement(Q.Provider, {
+        value: null
+      }, typeof r == "function" ? r(o, u) : k.cloneElement(k.Children.only(r), u))
+    );
+  }, s;
+}(k.Component);
+h.contextType = Q;
+h.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: e.shape({
+    current: typeof Element > "u" ? e.any : function(n, s, a, i, o, t) {
+      var r = n[s];
+      return e.instanceOf(r && "ownerDocument" in r ? r.ownerDocument.defaultView.Element : Element)(n, s, a, i, o, t);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: e.oneOfType([e.func.isRequired, e.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: e.bool,
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: e.bool,
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: e.bool,
+  /**
+   * By default the child component does not perform the enter transition when
+   * it first mounts, regardless of the value of `in`. If you want this
+   * behavior, set both `appear` and `in` to `true`.
+   *
+   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
+   * > only adds an additional enter transition. However, in the
+   * > `<CSSTransition>` component that first enter transition does result in
+   * > additional `.appear-*` classes, that way you can choose to style it
+   * > differently.
+   */
+  appear: e.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: e.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: e.bool,
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function(s) {
+    var a = yt;
+    s.addEndListener || (a = a.isRequired);
+    for (var i = arguments.length, o = new Array(i > 1 ? i - 1 : 0), t = 1; t < i; t++)
+      o[t - 1] = arguments[t];
+    return a.apply(void 0, [s].concat(o));
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: e.func,
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: e.func,
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: e.func,
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: e.func,
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: e.func,
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: e.func,
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: e.func
+} : {};
+function P() {
+}
+h.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: P,
+  onEntering: P,
+  onEntered: P,
+  onExit: P,
+  onExiting: P,
+  onExited: P
+};
+h.UNMOUNTED = I;
+h.EXITED = T;
+h.ENTERING = y;
+h.ENTERED = C;
+h.EXITING = G;
+function Nt(n) {
+  const {
+    prototype: s = {}
+  } = n;
+  return !!s.isReactComponent;
+}
+function Z(n, s, a, i, o) {
+  const t = n[s], r = o || s;
+  if (t == null || // When server-side rendering React doesn't warn either.
+  // This is not an accurate check for SSR.
+  // This is only in place for Emotion compat.
+  // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
+  typeof window > "u")
+    return null;
+  let u;
+  const l = t.type;
+  return typeof l == "function" && !Nt(l) && (u = "Did you accidentally use a plain function component for an element instead?"), u !== void 0 ? new Error(`Invalid ${i} \`${r}\` supplied to \`${a}\`. Expected an element that can hold a ref. ${u} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const tt = Y(e.element, Z);
+tt.isRequired = Y(e.element.isRequired, Z);
+function et(n) {
+  var s;
+  return parseInt(f.version, 10) >= 19 ? ((s = n == null ? void 0 : n.props) == null ? void 0 : s.ref) || null : (n == null ? void 0 : n.ref) || null;
+}
+const Dt = (n) => n.scrollTop;
+function B(n, s) {
+  const {
+    timeout: a,
+    easing: i,
+    style: o = {}
+  } = n;
+  return {
+    duration: o.transitionDuration ?? (typeof a == "number" ? a : a[s.mode] || 0),
+    easing: o.transitionTimingFunction ?? (typeof i == "object" ? i[s.mode] : i),
+    delay: o.transitionDelay
+  };
+}
+function H(n) {
+  return `scale(${n}, ${n ** 2})`;
+}
+const Rt = {
+  entering: {
+    opacity: 1,
+    transform: H(1)
+  },
+  entered: {
+    opacity: 1,
+    transform: "none"
+  }
+}, F = typeof navigator < "u" && /^((?!chrome|android).)*(safari|mobile)/i.test(navigator.userAgent) && /(os |version\/)15(.|_)4/i.test(navigator.userAgent), U = /* @__PURE__ */ f.forwardRef(function(s, a) {
+  const {
+    addEndListener: i,
+    appear: o = !0,
+    children: t,
+    easing: r,
+    in: u,
+    onEnter: l,
+    onEntered: p,
+    onEntering: d,
+    onExit: v,
+    onExited: b,
+    onExiting: N,
+    style: D,
+    timeout: E = "auto",
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: $ = h,
+    ...A
+  } = s, _ = Et(), w = f.useRef(), R = Tt(), L = f.useRef(null), nt = q(L, et(t), a), O = (c) => (x) => {
+    if (c) {
+      const g = L.current;
+      x === void 0 ? c(g) : c(g, x);
+    }
+  }, ot = O(d), rt = O((c, x) => {
+    Dt(c);
+    const {
+      duration: g,
+      delay: M,
+      easing: m
+    } = B({
+      style: D,
+      timeout: E,
+      easing: r
+    }, {
+      mode: "enter"
+    });
+    let S;
+    E === "auto" ? (S = R.transitions.getAutoHeightDuration(c.clientHeight), w.current = S) : S = g, c.style.transition = [R.transitions.create("opacity", {
+      duration: S,
+      delay: M
+    }), R.transitions.create("transform", {
+      duration: F ? S : S * 0.666,
+      delay: M,
+      easing: m
+    })].join(","), l && l(c, x);
+  }), it = O(p), st = O(N), at = O((c) => {
+    const {
+      duration: x,
+      delay: g,
+      easing: M
+    } = B({
+      style: D,
+      timeout: E,
+      easing: r
+    }, {
+      mode: "exit"
+    });
+    let m;
+    E === "auto" ? (m = R.transitions.getAutoHeightDuration(c.clientHeight), w.current = m) : m = x, c.style.transition = [R.transitions.create("opacity", {
+      duration: m,
+      delay: g
+    }), R.transitions.create("transform", {
+      duration: F ? m : m * 0.666,
+      delay: F ? g : g || m * 0.333,
+      easing: M
+    })].join(","), c.style.opacity = 0, c.style.transform = H(0.75), v && v(c);
+  }), ut = O(b);
+  return /* @__PURE__ */ ft($, {
+    appear: o,
+    in: u,
+    nodeRef: L,
+    onEnter: rt,
+    onEntered: it,
+    onEntering: ot,
+    onExit: at,
+    onExited: ut,
+    onExiting: st,
+    addEndListener: (c) => {
+      E === "auto" && _.start(w.current || 0, c), i && i(L.current, c);
+    },
+    timeout: E === "auto" ? null : E,
+    ...A,
+    children: (c, x) => /* @__PURE__ */ f.cloneElement(t, {
+      style: {
+        opacity: 0,
+        transform: H(0.75),
+        visibility: c === "exited" && !u ? "hidden" : void 0,
+        ...Rt[c],
+        ...D,
+        ...t.props.style
+      },
+      ref: nt,
+      ...x
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (U.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Add a custom transition end trigger. Called with the transitioning DOM
+   * node and a done callback. Allows for more fine grained transition end
+   * logic. Note: Timeouts are still used as a fallback if provided.
+   */
+  addEndListener: e.func,
+  /**
+   * Perform the enter transition when it first mounts if `in` is also `true`.
+   * Set this to `false` to disable this behavior.
+   * @default true
+   */
+  appear: e.bool,
+  /**
+   * A single child content element.
+   */
+  children: tt.isRequired,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: e.oneOfType([e.shape({
+    enter: e.string,
+    exit: e.string
+  }), e.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: e.bool,
+  /**
+   * @ignore
+   */
+  onEnter: e.func,
+  /**
+   * @ignore
+   */
+  onEntered: e.func,
+  /**
+   * @ignore
+   */
+  onEntering: e.func,
+  /**
+   * @ignore
+   */
+  onExit: e.func,
+  /**
+   * @ignore
+   */
+  onExited: e.func,
+  /**
+   * @ignore
+   */
+  onExiting: e.func,
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   *
+   * Set to 'auto' to automatically calculate transition time based on height.
+   * @default 'auto'
+   */
+  timeout: e.oneOfType([e.oneOf(["auto"]), e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })])
+});
+U && (U.muiSupportAuto = !0);
+function Ot(n, s, a, i, o) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const t = n[s], r = o || s;
+  return t == null ? null : t && t.nodeType !== 1 ? new Error(`Invalid ${i} \`${r}\` supplied to \`${a}\`. Expected an HTMLElement.`) : null;
+}
+const St = "exact-prop: ​";
+function Pt(n) {
+  return process.env.NODE_ENV === "production" ? n : {
+    ...n,
+    [St]: (s) => {
+      const a = Object.keys(s).filter((i) => !n.hasOwnProperty(i));
+      return a.length > 0 ? new Error(`The following props are not supported: ${a.map((i) => `\`${i}\``).join(", ")}. Please remove them.`) : null;
+    }
+  };
+}
+function Ut(n) {
+  return n && n.ownerDocument || document;
+}
+let K = 0;
+function Ct(n) {
+  const [s, a] = f.useState(n), i = n || s;
+  return f.useEffect(() => {
+    s == null && (K += 1, a(`mui-${K}`));
+  }, [s]), i;
+}
+const wt = {
+  ...f
+}, J = wt.useId;
+function jt(n) {
+  if (J !== void 0) {
+    const s = J();
+    return n ?? s;
+  }
+  return Ct(n);
+}
+function It(n) {
+  return typeof n == "function" ? n() : n;
+}
+const j = /* @__PURE__ */ f.forwardRef(function(s, a) {
+  const {
+    children: i,
+    container: o,
+    disablePortal: t = !1
+  } = s, [r, u] = f.useState(null), l = q(/* @__PURE__ */ f.isValidElement(i) ? et(i) : null, a);
+  if (W(() => {
+    t || u(It(o) || document.body);
+  }, [o, t]), W(() => {
+    if (r && !t)
+      return X(a, r), () => {
+        X(a, null);
+      };
+  }, [a, r, t]), t) {
+    if (/* @__PURE__ */ f.isValidElement(i)) {
+      const p = {
+        ref: l
+      };
+      return /* @__PURE__ */ f.cloneElement(i, p);
+    }
+    return i;
+  }
+  return r && /* @__PURE__ */ ht.createPortal(i, r);
+});
+process.env.NODE_ENV !== "production" && (j.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The children to render into the `container`.
+   */
+  children: e.node,
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: e.oneOfType([Ot, e.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: e.bool
+});
+process.env.NODE_ENV !== "production" && (j.propTypes = Pt(j.propTypes));
+function qt(n, s) {
+  const {
+    className: a,
+    elementType: i,
+    ownerState: o,
+    externalForwardedProps: t,
+    internalForwardedProps: r,
+    ...u
+  } = s, {
+    component: l,
+    slots: p = {
+      [n]: void 0
+    },
+    slotProps: d = {
+      [n]: void 0
+    },
+    ...v
+  } = t, b = p[n] || i, N = xt(d[n], o), {
+    props: {
+      component: D,
+      ...E
+    },
+    internalRef: $
+  } = gt({
+    className: a,
+    ...u,
+    externalForwardedProps: n === "root" ? v : void 0,
+    externalSlotProps: N
+  }), A = q($, N == null ? void 0 : N.ref, s.ref), _ = n === "root" ? D || l : D, w = vt(b, {
+    ...n === "root" && !l && !p[n] && r,
+    ...n !== "root" && !p[n] && r,
+    ...E,
+    ..._ && {
+      as: _
+    },
+    ref: A
+  }, o);
+  return [b, w];
+}
+export {
+  U as G,
+  Ot as H,
+  j as P,
+  h as T,
+  jt as a,
+  qt as b,
+  Pt as c,
+  B as d,
+  tt as e,
+  et as g,
+  Ut as o,
+  Dt as r,
+  Tt as u
+};