@gobolt/genesis 0.0.7

package/dist/index-SAAXFt-P.js

@@ -0,0 +1,946 @@
+import * as u from "react";
+import { forwardRef as Le, useRef as ke, useImperativeHandle as De } from "react";
+import { c as j, d as Be, a as X, _ as Me, z as W, m as He, n as fe, D as Xe, H as se, C as ue, N as We, A as Ye } from "./index-BWys7dkb.js";
+import { K as v, i as Ze, T as Ke, u as qe, g as Fe, z as Ue } from "./index-VDH3iLaC.js";
+import { u as Ge } from "./isVisible-CNQjrJPN.js";
+import { C as Je } from "./ContextIsolator-CGkdKtc3.js";
+import { i as Qe, c as et } from "./reactNode-sKPeiqPL.js";
+import { P as G } from "./presetColors-Cl8UP3Nw.js";
+function tt(t, o) {
+  return G.reduce((r, e) => {
+    const n = t[`${e}1`], s = t[`${e}3`], a = t[`${e}6`], i = t[`${e}7`];
+    return Object.assign(Object.assign({}, r), o(e, {
+      lightColor: n,
+      lightBorderColor: s,
+      darkColor: a,
+      textColor: i
+    }));
+  }, {});
+}
+const ot = new v("antZoomIn", {
+  "0%": {
+    transform: "scale(0.2)",
+    opacity: 0
+  },
+  "100%": {
+    transform: "scale(1)",
+    opacity: 1
+  }
+}), nt = new v("antZoomOut", {
+  "0%": {
+    transform: "scale(1)"
+  },
+  "100%": {
+    transform: "scale(0.2)",
+    opacity: 0
+  }
+}), ie = new v("antZoomBigIn", {
+  "0%": {
+    transform: "scale(0.8)",
+    opacity: 0
+  },
+  "100%": {
+    transform: "scale(1)",
+    opacity: 1
+  }
+}), le = new v("antZoomBigOut", {
+  "0%": {
+    transform: "scale(1)"
+  },
+  "100%": {
+    transform: "scale(0.8)",
+    opacity: 0
+  }
+}), rt = new v("antZoomUpIn", {
+  "0%": {
+    transform: "scale(0.8)",
+    transformOrigin: "50% 0%",
+    opacity: 0
+  },
+  "100%": {
+    transform: "scale(1)",
+    transformOrigin: "50% 0%"
+  }
+}), at = new v("antZoomUpOut", {
+  "0%": {
+    transform: "scale(1)",
+    transformOrigin: "50% 0%"
+  },
+  "100%": {
+    transform: "scale(0.8)",
+    transformOrigin: "50% 0%",
+    opacity: 0
+  }
+}), st = new v("antZoomLeftIn", {
+  "0%": {
+    transform: "scale(0.8)",
+    transformOrigin: "0% 50%",
+    opacity: 0
+  },
+  "100%": {
+    transform: "scale(1)",
+    transformOrigin: "0% 50%"
+  }
+}), it = new v("antZoomLeftOut", {
+  "0%": {
+    transform: "scale(1)",
+    transformOrigin: "0% 50%"
+  },
+  "100%": {
+    transform: "scale(0.8)",
+    transformOrigin: "0% 50%",
+    opacity: 0
+  }
+}), lt = new v("antZoomRightIn", {
+  "0%": {
+    transform: "scale(0.8)",
+    transformOrigin: "100% 50%",
+    opacity: 0
+  },
+  "100%": {
+    transform: "scale(1)",
+    transformOrigin: "100% 50%"
+  }
+}), ct = new v("antZoomRightOut", {
+  "0%": {
+    transform: "scale(1)",
+    transformOrigin: "100% 50%"
+  },
+  "100%": {
+    transform: "scale(0.8)",
+    transformOrigin: "100% 50%",
+    opacity: 0
+  }
+}), ft = new v("antZoomDownIn", {
+  "0%": {
+    transform: "scale(0.8)",
+    transformOrigin: "50% 100%",
+    opacity: 0
+  },
+  "100%": {
+    transform: "scale(1)",
+    transformOrigin: "50% 100%"
+  }
+}), ut = new v("antZoomDownOut", {
+  "0%": {
+    transform: "scale(1)",
+    transformOrigin: "50% 100%"
+  },
+  "100%": {
+    transform: "scale(0.8)",
+    transformOrigin: "50% 100%",
+    opacity: 0
+  }
+}), mt = {
+  zoom: {
+    inKeyframes: ot,
+    outKeyframes: nt
+  },
+  "zoom-big": {
+    inKeyframes: ie,
+    outKeyframes: le
+  },
+  "zoom-big-fast": {
+    inKeyframes: ie,
+    outKeyframes: le
+  },
+  "zoom-left": {
+    inKeyframes: st,
+    outKeyframes: it
+  },
+  "zoom-right": {
+    inKeyframes: lt,
+    outKeyframes: ct
+  },
+  "zoom-up": {
+    inKeyframes: rt,
+    outKeyframes: at
+  },
+  "zoom-down": {
+    inKeyframes: ft,
+    outKeyframes: ut
+  }
+}, dt = (t, o) => {
+  const {
+    antCls: r
+  } = t, e = `${r}-${o}`, {
+    inKeyframes: n,
+    outKeyframes: s
+  } = mt[o];
+  return [Ze(e, n, s, t.motionDurationFast), {
+    [`
+        ${e}-enter,
+        ${e}-appear
+      `]: {
+      transform: "scale(0)",
+      opacity: 0,
+      animationTimingFunction: t.motionEaseOutCirc,
+      "&-prepare": {
+        transform: "none"
+      }
+    },
+    [`${e}-leave`]: {
+      animationTimingFunction: t.motionEaseInOutCirc
+    }
+  }];
+};
+function me(t) {
+  var o = t.children, r = t.prefixCls, e = t.id, n = t.overlayInnerStyle, s = t.bodyClassName, a = t.className, i = t.style;
+  return /* @__PURE__ */ u.createElement("div", {
+    className: j("".concat(r, "-content"), a),
+    style: i
+  }, /* @__PURE__ */ u.createElement("div", {
+    className: j("".concat(r, "-inner"), s),
+    id: e,
+    role: "tooltip",
+    style: n
+  }, typeof o == "function" ? o() : o));
+}
+var k = {
+  shiftX: 64,
+  adjustY: 1
+}, D = {
+  adjustX: 1,
+  shiftY: !0
+}, w = [0, 0], pt = {
+  left: {
+    points: ["cr", "cl"],
+    overflow: D,
+    offset: [-4, 0],
+    targetOffset: w
+  },
+  right: {
+    points: ["cl", "cr"],
+    overflow: D,
+    offset: [4, 0],
+    targetOffset: w
+  },
+  top: {
+    points: ["bc", "tc"],
+    overflow: k,
+    offset: [0, -4],
+    targetOffset: w
+  },
+  bottom: {
+    points: ["tc", "bc"],
+    overflow: k,
+    offset: [0, 4],
+    targetOffset: w
+  },
+  topLeft: {
+    points: ["bl", "tl"],
+    overflow: k,
+    offset: [0, -4],
+    targetOffset: w
+  },
+  leftTop: {
+    points: ["tr", "tl"],
+    overflow: D,
+    offset: [-4, 0],
+    targetOffset: w
+  },
+  topRight: {
+    points: ["br", "tr"],
+    overflow: k,
+    offset: [0, -4],
+    targetOffset: w
+  },
+  rightTop: {
+    points: ["tl", "tr"],
+    overflow: D,
+    offset: [4, 0],
+    targetOffset: w
+  },
+  bottomRight: {
+    points: ["tr", "br"],
+    overflow: k,
+    offset: [0, 4],
+    targetOffset: w
+  },
+  rightBottom: {
+    points: ["bl", "br"],
+    overflow: D,
+    offset: [4, 0],
+    targetOffset: w
+  },
+  bottomLeft: {
+    points: ["tl", "bl"],
+    overflow: k,
+    offset: [0, 4],
+    targetOffset: w
+  },
+  leftBottom: {
+    points: ["br", "bl"],
+    overflow: D,
+    offset: [-4, 0],
+    targetOffset: w
+  }
+}, gt = ["overlayClassName", "trigger", "mouseEnterDelay", "mouseLeaveDelay", "overlayStyle", "prefixCls", "children", "onVisibleChange", "afterVisibleChange", "transitionName", "animation", "motion", "placement", "align", "destroyTooltipOnHide", "defaultVisible", "getTooltipContainer", "overlayInnerStyle", "arrowContent", "overlay", "id", "showArrow", "classNames", "styles"], bt = function(o, r) {
+  var e = o.overlayClassName, n = o.trigger, s = n === void 0 ? ["hover"] : n, a = o.mouseEnterDelay, i = a === void 0 ? 0 : a, l = o.mouseLeaveDelay, m = l === void 0 ? 0.1 : l, h = o.overlayStyle, c = o.prefixCls, d = c === void 0 ? "rc-tooltip" : c, y = o.children, O = o.onVisibleChange, $ = o.afterVisibleChange, _ = o.transitionName, b = o.animation, g = o.motion, x = o.placement, T = x === void 0 ? "right" : x, z = o.align, J = z === void 0 ? {} : z, B = o.destroyTooltipOnHide, I = B === void 0 ? !1 : B, Q = o.defaultVisible, Y = o.getTooltipContainer, ee = o.overlayInnerStyle;
+  o.arrowContent;
+  var f = o.overlay, R = o.id, A = o.showArrow, Z = A === void 0 ? !0 : A, P = o.classNames, N = o.styles, M = Be(o, gt), K = ke(null);
+  De(r, function() {
+    return K.current;
+  });
+  var q = X({}, M);
+  "visible" in o && (q.popupVisible = o.visible);
+  var H = function() {
+    return /* @__PURE__ */ u.createElement(me, {
+      key: "content",
+      prefixCls: d,
+      id: R,
+      bodyClassName: P == null ? void 0 : P.body,
+      overlayInnerStyle: X(X({}, ee), N == null ? void 0 : N.body)
+    }, f);
+  };
+  return /* @__PURE__ */ u.createElement(Ke, Me({
+    popupClassName: j(e, P == null ? void 0 : P.root),
+    prefixCls: d,
+    popup: H,
+    action: s,
+    builtinPlacements: pt,
+    popupPlacement: T,
+    ref: K,
+    popupAlign: J,
+    getPopupContainer: Y,
+    onPopupVisibleChange: O,
+    afterPopupVisibleChange: $,
+    popupTransitionName: _,
+    popupAnimation: b,
+    popupMotion: g,
+    defaultPopupVisible: Q,
+    autoDestroy: I,
+    mouseLeaveDelay: m,
+    popupStyle: X(X({}, h), N == null ? void 0 : N.root),
+    mouseEnterDelay: i,
+    arrow: Z
+  }, q), y);
+};
+const ht = /* @__PURE__ */ Le(bt);
+function yt(t) {
+  const {
+    sizePopupArrow: o,
+    borderRadiusXS: r,
+    borderRadiusOuter: e
+  } = t, n = o / 2, s = 0, a = n, i = e * 1 / Math.sqrt(2), l = n - e * (1 - 1 / Math.sqrt(2)), m = n - r * (1 / Math.sqrt(2)), h = e * (Math.sqrt(2) - 1) + r * (1 / Math.sqrt(2)), c = 2 * n - m, d = h, y = 2 * n - i, O = l, $ = 2 * n - s, _ = a, b = n * Math.sqrt(2) + e * (Math.sqrt(2) - 2), g = e * (Math.sqrt(2) - 1), x = `polygon(${g}px 100%, 50% ${g}px, ${2 * n - g}px 100%, ${g}px 100%)`, T = `path('M ${s} ${a} A ${e} ${e} 0 0 0 ${i} ${l} L ${m} ${h} A ${r} ${r} 0 0 1 ${c} ${d} L ${y} ${O} A ${e} ${e} 0 0 0 ${$} ${_} Z')`;
+  return {
+    arrowShadowWidth: b,
+    arrowPath: T,
+    arrowPolygon: x
+  };
+}
+const wt = (t, o, r) => {
+  const {
+    sizePopupArrow: e,
+    arrowPolygon: n,
+    arrowPath: s,
+    arrowShadowWidth: a,
+    borderRadiusXS: i,
+    calc: l
+  } = t;
+  return {
+    pointerEvents: "none",
+    width: e,
+    height: e,
+    overflow: "hidden",
+    "&::before": {
+      position: "absolute",
+      bottom: 0,
+      insetInlineStart: 0,
+      width: e,
+      height: l(e).div(2).equal(),
+      background: o,
+      clipPath: {
+        _multi_value_: !0,
+        value: [n, s]
+      },
+      content: '""'
+    },
+    "&::after": {
+      content: '""',
+      position: "absolute",
+      width: a,
+      height: a,
+      bottom: 0,
+      insetInline: 0,
+      margin: "auto",
+      borderRadius: {
+        _skip_check_: !0,
+        value: `0 0 ${W(i)} 0`
+      },
+      transform: "translateY(50%) rotate(-135deg)",
+      boxShadow: r,
+      zIndex: 0,
+      background: "transparent"
+    }
+  };
+}, de = 8;
+function pe(t) {
+  const {
+    contentRadius: o,
+    limitVerticalRadius: r
+  } = t, e = o > 12 ? o + 2 : 12;
+  return {
+    arrowOffsetHorizontal: e,
+    arrowOffsetVertical: r ? de : e
+  };
+}
+function U(t, o) {
+  return t ? o : {};
+}
+function vt(t, o, r) {
+  const {
+    componentCls: e,
+    boxShadowPopoverArrow: n,
+    arrowOffsetVertical: s,
+    arrowOffsetHorizontal: a
+  } = t, {
+    arrowDistance: i = 0,
+    arrowPlacement: l = {
+      left: !0,
+      right: !0,
+      top: !0,
+      bottom: !0
+    }
+  } = {};
+  return {
+    [e]: Object.assign(Object.assign(Object.assign(Object.assign({
+      // ============================ Basic ============================
+      [`${e}-arrow`]: [Object.assign(Object.assign({
+        position: "absolute",
+        zIndex: 1,
+        display: "block"
+      }, wt(t, o, n)), {
+        "&:before": {
+          background: o
+        }
+      })]
+    }, U(!!l.top, {
+      [[`&-placement-top > ${e}-arrow`, `&-placement-topLeft > ${e}-arrow`, `&-placement-topRight > ${e}-arrow`].join(",")]: {
+        bottom: i,
+        transform: "translateY(100%) rotate(180deg)"
+      },
+      [`&-placement-top > ${e}-arrow`]: {
+        left: {
+          _skip_check_: !0,
+          value: "50%"
+        },
+        transform: "translateX(-50%) translateY(100%) rotate(180deg)"
+      },
+      "&-placement-topLeft": {
+        "--arrow-offset-horizontal": a,
+        [`> ${e}-arrow`]: {
+          left: {
+            _skip_check_: !0,
+            value: a
+          }
+        }
+      },
+      "&-placement-topRight": {
+        "--arrow-offset-horizontal": `calc(100% - ${W(a)})`,
+        [`> ${e}-arrow`]: {
+          right: {
+            _skip_check_: !0,
+            value: a
+          }
+        }
+      }
+    })), U(!!l.bottom, {
+      [[`&-placement-bottom > ${e}-arrow`, `&-placement-bottomLeft > ${e}-arrow`, `&-placement-bottomRight > ${e}-arrow`].join(",")]: {
+        top: i,
+        transform: "translateY(-100%)"
+      },
+      [`&-placement-bottom > ${e}-arrow`]: {
+        left: {
+          _skip_check_: !0,
+          value: "50%"
+        },
+        transform: "translateX(-50%) translateY(-100%)"
+      },
+      "&-placement-bottomLeft": {
+        "--arrow-offset-horizontal": a,
+        [`> ${e}-arrow`]: {
+          left: {
+            _skip_check_: !0,
+            value: a
+          }
+        }
+      },
+      "&-placement-bottomRight": {
+        "--arrow-offset-horizontal": `calc(100% - ${W(a)})`,
+        [`> ${e}-arrow`]: {
+          right: {
+            _skip_check_: !0,
+            value: a
+          }
+        }
+      }
+    })), U(!!l.left, {
+      [[`&-placement-left > ${e}-arrow`, `&-placement-leftTop > ${e}-arrow`, `&-placement-leftBottom > ${e}-arrow`].join(",")]: {
+        right: {
+          _skip_check_: !0,
+          value: i
+        },
+        transform: "translateX(100%) rotate(90deg)"
+      },
+      [`&-placement-left > ${e}-arrow`]: {
+        top: {
+          _skip_check_: !0,
+          value: "50%"
+        },
+        transform: "translateY(-50%) translateX(100%) rotate(90deg)"
+      },
+      [`&-placement-leftTop > ${e}-arrow`]: {
+        top: s
+      },
+      [`&-placement-leftBottom > ${e}-arrow`]: {
+        bottom: s
+      }
+    })), U(!!l.right, {
+      [[`&-placement-right > ${e}-arrow`, `&-placement-rightTop > ${e}-arrow`, `&-placement-rightBottom > ${e}-arrow`].join(",")]: {
+        left: {
+          _skip_check_: !0,
+          value: i
+        },
+        transform: "translateX(-100%) rotate(-90deg)"
+      },
+      [`&-placement-right > ${e}-arrow`]: {
+        top: {
+          _skip_check_: !0,
+          value: "50%"
+        },
+        transform: "translateY(-50%) translateX(-100%) rotate(-90deg)"
+      },
+      [`&-placement-rightTop > ${e}-arrow`]: {
+        top: s
+      },
+      [`&-placement-rightBottom > ${e}-arrow`]: {
+        bottom: s
+      }
+    }))
+  };
+}
+function Ot(t, o, r, e) {
+  if (e === !1)
+    return {
+      adjustX: !1,
+      adjustY: !1
+    };
+  const n = e && typeof e == "object" ? e : {}, s = {};
+  switch (t) {
+    case "top":
+    case "bottom":
+      s.shiftX = o.arrowOffsetHorizontal * 2 + r, s.shiftY = !0, s.adjustY = !0;
+      break;
+    case "left":
+    case "right":
+      s.shiftY = o.arrowOffsetVertical * 2 + r, s.shiftX = !0, s.adjustX = !0;
+      break;
+  }
+  const a = Object.assign(Object.assign({}, s), n);
+  return a.shiftX || (a.adjustX = !0), a.shiftY || (a.adjustY = !0), a;
+}
+const ce = {
+  left: {
+    points: ["cr", "cl"]
+  },
+  right: {
+    points: ["cl", "cr"]
+  },
+  top: {
+    points: ["bc", "tc"]
+  },
+  bottom: {
+    points: ["tc", "bc"]
+  },
+  topLeft: {
+    points: ["bl", "tl"]
+  },
+  leftTop: {
+    points: ["tr", "tl"]
+  },
+  topRight: {
+    points: ["br", "tr"]
+  },
+  rightTop: {
+    points: ["tl", "tr"]
+  },
+  bottomRight: {
+    points: ["tr", "br"]
+  },
+  rightBottom: {
+    points: ["bl", "br"]
+  },
+  bottomLeft: {
+    points: ["tl", "bl"]
+  },
+  leftBottom: {
+    points: ["br", "bl"]
+  }
+}, Ct = {
+  topLeft: {
+    points: ["bl", "tc"]
+  },
+  leftTop: {
+    points: ["tr", "cl"]
+  },
+  topRight: {
+    points: ["br", "tc"]
+  },
+  rightTop: {
+    points: ["tl", "cr"]
+  },
+  bottomRight: {
+    points: ["tr", "bc"]
+  },
+  rightBottom: {
+    points: ["bl", "cr"]
+  },
+  bottomLeft: {
+    points: ["tl", "bc"]
+  },
+  leftBottom: {
+    points: ["br", "cl"]
+  }
+}, $t = /* @__PURE__ */ new Set(["topLeft", "topRight", "bottomLeft", "bottomRight", "leftTop", "leftBottom", "rightTop", "rightBottom"]);
+function _t(t) {
+  const {
+    arrowWidth: o,
+    autoAdjustOverflow: r,
+    arrowPointAtCenter: e,
+    offset: n,
+    borderRadius: s,
+    visibleFirst: a
+  } = t, i = o / 2, l = {};
+  return Object.keys(ce).forEach((m) => {
+    const h = e && Ct[m] || ce[m], c = Object.assign(Object.assign({}, h), {
+      offset: [0, 0],
+      dynamicInset: !0
+    });
+    switch (l[m] = c, $t.has(m) && (c.autoArrow = !1), m) {
+      case "top":
+      case "topLeft":
+      case "topRight":
+        c.offset[1] = -i - n;
+        break;
+      case "bottom":
+      case "bottomLeft":
+      case "bottomRight":
+        c.offset[1] = i + n;
+        break;
+      case "left":
+      case "leftTop":
+      case "leftBottom":
+        c.offset[0] = -i - n;
+        break;
+      case "right":
+      case "rightTop":
+      case "rightBottom":
+        c.offset[0] = i + n;
+        break;
+    }
+    const d = pe({
+      contentRadius: s,
+      limitVerticalRadius: !0
+    });
+    if (e)
+      switch (m) {
+        case "topLeft":
+        case "bottomLeft":
+          c.offset[0] = -d.arrowOffsetHorizontal - i;
+          break;
+        case "topRight":
+        case "bottomRight":
+          c.offset[0] = d.arrowOffsetHorizontal + i;
+          break;
+        case "leftTop":
+        case "rightTop":
+          c.offset[1] = -d.arrowOffsetHorizontal * 2 + i;
+          break;
+        case "leftBottom":
+        case "rightBottom":
+          c.offset[1] = d.arrowOffsetHorizontal * 2 - i;
+          break;
+      }
+    c.overflow = Ot(m, d, o, r), a && (c.htmlRegion = "visibleFirst");
+  }), l;
+}
+const xt = (t) => {
+  const {
+    calc: o,
+    componentCls: r,
+    // ant-tooltip
+    tooltipMaxWidth: e,
+    tooltipColor: n,
+    tooltipBg: s,
+    tooltipBorderRadius: a,
+    zIndexPopup: i,
+    controlHeight: l,
+    boxShadowSecondary: m,
+    paddingSM: h,
+    paddingXS: c,
+    arrowOffsetHorizontal: d,
+    sizePopupArrow: y
+  } = t, O = o(a).add(y).add(d).equal(), $ = o(a).mul(2).add(y).equal();
+  return [
+    {
+      [r]: Object.assign(Object.assign(Object.assign(Object.assign({}, Xe(t)), {
+        position: "absolute",
+        zIndex: i,
+        display: "block",
+        width: "max-content",
+        maxWidth: e,
+        visibility: "visible",
+        // When use `autoArrow`, origin will follow the arrow position
+        "--valid-offset-x": "var(--arrow-offset-horizontal, var(--arrow-x))",
+        transformOrigin: ["var(--valid-offset-x, 50%)", "var(--arrow-y, 50%)"].join(" "),
+        "&-hidden": {
+          display: "none"
+        },
+        "--antd-arrow-background-color": s,
+        // Wrapper for the tooltip content
+        [`${r}-inner`]: {
+          minWidth: $,
+          minHeight: l,
+          padding: `${W(t.calc(h).div(2).equal())} ${W(c)}`,
+          color: n,
+          textAlign: "start",
+          textDecoration: "none",
+          wordWrap: "break-word",
+          backgroundColor: s,
+          borderRadius: a,
+          boxShadow: m,
+          boxSizing: "border-box"
+        },
+        // Align placement should have another min width
+        [["&-placement-topLeft", "&-placement-topRight", "&-placement-bottomLeft", "&-placement-bottomRight"].join(",")]: {
+          minWidth: O
+        },
+        // Limit left and right placement radius
+        [["&-placement-left", "&-placement-leftTop", "&-placement-leftBottom", "&-placement-right", "&-placement-rightTop", "&-placement-rightBottom"].join(",")]: {
+          [`${r}-inner`]: {
+            borderRadius: t.min(a, de)
+          }
+        },
+        [`${r}-content`]: {
+          position: "relative"
+        }
+      }), tt(t, (_, b) => {
+        let {
+          darkColor: g
+        } = b;
+        return {
+          [`&${r}-${_}`]: {
+            [`${r}-inner`]: {
+              backgroundColor: g
+            },
+            [`${r}-arrow`]: {
+              "--antd-arrow-background-color": g
+            }
+          }
+        };
+      })), {
+        // RTL
+        "&-rtl": {
+          direction: "rtl"
+        }
+      })
+    },
+    // Arrow Style
+    vt(t, "var(--antd-arrow-background-color)"),
+    // Pure Render
+    {
+      [`${r}-pure`]: {
+        position: "relative",
+        maxWidth: "none",
+        margin: t.sizePopupArrow
+      }
+    }
+  ];
+}, Pt = (t) => Object.assign(Object.assign({
+  zIndexPopup: t.zIndexPopupBase + 70
+}, pe({
+  contentRadius: t.borderRadius,
+  limitVerticalRadius: !0
+})), yt(fe(t, {
+  borderRadiusOuter: Math.min(t.borderRadiusOuter, 4)
+}))), ge = function(t) {
+  let o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0;
+  return He("Tooltip", (e) => {
+    const {
+      borderRadius: n,
+      colorTextLightSolid: s,
+      colorBgSpotlight: a
+    } = e, i = fe(e, {
+      // default variables
+      tooltipMaxWidth: 250,
+      tooltipColor: s,
+      tooltipBorderRadius: n,
+      tooltipBg: a
+    });
+    return [xt(i), dt(e, "zoom-big-fast")];
+  }, Pt, {
+    resetStyle: !1,
+    // Popover use Tooltip as internal component. We do not need to handle this.
+    injectStyle: o
+  })(t);
+}, Nt = G.map((t) => `${t}-inverse`);
+function St(t) {
+  return (arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0) ? [].concat(se(Nt), se(G)).includes(t) : G.includes(t);
+}
+function be(t, o) {
+  const r = St(o), e = j({
+    [`${t}-${o}`]: o && r
+  }), n = {}, s = {};
+  return o && !r && (n.background = o, s["--antd-arrow-background-color"] = o), {
+    className: e,
+    overlayStyle: n,
+    arrowStyle: s
+  };
+}
+const jt = (t) => {
+  const {
+    prefixCls: o,
+    className: r,
+    placement: e = "top",
+    title: n,
+    color: s,
+    overlayInnerStyle: a
+  } = t, {
+    getPrefixCls: i
+  } = u.useContext(ue), l = i("tooltip", o), [m, h, c] = ge(l), d = be(l, s), y = d.arrowStyle, O = Object.assign(Object.assign({}, a), d.overlayStyle), $ = j(h, c, l, `${l}-pure`, `${l}-placement-${e}`, r, d.className);
+  return m(/* @__PURE__ */ u.createElement("div", {
+    className: $,
+    style: y
+  }, /* @__PURE__ */ u.createElement("div", {
+    className: `${l}-arrow`
+  }), /* @__PURE__ */ u.createElement(me, Object.assign({}, t, {
+    className: h,
+    prefixCls: l,
+    overlayInnerStyle: O
+  }), n)));
+};
+var Tt = function(t, o) {
+  var r = {};
+  for (var e in t) Object.prototype.hasOwnProperty.call(t, e) && o.indexOf(e) < 0 && (r[e] = t[e]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function") for (var n = 0, e = Object.getOwnPropertySymbols(t); n < e.length; n++)
+    o.indexOf(e[n]) < 0 && Object.prototype.propertyIsEnumerable.call(t, e[n]) && (r[e[n]] = t[e[n]]);
+  return r;
+};
+const zt = /* @__PURE__ */ u.forwardRef((t, o) => {
+  var r, e, n, s, a, i;
+  const {
+    prefixCls: l,
+    openClassName: m,
+    getTooltipContainer: h,
+    color: c,
+    overlayInnerStyle: d,
+    children: y,
+    afterOpenChange: O,
+    afterVisibleChange: $,
+    destroyTooltipOnHide: _,
+    arrow: b = !0,
+    title: g,
+    overlay: x,
+    builtinPlacements: T,
+    arrowPointAtCenter: z = !1,
+    autoAdjustOverflow: J = !0
+  } = t, B = !!b, [, I] = We(), {
+    getPopupContainer: Q,
+    getPrefixCls: Y,
+    direction: ee,
+    tooltip: f
+  } = u.useContext(ue), R = Ye("Tooltip"), A = u.useRef(null), Z = () => {
+    var p;
+    (p = A.current) === null || p === void 0 || p.forceAlign();
+  };
+  u.useImperativeHandle(o, () => {
+    var p;
+    return {
+      forceAlign: Z,
+      forcePopupAlign: () => {
+        R.deprecated(!1, "forcePopupAlign", "forceAlign"), Z();
+      },
+      nativeElement: (p = A.current) === null || p === void 0 ? void 0 : p.nativeElement
+    };
+  }), process.env.NODE_ENV !== "production" && ([["visible", "open"], ["defaultVisible", "defaultOpen"], ["onVisibleChange", "onOpenChange"], ["afterVisibleChange", "afterOpenChange"], ["arrowPointAtCenter", "arrow={{ pointAtCenter: true }}"], ["overlayStyle", "styles={{ root: {} }}"], ["overlayInnerStyle", "styles={{ body: {} }}"], ["overlayClassName", "classNames={{ root: {} }}"]].forEach((p) => {
+    let [C, S] = p;
+    R.deprecated(!(C in t), C, S);
+  }), process.env.NODE_ENV !== "production" && R(!_ || typeof _ == "boolean", "usage", "`destroyTooltipOnHide` no need config `keepParent` anymore. Please use `boolean` value directly."), process.env.NODE_ENV !== "production" && R(!b || typeof b == "boolean" || !("arrowPointAtCenter" in b), "deprecated", "`arrowPointAtCenter` in `arrow` is deprecated. Please use `pointAtCenter` instead."));
+  const [P, N] = Ge(!1, {
+    value: (r = t.open) !== null && r !== void 0 ? r : t.visible,
+    defaultValue: (e = t.defaultOpen) !== null && e !== void 0 ? e : t.defaultVisible
+  }), M = !g && !x && g !== 0, K = (p) => {
+    var C, S;
+    N(M ? !1 : p), M || ((C = t.onOpenChange) === null || C === void 0 || C.call(t, p), (S = t.onVisibleChange) === null || S === void 0 || S.call(t, p));
+  }, q = u.useMemo(() => {
+    var p, C;
+    let S = z;
+    return typeof b == "object" && (S = (C = (p = b.pointAtCenter) !== null && p !== void 0 ? p : b.arrowPointAtCenter) !== null && C !== void 0 ? C : z), T || _t({
+      arrowPointAtCenter: S,
+      autoAdjustOverflow: J,
+      arrowWidth: B ? I.sizePopupArrow : 0,
+      borderRadius: I.borderRadius,
+      offset: I.marginXXS,
+      visibleFirst: !0
+    });
+  }, [z, b, T, I]), H = u.useMemo(() => g === 0 ? g : x || g || "", [x, g]), re = /* @__PURE__ */ u.createElement(Je, {
+    space: !0
+  }, typeof H == "function" ? H() : H), {
+    getPopupContainer: ye,
+    placement: we = "top",
+    mouseEnterDelay: ve = 0.1,
+    mouseLeaveDelay: Oe = 0.1,
+    overlayStyle: Ce,
+    rootClassName: $e,
+    overlayClassName: _e,
+    styles: E,
+    classNames: V
+  } = t, ae = Tt(t, ["getPopupContainer", "placement", "mouseEnterDelay", "mouseLeaveDelay", "overlayStyle", "rootClassName", "overlayClassName", "styles", "classNames"]), L = Y("tooltip", l), xe = Y(), Pe = t["data-popover-inject"];
+  let te = P;
+  !("open" in t) && !("visible" in t) && M && (te = !1);
+  const oe = /* @__PURE__ */ u.isValidElement(y) && !Qe(y) ? y : /* @__PURE__ */ u.createElement("span", null, y), F = oe.props, Ne = !F.className || typeof F.className == "string" ? j(F.className, m || `${L}-open`) : F.className, [Se, je, Te] = ge(L, !Pe), ne = be(L, c), ze = ne.arrowStyle, Ie = j(_e, {
+    [`${L}-rtl`]: ee === "rtl"
+  }, ne.className, $e, je, Te, f == null ? void 0 : f.className, (n = f == null ? void 0 : f.classNames) === null || n === void 0 ? void 0 : n.root, V == null ? void 0 : V.root), Re = j((s = f == null ? void 0 : f.classNames) === null || s === void 0 ? void 0 : s.body, V == null ? void 0 : V.body), [Ae, Ee] = qe("Tooltip", ae.zIndex), Ve = /* @__PURE__ */ u.createElement(ht, Object.assign({}, ae, {
+    zIndex: Ae,
+    showArrow: B,
+    placement: we,
+    mouseEnterDelay: ve,
+    mouseLeaveDelay: Oe,
+    prefixCls: L,
+    classNames: {
+      root: Ie,
+      body: Re
+    },
+    styles: {
+      root: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, ze), (a = f == null ? void 0 : f.styles) === null || a === void 0 ? void 0 : a.root), f == null ? void 0 : f.style), Ce), E == null ? void 0 : E.root),
+      body: Object.assign(Object.assign(Object.assign(Object.assign({}, (i = f == null ? void 0 : f.styles) === null || i === void 0 ? void 0 : i.body), d), E == null ? void 0 : E.body), ne.overlayStyle)
+    },
+    getTooltipContainer: ye || h || Q,
+    ref: A,
+    builtinPlacements: q,
+    overlay: re,
+    visible: te,
+    onVisibleChange: K,
+    afterVisibleChange: O ?? $,
+    arrowContent: /* @__PURE__ */ u.createElement("span", {
+      className: `${L}-arrow-content`
+    }),
+    motion: {
+      motionName: Fe(xe, "zoom-big-fast", t.transitionName),
+      motionDeadline: 1e3
+    },
+    destroyTooltipOnHide: !!_
+  }), te ? et(oe, {
+    className: Ne
+  }) : oe);
+  return Se(/* @__PURE__ */ u.createElement(Ue.Provider, {
+    value: Ee
+  }, Ve));
+}), he = zt;
+process.env.NODE_ENV !== "production" && (he.displayName = "Tooltip");
+he._InternalPanelDoNotUseOrYouWillBeFired = jt;
+export {
+  he as T,
+  ot as z
+};