react-ecosistema-unp 1.7.1 → 1.7.2-pre.0

package/dist/TabPane-BiwPZSbT.js

@@ -0,0 +1,752 @@
+import * as S from "react";
+import C, { useRef as j, useCallback as g, useMemo as $, useEffect as it, cloneElement as ot, useContext as st } from "react";
+import { o as at, _ as ut, l as Y, u as lt, T as k, m as W, S as F, a as ct, $ as ft } from "./TabContext-CdjYJzMB.js";
+import { jsx as h } from "react/jsx-runtime";
+import { c as V, u as Z } from "./ThemeProvider-Bs1j1Nwi.js";
+import { u as dt } from "./useEventCallback-Bfo0-hwZ.js";
+import { P as u } from "./index-sDUMSncV.js";
+import { R as w } from "./index-BrykDZgK.js";
+function A(t, r) {
+  return A = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, i) {
+    return o.__proto__ = i, o;
+  }, A(t, r);
+}
+function pt(t, r) {
+  t.prototype = Object.create(r.prototype), t.prototype.constructor = t, A(t, r);
+}
+function Et(t) {
+  var r = at(t);
+  return r && r.defaultView || window;
+}
+function mt(t, r) {
+  return Et(t).getComputedStyle(t, r);
+}
+var ht = /([A-Z])/g;
+function xt(t) {
+  return t.replace(ht, "-$1").toLowerCase();
+}
+var vt = /^ms-/;
+function L(t) {
+  return xt(t).replace(vt, "-ms-");
+}
+var gt = /^((translate|rotate|scale)(X|Y|Z|3d)?|matrix(3d)?|perspective|skew(X|Y)?)$/i;
+function bt(t) {
+  return !!(t && gt.test(t));
+}
+function z(t, r) {
+  var o = "", i = "";
+  if (typeof r == "string")
+    return t.style.getPropertyValue(L(r)) || mt(t).getPropertyValue(L(r));
+  Object.keys(r).forEach(function(e) {
+    var n = r[e];
+    !n && n !== 0 ? t.style.removeProperty(L(e)) : bt(e) ? i += e + "(" + n + ") " : o += L(e) + ": " + n + ";";
+  }), i && (o += "transform: " + i + ";"), t.style.cssText += ";" + o;
+}
+const X = {
+  disabled: !1
+};
+var Ot = process.env.NODE_ENV !== "production" ? u.oneOfType([u.number, u.shape({
+  enter: u.number,
+  exit: u.number,
+  appear: u.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && u.oneOfType([u.string, u.shape({
+  enter: u.string,
+  exit: u.string,
+  active: u.string
+}), u.shape({
+  enter: u.string,
+  enterDone: u.string,
+  enterActive: u.string,
+  exit: u.string,
+  exitDone: u.string,
+  exitActive: u.string
+})]);
+const B = C.createContext(null);
+var Tt = function(r) {
+  return r.scrollTop;
+}, I = "unmounted", T = "exited", b = "entering", y = "entered", U = "exiting", v = /* @__PURE__ */ function(t) {
+  pt(r, t);
+  function r(i, e) {
+    var n;
+    n = t.call(this, i, e) || this;
+    var s = e, a = s && !s.isMounting ? i.enter : i.appear, l;
+    return n.appearStatus = null, i.in ? a ? (l = T, n.appearStatus = b) : l = y : i.unmountOnExit || i.mountOnEnter ? l = I : l = T, n.state = {
+      status: l
+    }, n.nextCallback = null, n;
+  }
+  r.getDerivedStateFromProps = function(e, n) {
+    var s = e.in;
+    return s && n.status === I ? {
+      status: T
+    } : null;
+  };
+  var o = r.prototype;
+  return o.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, o.componentDidUpdate = function(e) {
+    var n = null;
+    if (e !== this.props) {
+      var s = this.state.status;
+      this.props.in ? s !== b && s !== y && (n = b) : (s === b || s === y) && (n = U);
+    }
+    this.updateStatus(!1, n);
+  }, o.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, o.getTimeouts = function() {
+    var e = this.props.timeout, n, s, a;
+    return n = s = a = e, e != null && typeof e != "number" && (n = e.exit, s = e.enter, a = e.appear !== void 0 ? e.appear : s), {
+      exit: n,
+      enter: s,
+      appear: a
+    };
+  }, o.updateStatus = function(e, n) {
+    if (e === void 0 && (e = !1), n !== null)
+      if (this.cancelNextCallback(), n === b) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var s = this.props.nodeRef ? this.props.nodeRef.current : w.findDOMNode(this);
+          s && Tt(s);
+        }
+        this.performEnter(e);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === T && this.setState({
+      status: I
+    });
+  }, o.performEnter = function(e) {
+    var n = this, s = this.props.enter, a = this.context ? this.context.isMounting : e, l = this.props.nodeRef ? [a] : [w.findDOMNode(this), a], c = l[0], d = l[1], f = this.getTimeouts(), E = a ? f.appear : f.enter;
+    if (!e && !s || X.disabled) {
+      this.safeSetState({
+        status: y
+      }, function() {
+        n.props.onEntered(c);
+      });
+      return;
+    }
+    this.props.onEnter(c, d), this.safeSetState({
+      status: b
+    }, function() {
+      n.props.onEntering(c, d), n.onTransitionEnd(E, function() {
+        n.safeSetState({
+          status: y
+        }, function() {
+          n.props.onEntered(c, d);
+        });
+      });
+    });
+  }, o.performExit = function() {
+    var e = this, n = this.props.exit, s = this.getTimeouts(), a = this.props.nodeRef ? void 0 : w.findDOMNode(this);
+    if (!n || X.disabled) {
+      this.safeSetState({
+        status: T
+      }, function() {
+        e.props.onExited(a);
+      });
+      return;
+    }
+    this.props.onExit(a), this.safeSetState({
+      status: U
+    }, function() {
+      e.props.onExiting(a), e.onTransitionEnd(s.exit, function() {
+        e.safeSetState({
+          status: T
+        }, function() {
+          e.props.onExited(a);
+        });
+      });
+    });
+  }, o.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, o.safeSetState = function(e, n) {
+    n = this.setNextCallback(n), this.setState(e, n);
+  }, o.setNextCallback = function(e) {
+    var n = this, s = !0;
+    return this.nextCallback = function(a) {
+      s && (s = !1, n.nextCallback = null, e(a));
+    }, this.nextCallback.cancel = function() {
+      s = !1;
+    }, this.nextCallback;
+  }, o.onTransitionEnd = function(e, n) {
+    this.setNextCallback(n);
+    var s = this.props.nodeRef ? this.props.nodeRef.current : w.findDOMNode(this), a = e == null && !this.props.addEndListener;
+    if (!s || a) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var l = this.props.nodeRef ? [this.nextCallback] : [s, this.nextCallback], c = l[0], d = l[1];
+      this.props.addEndListener(c, d);
+    }
+    e != null && setTimeout(this.nextCallback, e);
+  }, o.render = function() {
+    var e = this.state.status;
+    if (e === I)
+      return null;
+    var n = this.props, s = n.children;
+    n.in, n.mountOnEnter, n.unmountOnExit, n.appear, n.enter, n.exit, n.timeout, n.addEndListener, n.onEnter, n.onEntering, n.onEntered, n.onExit, n.onExiting, n.onExited, n.nodeRef;
+    var a = ut(n, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ C.createElement(B.Provider, {
+        value: null
+      }, typeof s == "function" ? s(e, a) : C.cloneElement(C.Children.only(s), a))
+    );
+  }, r;
+}(C.Component);
+v.contextType = B;
+v.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: u.shape({
+    current: typeof Element > "u" ? u.any : function(t, r, o, i, e, n) {
+      var s = t[r];
+      return u.instanceOf(s && "ownerDocument" in s ? s.ownerDocument.defaultView.Element : Element)(t, r, o, i, e, n);
+    }
+  }),
+  /**
+   * 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: u.oneOfType([u.func.isRequired, u.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: u.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: u.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: u.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: u.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: u.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: u.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(r) {
+    var o = Ot;
+    r.addEndListener || (o = o.isRequired);
+    for (var i = arguments.length, e = new Array(i > 1 ? i - 1 : 0), n = 1; n < i; n++)
+      e[n - 1] = arguments[n];
+    return o.apply(void 0, [r].concat(e));
+  },
+  /**
+   * 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: u.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: u.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: u.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: u.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: u.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: u.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: u.func
+} : {};
+function R() {
+}
+v.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: R,
+  onEntering: R,
+  onEntered: R,
+  onExit: R,
+  onExiting: R,
+  onExited: R
+};
+v.UNMOUNTED = I;
+v.EXITED = T;
+v.ENTERING = b;
+v.ENTERED = y;
+v.EXITING = U;
+function yt() {
+  const t = S.version.split(".");
+  return {
+    major: +t[0],
+    minor: +t[1],
+    patch: +t[2]
+  };
+}
+function J(t) {
+  if (!t || typeof t == "function")
+    return null;
+  const {
+    major: r
+  } = yt();
+  return r >= 19 ? t.props.ref : t.ref;
+}
+function Ct(t, r, o, i) {
+  if (i === void 0 && (i = !0), t) {
+    var e = document.createEvent("HTMLEvents");
+    e.initEvent(r, o, i), t.dispatchEvent(e);
+  }
+}
+function Nt(t) {
+  var r = z(t, "transitionDuration") || "", o = r.indexOf("ms") === -1 ? 1e3 : 1;
+  return parseFloat(r) * o;
+}
+function Rt(t, r, o) {
+  o === void 0 && (o = 5);
+  var i = !1, e = setTimeout(function() {
+    i || Ct(t, "transitionend", !0);
+  }, r + o), n = Y(t, "transitionend", function() {
+    i = !0;
+  }, {
+    once: !0
+  });
+  return function() {
+    clearTimeout(e), n();
+  };
+}
+function St(t, r, o, i) {
+  o == null && (o = Nt(t) || 0);
+  var e = Rt(t, o, i), n = Y(t, "transitionend", r);
+  return function() {
+    e(), n();
+  };
+}
+function q(t, r) {
+  const o = z(t, r) || "", i = o.indexOf("ms") === -1 ? 1e3 : 1;
+  return parseFloat(o) * i;
+}
+function Dt(t, r) {
+  const o = q(t, "transitionDuration"), i = q(t, "transitionDelay"), e = St(t, (n) => {
+    n.target === t && (e(), r(n));
+  }, o + i);
+}
+function Pt(t) {
+  t.offsetHeight;
+}
+function wt(t) {
+  return t && "setState" in t ? w.findDOMNode(t) : t ?? null;
+}
+const It = /* @__PURE__ */ C.forwardRef(({
+  onEnter: t,
+  onEntering: r,
+  onEntered: o,
+  onExit: i,
+  onExiting: e,
+  onExited: n,
+  addEndListener: s,
+  children: a,
+  childRef: l,
+  ...c
+}, d) => {
+  const f = j(null), E = lt(f, l), m = (N) => {
+    E(wt(N));
+  }, p = (N) => (_) => {
+    N && f.current && N(f.current, _);
+  }, x = g(p(t), [t]), O = g(p(r), [r]), D = g(p(o), [o]), P = g(p(i), [i]), M = g(p(e), [e]), et = g(p(n), [n]), rt = g(p(s), [s]);
+  return /* @__PURE__ */ h(v, {
+    ref: d,
+    ...c,
+    onEnter: x,
+    onEntered: D,
+    onEntering: O,
+    onExit: P,
+    onExited: et,
+    onExiting: M,
+    addEndListener: rt,
+    nodeRef: f,
+    children: typeof a == "function" ? (N, _) => (
+      // TODO: Types for RTG missing innerProps, so need to cast.
+      a(N, {
+        ..._,
+        ref: m
+      })
+    ) : /* @__PURE__ */ C.cloneElement(a, {
+      ref: m
+    })
+  });
+}), Mt = {
+  [b]: "show",
+  [y]: "show"
+}, G = /* @__PURE__ */ S.forwardRef(({
+  className: t,
+  children: r,
+  transitionClasses: o = {},
+  onEnter: i,
+  ...e
+}, n) => {
+  const s = {
+    in: !1,
+    timeout: 300,
+    mountOnEnter: !1,
+    unmountOnExit: !1,
+    appear: !1,
+    ...e
+  }, a = g((l, c) => {
+    Pt(l), i == null || i(l, c);
+  }, [i]);
+  return /* @__PURE__ */ h(It, {
+    ref: n,
+    addEndListener: Dt,
+    ...s,
+    onEnter: a,
+    childRef: J(r),
+    children: (l, c) => /* @__PURE__ */ S.cloneElement(r, {
+      ...c,
+      className: V("fade", t, r.props.className, Mt[l], o[l])
+    })
+  });
+});
+G.displayName = "Fade";
+const H = (t) => !t || typeof t == "function" ? t : (r) => {
+  t.current = r;
+};
+function Lt(t, r) {
+  const o = H(t), i = H(r);
+  return (e) => {
+    o && o(e), i && i(e);
+  };
+}
+function kt(t, r) {
+  return $(() => Lt(t, r), [t, r]);
+}
+function Q({
+  children: t,
+  in: r,
+  onExited: o,
+  mountOnEnter: i,
+  unmountOnExit: e
+}) {
+  const n = j(null), s = j(r), a = dt(o);
+  it(() => {
+    r ? s.current = !0 : a(n.current);
+  }, [r, a]);
+  const l = kt(n, J(t)), c = /* @__PURE__ */ ot(t, {
+    ref: l
+  });
+  return r ? c : e || !s.current && i ? null : c;
+}
+const _t = ["active", "eventKey", "mountOnEnter", "transition", "unmountOnExit", "role", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited"], jt = ["activeKey", "getControlledId", "getControllerId"], $t = ["as"];
+function K(t, r) {
+  if (t == null) return {};
+  var o = {};
+  for (var i in t) if ({}.hasOwnProperty.call(t, i)) {
+    if (r.indexOf(i) >= 0) continue;
+    o[i] = t[i];
+  }
+  return o;
+}
+function tt(t) {
+  let {
+    active: r,
+    eventKey: o,
+    mountOnEnter: i,
+    transition: e,
+    unmountOnExit: n,
+    role: s = "tabpanel",
+    onEnter: a,
+    onEntering: l,
+    onEntered: c,
+    onExit: d,
+    onExiting: f,
+    onExited: E
+  } = t, m = K(t, _t);
+  const p = st(k);
+  if (!p) return [Object.assign({}, m, {
+    role: s
+  }), {
+    eventKey: o,
+    isActive: r,
+    mountOnEnter: i,
+    transition: e,
+    unmountOnExit: n,
+    onEnter: a,
+    onEntering: l,
+    onEntered: c,
+    onExit: d,
+    onExiting: f,
+    onExited: E
+  }];
+  const {
+    activeKey: x,
+    getControlledId: O,
+    getControllerId: D
+  } = p, P = K(p, jt), M = W(o);
+  return [Object.assign({}, m, {
+    role: s,
+    id: O(o),
+    "aria-labelledby": D(o)
+  }), {
+    eventKey: o,
+    isActive: r == null && M != null ? W(x) === M : r,
+    transition: e || P.transition,
+    mountOnEnter: i ?? P.mountOnEnter,
+    unmountOnExit: n ?? P.unmountOnExit,
+    onEnter: a,
+    onEntering: l,
+    onEntered: c,
+    onExit: d,
+    onExiting: f,
+    onExited: E
+  }];
+}
+const nt = /* @__PURE__ */ S.forwardRef(
+  // Need to define the default "as" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595
+  (t, r) => {
+    let {
+      as: o = "div"
+    } = t, i = K(t, $t);
+    const [e, {
+      isActive: n,
+      onEnter: s,
+      onEntering: a,
+      onEntered: l,
+      onExit: c,
+      onExiting: d,
+      onExited: f,
+      mountOnEnter: E,
+      unmountOnExit: m,
+      transition: p = Q
+    }] = tt(i);
+    return /* @__PURE__ */ h(k.Provider, {
+      value: null,
+      children: /* @__PURE__ */ h(F.Provider, {
+        value: null,
+        children: /* @__PURE__ */ h(p, {
+          in: n,
+          onEnter: s,
+          onEntering: a,
+          onEntered: l,
+          onExit: c,
+          onExiting: d,
+          onExited: f,
+          mountOnEnter: E,
+          unmountOnExit: m,
+          children: /* @__PURE__ */ h(o, Object.assign({}, e, {
+            ref: r,
+            hidden: !n,
+            "aria-hidden": !n
+          }))
+        })
+      })
+    });
+  }
+);
+nt.displayName = "TabPanel";
+const At = (t) => {
+  const {
+    id: r,
+    generateChildId: o,
+    onSelect: i,
+    activeKey: e,
+    defaultActiveKey: n,
+    transition: s,
+    mountOnEnter: a,
+    unmountOnExit: l,
+    children: c
+  } = t, [d, f] = ct(e, n, i), E = ft(r), m = $(() => o || ((x, O) => E ? `${E}-${O}-${x}` : null), [E, o]), p = $(() => ({
+    onSelect: f,
+    activeKey: d,
+    transition: s,
+    mountOnEnter: a || !1,
+    unmountOnExit: l || !1,
+    getControlledId: (x) => m(x, "tabpane"),
+    getControllerId: (x) => m(x, "tab")
+  }), [f, d, s, a, l, m]);
+  return /* @__PURE__ */ h(k.Provider, {
+    value: p,
+    children: /* @__PURE__ */ h(F.Provider, {
+      value: f || null,
+      children: c
+    })
+  });
+};
+At.Panel = nt;
+function Ut(t) {
+  return typeof t == "boolean" ? t ? G : Q : t;
+}
+const Kt = /* @__PURE__ */ S.forwardRef(({
+  className: t,
+  bsPrefix: r,
+  as: o = "div",
+  ...i
+}, e) => (r = Z(r, "tab-content"), /* @__PURE__ */ h(o, {
+  ref: e,
+  className: V(t, r),
+  ...i
+})));
+Kt.displayName = "TabContent";
+const Ft = /* @__PURE__ */ S.forwardRef(({
+  bsPrefix: t,
+  transition: r,
+  ...o
+}, i) => {
+  const [{
+    className: e,
+    // Need to define the default "as" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595
+    as: n = "div",
+    ...s
+  }, {
+    isActive: a,
+    onEnter: l,
+    onEntering: c,
+    onEntered: d,
+    onExit: f,
+    onExiting: E,
+    onExited: m,
+    mountOnEnter: p,
+    unmountOnExit: x,
+    transition: O = G
+  }] = tt({
+    ...o,
+    transition: Ut(r)
+  }), D = Z(t, "tab-pane");
+  return /* @__PURE__ */ h(k.Provider, {
+    value: null,
+    children: /* @__PURE__ */ h(F.Provider, {
+      value: null,
+      children: /* @__PURE__ */ h(O, {
+        in: a,
+        onEnter: l,
+        onEntering: c,
+        onEntered: d,
+        onExit: f,
+        onExiting: E,
+        onExited: m,
+        mountOnEnter: p,
+        unmountOnExit: x,
+        children: /* @__PURE__ */ h(n, {
+          ...s,
+          ref: i,
+          className: V(e, D, a && "active")
+        })
+      })
+    })
+  });
+});
+Ft.displayName = "TabPane";
+export {
+  At as T,
+  Kt as a,
+  Ft as b,
+  Ut as g,
+  kt as u
+};